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


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

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

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

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

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

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

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

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

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

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 true branch
  310.       const char *data = _data;
  311.   
  312.       if (len < 0) {
                 ^
  313.           if (data == NULL)
  314.               return (0);

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

crypto/asn1/asn1_lib.c:316:13: 
  314.               return (0);
  315.           else
  316. >             len = strlen(data);
  317.       }
  318.       if ((str->length < len) || (str->data == NULL)) {

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 false 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:170:9: Taking false branch
    168.           return CRYPTO_malloc(num, file, line);
    169.   
    170.       if (num == 0) {
                   ^
    171.           CRYPTO_free(str);
    172.           return NULL;

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

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

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

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

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

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

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

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