crypto/x509v3/v3_sxnet.c:177: error: MEMORY_LEAK
  memory dynamically allocated by call to `ASN1_INTEGER_new()` at line 171, column 18 is not reachable after line 177, column 5.
Showing all 95 steps of the trace


crypto/x509v3/v3_sxnet.c:166:1: start of procedure SXNET_add_id_ulong()
164.   /* Add an id given the zone as an unsigned long */
165.   
166. > int SXNET_add_id_ulong(SXNET **psx, unsigned long lzone, char *user,
167.                          int userlen)
168.   {

crypto/x509v3/v3_sxnet.c:171:9: 
169.       ASN1_INTEGER *izone;
170.   
171. >     if ((izone = ASN1_INTEGER_new()) == NULL
172.           || !ASN1_INTEGER_set(izone, lzone)) {
173.           X509V3err(X509V3_F_SXNET_ADD_ID_ULONG, ERR_R_MALLOC_FAILURE);

crypto/asn1/tasn_typ.c:77:1: start of procedure ASN1_INTEGER_new()
  75.   
  76.   IMPLEMENT_ASN1_STRING_FUNCTIONS(ASN1_OCTET_STRING)
  77. > IMPLEMENT_ASN1_STRING_FUNCTIONS(ASN1_INTEGER)
  78.   IMPLEMENT_ASN1_STRING_FUNCTIONS(ASN1_ENUMERATED)
  79.   IMPLEMENT_ASN1_STRING_FUNCTIONS(ASN1_BIT_STRING)

crypto/asn1/asn1_lib.c:348:1: start of procedure ASN1_STRING_type_new()
    346.   }
    347.   
    348. > ASN1_STRING *ASN1_STRING_type_new(int type)
    349.   {
    350.       ASN1_STRING *ret;

crypto/asn1/asn1_lib.c:352:5: 
    350.       ASN1_STRING *ret;
    351.   
    352. >     ret = OPENSSL_zalloc(sizeof(*ret));
    353.       if (ret == NULL) {
    354.           ASN1err(ASN1_F_ASN1_STRING_TYPE_NEW, ERR_R_MALLOC_FAILURE);

crypto/mem.c:156:1: start of procedure CRYPTO_zalloc()
      154.   }
      155.   
      156. > void *CRYPTO_zalloc(size_t num, const char *file, int line)
      157.   {
      158.       void *ret = CRYPTO_malloc(num, file, line);

crypto/mem.c:158:5: 
      156.   void *CRYPTO_zalloc(size_t num, const char *file, int line)
      157.   {
      158. >     void *ret = CRYPTO_malloc(num, file, line);
      159.   
      160.       if (ret != NULL)

crypto/mem.c:119:1: start of procedure CRYPTO_malloc()
        117.   }
        118.   
        119. > void *CRYPTO_malloc(size_t num, const char *file, int line)
        120.   {
        121.       void *ret = NULL;

crypto/mem.c:121:5: 
        119.   void *CRYPTO_malloc(size_t num, const char *file, int line)
        120.   {
        121. >     void *ret = NULL;
        122.   
        123.       if (num <= 0)

crypto/mem.c:123:9: Taking false branch
        121.       void *ret = NULL;
        122.   
        123.       if (num <= 0)
                       ^
        124.           return NULL;
        125.   

crypto/mem.c:126:5: 
        124.           return NULL;
        125.   
        126. >     allow_customize = 0;
        127.   #ifndef OPENSSL_NO_CRYPTO_MDEBUG
        128.       if (call_malloc_debug) {

crypto/mem.c:136:5: 
        134.       }
        135.   #else
        136. >     (void)file;
        137.       (void)line;
        138.       ret = malloc(num);

crypto/mem.c:137:5: 
        135.   #else
        136.       (void)file;
        137. >     (void)line;
        138.       ret = malloc(num);
        139.   #endif

crypto/mem.c:138:5: 
        136.       (void)file;
        137.       (void)line;
        138. >     ret = malloc(num);
        139.   #endif
        140.   

crypto/mem.c:153:5: 
        151.   #endif
        152.   
        153. >     return ret;
        154.   }
        155.   

crypto/mem.c:154:1: return from a call to CRYPTO_malloc
        152.   
        153.       return ret;
        154. > }
        155.   
        156.   void *CRYPTO_zalloc(size_t num, const char *file, int line)

crypto/mem.c:160:9: Taking true branch
      158.       void *ret = CRYPTO_malloc(num, file, line);
      159.   
      160.       if (ret != NULL)
                     ^
      161.           memset(ret, 0, num);
      162.       return ret;

crypto/mem.c:161:9: 
      159.   
      160.       if (ret != NULL)
      161. >         memset(ret, 0, num);
      162.       return ret;
      163.   }

crypto/mem.c:162:5: 
      160.       if (ret != NULL)
      161.           memset(ret, 0, num);
      162. >     return ret;
      163.   }
      164.   

crypto/mem.c:163:1: return from a call to CRYPTO_zalloc
      161.           memset(ret, 0, num);
      162.       return ret;
      163. > }
      164.   
      165.   void *CRYPTO_realloc(void *str, size_t num, const char *file, int line)

crypto/asn1/asn1_lib.c:353:9: Taking false branch
    351.   
    352.       ret = OPENSSL_zalloc(sizeof(*ret));
    353.       if (ret == NULL) {
                   ^
    354.           ASN1err(ASN1_F_ASN1_STRING_TYPE_NEW, ERR_R_MALLOC_FAILURE);
    355.           return (NULL);

crypto/asn1/asn1_lib.c:357:5: 
    355.           return (NULL);
    356.       }
    357. >     ret->type = type;
    358.       return (ret);
    359.   }

crypto/asn1/asn1_lib.c:358:5: 
    356.       }
    357.       ret->type = type;
    358. >     return (ret);
    359.   }
    360.   

crypto/asn1/asn1_lib.c:359:1: return from a call to ASN1_STRING_type_new
    357.       ret->type = type;
    358.       return (ret);
    359. > }
    360.   
    361.   void ASN1_STRING_free(ASN1_STRING *a)

crypto/asn1/tasn_typ.c:77:1: return from a call to ASN1_INTEGER_new
  75.   
  76.   IMPLEMENT_ASN1_STRING_FUNCTIONS(ASN1_OCTET_STRING)
  77. > IMPLEMENT_ASN1_STRING_FUNCTIONS(ASN1_INTEGER)
  78.   IMPLEMENT_ASN1_STRING_FUNCTIONS(ASN1_ENUMERATED)
  79.   IMPLEMENT_ASN1_STRING_FUNCTIONS(ASN1_BIT_STRING)

crypto/x509v3/v3_sxnet.c:171:9: Taking false branch
169.       ASN1_INTEGER *izone;
170.   
171.       if ((izone = ASN1_INTEGER_new()) == NULL
               ^
172.           || !ASN1_INTEGER_set(izone, lzone)) {
173.           X509V3err(X509V3_F_SXNET_ADD_ID_ULONG, ERR_R_MALLOC_FAILURE);

crypto/x509v3/v3_sxnet.c:172:13: 
170.   
171.       if ((izone = ASN1_INTEGER_new()) == NULL
172. >         || !ASN1_INTEGER_set(izone, lzone)) {
173.           X509V3err(X509V3_F_SXNET_ADD_ID_ULONG, ERR_R_MALLOC_FAILURE);
174.           ASN1_INTEGER_free(izone);

crypto/asn1/a_int.c:602:1: start of procedure ASN1_INTEGER_set()
  600.   }
  601.   
  602. > int ASN1_INTEGER_set(ASN1_INTEGER *a, long v)
  603.   {
  604.       return ASN1_INTEGER_set_int64(a, v);

crypto/asn1/a_int.c:604:5: 
  602.   int ASN1_INTEGER_set(ASN1_INTEGER *a, long v)
  603.   {
  604. >     return ASN1_INTEGER_set_int64(a, v);
  605.   }
  606.   

crypto/asn1/a_int.c:587:1: start of procedure ASN1_INTEGER_set_int64()
    585.   }
    586.   
    587. > int ASN1_INTEGER_set_int64(ASN1_INTEGER *a, int64_t r)
    588.   {
    589.       return asn1_string_set_int64(a, r, V_ASN1_INTEGER);

crypto/asn1/a_int.c:589:5: 
    587.   int ASN1_INTEGER_set_int64(ASN1_INTEGER *a, int64_t r)
    588.   {
    589. >     return asn1_string_set_int64(a, r, V_ASN1_INTEGER);
    590.   }
    591.   

crypto/asn1/a_int.c:404:1: start of procedure asn1_string_set_int64()
      402.   }
      403.   
      404. > static int asn1_string_set_int64(ASN1_STRING *a, int64_t r, int itype)
      405.   {
      406.       unsigned char tbuf[sizeof(r)];

crypto/asn1/a_int.c:408:5: 
      406.       unsigned char tbuf[sizeof(r)];
      407.       size_t l;
      408. >     a->type = itype;
      409.       if (r < 0) {
      410.           l = asn1_put_uint64(tbuf, -r);

crypto/asn1/a_int.c:409:9: Taking false branch
      407.       size_t l;
      408.       a->type = itype;
      409.       if (r < 0) {
                     ^
      410.           l = asn1_put_uint64(tbuf, -r);
      411.           a->type |= V_ASN1_NEG;

crypto/asn1/a_int.c:413:9: 
      411.           a->type |= V_ASN1_NEG;
      412.       } else {
      413. >         l = asn1_put_uint64(tbuf, r);
      414.           a->type &= ~V_ASN1_NEG;
      415.       }

crypto/asn1/a_int.c:291:1: start of procedure asn1_put_uint64()
        289.   }
        290.   
        291. > static size_t asn1_put_uint64(unsigned char *b, uint64_t r)
        292.   {
        293.       if (r >= 0x100) {

crypto/asn1/a_int.c:293:9: Taking true branch
        291.   static size_t asn1_put_uint64(unsigned char *b, uint64_t r)
        292.   {
        293.       if (r >= 0x100) {
                       ^
        294.           unsigned char *p;
        295.           uint64_t rtmp = r;

crypto/asn1/a_int.c:295:9: 
        293.       if (r >= 0x100) {
        294.           unsigned char *p;
        295. >         uint64_t rtmp = r;
        296.           size_t i = 0;
        297.   

crypto/asn1/a_int.c:296:9: 
        294.           unsigned char *p;
        295.           uint64_t rtmp = r;
        296. >         size_t i = 0;
        297.   
        298.           /* Work out how many bytes we need */

crypto/asn1/a_int.c:299:16: Loop condition is true. Entering loop body
        297.   
        298.           /* Work out how many bytes we need */
        299.           while (rtmp) {
                              ^
        300.               rtmp >>= 8;
        301.               i++;

crypto/asn1/a_int.c:300:13: 
        298.           /* Work out how many bytes we need */
        299.           while (rtmp) {
        300. >             rtmp >>= 8;
        301.               i++;
        302.           }

crypto/asn1/a_int.c:301:13: 
        299.           while (rtmp) {
        300.               rtmp >>= 8;
        301. >             i++;
        302.           }
        303.   

crypto/asn1/a_int.c:299:16: Loop condition is false. Leaving loop
        297.   
        298.           /* Work out how many bytes we need */
        299.           while (rtmp) {
                              ^
        300.               rtmp >>= 8;
        301.               i++;

crypto/asn1/a_int.c:305:9: 
        303.   
        304.           /* Copy from end to beginning */
        305. >         p = b + i - 1;
        306.   
        307.           do {

crypto/asn1/a_int.c:308:13: 
        306.   
        307.           do {
        308. >             *p-- = r & 0xFF;
        309.               r >>= 8;
        310.           } while (p >= b);

crypto/asn1/a_int.c:309:13: 
        307.           do {
        308.               *p-- = r & 0xFF;
        309. >             r >>= 8;
        310.           } while (p >= b);
        311.   

crypto/asn1/a_int.c:310:18: Loop condition is false. Leaving loop
        308.               *p-- = r & 0xFF;
        309.               r >>= 8;
        310.           } while (p >= b);
                                ^
        311.   
        312.           return i;

crypto/asn1/a_int.c:312:9: 
        310.           } while (p >= b);
        311.   
        312. >         return i;
        313.       }
        314.   

crypto/asn1/a_int.c:318:1: return from a call to asn1_put_uint64
        316.       return 1;
        317.   
        318. > }
        319.   
        320.   /*

crypto/asn1/a_int.c:414:9: 
      412.       } else {
      413.           l = asn1_put_uint64(tbuf, r);
      414. >         a->type &= ~V_ASN1_NEG;
      415.       }
      416.       if (l == 0)

crypto/asn1/a_int.c:416:9: Taking false branch
      414.           a->type &= ~V_ASN1_NEG;
      415.       }
      416.       if (l == 0)
                     ^
      417.           return 0;
      418.       return ASN1_STRING_set(a, tbuf, l);

crypto/asn1/a_int.c:418:5: 
      416.       if (l == 0)
      417.           return 0;
      418. >     return ASN1_STRING_set(a, tbuf, l);
      419.   }
      420.   

crypto/asn1/asn1_lib.c:307:1: start of procedure ASN1_STRING_set()
        305.   }
        306.   
        307. > int ASN1_STRING_set(ASN1_STRING *str, const void *_data, int len)
        308.   {
        309.       unsigned char *c;

crypto/asn1/asn1_lib.c:310:5: 
        308.   {
        309.       unsigned char *c;
        310. >     const char *data = _data;
        311.   
        312.       if (len < 0) {

crypto/asn1/asn1_lib.c:312:9: Taking false branch
        310.       const char *data = _data;
        311.   
        312.       if (len < 0) {
                       ^
        313.           if (data == NULL)
        314.               return (0);

crypto/asn1/asn1_lib.c:318:10: Taking true branch
        316.               len = strlen(data);
        317.       }
        318.       if ((str->length < len) || (str->data == NULL)) {
                        ^
        319.           c = str->data;
        320.           str->data = OPENSSL_realloc(c, len + 1);

crypto/asn1/asn1_lib.c:319:9: 
        317.       }
        318.       if ((str->length < len) || (str->data == NULL)) {
        319. >         c = str->data;
        320.           str->data = OPENSSL_realloc(c, len + 1);
        321.           if (str->data == NULL) {

crypto/asn1/asn1_lib.c:320:9: 
        318.       if ((str->length < len) || (str->data == NULL)) {
        319.           c = str->data;
        320. >         str->data = OPENSSL_realloc(c, len + 1);
        321.           if (str->data == NULL) {
        322.               ASN1err(ASN1_F_ASN1_STRING_SET, ERR_R_MALLOC_FAILURE);

crypto/mem.c:165:1: start of procedure CRYPTO_realloc()
          163.   }
          164.   
          165. > void *CRYPTO_realloc(void *str, size_t num, const char *file, int line)
          166.   {
          167.       if (str == NULL)

crypto/mem.c:167:9: Taking true branch
          165.   void *CRYPTO_realloc(void *str, size_t num, const char *file, int line)
          166.   {
          167.       if (str == NULL)
                         ^
          168.           return CRYPTO_malloc(num, file, line);
          169.   

crypto/mem.c:168:9: 
          166.   {
          167.       if (str == NULL)
          168. >         return CRYPTO_malloc(num, file, line);
          169.   
          170.       if (num == 0) {

crypto/mem.c:119:1: start of procedure CRYPTO_malloc()
            117.   }
            118.   
            119. > void *CRYPTO_malloc(size_t num, const char *file, int line)
            120.   {
            121.       void *ret = NULL;

crypto/mem.c:121:5: 
            119.   void *CRYPTO_malloc(size_t num, const char *file, int line)
            120.   {
            121. >     void *ret = NULL;
            122.   
            123.       if (num <= 0)

crypto/mem.c:123:9: Taking false branch
            121.       void *ret = NULL;
            122.   
            123.       if (num <= 0)
                           ^
            124.           return NULL;
            125.   

crypto/mem.c:126:5: 
            124.           return NULL;
            125.   
            126. >     allow_customize = 0;
            127.   #ifndef OPENSSL_NO_CRYPTO_MDEBUG
            128.       if (call_malloc_debug) {

crypto/mem.c:136:5: 
            134.       }
            135.   #else
            136. >     (void)file;
            137.       (void)line;
            138.       ret = malloc(num);

crypto/mem.c:137:5: 
            135.   #else
            136.       (void)file;
            137. >     (void)line;
            138.       ret = malloc(num);
            139.   #endif

crypto/mem.c:138:5: 
            136.       (void)file;
            137.       (void)line;
            138. >     ret = malloc(num);
            139.   #endif
            140.   

crypto/mem.c:153:5: 
            151.   #endif
            152.   
            153. >     return ret;
            154.   }
            155.   

crypto/mem.c:154:1: return from a call to CRYPTO_malloc
            152.   
            153.       return ret;
            154. > }
            155.   
            156.   void *CRYPTO_zalloc(size_t num, const char *file, int line)

crypto/mem.c:190:1: return from a call to CRYPTO_realloc
          188.       return realloc(str, num);
          189.   
          190. > }
          191.   
          192.   void *CRYPTO_clear_realloc(void *str, size_t old_len, size_t num,

crypto/asn1/asn1_lib.c:321:13: Taking false branch
        319.           c = str->data;
        320.           str->data = OPENSSL_realloc(c, len + 1);
        321.           if (str->data == NULL) {
                           ^
        322.               ASN1err(ASN1_F_ASN1_STRING_SET, ERR_R_MALLOC_FAILURE);
        323.               str->data = c;

crypto/asn1/asn1_lib.c:327:5: 
        325.           }
        326.       }
        327. >     str->length = len;
        328.       if (data != NULL) {
        329.           memcpy(str->data, data, len);

crypto/asn1/asn1_lib.c:328:9: Taking true branch
        326.       }
        327.       str->length = len;
        328.       if (data != NULL) {
                       ^
        329.           memcpy(str->data, data, len);
        330.           /* an allowance for strings :-) */

crypto/asn1/asn1_lib.c:329:9: 
        327.       str->length = len;
        328.       if (data != NULL) {
        329. >         memcpy(str->data, data, len);
        330.           /* an allowance for strings :-) */
        331.           str->data[len] = '\0';

crypto/asn1/asn1_lib.c:331:9: 
        329.           memcpy(str->data, data, len);
        330.           /* an allowance for strings :-) */
        331. >         str->data[len] = '\0';
        332.       }
        333.       return (1);

crypto/asn1/asn1_lib.c:333:5: 
        331.           str->data[len] = '\0';
        332.       }
        333. >     return (1);
        334.   }
        335.   

crypto/asn1/asn1_lib.c:334:1: return from a call to ASN1_STRING_set
        332.       }
        333.       return (1);
        334. > }
        335.   
        336.   void ASN1_STRING_set0(ASN1_STRING *str, void *data, int len)

crypto/asn1/a_int.c:419:1: return from a call to asn1_string_set_int64
      417.           return 0;
      418.       return ASN1_STRING_set(a, tbuf, l);
      419. > }
      420.   
      421.   static int asn1_string_get_uint64(uint64_t *pr, const ASN1_STRING *a,

crypto/asn1/a_int.c:590:1: return from a call to ASN1_INTEGER_set_int64
    588.   {
    589.       return asn1_string_set_int64(a, r, V_ASN1_INTEGER);
    590. > }
    591.   
    592.   int ASN1_INTEGER_get_uint64(uint64_t *pr, const ASN1_INTEGER *a)

crypto/asn1/a_int.c:605:1: return from a call to ASN1_INTEGER_set
  603.   {
  604.       return ASN1_INTEGER_set_int64(a, v);
  605. > }
  606.   
  607.   long ASN1_INTEGER_get(const ASN1_INTEGER *a)

crypto/x509v3/v3_sxnet.c:172:13: Taking false branch
170.   
171.       if ((izone = ASN1_INTEGER_new()) == NULL
172.           || !ASN1_INTEGER_set(izone, lzone)) {
                   ^
173.           X509V3err(X509V3_F_SXNET_ADD_ID_ULONG, ERR_R_MALLOC_FAILURE);
174.           ASN1_INTEGER_free(izone);

crypto/x509v3/v3_sxnet.c:177:5: 
175.           return 0;
176.       }
177. >     return SXNET_add_id_INTEGER(psx, izone, user, userlen);
178.   
179.   }

crypto/x509v3/v3_sxnet.c:186:1: start of procedure SXNET_add_id_INTEGER()
  184.    */
  185.   
  186. > int SXNET_add_id_INTEGER(SXNET **psx, ASN1_INTEGER *zone, char *user,
  187.                            int userlen)
  188.   {

crypto/x509v3/v3_sxnet.c:189:5: 
  187.                            int userlen)
  188.   {
  189. >     SXNET *sx = NULL;
  190.       SXNETID *id = NULL;
  191.       if (!psx || !zone || !user) {

crypto/x509v3/v3_sxnet.c:190:5: 
  188.   {
  189.       SXNET *sx = NULL;
  190. >     SXNETID *id = NULL;
  191.       if (!psx || !zone || !user) {
  192.           X509V3err(X509V3_F_SXNET_ADD_ID_INTEGER,

crypto/x509v3/v3_sxnet.c:191:10: Taking false branch
  189.       SXNET *sx = NULL;
  190.       SXNETID *id = NULL;
  191.       if (!psx || !zone || !user) {
                  ^
  192.           X509V3err(X509V3_F_SXNET_ADD_ID_INTEGER,
  193.                     X509V3_R_INVALID_NULL_ARGUMENT);

crypto/x509v3/v3_sxnet.c:191:18: Taking false branch
  189.       SXNET *sx = NULL;
  190.       SXNETID *id = NULL;
  191.       if (!psx || !zone || !user) {
                          ^
  192.           X509V3err(X509V3_F_SXNET_ADD_ID_INTEGER,
  193.                     X509V3_R_INVALID_NULL_ARGUMENT);

crypto/x509v3/v3_sxnet.c:191:27: Taking false branch
  189.       SXNET *sx = NULL;
  190.       SXNETID *id = NULL;
  191.       if (!psx || !zone || !user) {
                                   ^
  192.           X509V3err(X509V3_F_SXNET_ADD_ID_INTEGER,
  193.                     X509V3_R_INVALID_NULL_ARGUMENT);

crypto/x509v3/v3_sxnet.c:196:9: Taking true branch
  194.           return 0;
  195.       }
  196.       if (userlen == -1)
                 ^
  197.           userlen = strlen(user);
  198.       if (userlen > 64) {

crypto/x509v3/v3_sxnet.c:197:9: 
  195.       }
  196.       if (userlen == -1)
  197. >         userlen = strlen(user);
  198.       if (userlen > 64) {
  199.           X509V3err(X509V3_F_SXNET_ADD_ID_INTEGER, X509V3_R_USER_TOO_LONG);

crypto/x509v3/v3_sxnet.c:198:9: Taking true branch
  196.       if (userlen == -1)
  197.           userlen = strlen(user);
  198.       if (userlen > 64) {
                 ^
  199.           X509V3err(X509V3_F_SXNET_ADD_ID_INTEGER, X509V3_R_USER_TOO_LONG);
  200.           return 0;

crypto/x509v3/v3_sxnet.c:199:9: Skipping ERR_put_error(): empty list of specs
  197.           userlen = strlen(user);
  198.       if (userlen > 64) {
  199.           X509V3err(X509V3_F_SXNET_ADD_ID_INTEGER, X509V3_R_USER_TOO_LONG);
                 ^
  200.           return 0;
  201.       }

crypto/x509v3/v3_sxnet.c:200:9: 
  198.       if (userlen > 64) {
  199.           X509V3err(X509V3_F_SXNET_ADD_ID_INTEGER, X509V3_R_USER_TOO_LONG);
  200. >         return 0;
  201.       }
  202.       if (*psx == NULL) {

crypto/x509v3/v3_sxnet.c:233:1: return from a call to SXNET_add_id_INTEGER
  231.       *psx = NULL;
  232.       return 0;
  233. > }
  234.   
  235.   ASN1_OCTET_STRING *SXNET_get_id_asc(SXNET *sx, char *zone)

int SXNET_add_id_ulong(SXNET **psx, unsigned long lzone, char *user,
                       int userlen)
{
    ASN1_INTEGER *izone;
    if ((izone = ASN1_INTEGER_new()) == NULL
        || !ASN1_INTEGER_set(izone, lzone)) {
        X509V3err(X509V3_F_SXNET_ADD_ID_ULONG, ERR_R_MALLOC_FAILURE);
        ASN1_INTEGER_free(izone);
        return 0;
    }
    return SXNET_add_id_INTEGER(psx, izone, user, userlen);
}
['int SXNET_add_id_ulong(SXNET **psx, unsigned long lzone, char *user,\n                       int userlen)\n{\n    ASN1_INTEGER *izone;\n    if ((izone = ASN1_INTEGER_new()) == NULL\n        || !ASN1_INTEGER_set(izone, lzone)) {\n        X509V3err(X509V3_F_SXNET_ADD_ID_ULONG, ERR_R_MALLOC_FAILURE);\n        ASN1_INTEGER_free(izone);\n        return 0;\n    }\n    return SXNET_add_id_INTEGER(psx, izone, user, userlen);\n}', 'IMPLEMENT_ASN1_STRING_FUNCTIONS(ASN1_INTEGER)', 'ASN1_STRING *ASN1_STRING_type_new(int type)\n{\n    ASN1_STRING *ret;\n    ret = OPENSSL_zalloc(sizeof(*ret));\n    if (ret == NULL) {\n        ASN1err(ASN1_F_ASN1_STRING_TYPE_NEW, ERR_R_MALLOC_FAILURE);\n        return (NULL);\n    }\n    ret->type = type;\n    return (ret);\n}', 'void *CRYPTO_zalloc(size_t num, const char *file, int line)\n{\n    void *ret = CRYPTO_malloc(num, file, line);\n    if (ret != NULL)\n        memset(ret, 0, num);\n    return ret;\n}', 'void *CRYPTO_malloc(size_t num, const char *file, int line)\n{\n    void *ret = NULL;\n    if (num <= 0)\n        return NULL;\n    allow_customize = 0;\n#ifndef OPENSSL_NO_CRYPTO_MDEBUG\n    if (call_malloc_debug) {\n        CRYPTO_mem_debug_malloc(NULL, num, 0, file, line);\n        ret = malloc(num);\n        CRYPTO_mem_debug_malloc(ret, num, 1, file, line);\n    } else {\n        ret = malloc(num);\n    }\n#else\n    (void)file;\n    (void)line;\n    ret = malloc(num);\n#endif\n#ifndef OPENSSL_CPUID_OBJ\n    if (ret && (num > 2048)) {\n        extern unsigned char cleanse_ctr;\n        ((unsigned char *)ret)[0] = cleanse_ctr;\n    }\n#endif\n    return ret;\n}', 'int ASN1_INTEGER_set(ASN1_INTEGER *a, long v)\n{\n    return ASN1_INTEGER_set_int64(a, v);\n}', 'int ASN1_INTEGER_set_int64(ASN1_INTEGER *a, int64_t r)\n{\n    return asn1_string_set_int64(a, r, V_ASN1_INTEGER);\n}', 'static int asn1_string_set_int64(ASN1_STRING *a, int64_t r, int itype)\n{\n    unsigned char tbuf[sizeof(r)];\n    size_t l;\n    a->type = itype;\n    if (r < 0) {\n        l = asn1_put_uint64(tbuf, -r);\n        a->type |= V_ASN1_NEG;\n    } else {\n        l = asn1_put_uint64(tbuf, r);\n        a->type &= ~V_ASN1_NEG;\n    }\n    if (l == 0)\n        return 0;\n    return ASN1_STRING_set(a, tbuf, l);\n}', 'static size_t asn1_put_uint64(unsigned char *b, uint64_t r)\n{\n    if (r >= 0x100) {\n        unsigned char *p;\n        uint64_t rtmp = r;\n        size_t i = 0;\n        while (rtmp) {\n            rtmp >>= 8;\n            i++;\n        }\n        p = b + i - 1;\n        do {\n            *p-- = r & 0xFF;\n            r >>= 8;\n        } while (p >= b);\n        return i;\n    }\n    b[0] = (unsigned char)r;\n    return 1;\n}', "int ASN1_STRING_set(ASN1_STRING *str, const void *_data, int len)\n{\n    unsigned char *c;\n    const char *data = _data;\n    if (len < 0) {\n        if (data == NULL)\n            return (0);\n        else\n            len = strlen(data);\n    }\n    if ((str->length < len) || (str->data == NULL)) {\n        c = str->data;\n        str->data = OPENSSL_realloc(c, len + 1);\n        if (str->data == NULL) {\n            ASN1err(ASN1_F_ASN1_STRING_SET, ERR_R_MALLOC_FAILURE);\n            str->data = c;\n            return (0);\n        }\n    }\n    str->length = len;\n    if (data != NULL) {\n        memcpy(str->data, data, len);\n        str->data[len] = '\\0';\n    }\n    return (1);\n}", 'void *CRYPTO_realloc(void *str, size_t num, const char *file, int line)\n{\n    if (str == NULL)\n        return CRYPTO_malloc(num, file, line);\n    if (num == 0) {\n        CRYPTO_free(str);\n        return NULL;\n    }\n    allow_customize = 0;\n#ifndef OPENSSL_NO_CRYPTO_MDEBUG\n    if (call_malloc_debug) {\n        void *ret;\n        CRYPTO_mem_debug_realloc(str, NULL, num, 0, file, line);\n        ret = realloc(str, num);\n        CRYPTO_mem_debug_realloc(str, ret, num, 1, file, line);\n        return ret;\n    }\n#else\n    (void)file;\n    (void)line;\n#endif\n    return realloc(str, num);\n}', 'int SXNET_add_id_INTEGER(SXNET **psx, ASN1_INTEGER *zone, char *user,\n                         int userlen)\n{\n    SXNET *sx = NULL;\n    SXNETID *id = NULL;\n    if (!psx || !zone || !user) {\n        X509V3err(X509V3_F_SXNET_ADD_ID_INTEGER,\n                  X509V3_R_INVALID_NULL_ARGUMENT);\n        return 0;\n    }\n    if (userlen == -1)\n        userlen = strlen(user);\n    if (userlen > 64) {\n        X509V3err(X509V3_F_SXNET_ADD_ID_INTEGER, X509V3_R_USER_TOO_LONG);\n        return 0;\n    }\n    if (*psx == NULL) {\n        if ((sx = SXNET_new()) == NULL)\n            goto err;\n        if (!ASN1_INTEGER_set(sx->version, 0))\n            goto err;\n        *psx = sx;\n    } else\n        sx = *psx;\n    if (SXNET_get_id_INTEGER(sx, zone)) {\n        X509V3err(X509V3_F_SXNET_ADD_ID_INTEGER, X509V3_R_DUPLICATE_ZONE_ID);\n        return 0;\n    }\n    if ((id = SXNETID_new()) == NULL)\n        goto err;\n    if (userlen == -1)\n        userlen = strlen(user);\n    if (!ASN1_OCTET_STRING_set(id->user, (unsigned char *)user, userlen))\n        goto err;\n    if (!sk_SXNETID_push(sx->ids, id))\n        goto err;\n    id->zone = zone;\n    return 1;\n err:\n    X509V3err(X509V3_F_SXNET_ADD_ID_INTEGER, ERR_R_MALLOC_FAILURE);\n    SXNETID_free(id);\n    SXNET_free(sx);\n    *psx = NULL;\n    return 0;\n}']