main()
{
LHASH *conf;
char buf[256];
int i;
conf = lh_new(lh_strhash, strcmp);
for (;;) {
char *p;
buf[0] = '\0';
fgets(buf, 256, stdin);
if (buf[0] == '\0')
break;
i = strlen(buf);
p = OPENSSL_malloc(i + 1);
memcpy(p, buf, i + 1);
lh_insert(conf, p);
}
lh_node_stats(conf, stdout);
lh_stats(conf, stdout);
lh_node_usage_stats(conf, stdout);
exit(0);
}
/*
* anonymization of octet string
* anonymized octet strings are also kept in a linked list to make
* sure they are unique
*
* astr has to be a large enough buffer where the anonymized string
* will be copied, the anonymized string will be as long as the
* original string
*/
int
anon_octs_map(anon_octs_t *a, const char *str, char *astr)
{
struct hash_node node;
struct hash_node *p;
int tmp;
(void) anon_octs_set_state(a, NON_LEX);
/* lookup anon. string in lhash table */
node.data = (char*) str;
p = (struct hash_node *) lh_retrieve(a->hash_table,(void*) &node);
if (p) { /* found in lhash table */
strcpy(astr, p->hash);
} else { /* not found in lhash table */
/* generate a unique random string */
do {
generate_random_string(astr, strlen(str));
tmp = list_insert(&(a->list),astr);
assert(tmp >= 0);
} while (tmp==1);
/* store anon. string in lhash table */
p = (struct hash_node*) malloc(sizeof(struct hash_node));
assert(p);
p->data = (char*) malloc(strlen(str)+1);
assert(p->data);
p->hash = (char*) malloc(strlen(astr)+1);
assert(p->hash);
strcpy(p->data, str);
strcpy(p->hash, astr);
lh_insert(a->hash_table, p);
}
return 0;
}
main()
{
LHASH *conf;
char buf[256];
int i;
conf=lh_new(lh_strhash,TINYCLR_SSL_STRCMP);
for (;;)
{
char *p;
buf[0]='\0';
TINYCLR_SSL_FGETS(buf,256,OPENSSL_TYPE__FILE_STDIN);
if (buf[0] == '\0') break;
i=TINYCLR_SSL_STRLEN(buf);
p=OPENSSL_malloc(i+1);
TINYCLR_SSL_MEMCPY(p,buf,i+1);
lh_insert(conf,p);
}
lh_node_stats(conf,OPENSSL_TYPE__FILE_STDOUT);
lh_stats(conf,OPENSSL_TYPE__FILE_STDOUT);
lh_node_usage_stats(conf,OPENSSL_TYPE__FILE_STDOUT);
TINYCLR_SSL_EXIT(0);
}
void ERR_load_strings(int lib, ERR_STRING_DATA *str)
{
if (error_hash == NULL)
{
CRYPTO_w_lock(CRYPTO_LOCK_ERR_HASH);
error_hash=lh_new(err_hash,err_cmp);
if (error_hash == NULL)
{
CRYPTO_w_unlock(CRYPTO_LOCK_ERR_HASH);
return;
}
CRYPTO_w_unlock(CRYPTO_LOCK_ERR_HASH);
ERR_load_ERR_strings();
}
CRYPTO_w_lock(CRYPTO_LOCK_ERR_HASH);
while (str->error)
{
str->error|=ERR_PACK(lib,0,0);
lh_insert(error_hash,str);
str++;
}
CRYPTO_w_unlock(CRYPTO_LOCK_ERR_HASH);
}
/* Privately exposed (via eng_int.h) functions for adding and/or removing
* ENGINEs from the implementation table */
int engine_table_register(ENGINE_TABLE **table, ENGINE_CLEANUP_CB *cleanup,
ENGINE *e, const int *nids, int num_nids, int setdefault)
{
int ret = 0, added = 0;
ENGINE_PILE tmplate, *fnd;
CRYPTO_w_lock(CRYPTO_LOCK_ENGINE);
if(!(*table))
added = 1;
if(!int_table_check(table, 1))
goto end;
if(added)
/* The cleanup callback needs to be added */
engine_cleanup_add_first(cleanup);
while(num_nids--)
{
tmplate.nid = *nids;
fnd = lh_retrieve(&(*table)->piles, &tmplate);
if(!fnd)
{
fnd = OPENSSL_malloc(sizeof(ENGINE_PILE));
if(!fnd) goto end;
fnd->uptodate = 0;
fnd->nid = *nids;
fnd->sk = sk_ENGINE_new_null();
if(!fnd->sk)
{
OPENSSL_free(fnd);
goto end;
}
fnd->funct = NULL;
lh_insert(&(*table)->piles, fnd);
}
/* A registration shouldn't add duplciate entries */
sk_ENGINE_delete_ptr(fnd->sk, e);
/* if 'setdefault', this ENGINE goes to the head of the list */
if(!sk_ENGINE_push(fnd->sk, e))
goto end;
/* "touch" this ENGINE_PILE */
fnd->uptodate = 1;
if(setdefault)
{
if(!engine_unlocked_init(e))
{
ENGINEerr(ENGINE_F_ENGINE_TABLE_REGISTER,
ENGINE_R_INIT_FAILED);
goto end;
}
if(fnd->funct)
engine_unlocked_finish(fnd->funct, 0);
fnd->funct = e;
}
nids++;
}
ret = 1;
end:
CRYPTO_w_unlock(CRYPTO_LOCK_ENGINE);
return ret;
}
ERR_STATE *ERR_get_state(void)
{
ERR_STATE *ret=NULL,tmp,*tmpp;
int i;
unsigned long pid;
pid=(unsigned long)CRYPTO_thread_id();
CRYPTO_r_lock(CRYPTO_LOCK_ERR);
if (thread_hash == NULL)
{
CRYPTO_r_unlock(CRYPTO_LOCK_ERR);
CRYPTO_w_lock(CRYPTO_LOCK_ERR);
if (thread_hash == NULL)
{
MemCheck_off();
thread_hash=lh_new(pid_hash,pid_cmp);
MemCheck_on();
CRYPTO_w_unlock(CRYPTO_LOCK_ERR);
if (thread_hash == NULL) return(getFallback());
}
else
CRYPTO_w_unlock(CRYPTO_LOCK_ERR);
}
else
{
tmp.pid=pid;
ret=(ERR_STATE *)lh_retrieve(thread_hash,&tmp);
CRYPTO_r_unlock(CRYPTO_LOCK_ERR);
}
/* ret == the error state, if NULL, make a new one */
if (ret == NULL)
{
ret=(ERR_STATE *)Malloc(sizeof(ERR_STATE));
if (ret == NULL) return(getFallback());
ret->pid=pid;
ret->top=0;
ret->bottom=0;
for (i=0; i<ERR_NUM_ERRORS; i++)
{
ret->err_data[i]=NULL;
ret->err_data_flags[i]=0;
}
CRYPTO_w_lock(CRYPTO_LOCK_ERR);
tmpp=(ERR_STATE *)lh_insert(thread_hash,ret);
CRYPTO_w_unlock(CRYPTO_LOCK_ERR);
if (tmpp != NULL) /* old entry - should not happen */
{
ERR_STATE_free(tmpp);
}
}
return(ret);
}
void CRYPTO_dbg_realloc(void *addr1, void *addr2, int num,
const char *file, int line, int before_p)
{
MEM m,*mp;
#ifdef LEVITTE_DEBUG_MEM
fprintf(stderr, "LEVITTE_DEBUG_MEM: --> CRYPTO_dbg_malloc(addr1 = %p, addr2 = %p, num = %d, file = \"%s\", line = %d, before_p = %d)\n",
addr1, addr2, num, file, line, before_p);
#endif
switch(before_p)
{
case 0:
break;
case 1:
if (addr2 == NULL)
break;
if (addr1 == NULL)
{
CRYPTO_dbg_malloc(addr2, num, file, line, 128 | before_p);
break;
}
if (is_MemCheck_on())
{
MemCheck_off(); /* make sure we hold MALLOC2 lock */
m.addr=addr1;
mp=(MEM *)lh_delete(mh,(char *)&m);
if (mp != NULL)
{
#ifdef LEVITTE_DEBUG_MEM
fprintf(stderr, "LEVITTE_DEBUG_MEM: [%5d] * 0x%p (%d) -> 0x%p (%d)\n",
mp->order,
mp->addr, mp->num,
addr2, num);
#endif
mp->addr=addr2;
mp->num=num;
lh_insert(mh,(char *)mp);
}
MemCheck_on(); /* release MALLOC2 lock
* if num_disabled drops to 0 */
}
break;
}
return;
}
int CRYPTO_push_info_(const char *info, const char *file, int line)
{
APP_INFO *ami, *amim;
int ret=0;
if (is_MemCheck_on())
{
MemCheck_off(); /* obtain MALLOC2 lock */
if ((ami = (APP_INFO *)OPENSSL_malloc(sizeof(APP_INFO))) == NULL)
{
ret=0;
goto err;
}
if (amih == NULL)
{
if ((amih=lh_new(app_info_hash, app_info_cmp)) == NULL)
{
OPENSSL_free(ami);
ret=0;
goto err;
}
}
ami->thread=CRYPTO_thread_id();
ami->file=file;
ami->line=line;
ami->info=info;
ami->references=1;
ami->next=NULL;
if ((amim=(APP_INFO *)lh_insert(amih,(char *)ami)) != NULL)
{
#ifdef LEVITTE_DEBUG_MEM
if (ami->thread != amim->thread)
{
fprintf(stderr, "CRYPTO_push_info(): previous info has other thread ID (%lu) than the current thread (%lu)!!!!\n",
amim->thread, ami->thread);
abort();
}
#endif
ami->next=amim;
}
err:
MemCheck_on(); /* release MALLOC2 lock */
}
return(ret);
}
static ERR_STRING_DATA *int_err_set_item(ERR_STRING_DATA *d)
{
ERR_STRING_DATA *p;
LHASH *hash;
err_fns_check();
hash = ERRFN(err_get)(1);
if (!hash)
return NULL;
CRYPTO_w_lock(CRYPTO_LOCK_ERR);
p = (ERR_STRING_DATA *)lh_insert(hash, d);
CRYPTO_w_unlock(CRYPTO_LOCK_ERR);
return p;
}
int OBJ_NAME_add(const char *name, int type, const char *data)
{
OBJ_NAME *onp,*ret;
int alias;
if ((names_lh == NULL) && !OBJ_NAME_init()) return(0);
alias=type&OBJ_NAME_ALIAS;
type&= ~OBJ_NAME_ALIAS;
onp=(OBJ_NAME *)OPENSSL_malloc(sizeof(OBJ_NAME));
if (onp == NULL)
{
/* ERROR */
return(0);
}
onp->name=name;
onp->alias=alias;
onp->type=type;
onp->data=data;
ret=(OBJ_NAME *)lh_insert(names_lh,onp);
if (ret != NULL)
{
/* free things */
if ((name_funcs_stack != NULL) && (sk_NAME_FUNCS_num(name_funcs_stack) > ret->type))
{
/* XXX: I'm not sure I understand why the free
* function should get three arguments...
* -- Richard Levitte
*/
sk_NAME_FUNCS_value(name_funcs_stack,ret->type)
->free_func(ret->name,ret->type,ret->data);
}
OPENSSL_free(ret);
}
else
{
if (lh_error(names_lh))
{
/* ERROR */
return(0);
}
}
return(1);
}
static ERR_STATE *int_thread_set_item(ERR_STATE *d)
{
ERR_STATE *p;
LHASH *hash;
err_fns_check();
hash = ERRFN(thread_get)(1);
if (!hash)
return NULL;
CRYPTO_w_lock(CRYPTO_LOCK_ERR);
p = (ERR_STATE *)lh_insert(hash, d);
CRYPTO_w_unlock(CRYPTO_LOCK_ERR);
ERRFN(thread_release)(&hash);
return p;
}
static LHASH *prog_init(void)
{
LHASH *ret;
FUNCTION *f;
size_t i;
/* Purely so it looks nice when the user hits ? */
for (i = 0, f = functions; f->name != NULL; ++f, ++i) ;
qsort(functions, i, sizeof *functions, SortFnByName);
if ((ret = lh_new(hash, cmp)) == NULL)
return (NULL);
for (f = functions; f->name != NULL; f++)
lh_insert(ret, f);
return (ret);
}
int TXT_DB_insert(TXT_DB *db, char **row)
{
int i;
char **r;
for (i=0; i<db->num_fields; i++)
{
if (db->index[i] != NULL)
{
if ((db->qual[i] != NULL) &&
(db->qual[i](row) == 0)) continue;
r=(char **)lh_retrieve(db->index[i],row);
if (r != NULL)
{
db->error=DB_ERROR_INDEX_CLASH;
db->arg1=i;
db->arg_row=r;
goto err;
}
}
}
/* We have passed the index checks, now just append and insert */
if (!sk_push(db->data,(char *)row))
{
db->error=DB_ERROR_MALLOC;
goto err;
}
for (i=0; i<db->num_fields; i++)
{
if (db->index[i] != NULL)
{
if ((db->qual[i] != NULL) &&
(db->qual[i](row) == 0)) continue;
lh_insert(db->index[i],row);
}
}
return(1);
err:
return(0);
}
int OBJ_add_object(const ASN1_OBJECT *obj)
{
ASN1_OBJECT *o;
ADDED_OBJ *ao[4]={NULL,NULL,NULL,NULL},*aop;
int i;
if (added == NULL)
if (!init_added()) return(0);
if ((o=OBJ_dup(obj)) == NULL) goto err;
if (!(ao[ADDED_NID]=(ADDED_OBJ *)OPENSSL_malloc(sizeof(ADDED_OBJ)))) goto err2;
if ((o->length != 0) && (obj->data != NULL))
if (!(ao[ADDED_DATA]=(ADDED_OBJ *)OPENSSL_malloc(sizeof(ADDED_OBJ)))) goto err2;
if (o->sn != NULL)
if (!(ao[ADDED_SNAME]=(ADDED_OBJ *)OPENSSL_malloc(sizeof(ADDED_OBJ)))) goto err2;
if (o->ln != NULL)
if (!(ao[ADDED_LNAME]=(ADDED_OBJ *)OPENSSL_malloc(sizeof(ADDED_OBJ)))) goto err2;
for (i=ADDED_DATA; i<=ADDED_NID; i++)
{
if (ao[i] != NULL)
{
ao[i]->type=i;
ao[i]->obj=o;
aop=(ADDED_OBJ *)lh_insert(added,ao[i]);
/* memory leak, buit should not normally matter */
if (aop != NULL)
OPENSSL_free(aop);
}
}
o->flags&= ~(ASN1_OBJECT_FLAG_DYNAMIC|ASN1_OBJECT_FLAG_DYNAMIC_STRINGS|
ASN1_OBJECT_FLAG_DYNAMIC_DATA);
return(o->nid);
err2:
OBJerr(OBJ_F_OBJ_ADD_OBJECT,ERR_R_MALLOC_FAILURE);
err:
for (i=ADDED_DATA; i<=ADDED_NID; i++)
if (ao[i] != NULL) OPENSSL_free(ao[i]);
if (o != NULL) OPENSSL_free(o);
return(NID_undef);
}
int TXT_DB_create_index(TXT_DB *db, int field, int (*qual)(char **),
LHASH_HASH_FN_TYPE hash, LHASH_COMP_FN_TYPE cmp)
{
LHASH *idx;
char **r;
int i,n;
if (field >= db->num_fields)
{
db->error=DB_ERROR_INDEX_OUT_OF_RANGE;
return(0);
}
if ((idx=lh_new(hash,cmp)) == NULL)
{
db->error=DB_ERROR_MALLOC;
return(0);
}
n=sk_num(db->data);
for (i=0; i<n; i++)
{
r=(char **)sk_value(db->data,i);
if ((qual != NULL) && (qual(r) == 0)) continue;
if ((r=lh_insert(idx,r)) != NULL)
{
db->error=DB_ERROR_INDEX_CLASH;
db->arg1=sk_find(db->data,(char *)r);
db->arg2=i;
lh_free(idx);
return(0);
}
}
if (db->index[field] != NULL) lh_free(db->index[field]);
db->index[field]=idx;
db->qual[field]=qual;
return(1);
}
static APP_INFO *pop_info(void)
{
APP_INFO tmp;
APP_INFO *ret = NULL;
if (amih != NULL)
{
tmp.thread=CRYPTO_thread_id();
if ((ret=(APP_INFO *)lh_delete(amih,&tmp)) != NULL)
{
APP_INFO *next=ret->next;
if (next != NULL)
{
next->references++;
lh_insert(amih,(char *)next);
}
#ifdef LEVITTE_DEBUG_MEM
if (ret->thread != tmp.thread)
{
fprintf(stderr, "pop_info(): deleted info has other thread ID (%lu) than the current thread (%lu)!!!!\n",
ret->thread, tmp.thread);
abort();
}
#endif
if (--(ret->references) <= 0)
{
ret->next = NULL;
if (next != NULL)
next->references--;
OPENSSL_free(ret);
}
}
}
return(ret);
}
int data_3 = 3;
/* temporary data pointer used for testing get */
int *data = 0;
puts("\ntesting delete functionality ");
puts("creating a table");
table = lh_new();
assert(table);
assert( 32 == table->size );
assert( 0 == lh_nelems(table) );
puts("inserting some data");
assert( lh_insert(table, key_1, &data_1) );
assert( 1 == lh_nelems(table) );
assert( 0 == lh_get(table, key_2) );
assert( 0 == lh_get(table, key_3) );
data = lh_get(table, key_1);
assert(data);
assert( data_1 == *data );
assert( lh_insert(table, key_2, &data_2) );
assert( 2 == lh_nelems(table) );
assert( 0 == lh_get(table, key_3) );
data = lh_get(table, key_2);
assert(data);
void set(void){
/* our simple hash table */
struct lh_table *table = 0;
/* some keys */
char *key_1 = "rhubarb";
char *key_2 = "carrot";
char *key_3 = "potato";
/* some data */
int data_1 = 1;
int data_2 = 2;
int data_3 = 3;
/* some data we override with */
int new_data_1 = 14;
int new_data_2 = 15;
int new_data_3 = 16;
/* temporary data pointer used for testing get */
int *data = 0;
puts("\ntesting set functionality");
puts("creating table");
table = lh_new();
assert(table);
assert( 32 == table->size );
assert( 0 == lh_nelems(table) );
puts("inserting some data");
assert( lh_insert(table, key_1, &data_1) );
assert( 1 == lh_nelems(table) );
assert( 0 == lh_get(table, key_2) );
assert( 0 == lh_get(table, key_3) );
data = lh_get(table, key_1);
assert(data);
assert( data_1 == *data );
assert( lh_insert(table, key_2, &data_2) );
assert( 2 == lh_nelems(table) );
assert( 0 == lh_get(table, key_3) );
data = lh_get(table, key_2);
assert(data);
assert( data_2 == *data );
assert( lh_insert(table, key_3, &data_3) );
assert( 3 == lh_nelems(table) );
data = lh_get(table, key_3);
assert(data);
assert( data_3 == *data );
puts("testing set");
puts("testing set failure for non-existing key");
data = lh_set(table, "foobarr", &data_1);
assert( 0 == data );
puts("two set");
data = lh_set(table, key_2, &new_data_2);
assert(data);
assert( *data == data_2 );
assert( 3 == lh_nelems(table) );
data = lh_get(table, key_2);
assert(data);
assert( *data == new_data_2 );
puts("three set");
data = lh_set(table, key_3, &new_data_3);
assert(data);
assert( *data == data_3 );
assert( 3 == lh_nelems(table) );
data = lh_get(table, key_3);
assert(data);
assert( *data == new_data_3 );
puts("one set");
data = lh_set(table, key_1, &new_data_1);
assert(data);
assert( *data == data_1 );
assert( 3 == lh_nelems(table) );
data = lh_get(table, key_1);
assert(data);
assert( *data == new_data_1 );
assert( lh_destroy(table, 1, 0) );
puts("success!");
}
void CRYPTO_dbg_malloc(void *addr, int num, const char *file, int line,
int before_p)
{
MEM *m,*mm;
APP_INFO tmp,*amim;
switch(before_p & 127)
{
case 0:
break;
case 1:
if (addr == NULL)
break;
if (is_MemCheck_on())
{
MemCheck_off(); /* make sure we hold MALLOC2 lock */
if ((m=(MEM *)OPENSSL_malloc(sizeof(MEM))) == NULL)
{
OPENSSL_free(addr);
MemCheck_on(); /* release MALLOC2 lock
* if num_disabled drops to 0 */
return;
}
if (mh == NULL)
{
if ((mh=lh_new(mem_hash, mem_cmp)) == NULL)
{
OPENSSL_free(addr);
OPENSSL_free(m);
addr=NULL;
goto err;
}
}
m->addr=addr;
m->file=file;
m->line=line;
m->num=num;
if (options & V_CRYPTO_MDEBUG_THREAD)
m->thread=CRYPTO_thread_id();
else
m->thread=0;
if (order == break_order_num)
{
/* BREAK HERE */
m->order=order;
}
m->order=order++;
#ifdef LEVITTE_DEBUG_MEM
fprintf(stderr, "LEVITTE_DEBUG_MEM: [%5d] %c 0x%p (%d)\n",
m->order,
(before_p & 128) ? '*' : '+',
m->addr, m->num);
#endif
if (options & V_CRYPTO_MDEBUG_TIME)
m->time=time(NULL);
else
m->time=0;
tmp.thread=CRYPTO_thread_id();
m->app_info=NULL;
if (amih != NULL
&& (amim=(APP_INFO *)lh_retrieve(amih,(char *)&tmp)) != NULL)
{
m->app_info = amim;
amim->references++;
}
if ((mm=(MEM *)lh_insert(mh,(char *)m)) != NULL)
{
/* Not good, but don't sweat it */
if (mm->app_info != NULL)
{
mm->app_info->references--;
}
OPENSSL_free(mm);
}
err:
MemCheck_on(); /* release MALLOC2 lock
* if num_disabled drops to 0 */
}
break;
}
return;
}
/*
* generate anonymized strings preserving lexicographic-order
*
* only strings between start and end (including start, excluding end)
* will be processed
* set end to null to process list to the end
* prev_length - length of prefixes already processed. Hence all
* strings in the range must be longer or of equal
* length. Furthermore, all strings in the range are expected to have
* identical prefixes of prev_length.
* aprefix - anonymized prefix (first prev_length chars)
*/
static int
generate_lex_anonymizations(anon_octs_t *a, size_t prev_length,
const char* aprefix,
struct node *start, struct node *end)
{
char* str; /* prefix up to min_length */
char* astr; /* astr - anonymized str */
char* prefix; /* prefix of prev_length - same for all strings in group */
//char* aprefix; /* anonymized (hash of) prefix */
//char* middle; /* part of string between prev_length and min_length */
char* amiddle; /* anonymized (hash of) middle */
struct node *p, *q; /* nodes in list */
struct node *start2; /* recursively process this part of the list */
size_t min_length; /* minimum string length in our part of list */
int count; /* number of unique prefixes (of min_length) */
struct node* hashlist = NULL; /* stores generated amiddle's */
struct node *hp; /* nodes in hash list */
struct hash_node* node = NULL; /* lhash table node */
int i;
assert(a);
if (!start)
return 0;
assert(aprefix || prev_length > 0);
/* find min length */
min_length = strlen(start->data);
for (p = start; p && p!=end; p = p->next) {
int tmp = strlen(p->data);
if (tmp < min_length) {
min_length = tmp;
}
}
assert(min_length > prev_length);
/* count unique prefixes of min_length (after position prev_length) */
count = 0;
for (p = start, q = NULL; p && p!=end; q = p, p = p->next) {
if (q) {
if (strncmp(p->data+prev_length, q->data+prev_length,
min_length-prev_length)) {
count++;
}
} else { /* first element in list */
count++;
}
}
/* produce hashlist (amiddle) */
for (i=0; i<count; i++) {
do {
amiddle = (char*) malloc(min_length-prev_length+1);
amiddle = generate_random_string(amiddle, min_length-prev_length);
} while (list_insert(&hashlist,amiddle)==1);
}
/* assign anon. strings to real strings and store them in lhash table */
str = (char*) malloc(min_length+1);
astr = (char*) malloc(min_length+1);
assert(str);
assert(astr);
hp = hashlist;
int group_size = 0; /* size of last group
* excluding min_lenght element (if it exists)
*/
int is_diff = 0; /* is current string (p) different from previous one (q)
* up to min_length?
*/
int was_minlength = 0; /* if last group contained (==started with)
* a string of min_length
* - determines if we need to allocate new str, astr
*/
start2 = start;
for (p = start, q = NULL; p && p!=end; q = p, p = p->next) {
/*
fprintf(stderr, "assigning %s (hp: %s)...\n",
p->data, (hp)?hp->data:"NULL");
*/
assert(strlen(p->data) >= min_length);
/* check if p is different from q up to first min_length chars */
is_diff = 0;
if (q) {
if (strncmp(p->data+prev_length, q->data+prev_length,
min_length-prev_length)) {
is_diff = 1;
} else {
group_size++;
}
} else {
/* first item in list */
is_diff = 1;
}
if (is_diff) {
if (q) { /* don't call for first item in list */
/* anonymize the previous group */
if (group_size > 0) {
assert(strlen(start2->data) > min_length);
generate_lex_anonymizations(a, min_length, astr,
start2, p);
}
if (was_minlength) {
str = (char*) malloc(min_length+1);
astr = (char*) malloc(min_length+1);
assert(str);
assert(astr);
}
}
start2 = p;
/* prepare str, astr */
strncpy(str, p->data, min_length);
str[min_length] = '\0';
/* aprefix generated earlier and passed as a function argument */
strncpy(astr, aprefix, prev_length);
assert(hp);
assert(hp->data);
strncpy(astr+prev_length, hp->data, min_length-prev_length);
astr[min_length] = '\0';
if (strlen(p->data) == min_length) {
/* store (str, astr) in lhash */
node = (struct hash_node*) malloc(sizeof(struct hash_node));
assert(node);
node->data = str;
node->hash = astr;
/*
fprintf(stderr, "storing in hash table [%s --> %s]\n",
str, astr);
*/
lh_insert(a->hash_table, node);
/* omit this (min_length) element from recursion */
start2 = p->next;
was_minlength = 1;
group_size = 0;
} else {
/* don't need to store (str, astr) in lhash */
was_minlength = 0;
group_size = 1;
}
/* advance to next node in hashlist */
hp = hp->next;
} /* else do nothing */
}
if (start2 && group_size > 0) {
assert(strlen(start2->data) > min_length);
generate_lex_anonymizations(a, min_length, astr, start2, end);
}
if (was_minlength) {
str = (char*) malloc(min_length+1);
astr = (char*) malloc(min_length+1);
assert(str);
assert(astr);
}
/* we don't need the list of used strings anymore */
//list_remove_all(&(a->list));
list_remove_all(&hashlist);
free(str);
free(astr);
return 0;
}
int main(int argc, char **argv) {
_LHASH *lh;
struct dummy_lhash dummy_lh = {NULL};
unsigned i;
CRYPTO_library_init();
lh = lh_new(NULL, NULL);
if (lh == NULL) {
return 1;
}
for (i = 0; i < 100000; i++) {
unsigned action;
char *s, *s1, *s2;
if (dummy_lh_num_items(&dummy_lh) != lh_num_items(lh)) {
fprintf(stderr, "Length mismatch\n");
return 1;
}
action = rand() % 3;
switch (action) {
case 0:
s = rand_string();
s1 = (char *)lh_retrieve(lh, s);
s2 = dummy_lh_retrieve(&dummy_lh, s);
if (s1 != NULL && (s2 == NULL || strcmp(s1, s2) != 0)) {
fprintf(stderr, "lh_retrieve failure\n");
abort();
}
free(s);
break;
case 1:
s = rand_string();
lh_insert(lh, (void **)&s1, s);
dummy_lh_insert(&dummy_lh, &s2, strdup(s));
if (s1 != NULL && (s2 == NULL || strcmp(s1, s2) != 0)) {
fprintf(stderr, "lh_insert failure\n");
abort();
}
if (s1) {
free(s1);
}
if (s2) {
free(s2);
}
break;
case 2:
s = rand_string();
s1 = lh_delete(lh, s);
s2 = dummy_lh_delete(&dummy_lh, s);
if (s1 != NULL && (s2 == NULL || strcmp(s1, s2) != 0)) {
fprintf(stderr, "lh_insert failure\n");
abort();
}
if (s1) {
free(s1);
}
if (s2) {
free(s2);
}
free(s);
break;
default:
abort();
}
}
lh_doall(lh, free);
lh_free(lh);
dummy_lh_free(&dummy_lh);
printf("PASS\n");
return 0;
}
void new_insert_get_destroy(void){
/* our simple hash table */
struct lh_table *table = 0;
/* some keys */
char *key_1 = "bbbbb";
char *key_2 = "aaaaa";
char *key_3 = "ccccc";
/* some data */
int data_1 = 1;
int data_2 = 2;
int data_3 = 3;
/* temporary data pointer used for testing get */
int *data = 0;
puts("\ntesting basic functionality");
puts("testing new");
table = lh_new();
assert(table);
assert( 32 == table->size );
assert( 0 == lh_nelems(table) );
assert( 0 == lh_load(table) );
puts("testing insert and get");
puts("one insert");
assert( lh_insert(table, key_1, &data_1) );
assert( 1 == lh_nelems(table));
assert( 0 == lh_get(table, key_2) );
assert( 0 == lh_get(table, key_3) );
puts("one get");
data = lh_get(table, key_1);
assert(data);
assert( data_1 == *data );
puts("two insert");
assert( lh_insert(table, key_2, &data_2) );
assert( 2 == lh_nelems(table) );
assert( 0 == lh_get(table, key_3) );
puts("two get");
data = lh_get(table, key_2);
assert(data);
assert( data_2 == *data );
puts("three insert");
assert( lh_insert(table, key_3, &data_3) );
assert( 3 == lh_nelems(table) );
puts("three get");
data = lh_get(table, key_3);
assert(data);
assert( data_3 == *data );
assert( lh_destroy(table, 1, 0) );
puts("success!");
}
ERR_STATE *ERR_get_state(void)
{
static ERR_STATE fallback;
ERR_STATE *ret=NULL,tmp,*tmpp=NULL;
int thread_state_exists;
int i;
unsigned long pid;
pid=(unsigned long)CRYPTO_thread_id();
CRYPTO_w_lock(CRYPTO_LOCK_ERR);
if (thread_hash != NULL)
{
tmp.pid=pid;
ret=(ERR_STATE *)lh_retrieve(thread_hash,&tmp);
}
CRYPTO_w_unlock(CRYPTO_LOCK_ERR);
/* ret == the error state, if NULL, make a new one */
if (ret == NULL)
{
ret=(ERR_STATE *)OPENSSL_malloc(sizeof(ERR_STATE));
if (ret == NULL) return(&fallback);
ret->pid=pid;
ret->top=0;
ret->bottom=0;
for (i=0; i<ERR_NUM_ERRORS; i++)
{
ret->err_data[i]=NULL;
ret->err_data_flags[i]=0;
}
CRYPTO_w_lock(CRYPTO_LOCK_ERR);
/* no entry yet in thread_hash for current thread -
* thus, it may have changed since we last looked at it */
if (thread_hash == NULL)
thread_hash = lh_new(pid_hash, pid_cmp);
if (thread_hash == NULL)
thread_state_exists = 0; /* allocation error */
else
{
tmpp=(ERR_STATE *)lh_insert(thread_hash,ret);
thread_state_exists = 1;
}
CRYPTO_w_unlock(CRYPTO_LOCK_ERR);
if (!thread_state_exists)
{
ERR_STATE_free(ret); /* could not insert it */
return(&fallback);
}
if (tmpp != NULL) /* old entry - should not happen */
{
ERR_STATE_free(tmpp);
}
}
return(ret);
}
/*
* Store a pathname in the pathname store.
*/
char*
Pathstore_path(Pathstore *store, char *pathname, int discardDuplicateFiles)
{
char chksum1[CHKSUMFILE_SIZE];
struct unixfilesystem *fs = (struct unixfilesystem *) (store->fshandle);
numstores++;
PathstoreElement *entry;
/* For 1 file case
* No hash table or checksum
*/
if(numfilesseen == 0){
numfilesseen++;
entry = malloc(sizeof(PathstoreElement));;
entry->pathname = strdup(pathname);
if (entry->pathname == NULL) {
free(entry);
printf("memory problem 2\n");
return NULL;
}
store->elementList = entry;
return entry->pathname;
}
/* For >1 file
* Use hash table and checksums
*/
_LHASH *hashtable;
// if we are going from 1 file case to 2 files
if(numfilesseen == 1){
numfilesseen++;
//store first entry somewhere
PathstoreElement *temp = store->elementList;
//calc checksum for file 1 path
int err = chksumfile_bypathname(fs, temp->pathname, chksum1);
if (err < 0) {
fprintf(stderr,"Can't checksum path %s\n", pathname);
return 0;
}
memcpy(temp->chksum, chksum1, CHKSUMFILE_SIZE);
//initialize hash table
store->elementList = lh_new(HashCallback, CompareCallback);
hashtable = (_LHASH*) (store->elementList);
//seed hash table with first entry
lh_insert(hashtable,(char *) temp);
if (lh_error(hashtable)) {
free(temp);
printf("hash problem\n");
return NULL;
}
}else{
hashtable = (_LHASH*) (store->elementList);
}
// calc checksum of pathname
int err = chksumfile_bypathname(fs, pathname, chksum1);
if (err < 0) {
fprintf(stderr,"Can't checksum path %s\n", pathname);
return 0;
}
PathstoreElement key;
memcpy(key.chksum, chksum1, CHKSUMFILE_SIZE);
// if discardDups, see if its in table, if it is, return
if (discardDuplicateFiles) {
entry = lh_retrieve(hashtable, (char *) &key);
if(entry != NULL){
numdups++;
return NULL;
}
}
// otherwise add
entry = malloc(sizeof(PathstoreElement));
if (entry == NULL) {
printf("memory problem\n");
return NULL;
}
memcpy(entry->chksum, chksum1, CHKSUMFILE_SIZE);
entry->pathname = strdup(pathname);
if (entry->pathname == NULL) {
free(entry);
printf("memory problem 2\n");
return NULL;
}
lh_insert(hashtable,(char *) entry);
if (lh_error(hashtable)) {
free(entry);
printf("hash problem\n");
return NULL;
}
return entry->pathname;
}
static int def_load_bio(CONF *conf, BIO *in, long *line)
{
/* The macro BUFSIZE conflicts with a system macro in VxWorks */
#define CONFBUFSIZE 512
int bufnum = 0, i, ii;
BUF_MEM *buff = NULL;
char *s, *p, *end;
int again;
long eline = 0;
char btmp[DECIMAL_SIZE(eline) + 1];
CONF_VALUE *v = NULL, *tv;
CONF_VALUE *sv = NULL;
char *section = NULL, *buf;
char *start, *psection, *pname;
void *h = (void *)(conf->data);
if ((buff = BUF_MEM_new()) == NULL) {
CONFerr(CONF_F_DEF_LOAD_BIO, ERR_R_BUF_LIB);
goto err;
}
section = (char *)OPENSSL_malloc(10);
if (section == NULL) {
CONFerr(CONF_F_DEF_LOAD_BIO, ERR_R_MALLOC_FAILURE);
goto err;
}
BUF_strlcpy(section, "default", 10);
if (_CONF_new_data(conf) == 0) {
CONFerr(CONF_F_DEF_LOAD_BIO, ERR_R_MALLOC_FAILURE);
goto err;
}
sv = _CONF_new_section(conf, section);
if (sv == NULL) {
CONFerr(CONF_F_DEF_LOAD_BIO, CONF_R_UNABLE_TO_CREATE_NEW_SECTION);
goto err;
}
bufnum = 0;
again = 0;
for (;;) {
if (!BUF_MEM_grow(buff, bufnum + CONFBUFSIZE)) {
CONFerr(CONF_F_DEF_LOAD_BIO, ERR_R_BUF_LIB);
goto err;
}
p = &(buff->data[bufnum]);
*p = '\0';
BIO_gets(in, p, CONFBUFSIZE - 1);
p[CONFBUFSIZE - 1] = '\0';
ii = i = sgx_strlen(p);
if (i == 0 && !again)
break;
again = 0;
while (i > 0) {
if ((p[i - 1] != '\r') && (p[i - 1] != '\n'))
break;
else
i--;
}
/*
* we removed some trailing stuff so there is a new line on the end.
*/
if (ii && i == ii)
again = 1; /* long line */
else {
p[i] = '\0';
eline++; /* another input line */
}
/* we now have a line with trailing \r\n removed */
/* i is the number of bytes */
bufnum += i;
v = NULL;
/* check for line continuation */
if (bufnum >= 1) {
/*
* If we have bytes and the last char '\\' and second last char
* is not '\\'
*/
p = &(buff->data[bufnum - 1]);
if (IS_ESC(conf, p[0]) && ((bufnum <= 1) || !IS_ESC(conf, p[-1]))) {
bufnum--;
again = 1;
}
}
if (again)
continue;
bufnum = 0;
buf = buff->data;
clear_comments(conf, buf);
s = eat_ws(conf, buf);
if (IS_EOF(conf, *s))
continue; /* blank line */
if (*s == '[') {
char *ss;
s++;
start = eat_ws(conf, s);
ss = start;
again:
end = eat_alpha_numeric(conf, ss);
p = eat_ws(conf, end);
if (*p != ']') {
if (*p != '\0' && ss != p) {
ss = p;
goto again;
}
CONFerr(CONF_F_DEF_LOAD_BIO,
CONF_R_MISSING_CLOSE_SQUARE_BRACKET);
goto err;
}
*end = '\0';
if (!str_copy(conf, NULL, §ion, start))
goto err;
if ((sv = _CONF_get_section(conf, section)) == NULL)
sv = _CONF_new_section(conf, section);
if (sv == NULL) {
CONFerr(CONF_F_DEF_LOAD_BIO,
CONF_R_UNABLE_TO_CREATE_NEW_SECTION);
goto err;
}
continue;
} else {
pname = s;
psection = NULL;
end = eat_alpha_numeric(conf, s);
if ((end[0] == ':') && (end[1] == ':')) {
*end = '\0';
end += 2;
psection = pname;
pname = end;
end = eat_alpha_numeric(conf, end);
}
p = eat_ws(conf, end);
if (*p != '=') {
CONFerr(CONF_F_DEF_LOAD_BIO, CONF_R_MISSING_EQUAL_SIGN);
goto err;
}
*end = '\0';
p++;
start = eat_ws(conf, p);
while (!IS_EOF(conf, *p))
p++;
p--;
while ((p != start) && (IS_WS(conf, *p)))
p--;
p++;
*p = '\0';
if (!(v = (CONF_VALUE *)OPENSSL_malloc(sizeof(CONF_VALUE)))) {
CONFerr(CONF_F_DEF_LOAD_BIO, ERR_R_MALLOC_FAILURE);
goto err;
}
if (psection == NULL)
psection = section;
v->name = (char *)OPENSSL_malloc(strlen(pname) + 1);
v->value = NULL;
if (v->name == NULL) {
CONFerr(CONF_F_DEF_LOAD_BIO, ERR_R_MALLOC_FAILURE);
goto err;
}
BUF_strlcpy(v->name, pname, sgx_strlen(pname) + 1);
if (!str_copy(conf, psection, &(v->value), start))
goto err;
if (sgx_strcmp(psection, section) != 0) {
if ((tv = _CONF_get_section(conf, psection))
== NULL)
tv = _CONF_new_section(conf, psection);
if (tv == NULL) {
CONFerr(CONF_F_DEF_LOAD_BIO,
CONF_R_UNABLE_TO_CREATE_NEW_SECTION);
goto err;
}
} else
tv = sv;
#if 1
if (_CONF_add_string(conf, tv, v) == 0) {
CONFerr(CONF_F_DEF_LOAD_BIO, ERR_R_MALLOC_FAILURE);
goto err;
}
#else
v->section = tv->section;
if (!sk_CONF_VALUE_push(ts, v)) {
CONFerr(CONF_F_DEF_LOAD_BIO, ERR_R_MALLOC_FAILURE);
goto err;
}
vv = (CONF_VALUE *)lh_insert(conf->data, v);
if (vv != NULL) {
sk_CONF_VALUE_delete_ptr(ts, vv);
OPENSSL_free(vv->name);
OPENSSL_free(vv->value);
OPENSSL_free(vv);
}
#endif
v = NULL;
}
}
if (buff != NULL)
BUF_MEM_free(buff);
if (section != NULL)
OPENSSL_free(section);
return (1);
err:
if (buff != NULL)
BUF_MEM_free(buff);
if (section != NULL)
OPENSSL_free(section);
if (line != NULL)
*line = eline;
BIO_snprintf(btmp, sizeof btmp, "%ld", eline);
ERR_add_error_data(2, "line ", btmp);
if ((h != conf->data) && (conf->data != NULL)) {
CONF_free(conf->data);
conf->data = NULL;
}
if (v != NULL) {
if (v->name != NULL)
OPENSSL_free(v->name);
if (v->value != NULL)
OPENSSL_free(v->value);
if (v != NULL)
OPENSSL_free(v);
}
return (0);
}