crypto/x509/x509_att.c:324: error: MEMORY_LEAK
  memory dynamically allocated to `return` by call to `ASN1_STRING_type_new()` at line 312, column 21 is not reachable after line 324, column 9.
Showing all 55 steps of the trace


crypto/x509/x509_att.c:295:1: start of procedure X509_ATTRIBUTE_set1_data()
293.   }
294.   
295. > int X509_ATTRIBUTE_set1_data(X509_ATTRIBUTE *attr, int attrtype,
296.                                const void *data, int len)
297.   {

crypto/x509/x509_att.c:299:5: 
297.   {
298.       ASN1_TYPE *ttmp;
299. >     ASN1_STRING *stmp = NULL;
300.       int atype = 0;
301.       if (!attr)

crypto/x509/x509_att.c:300:5: 
298.       ASN1_TYPE *ttmp;
299.       ASN1_STRING *stmp = NULL;
300. >     int atype = 0;
301.       if (!attr)
302.           return 0;

crypto/x509/x509_att.c:301:10: Taking false branch
299.       ASN1_STRING *stmp = NULL;
300.       int atype = 0;
301.       if (!attr)
                ^
302.           return 0;
303.       if (attrtype & MBSTRING_FLAG) {

crypto/x509/x509_att.c:303:9: Taking false branch
301.       if (!attr)
302.           return 0;
303.       if (attrtype & MBSTRING_FLAG) {
               ^
304.           stmp = ASN1_STRING_set_by_NID(NULL, data, len, attrtype,
305.                                         OBJ_obj2nid(attr->object));

crypto/x509/x509_att.c:311:16: Taking true branch
309.           }
310.           atype = stmp->type;
311.       } else if (len != -1) {
                      ^
312.           if ((stmp = ASN1_STRING_type_new(attrtype)) == NULL)
313.               goto err;

crypto/x509/x509_att.c:312:13: 
310.           atype = stmp->type;
311.       } else if (len != -1) {
312. >         if ((stmp = ASN1_STRING_type_new(attrtype)) == NULL)
313.               goto err;
314.           if (!ASN1_STRING_set(stmp, data, len))

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.   #ifdef 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/x509/x509_att.c:312:13: Taking false branch
310.           atype = stmp->type;
311.       } else if (len != -1) {
312.           if ((stmp = ASN1_STRING_type_new(attrtype)) == NULL)
                   ^
313.               goto err;
314.           if (!ASN1_STRING_set(stmp, data, len))

crypto/x509/x509_att.c:314:14: 
312.           if ((stmp = ASN1_STRING_type_new(attrtype)) == NULL)
313.               goto err;
314. >         if (!ASN1_STRING_set(stmp, data, len))
315.               goto err;
316.           atype = attrtype;

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.   #ifdef 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/x509/x509_att.c:314:14: Taking false branch
312.           if ((stmp = ASN1_STRING_type_new(attrtype)) == NULL)
313.               goto err;
314.           if (!ASN1_STRING_set(stmp, data, len))
                    ^
315.               goto err;
316.           atype = attrtype;

crypto/x509/x509_att.c:316:9: 
314.           if (!ASN1_STRING_set(stmp, data, len))
315.               goto err;
316. >         atype = attrtype;
317.       }
318.       /*

crypto/x509/x509_att.c:323:9: Taking true branch
321.        * this.
322.        */
323.       if (attrtype == 0)
               ^
324.           return 1;
325.       if ((ttmp = ASN1_TYPE_new()) == NULL)

crypto/x509/x509_att.c:324:9: 
322.        */
323.       if (attrtype == 0)
324. >         return 1;
325.       if ((ttmp = ASN1_TYPE_new()) == NULL)
326.           goto err;
