crypto/x509v3/v3_bitst.c:102: error: NULL_DEREFERENCE
  pointer `null` is dereferenced by call to `X509V3_add_value()` at line 102, column 13.
Showing all 108 steps of the trace


crypto/x509v3/v3_bitst.c:95:1: start of procedure i2v_ASN1_BIT_STRING()
93.   EXT_BITSTRING(NID_key_usage, key_usage_type_table);
94.   
95. > STACK_OF(CONF_VALUE) *i2v_ASN1_BIT_STRING(X509V3_EXT_METHOD *method,
96.                                             ASN1_BIT_STRING *bits,
97.                                             STACK_OF(CONF_VALUE) *ret)

crypto/x509v3/v3_bitst.c:100:10: 
98.   {
99.       BIT_STRING_BITNAME *bnam;
100. >     for (bnam = method->usr_data; bnam->lname; bnam++) {
101.           if (ASN1_BIT_STRING_get_bit(bits, bnam->bitnum))
102.               X509V3_add_value(bnam->lname, NULL, &ret);

crypto/x509v3/v3_bitst.c:100:35: Loop condition is true. Entering loop body
98.   {
99.       BIT_STRING_BITNAME *bnam;
100.       for (bnam = method->usr_data; bnam->lname; bnam++) {
                                         ^
101.           if (ASN1_BIT_STRING_get_bit(bits, bnam->bitnum))
102.               X509V3_add_value(bnam->lname, NULL, &ret);

crypto/x509v3/v3_bitst.c:101:13: 
99.       BIT_STRING_BITNAME *bnam;
100.       for (bnam = method->usr_data; bnam->lname; bnam++) {
101. >         if (ASN1_BIT_STRING_get_bit(bits, bnam->bitnum))
102.               X509V3_add_value(bnam->lname, NULL, &ret);
103.       }

crypto/asn1/a_bitstr.c:222:1: start of procedure ASN1_BIT_STRING_get_bit()
  220.   }
  221.   
  222. > int ASN1_BIT_STRING_get_bit(const ASN1_BIT_STRING *a, int n)
  223.   {
  224.       int w, v;

crypto/asn1/a_bitstr.c:226:5: 
  224.       int w, v;
  225.   
  226. >     w = n / 8;
  227.       v = 1 << (7 - (n & 0x07));
  228.       if ((a == NULL) || (a->length < (w + 1)) || (a->data == NULL))

crypto/asn1/a_bitstr.c:227:5: 
  225.   
  226.       w = n / 8;
  227. >     v = 1 << (7 - (n & 0x07));
  228.       if ((a == NULL) || (a->length < (w + 1)) || (a->data == NULL))
  229.           return (0);

crypto/asn1/a_bitstr.c:228:10: Taking false branch
  226.       w = n / 8;
  227.       v = 1 << (7 - (n & 0x07));
  228.       if ((a == NULL) || (a->length < (w + 1)) || (a->data == NULL))
                  ^
  229.           return (0);
  230.       return ((a->data[w] & v) != 0);

crypto/asn1/a_bitstr.c:228:25: Taking false branch
  226.       w = n / 8;
  227.       v = 1 << (7 - (n & 0x07));
  228.       if ((a == NULL) || (a->length < (w + 1)) || (a->data == NULL))
                                 ^
  229.           return (0);
  230.       return ((a->data[w] & v) != 0);

crypto/asn1/a_bitstr.c:228:50: Taking false branch
  226.       w = n / 8;
  227.       v = 1 << (7 - (n & 0x07));
  228.       if ((a == NULL) || (a->length < (w + 1)) || (a->data == NULL))
                                                          ^
  229.           return (0);
  230.       return ((a->data[w] & v) != 0);

crypto/asn1/a_bitstr.c:230:13: Condition is true
  228.       if ((a == NULL) || (a->length < (w + 1)) || (a->data == NULL))
  229.           return (0);
  230.       return ((a->data[w] & v) != 0);
                     ^
  231.   }
  232.   

crypto/asn1/a_bitstr.c:230:5: 
  228.       if ((a == NULL) || (a->length < (w + 1)) || (a->data == NULL))
  229.           return (0);
  230. >     return ((a->data[w] & v) != 0);
  231.   }
  232.   

crypto/asn1/a_bitstr.c:231:1: return from a call to ASN1_BIT_STRING_get_bit
  229.           return (0);
  230.       return ((a->data[w] & v) != 0);
  231. > }
  232.   
  233.   /*

crypto/x509v3/v3_bitst.c:101:13: Taking true branch
99.       BIT_STRING_BITNAME *bnam;
100.       for (bnam = method->usr_data; bnam->lname; bnam++) {
101.           if (ASN1_BIT_STRING_get_bit(bits, bnam->bitnum))
                   ^
102.               X509V3_add_value(bnam->lname, NULL, &ret);
103.       }

crypto/x509v3/v3_bitst.c:102:13: 
100.       for (bnam = method->usr_data; bnam->lname; bnam++) {
101.           if (ASN1_BIT_STRING_get_bit(bits, bnam->bitnum))
102. >             X509V3_add_value(bnam->lname, NULL, &ret);
103.       }
104.       return ret;

crypto/x509v3/v3_utl.c:82:1: start of procedure X509V3_add_value()
  80.   /* Add a CONF_VALUE name value pair to stack */
  81.   
  82. > int X509V3_add_value(const char *name, const char *value,
  83.                        STACK_OF(CONF_VALUE) **extlist)
  84.   {

crypto/x509v3/v3_utl.c:85:5: 
  83.                        STACK_OF(CONF_VALUE) **extlist)
  84.   {
  85. >     CONF_VALUE *vtmp = NULL;
  86.       char *tname = NULL, *tvalue = NULL;
  87.   

crypto/x509v3/v3_utl.c:86:5: 
  84.   {
  85.       CONF_VALUE *vtmp = NULL;
  86. >     char *tname = NULL, *tvalue = NULL;
  87.   
  88.       if (name && (tname = OPENSSL_strdup(name)) == NULL)

crypto/x509v3/v3_utl.c:88:9: Taking true branch
  86.       char *tname = NULL, *tvalue = NULL;
  87.   
  88.       if (name && (tname = OPENSSL_strdup(name)) == NULL)
                ^
  89.           goto err;
  90.       if (value && (tvalue = OPENSSL_strdup(value)) == NULL)

crypto/x509v3/v3_utl.c:88:17: 
  86.       char *tname = NULL, *tvalue = NULL;
  87.   
  88. >     if (name && (tname = OPENSSL_strdup(name)) == NULL)
  89.           goto err;
  90.       if (value && (tvalue = OPENSSL_strdup(value)) == 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:88:17: Taking false branch
  86.       char *tname = NULL, *tvalue = NULL;
  87.   
  88.       if (name && (tname = OPENSSL_strdup(name)) == NULL)
                        ^
  89.           goto err;
  90.       if (value && (tvalue = OPENSSL_strdup(value)) == NULL)

crypto/x509v3/v3_utl.c:90:9: Taking true branch
  88.       if (name && (tname = OPENSSL_strdup(name)) == NULL)
  89.           goto err;
  90.       if (value && (tvalue = OPENSSL_strdup(value)) == NULL)
                ^
  91.           goto err;
  92.       if ((vtmp = OPENSSL_malloc(sizeof(*vtmp))) == NULL)

crypto/x509v3/v3_utl.c:90:18: 
  88.       if (name && (tname = OPENSSL_strdup(name)) == NULL)
  89.           goto err;
  90. >     if (value && (tvalue = OPENSSL_strdup(value)) == NULL)
  91.           goto err;
  92.       if ((vtmp = OPENSSL_malloc(sizeof(*vtmp))) == 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:90:18: Taking false branch
  88.       if (name && (tname = OPENSSL_strdup(name)) == NULL)
  89.           goto err;
  90.       if (value && (tvalue = OPENSSL_strdup(value)) == NULL)
                         ^
  91.           goto err;
  92.       if ((vtmp = OPENSSL_malloc(sizeof(*vtmp))) == NULL)

crypto/x509v3/v3_utl.c:92:9: 
  90.       if (value && (tvalue = OPENSSL_strdup(value)) == NULL)
  91.           goto err;
  92. >     if ((vtmp = OPENSSL_malloc(sizeof(*vtmp))) == NULL)
  93.           goto err;
  94.       if (*extlist == NULL && (*extlist = sk_CONF_VALUE_new_null()) == 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/x509v3/v3_utl.c:92:9: Taking false branch
  90.       if (value && (tvalue = OPENSSL_strdup(value)) == NULL)
  91.           goto err;
  92.       if ((vtmp = OPENSSL_malloc(sizeof(*vtmp))) == NULL)
                ^
  93.           goto err;
  94.       if (*extlist == NULL && (*extlist = sk_CONF_VALUE_new_null()) == NULL)

crypto/x509v3/v3_utl.c:94:9: Taking false branch
  92.       if ((vtmp = OPENSSL_malloc(sizeof(*vtmp))) == NULL)
  93.           goto err;
  94.       if (*extlist == NULL && (*extlist = sk_CONF_VALUE_new_null()) == NULL)
                ^
  95.           goto err;
  96.       vtmp->section = NULL;

crypto/x509v3/v3_utl.c:96:5: 
  94.       if (*extlist == NULL && (*extlist = sk_CONF_VALUE_new_null()) == NULL)
  95.           goto err;
  96. >     vtmp->section = NULL;
  97.       vtmp->name = tname;
  98.       vtmp->value = tvalue;

crypto/x509v3/v3_utl.c:97:5: 
  95.           goto err;
  96.       vtmp->section = NULL;
  97. >     vtmp->name = tname;
  98.       vtmp->value = tvalue;
  99.       if (!sk_CONF_VALUE_push(*extlist, vtmp))

crypto/x509v3/v3_utl.c:98:5: 
  96.       vtmp->section = NULL;
  97.       vtmp->name = tname;
  98. >     vtmp->value = tvalue;
  99.       if (!sk_CONF_VALUE_push(*extlist, vtmp))
  100.           goto err;

crypto/x509v3/v3_utl.c:99:10: 
  97.       vtmp->name = tname;
  98.       vtmp->value = tvalue;
  99. >     if (!sk_CONF_VALUE_push(*extlist, vtmp))
  100.           goto err;
  101.       return 1;

include/openssl/conf.h:79:1: start of procedure sk_CONF_VALUE_push()
    77.   } CONF_VALUE;
    78.   
    79. > DEFINE_STACK_OF(CONF_VALUE)
    80.   DEFINE_LHASH_OF(CONF_VALUE);
    81.   

crypto/stack/stack.c:258:1: start of procedure sk_push()
      256.   }
      257.   
      258. > int sk_push(_STACK *st, void *data)
      259.   {
      260.       return (sk_insert(st, data, st->num));

crypto/stack/stack.c:260:5: 
      258.   int sk_push(_STACK *st, void *data)
      259.   {
      260. >     return (sk_insert(st, data, st->num));
      261.   }
      262.   

crypto/stack/stack.c:166:1: start of procedure sk_insert()
        164.   }
        165.   
        166. > int sk_insert(_STACK *st, void *data, int loc)
        167.   {
        168.       char **s;

crypto/stack/stack.c:170:9: Taking false branch
        168.       char **s;
        169.   
        170.       if (st == NULL)
                       ^
        171.           return 0;
        172.       if (st->num_alloc <= st->num + 1) {

crypto/stack/stack.c:172:9: Taking true branch
        170.       if (st == NULL)
        171.           return 0;
        172.       if (st->num_alloc <= st->num + 1) {
                       ^
        173.           s = OPENSSL_realloc((char *)st->data,
        174.                               (unsigned int)sizeof(char *) * st->num_alloc * 2);

crypto/stack/stack.c:173:9: 
        171.           return 0;
        172.       if (st->num_alloc <= st->num + 1) {
        173. >         s = OPENSSL_realloc((char *)st->data,
        174.                               (unsigned int)sizeof(char *) * st->num_alloc * 2);
        175.           if (s == NULL)

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 true 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:168:9: 
          166.   {
          167.       if (str == NULL)
          168. >         return CRYPTO_malloc(num, file, line);
          169.   
          170.       if (num == 0) {

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: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/stack/stack.c:175:13: Taking false branch
        173.           s = OPENSSL_realloc((char *)st->data,
        174.                               (unsigned int)sizeof(char *) * st->num_alloc * 2);
        175.           if (s == NULL)
                           ^
        176.               return (0);
        177.           st->data = s;

crypto/stack/stack.c:177:9: 
        175.           if (s == NULL)
        176.               return (0);
        177. >         st->data = s;
        178.           st->num_alloc *= 2;
        179.       }

crypto/stack/stack.c:178:9: 
        176.               return (0);
        177.           st->data = s;
        178. >         st->num_alloc *= 2;
        179.       }
        180.       if ((loc >= (int)st->num) || (loc < 0))

crypto/stack/stack.c:180:10: Taking true branch
        178.           st->num_alloc *= 2;
        179.       }
        180.       if ((loc >= (int)st->num) || (loc < 0))
                        ^
        181.           st->data[st->num] = data;
        182.       else {

crypto/stack/stack.c:181:9: 
        179.       }
        180.       if ((loc >= (int)st->num) || (loc < 0))
        181. >         st->data[st->num] = data;
        182.       else {
        183.           memmove(&(st->data[loc + 1]),

crypto/stack/stack.c:187:5: 
        185.           st->data[loc] = data;
        186.       }
        187. >     st->num++;
        188.       st->sorted = 0;
        189.       return (st->num);

crypto/stack/stack.c:188:5: 
        186.       }
        187.       st->num++;
        188. >     st->sorted = 0;
        189.       return (st->num);
        190.   }

crypto/stack/stack.c:189:5: 
        187.       st->num++;
        188.       st->sorted = 0;
        189. >     return (st->num);
        190.   }
        191.   

crypto/stack/stack.c:190:1: return from a call to sk_insert
        188.       st->sorted = 0;
        189.       return (st->num);
        190. > }
        191.   
        192.   void *sk_delete_ptr(_STACK *st, void *p)

crypto/stack/stack.c:261:1: return from a call to sk_push
      259.   {
      260.       return (sk_insert(st, data, st->num));
      261. > }
      262.   
      263.   int sk_unshift(_STACK *st, void *data)

include/openssl/conf.h:79:1: return from a call to sk_CONF_VALUE_push
    77.   } CONF_VALUE;
    78.   
    79. > DEFINE_STACK_OF(CONF_VALUE)
    80.   DEFINE_LHASH_OF(CONF_VALUE);
    81.   

crypto/x509v3/v3_utl.c:99:10: Taking false branch
  97.       vtmp->name = tname;
  98.       vtmp->value = tvalue;
  99.       if (!sk_CONF_VALUE_push(*extlist, vtmp))
                  ^
  100.           goto err;
  101.       return 1;

crypto/x509v3/v3_utl.c:101:5: 
  99.       if (!sk_CONF_VALUE_push(*extlist, vtmp))
  100.           goto err;
  101. >     return 1;
  102.    err:
  103.       X509V3err(X509V3_F_X509V3_ADD_VALUE, ERR_R_MALLOC_FAILURE);

crypto/x509v3/v3_utl.c:108:1: return from a call to X509V3_add_value
  106.       OPENSSL_free(tvalue);
  107.       return 0;
  108. > }
  109.   
  110.   int X509V3_add_value_uchar(const char *name, const unsigned char *value,
