static void int_thread_del_item(const ERR_STATE *d)
{
ERR_STATE *p;
LHASH *hash;
err_fns_check();
hash = ERRFN(thread_get)(0);
if (!hash)
return;
CRYPTO_w_lock(CRYPTO_LOCK_ERR);
p = (ERR_STATE *)lh_delete(hash, d);
/* make sure we don't leak memory */
if (int_thread_hash_references == 1
&& int_thread_hash && (lh_num_items(int_thread_hash) == 0))
{
lh_free(int_thread_hash);
int_thread_hash = NULL;
}
CRYPTO_w_unlock(CRYPTO_LOCK_ERR);
ERRFN(thread_release)(&hash);
if (p)
ERR_STATE_free(p);
}
/*
* Free up all the sources allocated for a pathstore.
*/
void
Pathstore_destory(Pathstore *store)
{
_LHASH *hashtable = (_LHASH*) (store->elementList);
lh_doall(hashtable, StoreCleanup);
lh_free(hashtable);
}
static void int_err_del(void)
{
CRYPTO_w_lock(CRYPTO_LOCK_ERR);
if (int_error_hash)
{
lh_free(int_error_hash);
int_error_hash = NULL;
}
CRYPTO_w_unlock(CRYPTO_LOCK_ERR);
}
void OBJ_cleanup(void)
{
if (added == NULL) return;
added->down_load=0;
lh_doall(added,LHASH_DOALL_FN(cleanup1)); /* zero counters */
lh_doall(added,LHASH_DOALL_FN(cleanup2)); /* set counters */
lh_doall(added,LHASH_DOALL_FN(cleanup3)); /* free objects */
lh_free(added);
added=NULL;
}
void engine_table_cleanup(ENGINE_TABLE **table)
{
CRYPTO_w_lock(CRYPTO_LOCK_ENGINE);
if(*table)
{
lh_doall(&(*table)->piles, LHASH_DOALL_FN(int_cleanup_cb));
lh_free(&(*table)->piles);
*table = NULL;
}
CRYPTO_w_unlock(CRYPTO_LOCK_ENGINE);
}
void ERR_free_strings(void)
{
CRYPTO_w_lock(CRYPTO_LOCK_ERR);
if (error_hash != NULL)
{
lh_free(error_hash);
error_hash=NULL;
}
CRYPTO_w_unlock(CRYPTO_LOCK_ERR);
}
int huddraw_tunnel() {
if (!(hud_inv & HUDINVMASK_TUNNEL)) return 0;
bg_color = B1(COLOR_NETHER_RED);
draw_clear();
fg_color = B3(COLOR_GOLD_YELLOW);
int32_t x = (int32_t)floor(gs.own.x);
int32_t y = (int32_t)floor(gs.own.y);
int32_t z = (int32_t)floor(gs.own.z);
extent_t ex = { { x-80, y-2, z-80 }, { x+80, y+2, z+80 } };
cuboid_t cb = export_cuboid_extent(ex);
int r,c,i,j;
int32_t off = cb.boff + 16*cb.sa.x + 16;
for(r=0; r<128; r++) {
for(c=0; c<128; c++) {
int poff = off+r*cb.sa.x+c;
int s1=0,s2=0;
for(i=-8; i<8; i++) {
for(j=0; j<5; j++) {
s1+= (cb.data[j][poff-1+i*cb.sa.x].bid != 0)
-2*(cb.data[j][poff+0+i*cb.sa.x].bid != 0)
+ (cb.data[j][poff+1+i*cb.sa.x].bid != 0);
s2+= (cb.data[j][poff+i -cb.sa.x].bid != 0)
-2*(cb.data[j][poff+i ].bid != 0)
+ (cb.data[j][poff+i +cb.sa.x].bid != 0);
}
}
int s = MAX(s1,s2);
if (s>10) hud_image[r*128+c] = B3(COLOR_RED);
if (s>30) hud_image[r*128+c] = B3(COLOR_ORANGE);
if (s>60) hud_image[r*128+c] = B3(COLOR_YELLOW);
if (s>80) hud_image[r*128+c] = B3(COLOR_WHITE);
}
}
for(i=0; i<256; i++) lh_free(cb.data[i]);
hud_image[64*128+64] = B3(COLOR_DIAMOND_BLUE);
char text[256];
sprintf(text, "%d,%d", x, z);
draw_text(2, 2, text);
sprintf(text, "Y:%d", y);
draw_text(2, 10, text);
bg_color = COLOR_TRANSPARENT;
huddraw_compass(111, 16, B3(COLOR_GOLD_YELLOW), B3(COLOR_WHITE));
return 1;
}
void
anon_octs_delete(anon_octs_t *a)
{
if (! a) {
return;
}
lh_free(a->hash_table);
list_remove_all(&(a->list));
free(a);
}
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);
}
void test_localization(void) {
const char* filePath = NULL;
const char* language = NULL;
const char* testLanguage = NULL;
const char* const* languages;
size_t i = 0;
LocalizationHandler* lh = NULL;
filePath = "localization.txt";
language = "en";
testLanguage = "it";
g_print("\n\rInitialize localization with '%s' file and '%s' language...\n\r", filePath, language);
lh = lh_new(filePath, language);
g_print("File path is '%s' ", lh_get_file_path(lh));
g_print(", language is '%s'\n\r", lh_get_language(lh));
languages = lh_get_supported_languages(lh);
g_return_if_fail(languages != NULL);
g_print("Supported languages: ");
for (i = 0; languages[i]; i++) {
g_print("%s ", languages[i]);
}
g_print("\n\r");
g_print("Check file strings...\n\r");
g_print("Check localized file strings...\n\r");
test_print_localization_strings(lh, NULL);
if (lh_language_is_supported(lh, testLanguage) == FALSE) {
g_print("'%s' language is not supported...\n\r", testLanguage);
}
if (lh_language_is_supported(lh, language) == TRUE) {
test_print_localization_strings(lh, language);
}
if (lh_language_is_supported(lh, testLanguage) == TRUE) {
test_print_localization_strings(lh, language);
}
g_print("Release localization resources...\n\r");
lh_free(lh);
}
int huddraw_map() {
int shading[16] = { 3, 3, 3, 3, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2 };
if (!(hud_inv & HUDINVMASK_TUNNEL)) return 0;
bg_color = B0(COLOR_BLACK);
draw_clear();
int32_t x = (int32_t)floor(gs.own.x);
int32_t y = (int32_t)floor(gs.own.y);
int32_t z = (int32_t)floor(gs.own.z);
extent_t ex = { { x-80, y-12, z-80 }, { x+80, y+3, z+80 } };
cuboid_t cb = export_cuboid_extent(ex);
int r,c,i,j;
int32_t off = cb.boff + 16*cb.sa.x + 16;
for(r=0; r<128; r++) {
for(c=0; c<128; c++) {
int poff = off+r*cb.sa.x+c;
for(j=0; j<16; j++) {
if ( cb.data[j][poff].bid ) {
int8_t color = BLOCK_COLORMAP[cb.data[j][poff].bid][cb.data[j][poff].meta];
hud_image[r*128+c] = color*4 + shading[j];
}
}
}
}
for(i=0; i<256; i++) lh_free(cb.data[i]);
hud_image[64*128+64] = 126;
char text[256];
bg_color = B3(COLOR_WHITE);
fg_color = B3(COLOR_REDSTONE_RED);
sprintf(text, "%d,%d", x, z);
draw_text(2, 2, text);
sprintf(text, "Y:%d", y);
draw_text(2, 9, text);
bg_color = COLOR_TRANSPARENT;
huddraw_compass(111, 16, B3(COLOR_GOLD_YELLOW), B3(COLOR_WHITE));
return 1;
}
void TXT_DB_free(TXT_DB *db)
{
int i,n;
char **p,*max;
if(db == NULL)
return;
if (db->index != NULL)
{
for (i=db->num_fields-1; i>=0; i--)
if (db->index[i] != NULL) lh_free(db->index[i]);
OPENSSL_free(db->index);
}
if (db->qual != NULL)
OPENSSL_free(db->qual);
if (db->data != NULL)
{
for (i=sk_num(db->data)-1; i>=0; i--)
{
/* check if any 'fields' have been allocated
* from outside of the initial block */
p=(char **)sk_value(db->data,i);
max=p[db->num_fields]; /* last address */
if (max == NULL) /* new row */
{
for (n=0; n<db->num_fields; n++)
if (p[n] != NULL) OPENSSL_free(p[n]);
}
else
{
for (n=0; n<db->num_fields; n++)
{
if (((p[n] < (char *)p) || (p[n] > max))
&& (p[n] != NULL))
OPENSSL_free(p[n]);
}
}
OPENSSL_free(sk_value(db->data,i));
}
sk_free(db->data);
}
OPENSSL_free(db);
}
void OBJ_NAME_cleanup(int type)
{
unsigned long down_load;
if (names_lh == NULL)
return;
free_type = type;
down_load = names_lh->down_load;
names_lh->down_load = 0;
lh_doall(names_lh, LHASH_DOALL_FN(names_lh_free));
if (type < 0) {
lh_free(names_lh);
sk_NAME_FUNCS_pop_free(name_funcs_stack, name_funcs_free);
names_lh = NULL;
name_funcs_stack = NULL;
} else
names_lh->down_load = down_load;
}
void ERR_remove_state(unsigned long pid)
{
ERR_STATE *p = NULL,tmp;
if (thread_hash == NULL)
return;
if (pid == 0)
pid=(unsigned long)CRYPTO_thread_id();
tmp.pid=pid;
CRYPTO_w_lock(CRYPTO_LOCK_ERR);
if (thread_hash)
{
p=(ERR_STATE *)lh_delete(thread_hash,&tmp);
if (lh_num_items(thread_hash) == 0)
{
/* make sure we don't leak memory */
lh_free(thread_hash);
thread_hash = NULL;
}
}
CRYPTO_w_unlock(CRYPTO_LOCK_ERR);
if (p != NULL) ERR_STATE_free(p);
}
void CRYPTO_mem_leaks(BIO *b)
{
MEM_LEAK ml;
if (mh == NULL && amih == NULL)
return;
MemCheck_off(); /* obtain MALLOC2 lock */
ml.bio=b;
ml.bytes=0;
ml.chunks=0;
if (mh != NULL)
lh_doall_arg(mh, LHASH_DOALL_ARG_FN(print_leak),
(char *)&ml);
if (ml.chunks != 0)
{
BIO_printf(b,"%ld bytes leaked in %d chunks\n",
ml.bytes,ml.chunks);
}
else
{
/* Make sure that, if we found no leaks, memory-leak debugging itself
* does not introduce memory leaks (which might irritate
* external debugging tools).
* (When someone enables leak checking, but does not call
* this function, we declare it to be their fault.)
*
* XXX This should be in CRYPTO_mem_leaks_cb,
* and CRYPTO_mem_leaks should be implemented by
* using CRYPTO_mem_leaks_cb.
* (Also their should be a variant of lh_doall_arg
* that takes a function pointer instead of a void *;
* this would obviate the ugly and illegal
* void_fn_to_char kludge in CRYPTO_mem_leaks_cb.
* Otherwise the code police will come and get us.)
*/
int old_mh_mode;
CRYPTO_w_lock(CRYPTO_LOCK_MALLOC);
/* avoid deadlock when lh_free() uses CRYPTO_dbg_free(),
* which uses CRYPTO_is_mem_check_on */
old_mh_mode = mh_mode;
mh_mode = CRYPTO_MEM_CHECK_OFF;
if (mh != NULL)
{
lh_free(mh);
mh = NULL;
}
if (amih != NULL)
{
if (lh_num_items(amih) == 0)
{
lh_free(amih);
amih = NULL;
}
}
mh_mode = old_mh_mode;
CRYPTO_w_unlock(CRYPTO_LOCK_MALLOC);
}
MemCheck_on(); /* release MALLOC2 lock */
}
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;
}
int openssl_main(int Argc, char *Argv[])
#endif
{
ARGS arg;
#define PROG_NAME_SIZE 39
char pname[PROG_NAME_SIZE+1];
FUNCTION f,*fp;
MS_STATIC const char *prompt;
MS_STATIC char buf[1024];
char *to_free=NULL;
int n,i,ret=0;
int argc;
char **argv,*p;
LHASH *prog=NULL;
long errline;
arg.data=NULL;
arg.count=0;
if (bio_err == NULL)
if ((bio_err=BIO_new(BIO_s_file())) != NULL)
#ifdef SYMBIAN
BIO_set_fp(bio_err,fp_stderr,BIO_NOCLOSE|BIO_FP_TEXT);
#else
BIO_set_fp(bio_err,stderr,BIO_NOCLOSE|BIO_FP_TEXT);
#endif
if (getenv("OPENSSL_DEBUG_MEMORY") != NULL) /* if not defined, use compiled-in library defaults */
{
if (!(0 == strcmp(getenv("OPENSSL_DEBUG_MEMORY"), "off")))
{
CRYPTO_malloc_debug_init();
CRYPTO_set_mem_debug_options(V_CRYPTO_MDEBUG_ALL);
}
else
{
/* OPENSSL_DEBUG_MEMORY=off */
CRYPTO_set_mem_debug_functions(0, 0, 0, 0, 0);
}
}
CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON);
#if 0
if (getenv("OPENSSL_DEBUG_LOCKING") != NULL)
#endif
{
CRYPTO_set_locking_callback(lock_dbg_cb);
}
apps_startup();
/* Lets load up our environment a little */
p=getenv("OPENSSL_CONF");
if (p == NULL)
p=getenv("SSLEAY_CONF");
if (p == NULL)
p=to_free=make_config_name();
default_config_file=p;
config=NCONF_new(NULL);
i=NCONF_load(config,p,&errline);
if (i == 0)
{
NCONF_free(config);
config = NULL;
ERR_clear_error();
}
prog=prog_init();
/* first check the program name */
program_name(Argv[0],pname,sizeof pname);
f.name=pname;
fp=(FUNCTION *)lh_retrieve(prog,&f);
if (fp != NULL)
{
Argv[0]=pname;
ret=fp->func(Argc,Argv);
goto end;
}
/* ok, now check that there are not arguments, if there are,
* run with them, shifting the ssleay off the front */
if (Argc != 1)
{
Argc--;
Argv++;
ret=do_cmd(prog,Argc,Argv);
if (ret < 0) ret=0;
goto end;
}
/* ok, lets enter the old 'OpenSSL>' mode */
for (;;)
{
ret=0;
p=buf;
n=sizeof buf;
i=0;
for (;;)
{
p[0]='\0';
if (i++)
prompt=">";
else prompt="OpenSSL> ";
#ifndef SYMBIAN
fputs(prompt,stdout);
fflush(stdout);
fgets(p,n,stdin);
#else
fputs(prompt,stdout);
fflush(stdout);
fgets(p,n,stdin);
#endif
if (p[0] == '\0') goto end;
i=strlen(p);
if (i <= 1) break;
if (p[i-2] != '\\') break;
i-=2;
p+=i;
n-=i;
}
if (!chopup_args(&arg,buf,&argc,&argv)) break;
ret=do_cmd(prog,argc,argv);
if (ret < 0)
{
ret=0;
goto end;
}
if (ret != 0)
BIO_printf(bio_err,"error in %s\n",argv[0]);
(void)BIO_flush(bio_err);
}
BIO_printf(bio_err,"bad exit\n");
ret=1;
end:
if (to_free)
OPENSSL_free(to_free);
if (config != NULL)
{
NCONF_free(config);
config=NULL;
}
if (prog != NULL) lh_free(prog);
if (arg.data != NULL) OPENSSL_free(arg.data);
apps_shutdown();
CRYPTO_mem_leaks(bio_err);
if (bio_err != NULL)
{
BIO_free(bio_err);
bio_err=NULL;
}
return ret;
// OPENSSL_EXIT(ret);
}
void free_hash_table(HashTable t)
{
// TODO: free all entries
lh_free(t);
}
