Changeset 48

Show
Ignore:
Timestamp:
04/05/05 12:46:02
Author:
ben
Message:

Memory leak detection. Some bignums appear to leak, still, but OpenSSL doesn't
detect them for some reason.

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • openpgpsdk/trunk/src/Makefile

    r44 r48  
    11# $Id$ 
    22 
    3 CFLAGS=-Wall -Werror -g 
     3DM_FLAGS=-DDMALLOC -I/usr/local/include 
     4DM_LIB=/usr/local/lib/libdmalloc.a 
     5 
     6CFLAGS=-Wall -Werror -g $(DM_FLAGS) 
    47LDFLAGS=-g 
    58 
    …… 
    1114 
    1215packet-dump: packet-dump.o libops.a 
    13         $(CC) $(LDFLAGS) -o packet-dump packet-dump.o libops.a -lcrypto 
     16        $(CC) $(LDFLAGS) -o packet-dump packet-dump.o libops.a -lcrypto \ 
     17                $(DM_LIB) 
    1418 
    1519verify: verify.o libops.a 
    16         $(CC) $(LDFLAGS) -o verify verify.o libops.a -lcrypto 
     20        $(CC) $(LDFLAGS) -o verify verify.o libops.a -lcrypto $(DM_LIB) 
     21 
     22tags: 
     23        rm -f TAGS 
     24        find . -name '*.[ch]' | xargs etags -a 
     25 
    1726clean: 
    1827        rm -f packet-dump packet-dump.o packet-parse.o .depend 

  • openpgpsdk/trunk/src/accumulate.c

    r47 r48  
    153153 
    154154    case OPS_PTAG_CT_PUBLIC_SUBKEY: 
     155        if(arg->subkey.version) 
     156            ops_public_key_free(&arg->subkey); 
    155157        arg->subkey=content->public_key; 
    156158        return OPS_KEEP_MEMORY; 
    …… 
    238240 
    239241    ops_public_key_free(&arg.pkey); 
     242    if(arg.subkey.version) 
     243        ops_public_key_free(&arg.subkey); 
    240244    ops_user_id_free(&arg.user_id); 
    241245    } 

  • openpgpsdk/trunk/src/crypto.h

    r46 r48  
    1919    }; 
    2020 
     21void ops_crypto_init(void); 
     22void ops_crypto_finish(void); 
    2123void ops_hash_md5(ops_hash_t *hash); 
    2224void ops_hash_sha1(ops_hash_t *hash); 

  • openpgpsdk/trunk/src/fingerprint.c

    r46 r48  
    44#include "build.h" 
    55#include <assert.h> 
     6 
     7#ifdef DMALLOC 
     8# include <dmalloc.h> 
     9#endif 
    610 
    711void ops_fingerprint(ops_fingerprint_t *fp,const ops_public_key_t *key) 

  • openpgpsdk/trunk/src/keyring.c

    r44 r48  
    11#include "keyring.h" 
    22#include "keyring_local.h" 
     3#include <stdlib.h> 
     4 
     5#ifdef DMALLOC 
     6# include <dmalloc.h> 
     7#endif 
    38 
    49ops_key_data_t * 
    …… 
    1419    return NULL; 
    1520    } 
     21 
     22void ops_key_data_free(ops_key_data_t *key) 
     23    { 
     24    int n; 
     25 
     26    for(n=0 ; n < key->nuids ; ++n) 
     27        ops_user_id_free(&key->uids[n]); 
     28    free(key->uids); 
     29    key->uids=NULL; 
     30 
     31    for(n=0 ; n < key->npackets ; ++n) 
     32        ops_packet_free(&key->packets[n]); 
     33    free(key->packets); 
     34    key->packets=NULL; 
     35 
     36    ops_public_key_free(&key->pkey); 
     37    } 
     38 
     39void ops_keyring_free(ops_keyring_t *keyring) 
     40    { 
     41    int n; 
     42 
     43    for(n=0 ; n < keyring->nkeys ; ++n) 
     44        ops_key_data_free(&keyring->keys[n]); 
     45    free(keyring->keys); 
     46    keyring->keys=NULL; 
     47    } 

  • openpgpsdk/trunk/src/keyring.h

    r44 r48  
    1313ops_keyring_find_key_by_id(const ops_keyring_t *keyring, 
    1414                           const unsigned char keyid[OPS_KEY_ID_SIZE]); 
     15void ops_key_data_free(ops_key_data_t *key); 
     16void ops_keyring_free(ops_keyring_t *keyring); 

  • openpgpsdk/trunk/src/memory.c

    r40 r48  
    22#include <stdlib.h> 
    33#include <assert.h> 
     4 
     5#ifdef DMALLOC 
     6# include <dmalloc.h> 
     7#endif 
    48 
    59void ops_memory_init(ops_memory_t *mem,size_t initial_size) 

  • openpgpsdk/trunk/src/openssl_crypto.c

    r46 r48  
    44#include <openssl/dsa.h> 
    55#include <openssl/rsa.h> 
     6#include <openssl/err.h> 
    67#include <assert.h> 
    78#include <stdlib.h> 
     9 
     10#ifdef DMALLOC 
     11# include <dmalloc.h> 
     12#endif 
    813 
    914static void md5_init(ops_hash_t *hash) 
    …… 
    109114    return n; 
    110115    } 
     116 
     117void ops_crypto_init() 
     118    { 
     119#ifdef DMALLOC 
     120    CRYPTO_malloc_debug_init(); 
     121    CRYPTO_dbg_set_options(V_CRYPTO_MDEBUG_ALL); 
     122    CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON); 
     123#endif 
     124    } 
     125 
     126void ops_crypto_finish() 
     127    { 
     128    CRYPTO_cleanup_all_ex_data(); 
     129    ERR_remove_state(0); 
     130#ifdef DMALLOC 
     131    CRYPTO_mem_leaks_fp(stderr); 
     132#endif 
     133    } 

  • openpgpsdk/trunk/src/packet-parse.c

    r44 r48  
    1212#include <stdlib.h> 
    1313#include <string.h> 
     14 
     15#ifdef DMALLOC 
     16# include <dmalloc.h> 
     17#endif 
    1418 
    1519typedef struct ops_region 
    …… 
    321325    } 
    322326 
     327void ops_packet_free(ops_packet_t *packet) 
     328    { 
     329    free(packet->raw); 
     330    packet->raw=NULL; 
     331    } 
     332 
    323333void ops_content_free_inner(ops_parser_content_t *c) 
    324334    { 
    …… 
    345355 
    346356    case OPS_PARSER_PACKET_END: 
    347         free(c->content.packet.raw); 
    348         c->content.packet.raw=NULL; 
     357        ops_packet_free(&c->content.packet); 
     358        break; 
     359 
     360    case OPS_PARSER_ERROR: 
    349361        break; 
    350362 

  • openpgpsdk/trunk/src/packet.h

    r44 r48  
    406406    } ops_fingerprint_t; 
    407407 
     408void ops_init(void); 
     409void ops_finish(void); 
    408410void ops_keyid(unsigned char keyid[OPS_KEY_ID_SIZE], 
    409411               const ops_public_key_t *key); 
    …… 
    412414void ops_user_id_free(ops_user_id_t *id); 
    413415void ops_signature_free(ops_signature_t *sig); 
     416void ops_packet_free(ops_packet_t *packet); 
    414417 
    415418/* vim:set textwidth=120: */ 

  • openpgpsdk/trunk/src/util.c

    r46 r48  
    11#include "util.h" 
     2#include "crypto.h" 
    23#include <stdio.h> 
    34#include <assert.h> 
    …… 
    89        printf("%02X",*src++); 
    910    } 
     11 
     12void ops_init(void) 
     13    { 
     14    ops_crypto_init(); 
     15    } 
     16 
     17void ops_finish(void) 
     18    { 
     19    ops_crypto_finish(); 
     20    } 

  • openpgpsdk/trunk/src/validate.c

    r40 r48  
    55#include <assert.h> 
    66#include <openssl/md5.h> 
     7 
     8#ifdef DMALLOC 
     9# include <dmalloc.h> 
     10#endif 
    711 
    812typedef struct 

  • openpgpsdk/trunk/src/verify.c

    r44 r48  
    2727    ops_keyring_t keyring; 
    2828 
     29    ops_init(); 
     30 
    2931    memset(&keyring,'\0',sizeof keyring); 
    3032    ops_parse_options_init(&opt); 
    …… 
    3537    ops_parse_and_accumulate(&keyring,&opt); 
    3638 
     39    ops_keyring_free(&keyring); 
     40 
     41    ops_finish(); 
     42 
    3743    return 0; 
    3844    }