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


crypto/x509v3/v3_sxnet.c:250:1: start of procedure SXNET_get_id_ulong()
248.   }
249.   
250. > ASN1_OCTET_STRING *SXNET_get_id_ulong(SXNET *sx, unsigned long lzone)
251.   {
252.       ASN1_INTEGER *izone;

crypto/x509v3/v3_sxnet.c:255:9: 
253.       ASN1_OCTET_STRING *oct;
254.   
255. >     if ((izone = ASN1_INTEGER_new()) == NULL
256.           || !ASN1_INTEGER_set(izone, lzone)) {
257.           X509V3err(X509V3_F_SXNET_GET_ID_ULONG, ERR_R_MALLOC_FAILURE);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

crypto/x509v3/v3_sxnet.c:255:9: Taking false branch
253.       ASN1_OCTET_STRING *oct;
254.   
255.       if ((izone = ASN1_INTEGER_new()) == NULL
               ^
256.           || !ASN1_INTEGER_set(izone, lzone)) {
257.           X509V3err(X509V3_F_SXNET_GET_ID_ULONG, ERR_R_MALLOC_FAILURE);

crypto/x509v3/v3_sxnet.c:256:13: 
254.   
255.       if ((izone = ASN1_INTEGER_new()) == NULL
256. >         || !ASN1_INTEGER_set(izone, lzone)) {
257.           X509V3err(X509V3_F_SXNET_GET_ID_ULONG, ERR_R_MALLOC_FAILURE);
258.           ASN1_INTEGER_free(izone);

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

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

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

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

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

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

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

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

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

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

crypto/asn1/a_int.c:316:5: 
        314.       }
        315.   
        316. >     b[0] = (unsigned char)r;
        317.       return 1;
        318.   

crypto/asn1/a_int.c:317:5: 
        315.   
        316.       b[0] = (unsigned char)r;
        317. >     return 1;
        318.   
        319.   }

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

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

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

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

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

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

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

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

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

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

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

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

crypto/mem.c:171:9: Taking false branch
          169.           return CRYPTO_malloc(num, file, line);
          170.   
          171.       if (num == 0) {
                         ^
          172.           CRYPTO_free(str);
          173.           return NULL;

crypto/mem.c:176:5: 
          174.       }
          175.   
          176. >     allow_customize = 0;
          177.   #ifndef OPENSSL_NO_CRYPTO_MDEBUG
          178.       if (call_malloc_debug) {

crypto/mem.c:186:5: 
          184.       }
          185.   #else
          186. >     (void)file;
          187.       (void)line;
          188.   #endif

crypto/mem.c:187:5: 
          185.   #else
          186.       (void)file;
          187. >     (void)line;
          188.   #endif
          189.       return realloc(str, num);

crypto/mem.c:189:5: 
          187.       (void)line;
          188.   #endif
          189. >     return realloc(str, num);
          190.   
          191.   }

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

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

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

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

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

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

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

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

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

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

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

crypto/x509v3/v3_sxnet.c:256:13: Taking false branch
254.   
255.       if ((izone = ASN1_INTEGER_new()) == NULL
256.           || !ASN1_INTEGER_set(izone, lzone)) {
                   ^
257.           X509V3err(X509V3_F_SXNET_GET_ID_ULONG, ERR_R_MALLOC_FAILURE);
258.           ASN1_INTEGER_free(izone);

crypto/x509v3/v3_sxnet.c:261:5: 
259.           return NULL;
260.       }
261. >     oct = SXNET_get_id_INTEGER(sx, izone);
262.       ASN1_INTEGER_free(izone);
263.       return oct;

crypto/x509v3/v3_sxnet.c:266:1: start of procedure SXNET_get_id_INTEGER()
  264.   }
  265.   
  266. > ASN1_OCTET_STRING *SXNET_get_id_INTEGER(SXNET *sx, ASN1_INTEGER *zone)
  267.   {
  268.       SXNETID *id;

crypto/x509v3/v3_sxnet.c:270:10: 
  268.       SXNETID *id;
  269.       int i;
  270. >     for (i = 0; i < sk_SXNETID_num(sx->ids); i++) {
  271.           id = sk_SXNETID_value(sx->ids, i);
  272.           if (!ASN1_INTEGER_cmp(id->zone, zone))

crypto/x509v3/v3_sxnet.c:270:17: 
  268.       SXNETID *id;
  269.       int i;
  270. >     for (i = 0; i < sk_SXNETID_num(sx->ids); i++) {
  271.           id = sk_SXNETID_value(sx->ids, i);
  272.           if (!ASN1_INTEGER_cmp(id->zone, zone))

include/openssl/x509v3.h:274:1: start of procedure sk_SXNETID_num()
    272.   } SXNETID;
    273.   
    274. > DEFINE_STACK_OF(SXNETID)
    275.   
    276.   typedef struct SXNET_st {

crypto/stack/stack.c:317:1: start of procedure sk_num()
      315.   }
      316.   
      317. > int sk_num(const _STACK *st)
      318.   {
      319.       if (st == NULL)

crypto/stack/stack.c:319:9: Taking true branch
      317.   int sk_num(const _STACK *st)
      318.   {
      319.       if (st == NULL)
                     ^
      320.           return -1;
      321.       return st->num;

crypto/stack/stack.c:320:9: 
      318.   {
      319.       if (st == NULL)
      320. >         return -1;
      321.       return st->num;
      322.   }

crypto/stack/stack.c:322:1: return from a call to sk_num
      320.           return -1;
      321.       return st->num;
      322. > }
      323.   
      324.   void *sk_value(const _STACK *st, int i)

include/openssl/x509v3.h:274:1: return from a call to sk_SXNETID_num
    272.   } SXNETID;
    273.   
    274. > DEFINE_STACK_OF(SXNETID)
    275.   
    276.   typedef struct SXNET_st {

crypto/x509v3/v3_sxnet.c:270:17: Loop condition is false. Leaving loop
  268.       SXNETID *id;
  269.       int i;
  270.       for (i = 0; i < sk_SXNETID_num(sx->ids); i++) {
                         ^
  271.           id = sk_SXNETID_value(sx->ids, i);
  272.           if (!ASN1_INTEGER_cmp(id->zone, zone))

crypto/x509v3/v3_sxnet.c:275:5: 
  273.               return id->user;
  274.       }
  275. >     return NULL;
  276.   }

crypto/x509v3/v3_sxnet.c:276:1: return from a call to SXNET_get_id_INTEGER
  274.       }
  275.       return NULL;
  276. > }

crypto/x509v3/v3_sxnet.c:262:5: 
260.       }
261.       oct = SXNET_get_id_INTEGER(sx, izone);
262. >     ASN1_INTEGER_free(izone);
263.       return oct;
264.   }

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

crypto/asn1/asn1_lib.c:362:1: start of procedure ASN1_STRING_free()
    360.   }
    361.   
    362. > void ASN1_STRING_free(ASN1_STRING *a)
    363.   {
    364.       if (a == NULL)

crypto/asn1/asn1_lib.c:364:9: Taking false branch
    362.   void ASN1_STRING_free(ASN1_STRING *a)
    363.   {
    364.       if (a == NULL)
                   ^
    365.           return;
    366.       if (!(a->flags & ASN1_STRING_FLAG_NDEF))

crypto/asn1/asn1_lib.c:366:11: Taking false branch
    364.       if (a == NULL)
    365.           return;
    366.       if (!(a->flags & ASN1_STRING_FLAG_NDEF))
                     ^
    367.           OPENSSL_free(a->data);
    368.       if (!(a->flags & ASN1_STRING_FLAG_EMBED))

crypto/asn1/asn1_lib.c:368:11: Taking false branch
    366.       if (!(a->flags & ASN1_STRING_FLAG_NDEF))
    367.           OPENSSL_free(a->data);
    368.       if (!(a->flags & ASN1_STRING_FLAG_EMBED))
                     ^
    369.           OPENSSL_free(a);
    370.   }

crypto/asn1/asn1_lib.c:368:5: 
    366.       if (!(a->flags & ASN1_STRING_FLAG_NDEF))
    367.           OPENSSL_free(a->data);
    368. >     if (!(a->flags & ASN1_STRING_FLAG_EMBED))
    369.           OPENSSL_free(a);
    370.   }

crypto/asn1/asn1_lib.c:370:1: return from a call to ASN1_STRING_free
    368.       if (!(a->flags & ASN1_STRING_FLAG_EMBED))
    369.           OPENSSL_free(a);
    370. > }
    371.   
    372.   void ASN1_STRING_clear_free(ASN1_STRING *a)

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