OpenCoverage

base64.c

Absolute File Name:

/home/opencoverage/opencoverage/guest-scripts/coreutils/src/lib/base64.c

Source code

Switch to Preprocessed file

Line Source Count

1 /* base64.c -- Encode binary data using printable characters. -

3 -

4 This program is free software; you can redistribute it and/or modify -

5 it under the terms of the GNU General Public License as published by -

6 the Free Software Foundation; either version 3, or (at your option) -

7 any later version. -

8 -

9 This program is distributed in the hope that it will be useful, -

10 but WITHOUT ANY WARRANTY; without even the implied warranty of -

11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -

12 GNU General Public License for more details. -

13 -

14 You should have received a copy of the GNU General Public License -

15 along with this program; if not, see <https://www.gnu.org/licenses/>. */ -

16 -

17 /* Written by Simon Josefsson. Partially adapted from GNU MailUtils -

18 * (mailbox/filter_trans.c, as of 2004-11-28). Improved by review -

19 * from Paul Eggert, Bruno Haible, and Stepan Kasal. -

20 * -

21 * See also RFC 4648 <https://www.ietf.org/rfc/rfc4648.txt>. -

22 * -

23 * Be careful with error checking. Here is how you would typically -

24 * use these functions: -

25 * -

26 * bool ok = base64_decode_alloc (in, inlen, &out, &outlen); -

27 * if (!ok) -

28 * FAIL: input was not valid base64 -

29 * if (out == NULL) -

30 * FAIL: memory allocation error -

31 * OK: data in OUT/OUTLEN -

32 * -

33 * size_t outlen = base64_encode_alloc (in, inlen, &out); -

34 * if (out == NULL && outlen == 0 && inlen != 0) -

35 * FAIL: input too long -

36 * if (out == NULL) -

37 * FAIL: memory allocation error -

38 * OK: data in OUT/OUTLEN. -

39 * -

40 */ -

41 -

42 #include <config.h> -

43 -

44 /* Get prototype. */ -

45 #include "base64.h" -

46 -

47 /* Get malloc. */ -

48 #include <stdlib.h> -

49 -

50 /* Get UCHAR_MAX. */ -

51 #include <limits.h> -

52 -

53 #include <string.h> -

54 -

55 /* C89 compliant way to cast 'char' to 'unsigned char'. */ -

56 static unsigned char -

57 to_uchar (char ch) -

58 { -

return ch;

executed 132607 times by 1 test: return ch;

Executed by:

base64

132607

60 } -

61 -

62 static const char b64c[64] = -

63 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; -

64 -

65 /* Base64 encode IN array of size INLEN into OUT array. OUT needs -

66 to be of length >= BASE64_LENGTH(INLEN), and INLEN needs to be -

67 a multiple of 3. */ -

68 static void -

69 base64_encode_fast (const char *restrict in, size_t inlen, char *restrict out) -

70 { -

while (inlen)

inlen	Description
TRUE	evaluated 43 times by 1 test Evaluated by: base64
FALSE	evaluated 4 times by 1 test Evaluated by: base64

4-43

72 { -

73 *out++ = b64c[to_uchar (in[0]) >> 2]; -

74 *out++ = b64c[((to_uchar (in[0]) << 4) + (to_uchar (in[1]) >> 4)) & 0x3f]; -

75 *out++ = b64c[((to_uchar (in[1]) << 2) + (to_uchar (in[2]) >> 6)) & 0x3f]; -

76 *out++ = b64c[to_uchar (in[2]) & 0x3f]; -

77 -

78 inlen -= 3; -

79 in += 3; -

}

executed 43 times by 1 test: end of block

Executed by:

base64

}

executed 4 times by 1 test: end of block

Executed by:

base64

82 -

83 /* Base64 encode IN array of size INLEN into OUT array of size OUTLEN. -

84 If OUTLEN is less than BASE64_LENGTH(INLEN), write as many bytes as -

85 possible. If OUTLEN is larger than BASE64_LENGTH(INLEN), also zero -

86 terminate the output buffer. */ -

87 void -

88 base64_encode (const char *restrict in, size_t inlen, -

89 char *restrict out, size_t outlen) -

90 { -

91 /* Note this outlen constraint can be enforced at compile time. -

92 I.E. that the output buffer is exactly large enough to hold -

93 the encoded inlen bytes. The inlen constraints (of corresponding -

94 to outlen, and being a multiple of 3) can change at runtime -

95 at the end of input. However the common case when reading -

96 large inputs is to have both constraints satisfied, so we depend -

97 on both in base_encode_fast(). */ -

if (outlen % 4 == 0 && inlen == outlen / 4 * 3)

outlen % 4 == 0	Description
TRUE	evaluated 17 times by 1 test Evaluated by: base64
FALSE	never evaluated

inlen == outlen / 4 * 3	Description
TRUE	evaluated 4 times by 1 test Evaluated by: base64
FALSE	evaluated 13 times by 1 test Evaluated by: base64

0-17

99 { -

100 base64_encode_fast (in, inlen, out); -

101

return;

executed 4 times by 1 test: return;

Executed by:

base64

102 } -

103 -

104

while (inlen && outlen)

inlen	Description
TRUE	evaluated 89 times by 1 test Evaluated by: base64
FALSE	never evaluated

outlen	Description
TRUE	evaluated 89 times by 1 test Evaluated by: base64
FALSE	never evaluated

0-89

105 { -

106 *out++ = b64c[to_uchar (in[0]) >> 2]; -

107

if (!--outlen)

!--outlen	Description
TRUE	never evaluated
FALSE	evaluated 89 times by 1 test Evaluated by: base64

0-89

108

break;

never executed: break;

109 *out++ = b64c[((to_uchar (in[0]) << 4) -

110 + (--inlen ? to_uchar (in[1]) >> 4 : 0)) -

111 & 0x3f]; -

112

if (!--outlen)

!--outlen	Description
TRUE	never evaluated
FALSE	evaluated 89 times by 1 test Evaluated by: base64

0-89

113

break;

never executed: break;

114 *out++ = -

115

(inlen

inlen	Description
TRUE	evaluated 80 times by 1 test Evaluated by: base64
FALSE	evaluated 9 times by 1 test Evaluated by: base64

9-80

116 ? b64c[((to_uchar (in[1]) << 2) -

117 + (--inlen ? to_uchar (in[2]) >> 6 : 0)) -

118 & 0x3f] -

119 : '='); -

120

if (!--outlen)

!--outlen	Description
TRUE	never evaluated
FALSE	evaluated 89 times by 1 test Evaluated by: base64

0-89

121

break;

never executed: break;

122

*out++ = inlen ? b64c[to_uchar (in[2]) & 0x3f] : '=';

inlen	Description
TRUE	evaluated 76 times by 1 test Evaluated by: base64
FALSE	evaluated 13 times by 1 test Evaluated by: base64

13-76

123

if (!--outlen)

!--outlen	Description
TRUE	evaluated 13 times by 1 test Evaluated by: base64
FALSE	evaluated 76 times by 1 test Evaluated by: base64

13-76

124

break;

executed 13 times by 1 test: break;

Executed by:

base64

125

if (inlen)

inlen	Description
TRUE	evaluated 76 times by 1 test Evaluated by: base64
FALSE	never evaluated

0-76

126

inlen--;

executed 76 times by 1 test: inlen--;

Executed by:

base64

127

if (inlen)

inlen	Description
TRUE	evaluated 76 times by 1 test Evaluated by: base64
FALSE	never evaluated

0-76

128

in += 3;

executed 76 times by 1 test: in += 3;

Executed by:

base64

129

}

executed 76 times by 1 test: end of block

Executed by:

base64

130 -

131

if (outlen)

outlen	Description
TRUE	never evaluated
FALSE	evaluated 13 times by 1 test Evaluated by: base64

0-13

132

*out = '\0';

never executed: *out = '\0';

133

}

executed 13 times by 1 test: end of block

Executed by:

base64

134 -

135 /* Allocate a buffer and store zero terminated base64 encoded data -

136 from array IN of size INLEN, returning BASE64_LENGTH(INLEN), i.e., -

137 the length of the encoded data, excluding the terminating zero. On -

138 return, the OUT variable will hold a pointer to newly allocated -

139 memory that must be deallocated by the caller. If output string -

140 length would overflow, 0 is returned and OUT is set to NULL. If -

141 memory allocation failed, OUT is set to NULL, and the return value -

142 indicates length of the requested memory block, i.e., -

143 BASE64_LENGTH(inlen) + 1. */ -

144 size_t -

145 base64_encode_alloc (const char *in, size_t inlen, char **out) -

146 { -

147 size_t outlen = 1 + BASE64_LENGTH (inlen); -

148 -

149 /* Check for overflow in outlen computation. -

150 * -

151 * If there is no overflow, outlen >= inlen. -

152 * -

153 * If the operation (inlen + 2) overflows then it yields at most +1, so -

154 * outlen is 0. -

155 * -

156 * If the multiplication overflows, we lose at least half of the -

157 * correct value, so the result is < ((inlen + 2) / 3) * 2, which is -

158 * less than (inlen + 2) * 0.66667, which is less than inlen as soon as -

159 * (inlen > 4). -

160 */ -

161

if (inlen > outlen)

inlen > outlen	Description
TRUE	never evaluated
FALSE	never evaluated

162 { -

163 *out = NULL; -

164

return 0;

never executed: return 0;

165 } -

166 -

167 *out = malloc (outlen); -

168

if (!*out)

!*out	Description
TRUE	never evaluated
FALSE	never evaluated

169

return outlen;

never executed: return outlen;

170 -

171 base64_encode (in, inlen, *out, outlen); -

172 -

173

return outlen - 1;

never executed: return outlen - 1;

174 } -

175 -

176 /* With this approach this file works independent of the charset used -

177 (think EBCDIC). However, it does assume that the characters in the -

178 Base64 alphabet (A-Za-z0-9+/) are encoded in 0..255. POSIX -

179 1003.1-2001 require that char and unsigned char are 8-bit -

180 quantities, though, taking care of that problem. But this may be a -

181 potential problem on non-POSIX C99 platforms. -

182 -

183 IBM C V6 for AIX mishandles "#define B64(x) ...'x'...", so use "_" -

184 as the formal parameter rather than "x". */ -

185 #define B64(_) \ -

186 ((_) == 'A' ? 0 \ -

187 : (_) == 'B' ? 1 \ -

188 : (_) == 'C' ? 2 \ -

189 : (_) == 'D' ? 3 \ -

190 : (_) == 'E' ? 4 \ -

191 : (_) == 'F' ? 5 \ -

192 : (_) == 'G' ? 6 \ -

193 : (_) == 'H' ? 7 \ -

194 : (_) == 'I' ? 8 \ -

195 : (_) == 'J' ? 9 \ -

196 : (_) == 'K' ? 10 \ -

197 : (_) == 'L' ? 11 \ -

198 : (_) == 'M' ? 12 \ -

199 : (_) == 'N' ? 13 \ -

200 : (_) == 'O' ? 14 \ -

201 : (_) == 'P' ? 15 \ -

202 : (_) == 'Q' ? 16 \ -

203 : (_) == 'R' ? 17 \ -

204 : (_) == 'S' ? 18 \ -

205 : (_) == 'T' ? 19 \ -

206 : (_) == 'U' ? 20 \ -

207 : (_) == 'V' ? 21 \ -

208 : (_) == 'W' ? 22 \ -

209 : (_) == 'X' ? 23 \ -

210 : (_) == 'Y' ? 24 \ -

211 : (_) == 'Z' ? 25 \ -

212 : (_) == 'a' ? 26 \ -

213 : (_) == 'b' ? 27 \ -

214 : (_) == 'c' ? 28 \ -

215 : (_) == 'd' ? 29 \ -

216 : (_) == 'e' ? 30 \ -

217 : (_) == 'f' ? 31 \ -

218 : (_) == 'g' ? 32 \ -

219 : (_) == 'h' ? 33 \ -

220 : (_) == 'i' ? 34 \ -

221 : (_) == 'j' ? 35 \ -

222 : (_) == 'k' ? 36 \ -

223 : (_) == 'l' ? 37 \ -

224 : (_) == 'm' ? 38 \ -

225 : (_) == 'n' ? 39 \ -

226 : (_) == 'o' ? 40 \ -

227 : (_) == 'p' ? 41 \ -

228 : (_) == 'q' ? 42 \ -

229 : (_) == 'r' ? 43 \ -

230 : (_) == 's' ? 44 \ -

231 : (_) == 't' ? 45 \ -

232 : (_) == 'u' ? 46 \ -

233 : (_) == 'v' ? 47 \ -

234 : (_) == 'w' ? 48 \ -

235 : (_) == 'x' ? 49 \ -

236 : (_) == 'y' ? 50 \ -

237 : (_) == 'z' ? 51 \ -

238 : (_) == '0' ? 52 \ -

239 : (_) == '1' ? 53 \ -

240 : (_) == '2' ? 54 \ -

241 : (_) == '3' ? 55 \ -

242 : (_) == '4' ? 56 \ -

243 : (_) == '5' ? 57 \ -

244 : (_) == '6' ? 58 \ -

245 : (_) == '7' ? 59 \ -

246 : (_) == '8' ? 60 \ -

247 : (_) == '9' ? 61 \ -

248 : (_) == '+' ? 62 \ -

249 : (_) == '/' ? 63 \ -

250 : -1) -

251 -

252 static const signed char b64[0x100] = { -

253 B64 (0), B64 (1), B64 (2), B64 (3), -

254 B64 (4), B64 (5), B64 (6), B64 (7), -

255 B64 (8), B64 (9), B64 (10), B64 (11), -

256 B64 (12), B64 (13), B64 (14), B64 (15), -

257 B64 (16), B64 (17), B64 (18), B64 (19), -

258 B64 (20), B64 (21), B64 (22), B64 (23), -

259 B64 (24), B64 (25), B64 (26), B64 (27), -

260 B64 (28), B64 (29), B64 (30), B64 (31), -

261 B64 (32), B64 (33), B64 (34), B64 (35), -

262 B64 (36), B64 (37), B64 (38), B64 (39), -

263 B64 (40), B64 (41), B64 (42), B64 (43), -

264 B64 (44), B64 (45), B64 (46), B64 (47), -

265 B64 (48), B64 (49), B64 (50), B64 (51), -

266 B64 (52), B64 (53), B64 (54), B64 (55), -

267 B64 (56), B64 (57), B64 (58), B64 (59), -

268 B64 (60), B64 (61), B64 (62), B64 (63), -

269 B64 (64), B64 (65), B64 (66), B64 (67), -

270 B64 (68), B64 (69), B64 (70), B64 (71), -

271 B64 (72), B64 (73), B64 (74), B64 (75), -

272 B64 (76), B64 (77), B64 (78), B64 (79), -

273 B64 (80), B64 (81), B64 (82), B64 (83), -

274 B64 (84), B64 (85), B64 (86), B64 (87), -

275 B64 (88), B64 (89), B64 (90), B64 (91), -

276 B64 (92), B64 (93), B64 (94), B64 (95), -

277 B64 (96), B64 (97), B64 (98), B64 (99), -

278 B64 (100), B64 (101), B64 (102), B64 (103), -

279 B64 (104), B64 (105), B64 (106), B64 (107), -

280 B64 (108), B64 (109), B64 (110), B64 (111), -

281 B64 (112), B64 (113), B64 (114), B64 (115), -

282 B64 (116), B64 (117), B64 (118), B64 (119), -

283 B64 (120), B64 (121), B64 (122), B64 (123), -

284 B64 (124), B64 (125), B64 (126), B64 (127), -

285 B64 (128), B64 (129), B64 (130), B64 (131), -

286 B64 (132), B64 (133), B64 (134), B64 (135), -

287 B64 (136), B64 (137), B64 (138), B64 (139), -

288 B64 (140), B64 (141), B64 (142), B64 (143), -

289 B64 (144), B64 (145), B64 (146), B64 (147), -

290 B64 (148), B64 (149), B64 (150), B64 (151), -

291 B64 (152), B64 (153), B64 (154), B64 (155), -

292 B64 (156), B64 (157), B64 (158), B64 (159), -

293 B64 (160), B64 (161), B64 (162), B64 (163), -

294 B64 (164), B64 (165), B64 (166), B64 (167), -

295 B64 (168), B64 (169), B64 (170), B64 (171), -

296 B64 (172), B64 (173), B64 (174), B64 (175), -

297 B64 (176), B64 (177), B64 (178), B64 (179), -

298 B64 (180), B64 (181), B64 (182), B64 (183), -

299 B64 (184), B64 (185), B64 (186), B64 (187), -

300 B64 (188), B64 (189), B64 (190), B64 (191), -

301 B64 (192), B64 (193), B64 (194), B64 (195), -

302 B64 (196), B64 (197), B64 (198), B64 (199), -

303 B64 (200), B64 (201), B64 (202), B64 (203), -

304 B64 (204), B64 (205), B64 (206), B64 (207), -

305 B64 (208), B64 (209), B64 (210), B64 (211), -

306 B64 (212), B64 (213), B64 (214), B64 (215), -

307 B64 (216), B64 (217), B64 (218), B64 (219), -

308 B64 (220), B64 (221), B64 (222), B64 (223), -

309 B64 (224), B64 (225), B64 (226), B64 (227), -

310 B64 (228), B64 (229), B64 (230), B64 (231), -

311 B64 (232), B64 (233), B64 (234), B64 (235), -

312 B64 (236), B64 (237), B64 (238), B64 (239), -

313 B64 (240), B64 (241), B64 (242), B64 (243), -

314 B64 (244), B64 (245), B64 (246), B64 (247), -

315 B64 (248), B64 (249), B64 (250), B64 (251), -

316 B64 (252), B64 (253), B64 (254), B64 (255) -

317 }; -

318 -

319 #if UCHAR_MAX == 255 -

320 # define uchar_in_range(c) true -

321 #else -

322 # define uchar_in_range(c) ((c) <= 255) -

323 #endif -

324 -

325 /* Return true if CH is a character from the Base64 alphabet, and -

326 false otherwise. Note that '=' is padding and not considered to be -

327 part of the alphabet. */ -

328 bool -

329 isbase64 (char ch) -

330 { -

331

return uchar_in_range (to_uchar (ch)) && 0 <= b64[to_uchar (ch)];

executed 53861 times by 1 test: return 1 && 0 <= b64[to_uchar (ch)];

Executed by:

base64

53861

332 } -

333 -

334 /* Initialize decode-context buffer, CTX. */ -

335 void -

336 base64_decode_ctx_init (struct base64_decode_context *ctx) -

337 { -

338 ctx->i = 0; -

339

}

executed 174 times by 1 test: end of block

Executed by:

base64

174

340 -

341 /* If CTX->i is 0 or 4, there are four or more bytes in [*IN..IN_END), and -

342 none of those four is a newline, then return *IN. Otherwise, copy up to -

343 4 - CTX->i non-newline bytes from that range into CTX->buf, starting at -

344 index CTX->i and setting CTX->i to reflect the number of bytes copied, -

345 and return CTX->buf. In either case, advance *IN to point to the byte -

346 after the last one processed, and set *N_NON_NEWLINE to the number of -

347 verified non-newline bytes accessible through the returned pointer. */ -

348 static char * -

349 get_4 (struct base64_decode_context *ctx, -

350 char const *restrict *in, char const *restrict in_end, -

351 size_t *n_non_newline) -

352 { -

353

if (ctx->i == 4)

ctx->i == 4	Description
TRUE	evaluated 906 times by 1 test Evaluated by: base64
FALSE	evaluated 165 times by 1 test Evaluated by: base64

165-906

354

ctx->i = 0;

executed 906 times by 1 test: ctx->i = 0;

Executed by:

base64

906

355 -

356

if (ctx->i == 0)

ctx->i == 0	Description
TRUE	evaluated 1064 times by 1 test Evaluated by: base64
FALSE	evaluated 7 times by 1 test Evaluated by: base64

7-1064

357 { -

358 char const *t = *in; -

359

if (4 <= in_end - *in && memchr (t, '\n', 4) == NULL)

4 <= in_end - *in	Description
TRUE	evaluated 969 times by 1 test Evaluated by: base64
FALSE	evaluated 95 times by 1 test Evaluated by: base64

memchr (t, '\n...== ((void *)0)	Description
TRUE	evaluated 66 times by 1 test Evaluated by: base64
FALSE	evaluated 903 times by 1 test Evaluated by: base64

66-969

360 { -

361 /* This is the common case: no newline. */ -

362 *in += 4; -

363 *n_non_newline = 4; -

364

return (char *) t;

executed 66 times by 1 test: return (char *) t;

Executed by:

base64

365 } -

366

}

executed 998 times by 1 test: end of block

Executed by:

base64

998

367 -

368 { -

369 /* Copy non-newline bytes into BUF. */ -

370 char const *p = *in; -

371

while (p < in_end)

p < in_end	Description
TRUE	evaluated 4576 times by 1 test Evaluated by: base64
FALSE	evaluated 99 times by 1 test Evaluated by: base64

99-4576

372 { -

373 char c = *p++; -

374

if (c != '\n')

c != '\n'	Description
TRUE	evaluated 3633 times by 1 test Evaluated by: base64
FALSE	evaluated 943 times by 1 test Evaluated by: base64

943-3633

375 { -

376 ctx->buf[ctx->i++] = c; -

377

if (ctx->i == 4)

ctx->i == 4	Description
TRUE	evaluated 906 times by 1 test Evaluated by: base64
FALSE	evaluated 2727 times by 1 test Evaluated by: base64

906-2727

378

break;

executed 906 times by 1 test: break;

Executed by:

base64

906

379

}

executed 2727 times by 1 test: end of block

Executed by:

base64

2727

380

}

executed 3670 times by 1 test: end of block

Executed by:

base64

3670

381 -

382 *in = p; -

383 *n_non_newline = ctx->i; -

384

return ctx->buf;

executed 1005 times by 1 test: return ctx->buf;

Executed by:

base64

1005

385 } -

386 } -

387 -

388 #define return_false \ -

389 do \ -

390 { \ -

391 *outp = out; \ -

392 return false; \ -

393 } \ -

394 while (false) -

395 -

396 /* Decode up to four bytes of base64-encoded data, IN, of length INLEN -

397 into the output buffer, *OUT, of size *OUTLEN bytes. Return true if -

398 decoding is successful, false otherwise. If *OUTLEN is too small, -

399 as many bytes as possible are written to *OUT. On return, advance -

400 *OUT to point to the byte after the last one written, and decrement -

401 *OUTLEN to reflect the number of bytes remaining in *OUT. */ -

402 static bool -

403 decode_4 (char const *restrict in, size_t inlen, -

404 char *restrict *outp, size_t *outleft) -

405 { -

406 char *out = *outp; -

407

if (inlen < 2)

inlen < 2	Description
TRUE	evaluated 319 times by 1 test Evaluated by: base64
FALSE	evaluated 13973 times by 1 test Evaluated by: base64

319-13973

408

return false;

executed 319 times by 1 test: return 0 ;

Executed by:

base64

319

409 -

410

if (!isbase64 (in[0]) || !isbase64 (in[1]))

!isbase64 (in[0])	Description
TRUE	evaluated 255 times by 1 test Evaluated by: base64
FALSE	evaluated 13718 times by 1 test Evaluated by: base64

!isbase64 (in[1])	Description
TRUE	evaluated 315 times by 1 test Evaluated by: base64
FALSE	evaluated 13403 times by 1 test Evaluated by: base64

255-13718

411

return false;

executed 570 times by 1 test: return 0 ;

Executed by:

base64

570

412 -

413

if (*outleft)

*outleft	Description
TRUE	evaluated 13403 times by 1 test Evaluated by: base64
FALSE	never evaluated

0-13403

414 { -

415 *out++ = ((b64[to_uchar (in[0])] << 2) -

416 | (b64[to_uchar (in[1])] >> 4)); -

417 --*outleft; -

418

}

executed 13403 times by 1 test: end of block

Executed by:

base64

13403

419 -

420

if (inlen == 2)

inlen == 2	Description
TRUE	evaluated 3 times by 1 test Evaluated by: base64
FALSE	evaluated 13400 times by 1 test Evaluated by: base64

3-13400

421

return_false;

executed 3 times by 1 test: return 0 ;

Executed by:

base64

never executed: end of block

0-3

422 -

423

if (in[2] == '=')

in[2] == '='	Description
TRUE	evaluated 130 times by 1 test Evaluated by: base64
FALSE	evaluated 13270 times by 1 test Evaluated by: base64

130-13270

424 { -

425

if (inlen != 4)

inlen != 4	Description
TRUE	evaluated 59 times by 1 test Evaluated by: base64
FALSE	evaluated 71 times by 1 test Evaluated by: base64

59-71

426

return_false;

executed 59 times by 1 test: return 0 ;

Executed by:

base64

never executed: end of block

0-59

427 -

428

if (in[3] != '=')

in[3] != '='	Description
TRUE	never evaluated
FALSE	evaluated 71 times by 1 test Evaluated by: base64

0-71

429

return_false;

never executed: return 0 ;

never executed: end of block

430

}

executed 71 times by 1 test: end of block

Executed by:

base64

431 else -

432 { -

433

if (!isbase64 (in[2]))

!isbase64 (in[2])	Description
TRUE	evaluated 297 times by 1 test Evaluated by: base64
FALSE	evaluated 12973 times by 1 test Evaluated by: base64

297-12973

434

return_false;

executed 297 times by 1 test: return 0 ;

Executed by:

base64

never executed: end of block

0-297

435 -

436

if (*outleft)

*outleft	Description
TRUE	evaluated 12973 times by 1 test Evaluated by: base64
FALSE	never evaluated

0-12973

437 { -

438 *out++ = (((b64[to_uchar (in[1])] << 4) & 0xf0) -

439 | (b64[to_uchar (in[2])] >> 2)); -

440 --*outleft; -

441

}

executed 12973 times by 1 test: end of block

Executed by:

base64

12973

442 -

443

if (inlen == 3)

inlen == 3	Description
TRUE	evaluated 3 times by 1 test Evaluated by: base64
FALSE	evaluated 12970 times by 1 test Evaluated by: base64

3-12970

444

return_false;

executed 3 times by 1 test: return 0 ;

Executed by:

base64

never executed: end of block

0-3

445 -

446

if (in[3] == '=')

in[3] == '='	Description
TRUE	evaluated 70 times by 1 test Evaluated by: base64
FALSE	evaluated 12900 times by 1 test Evaluated by: base64

70-12900

447 { -

448

if (inlen != 4)

inlen != 4	Description
TRUE	evaluated 24 times by 1 test Evaluated by: base64
FALSE	evaluated 46 times by 1 test Evaluated by: base64

24-46

449

return_false;

executed 24 times by 1 test: return 0 ;

Executed by:

base64

never executed: end of block

0-24

450

}

executed 46 times by 1 test: end of block

Executed by:

base64

451 else -

452 { -

453

if (!isbase64 (in[3]))

!isbase64 (in[3])	Description
TRUE	evaluated 277 times by 1 test Evaluated by: base64
FALSE	evaluated 12623 times by 1 test Evaluated by: base64

277-12623

454

return_false;

executed 277 times by 1 test: return 0 ;

Executed by:

base64

never executed: end of block

0-277

455 -

456

if (*outleft)

*outleft	Description
TRUE	evaluated 12623 times by 1 test Evaluated by: base64
FALSE	never evaluated

0-12623

457 { -

458 *out++ = (((b64[to_uchar (in[2])] << 6) & 0xc0) -

459 | b64[to_uchar (in[3])]); -

460 --*outleft; -

461

}

executed 12623 times by 1 test: end of block

Executed by:

base64

12623

462

}

executed 12623 times by 1 test: end of block

Executed by:

base64

12623

463 } -

464 -

465 *outp = out; -

466

return true;

executed 12740 times by 1 test: return 1 ;

Executed by:

base64

12740

467 } -

468 -

469 /* Decode base64-encoded input array IN of length INLEN to output array -

470 OUT that can hold *OUTLEN bytes. The input data may be interspersed -

471 with newlines. Return true if decoding was successful, i.e. if the -

472 input was valid base64 data, false otherwise. If *OUTLEN is too -

473 small, as many bytes as possible will be written to OUT. On return, -

474 *OUTLEN holds the length of decoded bytes in OUT. Note that as soon -

475 as any non-alphabet, non-newline character is encountered, decoding -

476 is stopped and false is returned. If INLEN is zero, then process -

477 only whatever data is stored in CTX. -

478 -

479 Initially, CTX must have been initialized via base64_decode_ctx_init. -

480 Subsequent calls to this function must reuse whatever state is recorded -

481 in that buffer. It is necessary for when a quadruple of base64 input -

482 bytes spans two input buffers. -

483 -

484 If CTX is NULL then newlines are treated as garbage and the input -

485 buffer is processed as a unit. */ -

486 -

487 bool -

488 base64_decode_ctx (struct base64_decode_context *ctx, -

489 const char *restrict in, size_t inlen, -

490 char *restrict out, size_t *outlen) -

491 { -

492 size_t outleft = *outlen; -

493 bool ignore_newlines = ctx != NULL; -

494 bool flush_ctx = false; -

495 unsigned int ctx_i = 0; -

496 -

497

if (ignore_newlines)

ignore_newlines	Description
TRUE	evaluated 271 times by 1 test Evaluated by: base64
FALSE	never evaluated

0-271

498 { -

499 ctx_i = ctx->i; -

500 flush_ctx = inlen == 0; -

501

}

executed 271 times by 1 test: end of block

Executed by:

base64

271

502 -

503 -

504 while (true) -

505 { -

506 size_t outleft_save = outleft; -

507

if (ctx_i == 0 && !flush_ctx)

ctx_i == 0	Description
TRUE	evaluated 1551 times by 1 test Evaluated by: base64
FALSE	evaluated 94 times by 1 test Evaluated by: base64

!flush_ctx	Description
TRUE	evaluated 1547 times by 1 test Evaluated by: base64
FALSE	evaluated 4 times by 1 test Evaluated by: base64

4-1551

508 { -

509 while (true) -

510 { -

511 /* Save a copy of outleft, in case we need to re-parse this -

512 block of four bytes. */ -

513 outleft_save = outleft; -

514

if (!decode_4 (in, inlen, &out, &outleft))

!decode_4 (in,...out, &outleft)	Description
TRUE	evaluated 1547 times by 1 test Evaluated by: base64
FALSE	evaluated 11769 times by 1 test Evaluated by: base64

1547-11769

515

break;

executed 1547 times by 1 test: break;

Executed by:

base64

1547

516 -

517 in += 4; -

518 inlen -= 4; -

519

}

executed 11769 times by 1 test: end of block

Executed by:

base64

11769

520

}

executed 1547 times by 1 test: end of block

Executed by:

base64

1547

521 -

522

if (inlen == 0 && !flush_ctx)

inlen == 0	Description
TRUE	evaluated 263 times by 1 test Evaluated by: base64
FALSE	evaluated 1382 times by 1 test Evaluated by: base64

!flush_ctx	Description
TRUE	evaluated 171 times by 1 test Evaluated by: base64
FALSE	evaluated 92 times by 1 test Evaluated by: base64

92-1382

523

break;

executed 171 times by 1 test: break;

Executed by:

base64

171

524 -

525 /* Handle the common case of 72-byte wrapped lines. -

526 This also handles any other multiple-of-4-byte wrapping. */ -

527

if (inlen && *in == '\n' && ignore_newlines)

inlen	Description
TRUE	evaluated 1382 times by 1 test Evaluated by: base64
FALSE	evaluated 92 times by 1 test Evaluated by: base64

*in == '\n'	Description
TRUE	evaluated 403 times by 1 test Evaluated by: base64
FALSE	evaluated 979 times by 1 test Evaluated by: base64

ignore_newlines	Description
TRUE	evaluated 403 times by 1 test Evaluated by: base64
FALSE	never evaluated

0-1382

528 { -

529 ++in; -

530 --inlen; -

531

continue;

executed 403 times by 1 test: continue;

Executed by:

base64

403

532 } -

533 -

534 /* Restore OUT and OUTLEFT. */ -

535 out -= outleft_save - outleft; -

536 outleft = outleft_save; -

537 -

538 { -

539 char const *in_end = in + inlen; -

540 char const *non_nl; -

541 -

542

if (ignore_newlines)

ignore_newlines	Description
TRUE	evaluated 1071 times by 1 test Evaluated by: base64
FALSE	never evaluated

0-1071

543

non_nl = get_4 (ctx, &in, in_end, &inlen);

executed 1071 times by 1 test: non_nl = get_4 (ctx, &in, in_end, &inlen);

Executed by:

base64

1071

544 else -

545

non_nl = in; /* Might have nl in this case. */

never executed: non_nl = in;

546 -

547 /* If the input is empty or consists solely of newlines (0 non-newlines), -

548 then we're done. Likewise if there are fewer than 4 bytes when not -

549 flushing context and not treating newlines as garbage. */ -

550

if (inlen == 0 || (inlen < 4 && !flush_ctx && ignore_newlines))

inlen == 0	Description
TRUE	evaluated 88 times by 1 test Evaluated by: base64
FALSE	evaluated 983 times by 1 test Evaluated by: base64

inlen < 4	Description
TRUE	evaluated 11 times by 1 test Evaluated by: base64
FALSE	evaluated 972 times by 1 test Evaluated by: base64

!flush_ctx	Description
TRUE	evaluated 7 times by 1 test Evaluated by: base64
FALSE	evaluated 4 times by 1 test Evaluated by: base64

ignore_newlines	Description
TRUE	evaluated 7 times by 1 test Evaluated by: base64
FALSE	never evaluated

0-983

551 { -

552 inlen = 0; -

553

break;

executed 95 times by 1 test: break;

Executed by:

base64

554 } -

555

if (!decode_4 (non_nl, inlen, &out, &outleft))

!decode_4 (non...out, &outleft)	Description
TRUE	evaluated 5 times by 1 test Evaluated by: base64
FALSE	evaluated 971 times by 1 test Evaluated by: base64

5-971

556

break;

executed 5 times by 1 test: break;

Executed by:

base64

557 -

558 inlen = in_end - in; -

559 } -

560

}

executed 971 times by 1 test: end of block

Executed by:

base64

971

561 -

562 *outlen -= outleft; -

563 -

564

return inlen == 0;

executed 271 times by 1 test: return inlen == 0;

Executed by:

base64

271

565 } -

566 -

567 /* Allocate an output buffer in *OUT, and decode the base64 encoded -

568 data stored in IN of size INLEN to the *OUT buffer. On return, the -

569 size of the decoded data is stored in *OUTLEN. OUTLEN may be NULL, -

570 if the caller is not interested in the decoded length. *OUT may be -

571 NULL to indicate an out of memory error, in which case *OUTLEN -

572 contains the size of the memory block needed. The function returns -

573 true on successful decoding and memory allocation errors. (Use the -

574 *OUT and *OUTLEN parameters to differentiate between successful -

575 decoding and memory error.) The function returns false if the -

576 input was invalid, in which case *OUT is NULL and *OUTLEN is -

577 undefined. */ -

578 bool -

579 base64_decode_alloc_ctx (struct base64_decode_context *ctx, -

580 const char *in, size_t inlen, char **out, -

581 size_t *outlen) -

582 { -

583 /* This may allocate a few bytes too many, depending on input, -

584 but it's not worth the extra CPU time to compute the exact size. -

585 The exact size is 3 * (inlen + (ctx ? ctx->i : 0)) / 4, minus 1 if the -

586 input ends with "=" and minus another 1 if the input ends with "==". -

587 Dividing before multiplying avoids the possibility of overflow. */ -

588 size_t needlen = 3 * (inlen / 4) + 3; -

589 -

590 *out = malloc (needlen); -

591

if (!*out)

!*out	Description
TRUE	never evaluated
FALSE	never evaluated

592

return true;

never executed: return 1 ;

593 -

594

if (!base64_decode_ctx (ctx, in, inlen, *out, &needlen))

!base64_decode...out, &needlen)	Description
TRUE	never evaluated
FALSE	never evaluated

595 { -

596 free (*out); -

597 *out = NULL; -

598

return false;

never executed: return 0 ;

599 } -

600 -

601

if (outlen)

outlen	Description
TRUE	never evaluated
FALSE	never evaluated

602

*outlen = needlen;

never executed: *outlen = needlen;

603 -

604

return true;

never executed: return 1 ;

605 } -

Source code

Switch to Preprocessed file

Generated by Squish Coco 4.1.2