crypto/x509v3/v3_utl.c:1131: error: MEMORY_LEAK
  memory dynamically allocated by call to `ASN1_OCTET_STRING_new()` at line 1121, column 11 is not reachable after line 1131, column 5.
Showing all 143 steps of the trace


crypto/x509v3/v3_utl.c:1093:1: start of procedure a2i_IPADDRESS_NC()
1091.   }
1092.   
1093. > ASN1_OCTET_STRING *a2i_IPADDRESS_NC(const char *ipasc)
1094.   {
1095.       ASN1_OCTET_STRING *ret = NULL;

crypto/x509v3/v3_utl.c:1095:5: 
1093.   ASN1_OCTET_STRING *a2i_IPADDRESS_NC(const char *ipasc)
1094.   {
1095. >     ASN1_OCTET_STRING *ret = NULL;
1096.       unsigned char ipout[32];
1097.       char *iptmp = NULL, *p;

crypto/x509v3/v3_utl.c:1097:5: 
1095.       ASN1_OCTET_STRING *ret = NULL;
1096.       unsigned char ipout[32];
1097. >     char *iptmp = NULL, *p;
1098.       int iplen1, iplen2;
1099.       p = strchr(ipasc, '/');

crypto/x509v3/v3_utl.c:1099:5: 
1097.       char *iptmp = NULL, *p;
1098.       int iplen1, iplen2;
1099. >     p = strchr(ipasc, '/');
1100.       if (!p)
1101.           return NULL;

crypto/x509v3/v3_utl.c:1100:10: Taking false branch
1098.       int iplen1, iplen2;
1099.       p = strchr(ipasc, '/');
1100.       if (!p)
                 ^
1101.           return NULL;
1102.       iptmp = OPENSSL_strdup(ipasc);

crypto/x509v3/v3_utl.c:1102:5: 
1100.       if (!p)
1101.           return NULL;
1102. >     iptmp = OPENSSL_strdup(ipasc);
1103.       if (!iptmp)
1104.           return NULL;

crypto/o_str.c:120:1: start of procedure CRYPTO_strdup()
  118.   }
  119.   
  120. > char *CRYPTO_strdup(const char *str, const char* file, int line)
  121.   {
  122.       char *ret;

crypto/o_str.c:125:9: Taking false branch
  123.       size_t size;
  124.   
  125.       if (str == NULL)
                 ^
  126.           return NULL;
  127.       size = strlen(str) + 1;

crypto/o_str.c:127:5: 
  125.       if (str == NULL)
  126.           return NULL;
  127. >     size = strlen(str) + 1;
  128.       ret = CRYPTO_malloc(size, file, line);
  129.       if (ret != NULL)

crypto/o_str.c:128:5: 
  126.           return NULL;
  127.       size = strlen(str) + 1;
  128. >     ret = CRYPTO_malloc(size, file, line);
  129.       if (ret != NULL)
  130.           memcpy(ret, str, size);

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/o_str.c:129:9: Taking true branch
  127.       size = strlen(str) + 1;
  128.       ret = CRYPTO_malloc(size, file, line);
  129.       if (ret != NULL)
                 ^
  130.           memcpy(ret, str, size);
  131.       return ret;

crypto/o_str.c:130:9: 
  128.       ret = CRYPTO_malloc(size, file, line);
  129.       if (ret != NULL)
  130. >         memcpy(ret, str, size);
  131.       return ret;
  132.   }

crypto/o_str.c:131:5: 
  129.       if (ret != NULL)
  130.           memcpy(ret, str, size);
  131. >     return ret;
  132.   }
  133.   

crypto/o_str.c:132:1: return from a call to CRYPTO_strdup
  130.           memcpy(ret, str, size);
  131.       return ret;
  132. > }
  133.   
  134.   char *CRYPTO_strndup(const char *str, size_t s, const char* file, int line)

crypto/x509v3/v3_utl.c:1103:10: Taking false branch
1101.           return NULL;
1102.       iptmp = OPENSSL_strdup(ipasc);
1103.       if (!iptmp)
                 ^
1104.           return NULL;
1105.       p = iptmp + (p - ipasc);

crypto/x509v3/v3_utl.c:1105:5: 
1103.       if (!iptmp)
1104.           return NULL;
1105. >     p = iptmp + (p - ipasc);
1106.       *p++ = 0;
1107.   

crypto/x509v3/v3_utl.c:1106:5: 
1104.           return NULL;
1105.       p = iptmp + (p - ipasc);
1106. >     *p++ = 0;
1107.   
1108.       iplen1 = a2i_ipadd(ipout, iptmp);

crypto/x509v3/v3_utl.c:1108:5: 
1106.       *p++ = 0;
1107.   
1108. >     iplen1 = a2i_ipadd(ipout, iptmp);
1109.   
1110.       if (!iplen1)

crypto/x509v3/v3_utl.c:1135:1: start of procedure a2i_ipadd()
  1133.   }
  1134.   
  1135. > int a2i_ipadd(unsigned char *ipout, const char *ipasc)
  1136.   {
  1137.       /* If string contains a ':' assume IPv6 */

crypto/x509v3/v3_utl.c:1139:9: Taking false branch
  1137.       /* If string contains a ':' assume IPv6 */
  1138.   
  1139.       if (strchr(ipasc, ':')) {
                  ^
  1140.           if (!ipv6_from_asc(ipout, ipasc))
  1141.               return 0;

crypto/x509v3/v3_utl.c:1144:14: 
  1142.           return 16;
  1143.       } else {
  1144. >         if (!ipv4_from_asc(ipout, ipasc))
  1145.               return 0;
  1146.           return 4;

crypto/x509v3/v3_utl.c:1150:1: start of procedure ipv4_from_asc()
    1148.   }
    1149.   
    1150. > static int ipv4_from_asc(unsigned char *v4, const char *in)
    1151.   {
    1152.       int a0, a1, a2, a3;

crypto/x509v3/v3_utl.c:1153:9: Taking false branch
    1151.   {
    1152.       int a0, a1, a2, a3;
    1153.       if (sscanf(in, "%d.%d.%d.%d", &a0, &a1, &a2, &a3) != 4)
                    ^
    1154.           return 0;
    1155.       if ((a0 < 0) || (a0 > 255) || (a1 < 0) || (a1 > 255)

crypto/x509v3/v3_utl.c:1155:10: Taking false branch
    1153.       if (sscanf(in, "%d.%d.%d.%d", &a0, &a1, &a2, &a3) != 4)
    1154.           return 0;
    1155.       if ((a0 < 0) || (a0 > 255) || (a1 < 0) || (a1 > 255)
                     ^
    1156.           || (a2 < 0) || (a2 > 255) || (a3 < 0) || (a3 > 255))
    1157.           return 0;

crypto/x509v3/v3_utl.c:1155:22: Taking false branch
    1153.       if (sscanf(in, "%d.%d.%d.%d", &a0, &a1, &a2, &a3) != 4)
    1154.           return 0;
    1155.       if ((a0 < 0) || (a0 > 255) || (a1 < 0) || (a1 > 255)
                                 ^
    1156.           || (a2 < 0) || (a2 > 255) || (a3 < 0) || (a3 > 255))
    1157.           return 0;

crypto/x509v3/v3_utl.c:1155:36: Taking false branch
    1153.       if (sscanf(in, "%d.%d.%d.%d", &a0, &a1, &a2, &a3) != 4)
    1154.           return 0;
    1155.       if ((a0 < 0) || (a0 > 255) || (a1 < 0) || (a1 > 255)
                                               ^
    1156.           || (a2 < 0) || (a2 > 255) || (a3 < 0) || (a3 > 255))
    1157.           return 0;

crypto/x509v3/v3_utl.c:1155:48: Taking false branch
    1153.       if (sscanf(in, "%d.%d.%d.%d", &a0, &a1, &a2, &a3) != 4)
    1154.           return 0;
    1155.       if ((a0 < 0) || (a0 > 255) || (a1 < 0) || (a1 > 255)
                                                           ^
    1156.           || (a2 < 0) || (a2 > 255) || (a3 < 0) || (a3 > 255))
    1157.           return 0;

crypto/x509v3/v3_utl.c:1156:13: Taking false branch
    1154.           return 0;
    1155.       if ((a0 < 0) || (a0 > 255) || (a1 < 0) || (a1 > 255)
    1156.           || (a2 < 0) || (a2 > 255) || (a3 < 0) || (a3 > 255))
                        ^
    1157.           return 0;
    1158.       v4[0] = a0;

crypto/x509v3/v3_utl.c:1156:25: Taking false branch
    1154.           return 0;
    1155.       if ((a0 < 0) || (a0 > 255) || (a1 < 0) || (a1 > 255)
    1156.           || (a2 < 0) || (a2 > 255) || (a3 < 0) || (a3 > 255))
                                    ^
    1157.           return 0;
    1158.       v4[0] = a0;

crypto/x509v3/v3_utl.c:1156:39: Taking false branch
    1154.           return 0;
    1155.       if ((a0 < 0) || (a0 > 255) || (a1 < 0) || (a1 > 255)
    1156.           || (a2 < 0) || (a2 > 255) || (a3 < 0) || (a3 > 255))
                                                  ^
    1157.           return 0;
    1158.       v4[0] = a0;

crypto/x509v3/v3_utl.c:1156:51: Taking false branch
    1154.           return 0;
    1155.       if ((a0 < 0) || (a0 > 255) || (a1 < 0) || (a1 > 255)
    1156.           || (a2 < 0) || (a2 > 255) || (a3 < 0) || (a3 > 255))
                                                              ^
    1157.           return 0;
    1158.       v4[0] = a0;

crypto/x509v3/v3_utl.c:1158:5: 
    1156.           || (a2 < 0) || (a2 > 255) || (a3 < 0) || (a3 > 255))
    1157.           return 0;
    1158. >     v4[0] = a0;
    1159.       v4[1] = a1;
    1160.       v4[2] = a2;

crypto/x509v3/v3_utl.c:1159:5: 
    1157.           return 0;
    1158.       v4[0] = a0;
    1159. >     v4[1] = a1;
    1160.       v4[2] = a2;
    1161.       v4[3] = a3;

crypto/x509v3/v3_utl.c:1160:5: 
    1158.       v4[0] = a0;
    1159.       v4[1] = a1;
    1160. >     v4[2] = a2;
    1161.       v4[3] = a3;
    1162.       return 1;

crypto/x509v3/v3_utl.c:1161:5: 
    1159.       v4[1] = a1;
    1160.       v4[2] = a2;
    1161. >     v4[3] = a3;
    1162.       return 1;
    1163.   }

crypto/x509v3/v3_utl.c:1162:5: 
    1160.       v4[2] = a2;
    1161.       v4[3] = a3;
    1162. >     return 1;
    1163.   }
    1164.   

crypto/x509v3/v3_utl.c:1163:1: return from a call to ipv4_from_asc
    1161.       v4[3] = a3;
    1162.       return 1;
    1163. > }
    1164.   
    1165.   typedef struct {

crypto/x509v3/v3_utl.c:1144:14: Taking false branch
  1142.           return 16;
  1143.       } else {
  1144.           if (!ipv4_from_asc(ipout, ipasc))
                       ^
  1145.               return 0;
  1146.           return 4;

crypto/x509v3/v3_utl.c:1146:9: 
  1144.           if (!ipv4_from_asc(ipout, ipasc))
  1145.               return 0;
  1146. >         return 4;
  1147.       }
  1148.   }

crypto/x509v3/v3_utl.c:1148:1: return from a call to a2i_ipadd
  1146.           return 4;
  1147.       }
  1148. > }
  1149.   
  1150.   static int ipv4_from_asc(unsigned char *v4, const char *in)

crypto/x509v3/v3_utl.c:1110:10: Taking false branch
1108.       iplen1 = a2i_ipadd(ipout, iptmp);
1109.   
1110.       if (!iplen1)
                 ^
1111.           goto err;
1112.   

crypto/x509v3/v3_utl.c:1113:5: 
1111.           goto err;
1112.   
1113. >     iplen2 = a2i_ipadd(ipout + iplen1, p);
1114.   
1115.       OPENSSL_free(iptmp);

crypto/x509v3/v3_utl.c:1135:1: start of procedure a2i_ipadd()
  1133.   }
  1134.   
  1135. > int a2i_ipadd(unsigned char *ipout, const char *ipasc)
  1136.   {
  1137.       /* If string contains a ':' assume IPv6 */

crypto/x509v3/v3_utl.c:1139:9: Taking false branch
  1137.       /* If string contains a ':' assume IPv6 */
  1138.   
  1139.       if (strchr(ipasc, ':')) {
                  ^
  1140.           if (!ipv6_from_asc(ipout, ipasc))
  1141.               return 0;

crypto/x509v3/v3_utl.c:1144:14: 
  1142.           return 16;
  1143.       } else {
  1144. >         if (!ipv4_from_asc(ipout, ipasc))
  1145.               return 0;
  1146.           return 4;

crypto/x509v3/v3_utl.c:1150:1: start of procedure ipv4_from_asc()
    1148.   }
    1149.   
    1150. > static int ipv4_from_asc(unsigned char *v4, const char *in)
    1151.   {
    1152.       int a0, a1, a2, a3;

crypto/x509v3/v3_utl.c:1153:9: Taking false branch
    1151.   {
    1152.       int a0, a1, a2, a3;
    1153.       if (sscanf(in, "%d.%d.%d.%d", &a0, &a1, &a2, &a3) != 4)
                    ^
    1154.           return 0;
    1155.       if ((a0 < 0) || (a0 > 255) || (a1 < 0) || (a1 > 255)

crypto/x509v3/v3_utl.c:1155:10: Taking false branch
    1153.       if (sscanf(in, "%d.%d.%d.%d", &a0, &a1, &a2, &a3) != 4)
    1154.           return 0;
    1155.       if ((a0 < 0) || (a0 > 255) || (a1 < 0) || (a1 > 255)
                     ^
    1156.           || (a2 < 0) || (a2 > 255) || (a3 < 0) || (a3 > 255))
    1157.           return 0;

crypto/x509v3/v3_utl.c:1155:22: Taking false branch
    1153.       if (sscanf(in, "%d.%d.%d.%d", &a0, &a1, &a2, &a3) != 4)
    1154.           return 0;
    1155.       if ((a0 < 0) || (a0 > 255) || (a1 < 0) || (a1 > 255)
                                 ^
    1156.           || (a2 < 0) || (a2 > 255) || (a3 < 0) || (a3 > 255))
    1157.           return 0;

crypto/x509v3/v3_utl.c:1155:36: Taking false branch
    1153.       if (sscanf(in, "%d.%d.%d.%d", &a0, &a1, &a2, &a3) != 4)
    1154.           return 0;
    1155.       if ((a0 < 0) || (a0 > 255) || (a1 < 0) || (a1 > 255)
                                               ^
    1156.           || (a2 < 0) || (a2 > 255) || (a3 < 0) || (a3 > 255))
    1157.           return 0;

crypto/x509v3/v3_utl.c:1155:48: Taking false branch
    1153.       if (sscanf(in, "%d.%d.%d.%d", &a0, &a1, &a2, &a3) != 4)
    1154.           return 0;
    1155.       if ((a0 < 0) || (a0 > 255) || (a1 < 0) || (a1 > 255)
                                                           ^
    1156.           || (a2 < 0) || (a2 > 255) || (a3 < 0) || (a3 > 255))
    1157.           return 0;

crypto/x509v3/v3_utl.c:1156:13: Taking false branch
    1154.           return 0;
    1155.       if ((a0 < 0) || (a0 > 255) || (a1 < 0) || (a1 > 255)
    1156.           || (a2 < 0) || (a2 > 255) || (a3 < 0) || (a3 > 255))
                        ^
    1157.           return 0;
    1158.       v4[0] = a0;

crypto/x509v3/v3_utl.c:1156:25: Taking false branch
    1154.           return 0;
    1155.       if ((a0 < 0) || (a0 > 255) || (a1 < 0) || (a1 > 255)
    1156.           || (a2 < 0) || (a2 > 255) || (a3 < 0) || (a3 > 255))
                                    ^
    1157.           return 0;
    1158.       v4[0] = a0;

crypto/x509v3/v3_utl.c:1156:39: Taking false branch
    1154.           return 0;
    1155.       if ((a0 < 0) || (a0 > 255) || (a1 < 0) || (a1 > 255)
    1156.           || (a2 < 0) || (a2 > 255) || (a3 < 0) || (a3 > 255))
                                                  ^
    1157.           return 0;
    1158.       v4[0] = a0;

crypto/x509v3/v3_utl.c:1156:51: Taking false branch
    1154.           return 0;
    1155.       if ((a0 < 0) || (a0 > 255) || (a1 < 0) || (a1 > 255)
    1156.           || (a2 < 0) || (a2 > 255) || (a3 < 0) || (a3 > 255))
                                                              ^
    1157.           return 0;
    1158.       v4[0] = a0;

crypto/x509v3/v3_utl.c:1158:5: 
    1156.           || (a2 < 0) || (a2 > 255) || (a3 < 0) || (a3 > 255))
    1157.           return 0;
    1158. >     v4[0] = a0;
    1159.       v4[1] = a1;
    1160.       v4[2] = a2;

crypto/x509v3/v3_utl.c:1159:5: 
    1157.           return 0;
    1158.       v4[0] = a0;
    1159. >     v4[1] = a1;
    1160.       v4[2] = a2;
    1161.       v4[3] = a3;

crypto/x509v3/v3_utl.c:1160:5: 
    1158.       v4[0] = a0;
    1159.       v4[1] = a1;
    1160. >     v4[2] = a2;
    1161.       v4[3] = a3;
    1162.       return 1;

crypto/x509v3/v3_utl.c:1161:5: 
    1159.       v4[1] = a1;
    1160.       v4[2] = a2;
    1161. >     v4[3] = a3;
    1162.       return 1;
    1163.   }

crypto/x509v3/v3_utl.c:1162:5: 
    1160.       v4[2] = a2;
    1161.       v4[3] = a3;
    1162. >     return 1;
    1163.   }
    1164.   

crypto/x509v3/v3_utl.c:1163:1: return from a call to ipv4_from_asc
    1161.       v4[3] = a3;
    1162.       return 1;
    1163. > }
    1164.   
    1165.   typedef struct {

crypto/x509v3/v3_utl.c:1144:14: Taking false branch
  1142.           return 16;
  1143.       } else {
  1144.           if (!ipv4_from_asc(ipout, ipasc))
                       ^
  1145.               return 0;
  1146.           return 4;

crypto/x509v3/v3_utl.c:1146:9: 
  1144.           if (!ipv4_from_asc(ipout, ipasc))
  1145.               return 0;
  1146. >         return 4;
  1147.       }
  1148.   }

crypto/x509v3/v3_utl.c:1148:1: return from a call to a2i_ipadd
  1146.           return 4;
  1147.       }
  1148. > }
  1149.   
  1150.   static int ipv4_from_asc(unsigned char *v4, const char *in)

crypto/x509v3/v3_utl.c:1115:5: 
1113.       iplen2 = a2i_ipadd(ipout + iplen1, p);
1114.   
1115. >     OPENSSL_free(iptmp);
1116.       iptmp = NULL;
1117.   

crypto/mem.c:233:1: start of procedure CRYPTO_free()
  231.   }
  232.   
  233. > void CRYPTO_free(void *str)
  234.   {
  235.   #ifndef OPENSSL_NO_CRYPTO_MDEBUG

crypto/mem.c:244:5: 
  242.       }
  243.   #else
  244. >     free(str);
  245.   #endif
  246.   }

crypto/mem.c:246:1: return from a call to CRYPTO_free
  244.       free(str);
  245.   #endif
  246. > }
  247.   
  248.   void CRYPTO_clear_free(void *str, size_t num)

crypto/x509v3/v3_utl.c:1116:5: 
1114.   
1115.       OPENSSL_free(iptmp);
1116. >     iptmp = NULL;
1117.   
1118.       if (!iplen2 || (iplen1 != iplen2))

crypto/x509v3/v3_utl.c:1118:10: Taking false branch
1116.       iptmp = NULL;
1117.   
1118.       if (!iplen2 || (iplen1 != iplen2))
                 ^
1119.           goto err;
1120.   

crypto/x509v3/v3_utl.c:1118:21: Taking false branch
1116.       iptmp = NULL;
1117.   
1118.       if (!iplen2 || (iplen1 != iplen2))
                            ^
1119.           goto err;
1120.   

crypto/x509v3/v3_utl.c:1121:5: 
1119.           goto err;
1120.   
1121. >     ret = ASN1_OCTET_STRING_new();
1122.       if (ret == NULL)
1123.           goto err;

crypto/asn1/tasn_typ.c:76:1: start of procedure ASN1_OCTET_STRING_new()
  74.   }
  75.   
  76. > IMPLEMENT_ASN1_STRING_FUNCTIONS(ASN1_OCTET_STRING)
  77.   IMPLEMENT_ASN1_STRING_FUNCTIONS(ASN1_INTEGER)
  78.   IMPLEMENT_ASN1_STRING_FUNCTIONS(ASN1_ENUMERATED)

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:76:1: return from a call to ASN1_OCTET_STRING_new
  74.   }
  75.   
  76. > IMPLEMENT_ASN1_STRING_FUNCTIONS(ASN1_OCTET_STRING)
  77.   IMPLEMENT_ASN1_STRING_FUNCTIONS(ASN1_INTEGER)
  78.   IMPLEMENT_ASN1_STRING_FUNCTIONS(ASN1_ENUMERATED)

crypto/x509v3/v3_utl.c:1122:9: Taking false branch
1120.   
1121.       ret = ASN1_OCTET_STRING_new();
1122.       if (ret == NULL)
                ^
1123.           goto err;
1124.       if (!ASN1_OCTET_STRING_set(ret, ipout, iplen1 + iplen2))

crypto/x509v3/v3_utl.c:1124:10: 
1122.       if (ret == NULL)
1123.           goto err;
1124. >     if (!ASN1_OCTET_STRING_set(ret, ipout, iplen1 + iplen2))
1125.           goto err;
1126.   

crypto/asn1/a_octet.c:73:1: start of procedure ASN1_OCTET_STRING_set()
  71.   }
  72.   
  73. > int ASN1_OCTET_STRING_set(ASN1_OCTET_STRING *x, const unsigned char *d,
  74.                             int len)
  75.   {

crypto/asn1/a_octet.c:76:5: 
  74.                             int len)
  75.   {
  76. >     return ASN1_STRING_set(x, d, len);
  77.   }

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_octet.c:77:1: return from a call to ASN1_OCTET_STRING_set
  75.   {
  76.       return ASN1_STRING_set(x, d, len);
  77. > }

crypto/x509v3/v3_utl.c:1124:10: Taking true branch
1122.       if (ret == NULL)
1123.           goto err;
1124.       if (!ASN1_OCTET_STRING_set(ret, ipout, iplen1 + iplen2))
                 ^
1125.           goto err;
1126.   

crypto/x509v3/v3_utl.c:1129:2: 
1127.       return ret;
1128.   
1129. >  err:
1130.       OPENSSL_free(iptmp);
1131.       ASN1_OCTET_STRING_free(ret);

crypto/x509v3/v3_utl.c:1130:5: 
1128.   
1129.    err:
1130. >     OPENSSL_free(iptmp);
1131.       ASN1_OCTET_STRING_free(ret);
1132.       return NULL;

crypto/mem.c:233:1: start of procedure CRYPTO_free()
  231.   }
  232.   
  233. > void CRYPTO_free(void *str)
  234.   {
  235.   #ifndef OPENSSL_NO_CRYPTO_MDEBUG

crypto/mem.c:244:5: 
  242.       }
  243.   #else
  244. >     free(str);
  245.   #endif
  246.   }

crypto/mem.c:246:1: return from a call to CRYPTO_free
  244.       free(str);
  245.   #endif
  246. > }
  247.   
  248.   void CRYPTO_clear_free(void *str, size_t num)

crypto/x509v3/v3_utl.c:1131:5: 
1129.    err:
1130.       OPENSSL_free(iptmp);
1131. >     ASN1_OCTET_STRING_free(ret);
1132.       return NULL;
1133.   }

crypto/asn1/tasn_typ.c:76:1: start of procedure ASN1_OCTET_STRING_free()
  74.   }
  75.   
  76. > IMPLEMENT_ASN1_STRING_FUNCTIONS(ASN1_OCTET_STRING)
  77.   IMPLEMENT_ASN1_STRING_FUNCTIONS(ASN1_INTEGER)
  78.   IMPLEMENT_ASN1_STRING_FUNCTIONS(ASN1_ENUMERATED)

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

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

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

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

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

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

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