static int parse_siit_json(cJSON *json)
{
bool global_found = false;
bool pool6_found = false;
bool eamt_found = false;
bool blacklist_found = false;
bool pool6791_found = false;
bool *globals_found;
int error;
error = send_ctrl_msg(SEC_INIT);
if (error)
return error;
globals_found = create_globals_found_array();
if (!globals_found) {
log_err("Out of memory.");
return -ENOMEM;
}
for (json = json->child; json; json = json->next) {
if (strcasecmp("global", json->string) == 0) {
check_duplicates(&global_found, "global");
error = handle_global(json, globals_found);
} else if (strcasecmp("pool6", json->string) == 0) {
check_duplicates(&pool6_found, "pool6");
error = handle_pool6(json);
} else if (strcasecmp("eamt", json->string) == 0) {
check_duplicates(&eamt_found, "eamt");
error = handle_eamt(json);
} else if (strcasecmp("blacklist", json->string) == 0) {
check_duplicates(&blacklist_found, "blacklist");
error = handle_addr4_pool(json, SEC_BLACKLIST);
} else if (strcasecmp("pool6791", json->string) == 0) {
check_duplicates(&pool6791_found, "pool6791");
error = handle_addr4_pool(json, SEC_POOL6791);
} else if (strcasecmp("file_type", json->string) == 0) {
/* No code. */
} else {
log_err("I don't know what '%s' is; Canceling.",
json->string);
error = -EINVAL;
}
if (error) {
free(globals_found);
return error;
}
}
free(globals_found);
return send_ctrl_msg(SEC_COMMIT);
}
static int parse_nat64_json(cJSON *json)
{
bool global_found = false;
bool pool6_found = false;
bool pool4_found = false;
bool bib_found = false;
bool *globals_found;
int error;
error = send_ctrl_msg(SEC_INIT);
if (error)
return error;
globals_found = create_globals_found_array();
if (!globals_found) {
log_err("Out of memory.");
return -ENOMEM;
}
for (json = json->child; json; json = json->next) {
if (strcasecmp("global", json->string) == 0) {
check_duplicates(&global_found, "global");
error = handle_global(json, globals_found);
} else if (strcasecmp("pool6", json->string) == 0) {
check_duplicates(&pool6_found, "pool6");
error = handle_pool6(json);
} else if (strcasecmp("pool4", json->string) == 0) {
check_duplicates(&pool4_found, "pool4");
error = handle_pool4(json);
} else if (strcasecmp("bib", json->string) == 0) {
check_duplicates(&bib_found, "bib");
error = handle_bib(json);
} else if (strcasecmp("file_type", json->string) == 0) {
/* No code. */
} else {
log_err("I don't know what '%s' is; Canceling.",
json->string);
error = -EINVAL;
}
if (error) {
log_info("Error: %d", error);
free(globals_found);
return error;
}
}
free(globals_found);
return send_ctrl_msg(SEC_COMMIT);
}
int
add_dir(char *path)
{
int position = 0;
int len = strlen(path);
if( check_duplicates(path) == 1 )
return 0;
// find a free position in fifo
while(position < MAX_DIRS)
{
if(dirlist[position] == 0)
{
pthread_mutex_lock(&dirlist_acc[position]);
dirlist[position] = malloc( len+1 );
if(dirlist[position] != 0)
{
strncpy(dirlist[position], path, len);
}
else
{
printf("add_dir: Could not allocate memory.\n");
return 0;
}
pthread_mutex_unlock(&dirlist_acc[position]);
break;
}
position++;
}
}
static void
check_collisions(mmv_t *mmv)
{
REPDICT *rd;
size_t rd_size;
if (mmv->nreps == 0) {
return;
}
// Remember the size of this allocation
rd_size = mmv->nreps * sizeof (REPDICT);
rd = (REPDICT *) mmv_alloc(rd_size);
init_repdict(mmv, rd);
check_duplicates(mmv, rd);
chgive(rd, rd_size);
}
environment_list* insert_table(Node* node, environment_list* env, environment_list* previous, environment_list *outter_table){
Node *aux;
Node *aux2;
table_element *temp;
table_element *nodeFunc;
switch (node->type){
case VarDecl: ;
aux=node;
while(aux!=NULL){
aux2=aux->childs;
Node *value=get_type(aux2);
while(aux2->next!=NULL){
check_duplicates(aux2,env->locals);
lower(aux2->value.s);
env->locals=insert_line(env->locals,aux2->value.s,check_type(value,env),"",_NULL_);
aux2=aux2->next;
}
aux=aux->next;
}
return env;
case FuncDecl:
case FuncDef2:
case FuncDef: ;
aux=node;
while(aux!=NULL){
if(aux->type==FuncDef)
nodeFunc=insert_func(1,aux->childs,env,outter_table);
else if(aux->type==FuncDef2)
nodeFunc=insert_funcdef2(aux->childs,env,outter_table);
else if(aux->type==FuncDecl)
nodeFunc=insert_func(0,aux->childs,env,outter_table);
if(env->locals==NULL){
env->locals=nodeFunc;
}
else if(aux->type==FuncDef2){
if(nodeFunc!=NULL){
for(temp=env->locals;temp->next!=NULL;temp=temp->next){
if(strcmp(temp->name,nodeFunc->name)==0){
temp=nodeFunc;
break;
}
}
}
}
else{
for(temp=env->locals;temp->next!=NULL;temp=temp->next);
temp->next=nodeFunc;
}
aux=aux->next;
}
return env;
case Params:
case VarParams: ;
aux=node;
while(aux!=NULL){
aux2=aux->childs;
char *flag;
if(aux->type==Params) flag="param";
else flag="varparam";
Node *value=get_type(aux2);
while(aux2->next!=NULL){
check_duplicates(aux2,env->locals);
lower(aux2->value.s);
env->number_of_arguments++;
env->locals=insert_line(env->locals,aux2->value.s,check_type(value,env),flag,_NULL_);
aux2=aux2->next;
}
aux=aux->next;
}
return env;
case IfElse: ;
//check_statements(node->childs,"if",env);
break;
case While: ;
//check_statements(node->childs,"while",env);
break;
case ValParam: ;
//check_statements(node->childs,"val-paramstr",env);
break;
case Repeat: ;
//check_statements(node->childs->next,"repeat-until",env);
break;
case Assign: ;
//check_expressions();
break;
case WriteLn: ;
//check_writeln(node);
break;
case Call: ;
check_number_of_arguments(node->childs,env);
break;
default: break;
}
if(node->childs){
env = insert_table(node->childs,env,previous,outter_table);
}
if(node->next)
env = insert_table(node->next, env,previous,outter_table);
return env;
}
//given a file extract blocks and check for duplicates
int extract_blocks(char* filename){
//printf("Processing %s \n",filename);
int fd = open(filename,O_RDONLY | O_LARGEFILE);
uint64_t off=0;
if(fd){
struct stat st;
stat(filename, &st);
total_space+=st.st_size;
//declare a block
unsigned char block_read[READSIZE];
bzero(block_read,sizeof(block_read));
//read first block from file
int aux = pread(fd,block_read,READSIZE,off);
off+= READSIZE;
//check if the file still has more blocks and if size <bzise discard
//the last incomplete block
while(aux>0){
//Process fixed size dups all sizes specified
int curr_sizes_proc=0;
while(curr_sizes_proc<nr_sizes_proc){
int size_block=sizes_proc[curr_sizes_proc];
int size_proced=0;
unsigned char *block_proc;
while(aux-size_proced>=size_block){
block_proc=malloc(size_block);
bzero(block_proc,size_block);
memcpy(block_proc,&block_read[size_proced],size_block);
//index the block and find duplicates
check_duplicates(block_proc,size_block,curr_sizes_proc);
free(block_proc);
size_proced+=size_block;
}
if(aux-size_proced > 0){
incomplete_blocks[curr_sizes_proc]++;
incomplete_space[curr_sizes_proc]+=aux-size_proced;
//process the block anyway
block_proc=malloc(aux-size_proced);
bzero(block_proc,aux-size_proced);
memcpy(block_proc,&block_read[size_proced],aux-size_proced);
//index the block and find duplicates
check_duplicates(block_proc,aux-size_proced,curr_sizes_proc);
free(block_proc);
}
curr_sizes_proc++;
}
//process rabin chunks with avg size of 1K,4K,8K,16K
//min size = avg size/2 and max size = avg size*2
//Process fixed size dups for 1K,4K,8K,16K
int curr_sizes_proc_rabin=0;
while(curr_sizes_proc_rabin<nr_sizes_proc_rabin){
rabin_polynomial_min_block_size=sizes_proc_rabin[curr_sizes_proc_rabin]/2;
rabin_polynomial_max_block_size=sizes_proc_rabin[curr_sizes_proc_rabin]*2;
rabin_polynomial_average_block_size=sizes_proc_rabin[curr_sizes_proc_rabin];
rabin_sliding_window_size=30;
struct rab_block_info *block;
if(cur_block[curr_sizes_proc_rabin] == NULL) {
//printf("Initializing rabin block %d\n",curr_sizes_proc_rabin);
cur_block[curr_sizes_proc_rabin]=init_empty_block();
}
block=cur_block[curr_sizes_proc_rabin];
int i;
for(i=0;i<aux;i++) {
char cur_byte=*((char *)(block_read+i));
char pushed_out=block->current_window_data[block->window_pos];
block->current_window_data[block->window_pos]=cur_byte;
block->cur_roll_checksum=(block->cur_roll_checksum*rabin_polynomial_prime)+cur_byte;
block->tail->polynomial=(block->tail->polynomial*rabin_polynomial_prime)+cur_byte;
block->cur_roll_checksum-=(pushed_out*polynomial_lookup_buf[rabin_sliding_window_size]);
block->window_pos++;
block->total_bytes_read++;
block->tail->length++;
if(block->window_pos == rabin_sliding_window_size) //Loop back around
block->window_pos=0;
//If we hit our special value or reached the max win size create a new block
if((block->tail->length >= rabin_polynomial_min_block_size && (block->cur_roll_checksum % rabin_polynomial_average_block_size) == rabin_polynomial_prime)|| block->tail->length == rabin_polynomial_max_block_size) {
block->tail->start=block->total_bytes_read-block->tail->length;
//insert hash in berkDB
//index the block and find duplicates
check_rabin_duplicates(cur_block[curr_sizes_proc_rabin]->tail,nr_sizes_proc+curr_sizes_proc_rabin);
//free oldblock and polinomial
//free(cur_block[curr_sizes_proc]->tail);
cur_block[curr_sizes_proc_rabin]->tail=gen_new_polynomial(NULL,0,0,0);
//if(i==READSIZE-1)
//cur_block[curr_sizes_proc_rabin]->current_poly_finished=1;
}
}
curr_sizes_proc_rabin++;
}
//free this block from memory and process another
//free(block_read);
//block_read=malloc(sizeof(unsigned char)*READSIZE);
aux = pread(fd,block_read,READSIZE,off);
off+=READSIZE;
}
//zero the blocks a new file is being processed
int auxc=0;
for(auxc=0;auxc<nr_sizes_proc_rabin;auxc++){
struct rab_block_info *lastblock;
lastblock = cur_block[auxc];
if( lastblock->tail->length > 0){
if(lastblock->tail->length < sizes_proc_rabin[auxc]/2 ){
incomplete_blocks[nr_sizes_proc+auxc]++;
incomplete_space[nr_sizes_proc+auxc]+=lastblock->tail->length;
}
//insert hash in berkDB
//index the block and find duplicates
check_rabin_duplicates(lastblock->tail,nr_sizes_proc+auxc);
}
cur_block[auxc]=NULL;
}
close(fd);
}
else{
fprintf(stderr,"error opening file %s\n",filename);
exit(1);
}
return 0;
}
int main(int argc, char** argv)
{
//Main Local Variable Declarations
char temp_id[11];
double temp_lat;
double temp_long;
struct observer *observer_start = NULL;
char temp_obsid[11];
char temp_mammal_type;
double temp_bearing;
double temp_range;
struct sighting *sighting_start = NULL;
char fileName[51];
int flag = 0;
char continueInput;
//Loop through everything if input is false
do
{
//Allows user to choose to continue or quit
printf("Welcome to the Sea Mammal Sightings Analyzer!\n");
printf("Type 'Y' to continue or 'N' to exit: \n");
scanf(" %c", &continueInput);
if(continueInput == 'Y' || continueInput == 'y')
{
//File Input. Example file: observers_3.txt sightings_3.txt
printf("Please enter the name of the observer file: ");
//Read in user input
scanf("%s", fileName);
FILE* f1 = fopen(fileName, "r");
//Error print if file problem
if(f1 == NULL)
{
perror("Error opening file");
return;
}
//Read in first line; input into dateTime structure
fscanf(f1, "%d %d %d %d %d %d", &dateTime.date, &dateTime.month,
&dateTime.year, &dateTime.hour, &dateTime.minute, &dateTime
.second);
//Read in every line that has three elements; input into observer
//structure and insert into observer linked list
while(fscanf(f1, "%4s %lf %lf", temp_id, &temp_lat, &temp_long)
== 3)
{
struct observer *new_obs = make_observer(temp_id, temp_lat,
temp_long);
insert_observer(new_obs, &observer_start);
}
fclose(f1);
//File input. Examples above
printf("\nPlease enter the name of the mammal sighting file: ");
//Read in user input
scanf("%s", fileName);
FILE* f2 = fopen(fileName, "r");
//Read in every line that has four elements; input into sightings
//structure and insert into sightings linked list
while(fscanf(f2, "%4s %c %lf %lf", temp_obsid, &temp_mammal_type,
&temp_bearing, &temp_range) == 4)
{
struct sighting *new_sighting = make_sighting(temp_obsid,
temp_mammal_type, temp_bearing, temp_range);
insert_sighting(new_sighting, &sighting_start);
//Increment sighting_count to keep track of number of sightings
sighting_count++;
}
fclose(f2);
//Print time and date
printf("%d/%d/%d %d:%d:%d\n", dateTime.date, dateTime.month,
dateTime.year, dateTime.hour, dateTime.minute,
dateTime.second);
//Commented out debugging functions
//print_observer(&observer_start);
//print_sighting(&sighting_start);
//Mission 1 - All functions (including Linked List) are in
//feature1.h
apply_mammal_locations(&observer_start, &sighting_start);
print_locations(&sighting_start);
//Loop through Feature 2 stuff if input is false
do
{
printf("Type 'Y' to continue or 'N' to exit: \n");
scanf(" %c", &continueInput);
if(continueInput == 'Y' || continueInput == 'y')
{
//Mission 2 - All functions are in feature2.h
set_true_location(&sighting_start);
print_locations_mission2(&sighting_start);
//Loop through Feature 3 stuff if input is false
do
{
printf("Type 'Y' to continue or 'N' to exit: \n");
scanf(" %c", &continueInput);
if(continueInput == 'Y' || continueInput == 'y')
{
//Mission 3 - All functions are in feature3.h
check_pod(&sighting_start);
check_duplicates(&pod_start);
print_pods(&pod_start);
//Allow user to exit program
printf("Press any key and return to exit\n");
scanf(" ", &continueInput);
printf("Thank you for using the Sea Mammal "
"Sightings Analyzer\n");
//Exit Program
return (EXIT_SUCCESS);
}
else if(continueInput == 'N' || continueInput == 'n')
{
//Exit Program
printf("Thank you for using the Sea Mammal "
"Sightings Analyzer\n");
return (EXIT_SUCCESS);
}
else
{
//Loop back to start; clear continueInput for scanf
printf("Please enter a valid character\n");
continueInput = 0;
}
//Loop forever
}while(1);
}
else if(continueInput == 'N' || continueInput == 'n')
{
//Exit Program
printf("Thank you for using the Sea Mammal Sightings "
"Analyzer\n");
return (EXIT_SUCCESS);
}
else
{
//Loop back to start; clear continueInput for scanf
printf("Please enter a valid character\n");
continueInput = 0;
}
//Loop forever
}while(1);
}
else if(continueInput == 'N' || continueInput == 'n')
{
//Exit Program
printf("Thank you for using the Sea Mammal Sightings Analyzer\n");
return (EXIT_SUCCESS);
}
else
{
//Loop back to start; clear continueInput for scanf
printf("Please enter a valid character\n");
continueInput = 0;
}
//Loop forever
}while(flag == 0);
//Exit incase above code doesn't for some reason
return (EXIT_SUCCESS);
}
//given a file extract blocks and check for duplicates
int extract_blocks(char* filename){
printf("Processing %s \n",filename);
int fd = open(filename,O_RDONLY | O_LARGEFILE);
uint64_t off=0;
if(fd){
//declare a block
unsigned char block_read[READSIZE];
bzero(block_read,sizeof(block_read));
//read first block from file
int aux = pread(fd,block_read,READSIZE,off);
off+= READSIZE;
//check if the file still has more blocks and if size <bzise discard
//the last incomplete block
while(aux>0){
//Process fixed size dups all sizes specified
int curr_sizes_proc=0;
while(curr_sizes_proc<nr_sizes_proc){
int size_block=sizes_proc[curr_sizes_proc];
int size_proced=0;
unsigned char *block_proc;
while(aux-size_proced>=size_block){
block_proc=malloc(size_block);
bzero(block_proc,size_block);
memcpy(block_proc,&block_read[size_proced],size_block);
//index the block and find duplicates
check_duplicates(block_proc,size_block,curr_sizes_proc);
free(block_proc);
size_proced+=size_block;
}
curr_sizes_proc++;
}
//free this block from memory and process another
//free(block_read);
//block_read=malloc(sizeof(unsigned char)*READSIZE);
aux = pread(fd,block_read,READSIZE,off);
off+=READSIZE;
}
close(fd);
}
else{
fprintf(stderr,"error opening file %s\n",filename);
exit(1);
}
return 0;
}