logo

utils-std

Collection of commonly available Unix tools git clone https://anongit.hacktivis.me/git/utils-std.git/

base64.c (11904B)

    

  1. // utils-std: Collection of commonly available Unix tools
  2. // SPDX-FileCopyrightText: 2017 Haelwenn (lanodan) Monnier <contact+utils@hacktivis.me>
  3. // SPDX-FileCopyrightText: 2018 The NetBSD Foundation, Inc.
  4. // SPDX-License-Identifier: MPL-2.0 AND BSD-2-Clause
  6. #define _POSIX_C_SOURCE 200809L
  7. #include "../config.h"
  8. #include "../libutils/getopt_nolong.h"
  10. #include <assert.h>   /* assert */
  11. #include <ctype.h>    /* isspace */
  12. #include <errno.h>    /* errno */
  13. #include <stdint.h>   /* uint8_t */
  14. #include <stdio.h>    /* fopen(), fprintf() */
  15. #include <stdlib.h>   /* abort */
  16. #include <string.h>   /* strerror(), strncmp() */
  17. #include <sys/stat.h> /* fstat */
  18. #include <unistd.h>   /* read(), write(), close(), getopt() */
  19. #ifdef HAS_GETOPT_LONG
  20. #include <getopt.h>
  21. #endif
  23. // 64(26+26+10+2) + NULL
  24. static const char *b64_encmap = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
  25. static size_t c_out = 0;
  26. // 76 is lowest of all base64 related RFCs
  27. static long wrap_nl = 76;
  28. const char *argv0 = "base64";
  30. static int
  31. xputc(int c, FILE *stream)
  32. {
  33. 	if(fputc(c, stream) == EOF)
  34. 	{
  35. 		fprintf(stderr, "%s: error: Failed writing: %s\n", argv0, strerror(errno));
  36. 		errno = 0;
  37. 		return 1;
  38. 	}
  40. 	int err = ferror(stream);
  41. 	if(err != 0)
  42. 	{
  43. 		fprintf(stderr, "%s: error: Failed writing: %s\n", argv0, strerror(err));
  44. 		errno = 0;
  45. 		return 1;
  46. 	}
  48. 	return 0;
  49. }
  51. static inline uint8_t
  52. b64_get(uint8_t pos)
  53. {
  54. 	assert(pos <= 64);
  55. 	return b64_encmap[pos];
  56. }
  58. static void
  59. b64encode(uint8_t out[4], uint8_t in[3])
  60. {
  61. 	out[0] = b64_get(in[0] >> 2);
  62. 	out[1] = b64_get((uint8_t)(((in[0] & 0x03) << 4) | (in[1] >> 4)));
  63. 	out[2] = b64_get((uint8_t)(((in[1] & 0x0f) << 2) | (in[2] >> 6)));
  64. 	out[3] = b64_get(in[2] & 0x3f);
  65. }
  67. static int
  68. base64_encode(FILE *fin, const char *iname)
  69. {
  70. 	while(1)
  71. 	{
  72. 		uint8_t obuf[4] = "----";
  73. 		uint8_t ibuf[3] = {0, 0, 0};
  74. 		uint8_t pad = 0;
  76. 		size_t c = 0;
  77. 		for(; c < 3; c++)
  78. 		{
  79. 			int buf = getc(fin);
  80. 			if(buf == EOF)
  81. 			{
  82. 				break;
  83. 			}
  84. 			ibuf[c] = buf;
  85. 		}
  86. 		if(c == 0)
  87. 		{
  88. 			return 0;
  89. 		};
  90. 		if(ferror(fin))
  91. 		{
  92. 			fprintf(
  93. 			    stderr, "%s: error: Failed reading from file '%s': %s\n", argv0, iname, strerror(errno));
  94. 			errno = 0;
  95. 			return 1;
  96. 		}
  97. 		for(; c < 3; pad++, c++)
  98. 		{
  99. 			ibuf[c] = 0;
  100. 		}
  101. 		assert(c == 3);
  102. 		assert(pad <= 3);
  104. 		b64encode(obuf, (uint8_t *)ibuf);
  106. 		for(; pad > 0; pad--)
  107. 		{
  108. 			obuf[4 - pad] = '=';
  109. 		}
  111. 		if(fwrite((char *)obuf, 4, 1, stdout) <= 0)
  112. 		{
  113. 			fprintf(stderr, "%s: error: Failed writing: %s\n", argv0, strerror(errno));
  114. 			errno = 0;
  115. 			return 1;
  116. 		}
  117. 		c_out += 4;
  119. 		if(wrap_nl != 0 && (c_out + 4) > wrap_nl)
  120. 		{
  121. 			c_out = 0;
  122. 			if(xputc('\n', stdout) != 0) return 1;
  123. 		}
  125. 		if(feof(fin))
  126. 		{
  127. 			if(fflush(stdout))
  128. 			{
  129. 				fprintf(stderr, "%s: error: Failed writing: %s\n", argv0, strerror(errno));
  130. 				errno = 0;
  131. 				return 1;
  132. 			}
  133. 			int err = ferror(stdout);
  134. 			if(err != 0)
  135. 			{
  136. 				fprintf(stderr, "%s: error: Failed writing: %s\n", argv0, strerror(errno));
  137. 				return 1;
  138. 			}
  140. 			return 0;
  141. 		}
  142. 	}
  144. 	abort(); // unreachable
  145. }
  147. // This function is based on NetBSD's code, which contains the following notices:
  148. // Copyright (c) 2018 The NetBSD Foundation, Inc.
  149. //
  150. // This code is derived from software contributed to The NetBSD Foundation
  151. // by Christos Zoulas.
  152. static int
  153. base64_decode(FILE *fin, const char *iname)
  154. {
  155. 	int c = 0;
  156. 	uint8_t out = 0;
  157. 	int state = 0;
  159. 	while((c = getc(fin)) != EOF)
  160. 	{
  161. 		if(isspace(c)) continue;
  163. 		if(c == '=') break;
  165. 		uint8_t b = 65;
  166. 		for(uint8_t i = 0; i < 64; i++)
  167. 		{
  168. 			if(b64_encmap[i] == c)
  169. 			{
  170. 				b = i;
  171. 				break;
  172. 			}
  173. 		}
  174. 		if(b > 64)
  175. 		{
  176. 			fprintf(stderr, "%s: error: Invalid character '%c'\n", argv0, c);
  177. 			return 1;
  178. 		}
  180. 		//fprintf(stderr, "state: %d | c: %c (%d) | b: %d\n", state, c, c, b);
  182. 		switch(state)
  183. 		{
  184. 		case 0:
  185. 			out = (uint8_t)(b << 2);
  186. 			break;
  187. 		case 1:
  188. 			out |= b >> 4;
  189. 			if(xputc(out, stdout) != 0) return 1;
  190. 			out = (uint8_t)((b & 0xf) << 4);
  191. 			break;
  192. 		case 2:
  193. 			out |= b >> 2;
  194. 			if(xputc(out, stdout) != 0) return 1;
  195. 			out = (uint8_t)((b & 0x3) << 6);
  196. 			break;
  197. 		case 3:
  198. 			out |= b;
  199. 			if(xputc(out, stdout) != 0) return 1;
  200. 			out = 0;
  201. 			break;
  202. 		default:
  203. 			abort();
  204. 		}
  205. 		state = (state + 1) & 3;
  206. 	}
  208. 	//fprintf(stderr, "[outside] state: %d | c: %c (%d) | out: %d\n", state, c, c, out);
  210. 	if(c == '=')
  211. 	{
  212. 		switch(state)
  213. 		{
  214. 		case 0:
  215. 		case 1:
  216. 			fprintf(stderr, "%s: error: Invalid character '%c' (early '=')\n", argv0, c);
  217. 			return 1;
  218. 		case 2:
  219. 			while(isspace(c = getc(fin)))
  220. 				;
  222. 			if(c != '=')
  223. 			{
  224. 				fprintf(stderr, "%s: error: Invalid character '%c' (not '=')\n", argv0, c);
  225. 				return 1;
  226. 			}
  227. 			/* fallthrough */
  228. 		case 3:
  229. 			while(isspace(c = getc(fin)))
  230. 				;
  232. 			if(c != EOF)
  233. 			{
  234. 				fprintf(stderr, "%s: error: Invalid character '%c' (not EOF)\n", argv0, c);
  235. 				return 1;
  236. 			}
  237. 			return 0;
  238. 		default:
  239. 			abort();
  240. 		}
  241. 	}
  243. 	assert(c == EOF || state == 0);
  245. 	if(fflush(stdout))
  246. 	{
  247. 		fprintf(stderr, "%s: error: Failed writing: %s\n", argv0, strerror(errno));
  248. 		errno = 0;
  249. 		return 1;
  250. 	}
  251. 	int err = ferror(stdout);
  252. 	if(err != 0)
  253. 	{
  254. 		fprintf(stderr, "%s: error: Failed writing: %s\n", argv0, strerror(err));
  255. 		errno = 0;
  256. 		return 1;
  257. 	}
  259. 	return 0;
  260. }
  262. static int
  263. base64_main(int argc, char *argv[])
  264. {
  265. 	argv0 = "base64";
  266. 	int (*process)(FILE *, const char *) = &base64_encode;
  268. 	int ret = 0;
  270. #ifdef HAS_GETOPT_LONG
  271. 	// Strictly for GNUisms compatibility so no long-only options
  272. 	// clang-format off
  273. 	static struct option opts[] = {
  274. 		{"decode", no_argument, NULL, 'd'},
  275. 		{"wrap", required_argument, NULL, 'w'},
  276. 		{0, 0, 0, 0},
  277. 	};
  278. 	// clang-format on
  280. 	// Need + as first character to get POSIX-style option parsing
  281. 	for(int c = -1; (c = getopt_long(argc, argv, "+:dw:", opts, NULL)) != -1;)
  282. #else
  283. 	for(int c = -1; (c = getopt_nolong(argc, argv, ":dw:")) != -1;)
  284. #endif
  285. 	{
  286. 		switch(c)
  287. 		{
  288. 		case 'd':
  289. 			process = &base64_decode;
  290. 			break;
  291. 		case 'w':
  292. 			errno = 0;
  293. 			char *e = NULL;
  294. 			wrap_nl = strtol(optarg, &e, 10);
  296. 			// extraneous characters is invalid
  297. 			if(e && *e != 0) errno = EINVAL;
  299. 			if(errno != 0)
  300. 			{
  301. 				fprintf(stderr, "%s: error: Option '-w %s': %s\n", argv0, optarg, strerror(errno));
  302. 				return 1;
  303. 			}
  304. 			break;
  305. 		case ':':
  306. 			fprintf(stderr, "%s: error: Missing operand for option '-%c'\n", argv0, optopt);
  307. 			return 1;
  308. 		case '?':
  309. 			GETOPT_UNKNOWN_OPT
  310. 			return 1;
  311. 		}
  312. 	}
  314. 	argc -= optind;
  315. 	argv += optind;
  317. 	if(argc <= 0)
  318. 	{
  319. 		ret = process(stdin, "<stdin>");
  320. 		goto end;
  321. 	}
  323. 	for(int argi = 0; argi < argc; argi++)
  324. 	{
  325. 		if(strncmp(argv[argi], "-", 2) == 0)
  326. 		{
  327. 			if(process(stdin, "<stdin>") != 0)
  328. 			{
  329. 				ret = 1;
  330. 				goto end;
  331. 			}
  332. 		}
  333. 		else if(strncmp(argv[argi], "--", 3) == 0)
  334. 		{
  335. 			continue;
  336. 		}
  337. 		else
  338. 		{
  339. 			FILE *fin = fopen(argv[argi], "r");
  340. 			if(fin == NULL)
  341. 			{
  342. 				fprintf(stderr,
  343. 				        "%s: error: Failed opening file '%s': %s\n",
  344. 				        argv0,
  345. 				        argv[argi],
  346. 				        strerror(errno));
  347. 				ret = 1;
  348. 				goto end;
  349. 			}
  351. 			if(process(fin, argv[argi]) != 0) ret = 1;
  353. 			if(fclose(fin) < 0)
  354. 			{
  355. 				fprintf(stderr,
  356. 				        "%s: error: Failed closing file '%s': %s\n",
  357. 				        argv0,
  358. 				        argv[argi],
  359. 				        strerror(errno));
  360. 				ret = 1;
  361. 				goto end;
  362. 			}
  363. 		}
  364. 	}
  366. end:
  367. 	if(wrap_nl != 0 && c_out > 0)
  368. 	{
  369. 		printf("\n");
  370. 	}
  372. 	if(fclose(stdin) != 0)
  373. 	{
  374. 		fprintf(stderr, "%s: error: Failed closing file <stdin>: %s\n", argv0, strerror(errno));
  375. 		ret = 1;
  376. 	}
  378. 	if(fclose(stdout) != 0)
  379. 	{
  380. 		fprintf(stderr, "%s: error: Failed closing file <stdout>: %s\n", argv0, strerror(errno));
  381. 		ret = 1;
  382. 	}
  384. 	return ret;
  385. }
  387. static int
  388. uuencode(FILE *fin, const char *iname)
  389. {
  390. 	bool fin_eof = false;
  391. 	while(!fin_eof)
  392. 	{
  393. 		char output[60] = "";
  395. 		size_t pos = 0;
  396. 		int len = 0;
  397. 		for(; (len < 45) && !fin_eof; pos += 4, len += 3)
  398. 		{
  399. 			uint8_t ibuf[3] = {0, 0, 0};
  401. 			size_t c = 0;
  402. 			for(; c < 3; c++)
  403. 			{
  404. 				int buf = getc(fin);
  405. 				if(buf == EOF)
  406. 				{
  407. 					fin_eof = true;
  408. 					break;
  409. 				}
  410. 				ibuf[c] = buf;
  411. 			}
  412. 			if(c == 0)
  413. 			{
  414. 				break;
  415. 			}
  416. 			if(ferror(fin))
  417. 			{
  418. 				fprintf(stderr,
  419. 				        "%s: error: Failed reading from file '%s': %s\n",
  420. 				        argv0,
  421. 				        iname,
  422. 				        strerror(errno));
  423. 				errno = 0;
  424. 				return 1;
  425. 			}
  427. 			assert((3 + pos) < 60);
  428. 			/* conversion math taken from POSIX.1-2024 specification */
  429. 			/* clang-format off */
  430. 			output[0+pos] = 0x20 + (( ibuf[0] >> 2                           ) & 0x3F);
  431. 			output[1+pos] = 0x20 + (((ibuf[0] << 4) | ((ibuf[1] >> 4) & 0x0F)) & 0x3F);
  432. 			output[2+pos] = 0x20 + (((ibuf[1] << 2) | ((ibuf[2] >> 6) & 0x03)) & 0x3F);
  433. 			output[3+pos] = 0x20 + (( ibuf[2]                                ) & 0x3F);
  434. 			/* clang-format on */
  436. 			for(int i = 0; i < 4; i++)
  437. 				if(output[i + pos] == 0x20) output[i + pos] = 0x60;
  438. 		}
  440. 		if(printf("%c", len == 0 ? 0x60 : 0x20 + len) < 0)
  441. 		{
  442. 			fprintf(stderr, "%s: error: Failed writing length: %s\n", argv0, strerror(errno));
  443. 			errno = 0;
  444. 			return 1;
  445. 		}
  447. 		if(pos > 0)
  448. 			if(fwrite(output, pos, 1, stdout) <= 0)
  449. 			{
  450. 				fprintf(stderr, "%s: error: Failed writing data: %s\n", argv0, strerror(errno));
  451. 				errno = 0;
  452. 				return 1;
  453. 			}
  455. 		if(printf("\n") < 0)
  456. 		{
  457. 			fprintf(stderr, "%s: error: Failed writing newline: %s\n", argv0, strerror(errno));
  458. 			errno = 0;
  459. 			return 1;
  460. 		}
  461. 	}
  463. 	if(fflush(stdout) != 0)
  464. 	{
  465. 		fprintf(stderr, "%s: error: Failed writing (flush): %s\n", argv0, strerror(errno));
  466. 		errno = 0;
  467. 		return 1;
  468. 	}
  469. 	int err = ferror(stdout);
  470. 	if(err != 0)
  471. 	{
  472. 		fprintf(stderr, "%s: error: Failed writing (ferror): %s\n", argv0, strerror(errno));
  473. 		return 1;
  474. 	}
  476. 	return 0;
  477. }
  479. static int
  480. uuencode_main(int argc, char *argv[])
  481. {
  482. 	argv0 = "uuencode";
  483. 	const char *begin_str = "begin";
  484. 	const char *end_str = "end\n";
  485. 	int (*process)(FILE *, const char *) = &uuencode;
  487. 	// get old, then reset to old. Yay to POSIX nonsense
  488. 	mode_t mask = umask(0);
  489. 	umask(mask);
  491. 	// negate to get a normal bitmask
  492. 	mask ^= 0777;
  494. 	wrap_nl = 45;
  496. 	int ret = 0;
  498. 	for(int c = -1; (c = getopt_nolong(argc, argv, ":m")) != -1;)
  499. 	{
  500. 		switch(c)
  501. 		{
  502. 		case 'm':
  503. 			process = &base64_encode;
  504. 			begin_str = "begin-base64";
  505. 			end_str = "====\n";
  506. 			wrap_nl = 76;
  507. 			break;
  508. 		case ':':
  509. 			fprintf(stderr, "%s: error: Missing operand for option '-%c'\n", argv0, optopt);
  510. 			return 1;
  511. 		case '?':
  512. 			GETOPT_UNKNOWN_OPT
  513. 			return 1;
  514. 		}
  515. 	}
  517. 	argc -= optind;
  518. 	argv += optind;
  520. 	if(argc > 2)
  521. 	{
  522. 		fprintf(stderr, "%s: error: Expected 2 arguments or less, got %d\n", argv0, argc);
  523. 		return 1;
  524. 	}
  526. 	FILE *fin = stdin;
  527. 	const char *decode_path = "-";
  528. 	const char *iname = "<stdin>";
  529. 	mode_t mode = 0666 & mask;
  531. 	if(argc >= 1) decode_path = argv[argc - 1];
  533. 	if(argc == 2)
  534. 	{
  535. 		iname = argv[0];
  537. 		fin = fopen(iname, "rb");
  538. 		if(!fin)
  539. 		{
  540. 			fprintf(
  541. 			    stderr, "%s: error: Failed opening input file '%s': %s\n", argv0, iname, strerror(errno));
  542. 			return 1;
  543. 		}
  545. 		struct stat fin_stat;
  546. 		if(fstat(fileno(fin), &fin_stat) != 0)
  547. 		{
  548. 			fprintf(stderr,
  549. 			        "%s: warning: Failed getting status for file '%s': %s\n",
  550. 			        argv0,
  551. 			        iname,
  552. 			        strerror(errno));
  553. 			ret = 1;
  554. 		}
  556. 		mode = fin_stat.st_mode & 0777;
  557. 	}
  559. 	printf("%s %03o %s\n", begin_str, mode, decode_path);
  560. 	if(process(fin, iname) != 0)
  561. 	{
  562. 		ret = 1;
  563. 		goto end;
  564. 	}
  566. end:
  567. 	if(ret == 0)
  568. 	{
  569. 		if(wrap_nl != 0 && c_out > 0) printf("\n");
  571. 		printf("%s", end_str);
  572. 	}
  574. 	if(fclose(fin) != 0)
  575. 	{
  576. 		fprintf(stderr, "%s: error: Failed closing file \"%s\": %s\n", argv0, iname, strerror(errno));
  577. 		ret = 1;
  578. 	}
  580. 	if(fclose(stdout) != 0)
  581. 	{
  582. 		fprintf(stderr, "%s: error: Failed closing file <stdout>: %s\n", argv0, strerror(errno));
  583. 		ret = 1;
  584. 	}
  586. 	return ret;
  587. }
  589. int
  590. main(int argc, char *argv[])
  591. {
  592. 	const char *arg0 = argv[0];
  594. 	const char *s = strrchr(arg0, '/');
  595. 	if(s) arg0 = s + 1;
  597. 	if(strcmp(arg0, "base64") == 0) return base64_main(argc, argv);
  598. 	if(strcmp(arg0, "uuencode") == 0) return uuencode_main(argc, argv);
  600. 	fprintf(stderr, "%s: error: Unknown utility '%s' expected 'base64' or 'uuencode'\n", arg0, arg0);
  602. 	return -1;
  603. }