crypto/x509/x509_lu.c:549: error: NULL_DEREFERENCE
  pointer `obj` last assigned on line 548 could be null and is dereferenced at line 549, column 13.
Showing all 33 steps of the trace


crypto/x509/x509_lu.c:523:1: start of procedure X509_STORE_get1_crls()
521.   }
522.   
523. > STACK_OF(X509_CRL) *X509_STORE_get1_crls(X509_STORE_CTX *ctx, X509_NAME *nm)
524.   {
525.       int i, idx, cnt;

crypto/x509/x509_lu.c:529:5: 
527.       X509_CRL *x;
528.       X509_OBJECT *obj, xobj;
529. >     sk = sk_X509_CRL_new_null();
530.   
531.       /*

crypto/stack/stack.c:145:1: start of procedure sk_new_null()
  143.   }
  144.   
  145. > _STACK *sk_new_null(void)
  146.   {
  147.       return sk_new((int (*)(const void *, const void *))0);

crypto/stack/stack.c:147:5: Skipping sk_new(): empty list of specs
  145.   _STACK *sk_new_null(void)
  146.   {
  147.       return sk_new((int (*)(const void *, const void *))0);
             ^
  148.   }
  149.   

crypto/stack/stack.c:148:1: return from a call to sk_new_null
  146.   {
  147.       return sk_new((int (*)(const void *, const void *))0);
  148. > }
  149.   
  150.   _STACK *sk_new(int (*c) (const void *, const void *))

crypto/x509/x509_lu.c:534:10: Taking false branch
532.        * Always do lookup to possibly add new CRLs to cache
533.        */
534.       if (!X509_STORE_get_by_subject(ctx, X509_LU_CRL, nm, &xobj)) {
                ^
535.           sk_X509_CRL_free(sk);
536.           return NULL;

crypto/x509/x509_lu.c:538:5: 
536.           return NULL;
537.       }
538. >     X509_OBJECT_free_contents(&xobj);
539.       CRYPTO_w_lock(CRYPTO_LOCK_X509_STORE);
540.       idx = x509_object_idx_cnt(ctx->ctx->objs, X509_LU_CRL, nm, &cnt);

crypto/x509/x509_lu.c:407:1: start of procedure X509_OBJECT_free_contents()
  405.   }
  406.   
  407. > void X509_OBJECT_free_contents(X509_OBJECT *a)
  408.   {
  409.       if (!a)

crypto/x509/x509_lu.c:409:10: Taking false branch
  407.   void X509_OBJECT_free_contents(X509_OBJECT *a)
  408.   {
  409.       if (!a)
                  ^
  410.           return;
  411.       switch (a->type) {

crypto/x509/x509_lu.c:411:5: 
  409.       if (!a)
  410.           return;
  411. >     switch (a->type) {
  412.       default:
  413.           break;

crypto/x509/x509_lu.c:414:5: Switch condition is false. Skipping switch case
  412.       default:
  413.           break;
  414.       case X509_LU_X509:
             ^
  415.           X509_free(a->data.x509);
  416.           break;

crypto/x509/x509_lu.c:417:5: Switch condition is false. Skipping switch case
  415.           X509_free(a->data.x509);
  416.           break;
  417.       case X509_LU_CRL:
             ^
  418.           X509_CRL_free(a->data.crl);
  419.           break;

crypto/x509/x509_lu.c:421:1: return from a call to X509_OBJECT_free_contents
  419.           break;
  420.       }
  421. > }
  422.   
  423.   static int x509_object_idx_cnt(STACK_OF(X509_OBJECT) *h, int type,

crypto/x509/x509_lu.c:539:5: 
537.       }
538.       X509_OBJECT_free_contents(&xobj);
539. >     CRYPTO_w_lock(CRYPTO_LOCK_X509_STORE);
540.       idx = x509_object_idx_cnt(ctx->ctx->objs, X509_LU_CRL, nm, &cnt);
541.       if (idx < 0) {

crypto/lock.c:416:1: start of procedure CRYPTO_lock()
  414.   }
  415.   
  416. > void CRYPTO_lock(int mode, int type, const char *file, int line)
  417.   {
  418.   #ifdef LOCK_DEBUG

crypto/lock.c:443:9: Taking false branch
  441.       }
  442.   #endif
  443.       if (type < 0) {
                 ^
  444.           if (dynlock_lock_callback != NULL) {
  445.               struct CRYPTO_dynlock_value *pointer

crypto/lock.c:454:16: Taking true branch
  452.               CRYPTO_destroy_dynlockid(type);
  453.           }
  454.       } else if (locking_callback != NULL)
                        ^
  455.           locking_callback(mode, type, file, line);
  456.   }

crypto/lock.c:455:9: Skipping __function_pointer__(): unresolved function pointer
  453.           }
  454.       } else if (locking_callback != NULL)
  455.           locking_callback(mode, type, file, line);
                 ^
  456.   }
  457.   

crypto/lock.c:443:5: 
  441.       }
  442.   #endif
  443. >     if (type < 0) {
  444.           if (dynlock_lock_callback != NULL) {
  445.               struct CRYPTO_dynlock_value *pointer

crypto/lock.c:456:1: return from a call to CRYPTO_lock
  454.       } else if (locking_callback != NULL)
  455.           locking_callback(mode, type, file, line);
  456. > }
  457.   
  458.   int CRYPTO_add_lock(int *pointer, int amount, int type, const char *file,

crypto/x509/x509_lu.c:540:5: Skipping x509_object_idx_cnt(): empty list of specs
538.       X509_OBJECT_free_contents(&xobj);
539.       CRYPTO_w_lock(CRYPTO_LOCK_X509_STORE);
540.       idx = x509_object_idx_cnt(ctx->ctx->objs, X509_LU_CRL, nm, &cnt);
           ^
541.       if (idx < 0) {
542.           CRYPTO_w_unlock(CRYPTO_LOCK_X509_STORE);

crypto/x509/x509_lu.c:541:9: Taking false branch
539.       CRYPTO_w_lock(CRYPTO_LOCK_X509_STORE);
540.       idx = x509_object_idx_cnt(ctx->ctx->objs, X509_LU_CRL, nm, &cnt);
541.       if (idx < 0) {
               ^
542.           CRYPTO_w_unlock(CRYPTO_LOCK_X509_STORE);
543.           sk_X509_CRL_free(sk);

crypto/x509/x509_lu.c:547:10: 
545.       }
546.   
547. >     for (i = 0; i < cnt; i++, idx++) {
548.           obj = sk_X509_OBJECT_value(ctx->ctx->objs, idx);
549.           x = obj->data.crl;

crypto/x509/x509_lu.c:547:17: Loop condition is true. Entering loop body
545.       }
546.   
547.       for (i = 0; i < cnt; i++, idx++) {
                       ^
548.           obj = sk_X509_OBJECT_value(ctx->ctx->objs, idx);
549.           x = obj->data.crl;

crypto/x509/x509_lu.c:548:15: Condition is true
546.   
547.       for (i = 0; i < cnt; i++, idx++) {
548.           obj = sk_X509_OBJECT_value(ctx->ctx->objs, idx);
                     ^
549.           x = obj->data.crl;
550.           X509_CRL_up_ref(x);

crypto/x509/x509_lu.c:548:9: 
546.   
547.       for (i = 0; i < cnt; i++, idx++) {
548. >         obj = sk_X509_OBJECT_value(ctx->ctx->objs, idx);
549.           x = obj->data.crl;
550.           X509_CRL_up_ref(x);

crypto/stack/stack.c:324:1: start of procedure sk_value()
  322.   }
  323.   
  324. > void *sk_value(const _STACK *st, int i)
  325.   {
  326.       if (!st || (i < 0) || (i >= st->num))

crypto/stack/stack.c:326:10: Taking false branch
  324.   void *sk_value(const _STACK *st, int i)
  325.   {
  326.       if (!st || (i < 0) || (i >= st->num))
                  ^
  327.           return NULL;
  328.       return st->data[i];

crypto/stack/stack.c:326:17: Taking false branch
  324.   void *sk_value(const _STACK *st, int i)
  325.   {
  326.       if (!st || (i < 0) || (i >= st->num))
                         ^
  327.           return NULL;
  328.       return st->data[i];

crypto/stack/stack.c:326:28: Taking true branch
  324.   void *sk_value(const _STACK *st, int i)
  325.   {
  326.       if (!st || (i < 0) || (i >= st->num))
                                    ^
  327.           return NULL;
  328.       return st->data[i];

crypto/stack/stack.c:327:9: 
  325.   {
  326.       if (!st || (i < 0) || (i >= st->num))
  327. >         return NULL;
  328.       return st->data[i];
  329.   }

crypto/stack/stack.c:329:1: return from a call to sk_value
  327.           return NULL;
  328.       return st->data[i];
  329. > }
  330.   
  331.   void *sk_set(_STACK *st, int i, void *value)

crypto/x509/x509_lu.c:549:9: 
547.       for (i = 0; i < cnt; i++, idx++) {
548.           obj = sk_X509_OBJECT_value(ctx->ctx->objs, idx);
549. >         x = obj->data.crl;
550.           X509_CRL_up_ref(x);
551.           if (!sk_X509_CRL_push(sk, x)) {
