logo

utils-std

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

base64.c (7113B)

    

  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 <assert.h> /* assert */
  8. #include <ctype.h>  /* isspace */
  9. #include <errno.h>  /* errno */
  10. #include <stdint.h> /* uint8_t */
  11. #include <stdio.h>  /* fopen(), fprintf(), BUFSIZ */
  12. #include <stdlib.h> /* abort */
  13. #include <string.h> /* strerror(), strncmp() */
  14. #include <unistd.h> /* read(), write(), close(), getopt(), opt* */
  16. // 64(26+26+10+2) + NULL
  17. static const char *b64_encmap = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
  18. static size_t c_out = 0;
  19. // 76 is lowest of all base64 related RFCs
  20. static long wrap_nl = 76;
  21. const char *argv0 = "base64";
  23. static int
  24. xputc(int c, FILE *stream)
  25. {
  26. 	assert(errno == 0);
  27. 	if(fputc(c, stream) == EOF)
  28. 	{
  29. 		fprintf(stderr, "%s: error: Failed writing: %s\n", argv0, strerror(errno));
  30. 		errno = 0;
  31. 		return 1;
  32. 	}
  34. 	assert(errno == 0);
  35. 	int err = ferror(stream);
  36. 	if(err != 0)
  37. 	{
  38. 		fprintf(stderr, "%s: error: Failed writing: %s\n", argv0, strerror(err));
  39. 		errno = 0;
  40. 		return 1;
  41. 	}
  43. 	return 0;
  44. }
  46. static inline uint8_t
  47. b64_get(uint8_t pos)
  48. {
  49. 	assert(pos <= 64);
  50. 	return b64_encmap[pos];
  51. }
  53. static void
  54. b64encode(uint8_t out[4], uint8_t in[3])
  55. {
  56. 	out[0] = b64_get(in[0] >> 2);
  57. 	out[1] = b64_get((uint8_t)(((in[0] & 0x03) << 4) | (in[1] >> 4)));
  58. 	out[2] = b64_get((uint8_t)(((in[1] & 0x0f) << 2) | (in[2] >> 6)));
  59. 	out[3] = b64_get(in[2] & 0x3f);
  60. }
  62. static int
  63. encode(FILE *fin, const char *name)
  64. {
  65. 	while(1)
  66. 	{
  67. 		uint8_t obuf[4] = "----";
  68. 		uint8_t ibuf[3] = {0, 0, 0};
  69. 		uint8_t pad = 0;
  71. 		size_t c = 0;
  72. 		for(; c < 3; c++)
  73. 		{
  74. 			int buf = getc(fin);
  75. 			if(buf == EOF)
  76. 			{
  77. 				break;
  78. 			}
  79. 			ibuf[c] = buf;
  80. 		}
  81. 		if(c == 0)
  82. 		{
  83. 			return 0;
  84. 		};
  85. 		assert(errno == 0);
  86. 		if(ferror(fin))
  87. 		{
  88. 			fprintf(
  89. 			    stderr, "%s: error: Failed reading from file '%s': %s\n", argv0, name, 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;
  114. 		assert(errno == 0);
  116. 		if(wrap_nl != 0 && (c_out + 4) > wrap_nl)
  117. 		{
  118. 			c_out = 0;
  119. 			if(xputc('\n', stdout) != 0) return 1;
  120. 		}
  122. 		if(feof(fin))
  123. 		{
  124. 			assert(errno == 0);
  125. 			if(fflush(stdout))
  126. 			{
  127. 				fprintf(stderr, "%s: error: Failed writing: %s\n", argv0, strerror(errno));
  128. 				errno = 0;
  129. 				return 1;
  130. 			}
  131. 			int err = ferror(stdout);
  132. 			if(err != 0)
  133. 			{
  134. 				fprintf(stderr, "%s: error: Failed writing: %s\n", argv0, strerror(errno));
  135. 				return 1;
  136. 			}
  138. 			return 0;
  139. 		}
  140. 	}
  142. 	abort(); // unreachable
  143. }
  145. // This function is based on NetBSD's code, which contains the following notices:
  146. // Copyright (c) 2018 The NetBSD Foundation, Inc.
  147. //
  148. // This code is derived from software contributed to The NetBSD Foundation
  149. // by Christos Zoulas.
  150. static int
  151. decode(FILE *fin, const char *name)
  152. {
  153. 	int c = 0;
  154. 	uint8_t out = 0;
  155. 	int state = 0;
  157. 	while((c = getc(fin)) != EOF)
  158. 	{
  159. 		if(isspace(c)) continue;
  161. 		if(c == '=') break;
  163. 		uint8_t b = 65;
  164. 		for(uint8_t i = 0; i < 64; i++)
  165. 		{
  166. 			if(b64_encmap[i] == c)
  167. 			{
  168. 				b = i;
  169. 				break;
  170. 			}
  171. 		}
  172. 		if(b > 64)
  173. 		{
  174. 			fprintf(stderr, "%s: error: Invalid character '%c'\n", argv0, c);
  175. 			return 1;
  176. 		}
  178. 		//fprintf(stderr, "state: %d | c: %c (%d) | b: %d\n", state, c, c, b);
  180. 		switch(state)
  181. 		{
  182. 		case 0:
  183. 			out = (uint8_t)(b << 2);
  184. 			break;
  185. 		case 1:
  186. 			out |= b >> 4;
  187. 			if(xputc(out, stdout) != 0) return 1;
  188. 			out = (uint8_t)((b & 0xf) << 4);
  189. 			break;
  190. 		case 2:
  191. 			out |= b >> 2;
  192. 			if(xputc(out, stdout) != 0) return 1;
  193. 			out = (uint8_t)((b & 0x3) << 6);
  194. 			break;
  195. 		case 3:
  196. 			out |= b;
  197. 			if(xputc(out, stdout) != 0) return 1;
  198. 			out = 0;
  199. 			break;
  200. 		default:
  201. 			abort();
  202. 		}
  203. 		state = (state + 1) & 3;
  204. 	}
  206. 	//fprintf(stderr, "[outside] state: %d | c: %c (%d) | out: %d\n", state, c, c, out);
  208. 	if(c == '=')
  209. 	{
  210. 		switch(state)
  211. 		{
  212. 		case 0:
  213. 		case 1:
  214. 			fprintf(stderr, "%s: error: Invalid character '%c' (early '=')\n", argv0, c);
  215. 			return 1;
  216. 		case 2:
  217. 			while(isspace(c = getc(fin)))
  218. 				;
  220. 			if(c != '=')
  221. 			{
  222. 				fprintf(stderr, "%s: error: Invalid character '%c' (not '=')\n", argv0, c);
  223. 				return 1;
  224. 			}
  225. 			/* fallthrough */
  226. 		case 3:
  227. 			while(isspace(c = getc(fin)))
  228. 				;
  230. 			if(c != EOF)
  231. 			{
  232. 				fprintf(stderr, "%s: error: Invalid character '%c' (not EOF)\n", argv0, c);
  233. 				return 1;
  234. 			}
  235. 			return 0;
  236. 		default:
  237. 			abort();
  238. 		}
  239. 	}
  241. 	assert(c == EOF || state == 0);
  243. 	assert(errno == 0);
  244. 	if(fflush(stdout))
  245. 	{
  246. 		fprintf(stderr, "%s: error: Failed writing: %s\n", argv0, strerror(errno));
  247. 		errno = 0;
  248. 		return 1;
  249. 	}
  250. 	assert(errno == 0);
  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. int
  263. main(int argc, char *argv[])
  264. {
  265. 	int (*process)(FILE *, const char *) = &encode;
  267. 	int c = 0, ret = 0;
  269. 	while((c = getopt(argc, argv, ":dw:")) != -1)
  270. 	{
  271. 		switch(c)
  272. 		{
  273. 		case 'd':
  274. 			process = &decode;
  275. 			break;
  276. 		case 'w':
  277. 			errno = 0;
  278. 			char *e = NULL;
  279. 			wrap_nl = strtol(optarg, &e, 10);
  281. 			// extraneous characters is invalid
  282. 			if(e && *e != 0) errno = EINVAL;
  284. 			if(errno != 0)
  285. 			{
  286. 				fprintf(stderr, "%s: error: Option '-w %s': %s\n", argv0, optarg, strerror(errno));
  287. 				return 1;
  288. 			}
  289. 			break;
  290. 		case ':':
  291. 			fprintf(stderr, "%s: error: Missing operand for option '-%c'\n", argv0, optopt);
  292. 			return 1;
  293. 		case '?':
  294. 			fprintf(stderr, "%s: error: Unrecognised option '-%c'\n", argv0, optopt);
  295. 			return 1;
  296. 		}
  297. 	}
  299. 	argc -= optind;
  300. 	argv += optind;
  302. 	if(argc <= 0)
  303. 	{
  304. 		ret = process(stdin, "<stdin>");
  305. 		goto end;
  306. 	}
  308. 	for(int argi = 0; argi < argc; argi++)
  309. 	{
  310. 		if(strncmp(argv[argi], "-", 2) == 0)
  311. 		{
  312. 			if(process(stdin, "<stdin>") != 0)
  313. 			{
  314. 				ret = 1;
  315. 				goto end;
  316. 			}
  317. 		}
  318. 		else if(strncmp(argv[argi], "--", 3) == 0)
  319. 		{
  320. 			continue;
  321. 		}
  322. 		else
  323. 		{
  324. 			FILE *fin = fopen(argv[argi], "r");
  325. 			if(fin == NULL || ferror(fin) != 0)
  326. 			{
  327. 				fprintf(stderr,
  328. 				        "%s: error: Failed opening file '%s': %s\n",
  329. 				        argv0,
  330. 				        argv[argi],
  331. 				        strerror(errno));
  332. 				ret = 1;
  333. 				goto end;
  334. 			}
  336. 			if(process(fin, argv[argi]) != 0)
  337. 			{
  338. 				ret = 1;
  339. 				goto end;
  340. 			}
  342. 			if(fclose(fin) < 0)
  343. 			{
  344. 				fprintf(stderr,
  345. 				        "%s: error: Failed closing file '%s': %s\n",
  346. 				        argv0,
  347. 				        argv[argi],
  348. 				        strerror(errno));
  349. 				ret = 1;
  350. 				goto end;
  351. 			}
  352. 		}
  353. 	}
  355. end:
  356. 	if(wrap_nl != 0 && c_out > 0)
  357. 	{
  358. 		printf("\n");
  359. 	}
  361. 	if(fclose(stdin) != 0)
  362. 	{
  363. 		fprintf(stderr, "%s: error: Failed closing file <stdin>: %s\n", argv0, strerror(errno));
  364. 		ret = 1;
  365. 	}
  367. 	if(fclose(stdout) != 0)
  368. 	{
  369. 		fprintf(stderr, "%s: error: Failed closing file <stdout>: %s\n", argv0, strerror(errno));
  370. 		ret = 1;
  371. 	}
  373. 	return ret;
  374. }