crypto/pem/pem_all.c:223: error: NULL_DEREFERENCE
  pointer `pktmp` last assigned on line 222 could be null and is dereferenced by call to `pkey_get_dsa()` at line 223, column 9.
Showing all 155 steps of the trace


crypto/pem/pem_all.c:218:1: start of procedure PEM_read_bio_DSAPrivateKey()
216.   }
217.   
218. > DSA *PEM_read_bio_DSAPrivateKey(BIO *bp, DSA **dsa, pem_password_cb *cb,
219.   								void *u)
220.   {

crypto/pem/pem_all.c:222:2: 
220.   {
221.   	EVP_PKEY *pktmp;
222. > 	pktmp = PEM_read_bio_PrivateKey(bp, NULL, cb, u);
223.   	return pkey_get_dsa(pktmp, dsa);	/* will free pktmp */
224.   }

crypto/pem/pem_pkey.c:75:1: start of procedure PEM_read_bio_PrivateKey()
  73.   int pem_check_suffix(const char *pem_str, const char *suffix);
  74.   
  75. > EVP_PKEY *PEM_read_bio_PrivateKey(BIO *bp, EVP_PKEY **x, pem_password_cb *cb, void *u)
  76.   	{
  77.   	char *nm=NULL;

crypto/pem/pem_pkey.c:77:2: 
  75.   EVP_PKEY *PEM_read_bio_PrivateKey(BIO *bp, EVP_PKEY **x, pem_password_cb *cb, void *u)
  76.   	{
  77. > 	char *nm=NULL;
  78.   	const unsigned char *p=NULL;
  79.   	unsigned char *data=NULL;

crypto/pem/pem_pkey.c:78:2: 
  76.   	{
  77.   	char *nm=NULL;
  78. > 	const unsigned char *p=NULL;
  79.   	unsigned char *data=NULL;
  80.   	long len;

crypto/pem/pem_pkey.c:79:2: 
  77.   	char *nm=NULL;
  78.   	const unsigned char *p=NULL;
  79. > 	unsigned char *data=NULL;
  80.   	long len;
  81.   	int slen;

crypto/pem/pem_pkey.c:82:2: 
  80.   	long len;
  81.   	int slen;
  82. > 	EVP_PKEY *ret=NULL;
  83.   
  84.   	if (!PEM_bytes_read_bio(&data, &len, &nm, PEM_STRING_EVP_PKEY, bp, cb, u))

crypto/pem/pem_pkey.c:84:7: 
  82.   	EVP_PKEY *ret=NULL;
  83.   
  84. > 	if (!PEM_bytes_read_bio(&data, &len, &nm, PEM_STRING_EVP_PKEY, bp, cb, u))
  85.   		return NULL;
  86.   	p = data;

crypto/pem/pem_lib.c:262:1: start of procedure PEM_bytes_read_bio()
    260.   }
    261.   
    262. > int PEM_bytes_read_bio(unsigned char **pdata, long *plen, char **pnm, const char *name, BIO *bp,
    263.   	     pem_password_cb *cb, void *u)
    264.   	{

crypto/pem/pem_lib.c:266:2: 
    264.   	{
    265.   	EVP_CIPHER_INFO cipher;
    266. > 	char *nm=NULL,*header=NULL;
    267.   	unsigned char *data=NULL;
    268.   	long len;

crypto/pem/pem_lib.c:267:2: 
    265.   	EVP_CIPHER_INFO cipher;
    266.   	char *nm=NULL,*header=NULL;
    267. > 	unsigned char *data=NULL;
    268.   	long len;
    269.   	int ret = 0;

crypto/pem/pem_lib.c:269:2: 
    267.   	unsigned char *data=NULL;
    268.   	long len;
    269. > 	int ret = 0;
    270.   
    271.   	for (;;)

crypto/pem/pem_lib.c:283:3: Loop condition is true. Entering loop body
    281.   		OPENSSL_free(header);
    282.   		OPENSSL_free(data);
    283.   		}
             ^
    284.   	if (!PEM_get_EVP_CIPHER_INFO(header,&cipher)) goto err;
    285.   	if (!PEM_do_header(&cipher,data,&len,cb,u)) goto err;

crypto/pem/pem_lib.c:273:8: 
    271.   	for (;;)
    272.   		{
    273. > 		if (!PEM_read_bio(bp,&nm,&header,&data,&len)) {
    274.   			if(ERR_GET_REASON(ERR_peek_error()) ==
    275.   				PEM_R_NO_START_LINE)

crypto/pem/pem_lib.c:658:1: start of procedure PEM_read_bio()
      656.   #endif
      657.   
      658. > int PEM_read_bio(BIO *bp, char **name, char **header, unsigned char **data,
      659.   	     long *len)
      660.   	{

crypto/pem/pem_lib.c:662:2: 
      660.   	{
      661.   	EVP_ENCODE_CTX ctx;
      662. > 	int end=0,i,k,bl=0,hl=0,nohead=0;
      663.   	char buf[256];
      664.   	BUF_MEM *nameB;

crypto/pem/pem_lib.c:668:2: 
      666.   	BUF_MEM *dataB,*tmpB;
      667.   	
      668. > 	nameB=BUF_MEM_new();
      669.   	headerB=BUF_MEM_new();
      670.   	dataB=BUF_MEM_new();

crypto/buffer/buffer.c:63:1: start of procedure BUF_MEM_new()
        61.   #include <openssl/buffer.h>
        62.   
        63. > BUF_MEM *BUF_MEM_new(void)
        64.   	{
        65.   	BUF_MEM *ret;

crypto/buffer/buffer.c:67:2: 
        65.   	BUF_MEM *ret;
        66.   
        67. > 	ret=OPENSSL_malloc(sizeof(BUF_MEM));
        68.   	if (ret == NULL)
        69.   		{

crypto/mem.c:294:1: start of procedure CRYPTO_malloc()
          292.   	}
          293.   
          294. > void *CRYPTO_malloc(int num, const char *file, int line)
          295.   	{
          296.   	void *ret = NULL;

crypto/mem.c:296:2: 
          294.   void *CRYPTO_malloc(int num, const char *file, int line)
          295.   	{
          296. > 	void *ret = NULL;
          297.   
          298.   	if (num <= 0) return NULL;

crypto/mem.c:298:6: Taking false branch
          296.   	void *ret = NULL;
          297.   
          298.   	if (num <= 0) return NULL;
                      ^
          299.   
          300.   	allow_customize = 0;

crypto/mem.c:300:2: 
          298.   	if (num <= 0) return NULL;
          299.   
          300. > 	allow_customize = 0;
          301.   	if (malloc_debug_func != NULL)
          302.   		{

crypto/mem.c:301:6: Taking true branch
          299.   
          300.   	allow_customize = 0;
          301.   	if (malloc_debug_func != NULL)
                      ^
          302.   		{
          303.   		allow_customize_debug = 0;

crypto/mem.c:303:3: 
          301.   	if (malloc_debug_func != NULL)
          302.   		{
          303. > 		allow_customize_debug = 0;
          304.   		malloc_debug_func(NULL, num, file, line, 0);
          305.   		}

crypto/mem.c:304:3: Skipping __function_pointer__(): unresolved function pointer
          302.   		{
          303.   		allow_customize_debug = 0;
          304.   		malloc_debug_func(NULL, num, file, line, 0);
                   ^
          305.   		}
          306.   	ret = malloc_ex_func(num,file,line);

crypto/mem.c:306:2: Skipping __function_pointer__(): unresolved function pointer
          304.   		malloc_debug_func(NULL, num, file, line, 0);
          305.   		}
          306.   	ret = malloc_ex_func(num,file,line);
                  ^
          307.   #ifdef LEVITTE_DEBUG_MEM
          308.   	fprintf(stderr, "LEVITTE_DEBUG_MEM:         > 0x%p (%d)\n", ret, num);

crypto/mem.c:310:6: Taking true branch
          308.   	fprintf(stderr, "LEVITTE_DEBUG_MEM:         > 0x%p (%d)\n", ret, num);
          309.   #endif
          310.   	if (malloc_debug_func != NULL)
                      ^
          311.   		malloc_debug_func(ret, num, file, line, 1);
          312.   

crypto/mem.c:311:3: Skipping __function_pointer__(): unresolved function pointer
          309.   #endif
          310.   	if (malloc_debug_func != NULL)
          311.   		malloc_debug_func(ret, num, file, line, 1);
                   ^
          312.   
          313.   #ifndef OPENSSL_CPUID_OBJ

crypto/mem.c:317:12: Taking false branch
          315.            * sanitisation function can't be optimised out. NB: We only do
          316.            * this for >2Kb so the overhead doesn't bother us. */
          317.           if(ret && (num > 2048))
                            ^
          318.   	{	extern unsigned char cleanse_ctr;
          319.                   ((unsigned char *)ret)[0] = cleanse_ctr;

crypto/mem.c:323:2: 
          321.   #endif
          322.   
          323. > 	return ret;
          324.   	}
          325.   

crypto/mem.c:324:2: return from a call to CRYPTO_malloc
          322.   
          323.   	return ret;
          324.   	}
                  ^
          325.   
          326.   void *CRYPTO_realloc(void *str, int num, const char *file, int line)

crypto/buffer/buffer.c:68:6: Taking true branch
        66.   
        67.   	ret=OPENSSL_malloc(sizeof(BUF_MEM));
        68.   	if (ret == NULL)
                   ^
        69.   		{
        70.   		BUFerr(BUF_F_BUF_MEM_NEW,ERR_R_MALLOC_FAILURE);

crypto/buffer/buffer.c:70:3: 
        68.   	if (ret == NULL)
        69.   		{
        70. > 		BUFerr(BUF_F_BUF_MEM_NEW,ERR_R_MALLOC_FAILURE);
        71.   		return(NULL);
        72.   		}

crypto/err/err.c:680:1: start of procedure ERR_put_error()
          678.   /********************************************************/
          679.   
          680. > void ERR_put_error(int lib, int func, int reason, const char *file,
          681.   	     int line)
          682.   	{

crypto/err/err.c:704:2: Skipping ERR_get_state(): empty list of specs
          702.   	}
          703.   #endif
          704.   	es=ERR_get_state();
                  ^
          705.   
          706.   	es->top=(es->top+1)%ERR_NUM_ERRORS;

crypto/err/err.c:706:2: 
          704.   	es=ERR_get_state();
          705.   
          706. > 	es->top=(es->top+1)%ERR_NUM_ERRORS;
          707.   	if (es->top == es->bottom)
          708.   		es->bottom=(es->bottom+1)%ERR_NUM_ERRORS;

crypto/err/err.c:707:6: Taking false branch
          705.   
          706.   	es->top=(es->top+1)%ERR_NUM_ERRORS;
          707.   	if (es->top == es->bottom)
                      ^
          708.   		es->bottom=(es->bottom+1)%ERR_NUM_ERRORS;
          709.   	es->err_flags[es->top]=0;

crypto/err/err.c:709:2: 
          707.   	if (es->top == es->bottom)
          708.   		es->bottom=(es->bottom+1)%ERR_NUM_ERRORS;
          709. > 	es->err_flags[es->top]=0;
          710.   	es->err_buffer[es->top]=ERR_PACK(lib,func,reason);
          711.   	es->err_file[es->top]=file;

crypto/err/err.c:710:2: 
          708.   		es->bottom=(es->bottom+1)%ERR_NUM_ERRORS;
          709.   	es->err_flags[es->top]=0;
          710. > 	es->err_buffer[es->top]=ERR_PACK(lib,func,reason);
          711.   	es->err_file[es->top]=file;
          712.   	es->err_line[es->top]=line;

crypto/err/err.c:711:2: 
          709.   	es->err_flags[es->top]=0;
          710.   	es->err_buffer[es->top]=ERR_PACK(lib,func,reason);
          711. > 	es->err_file[es->top]=file;
          712.   	es->err_line[es->top]=line;
          713.   	err_clear_data(es,es->top);

crypto/err/err.c:712:2: 
          710.   	es->err_buffer[es->top]=ERR_PACK(lib,func,reason);
          711.   	es->err_file[es->top]=file;
          712. > 	es->err_line[es->top]=line;
          713.   	err_clear_data(es,es->top);
          714.   	}

crypto/err/err.c:713:2: Taking true branch
          711.   	es->err_file[es->top]=file;
          712.   	es->err_line[es->top]=line;
          713.   	err_clear_data(es,es->top);
                  ^
          714.   	}
          715.   

crypto/err/err.c:713:2: Taking false branch
          711.   	es->err_file[es->top]=file;
          712.   	es->err_line[es->top]=line;
          713.   	err_clear_data(es,es->top);
                  ^
          714.   	}
          715.   

crypto/err/err.c:713:2: Loop condition is false. Leaving loop
          711.   	es->err_file[es->top]=file;
          712.   	es->err_line[es->top]=line;
          713.   	err_clear_data(es,es->top);
                  ^
          714.   	}
          715.   

crypto/err/err.c:714:2: return from a call to ERR_put_error
          712.   	es->err_line[es->top]=line;
          713.   	err_clear_data(es,es->top);
          714.   	}
                  ^
          715.   
          716.   void ERR_clear_error(void)

crypto/buffer/buffer.c:71:3: 
        69.   		{
        70.   		BUFerr(BUF_F_BUF_MEM_NEW,ERR_R_MALLOC_FAILURE);
        71. > 		return(NULL);
        72.   		}
        73.   	ret->length=0;

crypto/buffer/buffer.c:77:2: return from a call to BUF_MEM_new
        75.   	ret->data=NULL;
        76.   	return(ret);
        77.   	}
               ^
        78.   
        79.   void BUF_MEM_free(BUF_MEM *a)

crypto/pem/pem_lib.c:669:2: 
      667.   	
      668.   	nameB=BUF_MEM_new();
      669. > 	headerB=BUF_MEM_new();
      670.   	dataB=BUF_MEM_new();
      671.   	if ((nameB == NULL) || (headerB == NULL) || (dataB == NULL))

crypto/buffer/buffer.c:63:1: start of procedure BUF_MEM_new()
        61.   #include <openssl/buffer.h>
        62.   
        63. > BUF_MEM *BUF_MEM_new(void)
        64.   	{
        65.   	BUF_MEM *ret;

crypto/buffer/buffer.c:67:2: 
        65.   	BUF_MEM *ret;
        66.   
        67. > 	ret=OPENSSL_malloc(sizeof(BUF_MEM));
        68.   	if (ret == NULL)
        69.   		{

crypto/mem.c:294:1: start of procedure CRYPTO_malloc()
          292.   	}
          293.   
          294. > void *CRYPTO_malloc(int num, const char *file, int line)
          295.   	{
          296.   	void *ret = NULL;

crypto/mem.c:296:2: 
          294.   void *CRYPTO_malloc(int num, const char *file, int line)
          295.   	{
          296. > 	void *ret = NULL;
          297.   
          298.   	if (num <= 0) return NULL;

crypto/mem.c:298:6: Taking false branch
          296.   	void *ret = NULL;
          297.   
          298.   	if (num <= 0) return NULL;
                      ^
          299.   
          300.   	allow_customize = 0;

crypto/mem.c:300:2: 
          298.   	if (num <= 0) return NULL;
          299.   
          300. > 	allow_customize = 0;
          301.   	if (malloc_debug_func != NULL)
          302.   		{

crypto/mem.c:301:6: Taking true branch
          299.   
          300.   	allow_customize = 0;
          301.   	if (malloc_debug_func != NULL)
                      ^
          302.   		{
          303.   		allow_customize_debug = 0;

crypto/mem.c:303:3: 
          301.   	if (malloc_debug_func != NULL)
          302.   		{
          303. > 		allow_customize_debug = 0;
          304.   		malloc_debug_func(NULL, num, file, line, 0);
          305.   		}

crypto/mem.c:304:3: Skipping __function_pointer__(): unresolved function pointer
          302.   		{
          303.   		allow_customize_debug = 0;
          304.   		malloc_debug_func(NULL, num, file, line, 0);
                   ^
          305.   		}
          306.   	ret = malloc_ex_func(num,file,line);

crypto/mem.c:306:2: Skipping __function_pointer__(): unresolved function pointer
          304.   		malloc_debug_func(NULL, num, file, line, 0);
          305.   		}
          306.   	ret = malloc_ex_func(num,file,line);
                  ^
          307.   #ifdef LEVITTE_DEBUG_MEM
          308.   	fprintf(stderr, "LEVITTE_DEBUG_MEM:         > 0x%p (%d)\n", ret, num);

crypto/mem.c:310:6: Taking true branch
          308.   	fprintf(stderr, "LEVITTE_DEBUG_MEM:         > 0x%p (%d)\n", ret, num);
          309.   #endif
          310.   	if (malloc_debug_func != NULL)
                      ^
          311.   		malloc_debug_func(ret, num, file, line, 1);
          312.   

crypto/mem.c:311:3: Skipping __function_pointer__(): unresolved function pointer
          309.   #endif
          310.   	if (malloc_debug_func != NULL)
          311.   		malloc_debug_func(ret, num, file, line, 1);
                   ^
          312.   
          313.   #ifndef OPENSSL_CPUID_OBJ

crypto/mem.c:317:12: Taking false branch
          315.            * sanitisation function can't be optimised out. NB: We only do
          316.            * this for >2Kb so the overhead doesn't bother us. */
          317.           if(ret && (num > 2048))
                            ^
          318.   	{	extern unsigned char cleanse_ctr;
          319.                   ((unsigned char *)ret)[0] = cleanse_ctr;

crypto/mem.c:323:2: 
          321.   #endif
          322.   
          323. > 	return ret;
          324.   	}
          325.   

crypto/mem.c:324:2: return from a call to CRYPTO_malloc
          322.   
          323.   	return ret;
          324.   	}
                  ^
          325.   
          326.   void *CRYPTO_realloc(void *str, int num, const char *file, int line)

crypto/buffer/buffer.c:68:6: Taking true branch
        66.   
        67.   	ret=OPENSSL_malloc(sizeof(BUF_MEM));
        68.   	if (ret == NULL)
                   ^
        69.   		{
        70.   		BUFerr(BUF_F_BUF_MEM_NEW,ERR_R_MALLOC_FAILURE);

crypto/buffer/buffer.c:70:3: 
        68.   	if (ret == NULL)
        69.   		{
        70. > 		BUFerr(BUF_F_BUF_MEM_NEW,ERR_R_MALLOC_FAILURE);
        71.   		return(NULL);
        72.   		}

crypto/err/err.c:680:1: start of procedure ERR_put_error()
          678.   /********************************************************/
          679.   
          680. > void ERR_put_error(int lib, int func, int reason, const char *file,
          681.   	     int line)
          682.   	{

crypto/err/err.c:704:2: Skipping ERR_get_state(): empty list of specs
          702.   	}
          703.   #endif
          704.   	es=ERR_get_state();
                  ^
          705.   
          706.   	es->top=(es->top+1)%ERR_NUM_ERRORS;

crypto/err/err.c:706:2: 
          704.   	es=ERR_get_state();
          705.   
          706. > 	es->top=(es->top+1)%ERR_NUM_ERRORS;
          707.   	if (es->top == es->bottom)
          708.   		es->bottom=(es->bottom+1)%ERR_NUM_ERRORS;

crypto/err/err.c:707:6: Taking false branch
          705.   
          706.   	es->top=(es->top+1)%ERR_NUM_ERRORS;
          707.   	if (es->top == es->bottom)
                      ^
          708.   		es->bottom=(es->bottom+1)%ERR_NUM_ERRORS;
          709.   	es->err_flags[es->top]=0;

crypto/err/err.c:709:2: 
          707.   	if (es->top == es->bottom)
          708.   		es->bottom=(es->bottom+1)%ERR_NUM_ERRORS;
          709. > 	es->err_flags[es->top]=0;
          710.   	es->err_buffer[es->top]=ERR_PACK(lib,func,reason);
          711.   	es->err_file[es->top]=file;

crypto/err/err.c:710:2: 
          708.   		es->bottom=(es->bottom+1)%ERR_NUM_ERRORS;
          709.   	es->err_flags[es->top]=0;
          710. > 	es->err_buffer[es->top]=ERR_PACK(lib,func,reason);
          711.   	es->err_file[es->top]=file;
          712.   	es->err_line[es->top]=line;

crypto/err/err.c:711:2: 
          709.   	es->err_flags[es->top]=0;
          710.   	es->err_buffer[es->top]=ERR_PACK(lib,func,reason);
          711. > 	es->err_file[es->top]=file;
          712.   	es->err_line[es->top]=line;
          713.   	err_clear_data(es,es->top);

crypto/err/err.c:712:2: 
          710.   	es->err_buffer[es->top]=ERR_PACK(lib,func,reason);
          711.   	es->err_file[es->top]=file;
          712. > 	es->err_line[es->top]=line;
          713.   	err_clear_data(es,es->top);
          714.   	}

crypto/err/err.c:713:2: Taking true branch
          711.   	es->err_file[es->top]=file;
          712.   	es->err_line[es->top]=line;
          713.   	err_clear_data(es,es->top);
                  ^
          714.   	}
          715.   

crypto/err/err.c:713:2: Taking false branch
          711.   	es->err_file[es->top]=file;
          712.   	es->err_line[es->top]=line;
          713.   	err_clear_data(es,es->top);
                  ^
          714.   	}
          715.   

crypto/err/err.c:713:2: Loop condition is false. Leaving loop
          711.   	es->err_file[es->top]=file;
          712.   	es->err_line[es->top]=line;
          713.   	err_clear_data(es,es->top);
                  ^
          714.   	}
          715.   

crypto/err/err.c:714:2: return from a call to ERR_put_error
          712.   	es->err_line[es->top]=line;
          713.   	err_clear_data(es,es->top);
          714.   	}
                  ^
          715.   
          716.   void ERR_clear_error(void)

crypto/buffer/buffer.c:71:3: 
        69.   		{
        70.   		BUFerr(BUF_F_BUF_MEM_NEW,ERR_R_MALLOC_FAILURE);
        71. > 		return(NULL);
        72.   		}
        73.   	ret->length=0;

crypto/buffer/buffer.c:77:2: return from a call to BUF_MEM_new
        75.   	ret->data=NULL;
        76.   	return(ret);
        77.   	}
               ^
        78.   
        79.   void BUF_MEM_free(BUF_MEM *a)

crypto/pem/pem_lib.c:670:2: 
      668.   	nameB=BUF_MEM_new();
      669.   	headerB=BUF_MEM_new();
      670. > 	dataB=BUF_MEM_new();
      671.   	if ((nameB == NULL) || (headerB == NULL) || (dataB == NULL))
      672.   		{

crypto/buffer/buffer.c:63:1: start of procedure BUF_MEM_new()
        61.   #include <openssl/buffer.h>
        62.   
        63. > BUF_MEM *BUF_MEM_new(void)
        64.   	{
        65.   	BUF_MEM *ret;

crypto/buffer/buffer.c:67:2: 
        65.   	BUF_MEM *ret;
        66.   
        67. > 	ret=OPENSSL_malloc(sizeof(BUF_MEM));
        68.   	if (ret == NULL)
        69.   		{

crypto/mem.c:294:1: start of procedure CRYPTO_malloc()
          292.   	}
          293.   
          294. > void *CRYPTO_malloc(int num, const char *file, int line)
          295.   	{
          296.   	void *ret = NULL;

crypto/mem.c:296:2: 
          294.   void *CRYPTO_malloc(int num, const char *file, int line)
          295.   	{
          296. > 	void *ret = NULL;
          297.   
          298.   	if (num <= 0) return NULL;

crypto/mem.c:298:6: Taking false branch
          296.   	void *ret = NULL;
          297.   
          298.   	if (num <= 0) return NULL;
                      ^
          299.   
          300.   	allow_customize = 0;

crypto/mem.c:300:2: 
          298.   	if (num <= 0) return NULL;
          299.   
          300. > 	allow_customize = 0;
          301.   	if (malloc_debug_func != NULL)
          302.   		{

crypto/mem.c:301:6: Taking true branch
          299.   
          300.   	allow_customize = 0;
          301.   	if (malloc_debug_func != NULL)
                      ^
          302.   		{
          303.   		allow_customize_debug = 0;

crypto/mem.c:303:3: 
          301.   	if (malloc_debug_func != NULL)
          302.   		{
          303. > 		allow_customize_debug = 0;
          304.   		malloc_debug_func(NULL, num, file, line, 0);
          305.   		}

crypto/mem.c:304:3: Skipping __function_pointer__(): unresolved function pointer
          302.   		{
          303.   		allow_customize_debug = 0;
          304.   		malloc_debug_func(NULL, num, file, line, 0);
                   ^
          305.   		}
          306.   	ret = malloc_ex_func(num,file,line);

crypto/mem.c:306:2: Skipping __function_pointer__(): unresolved function pointer
          304.   		malloc_debug_func(NULL, num, file, line, 0);
          305.   		}
          306.   	ret = malloc_ex_func(num,file,line);
                  ^
          307.   #ifdef LEVITTE_DEBUG_MEM
          308.   	fprintf(stderr, "LEVITTE_DEBUG_MEM:         > 0x%p (%d)\n", ret, num);

crypto/mem.c:310:6: Taking true branch
          308.   	fprintf(stderr, "LEVITTE_DEBUG_MEM:         > 0x%p (%d)\n", ret, num);
          309.   #endif
          310.   	if (malloc_debug_func != NULL)
                      ^
          311.   		malloc_debug_func(ret, num, file, line, 1);
          312.   

crypto/mem.c:311:3: Skipping __function_pointer__(): unresolved function pointer
          309.   #endif
          310.   	if (malloc_debug_func != NULL)
          311.   		malloc_debug_func(ret, num, file, line, 1);
                   ^
          312.   
          313.   #ifndef OPENSSL_CPUID_OBJ

crypto/mem.c:317:12: Taking false branch
          315.            * sanitisation function can't be optimised out. NB: We only do
          316.            * this for >2Kb so the overhead doesn't bother us. */
          317.           if(ret && (num > 2048))
                            ^
          318.   	{	extern unsigned char cleanse_ctr;
          319.                   ((unsigned char *)ret)[0] = cleanse_ctr;

crypto/mem.c:323:2: 
          321.   #endif
          322.   
          323. > 	return ret;
          324.   	}
          325.   

crypto/mem.c:324:2: return from a call to CRYPTO_malloc
          322.   
          323.   	return ret;
          324.   	}
                  ^
          325.   
          326.   void *CRYPTO_realloc(void *str, int num, const char *file, int line)

crypto/buffer/buffer.c:68:6: Taking true branch
        66.   
        67.   	ret=OPENSSL_malloc(sizeof(BUF_MEM));
        68.   	if (ret == NULL)
                   ^
        69.   		{
        70.   		BUFerr(BUF_F_BUF_MEM_NEW,ERR_R_MALLOC_FAILURE);

crypto/buffer/buffer.c:70:3: 
        68.   	if (ret == NULL)
        69.   		{
        70. > 		BUFerr(BUF_F_BUF_MEM_NEW,ERR_R_MALLOC_FAILURE);
        71.   		return(NULL);
        72.   		}

crypto/err/err.c:680:1: start of procedure ERR_put_error()
          678.   /********************************************************/
          679.   
          680. > void ERR_put_error(int lib, int func, int reason, const char *file,
          681.   	     int line)
          682.   	{

crypto/err/err.c:704:2: Skipping ERR_get_state(): empty list of specs
          702.   	}
          703.   #endif
          704.   	es=ERR_get_state();
                  ^
          705.   
          706.   	es->top=(es->top+1)%ERR_NUM_ERRORS;

crypto/err/err.c:706:2: 
          704.   	es=ERR_get_state();
          705.   
          706. > 	es->top=(es->top+1)%ERR_NUM_ERRORS;
          707.   	if (es->top == es->bottom)
          708.   		es->bottom=(es->bottom+1)%ERR_NUM_ERRORS;

crypto/err/err.c:707:6: Taking false branch
          705.   
          706.   	es->top=(es->top+1)%ERR_NUM_ERRORS;
          707.   	if (es->top == es->bottom)
                      ^
          708.   		es->bottom=(es->bottom+1)%ERR_NUM_ERRORS;
          709.   	es->err_flags[es->top]=0;

crypto/err/err.c:709:2: 
          707.   	if (es->top == es->bottom)
          708.   		es->bottom=(es->bottom+1)%ERR_NUM_ERRORS;
          709. > 	es->err_flags[es->top]=0;
          710.   	es->err_buffer[es->top]=ERR_PACK(lib,func,reason);
          711.   	es->err_file[es->top]=file;

crypto/err/err.c:710:2: 
          708.   		es->bottom=(es->bottom+1)%ERR_NUM_ERRORS;
          709.   	es->err_flags[es->top]=0;
          710. > 	es->err_buffer[es->top]=ERR_PACK(lib,func,reason);
          711.   	es->err_file[es->top]=file;
          712.   	es->err_line[es->top]=line;

crypto/err/err.c:711:2: 
          709.   	es->err_flags[es->top]=0;
          710.   	es->err_buffer[es->top]=ERR_PACK(lib,func,reason);
          711. > 	es->err_file[es->top]=file;
          712.   	es->err_line[es->top]=line;
          713.   	err_clear_data(es,es->top);

crypto/err/err.c:712:2: 
          710.   	es->err_buffer[es->top]=ERR_PACK(lib,func,reason);
          711.   	es->err_file[es->top]=file;
          712. > 	es->err_line[es->top]=line;
          713.   	err_clear_data(es,es->top);
          714.   	}

crypto/err/err.c:713:2: Taking true branch
          711.   	es->err_file[es->top]=file;
          712.   	es->err_line[es->top]=line;
          713.   	err_clear_data(es,es->top);
                  ^
          714.   	}
          715.   

crypto/err/err.c:713:2: Taking false branch
          711.   	es->err_file[es->top]=file;
          712.   	es->err_line[es->top]=line;
          713.   	err_clear_data(es,es->top);
                  ^
          714.   	}
          715.   

crypto/err/err.c:713:2: Loop condition is false. Leaving loop
          711.   	es->err_file[es->top]=file;
          712.   	es->err_line[es->top]=line;
          713.   	err_clear_data(es,es->top);
                  ^
          714.   	}
          715.   

crypto/err/err.c:714:2: return from a call to ERR_put_error
          712.   	es->err_line[es->top]=line;
          713.   	err_clear_data(es,es->top);
          714.   	}
                  ^
          715.   
          716.   void ERR_clear_error(void)

crypto/buffer/buffer.c:71:3: 
        69.   		{
        70.   		BUFerr(BUF_F_BUF_MEM_NEW,ERR_R_MALLOC_FAILURE);
        71. > 		return(NULL);
        72.   		}
        73.   	ret->length=0;

crypto/buffer/buffer.c:77:2: return from a call to BUF_MEM_new
        75.   	ret->data=NULL;
        76.   	return(ret);
        77.   	}
               ^
        78.   
        79.   void BUF_MEM_free(BUF_MEM *a)

crypto/pem/pem_lib.c:671:7: Taking true branch
      669.   	headerB=BUF_MEM_new();
      670.   	dataB=BUF_MEM_new();
      671.   	if ((nameB == NULL) || (headerB == NULL) || (dataB == NULL))
                   ^
      672.   		{
      673.   		BUF_MEM_free(nameB);

crypto/pem/pem_lib.c:673:3: 
      671.   	if ((nameB == NULL) || (headerB == NULL) || (dataB == NULL))
      672.   		{
      673. > 		BUF_MEM_free(nameB);
      674.   		BUF_MEM_free(headerB);
      675.   		BUF_MEM_free(dataB);

crypto/buffer/buffer.c:79:1: start of procedure BUF_MEM_free()
        77.   	}
        78.   
        79. > void BUF_MEM_free(BUF_MEM *a)
        80.   	{
        81.   	if(a == NULL)

crypto/buffer/buffer.c:81:5: Taking true branch
        79.   void BUF_MEM_free(BUF_MEM *a)
        80.   	{
        81.   	if(a == NULL)
                  ^
        82.   	    return;
        83.   

crypto/buffer/buffer.c:82:6: 
        80.   	{
        81.   	if(a == NULL)
        82. > 	    return;
        83.   
        84.   	if (a->data != NULL)

crypto/buffer/buffer.c:90:2: return from a call to BUF_MEM_free
        88.   		}
        89.   	OPENSSL_free(a);
        90.   	}
               ^
        91.   
        92.   int BUF_MEM_grow(BUF_MEM *str, int len)

crypto/pem/pem_lib.c:674:3: 
      672.   		{
      673.   		BUF_MEM_free(nameB);
      674. > 		BUF_MEM_free(headerB);
      675.   		BUF_MEM_free(dataB);
      676.   		PEMerr(PEM_F_PEM_READ_BIO,ERR_R_MALLOC_FAILURE);

crypto/buffer/buffer.c:79:1: start of procedure BUF_MEM_free()
        77.   	}
        78.   
        79. > void BUF_MEM_free(BUF_MEM *a)
        80.   	{
        81.   	if(a == NULL)

crypto/buffer/buffer.c:81:5: Taking true branch
        79.   void BUF_MEM_free(BUF_MEM *a)
        80.   	{
        81.   	if(a == NULL)
                  ^
        82.   	    return;
        83.   

crypto/buffer/buffer.c:82:6: 
        80.   	{
        81.   	if(a == NULL)
        82. > 	    return;
        83.   
        84.   	if (a->data != NULL)

crypto/buffer/buffer.c:90:2: return from a call to BUF_MEM_free
        88.   		}
        89.   	OPENSSL_free(a);
        90.   	}
               ^
        91.   
        92.   int BUF_MEM_grow(BUF_MEM *str, int len)

crypto/pem/pem_lib.c:675:3: 
      673.   		BUF_MEM_free(nameB);
      674.   		BUF_MEM_free(headerB);
      675. > 		BUF_MEM_free(dataB);
      676.   		PEMerr(PEM_F_PEM_READ_BIO,ERR_R_MALLOC_FAILURE);
      677.   		return(0);

crypto/buffer/buffer.c:79:1: start of procedure BUF_MEM_free()
        77.   	}
        78.   
        79. > void BUF_MEM_free(BUF_MEM *a)
        80.   	{
        81.   	if(a == NULL)

crypto/buffer/buffer.c:81:5: Taking true branch
        79.   void BUF_MEM_free(BUF_MEM *a)
        80.   	{
        81.   	if(a == NULL)
                  ^
        82.   	    return;
        83.   

crypto/buffer/buffer.c:82:6: 
        80.   	{
        81.   	if(a == NULL)
        82. > 	    return;
        83.   
        84.   	if (a->data != NULL)

crypto/buffer/buffer.c:90:2: return from a call to BUF_MEM_free
        88.   		}
        89.   	OPENSSL_free(a);
        90.   	}
               ^
        91.   
        92.   int BUF_MEM_grow(BUF_MEM *str, int len)

crypto/pem/pem_lib.c:676:3: 
      674.   		BUF_MEM_free(headerB);
      675.   		BUF_MEM_free(dataB);
      676. > 		PEMerr(PEM_F_PEM_READ_BIO,ERR_R_MALLOC_FAILURE);
      677.   		return(0);
      678.   		}

crypto/err/err.c:680:1: start of procedure ERR_put_error()
        678.   /********************************************************/
        679.   
        680. > void ERR_put_error(int lib, int func, int reason, const char *file,
        681.   	     int line)
        682.   	{

crypto/err/err.c:704:2: Skipping ERR_get_state(): empty list of specs
        702.   	}
        703.   #endif
        704.   	es=ERR_get_state();
                ^
        705.   
        706.   	es->top=(es->top+1)%ERR_NUM_ERRORS;

crypto/err/err.c:706:2: 
        704.   	es=ERR_get_state();
        705.   
        706. > 	es->top=(es->top+1)%ERR_NUM_ERRORS;
        707.   	if (es->top == es->bottom)
        708.   		es->bottom=(es->bottom+1)%ERR_NUM_ERRORS;

crypto/err/err.c:707:6: Taking false branch
        705.   
        706.   	es->top=(es->top+1)%ERR_NUM_ERRORS;
        707.   	if (es->top == es->bottom)
                    ^
        708.   		es->bottom=(es->bottom+1)%ERR_NUM_ERRORS;
        709.   	es->err_flags[es->top]=0;

crypto/err/err.c:709:2: 
        707.   	if (es->top == es->bottom)
        708.   		es->bottom=(es->bottom+1)%ERR_NUM_ERRORS;
        709. > 	es->err_flags[es->top]=0;
        710.   	es->err_buffer[es->top]=ERR_PACK(lib,func,reason);
        711.   	es->err_file[es->top]=file;

crypto/err/err.c:710:2: 
        708.   		es->bottom=(es->bottom+1)%ERR_NUM_ERRORS;
        709.   	es->err_flags[es->top]=0;
        710. > 	es->err_buffer[es->top]=ERR_PACK(lib,func,reason);
        711.   	es->err_file[es->top]=file;
        712.   	es->err_line[es->top]=line;

crypto/err/err.c:711:2: 
        709.   	es->err_flags[es->top]=0;
        710.   	es->err_buffer[es->top]=ERR_PACK(lib,func,reason);
        711. > 	es->err_file[es->top]=file;
        712.   	es->err_line[es->top]=line;
        713.   	err_clear_data(es,es->top);

crypto/err/err.c:712:2: 
        710.   	es->err_buffer[es->top]=ERR_PACK(lib,func,reason);
        711.   	es->err_file[es->top]=file;
        712. > 	es->err_line[es->top]=line;
        713.   	err_clear_data(es,es->top);
        714.   	}

crypto/err/err.c:713:2: Taking true branch
        711.   	es->err_file[es->top]=file;
        712.   	es->err_line[es->top]=line;
        713.   	err_clear_data(es,es->top);
                ^
        714.   	}
        715.   

crypto/err/err.c:713:2: Taking false branch
        711.   	es->err_file[es->top]=file;
        712.   	es->err_line[es->top]=line;
        713.   	err_clear_data(es,es->top);
                ^
        714.   	}
        715.   

crypto/err/err.c:713:2: Loop condition is false. Leaving loop
        711.   	es->err_file[es->top]=file;
        712.   	es->err_line[es->top]=line;
        713.   	err_clear_data(es,es->top);
                ^
        714.   	}
        715.   

crypto/err/err.c:714:2: return from a call to ERR_put_error
        712.   	es->err_line[es->top]=line;
        713.   	err_clear_data(es,es->top);
        714.   	}
                ^
        715.   
        716.   void ERR_clear_error(void)

crypto/pem/pem_lib.c:677:3: 
      675.   		BUF_MEM_free(dataB);
      676.   		PEMerr(PEM_F_PEM_READ_BIO,ERR_R_MALLOC_FAILURE);
      677. > 		return(0);
      678.   		}
      679.   

crypto/pem/pem_lib.c:821:2: return from a call to PEM_read_bio
      819.   	BUF_MEM_free(dataB);
      820.   	return(0);
      821.   	}
              ^
      822.   
      823.   /* Check pem string and return prefix length.

crypto/pem/pem_lib.c:273:8: Taking true branch
    271.   	for (;;)
    272.   		{
    273.   		if (!PEM_read_bio(bp,&nm,&header,&data,&len)) {
                  ^
    274.   			if(ERR_GET_REASON(ERR_peek_error()) ==
    275.   				PEM_R_NO_START_LINE)

crypto/pem/pem_lib.c:274:7: 
    272.   		{
    273.   		if (!PEM_read_bio(bp,&nm,&header,&data,&len)) {
    274. > 			if(ERR_GET_REASON(ERR_peek_error()) ==
    275.   				PEM_R_NO_START_LINE)
    276.   				ERR_add_error_data(2, "Expecting: ", name);

crypto/err/err.c:743:1: start of procedure ERR_peek_error()
      741.   
      742.   
      743. > unsigned long ERR_peek_error(void)
      744.   	{ return(get_error_values(0,0,NULL,NULL,NULL,NULL)); }
      745.   

crypto/err/err.c:744:4: Skipping get_error_values(): empty list of specs
      742.   
      743.   unsigned long ERR_peek_error(void)
      744.   	{ return(get_error_values(0,0,NULL,NULL,NULL,NULL)); }
                ^
      745.   
      746.   unsigned long ERR_peek_error_line(const char **file, int *line)

crypto/err/err.c:744:55: return from a call to ERR_peek_error
      742.   
      743.   unsigned long ERR_peek_error(void)
      744.   	{ return(get_error_values(0,0,NULL,NULL,NULL,NULL)); }
                                                                   ^
      745.   
      746.   unsigned long ERR_peek_error_line(const char **file, int *line)

crypto/pem/pem_lib.c:274:7: Taking false branch
    272.   		{
    273.   		if (!PEM_read_bio(bp,&nm,&header,&data,&len)) {
    274.   			if(ERR_GET_REASON(ERR_peek_error()) ==
                 ^
    275.   				PEM_R_NO_START_LINE)
    276.   				ERR_add_error_data(2, "Expecting: ", name);

crypto/pem/pem_lib.c:277:4: 
    275.   				PEM_R_NO_START_LINE)
    276.   				ERR_add_error_data(2, "Expecting: ", name);
    277. > 			return 0;
    278.   		}
    279.   		if(check_pem(nm, name)) break;

crypto/pem/pem_lib.c:300:2: return from a call to PEM_bytes_read_bio
    298.   	if (!ret) OPENSSL_free(data);
    299.   	return ret;
    300.   	}
            ^
    301.   
    302.   #ifndef OPENSSL_NO_FP_API

crypto/pem/pem_pkey.c:84:7: Taking true branch
  82.   	EVP_PKEY *ret=NULL;
  83.   
  84.   	if (!PEM_bytes_read_bio(&data, &len, &nm, PEM_STRING_EVP_PKEY, bp, cb, u))
              ^
  85.   		return NULL;
  86.   	p = data;

crypto/pem/pem_pkey.c:85:3: 
  83.   
  84.   	if (!PEM_bytes_read_bio(&data, &len, &nm, PEM_STRING_EVP_PKEY, bp, cb, u))
  85. > 		return NULL;
  86.   	p = data;
  87.   

crypto/pem/pem_pkey.c:138:2: return from a call to PEM_read_bio_PrivateKey
  136.   	OPENSSL_free(data);
  137.   	return(ret);
  138.   	}
          ^
  139.   
  140.   int PEM_write_bio_PrivateKey(BIO *bp, EVP_PKEY *x, const EVP_CIPHER *enc,

crypto/pem/pem_all.c:223:2: 
221.   	EVP_PKEY *pktmp;
222.   	pktmp = PEM_read_bio_PrivateKey(bp, NULL, cb, u);
223. > 	return pkey_get_dsa(pktmp, dsa);	/* will free pktmp */
224.   }
225.   
