ssl/d1_lib.c:163: error: MEMORY_LEAK
  memory dynamically allocated by call to `CRYPTO_zalloc()` at line 139, column 15 is not reachable after line 163, column 5.
Showing all 146 steps of the trace


ssl/d1_lib.c:129:1: start of procedure dtls1_new()
127.   }
128.   
129. > int dtls1_new(SSL *s)
130.   {
131.       DTLS1_STATE *d1;

ssl/d1_lib.c:133:10: 
131.       DTLS1_STATE *d1;
132.   
133. >     if (!DTLS_RECORD_LAYER_new(&s->rlayer)) {
134.           return 0;
135.       }

ssl/record/rec_layer_d1.c:124:1: start of procedure DTLS_RECORD_LAYER_new()
  122.   #include "record_locl.h"
  123.   
  124. > int DTLS_RECORD_LAYER_new(RECORD_LAYER *rl)
  125.   {
  126.       DTLS_RECORD_LAYER *d;

ssl/record/rec_layer_d1.c:128:9: 
  126.       DTLS_RECORD_LAYER *d;
  127.       
  128. >     if ((d = OPENSSL_malloc(sizeof(*d))) == NULL)
  129.           return (0);
  130.   

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)

ssl/record/rec_layer_d1.c:128:9: Taking false branch
  126.       DTLS_RECORD_LAYER *d;
  127.       
  128.       if ((d = OPENSSL_malloc(sizeof(*d))) == NULL)
                 ^
  129.           return (0);
  130.   

ssl/record/rec_layer_d1.c:132:5: 
  130.   
  131.   
  132. >     rl->d = d;
  133.   
  134.       d->unprocessed_rcds.q = pqueue_new();

ssl/record/rec_layer_d1.c:134:5: 
  132.       rl->d = d;
  133.   
  134. >     d->unprocessed_rcds.q = pqueue_new();
  135.       d->processed_rcds.q = pqueue_new();
  136.       d->buffered_app_data.q = pqueue_new();

ssl/pqueue.c:86:1: start of procedure pqueue_new()
    84.   }
    85.   
    86. > pqueue *pqueue_new()
    87.   {
    88.       pqueue *pq = OPENSSL_zalloc(sizeof(*pq));

ssl/pqueue.c:88:5: 
    86.   pqueue *pqueue_new()
    87.   {
    88. >     pqueue *pq = OPENSSL_zalloc(sizeof(*pq));
    89.   
    90.       return pq;

crypto/mem.c:156:1: start of procedure CRYPTO_zalloc()
      154.   }
      155.   
      156. > void *CRYPTO_zalloc(size_t num, const char *file, int line)
      157.   {
      158.       void *ret = CRYPTO_malloc(num, file, line);

crypto/mem.c:158:5: 
      156.   void *CRYPTO_zalloc(size_t num, const char *file, int line)
      157.   {
      158. >     void *ret = CRYPTO_malloc(num, file, line);
      159.   
      160.       if (ret != NULL)

crypto/mem.c:119:1: start of procedure CRYPTO_malloc()
        117.   }
        118.   
        119. > void *CRYPTO_malloc(size_t num, const char *file, int line)
        120.   {
        121.       void *ret = NULL;

crypto/mem.c:121:5: 
        119.   void *CRYPTO_malloc(size_t num, const char *file, int line)
        120.   {
        121. >     void *ret = NULL;
        122.   
        123.       if (num <= 0)

crypto/mem.c:123:9: Taking false branch
        121.       void *ret = NULL;
        122.   
        123.       if (num <= 0)
                       ^
        124.           return NULL;
        125.   

crypto/mem.c:126:5: 
        124.           return NULL;
        125.   
        126. >     allow_customize = 0;
        127.   #ifndef OPENSSL_NO_CRYPTO_MDEBUG
        128.       if (call_malloc_debug) {

crypto/mem.c:136:5: 
        134.       }
        135.   #else
        136. >     (void)file;
        137.       (void)line;
        138.       ret = malloc(num);

crypto/mem.c:137:5: 
        135.   #else
        136.       (void)file;
        137. >     (void)line;
        138.       ret = malloc(num);
        139.   #endif

crypto/mem.c:138:5: 
        136.       (void)file;
        137.       (void)line;
        138. >     ret = malloc(num);
        139.   #endif
        140.   

crypto/mem.c:153:5: 
        151.   #endif
        152.   
        153. >     return ret;
        154.   }
        155.   

crypto/mem.c:154:1: return from a call to CRYPTO_malloc
        152.   
        153.       return ret;
        154. > }
        155.   
        156.   void *CRYPTO_zalloc(size_t num, const char *file, int line)

crypto/mem.c:160:9: Taking true branch
      158.       void *ret = CRYPTO_malloc(num, file, line);
      159.   
      160.       if (ret != NULL)
                     ^
      161.           memset(ret, 0, num);
      162.       return ret;

crypto/mem.c:161:9: 
      159.   
      160.       if (ret != NULL)
      161. >         memset(ret, 0, num);
      162.       return ret;
      163.   }

crypto/mem.c:162:5: 
      160.       if (ret != NULL)
      161.           memset(ret, 0, num);
      162. >     return ret;
      163.   }
      164.   

crypto/mem.c:163:1: return from a call to CRYPTO_zalloc
      161.           memset(ret, 0, num);
      162.       return ret;
      163. > }
      164.   
      165.   void *CRYPTO_realloc(void *str, size_t num, const char *file, int line)

ssl/pqueue.c:90:5: 
    88.       pqueue *pq = OPENSSL_zalloc(sizeof(*pq));
    89.   
    90. >     return pq;
    91.   }
    92.   

ssl/pqueue.c:91:1: return from a call to pqueue_new
    89.   
    90.       return pq;
    91. > }
    92.   
    93.   void pqueue_free(pqueue *pq)

ssl/record/rec_layer_d1.c:135:5: 
  133.   
  134.       d->unprocessed_rcds.q = pqueue_new();
  135. >     d->processed_rcds.q = pqueue_new();
  136.       d->buffered_app_data.q = pqueue_new();
  137.   

ssl/pqueue.c:86:1: start of procedure pqueue_new()
    84.   }
    85.   
    86. > pqueue *pqueue_new()
    87.   {
    88.       pqueue *pq = OPENSSL_zalloc(sizeof(*pq));

ssl/pqueue.c:88:5: 
    86.   pqueue *pqueue_new()
    87.   {
    88. >     pqueue *pq = OPENSSL_zalloc(sizeof(*pq));
    89.   
    90.       return pq;

crypto/mem.c:156:1: start of procedure CRYPTO_zalloc()
      154.   }
      155.   
      156. > void *CRYPTO_zalloc(size_t num, const char *file, int line)
      157.   {
      158.       void *ret = CRYPTO_malloc(num, file, line);

crypto/mem.c:158:5: 
      156.   void *CRYPTO_zalloc(size_t num, const char *file, int line)
      157.   {
      158. >     void *ret = CRYPTO_malloc(num, file, line);
      159.   
      160.       if (ret != NULL)

crypto/mem.c:119:1: start of procedure CRYPTO_malloc()
        117.   }
        118.   
        119. > void *CRYPTO_malloc(size_t num, const char *file, int line)
        120.   {
        121.       void *ret = NULL;

crypto/mem.c:121:5: 
        119.   void *CRYPTO_malloc(size_t num, const char *file, int line)
        120.   {
        121. >     void *ret = NULL;
        122.   
        123.       if (num <= 0)

crypto/mem.c:123:9: Taking false branch
        121.       void *ret = NULL;
        122.   
        123.       if (num <= 0)
                       ^
        124.           return NULL;
        125.   

crypto/mem.c:126:5: 
        124.           return NULL;
        125.   
        126. >     allow_customize = 0;
        127.   #ifndef OPENSSL_NO_CRYPTO_MDEBUG
        128.       if (call_malloc_debug) {

crypto/mem.c:136:5: 
        134.       }
        135.   #else
        136. >     (void)file;
        137.       (void)line;
        138.       ret = malloc(num);

crypto/mem.c:137:5: 
        135.   #else
        136.       (void)file;
        137. >     (void)line;
        138.       ret = malloc(num);
        139.   #endif

crypto/mem.c:138:5: 
        136.       (void)file;
        137.       (void)line;
        138. >     ret = malloc(num);
        139.   #endif
        140.   

crypto/mem.c:153:5: 
        151.   #endif
        152.   
        153. >     return ret;
        154.   }
        155.   

crypto/mem.c:154:1: return from a call to CRYPTO_malloc
        152.   
        153.       return ret;
        154. > }
        155.   
        156.   void *CRYPTO_zalloc(size_t num, const char *file, int line)

crypto/mem.c:160:9: Taking true branch
      158.       void *ret = CRYPTO_malloc(num, file, line);
      159.   
      160.       if (ret != NULL)
                     ^
      161.           memset(ret, 0, num);
      162.       return ret;

crypto/mem.c:161:9: 
      159.   
      160.       if (ret != NULL)
      161. >         memset(ret, 0, num);
      162.       return ret;
      163.   }

crypto/mem.c:162:5: 
      160.       if (ret != NULL)
      161.           memset(ret, 0, num);
      162. >     return ret;
      163.   }
      164.   

crypto/mem.c:163:1: return from a call to CRYPTO_zalloc
      161.           memset(ret, 0, num);
      162.       return ret;
      163. > }
      164.   
      165.   void *CRYPTO_realloc(void *str, size_t num, const char *file, int line)

ssl/pqueue.c:90:5: 
    88.       pqueue *pq = OPENSSL_zalloc(sizeof(*pq));
    89.   
    90. >     return pq;
    91.   }
    92.   

ssl/pqueue.c:91:1: return from a call to pqueue_new
    89.   
    90.       return pq;
    91. > }
    92.   
    93.   void pqueue_free(pqueue *pq)

ssl/record/rec_layer_d1.c:136:5: 
  134.       d->unprocessed_rcds.q = pqueue_new();
  135.       d->processed_rcds.q = pqueue_new();
  136. >     d->buffered_app_data.q = pqueue_new();
  137.   
  138.       if (d->unprocessed_rcds.q == NULL || d->processed_rcds.q == NULL

ssl/pqueue.c:86:1: start of procedure pqueue_new()
    84.   }
    85.   
    86. > pqueue *pqueue_new()
    87.   {
    88.       pqueue *pq = OPENSSL_zalloc(sizeof(*pq));

ssl/pqueue.c:88:5: 
    86.   pqueue *pqueue_new()
    87.   {
    88. >     pqueue *pq = OPENSSL_zalloc(sizeof(*pq));
    89.   
    90.       return pq;

crypto/mem.c:156:1: start of procedure CRYPTO_zalloc()
      154.   }
      155.   
      156. > void *CRYPTO_zalloc(size_t num, const char *file, int line)
      157.   {
      158.       void *ret = CRYPTO_malloc(num, file, line);

crypto/mem.c:158:5: 
      156.   void *CRYPTO_zalloc(size_t num, const char *file, int line)
      157.   {
      158. >     void *ret = CRYPTO_malloc(num, file, line);
      159.   
      160.       if (ret != NULL)

crypto/mem.c:119:1: start of procedure CRYPTO_malloc()
        117.   }
        118.   
        119. > void *CRYPTO_malloc(size_t num, const char *file, int line)
        120.   {
        121.       void *ret = NULL;

crypto/mem.c:121:5: 
        119.   void *CRYPTO_malloc(size_t num, const char *file, int line)
        120.   {
        121. >     void *ret = NULL;
        122.   
        123.       if (num <= 0)

crypto/mem.c:123:9: Taking false branch
        121.       void *ret = NULL;
        122.   
        123.       if (num <= 0)
                       ^
        124.           return NULL;
        125.   

crypto/mem.c:126:5: 
        124.           return NULL;
        125.   
        126. >     allow_customize = 0;
        127.   #ifndef OPENSSL_NO_CRYPTO_MDEBUG
        128.       if (call_malloc_debug) {

crypto/mem.c:136:5: 
        134.       }
        135.   #else
        136. >     (void)file;
        137.       (void)line;
        138.       ret = malloc(num);

crypto/mem.c:137:5: 
        135.   #else
        136.       (void)file;
        137. >     (void)line;
        138.       ret = malloc(num);
        139.   #endif

crypto/mem.c:138:5: 
        136.       (void)file;
        137.       (void)line;
        138. >     ret = malloc(num);
        139.   #endif
        140.   

crypto/mem.c:153:5: 
        151.   #endif
        152.   
        153. >     return ret;
        154.   }
        155.   

crypto/mem.c:154:1: return from a call to CRYPTO_malloc
        152.   
        153.       return ret;
        154. > }
        155.   
        156.   void *CRYPTO_zalloc(size_t num, const char *file, int line)

crypto/mem.c:160:9: Taking true branch
      158.       void *ret = CRYPTO_malloc(num, file, line);
      159.   
      160.       if (ret != NULL)
                     ^
      161.           memset(ret, 0, num);
      162.       return ret;

crypto/mem.c:161:9: 
      159.   
      160.       if (ret != NULL)
      161. >         memset(ret, 0, num);
      162.       return ret;
      163.   }

crypto/mem.c:162:5: 
      160.       if (ret != NULL)
      161.           memset(ret, 0, num);
      162. >     return ret;
      163.   }
      164.   

crypto/mem.c:163:1: return from a call to CRYPTO_zalloc
      161.           memset(ret, 0, num);
      162.       return ret;
      163. > }
      164.   
      165.   void *CRYPTO_realloc(void *str, size_t num, const char *file, int line)

ssl/pqueue.c:90:5: 
    88.       pqueue *pq = OPENSSL_zalloc(sizeof(*pq));
    89.   
    90. >     return pq;
    91.   }
    92.   

ssl/pqueue.c:91:1: return from a call to pqueue_new
    89.   
    90.       return pq;
    91. > }
    92.   
    93.   void pqueue_free(pqueue *pq)

ssl/record/rec_layer_d1.c:138:9: Taking false branch
  136.       d->buffered_app_data.q = pqueue_new();
  137.   
  138.       if (d->unprocessed_rcds.q == NULL || d->processed_rcds.q == NULL
                 ^
  139.           || d->buffered_app_data.q == NULL) {
  140.           pqueue_free(d->unprocessed_rcds.q);

ssl/record/rec_layer_d1.c:138:42: Taking false branch
  136.       d->buffered_app_data.q = pqueue_new();
  137.   
  138.       if (d->unprocessed_rcds.q == NULL || d->processed_rcds.q == NULL
                                                  ^
  139.           || d->buffered_app_data.q == NULL) {
  140.           pqueue_free(d->unprocessed_rcds.q);

ssl/record/rec_layer_d1.c:139:12: Taking false branch
  137.   
  138.       if (d->unprocessed_rcds.q == NULL || d->processed_rcds.q == NULL
  139.           || d->buffered_app_data.q == NULL) {
                    ^
  140.           pqueue_free(d->unprocessed_rcds.q);
  141.           pqueue_free(d->processed_rcds.q);

ssl/record/rec_layer_d1.c:148:5: 
  146.       }
  147.   
  148. >     return 1;
  149.   }
  150.   

ssl/record/rec_layer_d1.c:149:1: return from a call to DTLS_RECORD_LAYER_new
  147.   
  148.       return 1;
  149. > }
  150.   
  151.   void DTLS_RECORD_LAYER_free(RECORD_LAYER *rl)

ssl/d1_lib.c:133:10: Taking false branch
131.       DTLS1_STATE *d1;
132.   
133.       if (!DTLS_RECORD_LAYER_new(&s->rlayer)) {
                ^
134.           return 0;
135.       }

ssl/d1_lib.c:137:10: Taking false branch
135.       }
136.       
137.       if (!ssl3_new(s))
                ^
138.           return (0);
139.       if ((d1 = OPENSSL_zalloc(sizeof(*d1))) == NULL) {

ssl/d1_lib.c:139:9: 
137.       if (!ssl3_new(s))
138.           return (0);
139. >     if ((d1 = OPENSSL_zalloc(sizeof(*d1))) == NULL) {
140.           ssl3_free(s);
141.           return (0);

crypto/mem.c:156:1: start of procedure CRYPTO_zalloc()
  154.   }
  155.   
  156. > void *CRYPTO_zalloc(size_t num, const char *file, int line)
  157.   {
  158.       void *ret = CRYPTO_malloc(num, file, line);

crypto/mem.c:158:5: 
  156.   void *CRYPTO_zalloc(size_t num, const char *file, int line)
  157.   {
  158. >     void *ret = CRYPTO_malloc(num, file, line);
  159.   
  160.       if (ret != NULL)

crypto/mem.c:119:1: start of procedure CRYPTO_malloc()
    117.   }
    118.   
    119. > void *CRYPTO_malloc(size_t num, const char *file, int line)
    120.   {
    121.       void *ret = NULL;

crypto/mem.c:121:5: 
    119.   void *CRYPTO_malloc(size_t num, const char *file, int line)
    120.   {
    121. >     void *ret = NULL;
    122.   
    123.       if (num <= 0)

crypto/mem.c:123:9: Taking false branch
    121.       void *ret = NULL;
    122.   
    123.       if (num <= 0)
                   ^
    124.           return NULL;
    125.   

crypto/mem.c:126:5: 
    124.           return NULL;
    125.   
    126. >     allow_customize = 0;
    127.   #ifndef OPENSSL_NO_CRYPTO_MDEBUG
    128.       if (call_malloc_debug) {

crypto/mem.c:136:5: 
    134.       }
    135.   #else
    136. >     (void)file;
    137.       (void)line;
    138.       ret = malloc(num);

crypto/mem.c:137:5: 
    135.   #else
    136.       (void)file;
    137. >     (void)line;
    138.       ret = malloc(num);
    139.   #endif

crypto/mem.c:138:5: 
    136.       (void)file;
    137.       (void)line;
    138. >     ret = malloc(num);
    139.   #endif
    140.   

crypto/mem.c:153:5: 
    151.   #endif
    152.   
    153. >     return ret;
    154.   }
    155.   

crypto/mem.c:154:1: return from a call to CRYPTO_malloc
    152.   
    153.       return ret;
    154. > }
    155.   
    156.   void *CRYPTO_zalloc(size_t num, const char *file, int line)

crypto/mem.c:160:9: Taking true branch
  158.       void *ret = CRYPTO_malloc(num, file, line);
  159.   
  160.       if (ret != NULL)
                 ^
  161.           memset(ret, 0, num);
  162.       return ret;

crypto/mem.c:161:9: 
  159.   
  160.       if (ret != NULL)
  161. >         memset(ret, 0, num);
  162.       return ret;
  163.   }

crypto/mem.c:162:5: 
  160.       if (ret != NULL)
  161.           memset(ret, 0, num);
  162. >     return ret;
  163.   }
  164.   

crypto/mem.c:163:1: return from a call to CRYPTO_zalloc
  161.           memset(ret, 0, num);
  162.       return ret;
  163. > }
  164.   
  165.   void *CRYPTO_realloc(void *str, size_t num, const char *file, int line)

ssl/d1_lib.c:139:9: Taking false branch
137.       if (!ssl3_new(s))
138.           return (0);
139.       if ((d1 = OPENSSL_zalloc(sizeof(*d1))) == NULL) {
               ^
140.           ssl3_free(s);
141.           return (0);

ssl/d1_lib.c:144:5: 
142.       }
143.   
144. >     d1->buffered_messages = pqueue_new();
145.       d1->sent_messages = pqueue_new();
146.   

ssl/pqueue.c:86:1: start of procedure pqueue_new()
  84.   }
  85.   
  86. > pqueue *pqueue_new()
  87.   {
  88.       pqueue *pq = OPENSSL_zalloc(sizeof(*pq));

ssl/pqueue.c:88:5: 
  86.   pqueue *pqueue_new()
  87.   {
  88. >     pqueue *pq = OPENSSL_zalloc(sizeof(*pq));
  89.   
  90.       return pq;

crypto/mem.c:156:1: start of procedure CRYPTO_zalloc()
    154.   }
    155.   
    156. > void *CRYPTO_zalloc(size_t num, const char *file, int line)
    157.   {
    158.       void *ret = CRYPTO_malloc(num, file, line);

crypto/mem.c:158:5: 
    156.   void *CRYPTO_zalloc(size_t num, const char *file, int line)
    157.   {
    158. >     void *ret = CRYPTO_malloc(num, file, line);
    159.   
    160.       if (ret != NULL)

crypto/mem.c:119:1: start of procedure CRYPTO_malloc()
      117.   }
      118.   
      119. > void *CRYPTO_malloc(size_t num, const char *file, int line)
      120.   {
      121.       void *ret = NULL;

crypto/mem.c:121:5: 
      119.   void *CRYPTO_malloc(size_t num, const char *file, int line)
      120.   {
      121. >     void *ret = NULL;
      122.   
      123.       if (num <= 0)

crypto/mem.c:123:9: Taking false branch
      121.       void *ret = NULL;
      122.   
      123.       if (num <= 0)
                     ^
      124.           return NULL;
      125.   

crypto/mem.c:126:5: 
      124.           return NULL;
      125.   
      126. >     allow_customize = 0;
      127.   #ifndef OPENSSL_NO_CRYPTO_MDEBUG
      128.       if (call_malloc_debug) {

crypto/mem.c:136:5: 
      134.       }
      135.   #else
      136. >     (void)file;
      137.       (void)line;
      138.       ret = malloc(num);

crypto/mem.c:137:5: 
      135.   #else
      136.       (void)file;
      137. >     (void)line;
      138.       ret = malloc(num);
      139.   #endif

crypto/mem.c:138:5: 
      136.       (void)file;
      137.       (void)line;
      138. >     ret = malloc(num);
      139.   #endif
      140.   

crypto/mem.c:153:5: 
      151.   #endif
      152.   
      153. >     return ret;
      154.   }
      155.   

crypto/mem.c:154:1: return from a call to CRYPTO_malloc
      152.   
      153.       return ret;
      154. > }
      155.   
      156.   void *CRYPTO_zalloc(size_t num, const char *file, int line)

crypto/mem.c:160:9: Taking true branch
    158.       void *ret = CRYPTO_malloc(num, file, line);
    159.   
    160.       if (ret != NULL)
                   ^
    161.           memset(ret, 0, num);
    162.       return ret;

crypto/mem.c:161:9: 
    159.   
    160.       if (ret != NULL)
    161. >         memset(ret, 0, num);
    162.       return ret;
    163.   }

crypto/mem.c:162:5: 
    160.       if (ret != NULL)
    161.           memset(ret, 0, num);
    162. >     return ret;
    163.   }
    164.   

crypto/mem.c:163:1: return from a call to CRYPTO_zalloc
    161.           memset(ret, 0, num);
    162.       return ret;
    163. > }
    164.   
    165.   void *CRYPTO_realloc(void *str, size_t num, const char *file, int line)

ssl/pqueue.c:90:5: 
  88.       pqueue *pq = OPENSSL_zalloc(sizeof(*pq));
  89.   
  90. >     return pq;
  91.   }
  92.   

ssl/pqueue.c:91:1: return from a call to pqueue_new
  89.   
  90.       return pq;
  91. > }
  92.   
  93.   void pqueue_free(pqueue *pq)

ssl/d1_lib.c:145:5: 
143.   
144.       d1->buffered_messages = pqueue_new();
145. >     d1->sent_messages = pqueue_new();
146.   
147.       if (s->server) {

ssl/pqueue.c:86:1: start of procedure pqueue_new()
  84.   }
  85.   
  86. > pqueue *pqueue_new()
  87.   {
  88.       pqueue *pq = OPENSSL_zalloc(sizeof(*pq));

ssl/pqueue.c:88:5: 
  86.   pqueue *pqueue_new()
  87.   {
  88. >     pqueue *pq = OPENSSL_zalloc(sizeof(*pq));
  89.   
  90.       return pq;

crypto/mem.c:156:1: start of procedure CRYPTO_zalloc()
    154.   }
    155.   
    156. > void *CRYPTO_zalloc(size_t num, const char *file, int line)
    157.   {
    158.       void *ret = CRYPTO_malloc(num, file, line);

crypto/mem.c:158:5: 
    156.   void *CRYPTO_zalloc(size_t num, const char *file, int line)
    157.   {
    158. >     void *ret = CRYPTO_malloc(num, file, line);
    159.   
    160.       if (ret != NULL)

crypto/mem.c:119:1: start of procedure CRYPTO_malloc()
      117.   }
      118.   
      119. > void *CRYPTO_malloc(size_t num, const char *file, int line)
      120.   {
      121.       void *ret = NULL;

crypto/mem.c:121:5: 
      119.   void *CRYPTO_malloc(size_t num, const char *file, int line)
      120.   {
      121. >     void *ret = NULL;
      122.   
      123.       if (num <= 0)

crypto/mem.c:123:9: Taking false branch
      121.       void *ret = NULL;
      122.   
      123.       if (num <= 0)
                     ^
      124.           return NULL;
      125.   

crypto/mem.c:126:5: 
      124.           return NULL;
      125.   
      126. >     allow_customize = 0;
      127.   #ifndef OPENSSL_NO_CRYPTO_MDEBUG
      128.       if (call_malloc_debug) {

crypto/mem.c:136:5: 
      134.       }
      135.   #else
      136. >     (void)file;
      137.       (void)line;
      138.       ret = malloc(num);

crypto/mem.c:137:5: 
      135.   #else
      136.       (void)file;
      137. >     (void)line;
      138.       ret = malloc(num);
      139.   #endif

crypto/mem.c:138:5: 
      136.       (void)file;
      137.       (void)line;
      138. >     ret = malloc(num);
      139.   #endif
      140.   

crypto/mem.c:153:5: 
      151.   #endif
      152.   
      153. >     return ret;
      154.   }
      155.   

crypto/mem.c:154:1: return from a call to CRYPTO_malloc
      152.   
      153.       return ret;
      154. > }
      155.   
      156.   void *CRYPTO_zalloc(size_t num, const char *file, int line)

crypto/mem.c:160:9: Taking true branch
    158.       void *ret = CRYPTO_malloc(num, file, line);
    159.   
    160.       if (ret != NULL)
                   ^
    161.           memset(ret, 0, num);
    162.       return ret;

crypto/mem.c:161:9: 
    159.   
    160.       if (ret != NULL)
    161. >         memset(ret, 0, num);
    162.       return ret;
    163.   }

crypto/mem.c:162:5: 
    160.       if (ret != NULL)
    161.           memset(ret, 0, num);
    162. >     return ret;
    163.   }
    164.   

crypto/mem.c:163:1: return from a call to CRYPTO_zalloc
    161.           memset(ret, 0, num);
    162.       return ret;
    163. > }
    164.   
    165.   void *CRYPTO_realloc(void *str, size_t num, const char *file, int line)

ssl/pqueue.c:90:5: 
  88.       pqueue *pq = OPENSSL_zalloc(sizeof(*pq));
  89.   
  90. >     return pq;
  91.   }
  92.   

ssl/pqueue.c:91:1: return from a call to pqueue_new
  89.   
  90.       return pq;
  91. > }
  92.   
  93.   void pqueue_free(pqueue *pq)

ssl/d1_lib.c:147:9: Taking false branch
145.       d1->sent_messages = pqueue_new();
146.   
147.       if (s->server) {
               ^
148.           d1->cookie_len = sizeof(s->d1->cookie);
149.       }

ssl/d1_lib.c:151:5: 
149.       }
150.   
151. >     d1->link_mtu = 0;
152.       d1->mtu = 0;
153.   

ssl/d1_lib.c:152:5: 
150.   
151.       d1->link_mtu = 0;
152. >     d1->mtu = 0;
153.   
154.       if (d1->buffered_messages == NULL || d1->sent_messages == NULL) {

ssl/d1_lib.c:154:9: Taking false branch
152.       d1->mtu = 0;
153.   
154.       if (d1->buffered_messages == NULL || d1->sent_messages == NULL) {
               ^
155.           pqueue_free(d1->buffered_messages);
156.           pqueue_free(d1->sent_messages);

ssl/d1_lib.c:154:42: Taking false branch
152.       d1->mtu = 0;
153.   
154.       if (d1->buffered_messages == NULL || d1->sent_messages == NULL) {
                                                ^
155.           pqueue_free(d1->buffered_messages);
156.           pqueue_free(d1->sent_messages);

ssl/d1_lib.c:162:5: 
160.       }
161.   
162. >     s->d1 = d1;
163.       s->method->ssl_clear(s);
164.       return (1);

ssl/d1_lib.c:163:5: Skipping __function_pointer__(): unresolved function pointer
161.   
162.       s->d1 = d1;
163.       s->method->ssl_clear(s);
           ^
164.       return (1);
165.   }

int dtls1_new(SSL *s)
{
    DTLS1_STATE *d1;
    if (!DTLS_RECORD_LAYER_new(&s->rlayer)) {
        return 0;
    }
    if (!ssl3_new(s))
        return (0);
    if ((d1 = OPENSSL_zalloc(sizeof(*d1))) == NULL) {
        ssl3_free(s);
        return (0);
    }
    d1->buffered_messages = pqueue_new();
    d1->sent_messages = pqueue_new();
    if (s->server) {
        d1->cookie_len = sizeof(s->d1->cookie);
    }
    d1->link_mtu = 0;
    d1->mtu = 0;
    if (d1->buffered_messages == NULL || d1->sent_messages == NULL) {
        pqueue_free(d1->buffered_messages);
        pqueue_free(d1->sent_messages);
        OPENSSL_free(d1);
        ssl3_free(s);
        return (0);
    }
    s->d1 = d1;
    s->method->ssl_clear(s);
    return (1);
}
['int dtls1_new(SSL *s)\n{\n    DTLS1_STATE *d1;\n    if (!DTLS_RECORD_LAYER_new(&s->rlayer)) {\n        return 0;\n    }\n    if (!ssl3_new(s))\n        return (0);\n    if ((d1 = OPENSSL_zalloc(sizeof(*d1))) == NULL) {\n        ssl3_free(s);\n        return (0);\n    }\n    d1->buffered_messages = pqueue_new();\n    d1->sent_messages = pqueue_new();\n    if (s->server) {\n        d1->cookie_len = sizeof(s->d1->cookie);\n    }\n    d1->link_mtu = 0;\n    d1->mtu = 0;\n    if (d1->buffered_messages == NULL || d1->sent_messages == NULL) {\n        pqueue_free(d1->buffered_messages);\n        pqueue_free(d1->sent_messages);\n        OPENSSL_free(d1);\n        ssl3_free(s);\n        return (0);\n    }\n    s->d1 = d1;\n    s->method->ssl_clear(s);\n    return (1);\n}', 'int DTLS_RECORD_LAYER_new(RECORD_LAYER *rl)\n{\n    DTLS_RECORD_LAYER *d;\n    if ((d = OPENSSL_malloc(sizeof(*d))) == NULL)\n        return (0);\n    rl->d = d;\n    d->unprocessed_rcds.q = pqueue_new();\n    d->processed_rcds.q = pqueue_new();\n    d->buffered_app_data.q = pqueue_new();\n    if (d->unprocessed_rcds.q == NULL || d->processed_rcds.q == NULL\n        || d->buffered_app_data.q == NULL) {\n        pqueue_free(d->unprocessed_rcds.q);\n        pqueue_free(d->processed_rcds.q);\n        pqueue_free(d->buffered_app_data.q);\n        OPENSSL_free(d);\n        rl->d = NULL;\n        return (0);\n    }\n    return 1;\n}', 'void *CRYPTO_malloc(size_t num, const char *file, int line)\n{\n    void *ret = NULL;\n    if (num <= 0)\n        return NULL;\n    allow_customize = 0;\n#ifndef OPENSSL_NO_CRYPTO_MDEBUG\n    if (call_malloc_debug) {\n        CRYPTO_mem_debug_malloc(NULL, num, 0, file, line);\n        ret = malloc(num);\n        CRYPTO_mem_debug_malloc(ret, num, 1, file, line);\n    } else {\n        ret = malloc(num);\n    }\n#else\n    (void)file;\n    (void)line;\n    ret = malloc(num);\n#endif\n#ifndef OPENSSL_CPUID_OBJ\n    if (ret && (num > 2048)) {\n        extern unsigned char cleanse_ctr;\n        ((unsigned char *)ret)[0] = cleanse_ctr;\n    }\n#endif\n    return ret;\n}', 'pqueue *pqueue_new()\n{\n    pqueue *pq = OPENSSL_zalloc(sizeof(*pq));\n    return pq;\n}', 'void *CRYPTO_zalloc(size_t num, const char *file, int line)\n{\n    void *ret = CRYPTO_malloc(num, file, line);\n    if (ret != NULL)\n        memset(ret, 0, num);\n    return ret;\n}']