void httpd_www_noproxies_msg(int fd) {
char *retval;
retval = hashtable_lookup(cfg, "http-analyzer");
if (!retval || !strcmp(retval, "off")) {
hashtable_insert(cfg, "http-analyzer", "on");
hashtable_insert(cfg, "http-admin-mode", "on");
hashtable_insert(cfg, "http-admin-url", "http://ghost/");
} else {
retval = hashtable_lookup(cfg, "http-admin-mode");
if (!retval || !strcmp(retval, "off")) {
hashtable_insert(cfg, "http-admin-mode", "on");
hashtable_insert(cfg, "http-admin-url", "http://ghost/");
}
}
httpd_msg_page(fd, "Out of Proxies!", -1, NULL,
"There are currectly no proxies or no working proxies in the database.<BR>\n \
Please click <A HREF=\"%sproxies.html\"><U>here</U></A> to access the database<BR> \n",
hashtable_lookup(cfg, "http-admin-url"));
return ;
}
void hash() {
printf(">> HASH\n");
hashtable_t hash;
test_hash_t a = { "Hello" };
test_hash_t b = { "Intrusive" };
test_hash_t c = { "World" };
hashtable_init(&hash, 10, &hash_func);
hashtable_insert(&hash, &a.node, "a", 2);
hashtable_insert(&hash, &b.node, "b", 2);
hashtable_insert(&hash, &c.node, "c", 2);
hashnode_t *ga = hashtable_search(&hash, "a", 2);
hashnode_t *gb = hashtable_search(&hash, "b", 2);
hashnode_t *gc = hashtable_search(&hash, "c", 2);
test_hash_t *aa = hashtable_ref(ga, test_hash_t, node);
test_hash_t *bb = hashtable_ref(gb, test_hash_t, node);
test_hash_t *cc = hashtable_ref(gc, test_hash_t, node);
printf("%s\n", aa->message);
printf("%s\n", bb->message);
printf("%s\n", cc->message);
}
static void add_to_set(struct hashtable* h, key* k, val* v) {
int rv;
key* new_key;
flat_key_val* new_value;
new_value = hashtable_search(h, k);
if (new_value == NULL) {
new_key = key_new(k->data, k->size);
new_value = malloc(sizeof(flat_key_val) + k->size + v->size);
assert(new_value != NULL);
rv = hashtable_insert(h, new_key, new_value);
assert(rv != 0);
} else {
if ((k->size + v->size) != (new_value->ksize + new_value->vsize)) {
new_key = key_new(k->data, k->size);
new_value = hashtable_remove(h, k);
free(new_value);
new_value = malloc(sizeof(flat_key_val) + k->size + v->size);
assert(new_value != NULL);
rv = hashtable_insert(h, new_key, new_value);
assert(rv != 0);
}
}
new_value->ksize = k->size;
new_value->vsize = v->size;
memcpy(new_value->data, k->data, k->size);
memcpy(&new_value->data[k->size], v->data, v->size);
}
static int
verify_object(struct conf *conf, struct manifest *mf, struct object *obj,
struct hashtable *stated_files, struct hashtable *hashed_files)
{
for (uint32_t i = 0; i < obj->n_file_info_indexes; i++) {
struct file_info *fi = &mf->file_infos[obj->file_info_indexes[i]];
char *path = mf->files[fi->index];
struct file_stats *st = hashtable_search(stated_files, path);
if (!st) {
struct stat file_stat;
if (x_stat(path, &file_stat) != 0) {
return 0;
}
st = x_malloc(sizeof(*st));
st->size = file_stat.st_size;
st->mtime = file_stat.st_mtime;
st->ctime = file_stat.st_ctime;
hashtable_insert(stated_files, x_strdup(path), st);
}
if (fi->size != st->size) {
return 0;
}
if (conf->sloppiness & SLOPPY_FILE_STAT_MATCHES) {
if (fi->mtime == st->mtime && fi->ctime == st->ctime) {
cc_log("mtime/ctime hit for %s", path);
continue;
} else {
cc_log("mtime/ctime miss for %s", path);
}
}
struct file_hash *actual = hashtable_search(hashed_files, path);
if (!actual) {
struct mdfour hash;
hash_start(&hash);
int result = hash_source_code_file(conf, &hash, path);
if (result & HASH_SOURCE_CODE_ERROR) {
cc_log("Failed hashing %s", path);
return 0;
}
if (result & HASH_SOURCE_CODE_FOUND_TIME) {
return 0;
}
actual = x_malloc(sizeof(*actual));
hash_result_as_bytes(&hash, actual->hash);
actual->size = hash.totalN;
hashtable_insert(hashed_files, x_strdup(path), actual);
}
if (memcmp(fi->hash, actual->hash, mf->hash_size) != 0
|| fi->size != actual->size) {
return 0;
}
}
return 1;
}
static int
blockstore_set_chain_links(struct blockstore *bs,
struct blockentry *be)
{
struct blockentry *prev;
char hashStr[80];
uint256 hash;
bool s;
hash256_calc(&be->header, sizeof be->header, &hash);
uint256_snprintf_reverse(hashStr, sizeof hashStr, &hash);
if (be->height >= 0) {
struct blockentry *li;
/*
* We've reached the junction with the current/old best chain. All the
* entries from now on need to be made orphans.
*/
Log(LGPFX" Reached block %s\n", hashStr);
li = be->next;
while (li) {
hash256_calc(&li->header, sizeof li->header, &hash);
uint256_snprintf_reverse(hashStr, sizeof hashStr, &hash);
Log(LGPFX" moving #%d %s from blk -> orphan\n", li->height, hashStr);
s = hashtable_remove(bs->hash_blk, &hash, sizeof hash);
ASSERT(s);
li->height = -1;
s = hashtable_insert(bs->hash_orphans, &hash, sizeof hash, li);
ASSERT(s);
li = li->next;
}
return be->height;
}
ASSERT(be->height == -1); // orphan
prev = blockstore_lookup(bs, &be->header.prevBlock);
ASSERT(prev);
be->height = 1 + blockstore_set_chain_links(bs, prev);
Log(LGPFX" moving #%d %s from orphan -> blk\n", be->height, hashStr);
prev->next = be;
be->prev = prev;
s = hashtable_remove(bs->hash_orphans, &hash, sizeof hash);
ASSERT(s);
s = hashtable_insert(bs->hash_blk, &hash, sizeof hash, be);
ASSERT(s);
return be->height;
}
static void
blockstore_add_entry(struct blockstore *bs,
struct blockentry *be,
const uint256 *hash)
{
bool s;
if (bs->best_chain == NULL) {
s = hashtable_insert(bs->hash_blk, hash, sizeof *hash, be);
ASSERT(s);
ASSERT(uint256_issame(hash, &bs->genesis_hash));
ASSERT(be->prev == NULL);
ASSERT(bs->height);
bs->best_chain = be;
bs->genesis = be;
bs->height = 0;
be->height = 0;
memcpy(&bs->best_hash, hash, sizeof *hash);
} else if (uint256_issame(&be->header.prevBlock, &bs->best_hash)) {
s = hashtable_insert(bs->hash_blk, hash, sizeof *hash, be);
ASSERT(s);
bs->height++;
be->height = bs->height;
bs->best_chain->next = be;
be->prev = bs->best_chain;
bs->best_chain = be;
memcpy(&bs->best_hash, hash, sizeof *hash);
} else {
char hashStr[80];
uint32 count;
be->height = -1;
count = hashtable_getnumentries(bs->hash_orphans);
uint256_snprintf_reverse(hashStr, sizeof hashStr, hash);
Log(LGPFX" block %s orphaned. %u orphan%s total.\n",
hashStr, count, count > 1 ? "s" : "");
s = hashtable_insert(bs->hash_orphans, hash, sizeof *hash, be);
ASSERT(s);
blockstore_set_best_chain(bs, be, hash);
}
}
void
pc_schema_set_dimension(PCSCHEMA *s, PCDIMENSION *d)
{
s->dims[d->position] = d;
hashtable_insert(s->namehash, d->name, d);
pc_schema_calculate_byteoffsets(s);
}
static void open_exsited_queue_db(DB_TXN *txnp, char *queue_name, qstats_t *qsp){
int ret;
char *k = strdup(queue_name);
assert(k != NULL);
queue_t *q = (queue_t *)calloc(1, sizeof(queue_t));
assert(q != NULL);
/* init hash_key and hash_value */
q->dbp = NULL;
q->set_hits = q->old_set_hits = qsp->set_hits;
q->get_hits = q->old_get_hits = qsp->get_hits;
pthread_mutex_init(&(q->lock), NULL);
ret = db_create(&(q->dbp), envp, 0);
CHECK_DB_RET(ret);
ret = q->dbp->open(q->dbp, txnp, queue_name, NULL, DB_QUEUE, DB_CREATE, 0664);
CHECK_DB_RET(ret);
int result = hashtable_insert(qlist_htp, (void *)k, (void *)q);
assert(result != 0);
return;
dberr:
fprintf(stderr, "open_exsited_queue_db: %s\n", db_strerror(ret));
exit(EXIT_FAILURE);
}
struct reformat *reopen_cache(int lotNr, size_t structsize, char file[], char subname[], int flags) {
char lotfile[PATH_MAX];
struct reformat *re;
sprintf(lotfile, "%s\x10%s\x10%d", subname, file, lotNr);
if (lots_cache == NULL) {
lots_cache = create_hashtable(3, ht_stringhash, ht_stringcmp);
if (lots_cache == NULL)
err(1, "hashtable_create(reopen_cache)");
} else {
re = hashtable_search(lots_cache, lotfile);
#ifdef DEBUG
printf("has cahce for %s:%s lot %d. pointer %p\n", subname, file, lotNr, re);
#endif
if (re != NULL)
return re;
}
#ifdef DEBUG
printf("reopen_cache: Cache miss for %s:%s lot %d\n", subname, file, lotNr);
#endif
re = reopen(lotNr, structsize, file, subname, flags);
//Runarb 11 feb 2009:
//vi må nesten cache at filen ikke fantes, for bakoverkompetabilitet. Når vi siden gjør om dette på preopning til å ikke
//reåpne etter hver crawl, må vi gjøre om
if (re == NULL) {
return NULL;
}
hashtable_insert(lots_cache, strdup(lotfile), re);
return re;
}
/* updateIndex - Updates the structure containing the index by
* inserting a new WordNode if not already in the index
* and updating the DocumentNode if word is already
* in the index.
* If word is not in the index, procedure allocates
* a new WordNode and adds to the hashtable
*
* @word: string containing the word
* @docID: identifier of the document
* @index: InvertedIndex hashtable
*
* Returns 1 if successful
* Returns 0 otherwise
*/
int updateIndex(char* word, int docID, HashTable* index)
{
//WordNode* wNode = initWNode(word, docID);
WordNode* wNode = calloc(1, sizeof(WordNode));
if (!hashtable_get(index, word, wNode)) {
assert(!hashtable_lookup(index, word));
initWNode(word, docID, wNode);
hashtable_insert(index, word, wNode);
} else {
// Word in table, so update its list of DocumentNode
assert(hashtable_lookup(index, word));
DocumentNode* dNode = NULL;
if (!list_get(wNode->page, (element_t)&docID, (element_t)&dNode)) {
// No matching document, so insert a new one
assert(dNode == NULL);
dNode = calloc(1, sizeof(DocumentNode));
dNode->document_id = docID;
dNode->page_word_frequency = 1;
list_append(wNode->page, dNode);
} else {
assert(dNode != NULL);
assert(dNode->document_id == docID);
dNode->page_word_frequency++;
}
}
return 1;
}
addEntry(struct sockaddr_storage *const addr, dnscache_entry_t **const pEtry)
{
int r;
dnscache_entry_t *etry = NULL;
DEFiRet;
/* entry still does not exist, so add it */
struct sockaddr_storage *const keybuf = malloc(sizeof(struct sockaddr_storage));
CHKmalloc(keybuf);
CHKmalloc(etry = malloc(sizeof(dnscache_entry_t)));
resolveAddr(addr, etry);
assert(etry != NULL);
memcpy(&etry->addr, addr, SALEN((struct sockaddr*) addr));
etry->nUsed = 0;
if(dnscacheEnableTTL) {
etry->validUntil = time(NULL) + dnscacheDefaultTTL;
}
memcpy(keybuf, addr, sizeof(struct sockaddr_storage));
r = hashtable_insert(dnsCache.ht, keybuf, etry);
if(r == 0) {
DBGPRINTF("dnscache: inserting element failed\n");
}
*pEtry = etry;
finalize_it:
if(iRet != RS_RET_OK) {
free(keybuf);
}
RETiRet;
}
static void update_patch_function_lookup_for_module(NativePatch* module)
{
World* world = module->world;
caValue* everyPatchedFunction = &world->nativePatchWorld->everyPatchedFunction;
caValue* targetName = &module->targetName;
// Look at every function that this module patches.
std::map<std::string, EvaluateFunc>::const_iterator it;
for (it = module->patches.begin(); it != module->patches.end(); it++) {
Value functionName;
set_string(&functionName, it->first.c_str());
// Construct a global name for this function, using the block's global name.
Value globalName;
copy(targetName, &globalName);
string_append_qualified_name(&globalName, &functionName);
// Save this line.
caValue* entry = hashtable_insert(everyPatchedFunction, &globalName);
set_list(entry, 2);
copy(&module->targetName, list_get(entry, 0));
copy(&functionName, list_get(entry, 1));
}
}
static int
txdb_add_to_hashtable(struct txdb *txdb,
const void *buf,
size_t len,
const uint256 *txHash,
const uint256 *blkHash,
uint64 timestamp,
struct tx_entry **txePtr)
{
struct tx_entry *txe;
struct buff b;
int res;
bool s;
buff_init(&b, (char *)buf, len);
txe = safe_malloc(sizeof *txe);
if (blkHash) {
memcpy(&txe->blkHash, blkHash, sizeof *blkHash);
} else {
memset(&txe->blkHash, 0, sizeof txe->blkHash);
}
txe->relevant = 0; /* for now */
txe->timestamp = timestamp; // only really useful for 'relevant' ones.
res = deserialize_tx(&b, &txe->tx);
ASSERT(res == 0);
s = hashtable_insert(txdb->hash_tx, txHash, sizeof *txHash, txe);
ASSERT(s);
*txePtr = txe;
return 0;
}
void migrate_value(Value* value, Migration* migration)
{
if (is_ref(value)) {
set_term_ref(value, migrate_term_pointer(as_term_ref(value), migration));
} else if (is_block(value)) {
set_block(value, migrate_block_pointer(as_block(value), migration));
} else if (is_list_based(value)) {
migrate_list_value(value, migration);
} else if (is_hashtable(value)) {
Value oldHashtable;
move(value, &oldHashtable);
set_hashtable(value);
Value* hashtable = value;
for (int i=0; i < hashtable_slot_count(&oldHashtable); i++) {
Value* oldKey = hashtable_key_by_index(&oldHashtable, i);
if (oldKey == NULL || is_null(oldKey))
continue;
Value* oldValue = hashtable_value_by_index(&oldHashtable, i);
Value key;
copy(oldKey, &key);
migrate_value(&key, migration);
Value* newValue = hashtable_insert(hashtable, &key);
copy(oldValue, newValue);
migrate_value(newValue, migration);
}
}
}
static inline rsRetVal
addEntry(struct sockaddr_storage *addr, dnscache_entry_t **pEtry)
{
int r;
struct sockaddr_storage *keybuf;
dnscache_entry_t *etry = NULL;
DEFiRet;
CHKmalloc(etry = MALLOC(sizeof(dnscache_entry_t)));
CHKiRet(resolveAddr(addr, etry));
memcpy(&etry->addr, addr, SALEN((struct sockaddr*) addr));
etry->nUsed = 0;
*pEtry = etry;
CHKmalloc(keybuf = malloc(sizeof(struct sockaddr_storage)));
memcpy(keybuf, addr, sizeof(struct sockaddr_storage));
pthread_rwlock_unlock(&dnsCache.rwlock); /* release read lock */
pthread_rwlock_wrlock(&dnsCache.rwlock); /* and re-aquire for writing */
r = hashtable_insert(dnsCache.ht, keybuf, *pEtry);
if(r == 0) {
DBGPRINTF("dnscache: inserting element failed\n");
}
pthread_rwlock_unlock(&dnsCache.rwlock);
pthread_rwlock_rdlock(&dnsCache.rwlock); /* we need this again */
finalize_it:
if(iRet != RS_RET_OK && etry != NULL) {
/* Note: sub-fields cannot be populated in this case */
free(etry);
}
RETiRet;
}
static int pagetable_post(pagetable *pages, int posttype, char *path, postitem *pi)
{
/* wserror(ws, MESSAGE, "Adding a path to server: %s\n", path); */
webpage_table_item toinsert = {0};
toinsert.postitem_type = posttype;
toinsert.key = path;
toinsert.value = *pi;
toinsert.mime = NULL;
/* if it is a file, then i should auto-determine the mime here, if it is a buffer,
then it will be assumed that it is text/plain */
/* if(posttype == POSTITEM_BUFFER) { */
/* toinsert.mime = mime_lookup("txt"); */
/* } else if(posttype == POSTITEM_FILE) { */
/* toinsert.mime = mime_auto(pi->file_path); */
/* /\* printf("determined that the mime for %s was %s\n", pi->file_path, toinsert.mime); *\/ */
/* } */
toinsert.mime = "text/plain";
if(pagetable_find(pages, path) != NULL) {
/* wserror(ws, MESSAGE, "webshare: collission detected on %s, already present in share?\n", path); */
return -1;
}
return hashtable_insert((hashtable*)pages, &toinsert) == NULL ? -1 : 0;
}
void dllhashtable_insert(struct DLLHASHTABLE* dllhashtable_ptr,
void* key, void* value)
{
struct DLL* dll_ptr;
struct HASHTABLE* hashtable_ptr;
struct DLLHASHTABLE_DLLITEM* dllitem_ptr;
struct DLLHASHTABLE_HASHTABLEVALUE* hashtablevalue_ptr;
struct HASHITEM* hashitem_ptr;
dll_ptr = dllhashtable_ptr->dll_ptr;
hashtable_ptr = dllhashtable_ptr->hashtable_ptr;
hashtablevalue_ptr = (struct DLLHASHTABLE_HASHTABLEVALUE*)
malloc(sizeof(struct DLLHASHTABLE_HASHTABLEVALUE));
hashtablevalue_ptr->value = value;
hashtablevalue_ptr->dllitem_ptr = NULL;
hashtablevalue_ptr->delvaluefunc =
dllhashtable_ptr->hashtable_delvaluefunc;
hashitem_ptr = hashtable_insert(hashtable_ptr, key,
hashtablevalue_ptr);
// printf("hashitem_ptr = %p\n", hashitem_ptr);
// printf("hashtablevalue_ptr = %p\n", hashtablevalue_ptr);
dllitem_ptr = (struct DLLHASHTABLE_DLLITEM*)
dll_insert(dll_ptr, hashitem_ptr);
// printf("dllitem_ptr = %p\n", dllitem_ptr);
hashtablevalue_ptr->dllitem_ptr = dllitem_ptr;
}
hashtable_rc_t hashtable_resize(hash_table_t * const hashtblP, const hash_size_t sizeP)
{
hash_table_t newtbl;
hash_size_t n;
hash_node_t *node,*next;
if (hashtblP == NULL) {
return HASH_TABLE_BAD_PARAMETER_HASHTABLE;
}
newtbl.size = sizeP;
newtbl.hashfunc = hashtblP->hashfunc;
if(!(newtbl.nodes=calloc(sizeP, sizeof(hash_node_t*)))) return -1;
for(n=0; n<hashtblP->size; ++n) {
for(node=hashtblP->nodes[n]; node; node=next) {
next = node->next;
hashtable_insert(&newtbl, node->key, node->data);
// Lionel GAUTHIER: BAD CODE TO BE REWRITTEN
hashtable_remove(hashtblP, node->key);
}
}
free(hashtblP->nodes);
hashtblP->size=newtbl.size;
hashtblP->nodes=newtbl.nodes;
return HASH_TABLE_OK;
}
sp_image *osfy_image_create(sp_session *session, const byte image_id[20]) {
sp_image *image;
image = (sp_image *)hashtable_find(session->hashtable_images, image_id);
if(image) {
{
char buf[41];
hex_bytes_to_ascii(image->id, buf, 20);
DSFYDEBUG("Returning existing image '%s'\n", buf);
}
return image;
}
image = malloc(sizeof(sp_image));
memcpy(image->id, image_id, sizeof(image->id));
image->format = SP_IMAGE_FORMAT_UNKNOWN;
image->data = NULL;
image->error = SP_ERROR_RESOURCE_NOT_LOADED;
image->callback = NULL;
image->userdata = NULL;
image->is_loaded = 0;
image->ref_count = 0;
image->hashtable = session->hashtable_images;
hashtable_insert(image->hashtable, image->id, image);
return image;
}
static int
annotate_hash_table(BoxNode *n,HashTable *h,uint32_t *box)
{
PixelList *p;
PixelHashData *d=(PixelHashData *)hashtable_get_user_data(h);
Pixel q;
if (n->l&&n->r) {
return annotate_hash_table(n->l,h,box) && annotate_hash_table(n->r,h,box);
}
if (n->l||n->r) {
#ifndef NO_OUTPUT
printf ("box tree is dead\n");
#endif
return 0;
}
for (p=n->head[0];p;p=p->next[0]) {
PIXEL_UNSCALE(&(p->p),&q,d->scale);
if (!hashtable_insert(h,q,*box)) {
#ifndef NO_OUTPUT
printf ("hashtable insert failed\n");
#endif
return 0;
}
}
if (n->head[0]) (*box)++;
return 1;
}
void parse_libextractor_output(struct hashtable *dst, const char *output, char **whitelist) {
char **lines;
int n_lines = split(output, "\n", &lines);
char key[MAX_ATTRIB_LEN];
char val[MAX_ATTRIB_LEN];
printf("parse_libextractor_output: n_lines %i\n",n_lines);
int i, j;
for (i = 0; i < n_lines; i++) {
char *line = lines[i];
char *remain = strchr(line, '-');
const char *ret;
if (remain == NULL)
continue;
int keylen = remain - line;
remain += 2; // skip '- '
keylen = keylen > MAX_ATTRIB_LEN ? MAX_ATTRIB_LEN : keylen;
strlcpy(key, line, keylen);
strlcpy(val, remain, sizeof val);
if ((ret=in_list(key, whitelist)) == NULL) {
//warnx("ignoring attr %s - %s\n", key, val);
continue;
}
hashtable_insert(dst, strdup(ret), strdup(val));
//warnx("inserted attr %s - %s\n", key, val);
}
FreeSplitList(lines);
printf("parse_libextractor_output: done\n");
}
void set_mount_status(char *p,char *val) {
if (util_starts_with(p,NETWORK_SHARE)) {
p += strlen(NETWORK_SHARE);
}
char *current = hashtable_search(mount_points,p);
if (current == NULL) {
HTML_LOG(0,"Adding mount point [%s] = %s",p,val);
hashtable_insert(mount_points,STRDUP(p),val);
} else if ( STRCMP(current,val) != 0) {
hashtable_remove(mount_points,p,1);
HTML_LOG(0,"mount point [%s] status changed from [%s] to [%s]",p,current,val);
hashtable_insert(mount_points,STRDUP(p),val);
}
}
int ribs_queue_waitpid(pid_t pid) {
uint32_t loc = hashtable_lookup(&ht_pid_to_ctx, &pid, sizeof(pid));
if (loc)
return LOGGER_ERROR("pid is already in signal to ctx table"), -1;
hashtable_insert(&ht_pid_to_ctx, &pid, sizeof(pid), ¤t_ctx, sizeof(current_ctx));
return 0;
}
void set_symbol_from_string(caValue* val, caValue* str)
{
// Find this name as an existing builtin symbol.
int foundBuiltin = builtin_symbol_from_string(as_cstring(str));
if (foundBuiltin != -1) {
set_symbol(val, foundBuiltin);
return;
}
// Find this name as an existing runtime symbol.
caValue* foundRuntime = hashtable_get(g_runtimeSymbolMap, str);
if (foundRuntime != NULL) {
copy(foundRuntime, val);
return;
}
// Create a new runtime symbol.
caValue* newRuntime = hashtable_insert(g_runtimeSymbolMap, str);
int index = g_nextRuntimeSymbol++;
set_symbol(newRuntime, index);
set_symbol(val, index);
list_resize(g_runtimeSymbolTable, index+1);
set_value(list_get(g_runtimeSymbolTable, index), str);
}
Variable* Mote::getVariable(char* name) {
char* typeStr = "";
int isArray;
Variable* var;
var = (Variable*)hashtable_search(varTable, name);
if (var == NULL) {
// Could hash this for greater efficiency,
// but that would either require transformation
// in Tossim class or a more complex typemap.
if (app != NULL) {
for (int i = 0; i < app->numVariables; i++) {
if(strcmp(name, app->variableNames[i]) == 0) {
typeStr = app->variableTypes[i];
isArray = app->variableArray[i];
break;
}
}
}
// printf("Getting variable %s of type %s %s\n", name, typeStr, isArray? "[]" : "");
var = new Variable(name, typeStr, isArray, nodeID);
hashtable_insert(varTable, name, var);
}
return var;
}
void list_names_that_must_be_looped(Block* contents, Value* names)
{
// Find all names within 'contents' that must be looped. A name must be looped when
// a term inside the loop binds a name that was already used outside the loop.
Value namesMap;
set_hashtable(&namesMap);
for (BlockIteratorFlat it(contents); it; ++it) {
Term* term = it.current();
if (has_empty_name(term))
continue;
Value termVal;
termVal.set_term(contents->owningTerm);
Term* outsideName = find_name_at(&termVal, term_name(term));
// Don't look at names outside the major block.
if (outsideName != NULL && !is_under_same_major_block(term, outsideName))
outsideName = NULL;
if (outsideName != NULL)
set_bool(hashtable_insert(&namesMap, term_name(term)), true);
}
hashtable_get_keys(&namesMap, names);
list_sort(names, NULL, NULL);
}
//-----------------------------------------------------------------------------
mme_sgw_tunnel_t *
sgw_lite_cm_create_s11_tunnel (
Teid_t remote_teid,
Teid_t local_teid)
//-----------------------------------------------------------------------------
{
mme_sgw_tunnel_t *new_tunnel;
new_tunnel = malloc (sizeof (mme_sgw_tunnel_t));
if (new_tunnel == NULL) {
/*
* Malloc failed, may be ENOMEM error
*/
SPGW_APP_ERROR ("Failed to create tunnel for remote_teid %u\n", remote_teid);
return NULL;
}
new_tunnel->remote_teid = remote_teid;
new_tunnel->local_teid = local_teid;
/*
* Trying to insert the new tunnel into the tree.
* * * * If collision_p is not NULL (0), it means tunnel is already present.
*/
hashtable_insert (sgw_app.s11teid2mme_hashtable, local_teid, new_tunnel);
return new_tunnel;
}
int mysql_pool_get(struct mysql_login_info *info, struct mysql_pool_entry **mysql) {
if (0 > make_ht_key(&misc, info))
return -1;
char *ht_key = vmbuf_data(&misc);
size_t key_len = vmbuf_wlocpos(&misc);
uint32_t ofs = hashtable_lookup(&ht_idle_connections, ht_key, key_len);
if (0 == ofs) {
struct list *l = (struct list *)calloc(1, sizeof(struct list));
list_init(l);
ofs = hashtable_insert(&ht_idle_connections,
ht_key, key_len,
&l, sizeof(struct list *));
if (0 == ofs) // unable to insert
return -1;
// add one element since we know there isn't any
if (0 > create_entry(l))
return -1;
// get first free element
if (0 > get_free_entry(info, l, mysql))
return -1;
}
struct list *l = *(struct list **)hashtable_get_val(&ht_idle_connections, ofs);
if (list_empty(l)) {
LOGGER_INFO("adding one more entry in the list");
if (0 > create_entry(l))
return -1;
}
if (0 > get_free_entry(info, l, mysql))
return -1;
return 0;
}
static void on_accept(int fd, short ev, void *arg) {
int rv, *k;
tcp_client* c;
unsigned int addr_len;
is_socket_init = 1;
c = tcp_client_new();
k = malloc(sizeof(int));
*k = c->id;
rv = hashtable_insert(clients, k, c);
addr_len = sizeof(c->addr);
c->fd = accept(fd, (struct sockaddr*)&c->addr, &addr_len);
if (c->fd < 0) {
// TODO free client
return;
}
setnonblock(c->fd); // TODO check return value
c->buffer_ev = bufferevent_socket_new(tapioca_get_event_base(), c->fd,
BEV_OPT_CLOSE_ON_FREE);
bufferevent_setcb(c->buffer_ev, on_read, on_write, on_error, c);
bufferevent_enable(c->buffer_ev, EV_READ);
c->write_count = 0;
}
static int gtpv1u_create_s1u_tunnel(Gtpv1uCreateTunnelReq *create_tunnel_reqP)
{
/* Create a new nw-gtpv1-u stack req using API */
NwGtpv1uUlpApiT stack_req;
NwGtpv1uRcT rc;
/* Local tunnel end-point identifier */
uint32_t s1u_teid = 0;
gtpv1u_teid2enb_info_t *gtpv1u_teid2enb_info = NULL;
MessageDef *message_p = NULL;
hashtable_rc_t hash_rc;
GTPU_DEBUG("Rx GTPV1U_CREATE_TUNNEL_REQ Context %d\n", create_tunnel_reqP->context_teid);
memset(&stack_req, 0, sizeof(NwGtpv1uUlpApiT));
stack_req.apiType = NW_GTPV1U_ULP_API_CREATE_TUNNEL_ENDPOINT;
do {
s1u_teid = gtpv1u_new_teid();
GTPU_DEBUG("gtpv1u_create_s1u_tunnel() %u\n", s1u_teid);
stack_req.apiInfo.createTunnelEndPointInfo.teid = s1u_teid;
stack_req.apiInfo.createTunnelEndPointInfo.hUlpSession = 0;
stack_req.apiInfo.createTunnelEndPointInfo.hStackSession = 0;
rc = nwGtpv1uProcessUlpReq(gtpv1u_sgw_data.gtpv1u_stack, &stack_req);
GTPU_DEBUG(".\n");
} while (rc != NW_GTPV1U_OK);
gtpv1u_teid2enb_info = malloc (sizeof(gtpv1u_teid2enb_info_t));
memset(gtpv1u_teid2enb_info, 0, sizeof(gtpv1u_teid2enb_info_t));
gtpv1u_teid2enb_info->state = BEARER_IN_CONFIG;
//#warning !!! hack because missing modify session request, so force enb address
// gtpv1u_teid2enb_info->enb_ip_addr.pdn_type = IPv4;
// gtpv1u_teid2enb_info->enb_ip_addr.address.ipv4_address[0] = 192;
// gtpv1u_teid2enb_info->enb_ip_addr.address.ipv4_address[1] = 168;
// gtpv1u_teid2enb_info->enb_ip_addr.address.ipv4_address[2] = 1;
// gtpv1u_teid2enb_info->enb_ip_addr.address.ipv4_address[3] = 2;
message_p = itti_alloc_new_message(TASK_GTPV1_U, GTPV1U_CREATE_TUNNEL_RESP);
message_p->ittiMsg.gtpv1uCreateTunnelResp.S1u_teid = s1u_teid;
message_p->ittiMsg.gtpv1uCreateTunnelResp.context_teid = create_tunnel_reqP->context_teid;
message_p->ittiMsg.gtpv1uCreateTunnelResp.eps_bearer_id = create_tunnel_reqP->eps_bearer_id;
hash_rc = hashtable_is_key_exists(gtpv1u_sgw_data.S1U_mapping, s1u_teid);
if (hash_rc == HASH_TABLE_KEY_NOT_EXISTS) {
hash_rc = hashtable_insert(gtpv1u_sgw_data.S1U_mapping, s1u_teid, gtpv1u_teid2enb_info);
message_p->ittiMsg.gtpv1uCreateTunnelResp.status = 0;
} else {
message_p->ittiMsg.gtpv1uCreateTunnelResp.status = 0xFF;
}
GTPU_DEBUG("Tx GTPV1U_CREATE_TUNNEL_RESP Context %u teid %u eps bearer id %u status %d\n",
message_p->ittiMsg.gtpv1uCreateTunnelResp.context_teid,
message_p->ittiMsg.gtpv1uCreateTunnelResp.S1u_teid,
message_p->ittiMsg.gtpv1uCreateTunnelResp.eps_bearer_id,
message_p->ittiMsg.gtpv1uCreateTunnelResp.status);
return itti_send_msg_to_task(TASK_SPGW_APP, INSTANCE_DEFAULT, message_p);
}
