/src/openssl30/crypto/asn1/a_i2d_fp.c
| Line | Count | Source (jump to first uncovered line) | 
| 1 |  | /* | 
| 2 |  |  * Copyright 1995-2021 The OpenSSL Project Authors. All Rights Reserved. | 
| 3 |  |  * | 
| 4 |  |  * Licensed under the Apache License 2.0 (the "License").  You may not use | 
| 5 |  |  * this file except in compliance with the License.  You can obtain a copy | 
| 6 |  |  * in the file LICENSE in the source distribution or at | 
| 7 |  |  * https://www.openssl.org/source/license.html | 
| 8 |  |  */ | 
| 9 |  |  | 
| 10 |  | #include <stdio.h> | 
| 11 |  | #include "internal/cryptlib.h" | 
| 12 |  | #include <openssl/buffer.h> | 
| 13 |  | #include <openssl/asn1.h> | 
| 14 |  |  | 
| 15 |  | #ifndef NO_OLD_ASN1 | 
| 16 |  |  | 
| 17 |  | # ifndef OPENSSL_NO_STDIO | 
| 18 |  | int ASN1_i2d_fp(i2d_of_void *i2d, FILE *out, const void *x) | 
| 19 | 0 | { | 
| 20 | 0 |     BIO *b; | 
| 21 | 0 |     int ret; | 
| 22 |  | 
 | 
| 23 | 0 |     if ((b = BIO_new(BIO_s_file())) == NULL) { | 
| 24 | 0 |         ERR_raise(ERR_LIB_ASN1, ERR_R_BUF_LIB); | 
| 25 | 0 |         return 0; | 
| 26 | 0 |     } | 
| 27 | 0 |     BIO_set_fp(b, out, BIO_NOCLOSE); | 
| 28 | 0 |     ret = ASN1_i2d_bio(i2d, b, x); | 
| 29 | 0 |     BIO_free(b); | 
| 30 | 0 |     return ret; | 
| 31 | 0 | } | 
| 32 |  | # endif | 
| 33 |  |  | 
| 34 |  | int ASN1_i2d_bio(i2d_of_void *i2d, BIO *out, const void *x) | 
| 35 | 11.6k | { | 
| 36 | 11.6k |     char *b; | 
| 37 | 11.6k |     unsigned char *p; | 
| 38 | 11.6k |     int i, j = 0, n, ret = 1; | 
| 39 |  |  | 
| 40 | 11.6k |     n = i2d(x, NULL); | 
| 41 | 11.6k |     if (n <= 0) | 
| 42 | 0 |         return 0; | 
| 43 |  |  | 
| 44 | 11.6k |     b = OPENSSL_malloc(n); | 
| 45 | 11.6k |     if (b == NULL) { | 
| 46 | 0 |         ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE); | 
| 47 | 0 |         return 0; | 
| 48 | 0 |     } | 
| 49 |  |  | 
| 50 | 11.6k |     p = (unsigned char *)b; | 
| 51 | 11.6k |     i2d(x, &p); | 
| 52 |  |  | 
| 53 | 11.6k |     for (;;) { | 
| 54 | 11.6k |         i = BIO_write(out, &(b[j]), n); | 
| 55 | 11.6k |         if (i == n) | 
| 56 | 11.6k |             break; | 
| 57 | 0 |         if (i <= 0) { | 
| 58 | 0 |             ret = 0; | 
| 59 | 0 |             break; | 
| 60 | 0 |         } | 
| 61 | 0 |         j += i; | 
| 62 | 0 |         n -= i; | 
| 63 | 0 |     } | 
| 64 | 11.6k |     OPENSSL_free(b); | 
| 65 | 11.6k |     return ret; | 
| 66 | 11.6k | } | 
| 67 |  |  | 
| 68 |  | #endif | 
| 69 |  |  | 
| 70 |  | #ifndef OPENSSL_NO_STDIO | 
| 71 |  | int ASN1_item_i2d_fp(const ASN1_ITEM *it, FILE *out, const void *x) | 
| 72 | 0 | { | 
| 73 | 0 |     BIO *b; | 
| 74 | 0 |     int ret; | 
| 75 |  | 
 | 
| 76 | 0 |     if ((b = BIO_new(BIO_s_file())) == NULL) { | 
| 77 | 0 |         ERR_raise(ERR_LIB_ASN1, ERR_R_BUF_LIB); | 
| 78 | 0 |         return 0; | 
| 79 | 0 |     } | 
| 80 | 0 |     BIO_set_fp(b, out, BIO_NOCLOSE); | 
| 81 | 0 |     ret = ASN1_item_i2d_bio(it, b, x); | 
| 82 | 0 |     BIO_free(b); | 
| 83 | 0 |     return ret; | 
| 84 | 0 | } | 
| 85 |  | #endif | 
| 86 |  |  | 
| 87 |  | int ASN1_item_i2d_bio(const ASN1_ITEM *it, BIO *out, const void *x) | 
| 88 | 3.04k | { | 
| 89 | 3.04k |     unsigned char *b = NULL; | 
| 90 | 3.04k |     int i, j = 0, n, ret = 1; | 
| 91 |  |  | 
| 92 | 3.04k |     n = ASN1_item_i2d(x, &b, it); | 
| 93 | 3.04k |     if (b == NULL) { | 
| 94 | 0 |         ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE); | 
| 95 | 0 |         return 0; | 
| 96 | 0 |     } | 
| 97 |  |  | 
| 98 | 3.04k |     for (;;) { | 
| 99 | 3.04k |         i = BIO_write(out, &(b[j]), n); | 
| 100 | 3.04k |         if (i == n) | 
| 101 | 3.04k |             break; | 
| 102 | 0 |         if (i <= 0) { | 
| 103 | 0 |             ret = 0; | 
| 104 | 0 |             break; | 
| 105 | 0 |         } | 
| 106 | 0 |         j += i; | 
| 107 | 0 |         n -= i; | 
| 108 | 0 |     } | 
| 109 | 3.04k |     OPENSSL_free(b); | 
| 110 | 3.04k |     return ret; | 
| 111 | 3.04k | } | 
| 112 |  |  | 
| 113 |  | BIO *ASN1_item_i2d_mem_bio(const ASN1_ITEM *it, const ASN1_VALUE *val) | 
| 114 | 0 | { | 
| 115 | 0 |     BIO *res; | 
| 116 |  | 
 | 
| 117 | 0 |     if (it == NULL || val == NULL) { | 
| 118 | 0 |         ERR_raise(ERR_LIB_ASN1, ERR_R_PASSED_NULL_PARAMETER); | 
| 119 | 0 |         return NULL; | 
| 120 | 0 |     } | 
| 121 |  |  | 
| 122 | 0 |     if ((res = BIO_new(BIO_s_mem())) == NULL) | 
| 123 | 0 |         return NULL; | 
| 124 | 0 |     if (ASN1_item_i2d_bio(it, res, val) <= 0) { | 
| 125 | 0 |         BIO_free(res); | 
| 126 | 0 |         res = NULL; | 
| 127 | 0 |     } | 
| 128 | 0 |     return res; | 
| 129 | 0 | } |