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


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

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

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

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

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

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

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

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

crypto/pem/pem_lib.c:243:1: start of procedure PEM_bytes_read_bio()
    241.   }
    242.   
    243. > int PEM_bytes_read_bio(unsigned char **pdata, long *plen, char **pnm, const char *name, BIO *bp,
    244.   	     pem_password_cb *cb, void *u)
    245.   	{

crypto/pem/pem_lib.c:247:2: 
    245.   	{
    246.   	EVP_CIPHER_INFO cipher;
    247. > 	char *nm=NULL,*header=NULL;
    248.   	unsigned char *data=NULL;
    249.   	long len;

crypto/pem/pem_lib.c:248:2: 
    246.   	EVP_CIPHER_INFO cipher;
    247.   	char *nm=NULL,*header=NULL;
    248. > 	unsigned char *data=NULL;
    249.   	long len;
    250.   	int ret = 0;

crypto/pem/pem_lib.c:250:2: 
    248.   	unsigned char *data=NULL;
    249.   	long len;
    250. > 	int ret = 0;
    251.   
    252.   	for (;;)

crypto/pem/pem_lib.c:264:3: Loop condition is true. Entering loop body
    262.   		OPENSSL_free(header);
    263.   		OPENSSL_free(data);
    264.   		}
             ^
    265.   	if (!PEM_get_EVP_CIPHER_INFO(header,&cipher)) goto err;
    266.   	if (!PEM_do_header(&cipher,data,&len,cb,u)) goto err;

crypto/pem/pem_lib.c:254:8: 
    252.   	for (;;)
    253.   		{
    254. > 		if (!PEM_read_bio(bp,&nm,&header,&data,&len)) {
    255.   			if(ERR_GET_REASON(ERR_peek_error()) ==
    256.   				PEM_R_NO_START_LINE)

crypto/pem/pem_lib.c:636:1: start of procedure PEM_read_bio()
      634.   #endif
      635.   
      636. > int PEM_read_bio(BIO *bp, char **name, char **header, unsigned char **data,
      637.   	     long *len)
      638.   	{

crypto/pem/pem_lib.c:640:2: 
      638.   	{
      639.   	EVP_ENCODE_CTX ctx;
      640. > 	int end=0,i,k,bl=0,hl=0,nohead=0;
      641.   	char buf[256];
      642.   	BUF_MEM *nameB;

crypto/pem/pem_lib.c:646:2: 
      644.   	BUF_MEM *dataB,*tmpB;
      645.   	
      646. > 	nameB=BUF_MEM_new();
      647.   	headerB=BUF_MEM_new();
      648.   	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:291:1: start of procedure CRYPTO_malloc()
          289.   	}
          290.   
          291. > void *CRYPTO_malloc(int num, const char *file, int line)
          292.   	{
          293.   	void *ret = NULL;

crypto/mem.c:293:2: 
          291.   void *CRYPTO_malloc(int num, const char *file, int line)
          292.   	{
          293. > 	void *ret = NULL;
          294.   	extern unsigned char cleanse_ctr;
          295.   

crypto/mem.c:296:6: Taking false branch
          294.   	extern unsigned char cleanse_ctr;
          295.   
          296.   	if (num <= 0) return NULL;
                      ^
          297.   
          298.   	allow_customize = 0;

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

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

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

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

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

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

crypto/mem.c:309:3: Skipping __function_pointer__(): unresolved function pointer
          307.   #endif
          308.   	if (malloc_debug_func != NULL)
          309.   		malloc_debug_func(ret, num, file, line, 1);
                   ^
          310.   
          311.           /* Create a dependency on the value of 'cleanse_ctr' so our memory

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

crypto/mem.c:317:2: 
          315.                   ((unsigned char *)ret)[0] = cleanse_ctr;
          316.   
          317. > 	return ret;
          318.   	}
          319.   

crypto/mem.c:318:2: return from a call to CRYPTO_malloc
          316.   
          317.   	return ret;
          318.   	}
                  ^
          319.   
          320.   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:668:1: start of procedure ERR_put_error()
          666.   /********************************************************/
          667.   
          668. > void ERR_put_error(int lib, int func, int reason, const char *file,
          669.   	     int line)
          670.   	{

crypto/err/err.c:692:2: Skipping ERR_get_state(): empty list of specs
          690.   	}
          691.   #endif
          692.   	es=ERR_get_state();
                  ^
          693.   
          694.   	es->top=(es->top+1)%ERR_NUM_ERRORS;

crypto/err/err.c:694:2: 
          692.   	es=ERR_get_state();
          693.   
          694. > 	es->top=(es->top+1)%ERR_NUM_ERRORS;
          695.   	if (es->top == es->bottom)
          696.   		es->bottom=(es->bottom+1)%ERR_NUM_ERRORS;

crypto/err/err.c:695:6: Taking false branch
          693.   
          694.   	es->top=(es->top+1)%ERR_NUM_ERRORS;
          695.   	if (es->top == es->bottom)
                      ^
          696.   		es->bottom=(es->bottom+1)%ERR_NUM_ERRORS;
          697.   	es->err_flags[es->top]=0;

crypto/err/err.c:697:2: 
          695.   	if (es->top == es->bottom)
          696.   		es->bottom=(es->bottom+1)%ERR_NUM_ERRORS;
          697. > 	es->err_flags[es->top]=0;
          698.   	es->err_buffer[es->top]=ERR_PACK(lib,func,reason);
          699.   	es->err_file[es->top]=file;

crypto/err/err.c:698:2: 
          696.   		es->bottom=(es->bottom+1)%ERR_NUM_ERRORS;
          697.   	es->err_flags[es->top]=0;
          698. > 	es->err_buffer[es->top]=ERR_PACK(lib,func,reason);
          699.   	es->err_file[es->top]=file;
          700.   	es->err_line[es->top]=line;

crypto/err/err.c:699:2: 
          697.   	es->err_flags[es->top]=0;
          698.   	es->err_buffer[es->top]=ERR_PACK(lib,func,reason);
          699. > 	es->err_file[es->top]=file;
          700.   	es->err_line[es->top]=line;
          701.   	err_clear_data(es,es->top);

crypto/err/err.c:700:2: 
          698.   	es->err_buffer[es->top]=ERR_PACK(lib,func,reason);
          699.   	es->err_file[es->top]=file;
          700. > 	es->err_line[es->top]=line;
          701.   	err_clear_data(es,es->top);
          702.   	}

crypto/err/err.c:701:2: Taking true branch
          699.   	es->err_file[es->top]=file;
          700.   	es->err_line[es->top]=line;
          701.   	err_clear_data(es,es->top);
                  ^
          702.   	}
          703.   

crypto/err/err.c:701:2: Taking false branch
          699.   	es->err_file[es->top]=file;
          700.   	es->err_line[es->top]=line;
          701.   	err_clear_data(es,es->top);
                  ^
          702.   	}
          703.   

crypto/err/err.c:701:2: Loop condition is false. Leaving loop
          699.   	es->err_file[es->top]=file;
          700.   	es->err_line[es->top]=line;
          701.   	err_clear_data(es,es->top);
                  ^
          702.   	}
          703.   

crypto/err/err.c:702:2: return from a call to ERR_put_error
          700.   	es->err_line[es->top]=line;
          701.   	err_clear_data(es,es->top);
          702.   	}
                  ^
          703.   
          704.   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:647:2: 
      645.   	
      646.   	nameB=BUF_MEM_new();
      647. > 	headerB=BUF_MEM_new();
      648.   	dataB=BUF_MEM_new();
      649.   	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:291:1: start of procedure CRYPTO_malloc()
          289.   	}
          290.   
          291. > void *CRYPTO_malloc(int num, const char *file, int line)
          292.   	{
          293.   	void *ret = NULL;

crypto/mem.c:293:2: 
          291.   void *CRYPTO_malloc(int num, const char *file, int line)
          292.   	{
          293. > 	void *ret = NULL;
          294.   	extern unsigned char cleanse_ctr;
          295.   

crypto/mem.c:296:6: Taking false branch
          294.   	extern unsigned char cleanse_ctr;
          295.   
          296.   	if (num <= 0) return NULL;
                      ^
          297.   
          298.   	allow_customize = 0;

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

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

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

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

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

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

crypto/mem.c:309:3: Skipping __function_pointer__(): unresolved function pointer
          307.   #endif
          308.   	if (malloc_debug_func != NULL)
          309.   		malloc_debug_func(ret, num, file, line, 1);
                   ^
          310.   
          311.           /* Create a dependency on the value of 'cleanse_ctr' so our memory

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

crypto/mem.c:317:2: 
          315.                   ((unsigned char *)ret)[0] = cleanse_ctr;
          316.   
          317. > 	return ret;
          318.   	}
          319.   

crypto/mem.c:318:2: return from a call to CRYPTO_malloc
          316.   
          317.   	return ret;
          318.   	}
                  ^
          319.   
          320.   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:668:1: start of procedure ERR_put_error()
          666.   /********************************************************/
          667.   
          668. > void ERR_put_error(int lib, int func, int reason, const char *file,
          669.   	     int line)
          670.   	{

crypto/err/err.c:692:2: Skipping ERR_get_state(): empty list of specs
          690.   	}
          691.   #endif
          692.   	es=ERR_get_state();
                  ^
          693.   
          694.   	es->top=(es->top+1)%ERR_NUM_ERRORS;

crypto/err/err.c:694:2: 
          692.   	es=ERR_get_state();
          693.   
          694. > 	es->top=(es->top+1)%ERR_NUM_ERRORS;
          695.   	if (es->top == es->bottom)
          696.   		es->bottom=(es->bottom+1)%ERR_NUM_ERRORS;

crypto/err/err.c:695:6: Taking false branch
          693.   
          694.   	es->top=(es->top+1)%ERR_NUM_ERRORS;
          695.   	if (es->top == es->bottom)
                      ^
          696.   		es->bottom=(es->bottom+1)%ERR_NUM_ERRORS;
          697.   	es->err_flags[es->top]=0;

crypto/err/err.c:697:2: 
          695.   	if (es->top == es->bottom)
          696.   		es->bottom=(es->bottom+1)%ERR_NUM_ERRORS;
          697. > 	es->err_flags[es->top]=0;
          698.   	es->err_buffer[es->top]=ERR_PACK(lib,func,reason);
          699.   	es->err_file[es->top]=file;

crypto/err/err.c:698:2: 
          696.   		es->bottom=(es->bottom+1)%ERR_NUM_ERRORS;
          697.   	es->err_flags[es->top]=0;
          698. > 	es->err_buffer[es->top]=ERR_PACK(lib,func,reason);
          699.   	es->err_file[es->top]=file;
          700.   	es->err_line[es->top]=line;

crypto/err/err.c:699:2: 
          697.   	es->err_flags[es->top]=0;
          698.   	es->err_buffer[es->top]=ERR_PACK(lib,func,reason);
          699. > 	es->err_file[es->top]=file;
          700.   	es->err_line[es->top]=line;
          701.   	err_clear_data(es,es->top);

crypto/err/err.c:700:2: 
          698.   	es->err_buffer[es->top]=ERR_PACK(lib,func,reason);
          699.   	es->err_file[es->top]=file;
          700. > 	es->err_line[es->top]=line;
          701.   	err_clear_data(es,es->top);
          702.   	}

crypto/err/err.c:701:2: Taking true branch
          699.   	es->err_file[es->top]=file;
          700.   	es->err_line[es->top]=line;
          701.   	err_clear_data(es,es->top);
                  ^
          702.   	}
          703.   

crypto/err/err.c:701:2: Taking false branch
          699.   	es->err_file[es->top]=file;
          700.   	es->err_line[es->top]=line;
          701.   	err_clear_data(es,es->top);
                  ^
          702.   	}
          703.   

crypto/err/err.c:701:2: Loop condition is false. Leaving loop
          699.   	es->err_file[es->top]=file;
          700.   	es->err_line[es->top]=line;
          701.   	err_clear_data(es,es->top);
                  ^
          702.   	}
          703.   

crypto/err/err.c:702:2: return from a call to ERR_put_error
          700.   	es->err_line[es->top]=line;
          701.   	err_clear_data(es,es->top);
          702.   	}
                  ^
          703.   
          704.   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:648:2: 
      646.   	nameB=BUF_MEM_new();
      647.   	headerB=BUF_MEM_new();
      648. > 	dataB=BUF_MEM_new();
      649.   	if ((nameB == NULL) || (headerB == NULL) || (dataB == NULL))
      650.   		{

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:291:1: start of procedure CRYPTO_malloc()
          289.   	}
          290.   
          291. > void *CRYPTO_malloc(int num, const char *file, int line)
          292.   	{
          293.   	void *ret = NULL;

crypto/mem.c:293:2: 
          291.   void *CRYPTO_malloc(int num, const char *file, int line)
          292.   	{
          293. > 	void *ret = NULL;
          294.   	extern unsigned char cleanse_ctr;
          295.   

crypto/mem.c:296:6: Taking false branch
          294.   	extern unsigned char cleanse_ctr;
          295.   
          296.   	if (num <= 0) return NULL;
                      ^
          297.   
          298.   	allow_customize = 0;

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

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

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

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

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

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

crypto/mem.c:309:3: Skipping __function_pointer__(): unresolved function pointer
          307.   #endif
          308.   	if (malloc_debug_func != NULL)
          309.   		malloc_debug_func(ret, num, file, line, 1);
                   ^
          310.   
          311.           /* Create a dependency on the value of 'cleanse_ctr' so our memory

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

crypto/mem.c:317:2: 
          315.                   ((unsigned char *)ret)[0] = cleanse_ctr;
          316.   
          317. > 	return ret;
          318.   	}
          319.   

crypto/mem.c:318:2: return from a call to CRYPTO_malloc
          316.   
          317.   	return ret;
          318.   	}
                  ^
          319.   
          320.   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:668:1: start of procedure ERR_put_error()
          666.   /********************************************************/
          667.   
          668. > void ERR_put_error(int lib, int func, int reason, const char *file,
          669.   	     int line)
          670.   	{

crypto/err/err.c:692:2: Skipping ERR_get_state(): empty list of specs
          690.   	}
          691.   #endif
          692.   	es=ERR_get_state();
                  ^
          693.   
          694.   	es->top=(es->top+1)%ERR_NUM_ERRORS;

crypto/err/err.c:694:2: 
          692.   	es=ERR_get_state();
          693.   
          694. > 	es->top=(es->top+1)%ERR_NUM_ERRORS;
          695.   	if (es->top == es->bottom)
          696.   		es->bottom=(es->bottom+1)%ERR_NUM_ERRORS;

crypto/err/err.c:695:6: Taking false branch
          693.   
          694.   	es->top=(es->top+1)%ERR_NUM_ERRORS;
          695.   	if (es->top == es->bottom)
                      ^
          696.   		es->bottom=(es->bottom+1)%ERR_NUM_ERRORS;
          697.   	es->err_flags[es->top]=0;

crypto/err/err.c:697:2: 
          695.   	if (es->top == es->bottom)
          696.   		es->bottom=(es->bottom+1)%ERR_NUM_ERRORS;
          697. > 	es->err_flags[es->top]=0;
          698.   	es->err_buffer[es->top]=ERR_PACK(lib,func,reason);
          699.   	es->err_file[es->top]=file;

crypto/err/err.c:698:2: 
          696.   		es->bottom=(es->bottom+1)%ERR_NUM_ERRORS;
          697.   	es->err_flags[es->top]=0;
          698. > 	es->err_buffer[es->top]=ERR_PACK(lib,func,reason);
          699.   	es->err_file[es->top]=file;
          700.   	es->err_line[es->top]=line;

crypto/err/err.c:699:2: 
          697.   	es->err_flags[es->top]=0;
          698.   	es->err_buffer[es->top]=ERR_PACK(lib,func,reason);
          699. > 	es->err_file[es->top]=file;
          700.   	es->err_line[es->top]=line;
          701.   	err_clear_data(es,es->top);

crypto/err/err.c:700:2: 
          698.   	es->err_buffer[es->top]=ERR_PACK(lib,func,reason);
          699.   	es->err_file[es->top]=file;
          700. > 	es->err_line[es->top]=line;
          701.   	err_clear_data(es,es->top);
          702.   	}

crypto/err/err.c:701:2: Taking true branch
          699.   	es->err_file[es->top]=file;
          700.   	es->err_line[es->top]=line;
          701.   	err_clear_data(es,es->top);
                  ^
          702.   	}
          703.   

crypto/err/err.c:701:2: Taking false branch
          699.   	es->err_file[es->top]=file;
          700.   	es->err_line[es->top]=line;
          701.   	err_clear_data(es,es->top);
                  ^
          702.   	}
          703.   

crypto/err/err.c:701:2: Loop condition is false. Leaving loop
          699.   	es->err_file[es->top]=file;
          700.   	es->err_line[es->top]=line;
          701.   	err_clear_data(es,es->top);
                  ^
          702.   	}
          703.   

crypto/err/err.c:702:2: return from a call to ERR_put_error
          700.   	es->err_line[es->top]=line;
          701.   	err_clear_data(es,es->top);
          702.   	}
                  ^
          703.   
          704.   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:649:7: Taking true branch
      647.   	headerB=BUF_MEM_new();
      648.   	dataB=BUF_MEM_new();
      649.   	if ((nameB == NULL) || (headerB == NULL) || (dataB == NULL))
                   ^
      650.   		{
      651.   		BUF_MEM_free(nameB);

crypto/pem/pem_lib.c:651:3: 
      649.   	if ((nameB == NULL) || (headerB == NULL) || (dataB == NULL))
      650.   		{
      651. > 		BUF_MEM_free(nameB);
      652.   		BUF_MEM_free(headerB);
      653.   		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:652:3: 
      650.   		{
      651.   		BUF_MEM_free(nameB);
      652. > 		BUF_MEM_free(headerB);
      653.   		BUF_MEM_free(dataB);
      654.   		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:653:3: 
      651.   		BUF_MEM_free(nameB);
      652.   		BUF_MEM_free(headerB);
      653. > 		BUF_MEM_free(dataB);
      654.   		PEMerr(PEM_F_PEM_READ_BIO,ERR_R_MALLOC_FAILURE);
      655.   		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:654:3: 
      652.   		BUF_MEM_free(headerB);
      653.   		BUF_MEM_free(dataB);
      654. > 		PEMerr(PEM_F_PEM_READ_BIO,ERR_R_MALLOC_FAILURE);
      655.   		return(0);
      656.   		}

crypto/err/err.c:668:1: start of procedure ERR_put_error()
        666.   /********************************************************/
        667.   
        668. > void ERR_put_error(int lib, int func, int reason, const char *file,
        669.   	     int line)
        670.   	{

crypto/err/err.c:692:2: Skipping ERR_get_state(): empty list of specs
        690.   	}
        691.   #endif
        692.   	es=ERR_get_state();
                ^
        693.   
        694.   	es->top=(es->top+1)%ERR_NUM_ERRORS;

crypto/err/err.c:694:2: 
        692.   	es=ERR_get_state();
        693.   
        694. > 	es->top=(es->top+1)%ERR_NUM_ERRORS;
        695.   	if (es->top == es->bottom)
        696.   		es->bottom=(es->bottom+1)%ERR_NUM_ERRORS;

crypto/err/err.c:695:6: Taking false branch
        693.   
        694.   	es->top=(es->top+1)%ERR_NUM_ERRORS;
        695.   	if (es->top == es->bottom)
                    ^
        696.   		es->bottom=(es->bottom+1)%ERR_NUM_ERRORS;
        697.   	es->err_flags[es->top]=0;

crypto/err/err.c:697:2: 
        695.   	if (es->top == es->bottom)
        696.   		es->bottom=(es->bottom+1)%ERR_NUM_ERRORS;
        697. > 	es->err_flags[es->top]=0;
        698.   	es->err_buffer[es->top]=ERR_PACK(lib,func,reason);
        699.   	es->err_file[es->top]=file;

crypto/err/err.c:698:2: 
        696.   		es->bottom=(es->bottom+1)%ERR_NUM_ERRORS;
        697.   	es->err_flags[es->top]=0;
        698. > 	es->err_buffer[es->top]=ERR_PACK(lib,func,reason);
        699.   	es->err_file[es->top]=file;
        700.   	es->err_line[es->top]=line;

crypto/err/err.c:699:2: 
        697.   	es->err_flags[es->top]=0;
        698.   	es->err_buffer[es->top]=ERR_PACK(lib,func,reason);
        699. > 	es->err_file[es->top]=file;
        700.   	es->err_line[es->top]=line;
        701.   	err_clear_data(es,es->top);

crypto/err/err.c:700:2: 
        698.   	es->err_buffer[es->top]=ERR_PACK(lib,func,reason);
        699.   	es->err_file[es->top]=file;
        700. > 	es->err_line[es->top]=line;
        701.   	err_clear_data(es,es->top);
        702.   	}

crypto/err/err.c:701:2: Taking true branch
        699.   	es->err_file[es->top]=file;
        700.   	es->err_line[es->top]=line;
        701.   	err_clear_data(es,es->top);
                ^
        702.   	}
        703.   

crypto/err/err.c:701:2: Taking false branch
        699.   	es->err_file[es->top]=file;
        700.   	es->err_line[es->top]=line;
        701.   	err_clear_data(es,es->top);
                ^
        702.   	}
        703.   

crypto/err/err.c:701:2: Loop condition is false. Leaving loop
        699.   	es->err_file[es->top]=file;
        700.   	es->err_line[es->top]=line;
        701.   	err_clear_data(es,es->top);
                ^
        702.   	}
        703.   

crypto/err/err.c:702:2: return from a call to ERR_put_error
        700.   	es->err_line[es->top]=line;
        701.   	err_clear_data(es,es->top);
        702.   	}
                ^
        703.   
        704.   void ERR_clear_error(void)

crypto/pem/pem_lib.c:655:3: 
      653.   		BUF_MEM_free(dataB);
      654.   		PEMerr(PEM_F_PEM_READ_BIO,ERR_R_MALLOC_FAILURE);
      655. > 		return(0);
      656.   		}
      657.   

crypto/pem/pem_lib.c:799:2: return from a call to PEM_read_bio
      797.   	BUF_MEM_free(dataB);
      798.   	return(0);
      799.   	}
              ^
      800.   
      801.   /* Check pem string and return prefix length.

crypto/pem/pem_lib.c:254:8: Taking true branch
    252.   	for (;;)
    253.   		{
    254.   		if (!PEM_read_bio(bp,&nm,&header,&data,&len)) {
                  ^
    255.   			if(ERR_GET_REASON(ERR_peek_error()) ==
    256.   				PEM_R_NO_START_LINE)

crypto/pem/pem_lib.c:255:7: 
    253.   		{
    254.   		if (!PEM_read_bio(bp,&nm,&header,&data,&len)) {
    255. > 			if(ERR_GET_REASON(ERR_peek_error()) ==
    256.   				PEM_R_NO_START_LINE)
    257.   				ERR_add_error_data(2, "Expecting: ", name);

crypto/err/err.c:731:1: start of procedure ERR_peek_error()
      729.   
      730.   
      731. > unsigned long ERR_peek_error(void)
      732.   	{ return(get_error_values(0,0,NULL,NULL,NULL,NULL)); }
      733.   

crypto/err/err.c:732:4: Skipping get_error_values(): empty list of specs
      730.   
      731.   unsigned long ERR_peek_error(void)
      732.   	{ return(get_error_values(0,0,NULL,NULL,NULL,NULL)); }
                ^
      733.   
      734.   unsigned long ERR_peek_error_line(const char **file, int *line)

crypto/err/err.c:732:55: return from a call to ERR_peek_error
      730.   
      731.   unsigned long ERR_peek_error(void)
      732.   	{ return(get_error_values(0,0,NULL,NULL,NULL,NULL)); }
                                                                   ^
      733.   
      734.   unsigned long ERR_peek_error_line(const char **file, int *line)

crypto/pem/pem_lib.c:255:7: Taking false branch
    253.   		{
    254.   		if (!PEM_read_bio(bp,&nm,&header,&data,&len)) {
    255.   			if(ERR_GET_REASON(ERR_peek_error()) ==
                 ^
    256.   				PEM_R_NO_START_LINE)
    257.   				ERR_add_error_data(2, "Expecting: ", name);

crypto/pem/pem_lib.c:258:4: 
    256.   				PEM_R_NO_START_LINE)
    257.   				ERR_add_error_data(2, "Expecting: ", name);
    258. > 			return 0;
    259.   		}
    260.   		if(check_pem(nm, name)) break;

crypto/pem/pem_lib.c:281:2: return from a call to PEM_bytes_read_bio
    279.   	if (!ret) OPENSSL_free(data);
    280.   	return ret;
    281.   	}
            ^
    282.   
    283.   #ifndef OPENSSL_NO_FP_API

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

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

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

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