unsigned num_space_collapser_get (num_space_collapser_t *nsc, unsigned key)
{
unsigned *val;
char key_str[1024];
pthread_mutex_lock(&nsc->mutex);
sprintf(key_str, "%u", key);
if ((val = (unsigned *)hash_table_find(nsc->hash_table, key_str)))
{
printf("returning mapping %s -> %u\n", key_str, *val);
}
else
{
val = (unsigned *)malloc(sizeof(unsigned));
*val = next_value++;
printf("adding mapping %s -> %u\n", key_str, *val);
hash_table_add(nsc->hash_table, strdup(key_str), (void *)val);
}
pthread_mutex_unlock(&nsc->mutex);
return *val;
}
int symbol_table_add(Symbol_Table *table, char *name, TTR_Node *node)
{
Symbol_Entry_List *chain;
Symbol_Entry *entry;
assert(table != NULL);
assert(name != NULL);
assert(node != NULL);
chain = hash_table_lookup(table->table, name);
if (chain == NULL) {
if (init_symbol_entry_list(&chain, name))
return 1;
hash_table_add(table->table, name, chain);
}
entry = malloc(sizeof(Symbol_Entry));
if (entry == NULL)
return 1;
entry->name = strdup(name);
if (entry->name == NULL)
return 1;
entry->node = node;
entry->scope = table->scope_stack[table->sp-1];
entry->next = chain->first;
chain->first = entry;
return 0;
}
int main(int argc, const char *argv[]) {
hash_table* table = hash_table_create();
something smth;
smth.field = 2;
hash_table_add(table, "something", &smth);
something* smth2 = hash_table_get(table, "something");
printf("Asked for 'something'->field, got: %d\n", smth2->field);
char* data = "dsadsdsfdsfasfds";
hash_table_add(table, "wat", data);
char* retrieved = hash_table_get(table, "wat");
printf("Asked for 'wat', got: %s\n", retrieved);
hash_table_free(table);
return 0;
}
void handle_user_login(Bank* bank, char* args) {
char send_msg[MAX_LINE_SIZE + 1];
memset(send_msg, 0, MAX_LINE_SIZE);
if ((char*)hash_table_find(bank->user_balance_ht, args) == NULL ||
(char*)hash_table_find(bank->logged_user_ht, args) != NULL) {
strcat(send_msg, "NA");
} else {
strcat(send_msg, "OK");
hash_table_add(bank->logged_user_ht, args, "1");
}
bank_encrypt(bank, send_msg, strlen(send_msg));
bank_send(bank, send_msg, strlen(send_msg));
}
void bank_create_user(Bank* bank, char* args1, char* args2, char* args3) {
if (!args1 || !args2 || !args3) {
printf("Usage: create-user <user-name> <pin> <balance>\n");
return;
}
if (check_username(args1) != 0 || check_pin(args2) != 0
|| check_balance(args3) != 0) {
printf("Usage: create-user <user-name> <pin> <balance>\n");
return;
}
if ((char*)hash_table_find(bank->user_balance_ht, args1) != NULL) {
printf("Error: user %s already exists\n", args1);
return;
}
FILE *fp;
char card_name[MAX_CARD_NAME_SIZE + 1];
memset(card_name, 0, MAX_CARD_NAME_SIZE);
strcat(card_name, args1);
strcat(card_name, ".card");
fp = fopen(card_name, "w");
if (!fp) {
printf("Error creating card file for user %s\n", args1);
return;
}
printf("Created user %s\n", args1);
/* write to card*/
fprintf(fp, "%s\n", args1);
fprintf(fp, "%s\n", args2);
fclose(fp);
char* tmp;
tmp = (char*)malloc(64);
int len = strlen(args3);
if (len > 64) {
printf("Usage: create-user <user-name> <pin> <balance>\n");
return;
}
strncpy(tmp, args3, len);
hash_table_add(bank->user_balance_ht, args1, tmp);
}
int main()
{
hash_table_t *table = hash_table_new(MODE_VALUEREF);
int i = 1;
int val = 100;
int val2 = 200;
int j = 2;
int x =0;
for (x=0;x<300;x++)
{
// use the macro
HT_ADD(table, &j, &val);
// or use the function
//hash_table_add(table, &j, i, (void *) &val, sizeof(int));
val++;
j++;
}
hash_table_add(table, &j, i, (void *) &val2, 1);
j--; j--;
hash_table_remove(table, &j, i);
HT_REMOVE(table, &j);
if (hash_table_has_key(table, &j, i))
{
printf("Key found %d\n", j);
}
else
{
printf("Key NOT found %d\n", j);
}
val = -100;
val2 = -200;
int *value = NULL;
value = (int* ) HT_LOOKUP(table, &j);
void** keys = NULL;
size_t num = hash_table_get_keys(table, keys);
printf("found %d keys\n", (int)num);
printf("j -> %d \n", j);
if (value)
printf("value is %d\n", *value);
else
printf("*value is %p\n", value);
return 0;
}
int main() {
hash_table* h = hash_table_new();
hash_table_register_print(h, int_print);
hash_table_register_copy(h, int_copy);
hash_table_register_delete(h, int_delete);
hash_table_print(h);
char buff[3];
int ints[20];
for(int i=0; i < 20; i++) {
ints[i] = i;
sprintf(buff, "%i", i);
hash_table_add(h, buff, &(ints[i]));
}
hash_table_print(h);
hash_table_get(h, "1");
hash_table_remove(h, "1");
hash_table_print(h);
hash_table_delete(h);
return 0;
}
void bank_deposit(Bank* bank, char* name, char* amt) {
if (!name || !amt) {
printf("Usage: deposit <user-name> <amt>\n");
return;
}
if (check_username(name) || check_amt(amt)) {
printf("Usage: deposit <user-name> <amt>\n");
return;
}
if (!hash_table_find(bank->user_balance_ht, name)) {
printf("No such user\n");
return;
}
// handle name
char card_name[MAX_CARD_NAME_SIZE + 1];
memset(card_name, 0, MAX_CARD_NAME_SIZE);
strcat(card_name, name);
strcat(card_name, ".card");
// handle balance
int amount = 0;
int balance = 0;
sscanf(amt, "%d", &amount);
sscanf((char*)hash_table_find(bank->user_balance_ht, name), "%d", &balance);
if (balance + amount < 0) {
printf("Too rich for this program\n");
return;
}
balance += amount;
char* tmp;
tmp = (char*)malloc(64);
sprintf(tmp, "%d", balance);
hash_table_del(bank->user_balance_ht, name);
hash_table_add(bank->user_balance_ht, name, tmp);
printf("$%d added to %s's account\n", amount, name);
}
/**
* Function to resize the hash table store house
* @param table hash table to be resized
* @param len new length of the hash table
* @returns -1 when no elements in hash table
* @returns -2 when no emmory for new store house
* @returns 0 when sucess
*/
int _cdecl hash_table_resize(hash_table_t *table, size_t len)
{
hash_table_element_t ** elements;
hash_table_element_t ** temp;
size_t count;
int mode;
print_info("resizing hash table from %d to %d\n", table->key_num, len);
// FIXME traversing the elements twice, change it some time soon
count = hash_table_get_elements(table, &elements);
if (!count)
{
print_info("Got No Elements from the hash table\n");
return -1;
}
// keep the current store house in case we dont get more memory
temp = table->store_house;
table->store_house = (hash_table_element_t **) calloc(len, sizeof(hash_table_element_t *));
if (!table->store_house)
{
table->store_house = temp;
print_info("No Memory for new store house\n");
return -2;
}
table->key_num = len;
// fool the new hash table so if refers even previously copied values
mode = table->mode;
table->mode = MODE_ALLREF;
// the new table starts from scratch
table->key_count = 0;
while(count>0)
{
hash_table_element_t *elem = elements[--count];
hash_table_add(table, elem->key, elem->key_len, elem->value, elem->value_len);
}
table->mode = (hash_table_mode_t)mode;
// free old store house
free(temp);
return 0;
}
void handle_withdraw(Bank* bank, char* args1, char* args2) {
char* tmp;
int balance;
int amt;
char send_msg[MAX_LINE_SIZE + 1];
memset(send_msg, 0, MAX_LINE_SIZE);
tmp = (char*)hash_table_find(bank->user_balance_ht, args1);
sscanf(tmp, "%d", &balance);
sscanf(args2, "%d", &amt);
if (balance < amt) {
strcat(send_msg, "IF");
} else {
strcat(send_msg, "AD");
balance -= amt;
memset(tmp, 0, 64);
sprintf(tmp, "%d", balance);
hash_table_add(bank->user_balance_ht, args1, tmp);
}
bank_encrypt(bank, send_msg, strlen(send_msg));
bank_send(bank, send_msg, strlen(send_msg));
}
/******************************************************************
* macho_stabs_def_cb
*
* Callback for stabs_parse. Collect symbol definitions.
*/
static void macho_stabs_def_cb(struct module* module, unsigned long load_offset,
const char* name, unsigned long offset,
BOOL is_public, BOOL is_global, unsigned char sectidx,
struct symt_compiland* compiland, void* user)
{
struct macho_debug_info* mdi = user;
struct symtab_elt* ste;
TRACE("(%p, 0x%08lx, %s, 0x%08lx, %d, %d, %u, %p, %p/%p/%d)\n", module, load_offset,
debugstr_a(name), offset, is_public, is_global, sectidx,
compiland, mdi, mdi->fmap, mdi->fmap->fd);
/* Defer the creation of new non-debugging symbols until after we've
* finished parsing the stabs. */
ste = pool_alloc(&mdi->pool, sizeof(*ste));
ste->ht_elt.name = pool_strdup(&mdi->pool, name);
ste->compiland = compiland;
ste->addr = load_offset + offset;
ste->is_code = !!macho_sect_is_code(mdi->fmap, sectidx);
ste->is_public = !!is_public;
ste->is_global = !!is_global;
ste->used = 0;
hash_table_add(&mdi->ht_symtab, &ste->ht_elt);
}
static gboolean
is_read_only (const gchar *changed_element,
const gchar *changed_attribute)
{
static GHashTable *readonly_props = NULL;
static gsize readonly_props_loaded = 0;
if (g_once_init_enter (&readonly_props_loaded)) {
readonly_props = g_hash_table_new (g_str_hash,
g_str_equal);
hash_table_add (readonly_props, (gpointer) "@id");
hash_table_add (readonly_props, (gpointer) "@parentID");
hash_table_add (readonly_props, (gpointer) "@refID");
hash_table_add (readonly_props, (gpointer) "@restricted");
hash_table_add (readonly_props, (gpointer) "@searchable");
hash_table_add (readonly_props, (gpointer) "@childCount");
hash_table_add (readonly_props, (gpointer) "searchClass");
hash_table_add (readonly_props, (gpointer) "searchClass@name");
hash_table_add (readonly_props, (gpointer) "searchClass@includeDerived");
hash_table_add (readonly_props, (gpointer) "createClass");
hash_table_add (readonly_props, (gpointer) "createClass@name");
hash_table_add (readonly_props, (gpointer) "createClass@includeDerived");
hash_table_add (readonly_props, (gpointer) "writeStatus");
hash_table_add (readonly_props, (gpointer) "res@importUri");
hash_table_add (readonly_props, (gpointer) "storageTotal");
hash_table_add (readonly_props, (gpointer) "storageUsed");
hash_table_add (readonly_props, (gpointer) "storageFree");
hash_table_add (readonly_props, (gpointer) "storageMaxPartition");
hash_table_add (readonly_props, (gpointer) "storageMedium");
hash_table_add (readonly_props, (gpointer) "playbackCount");
hash_table_add (readonly_props, (gpointer) "srsRecordScheduleID");
hash_table_add (readonly_props, (gpointer) "srsRecordTaskID");
hash_table_add (readonly_props, (gpointer) "price");
hash_table_add (readonly_props, (gpointer) "price@currency");
hash_table_add (readonly_props, (gpointer) "payPerView");
hash_table_add (readonly_props, (gpointer) "dateTimeRange");
hash_table_add (readonly_props, (gpointer)
"dateTimeRange@daylightSaving");
hash_table_add (readonly_props, (gpointer) "signalStrength");
hash_table_add (readonly_props, (gpointer) "signalLocked");
hash_table_add (readonly_props, (gpointer) "tuned");
hash_table_add (readonly_props, (gpointer) "containerUpdateID");
hash_table_add (readonly_props, (gpointer) "objectUpdateID");
hash_table_add (readonly_props, (gpointer) "totalDeletedChildCount");
hash_table_add (readonly_props, (gpointer) "res@updateCount");
g_once_init_leave (&readonly_props_loaded, 1);
}
if (changed_element != NULL) {
if (changed_attribute != NULL) {
gchar *test_prop = g_strdup_printf ("%s@%s",
changed_element,
changed_attribute);
gboolean result = hash_table_contains (readonly_props,
test_prop);
g_free (test_prop);
if (result)
return TRUE;
test_prop = g_strdup_printf ("@%s", changed_attribute);
result = hash_table_contains (readonly_props,
test_prop);
g_free (test_prop);
if (result)
return TRUE;
}
return hash_table_contains (readonly_props, changed_element);
}
return FALSE;
}
static void
add_dep_prop (IndependentProperty *indep,
const gchar *name)
{
hash_table_add (indep->required_dep_props, g_strdup (name));
}
//read the mobility file and generates a hashtable of linked list with key pointing to vehicle id
hash_table_t* read_mobility_file(char mobility_file[]){
FILE *fp;
char str[128];
hash_table_t *table = hash_table_new(MODE_ALLREF);
if((fp=fopen(mobility_file, "r"))==NULL) {
printf("Cannot open file. %s\n",mobility_file);
exit(1);
}
Exnode* headRef;
node_info* Node_info=NULL;
head_node_info=Node_info;
int *keyholder[10];
int i=0;
while(!feof(fp)) {
if(fgets(str, 126, fp)) { // happy go for small mobility file :-)
char * pch;
int fmt=0;
pch = strtok (str," "); // the separator between the items in the list is a space
Exnode* node = malloc(sizeof(Exnode));
while (pch != NULL)
{ node->visit=0;
switch(fmt){
case 0:
node->time=atof(pch);
break;
case 1:
node->vid =atoi(pch);
break;
case 2:
node->x=atof(pch);
break;
case 3:
node->y=atof(pch);
break;
case 4:
node->speed=atof(pch);
break;
default:
//need a log statement here
break;
}
fmt +=1;
pch = strtok (NULL, " ");
}
node->next=NULL;
//check in the hash table if the key exist node->vid if exist ? initialize headRef
int *value = NULL;
value = (int *)HT_LOOKUP(table, &node->vid);
if (value==NULL){
if (Node_info==NULL){
Node_info=build_node_info(Node_info,node->vid,&(node->vid));
head_node_info=Node_info;
}
else{
build_node_info(Node_info,node->vid,&(node->vid));
}
keyholder[i]=&node->vid;i++;
//printf("Before to hash %p %d %lf\n",node,(node->vid),(node->time));
hash_table_add(table, &(node->vid), sizeof(node->vid), node, sizeof(&node));
//puts("NO node doesnt exist");
headRef=gen_list();
}
else{
//puts("Yes node exist");
headRef = (Exnode *)value;
//printf("After from hash %p %d\n",headRef, headRef->vid );
}
if (headRef!=NULL){
AppendNode(headRef, node);
}
}
}
fclose(fp);
return table;
}
int main(void) {
hash_table_t ht;
network_address_t addr1;
network_address_t addr2;
network_address_t addr3;
network_address_t addr4;
addr1[0] = 42;
addr1[1] = 1;
addr2[1] = 2;
addr3[1] = 3;
addr4[0] = 14;
addr4[1] = 4;
assert(network_compare_network_addresses(addr1, addr1));
ht = hash_table_create();
assert(hash_table_size(ht) == 0);
assert(hash_table_capacity(ht) == 64);
hash_table_add(ht, addr1, (void*)8);
hash_table_add(ht, addr2, (void*)16);
hash_table_add(ht, addr3, (void*)24);
assert(hash_table_contains(ht, addr1));
assert(!hash_table_contains(ht, addr4));
assert((long)hash_table_get(ht, addr2) == 16);
assert((long)hash_table_get(ht, addr3) == 24);
assert(hash_table_size(ht) == 3);
assert((long)hash_table_remove(ht, addr1) == 8);
assert(!hash_table_contains(ht, addr1));
assert(hash_table_capacity(ht) == 64);
assert(hash_table_size(ht) == 2);
assert(!hash_table_destroy(ht));
ht = hash_table_create();
assert(hash_table_size(ht) == 0);
assert(!hash_table_add(ht, addr1, (void*)8));
assert((long)hash_table_get(ht, addr2) == 0);
assert(!hash_table_add(ht, addr2, (void*)16));
assert((long)hash_table_get(ht, addr2) == 16);
assert(!hash_table_destroy(ht));
ht = hash_table_create();
hash_table_add(ht, addr4, (void*)32);
hash_table_add(ht, addr4, (void*)32);
hash_table_add(ht, addr4, (void*)32);
hash_table_add(ht, addr4, (void*)32);
assert(hash_table_size(ht) == 4);
assert(hash_table_contains(ht, addr4));
assert((long)hash_table_remove(ht, addr4) == 32);
assert((long)hash_table_remove(ht, addr1) == 0);
assert(hash_table_contains(ht, addr4));
assert(hash_table_size(ht) == 3);
assert((long)hash_table_remove(ht, addr4) == 32);
assert((long)hash_table_remove(ht, addr4) == 32);
assert((long)hash_table_remove(ht, addr4) == 32);
assert(!hash_table_contains(ht, addr4));
assert(hash_table_size(ht) == 0);
assert(!hash_table_destroy(ht));
ht = hash_table_create();
assert(hash_table_size(ht) == 0);
assert(hash_table_capacity(ht) == 64);
hash_table_add(ht, addr1, (void*)8);
hash_table_add(ht, addr2, (void*)16);
hash_table_add(ht, addr1, (void*)8);
hash_table_add(ht, addr2, (void*)16);
hash_table_add(ht, addr1, (void*)8);
hash_table_add(ht, addr2, (void*)16);
hash_table_add(ht, addr1, (void*)8);
hash_table_add(ht, addr2, (void*)16);
hash_table_add(ht, addr1, (void*)8);
assert(hash_table_contains(ht, addr2));
assert(!hash_table_contains(ht, addr4));
assert(!hash_table_get(ht, addr4));
hash_table_add(ht, addr2, (void*)16);
hash_table_add(ht, addr1, (void*)8);
hash_table_add(ht, addr2, (void*)16);
hash_table_add(ht, addr1, (void*)8);
hash_table_add(ht, addr2, (void*)16);
hash_table_add(ht, addr1, (void*)8);
hash_table_add(ht, addr2, (void*)16);
hash_table_add(ht, addr1, (void*)8);
hash_table_add(ht, addr2, (void*)16);
hash_table_add(ht, addr1, (void*)8);
hash_table_add(ht, addr2, (void*)16);
hash_table_add(ht, addr1, (void*)8);
hash_table_add(ht, addr2, (void*)16);
hash_table_add(ht, addr1, (void*)8);
hash_table_add(ht, addr2, (void*)16);
hash_table_add(ht, addr1, (void*)8);
hash_table_add(ht, addr2, (void*)16);
hash_table_add(ht, addr1, (void*)8);
hash_table_add(ht, addr2, (void*)16);
hash_table_add(ht, addr1, (void*)8);
hash_table_add(ht, addr2, (void*)16);
hash_table_add(ht, addr1, (void*)8);
hash_table_add(ht, addr2, (void*)16);
hash_table_add(ht, addr1, (void*)8);
hash_table_add(ht, addr2, (void*)16);
hash_table_add(ht, addr1, (void*)8);
hash_table_add(ht, addr2, (void*)16);
hash_table_add(ht, addr1, (void*)8);
hash_table_add(ht, addr2, (void*)16);
hash_table_add(ht, addr1, (void*)8);
hash_table_add(ht, addr2, (void*)16);
hash_table_add(ht, addr1, (void*)8);
hash_table_add(ht, addr2, (void*)16);
hash_table_add(ht, addr1, (void*)8);
hash_table_add(ht, addr2, (void*)16);
hash_table_add(ht, addr1, (void*)8);
hash_table_add(ht, addr2, (void*)16);
hash_table_add(ht, addr1, (void*)8);
hash_table_add(ht, addr2, (void*)16);
hash_table_add(ht, addr1, (void*)8);
hash_table_add(ht, addr2, (void*)16);
assert(hash_table_size(ht) == 50);
assert(hash_table_capacity(ht) == 128);
assert((long)hash_table_remove(ht, addr1) == 8);
assert((long)hash_table_remove(ht, addr2) == 16);
assert((long)hash_table_remove(ht, addr1) == 8);
assert((long)hash_table_remove(ht, addr2) == 16);
assert((long)hash_table_remove(ht, addr1) == 8);
assert((long)hash_table_remove(ht, addr2) == 16);
assert((long)hash_table_remove(ht, addr1) == 8);
assert((long)hash_table_remove(ht, addr2) == 16);
assert((long)hash_table_remove(ht, addr1) == 8);
assert((long)hash_table_remove(ht, addr2) == 16);
assert((long)hash_table_remove(ht, addr1) == 8);
assert((long)hash_table_remove(ht, addr2) == 16);
assert((long)hash_table_remove(ht, addr1) == 8);
assert((long)hash_table_remove(ht, addr2) == 16);
assert((long)hash_table_remove(ht, addr1) == 8);
assert((long)hash_table_remove(ht, addr2) == 16);
assert((long)hash_table_remove(ht, addr1) == 8);
assert((long)hash_table_remove(ht, addr2) == 16);
assert((long)hash_table_remove(ht, addr1) == 8);
assert((long)hash_table_remove(ht, addr2) == 16);
assert(hash_table_size(ht) == 30);
assert(hash_table_capacity(ht) == 64);
printf("all tests pass\n");
return 0;
}
/* Returns the route to dest or NULL on failure.
*/
miniroute_t miniroute_discover_route(network_address_t dest) {
char tmp;
struct resend_arg arg;
interrupt_level_t l;
miniroute_t path;
dcb_t control_block;
struct routing_header hdr;
//printf("entering miniroute_discover_route\n");
l = set_interrupt_level(DISABLED);
path = miniroute_cache_get(route_cache, dest);
if (path != NULL) {
//printf("got route from cache\n");
set_interrupt_level(l);
return path;
}
if (!hash_table_contains(dcb_table, dest)) {
control_block = (dcb_t)malloc(sizeof(struct discover_control_block));
if (!control_block) {
set_interrupt_level(l);
return NULL;
}
control_block->count = 0;
control_block->mutex = semaphore_create();
if (!control_block->mutex) {
free(control_block);
set_interrupt_level(l);
return NULL;
}
control_block->route_ready = semaphore_create();
if (!control_block->route_ready) {
free(control_block);
semaphore_destroy(control_block->mutex);
set_interrupt_level(l);
return NULL;
}
semaphore_initialize(control_block->mutex, 1);
semaphore_initialize(control_block->route_ready, 0);
control_block->resend_alarm = NULL;
control_block->alarm_arg = NULL;
hash_table_add(dcb_table, dest, control_block);
//printf("made a NEW discover control block\n");
}
control_block = hash_table_get(dcb_table, dest);
if (!control_block) {
//printf("ERROR: could not find discover control block\n");
set_interrupt_level(l);
return NULL;
}
control_block->count++;
set_interrupt_level(l);
semaphore_P(control_block->mutex);
path = miniroute_cache_get(route_cache, dest);
if (path) {
l = set_interrupt_level(DISABLED);
control_block->count--;
semaphore_V(control_block->mutex);
set_interrupt_level(l);
//printf("exiting miniroute_discover_route on SUCCESS\n");
return path;
}
else {
hdr.routing_packet_type = ROUTING_ROUTE_DISCOVERY;
pack_address(hdr.destination, dest);
l = set_interrupt_level(DISABLED);
pack_unsigned_int(hdr.id, curr_discovery_pkt_id++);
pack_unsigned_int(hdr.ttl, MAX_ROUTE_LENGTH);
pack_unsigned_int(hdr.path_len, 1);
pack_address(hdr.path[0], my_addr);
//make arg
arg.try_count = 0;
arg.hdr = &hdr;
arg.control_block = control_block;
control_block->alarm_arg = &arg;
//printf("sending first DISCOVERY pkt\n");
if (network_bcast_pkt(sizeof(struct routing_header), (char*)(&hdr), 0, &tmp) == -1) {
//error
control_block->count--;
semaphore_V(control_block->mutex);
set_interrupt_level(l);
return NULL;
}
control_block->resend_alarm = set_alarm(120, miniroute_resend,
control_block->alarm_arg, minithread_time());
set_interrupt_level(l);
semaphore_P(control_block->route_ready);
//got a reply pkt or timed out
path = miniroute_cache_get(route_cache, dest);
l = set_interrupt_level(DISABLED);
control_block->count--;
semaphore_V(control_block->mutex);
set_interrupt_level(l);
//printf("exiting miniroute_discover_route on SUCCESS\n");
return path;
}
}
/**
* Add the actions to the manager actions table
* @param manager Management struct to build into
*/
void action_add_to_manager( Management manager ) {
// add exit action to actions table
Action quit = new_action( action_quit );
hash_table_add( manager->actions, (void *)"quit", quit);
/* --------------------
* movement actions
*/
// north
Action north = new_action_linked( action_north, 2 );
hash_table_add( manager->actions, (void *)"north", north);
hash_table_add( manager->actions, (void *)"n", north);
// south
Action south = new_action_linked( action_south, 2 );
hash_table_add( manager->actions, (void *)"south", south);
hash_table_add( manager->actions, (void *)"s", south);
// east
Action east = new_action_linked( action_east, 2 );
hash_table_add( manager->actions, (void *)"east", east);
hash_table_add( manager->actions, (void *)"e", east);
// west
Action west = new_action_linked( action_west, 2 );
hash_table_add( manager->actions, (void *)"west", west);
hash_table_add( manager->actions, (void *)"w", west);
/* --------------------
* common actions
*/
// add look action to actions table
Action look = new_action( action_look );
hash_table_add( manager->actions, (void *)"look", look);
// add look action to actions table
Action shout = new_action( action_shout );
hash_table_add( manager->actions, (void *)"shout", shout);
}
void bank_process_local_command(Bank *bank, char *command, size_t len)
{
char *comm = (char *)calloc(MAX_COMMAND_SIZE, sizeof(char));
char *name = (char *)calloc(MAX_COMMAND_SIZE, sizeof(char));
char *misc = (char *)calloc(MAX_COMMAND_SIZE, sizeof(char));
char *misc_two = (char *)calloc(MAX_COMMAND_SIZE, sizeof(char));
char temp_comm[MAX_LINE_SIZE];
char temp_name[MAX_LINE_SIZE];
char temp_misc[MAX_LINE_SIZE];
char temp_misc_two[MAX_LINE_SIZE];
if(strlen(command) >= MAX_LINE_SIZE)
{
printf("Invalid command\n");
return;
}
sscanf(command, "%s %s %s %s", temp_comm,temp_name,temp_misc,temp_misc_two);
if(strlen(temp_comm) < 1 || strlen(temp_comm) >= MAX_COMMAND_SIZE)
{
printf("Invalid command\n");
return;
}
strncpy(comm, temp_comm, strlen(temp_comm) + 1);
if(strcmp(comm, "create-user") == 0)
{
if(strlen(temp_name) < 1 || strlen(temp_misc) < 1 || strlen(temp_misc_two) < 1 || strlen(temp_name) >= MAX_NAME_SIZE)
{
printf("Usage: create-user <user-name> <pin> <balance>\n");
return;
}
strncpy(name, temp_name, strlen(temp_name) + 1);
if(check_username(name) == 0)
{
printf("Usage: create-user <user-name> <pin> <balance>\n");
return;
}
if(hash_table_find(bank->user_bal, name) != NULL)
{
printf("%s already exists\n", name);
return;
}
if(strlen(temp_misc) != 4 || strlen(temp_misc_two) > 10)
{
printf("Usage: create-user <user-name> <pin> <balance>\n");
return;
}
strncpy(misc, temp_misc, strlen(temp_misc) + 1);
if(check_pin(misc) == 0)
{
printf("Usage: create-user <user-name> <pin> <balance>\n");
return;
}
strncpy(misc_two, temp_misc_two, strlen(temp_misc_two) + 1);
if(check_bal(misc_two) == 0)
{
printf("Usage: create-user <user-name> <pin> <balance>\n");
return;
}
// create card
int filelen = strlen(name) + 6;
char cardfile[filelen];
memset(cardfile, '\0', filelen);
strncpy(cardfile, name, strlen(name));
strncat(cardfile, ".card", 5);
FILE *card = fopen(cardfile, "w");
if(card == NULL){
printf("Error creating card file for user %s\n", name);
remove(cardfile);
return;
}
unsigned char *buff = (unsigned char *)calloc(BLOCK_SIZE+1, sizeof(char));
do_crypt(bank, (unsigned char *)misc, buff, 1);
fputs((char *)buff, card);
fclose(card);
hash_table_add(bank->user_bal, name, misc_two); //username balance
hash_table_add(bank->user_pin, name, misc); //username pin
printf("Created user %s\n", name);
return;
}
else if(strcmp(comm, "deposit") == 0)
{
if(strlen(temp_name) < 1 || strlen(temp_misc) < 1 || strlen(temp_name) >= MAX_NAME_SIZE)
{
printf("Usage: deposit <user-name> <amt>\n");
return;
}
strncpy(name, temp_name, strlen(temp_name) + 1);
if(check_username(name) != 1 || strlen(temp_misc) > 10)
{
printf("Usage: deposit <user-name> <amt>\n");
return;
}
if(hash_table_find(bank->user_bal, name) == NULL)
{
printf("No such user\n");
return;
}
strncpy(misc, temp_misc, strlen(temp_misc) + 1);
if(check_bal(misc) == 0)
{
printf("Usage: deposit <user-name> <amt>\n");
return;
}
char *ptr;
char* curr_bal = (char*) hash_table_find(bank->user_bal, name);
unsigned int curr_bal_int = (unsigned int)strtoul(curr_bal, &ptr, 10);
unsigned int amt = (unsigned int)strtoul(misc, &ptr, 10);
unsigned int new_bal = (unsigned int)amt + (unsigned int)curr_bal_int;
//checks if new_bal was capped
if( new_bal > UINT_MAX || (new_bal - amt) != curr_bal_int || new_bal < curr_bal_int){
printf("Too rich for this program\n");
return;
}
char *new_bal_char = (char *)calloc(MAX_MISC_SIZE, sizeof(char));
sprintf(new_bal_char, "%u", new_bal);
hash_table_del(bank->user_bal, name);
hash_table_add(bank->user_bal, name, new_bal_char);
printf("$%s added to %s's account\n", misc, name);
return;
}
else if(strcmp(comm, "balance") == 0)
{
if(strlen(temp_name) < 1)
{
printf("Usage: balance <user-name>\n");
return;
}
if(strlen(temp_name) >= MAX_NAME_SIZE)
{
printf("Usage: balance <user-name>\n");
return;
}
strncpy(name, temp_name, strlen(temp_name) + 1);
if(check_username(name) != 1)
{
printf("Usage: balance <user-name>\n");
return;
}
char *curr_bal = (char *) hash_table_find(bank->user_bal, name);
if(curr_bal == NULL)
{
printf("No such user\n");
return;
}
printf("$%s\n", curr_bal);
return;
}
else
{
printf("Invalid command\n");
return;
}
}
void bank_process_remote_command(Bank *bank, char *command, size_t len)
{
// ASSUME everything valid (checked in atm)
char *comm = calloc(2, sizeof(char)); // w = withdrawal, u = user exists?, b = balance, p = user pin
char *name = calloc(MAX_NAME_SIZE, sizeof(char));
char *pin = calloc(MAX_PIN_SIZE, sizeof(char));
char *amt = calloc(MAX_AMT_SIZE, sizeof(char));
unsigned char *back = (unsigned char *)calloc(10000, sizeof(unsigned char));
do_crypt(bank, (unsigned char *)command, back, 0);
sscanf((char*)back, "%s %s %s %s", comm, name, pin, amt);
free(back);
if(strcmp(comm, "u") == 0)
{
if(hash_table_find(bank->user_bal,name) == NULL)
{
send_no(bank);
return;
}
else
{
send_yes(bank);
return;
}
}
else if(strcmp(comm, "b") == 0)
{
if(hash_table_find(bank->user_bal, name) == NULL)
{
send_no_user(bank);
return;
}
char* balance = (char *)hash_table_find(bank->user_bal, name);
send_balance(bank, balance);
return;
}
else if(strcmp(comm, "p") == 0)
{
if(hash_table_find(bank->user_bal, name) == NULL)
{
send_no_user(bank);
return;
}
char* pin_from_hash = (char *) hash_table_find(bank->user_pin, name);
if(pin_from_hash == NULL)
{
send_no_pin(bank);
return;
}
if(strcmp(pin_from_hash, pin) == 0)
{
send_yes(bank);
return;
}
else
{
send_no(bank);
return;
}
}
else if(strcmp(comm, "w") == 0)
{
if(hash_table_find(bank->user_bal, name) == NULL)
{
send_no_user(bank);
return;
}
char *p;
unsigned int amt_w = (unsigned int)strtoul(amt, &p, 10);
unsigned int curr_amt = (unsigned int) strtoul((char *)hash_table_find(bank->user_bal, name), NULL, 10);
if(curr_amt < amt_w)
{
send_no_fund(bank);
return;
}
unsigned int new_amt = curr_amt - amt_w;
char *new_amt_char = calloc(MAX_AMT_SIZE, sizeof(char));
sprintf(new_amt_char, "%u", new_amt);
hash_table_del(bank->user_bal, name);
hash_table_add(bank->user_bal, name,new_amt_char);
send_yes(bank);
return;
}
}
//read the mobility file and generates a hashtable of linked list
void
parse_data (char *trace_file, int node_type)
{
FILE *fp;
char *pch, *p;
char str[128];
int fmt, id = 0, gid;
node_container *value;
//if(table==NULL)
create_new_table (node_type);
if(list_head ==NULL)
list_head = (node_info **) calloc (MAX_NUM_NODE_TYPES, sizeof (node_info*));
if (list_head == NULL ) {
LOG_E (OMG, "-------node list table creation failed--------\n");
exit (-1);
}
if ((fp = fopen (trace_file, "r")) == NULL) {
LOG_E (OMG, "[OMG]:Cannot open file %s\n", trace_file);
exit (1);
}
while (!feof (fp)) {
if (fgets (str, 126, fp)) {
fmt = 0;
p = str;
while (*p == ' ' || *p == '\t' || *p == '\r')
p++; // skip whitespaces
if (*p != '\n') { //escape empty line
pch = strtok (p, " "); // the separator between the items in the list is a space
node_data *node = (node_data *) calloc (1, sizeof (node_data));
node->type=-1;
while (pch != NULL) {
switch (fmt) {
case 0:
if (atof (pch) < 0)
LOG_E (OMG, "error: negative time input \n");
node->time = fabs (atof (pch));
LOG_D (OMG, "%.2f \n",node->time);
break;
case 1:
node->vid = atoi (pch);
LOG_D (OMG, "%d \n",node->vid);
break;
case 2:
node->x_pos = atof (pch);
LOG_D (OMG, "%.2f \n",node->x_pos);
break;
case 3:
node->y_pos = atof (pch);
LOG_D (OMG, "%.2f \n",node->y_pos);
break;
case 4:
if (atof (pch) < 0)
LOG_D (OMG, "error: negative speed input");
node->speed = fabs (atof (pch));
LOG_D (OMG, "speed %.2f \n",node->speed);
break;
/*case 5:
node->type = atof (pch);
break;*/
default:
LOG_E (OMG,
"[Error in trance file]:incorrect data format \n");
break;
}
fmt += 1;
pch = strtok (NULL, " ");
}
node->next = NULL;
node->visit = 0;
// look for node in node info
gid = find_node_info (node->vid, node_type);
if (gid == -1) {
node->gid = id;
add_node_info (node->vid, node->gid, node_type);
//store node data in the table
hash_table_add (table[node_type], node, NULL);
id++;
} else {
node->gid = gid;
value = hash_table_lookup (table[node_type], node->gid);
hash_table_add (table[node_type], node, value);
}
}
}
}
fclose (fp);
}
