logo

utils-std

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

base64.c (11537B)

    

  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 "../lib/getopt_nolong.h"
  9. #include <assert.h>   /* assert */
  10. #include <ctype.h>    /* isspace */
  11. #include <errno.h>    /* errno */
  12. #include <stdint.h>   /* uint8_t */
  13. #include <stdio.h>    /* fopen(), fprintf() */
  14. #include <stdlib.h>   /* abort */
  15. #include <string.h>   /* strerror(), strncmp() */
  16. #include <sys/stat.h> /* fstat */
  17. #include <unistd.h>   /* read(), write(), close(), getopt() */
  19. // 64(26+26+10+2) + NULL
  20. static const char *b64_encmap = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
  21. static size_t c_out = 0;
  22. // 76 is lowest of all base64 related RFCs
  23. static long wrap_nl = 76;
  24. const char *argv0 = "base64";
  26. static int
  27. xputc(int c, FILE *stream)
  28. {
  29. 	if(fputc(c, stream) == EOF)
  30. 	{
  31. 		fprintf(stderr, "%s: error: Failed writing: %s\n", argv0, strerror(errno));
  32. 		errno = 0;
  33. 		return 1;
  34. 	}
  36. 	int err = ferror(stream);
  37. 	if(err != 0)
  38. 	{
  39. 		fprintf(stderr, "%s: error: Failed writing: %s\n", argv0, strerror(err));
  40. 		errno = 0;
  41. 		return 1;
  42. 	}
  44. 	return 0;
  45. }
  47. static inline uint8_t
  48. b64_get(uint8_t pos)
  49. {
  50. 	assert(pos <= 64);
  51. 	return b64_encmap[pos];
  52. }
  54. static void
  55. b64encode(uint8_t out[4], uint8_t in[3])
  56. {
  57. 	out[0] = b64_get(in[0] >> 2);
  58. 	out[1] = b64_get((uint8_t)(((in[0] & 0x03) << 4) | (in[1] >> 4)));
  59. 	out[2] = b64_get((uint8_t)(((in[1] & 0x0f) << 2) | (in[2] >> 6)));
  60. 	out[3] = b64_get(in[2] & 0x3f);
  61. }
  63. static int
  64. base64_encode(FILE *fin, const char *iname)
  65. {
  66. 	while(1)
  67. 	{
  68. 		uint8_t obuf[4] = "----";
  69. 		uint8_t ibuf[3] = {0, 0, 0};
  70. 		uint8_t pad = 0;
  72. 		size_t c = 0;
  73. 		for(; c < 3; c++)
  74. 		{
  75. 			int buf = getc(fin);
  76. 			if(buf == EOF)
  77. 			{
  78. 				break;
  79. 			}
  80. 			ibuf[c] = buf;
  81. 		}
  82. 		if(c == 0)
  83. 		{
  84. 			return 0;
  85. 		};
  86. 		if(ferror(fin))
  87. 		{
  88. 			fprintf(
  89. 			    stderr, "%s: error: Failed reading from file '%s': %s\n", argv0, iname, strerror(errno));
  90. 			errno = 0;
  91. 			return 1;
  92. 		}
  93. 		for(; c < 3; pad++, c++)
  94. 		{
  95. 			ibuf[c] = 0;
  96. 		}
  97. 		assert(c == 3);
  98. 		assert(pad <= 3);
  100. 		b64encode(obuf, (uint8_t *)ibuf);
  102. 		for(; pad > 0; pad--)
  103. 		{
  104. 			obuf[4 - pad] = '=';
  105. 		}
  107. 		if(fwrite((char *)obuf, 4, 1, stdout) <= 0)
  108. 		{
  109. 			fprintf(stderr, "%s: error: Failed writing: %s\n", argv0, strerror(errno));
  110. 			errno = 0;
  111. 			return 1;
  112. 		}
  113. 		c_out += 4;
  115. 		if(wrap_nl != 0 && (c_out + 4) > wrap_nl)
  116. 		{
  117. 			c_out = 0;
  118. 			if(xputc('\n', stdout) != 0) return 1;
  119. 		}
  121. 		if(feof(fin))
  122. 		{
  123. 			if(fflush(stdout))
  124. 			{
  125. 				fprintf(stderr, "%s: error: Failed writing: %s\n", argv0, strerror(errno));
  126. 				errno = 0;
  127. 				return 1;
  128. 			}
  129. 			int err = ferror(stdout);
  130. 			if(err != 0)
  131. 			{
  132. 				fprintf(stderr, "%s: error: Failed writing: %s\n", argv0, strerror(errno));
  133. 				return 1;
  134. 			}
  136. 			return 0;
  137. 		}
  138. 	}
  140. 	abort(); // unreachable
  141. }
  143. // This function is based on NetBSD's code, which contains the following notices:
  144. // Copyright (c) 2018 The NetBSD Foundation, Inc.
  145. //
  146. // This code is derived from software contributed to The NetBSD Foundation
  147. // by Christos Zoulas.
  148. static int
  149. base64_decode(FILE *fin, const char *iname)
  150. {
  151. 	int c = 0;
  152. 	uint8_t out = 0;
  153. 	int state = 0;
  155. 	while((c = getc(fin)) != EOF)
  156. 	{
  157. 		if(isspace(c)) continue;
  159. 		if(c == '=') break;
  161. 		uint8_t b = 65;
  162. 		for(uint8_t i = 0; i < 64; i++)
  163. 		{
  164. 			if(b64_encmap[i] == c)
  165. 			{
  166. 				b = i;
  167. 				break;
  168. 			}
  169. 		}
  170. 		if(b > 64)
  171. 		{
  172. 			fprintf(stderr, "%s: error: Invalid character '%c'\n", argv0, c);
  173. 			return 1;
  174. 		}
  176. 		//fprintf(stderr, "state: %d | c: %c (%d) | b: %d\n", state, c, c, b);
  178. 		switch(state)
  179. 		{
  180. 		case 0:
  181. 			out = (uint8_t)(b << 2);
  182. 			break;
  183. 		case 1:
  184. 			out |= b >> 4;
  185. 			if(xputc(out, stdout) != 0) return 1;
  186. 			out = (uint8_t)((b & 0xf) << 4);
  187. 			break;
  188. 		case 2:
  189. 			out |= b >> 2;
  190. 			if(xputc(out, stdout) != 0) return 1;
  191. 			out = (uint8_t)((b & 0x3) << 6);
  192. 			break;
  193. 		case 3:
  194. 			out |= b;
  195. 			if(xputc(out, stdout) != 0) return 1;
  196. 			out = 0;
  197. 			break;
  198. 		default:
  199. 			abort();
  200. 		}
  201. 		state = (state + 1) & 3;
  202. 	}
  204. 	//fprintf(stderr, "[outside] state: %d | c: %c (%d) | out: %d\n", state, c, c, out);
  206. 	if(c == '=')
  207. 	{
  208. 		switch(state)
  209. 		{
  210. 		case 0:
  211. 		case 1:
  212. 			fprintf(stderr, "%s: error: Invalid character '%c' (early '=')\n", argv0, c);
  213. 			return 1;
  214. 		case 2:
  215. 			while(isspace(c = getc(fin)))
  216. 				;
  218. 			if(c != '=')
  219. 			{
  220. 				fprintf(stderr, "%s: error: Invalid character '%c' (not '=')\n", argv0, c);
  221. 				return 1;
  222. 			}
  223. 			/* fallthrough */
  224. 		case 3:
  225. 			while(isspace(c = getc(fin)))
  226. 				;
  228. 			if(c != EOF)
  229. 			{
  230. 				fprintf(stderr, "%s: error: Invalid character '%c' (not EOF)\n", argv0, c);
  231. 				return 1;
  232. 			}
  233. 			return 0;
  234. 		default:
  235. 			abort();
  236. 		}
  237. 	}
  239. 	assert(c == EOF || state == 0);
  241. 	if(fflush(stdout))
  242. 	{
  243. 		fprintf(stderr, "%s: error: Failed writing: %s\n", argv0, strerror(errno));
  244. 		errno = 0;
  245. 		return 1;
  246. 	}
  247. 	int err = ferror(stdout);
  248. 	if(err != 0)
  249. 	{
  250. 		fprintf(stderr, "%s: error: Failed writing: %s\n", argv0, strerror(err));
  251. 		errno = 0;
  252. 		return 1;
  253. 	}
  255. 	return 0;
  256. }
  258. static int
  259. base64_main(int argc, char *argv[])
  260. {
  261. 	argv0 = "base64";
  262. 	int (*process)(FILE *, const char *) = &base64_encode;
  264. 	int ret = 0;
  266. 	for(int c = -1; (c = getopt_nolong(argc, argv, ":dw:")) != -1;)
  267. 	{
  268. 		switch(c)
  269. 		{
  270. 		case 'd':
  271. 			process = &base64_decode;
  272. 			break;
  273. 		case 'w':
  274. 			errno = 0;
  275. 			char *e = NULL;
  276. 			wrap_nl = strtol(optarg, &e, 10);
  278. 			// extraneous characters is invalid
  279. 			if(e && *e != 0) errno = EINVAL;
  281. 			if(errno != 0)
  282. 			{
  283. 				fprintf(stderr, "%s: error: Option '-w %s': %s\n", argv0, optarg, strerror(errno));
  284. 				return 1;
  285. 			}
  286. 			break;
  287. 		case ':':
  288. 			fprintf(stderr, "%s: error: Missing operand for option '-%c'\n", argv0, optopt);
  289. 			return 1;
  290. 		case '?':
  291. 			if(!got_long_opt) fprintf(stderr, "%s: error: Unrecognised option '-%c'\n", argv0, optopt);
  292. 			return 1;
  293. 		}
  294. 	}
  296. 	argc -= optind;
  297. 	argv += optind;
  299. 	if(argc <= 0)
  300. 	{
  301. 		ret = process(stdin, "<stdin>");
  302. 		goto end;
  303. 	}
  305. 	for(int argi = 0; argi < argc; argi++)
  306. 	{
  307. 		if(strncmp(argv[argi], "-", 2) == 0)
  308. 		{
  309. 			if(process(stdin, "<stdin>") != 0)
  310. 			{
  311. 				ret = 1;
  312. 				goto end;
  313. 			}
  314. 		}
  315. 		else if(strncmp(argv[argi], "--", 3) == 0)
  316. 		{
  317. 			continue;
  318. 		}
  319. 		else
  320. 		{
  321. 			FILE *fin = fopen(argv[argi], "r");
  322. 			if(fin == NULL || ferror(fin) != 0)
  323. 			{
  324. 				fprintf(stderr,
  325. 				        "%s: error: Failed opening file '%s': %s\n",
  326. 				        argv0,
  327. 				        argv[argi],
  328. 				        strerror(errno));
  329. 				ret = 1;
  330. 				goto end;
  331. 			}
  333. 			if(process(fin, argv[argi]) != 0) ret = 1;
  335. 			if(fclose(fin) < 0)
  336. 			{
  337. 				fprintf(stderr,
  338. 				        "%s: error: Failed closing file '%s': %s\n",
  339. 				        argv0,
  340. 				        argv[argi],
  341. 				        strerror(errno));
  342. 				ret = 1;
  343. 				goto end;
  344. 			}
  345. 		}
  346. 	}
  348. end:
  349. 	if(wrap_nl != 0 && c_out > 0)
  350. 	{
  351. 		printf("\n");
  352. 	}
  354. 	if(fclose(stdin) != 0)
  355. 	{
  356. 		fprintf(stderr, "%s: error: Failed closing file <stdin>: %s\n", argv0, strerror(errno));
  357. 		ret = 1;
  358. 	}
  360. 	if(fclose(stdout) != 0)
  361. 	{
  362. 		fprintf(stderr, "%s: error: Failed closing file <stdout>: %s\n", argv0, strerror(errno));
  363. 		ret = 1;
  364. 	}
  366. 	return ret;
  367. }
  369. static int
  370. uuencode(FILE *fin, const char *iname)
  371. {
  372. 	while(1)
  373. 	{
  374. 		char output[60] = "";
  376. 		size_t pos = 0;
  377. 		int len = 0;
  378. 		for(; len < 45; pos += 4, len += 3)
  379. 		{
  380. 			uint8_t ibuf[3] = {0, 0, 0};
  382. 			size_t c = 0;
  383. 			for(; c < 3; c++)
  384. 			{
  385. 				int buf = getc(fin);
  386. 				if(buf == EOF)
  387. 				{
  388. 					break;
  389. 				}
  390. 				ibuf[c] = buf;
  391. 			}
  392. 			if(c == 0)
  393. 			{
  394. 				break;
  395. 			}
  396. 			if(ferror(fin))
  397. 			{
  398. 				fprintf(stderr,
  399. 				        "%s: error: Failed reading from file '%s': %s\n",
  400. 				        argv0,
  401. 				        iname,
  402. 				        strerror(errno));
  403. 				errno = 0;
  404. 				return 1;
  405. 			}
  407. 			assert((3 + pos) < 60);
  408. 			/* conversion math taken from POSIX.1-2024 specification */
  409. 			/* clang-format off */
  410. 			output[0+pos] = 0x20 + (( ibuf[0] >> 2                           ) & 0x3F);
  411. 			output[1+pos] = 0x20 + (((ibuf[0] << 4) | ((ibuf[1] >> 4) & 0x0F)) & 0x3F);
  412. 			output[2+pos] = 0x20 + (((ibuf[1] << 2) | ((ibuf[2] >> 6) & 0x03)) & 0x3F);
  413. 			output[3+pos] = 0x20 + (( ibuf[2]                                ) & 0x3F);
  414. 			/* clang-format on */
  416. 			for(int i = 0; i < 4; i++)
  417. 				if(output[i + pos] == 0x20) output[i + pos] = 0x60;
  418. 		}
  420. 		if(printf("%c", len == 0 ? 0x60 : 0x20 + len) < 0)
  421. 		{
  422. 			fprintf(stderr, "%s: error: Failed writing length: %s\n", argv0, strerror(errno));
  423. 			errno = 0;
  424. 			return 1;
  425. 		}
  427. 		if(pos > 0)
  428. 			if(fwrite(output, pos, 1, stdout) <= 0)
  429. 			{
  430. 				fprintf(stderr, "%s: error: Failed writing data: %s\n", argv0, strerror(errno));
  431. 				errno = 0;
  432. 				return 1;
  433. 			}
  435. 		if(printf("\n") < 0)
  436. 		{
  437. 			fprintf(stderr, "%s: error: Failed writing newline: %s\n", argv0, strerror(errno));
  438. 			errno = 0;
  439. 			return 1;
  440. 		}
  442. 		if(feof(fin)) break;
  443. 	}
  445. 	if(fflush(stdout) != 0)
  446. 	{
  447. 		fprintf(stderr, "%s: error: Failed writing (flush): %s\n", argv0, strerror(errno));
  448. 		errno = 0;
  449. 		return 1;
  450. 	}
  451. 	int err = ferror(stdout);
  452. 	if(err != 0)
  453. 	{
  454. 		fprintf(stderr, "%s: error: Failed writing (ferror): %s\n", argv0, strerror(errno));
  455. 		return 1;
  456. 	}
  458. 	return 0;
  459. }
  461. static int
  462. uuencode_main(int argc, char *argv[])
  463. {
  464. 	argv0 = "uuencode";
  465. 	const char *begin_str = "begin";
  466. 	const char *end_str = "end\n";
  467. 	int (*process)(FILE *, const char *) = &uuencode;
  469. 	// get old, then reset to old. Yay to POSIX nonsense
  470. 	mode_t mask = umask(0);
  471. 	umask(mask);
  473. 	// negate to get a normal bitmask
  474. 	mask ^= 0777;
  476. 	wrap_nl = 45;
  478. 	int ret = 0;
  480. 	for(int c = -1; (c = getopt_nolong(argc, argv, ":m")) != -1;)
  481. 	{
  482. 		switch(c)
  483. 		{
  484. 		case 'm':
  485. 			process = &base64_encode;
  486. 			begin_str = "begin-base64";
  487. 			end_str = "====\n";
  488. 			wrap_nl = 76;
  489. 			break;
  490. 		case ':':
  491. 			fprintf(stderr, "%s: error: Missing operand for option '-%c'\n", argv0, optopt);
  492. 			return 1;
  493. 		case '?':
  494. 			if(!got_long_opt) fprintf(stderr, "%s: error: Unrecognised option '-%c'\n", argv0, optopt);
  495. 			return 1;
  496. 		}
  497. 	}
  499. 	argc -= optind;
  500. 	argv += optind;
  502. 	if(argc > 2)
  503. 	{
  504. 		fprintf(stderr, "%s: error: Expected 2 arguments or less, got %d\n", argv0, argc);
  505. 		return 1;
  506. 	}
  508. 	FILE *fin = stdin;
  509. 	const char *decode_path = "-";
  510. 	const char *iname = "<stdin>";
  511. 	mode_t mode = 0666 & mask;
  513. 	if(argc >= 1) decode_path = argv[argc - 1];
  515. 	if(argc == 2)
  516. 	{
  517. 		iname = argv[0];
  519. 		fin = fopen(iname, "rb");
  520. 		if(!fin)
  521. 		{
  522. 			fprintf(
  523. 			    stderr, "%s: error: Failed opening input file '%s': %s\n", argv0, iname, strerror(errno));
  524. 			return 1;
  525. 		}
  527. 		struct stat fin_stat;
  528. 		if(fstat(fileno(fin), &fin_stat) != 0)
  529. 		{
  530. 			fprintf(stderr,
  531. 			        "%s: warning: Failed getting status for file '%s': %s\n",
  532. 			        argv0,
  533. 			        iname,
  534. 			        strerror(errno));
  535. 			ret = 1;
  536. 		}
  538. 		mode = fin_stat.st_mode & 0777;
  539. 	}
  541. 	printf("%s %03o %s\n", begin_str, mode, decode_path);
  542. 	if(process(fin, iname) != 0)
  543. 	{
  544. 		ret = 1;
  545. 		goto end;
  546. 	}
  548. end:
  549. 	if(ret == 0)
  550. 	{
  551. 		if(wrap_nl != 0 && c_out > 0) printf("\n");
  553. 		printf("%s", end_str);
  554. 	}
  556. 	if(fclose(fin) != 0)
  557. 	{
  558. 		fprintf(stderr, "%s: error: Failed closing file \"%s\": %s\n", argv0, iname, strerror(errno));
  559. 		ret = 1;
  560. 	}
  562. 	if(fclose(stdout) != 0)
  563. 	{
  564. 		fprintf(stderr, "%s: error: Failed closing file <stdout>: %s\n", argv0, strerror(errno));
  565. 		ret = 1;
  566. 	}
  568. 	return ret;
  569. }
  571. int
  572. main(int argc, char *argv[])
  573. {
  574. 	const char *arg0 = argv[0];
  576. 	const char *s = strrchr(arg0, '/');
  577. 	if(s) arg0 = s + 1;
  579. 	if(strcmp(arg0, "base64") == 0) return base64_main(argc, argv);
  580. 	if(strcmp(arg0, "uuencode") == 0) return uuencode_main(argc, argv);
  582. 	fprintf(stderr, "%s: error: Unknown utility '%s' expected 'base64' or 'uuencode'\n", arg0, arg0);
  584. 	return -1;
  585. }