crypto/asn1/a_time.c:129: error: MEMORY_LEAK
  memory dynamically allocated to `return` by call to `ASN1_GENERALIZEDTIME_new()` at line 119, column 20 is not reachable after line 129, column 13.
Showing all 60 steps of the trace


crypto/asn1/a_time.c:108:1: start of procedure ASN1_TIME_to_generalizedtime()
106.   
107.   /* Convert an ASN1_TIME structure to GeneralizedTime */
108. > ASN1_GENERALIZEDTIME *ASN1_TIME_to_generalizedtime(ASN1_TIME *t,
109.                                                      ASN1_GENERALIZEDTIME **out)
110.   {

crypto/asn1/a_time.c:115:10: 
113.       int newlen;
114.   
115. >     if (!ASN1_TIME_check(t))
116.           return NULL;
117.   

crypto/asn1/a_time.c:98:1: start of procedure ASN1_TIME_check()
  96.   }
  97.   
  98. > int ASN1_TIME_check(const ASN1_TIME *t)
  99.   {
  100.       if (t->type == V_ASN1_GENERALIZEDTIME)

crypto/asn1/a_time.c:100:9: Taking true branch
  98.   int ASN1_TIME_check(const ASN1_TIME *t)
  99.   {
  100.       if (t->type == V_ASN1_GENERALIZEDTIME)
                 ^
  101.           return ASN1_GENERALIZEDTIME_check(t);
  102.       else if (t->type == V_ASN1_UTCTIME)

crypto/asn1/a_time.c:101:9: 
  99.   {
  100.       if (t->type == V_ASN1_GENERALIZEDTIME)
  101. >         return ASN1_GENERALIZEDTIME_check(t);
  102.       else if (t->type == V_ASN1_UTCTIME)
  103.           return ASN1_UTCTIME_check(t);

crypto/asn1/a_gentm.c:185:1: start of procedure ASN1_GENERALIZEDTIME_check()
    183.   }
    184.   
    185. > int ASN1_GENERALIZEDTIME_check(const ASN1_GENERALIZEDTIME *d)
    186.   {
    187.       return asn1_generalizedtime_to_tm(NULL, d);

crypto/asn1/a_gentm.c:187:5: Skipping asn1_generalizedtime_to_tm(): empty list of specs
    185.   int ASN1_GENERALIZEDTIME_check(const ASN1_GENERALIZEDTIME *d)
    186.   {
    187.       return asn1_generalizedtime_to_tm(NULL, d);
               ^
    188.   }
    189.   

crypto/asn1/a_gentm.c:188:1: return from a call to ASN1_GENERALIZEDTIME_check
    186.   {
    187.       return asn1_generalizedtime_to_tm(NULL, d);
    188. > }
    189.   
    190.   int ASN1_GENERALIZEDTIME_set_string(ASN1_GENERALIZEDTIME *s, const char *str)

crypto/asn1/a_time.c:105:1: return from a call to ASN1_TIME_check
  103.           return ASN1_UTCTIME_check(t);
  104.       return 0;
  105. > }
  106.   
  107.   /* Convert an ASN1_TIME structure to GeneralizedTime */

crypto/asn1/a_time.c:115:10: Taking false branch
113.       int newlen;
114.   
115.       if (!ASN1_TIME_check(t))
                ^
116.           return NULL;
117.   

crypto/asn1/a_time.c:118:9: Taking true branch
116.           return NULL;
117.   
118.       if (out == NULL || *out == NULL) {
               ^
119.           if ((ret = ASN1_GENERALIZEDTIME_new()) == NULL)
120.               return NULL;

crypto/asn1/a_time.c:119:13: 
117.   
118.       if (out == NULL || *out == NULL) {
119. >         if ((ret = ASN1_GENERALIZEDTIME_new()) == NULL)
120.               return NULL;
121.           if (out)

crypto/asn1/tasn_typ.c:86:1: start of procedure ASN1_GENERALIZEDTIME_new()
  84.   IMPLEMENT_ASN1_STRING_FUNCTIONS(ASN1_GENERALSTRING)
  85.   IMPLEMENT_ASN1_STRING_FUNCTIONS(ASN1_UTCTIME)
  86. > IMPLEMENT_ASN1_STRING_FUNCTIONS(ASN1_GENERALIZEDTIME)
  87.   IMPLEMENT_ASN1_STRING_FUNCTIONS(ASN1_VISIBLESTRING)
  88.   IMPLEMENT_ASN1_STRING_FUNCTIONS(ASN1_UNIVERSALSTRING)

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:86:1: return from a call to ASN1_GENERALIZEDTIME_new
  84.   IMPLEMENT_ASN1_STRING_FUNCTIONS(ASN1_GENERALSTRING)
  85.   IMPLEMENT_ASN1_STRING_FUNCTIONS(ASN1_UTCTIME)
  86. > IMPLEMENT_ASN1_STRING_FUNCTIONS(ASN1_GENERALIZEDTIME)
  87.   IMPLEMENT_ASN1_STRING_FUNCTIONS(ASN1_VISIBLESTRING)
  88.   IMPLEMENT_ASN1_STRING_FUNCTIONS(ASN1_UNIVERSALSTRING)

crypto/asn1/a_time.c:119:13: Taking false branch
117.   
118.       if (out == NULL || *out == NULL) {
119.           if ((ret = ASN1_GENERALIZEDTIME_new()) == NULL)
                   ^
120.               return NULL;
121.           if (out)

crypto/asn1/a_time.c:121:13: Taking false branch
119.           if ((ret = ASN1_GENERALIZEDTIME_new()) == NULL)
120.               return NULL;
121.           if (out)
                   ^
122.               *out = ret;
123.       } else

crypto/asn1/a_time.c:127:9: Taking true branch
125.   
126.       /* If already GeneralizedTime just copy across */
127.       if (t->type == V_ASN1_GENERALIZEDTIME) {
               ^
128.           if (!ASN1_STRING_set(ret, t->data, t->length))
129.               return NULL;

crypto/asn1/a_time.c:128:14: 
126.       /* If already GeneralizedTime just copy across */
127.       if (t->type == V_ASN1_GENERALIZEDTIME) {
128. >         if (!ASN1_STRING_set(ret, t->data, t->length))
129.               return NULL;
130.           return ret;

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 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 true 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:322:13: Skipping ERR_put_error(): empty list of specs
  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;
  324.               return (0);

crypto/asn1/asn1_lib.c:323:13: 
  321.           if (str->data == NULL) {
  322.               ASN1err(ASN1_F_ASN1_STRING_SET, ERR_R_MALLOC_FAILURE);
  323. >             str->data = c;
  324.               return (0);
  325.           }

crypto/asn1/asn1_lib.c:324:13: 
  322.               ASN1err(ASN1_F_ASN1_STRING_SET, ERR_R_MALLOC_FAILURE);
  323.               str->data = c;
  324. >             return (0);
  325.           }
  326.       }

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_time.c:128:14: Taking true branch
126.       /* If already GeneralizedTime just copy across */
127.       if (t->type == V_ASN1_GENERALIZEDTIME) {
128.           if (!ASN1_STRING_set(ret, t->data, t->length))
                    ^
129.               return NULL;
130.           return ret;

crypto/asn1/a_time.c:129:13: 
127.       if (t->type == V_ASN1_GENERALIZEDTIME) {
128.           if (!ASN1_STRING_set(ret, t->data, t->length))
129. >             return NULL;
130.           return ret;
131.       }

ASN1_GENERALIZEDTIME *ASN1_TIME_to_generalizedtime(ASN1_TIME *t,
                                                   ASN1_GENERALIZEDTIME **out)
{
    ASN1_GENERALIZEDTIME *ret;
    char *str;
    int newlen;
    if (!ASN1_TIME_check(t))
        return NULL;
    if (out == NULL || *out == NULL) {
        if ((ret = ASN1_GENERALIZEDTIME_new()) == NULL)
            return NULL;
        if (out)
            *out = ret;
    } else
        ret = *out;
    if (t->type == V_ASN1_GENERALIZEDTIME) {
        if (!ASN1_STRING_set(ret, t->data, t->length))
            return NULL;
        return ret;
    }
    if (!ASN1_STRING_set(ret, NULL, t->length + 2))
        return NULL;
    newlen = t->length + 2 + 1;
    str = (char *)ret->data;
    if (t->data[0] >= '5')
        OPENSSL_strlcpy(str, "19", newlen);
    else
        OPENSSL_strlcpy(str, "20", newlen);
    OPENSSL_strlcat(str, (char *)t->data, newlen);
    return ret;
}
['ASN1_GENERALIZEDTIME *ASN1_TIME_to_generalizedtime(ASN1_TIME *t,\n                                                   ASN1_GENERALIZEDTIME **out)\n{\n    ASN1_GENERALIZEDTIME *ret;\n    char *str;\n    int newlen;\n    if (!ASN1_TIME_check(t))\n        return NULL;\n    if (out == NULL || *out == NULL) {\n        if ((ret = ASN1_GENERALIZEDTIME_new()) == NULL)\n            return NULL;\n        if (out)\n            *out = ret;\n    } else\n        ret = *out;\n    if (t->type == V_ASN1_GENERALIZEDTIME) {\n        if (!ASN1_STRING_set(ret, t->data, t->length))\n            return NULL;\n        return ret;\n    }\n    if (!ASN1_STRING_set(ret, NULL, t->length + 2))\n        return NULL;\n    newlen = t->length + 2 + 1;\n    str = (char *)ret->data;\n    if (t->data[0] >= \'5\')\n        OPENSSL_strlcpy(str, "19", newlen);\n    else\n        OPENSSL_strlcpy(str, "20", newlen);\n    OPENSSL_strlcat(str, (char *)t->data, newlen);\n    return ret;\n}', 'int ASN1_TIME_check(const ASN1_TIME *t)\n{\n    if (t->type == V_ASN1_GENERALIZEDTIME)\n        return ASN1_GENERALIZEDTIME_check(t);\n    else if (t->type == V_ASN1_UTCTIME)\n        return ASN1_UTCTIME_check(t);\n    return 0;\n}', 'int ASN1_GENERALIZEDTIME_check(const ASN1_GENERALIZEDTIME *d)\n{\n    return asn1_generalizedtime_to_tm(NULL, d);\n}', 'IMPLEMENT_ASN1_STRING_FUNCTIONS(ASN1_GENERALIZEDTIME)', '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_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}']