openssl/crypto/evp/bio_b64.c - Issue 2072073002: Delete bundled copy of OpenSSL and replace with README.

Side by Side Diff: openssl/crypto/evp/bio_b64.c

Issue 2072073002: Delete bundled copy of OpenSSL and replace with README. (Closed) Base URL: https://chromium.googlesource.com/chromium/deps/openssl@master

Patch Set: Delete bundled copy of OpenSSL and replace with README. Created 4 years, 6 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View unified diff | Download patch

OLD	NEW
	(Empty)
1 /* crypto/evp/bio_b64.c */

2 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)

3 * All rights reserved.

4 *

5 * This package is an SSL implementation written

6 * by Eric Young (eay@cryptsoft.com).

7 * The implementation was written so as to conform with Netscapes SSL.

8 *

9 * This library is free for commercial and non-commercial use as long as

10 * the following conditions are aheared to. The following conditions

11 * apply to all code found in this distribution, be it the RC4, RSA,

12 * lhash, DES, etc., code; not just the SSL code. The SSL documentation

13 * included with this distribution is covered by the same copyright terms

14 * except that the holder is Tim Hudson (tjh@cryptsoft.com).

15 *

16 * Copyright remains Eric Young's, and as such any Copyright notices in

17 * the code are not to be removed.

18 * If this package is used in a product, Eric Young should be given attribution

19 * as the author of the parts of the library used.

20 * This can be in the form of a textual message at program startup or

21 * in documentation (online or textual) provided with the package.

22 *

23 * Redistribution and use in source and binary forms, with or without

24 * modification, are permitted provided that the following conditions

25 * are met:

26 * 1. Redistributions of source code must retain the copyright

27 * notice, this list of conditions and the following disclaimer.

28 * 2. Redistributions in binary form must reproduce the above copyright

29 * notice, this list of conditions and the following disclaimer in the

30 * documentation and/or other materials provided with the distribution.

31 * 3. All advertising materials mentioning features or use of this software

32 * must display the following acknowledgement:

33 * "This product includes cryptographic software written by

34 * Eric Young (eay@cryptsoft.com)"

35 * The word 'cryptographic' can be left out if the rouines from the library

36 * being used are not cryptographic related :-).

37 * 4. If you include any Windows specific code (or a derivative thereof) from

38 * the apps directory (application code) you must include an acknowledgement:

39 * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"

40 *

41 * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND

42 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

43 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

44 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE

45 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

46 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS

47 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)

48 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

49 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY

50 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF

51 * SUCH DAMAGE.

52 *

53 * The licence and distribution terms for any publically available version or

54 * derivative of this code cannot be changed. i.e. this code cannot simply be

55 * copied and put under another distribution licence

56 * [including the GNU Public Licence.]

57 */

58

59 #include <stdio.h>

60 #include <errno.h>

61 #include "cryptlib.h"

62 #include <openssl/buffer.h>

63 #include <openssl/evp.h>

64

65 static int b64_write(BIO h, const char buf, int num);

66 static int b64_read(BIO h, char buf, int size);

67 static int b64_puts(BIO h, const char str);

68 /static int b64_gets(BIO h, char str, int size); /

69 static long b64_ctrl(BIO h, int cmd, long arg1, void arg2);

70 static int b64_new(BIO *h);

71 static int b64_free(BIO *data);

72 static long b64_callback_ctrl(BIO h,int cmd,bio_info_cb fp);

73 #define B64_BLOCK_SIZE 1024

74 #define B64_BLOCK_SIZE2 768

75 #define B64_NONE 0

76 #define B64_ENCODE 1

77 #define B64_DECODE 2

78

79 typedef struct b64_struct

80 {

81 /BIO bio; moved to the BIO structure */

82 int buf_len;

83 int buf_off;

84 int tmp_len; /* used to find the start when decoding */

85 int tmp_nl; /* If true, scan until '\n' */

86 int encode;

87 int start; /* have we started decoding yet? */

88 int cont; /* <= 0 when finished */

89 EVP_ENCODE_CTX base64;

90 char buf[EVP_ENCODE_LENGTH(B64_BLOCK_SIZE)+10];

91 char tmp[B64_BLOCK_SIZE];

92 } BIO_B64_CTX;

93

94 static BIO_METHOD methods_b64=

95 {

96 BIO_TYPE_BASE64,"base64 encoding",

97 b64_write,

98 b64_read,

99 b64_puts,

100 NULL, /* b64_gets, */

101 b64_ctrl,

102 b64_new,

103 b64_free,

104 b64_callback_ctrl,

105 };

106

107 BIO_METHOD *BIO_f_base64(void)

108 {

109 return(&methods_b64);

110 }

111

112 static int b64_new(BIO *bi)

113 {

114 BIO_B64_CTX *ctx;

115

116 ctx=(BIO_B64_CTX *)OPENSSL_malloc(sizeof(BIO_B64_CTX));

117 if (ctx == NULL) return(0);

118

119 ctx->buf_len=0;

120 ctx->tmp_len=0;

121 ctx->tmp_nl=0;

122 ctx->buf_off=0;

123 ctx->cont=1;

124 ctx->start=1;

125 ctx->encode=0;

126

127 bi->init=1;

128 bi->ptr=(char *)ctx;

129 bi->flags=0;

130 bi->num = 0;

131 return(1);

132 }

133

134 static int b64_free(BIO *a)

135 {

136 if (a == NULL) return(0);

137 OPENSSL_free(a->ptr);

138 a->ptr=NULL;

139 a->init=0;

140 a->flags=0;

141 return(1);

142 }

143

144 static int b64_read(BIO b, char out, int outl)

145 {

146 int ret=0,i,ii,j,k,x,n,num,ret_code=0;

147 BIO_B64_CTX *ctx;

148 unsigned char p,q;

149

150 if (out == NULL) return(0);

151 ctx=(BIO_B64_CTX *)b->ptr;

152

153 if ((ctx == NULL) \|\| (b->next_bio == NULL)) return(0);

154

155 BIO_clear_retry_flags(b);

156

157 if (ctx->encode != B64_DECODE)

158 {

159 ctx->encode=B64_DECODE;

160 ctx->buf_len=0;

161 ctx->buf_off=0;

162 ctx->tmp_len=0;

163 EVP_DecodeInit(&(ctx->base64));

164 }

165

166 /* First check if there are bytes decoded/encoded */

167 if (ctx->buf_len > 0)

168 {

169 OPENSSL_assert(ctx->buf_len >= ctx->buf_off);

170 i=ctx->buf_len-ctx->buf_off;

171 if (i > outl) i=outl;

172 OPENSSL_assert(ctx->buf_off+i < (int)sizeof(ctx->buf));

173 memcpy(out,&(ctx->buf[ctx->buf_off]),i);

174 ret=i;

175 out+=i;

176 outl-=i;

177 ctx->buf_off+=i;

178 if (ctx->buf_len == ctx->buf_off)

179 {

180 ctx->buf_len=0;

181 ctx->buf_off=0;

182 }

183 }

184

185 /* At this point, we have room of outl bytes and an empty

186 * buffer, so we should read in some more. */

187

188 ret_code=0;

189 while (outl > 0)

190 {

191 if (ctx->cont <= 0)

192 break;

193

194 i=BIO_read(b->next_bio,&(ctx->tmp[ctx->tmp_len]),

195 B64_BLOCK_SIZE-ctx->tmp_len);

196

197 if (i <= 0)

198 {

199 ret_code=i;

200

201 /* Should we continue next time we are called? */

202 if (!BIO_should_retry(b->next_bio))

203 {

204 ctx->cont=i;

205 /* If buffer empty break */

206 if(ctx->tmp_len == 0)

207 break;

208 /* Fall through and process what we have */

209 else

210 i = 0;

211 }

212 /* else we retry and add more data to buffer */

213 else

214 break;

215 }

216 i+=ctx->tmp_len;

217 ctx->tmp_len = i;

218

219 /* We need to scan, a line at a time until we

220 * have a valid line if we are starting. */

221 if (ctx->start && (BIO_get_flags(b) & BIO_FLAGS_BASE64_NO_NL))

222 {

223 /* ctx->start=1; */

224 ctx->tmp_len=0;

225 }

226 else if (ctx->start)

227 {

228 q=p=(unsigned char *)ctx->tmp;

229 num = 0;

230 for (j=0; j<i; j++)

231 {

232 if (*(q++) != '\n') continue;

233

234 /* due to a previous very long line,

235 * we need to keep on scanning for a '\n'

236 * before we even start looking for

237 * base64 encoded stuff. */

238 if (ctx->tmp_nl)

239 {

240 p=q;

241 ctx->tmp_nl=0;

242 continue;

243 }

244

245 k=EVP_DecodeUpdate(&(ctx->base64),

246 (unsigned char *)ctx->buf,

247 &num,p,q-p);

248 if ((k <= 0) && (num == 0) && (ctx->start))

249 EVP_DecodeInit(&ctx->base64);

250 else

251 {

252 if (p != (unsigned char *)

253 &(ctx->tmp[0]))

254 {

255 i-=(p- (unsigned char *)

256 &(ctx->tmp[0]));

257 for (x=0; x < i; x++)

258 ctx->tmp[x]=p[x];

259 }

260 EVP_DecodeInit(&ctx->base64);

261 ctx->start=0;

262 break;

263 }

264 p=q;

265 }

266

267 /* we fell off the end without starting */

268 if (j == i)

269 {

270 /* Is this is one long chunk?, if so, keep on

271 * reading until a new line. */

272 if (p == (unsigned char *)&(ctx->tmp[0]))

273 {

274 /* Check buffer full */

275 if (i == B64_BLOCK_SIZE)

276 {

277 ctx->tmp_nl=1;

278 ctx->tmp_len=0;

279 }

280 }

281 else if (p != q) /* finished on a '\n' */

282 {

283 n=q-p;

284 for (ii=0; ii<n; ii++)

285 ctx->tmp[ii]=p[ii];

286 ctx->tmp_len=n;

287 }

288 /* else finished on a '\n' */

289 continue;

290 }

291 else

292 {

293 ctx->tmp_len=0;

294 }

295 }

296 else if ((i < B64_BLOCK_SIZE) && (ctx->cont > 0))

297 {

298 /* If buffer isn't full and we can retry then

299 * restart to read in more data.

300 */

301 continue;

302 }

303

304 if (BIO_get_flags(b) & BIO_FLAGS_BASE64_NO_NL)

305 {

306 int z,jj;

307

308 #if 0

309 jj=(i>>2)<<2;

310 #else

311 jj = i & ~3; /* process per 4 */

312 #endif

313 z=EVP_DecodeBlock((unsigned char *)ctx->buf,

314 (unsigned char *)ctx->tmp,jj);

315 if (jj > 2)

316 {

317 if (ctx->tmp[jj-1] == '=')

318 {

319 z--;

320 if (ctx->tmp[jj-2] == '=')

321 z--;

322 }

323 }

324 /* z is now number of output bytes and jj is the

325 * number consumed */

326 if (jj != i)

327 {

328 memmove(ctx->tmp, &ctx->tmp[jj], i-jj);

329 ctx->tmp_len=i-jj;

330 }

331 ctx->buf_len=0;

332 if (z > 0)

333 {

334 ctx->buf_len=z;

335 }

336 i=z;

337 }

338 else

339 {

340 i=EVP_DecodeUpdate(&(ctx->base64),

341 (unsigned char *)ctx->buf,&ctx->buf_len,

342 (unsigned char *)ctx->tmp,i);

343 ctx->tmp_len = 0;

344 }

345 ctx->buf_off=0;

346 if (i < 0)

347 {

348 ret_code=0;

349 ctx->buf_len=0;

350 break;

351 }

352

353 if (ctx->buf_len <= outl)

354 i=ctx->buf_len;

355 else

356 i=outl;

357

358 memcpy(out,ctx->buf,i);

359 ret+=i;

360 ctx->buf_off=i;

361 if (ctx->buf_off == ctx->buf_len)

362 {

363 ctx->buf_len=0;

364 ctx->buf_off=0;

365 }

366 outl-=i;

367 out+=i;

368 }

369 /* BIO_clear_retry_flags(b); */

370 BIO_copy_next_retry(b);

371 return((ret == 0)?ret_code:ret);

372 }

373

374 static int b64_write(BIO b, const char in, int inl)

375 {

376 int ret=0;

377 int n;

378 int i;

379 BIO_B64_CTX *ctx;

380

381 ctx=(BIO_B64_CTX *)b->ptr;

382 BIO_clear_retry_flags(b);

383

384 if (ctx->encode != B64_ENCODE)

385 {

386 ctx->encode=B64_ENCODE;

387 ctx->buf_len=0;

388 ctx->buf_off=0;

389 ctx->tmp_len=0;

390 EVP_EncodeInit(&(ctx->base64));

391 }

392

393 OPENSSL_assert(ctx->buf_off < (int)sizeof(ctx->buf));

394 OPENSSL_assert(ctx->buf_len <= (int)sizeof(ctx->buf));

395 OPENSSL_assert(ctx->buf_len >= ctx->buf_off);

396 n=ctx->buf_len-ctx->buf_off;

397 while (n > 0)

398 {

399 i=BIO_write(b->next_bio,&(ctx->buf[ctx->buf_off]),n);

400 if (i <= 0)

401 {

402 BIO_copy_next_retry(b);

403 return(i);

404 }

405 OPENSSL_assert(i <= n);

406 ctx->buf_off+=i;

407 OPENSSL_assert(ctx->buf_off <= (int)sizeof(ctx->buf));

408 OPENSSL_assert(ctx->buf_len >= ctx->buf_off);

409 n-=i;

410 }

411 /* at this point all pending data has been written */

412 ctx->buf_off=0;

413 ctx->buf_len=0;

414

415 if ((in == NULL) \|\| (inl <= 0)) return(0);

416

417 while (inl > 0)

418 {

419 n=(inl > B64_BLOCK_SIZE)?B64_BLOCK_SIZE:inl;

420

421 if (BIO_get_flags(b) & BIO_FLAGS_BASE64_NO_NL)

422 {

423 if (ctx->tmp_len > 0)

424 {

425 OPENSSL_assert(ctx->tmp_len <= 3);

426 n=3-ctx->tmp_len;

427 /* There's a theoretical possibility for this */

428 if (n > inl)

429 n=inl;

430 memcpy(&(ctx->tmp[ctx->tmp_len]),in,n);

431 ctx->tmp_len+=n;

432 ret += n;

433 if (ctx->tmp_len < 3)

434 break;

435 ctx->buf_len=EVP_EncodeBlock((unsigned char )ct x->buf,(unsigned char )ctx->tmp,ctx->tmp_len);

436 OPENSSL_assert(ctx->buf_len <= (int)sizeof(ctx-> buf));

437 OPENSSL_assert(ctx->buf_len >= ctx->buf_off);

438 /* Since we're now done using the temporary

439 buffer, the length should be 0'd */

440 ctx->tmp_len=0;

441 }

442 else

443 {

444 if (n < 3)

445 {

446 memcpy(ctx->tmp,in,n);

447 ctx->tmp_len=n;

448 ret += n;

449 break;

450 }

451 n-=n%3;

452 ctx->buf_len=EVP_EncodeBlock((unsigned char )ct x->buf,(const unsigned char )in,n);

453 OPENSSL_assert(ctx->buf_len <= (int)sizeof(ctx-> buf));

454 OPENSSL_assert(ctx->buf_len >= ctx->buf_off);

455 ret += n;

456 }

457 }

458 else

459 {

460 EVP_EncodeUpdate(&(ctx->base64),

461 (unsigned char *)ctx->buf,&ctx->buf_len,

462 (unsigned char *)in,n);

463 OPENSSL_assert(ctx->buf_len <= (int)sizeof(ctx->buf));

464 OPENSSL_assert(ctx->buf_len >= ctx->buf_off);

465 ret += n;

466 }

467 inl-=n;

468 in+=n;

469

470 ctx->buf_off=0;

471 n=ctx->buf_len;

472 while (n > 0)

473 {

474 i=BIO_write(b->next_bio,&(ctx->buf[ctx->buf_off]),n);

475 if (i <= 0)

476 {

477 BIO_copy_next_retry(b);

478 return((ret == 0)?i:ret);

479 }

480 OPENSSL_assert(i <= n);

481 n-=i;

482 ctx->buf_off+=i;

483 OPENSSL_assert(ctx->buf_off <= (int)sizeof(ctx->buf));

484 OPENSSL_assert(ctx->buf_len >= ctx->buf_off);

485 }

486 ctx->buf_len=0;

487 ctx->buf_off=0;

488 }

489 return(ret);

490 }

491

492 static long b64_ctrl(BIO b, int cmd, long num, void ptr)

493 {

494 BIO_B64_CTX *ctx;

495 long ret=1;

496 int i;

497

498 ctx=(BIO_B64_CTX *)b->ptr;

499

500 switch (cmd)

501 {

502 case BIO_CTRL_RESET:

503 ctx->cont=1;

504 ctx->start=1;

505 ctx->encode=B64_NONE;

506 ret=BIO_ctrl(b->next_bio,cmd,num,ptr);

507 break;

508 case BIO_CTRL_EOF: /* More to read */

509 if (ctx->cont <= 0)

510 ret=1;

511 else

512 ret=BIO_ctrl(b->next_bio,cmd,num,ptr);

513 break;

514 case BIO_CTRL_WPENDING: /* More to write in buffer */

515 OPENSSL_assert(ctx->buf_len >= ctx->buf_off);

516 ret=ctx->buf_len-ctx->buf_off;

517 if ((ret == 0) && (ctx->encode != B64_NONE)

518 && (ctx->base64.num != 0))

519 ret=1;

520 else if (ret <= 0)

521 ret=BIO_ctrl(b->next_bio,cmd,num,ptr);

522 break;

523 case BIO_CTRL_PENDING: /* More to read in buffer */

524 OPENSSL_assert(ctx->buf_len >= ctx->buf_off);

525 ret=ctx->buf_len-ctx->buf_off;

526 if (ret <= 0)

527 ret=BIO_ctrl(b->next_bio,cmd,num,ptr);

528 break;

529 case BIO_CTRL_FLUSH:

530 /* do a final write */

531 again:

532 while (ctx->buf_len != ctx->buf_off)

533 {

534 i=b64_write(b,NULL,0);

535 if (i < 0)

536 return i;

537 }

538 if (BIO_get_flags(b) & BIO_FLAGS_BASE64_NO_NL)

539 {

540 if (ctx->tmp_len != 0)

541 {

542 ctx->buf_len=EVP_EncodeBlock(

543 (unsigned char *)ctx->buf,

544 (unsigned char *)ctx->tmp,

545 ctx->tmp_len);

546 ctx->buf_off=0;

547 ctx->tmp_len=0;

548 goto again;

549 }

550 }

551 else if (ctx->encode != B64_NONE && ctx->base64.num != 0)

552 {

553 ctx->buf_off=0;

554 EVP_EncodeFinal(&(ctx->base64),

555 (unsigned char *)ctx->buf,

556 &(ctx->buf_len));

557 /* push out the bytes */

558 goto again;

559 }

560 /* Finally flush the underlying BIO */

561 ret=BIO_ctrl(b->next_bio,cmd,num,ptr);

562 break;

563

564 case BIO_C_DO_STATE_MACHINE:

565 BIO_clear_retry_flags(b);

566 ret=BIO_ctrl(b->next_bio,cmd,num,ptr);

567 BIO_copy_next_retry(b);

568 break;

569

570 case BIO_CTRL_DUP:

571 break;

572 case BIO_CTRL_INFO:

573 case BIO_CTRL_GET:

574 case BIO_CTRL_SET:

575 default:

576 ret=BIO_ctrl(b->next_bio,cmd,num,ptr);

577 break;

578 }

579 return(ret);

580 }

581

582 static long b64_callback_ctrl(BIO b, int cmd, bio_info_cb fp)

583 {

584 long ret=1;

585

586 if (b->next_bio == NULL) return(0);

587 switch (cmd)

588 {

589 default:

590 ret=BIO_callback_ctrl(b->next_bio,cmd,fp);

591 break;

592 }

593 return(ret);

594 }

595

596 static int b64_puts(BIO b, const char str)

597 {

598 return b64_write(b,str,strlen(str));

599 }

OLD	NEW

« no previous file with comments | « openssl/crypto/err/openssl.ec ('k') | openssl/crypto/evp/bio_enc.c » ('j') | no next file with comments »