char gfxpoly_check(gfxpoly_t*poly)
{
dict_t*d = dict_new2(&point_type);
int s,t;
gfxpolystroke_t*stroke = poly->strokes;
for(;stroke;stroke=stroke->next) {
for(s=0;s<stroke->num_points;s++) {
point_t p = stroke->points[s];
int num = (s>=1 && s<stroke->num_points-1)?2:1; // mid points are two points (start+end)
if(!dict_contains(d, &p)) {
dict_put(d, &p, (void*)(ptroff_t)num);
} else {
int count = (ptroff_t)dict_lookup(d, &p);
dict_del(d, &p);
count+=num;
dict_put(d, &p, (void*)(ptroff_t)count);
}
}
}
DICT_ITERATE_ITEMS(d, point_t*, p, void*, c) {
int count = (ptroff_t)c;
if(count&1) {
fprintf(stderr, "Point (%f,%f) occurs %d times\n", p->x*poly->gridsize, p->y*poly->gridsize, count);
dict_destroy(d);
return 0;
}
}
void initialize_file(char*filename)
{
if(state) {
syntaxerror("invalid call to initialize_file during parsing of another file");
}
new_state();
state->package = internal_filename_package = strdup(filename);
global->token2info = dict_lookup(global->file2token2info,
current_filename // use long version
);
if(!global->token2info) {
global->token2info = dict_new2(&ptr_type);
dict_put(global->file2token2info, current_filename, global->token2info);
}
if(as3_pass==1) {
state->method = rfx_calloc(sizeof(methodstate_t));
dict_put(global->token2info, (void*)(ptroff_t)as3_tokencount, state->method);
state->method->late_binding = 1; // init scripts use getglobalscope, so we need a getlocal0/pushscope
state->method->allvars = dict_new();
} else {
state->method = dict_lookup(global->token2info, (void*)(ptroff_t)as3_tokencount);
state->method->variable_count = 0;
if(!state->method)
syntaxerror("internal error: skewed tokencount");
function_initvars(state->method, 0, 0, 0, 1);
global->init = 0;
}
}
void
set_config_defaults (dict_t *config)
{
char disc_database[256], *p;
#if defined (_BUILD_WIN32)
/* disable ASPI by default */
dict_put_flag (config, CONFIG_ENABLE_ASPI_FLAG, 0);
#endif
/* decide where disc compatibility database would be kept */
strcpy (disc_database, "./hdl_dump.list"); /* default */
#if defined (_BUILD_WIN32) && !defined (_BUILD_WINE)
p = getenv ("USERPROFILE");
if (p != NULL)
{
strcpy (disc_database, p);
strcat (disc_database, "\\Application Data\\hdl_dump.list");
}
#else
/* Unix/Linux/WineLib */
p = getenv ("HOME");
if (p != NULL)
{
strcpy (disc_database, p);
strcat (disc_database, "/.hdl_dump.list");
}
#endif
(void) dict_put (config, CONFIG_DISC_DATABASE_FILE, disc_database);
(void) dict_put (config, CONFIG_TARGET_KBPS, "2300");
(void) dict_put (config, CONFIG_AUTO_THROTTLE, "0");
}
/*
* Reads function-like macro arguments. Returns true if the argument list ends
* with "...". Otherwise false.
*/
static bool read_funclike_define_args(CppContext *ctx, Dict *param) {
for (;;) {
Token *tok = read_cpp_token(ctx);
if (is_punct(tok, ')'))
return false;
if (dict_size(param)) {
if (!is_punct(tok, ','))
error_token(tok, "',' expected, but got '%s'", token_to_string(tok));
tok = read_cpp_token(ctx);
}
if (!tok || tok->toktype == TOKTYPE_NEWLINE)
error_token(tok, "missing ')' in macro parameter list");
if (is_punct(tok, KEYWORD_THREEDOTS)) {
Token *subst = make_token(ctx, TOKTYPE_MACRO_PARAM, (TokenValue)dict_size(param));
dict_put(param, to_string("__VA_ARGS__"), subst);
Token *tok1 = read_cpp_token(ctx);
if (!is_punct(tok1, ')'))
error_token(tok1, "')' expected, but got '%s'", token_to_string(tok1));
return true;
}
if (tok->toktype != TOKTYPE_IDENT)
error_token(tok, "identifier expected, but got '%s'", token_to_string(tok));
Token *subst = make_token(ctx, TOKTYPE_MACRO_PARAM, (TokenValue)dict_size(param));
dict_put(param, tok->val.str, subst);
}
}
static void test_dict(void) {
Dict *dict = make_dict();
assert_null(dict_get(dict, "abc"));
dict_put(dict, "abc", (void *)50);
dict_put(dict, "xyz", (void *)70);
assert_int(50, (long)dict_get(dict, "abc"));
assert_int(70, (long)dict_get(dict, "xyz"));
assert_int(2, list_len(dict_keys(dict)));
}
static int add_group(Cfg *cfg, CfgGroup *grp)
{
Octstr *groupname;
Octstr *name;
List *names;
List *list;
groupname = cfg_get(grp, octstr_imm("group"));
if (groupname == NULL) {
error(0, "Group does not contain variable 'group'.");
return -1;
}
set_group_name(grp, groupname);
names = dict_keys(grp->vars);
while ((name = gwlist_extract_first(names)) != NULL) {
int a = is_allowed_in_group(groupname, name);
switch (a) {
case 0:
error(0, "Group '%s' may not contain field '%s'.",
octstr_get_cstr(groupname), octstr_get_cstr(name));
octstr_destroy(name);
octstr_destroy(groupname);
gwlist_destroy(names, octstr_destroy_item);
return -1;
break;
case -1:
error(0, "Group '%s' is no valid group identifier.",
octstr_get_cstr(groupname));
octstr_destroy(name);
octstr_destroy(groupname);
gwlist_destroy(names, octstr_destroy_item);
return -1;
break;
default:
octstr_destroy(name);
break;
}
}
gwlist_destroy(names, NULL);
if (is_single_group(groupname)) {
dict_put(cfg->single_groups, groupname, grp);
} else {
list = dict_get(cfg->multi_groups, groupname);
if (list == NULL) {
list = gwlist_create();
dict_put(cfg->multi_groups, groupname, list);
}
gwlist_append(list, grp);
}
octstr_destroy(groupname);
return 0;
}
int
ddb_update (const dict_t *config,
const char *startup,
const char *name,
compat_flags_t flags)
{
int result = RET_OK;
const char *disc_db = dict_lookup (config, CONFIG_DISC_DATABASE_FILE);
dict_t *list = dict_restore (NULL, disc_db);
if (list != NULL)
{
char tmp[500];
compat_flags_t dummy;
result = ddb_lookup (config, startup, tmp, &dummy);
if (result != RET_DDB_INCOMPATIBLE)
{ /* do not overwrite entries, marked as incompatible */
sprintf (tmp, "%s;0x%02x", name, flags);
(void) dict_put (list, startup, tmp);
result = dict_store (list, disc_db);
}
dict_free (list), list = NULL;
}
else
result = RET_NO_DISC_DB;
return (result);
}
/* Test to insert a large number of elements in the dict. */
static void test_readelements(const char *fname)
{
DICT *dict;
char buf[80];
FILE *fp;
void *val;
const char **keys;
int i;
/* initialize */
dict=dict_new();
/* read file and insert all entries */
fp=fopen(fname,"r");
assert(fp!=NULL);
while (fgets(buf,sizeof(buf),fp)!=NULL)
{
/* strip newline */
buf[strlen(buf)-1]='\0';
dict_put(dict,buf,&buf);
}
fclose(fp);
/* loop over dictionary contents */
keys=dict_keys(dict);
for (i=0;keys[i]!=NULL;i++)
{
val=dict_get(dict,keys[i]);
assert(val==buf);
}
/* free stuff */
dict_free(dict);
free(keys);
}
/*
* Parse a line in the format: <name=value name=value ...>
* and return a Dict with the name as key and the value as value,
* otherwise return NULL if a parsing error occures.
*/
static Dict *brunet_parse_body(Octstr *body)
{
Dict *param = NULL;
List *words = NULL;
long len;
Octstr *word;
words = octstr_split_words(body);
if ((len = gwlist_len(words)) > 0) {
param = dict_create(4, (void(*)(void *)) octstr_destroy);
while ((word = gwlist_extract_first(words)) != NULL) {
List *l = octstr_split(word, octstr_imm("="));
Octstr *key = gwlist_extract_first(l);
Octstr *value = gwlist_extract_first(l);
if (octstr_len(key))
dict_put(param, key, value);
octstr_destroy(key);
octstr_destroy(word);
gwlist_destroy(l, (void(*)(void *)) octstr_destroy);
}
}
gwlist_destroy(words, (void(*)(void *)) octstr_destroy);
return param;
}
void mkmap_append(MKMAP *mkmap, const char *key, const char *value)
{
DICT *dict = mkmap->dict;
if (dict_put(dict, key, value) != 0 && dict->error != 0)
msg_fatal("%s:%s: update failed", dict->type, dict->name);
}
void unknown_variable(char*name)
{
if(!state->method->unresolved_variables)
state->method->unresolved_variables = dict_new();
if(!dict_contains(state->method->unresolved_variables, name))
dict_put(state->method->unresolved_variables, name, 0);
}
static void store_function(const char*name, value_t*value)
{
ID id = rb_intern(name);
if(!global->functions) {
global->functions = dict_new(&ptr_type);
}
dict_put(global->functions, (void*)id, value);
}
/* Implementation for getting parameters to a dictionary. */
static int
dict_param_write(iparam_list * plist, const ref * pkey, const ref * pvalue)
{
int code =
dict_put(&((dict_param_list *) plist)->dict, pkey, pvalue, NULL);
return min(code, 0);
}
int main(void)
{
Dict *dict;
Octstr *foo, *bar;
unsigned long i;
gwlib_init();
foo = octstr_imm("foo");
bar = octstr_imm("bar");
debug("",0,"Dict simple test.");
dict = dict_create(10, NULL);
dict_put(dict, foo, bar);
info(0, "foo gives %s", octstr_get_cstr(dict_get(dict, foo)));
if (dict_key_count(dict) == 1)
info(0, "there is but one foo.");
else
error(0, "key count is %ld, should be 1.", dict_key_count(dict));
dict_destroy(dict);
debug("",0,"Dict extended/huge test.");
dict = dict_create(HUGE_SIZE, (void (*)(void *))octstr_destroy);
for (i = 1; i <= HUGE_SIZE; i++) {
unsigned long val;
Octstr *okey, *oval;
uuid_t id;
char key[UUID_STR_LEN + 1];
uuid_generate(id);
uuid_unparse(id, key);
val = gw_rand();
okey = octstr_create(key);
oval = octstr_format("%ld", val);
dict_put(dict, okey, oval);
}
gwthread_sleep(5); /* give hash table some time */
if (dict_key_count(dict) == HUGE_SIZE)
info(0, "ok, got %d entries in the dictionary.", HUGE_SIZE);
else
error(0, "key count is %ld, should be %d.", dict_key_count(dict), HUGE_SIZE);
dict_destroy(dict);
gwlib_shutdown();
return 0;
}
int urltrans_add_one(URLTranslationList *trans, CfgGroup *grp)
{
URLTranslation *ot;
long i;
List *list, *list2;
Octstr *alias;
ot = create_onetrans(grp);
if (ot == NULL)
return -1;
list_append(trans->list, ot);
list2 = dict_get(trans->names, ot->name);
if (list2 == NULL) {
list2 = list_create();
dict_put(trans->names, ot->name, list2);
}
list_append(list2, ot);
if (ot->keyword == NULL || ot->type == TRANSTYPE_SENDSMS)
return 0;
list = dict_get(trans->dict, ot->keyword);
if (list == NULL) {
list = list_create();
dict_put(trans->dict, ot->keyword, list);
}
list_append(list, ot);
for (i = 0; i < list_len(ot->aliases); ++i) {
alias = list_get(ot->aliases, i);
list = dict_get(trans->dict, alias);
if (list == NULL) {
list = list_create();
dict_put(trans->dict, alias, list);
}
list_append(list, ot);
}
return 0;
}
void datacache_store(datacache_t*cache, dataset_t*dataset)
{
dict_put(cache->dict, dataset->hash, dataset);
char*filename = dataset_filename(dataset->hash);
struct stat sb;
if(stat(filename, &sb)!=0) {
dataset_save(dataset, filename);
}
}
/* Simple test that adds a few key/value pairs to the dict and the does
most operations. */
static void test_simple(void)
{
DICT *dict;
void *val;
static char *value1="value1";
static char *value2="value2";
static char *replace2="replace2";
const char **keys;
int i;
/* initialize */
dict=dict_new();
/* store some entries */
dict_put(dict,"key1",value1);
dict_put(dict,"key2",value2);
dict_put(dict,"key3",dict);
dict_put(dict,"key2",replace2);
/* check dictionary contents */
val=dict_get(dict,"key1");
assert(val==value1);
val=dict_get(dict,"key2");
assert(val==replace2);
val=dict_get(dict,"key3");
assert(val==dict);
val=dict_get(dict,"key4");
assert(val==NULL);
val=dict_get(dict,"KEY1");
assert(val==NULL);
/* remove a key */
dict_put(dict,"key3",NULL);
val=dict_get(dict,"key3");
assert(val==NULL);
/* loop over dictionary contents */
keys=dict_keys(dict);
for (i=0;keys[i]!=NULL;i++)
{
val=dict_get(dict,keys[i]);
assert(((val==value1)||(val==replace2)));
}
/* free stuff */
dict_free(dict);
free(keys);
}
/* Test to insert a large number of elements in the dict. */
static void test_lotsofelements(void)
{
DICT *dict;
char buf[80];
int i,r;
void *val;
const char **keys;
/* initialize */
dict=dict_new();
/* insert a number of entries */
for (i=0;i<1024;i++)
{
r=1+(int)(10000.0*(rand()/(RAND_MAX+1.0)));
sprintf(buf,"test%04d",r);
dict_put(dict,buf,&buf);
}
/* remove a number of entries */
for (i=0;i<100;i++)
{
r=1+(int)(10000.0*(rand()/(RAND_MAX+1.0)));
sprintf(buf,"test%04d",r);
dict_put(dict,buf,NULL);
}
/* add some more entries */
for (i=0;i<1024;i++)
{
r=1+(int)(10000.0*(rand()/(RAND_MAX+1.0)));
sprintf(buf,"test%04d",r);
dict_put(dict,buf,&buf);
}
/* loop over dictionary contents */
keys=dict_keys(dict);
for (i=0;keys[i]!=NULL;i++)
{
val=dict_get(dict,keys[i]);
assert(val==buf);
}
/* free stuff */
dict_free(dict);
free(keys);
}
const char*register_string(const char*s)
{
if(!stringpool) {
stringpool = dict_new(&charptr_type);
}
char*stored_string = dict_lookup(stringpool, s);
if(!stored_string) {
stored_string = (char*)strdup(s);
dict_put(stringpool, s, stored_string);
}
return stored_string;
}
void cmap_add(char *c1, char *c2)
{
int i = dict_get(cmap, c1);
if (i >= 0) {
strcpy(cmap_dst[i], c2);
} else if (cmap_n < NCMAPS) {
strcpy(cmap_src[cmap_n], c1);
strcpy(cmap_dst[cmap_n], c2);
dict_put(cmap, cmap_src[cmap_n], cmap_n);
cmap_n++;
}
}
static void hcode_add(char *c1, char *c2)
{
int i = dict_get(hcodedict, c1);
if (i >= 0) {
strcpy(hcodedst[i], c2);
} else if (hcode_n < NHCODES) {
strcpy(hcodesrc[hcode_n], c1);
strcpy(hcodedst[hcode_n], c2);
dict_put(hcodedict, hcodesrc[hcode_n], hcode_n);
hcode_n++;
}
}
/*
* Enter a key-value pair where the key is a (constant) C string.
*/
int
dict_put_string(ref * pdref, const char *kstr, const ref * pvalue,
dict_stack_t *pds)
{
int code;
ref kname;
dict *pdict = pdref->value.pdict;
if ((code = name_ref(dict_mem(pdict),
(const byte *)kstr, strlen(kstr), &kname, 0)) < 0)
return code;
return dict_put(pdref, &kname, pvalue, pds);
}
static void proxymap_update_service(VSTREAM *client_stream)
{
int request_flags;
DICT *dict;
int dict_status;
int reply_status;
/*
* Process the request.
*
* XXX We don't close maps, so we must turn on synchronous update to ensure
* that the on-disk data is in a consistent state between updates.
*
* XXX We ignore duplicates, because the proxymap server would abort
* otherwise.
*/
if (attr_scan(client_stream, ATTR_FLAG_STRICT,
ATTR_TYPE_STR, MAIL_ATTR_TABLE, request_map,
ATTR_TYPE_INT, MAIL_ATTR_FLAGS, &request_flags,
ATTR_TYPE_STR, MAIL_ATTR_KEY, request_key,
ATTR_TYPE_STR, MAIL_ATTR_VALUE, request_value,
ATTR_TYPE_END) != 4) {
reply_status = PROXY_STAT_BAD;
} else if (proxy_writer == 0) {
msg_warn("refusing %s update request on non-%s service",
STR(request_map), MAIL_SERVICE_PROXYWRITE);
reply_status = PROXY_STAT_DENY;
} else if ((dict = proxy_map_find(STR(request_map), request_flags,
&reply_status)) == 0) {
/* void */ ;
} else {
dict->flags = ((dict->flags & ~DICT_FLAG_RQST_MASK)
| (request_flags & DICT_FLAG_RQST_MASK)
| DICT_FLAG_SYNC_UPDATE | DICT_FLAG_DUP_REPLACE);
dict_status = dict_put(dict, STR(request_key), STR(request_value));
if (dict_status == 0) {
reply_status = PROXY_STAT_OK;
} else if (dict->error == 0) {
reply_status = PROXY_STAT_NOKEY;
} else {
reply_status = PROXY_STAT_RETRY;
}
}
/*
* Respond to the client.
*/
attr_print(client_stream, ATTR_FLAG_NONE,
ATTR_TYPE_INT, MAIL_ATTR_STATUS, reply_status,
ATTR_TYPE_END);
}
void wap_map_add_user(Octstr *name, Octstr *user, Octstr *pass,
Octstr *msisdn) {
struct user_map_struct *entry;
if (user_map == NULL)
user_map = dict_create(32, wap_user_map_destroy);
entry = gw_malloc(sizeof(*entry));
entry->name = name;
entry->user = user;
entry->pass = pass;
entry->msisdn = msisdn;
dict_put(user_map, entry->user, entry);
}
static void boxc_sent_push(Boxc *conn, Msg *m)
{
Octstr *os;
char id[UUID_STR_LEN + 1];
if (conn->is_wap || !conn->sent || !m || msg_type(m) != sms)
return;
uuid_unparse(m->sms.id, id);
os = octstr_create(id);
dict_put(conn->sent, os, msg_duplicate(m));
semaphore_down(conn->pending);
octstr_destroy(os);
}
variable_t* new_variable2(methodstate_t*method, const char*name, classinfo_t*type, char init, char maybeslot)
{
if(maybeslot) {
variable_t*v = find_slot(method, name);
if(v) {
alloc_local();
return v;
}
}
NEW(variable_t, v);
v->type = type;
v->init = v->kill = init;
if(name) {
if(!method->no_variable_scoping) {
if(dict_contains(state->vars, name)) {
syntaxerror("variable %s already defined", name);
}
v->index = alloc_local();
dict_put(state->vars, name, v);
} else {
if(as3_pass==2 && dict_contains(state->method->allvars, name)) {
variable_t*v = dict_lookup(state->method->allvars, name);
if(v->type != type && (!v->type || v->type->kind!=INFOTYPE_UNRESOLVED)) {
syntaxerror("variable %s already defined.", name);
}
return v;
}
v->index = alloc_local();
}
dict_put(state->method->allvars, name, v);
} else {
v->index = alloc_local();
}
return v;
}
void smtp_sasl_auth_cache_store(SMTP_SASL_AUTH_CACHE *auth_cache,
const SMTP_SESSION *session,
const SMTP_RESP *resp)
{
char *key;
char *value;
key = smtp_sasl_auth_cache_make_key(session->host, session->sasl_username);
value = smtp_sasl_auth_cache_make_value(session->sasl_passwd,
resp->dsn, resp->str);
dict_put(auth_cache->dict, key, value);
myfree(value);
myfree(key);
}
static int
dict_copy_elements(const ref * pdrfrom /* t_dictionary */ ,
ref * pdrto /* t_dictionary */ , int options,
dict_stack_t *pds)
{
int space = r_space(pdrto);
int index;
ref elt[2];
ref *pvslot;
int code;
if (space != avm_max) {
/* Do the store check before starting the copy. */
index = dict_first(pdrfrom);
while ((index = dict_next(pdrfrom, index, elt)) >= 0)
if (!(options & COPY_NEW_ONLY) ||
dict_find(pdrto, &elt[0], &pvslot) <= 0
) {
store_check_space(space, &elt[0]);
store_check_space(space, &elt[1]);
}
}
/* Now copy the contents. */
index = dict_first(pdrfrom);
while ((index = dict_next(pdrfrom, index, elt)) >= 0) {
ref *pvalue = pv_no_defn;
if ((options & COPY_NEW_ONLY) &&
dict_find(pdrto, &elt[0], &pvslot) > 0
)
continue;
if ((options & COPY_FOR_RESIZE) &&
r_has_type(&elt[0], t_name) &&
(pvalue = elt[0].value.pname->pvalue, pv_valid(pvalue))
)
elt[0].value.pname->pvalue = pv_no_defn;
if ((code = dict_put(pdrto, &elt[0], &elt[1], pds)) < 0) {
/*
* If COPY_FOR_RESIZE is set, the dict_put isn't supposed to
* be able to fail, but we don't want to depend on this.
*/
if (pvalue != pv_no_defn)
elt[0].value.pname->pvalue = pvalue;
return code;
}
}
return 0;
}
void smpp_listener_auth_failed(SMPPServer *smpp_server, Octstr *ip) {
if (octstr_len(smpp_server->ip_blocklist_exempt_ips) && (octstr_search(smpp_server->ip_blocklist_exempt_ips, ip, 0) > -1)) {
debug("smpp.listener.auth.failed", 0, "IP address %s is exempt from the IP block list", octstr_get_cstr(ip));
return;
}
gw_rwlock_wrlock(smpp_server->ip_blocklist_lock);
SMPPBlockedIp *smpp_blocked_ip = dict_get(smpp_server->ip_blocklist, ip);
if(smpp_blocked_ip == NULL) {
smpp_blocked_ip = smpp_blocked_ip_create();
dict_put(smpp_server->ip_blocklist, ip, smpp_blocked_ip);
}
smpp_blocked_ip->attempts++;
smpp_blocked_ip->time_blocked = time(NULL);
debug("smpp.listener.auth.failed", 0, "IP address %s, attempts %ld have failed", octstr_get_cstr(ip), smpp_blocked_ip->attempts);
gw_rwlock_unlock(smpp_server->ip_blocklist_lock);
}
gfxfilterchain_t* gfxfilterchain_parse(const char*_filterexpr)
{
char*filterexpr = strdup(_filterexpr);
char*f = filterexpr;
char*end = filterexpr+strlen(filterexpr);
dict_t* params = dict_new2(&charptr_type);
char*cmd = 0;
gfxfilterchain_t*chain = 0;
gfxfilterchain_t*next = 0;
while(*f) {
char* eq = strchr(f, '=');
char* colon = strchr(f, ':');
if(!colon) {
colon = end;
}
*colon = 0;
if(eq && eq < colon) { // parameter
*eq = 0;
if(!cmd) {
fprintf(stderr, "Error: need a filter before specifying parameters (%s=%s)\n", f, eq+1);
return 0;
}
dict_put(params, f, strdup(eq+1));
} else {
if(cmd) {
add_to_chain(cmd, params, &chain, &next);
cmd = 0;
}
cmd = f;
}
if(colon == end)
break;
f = colon+1;
}
if(cmd) {
add_to_chain(cmd, params, &chain, &next);
}
free(filterexpr);
dict_destroy(params);
return chain;
}
