char *geo_lookup(GeoIP *gi, char *ipaddr, int bird) { /* * Lookup the country_code by ip address, we can * extend this in the future with more granular data * such as region,city or even zipcode. */ static char area[MAX_BUF_LENGTH]; // set the charset to UTF8 GeoIP_set_charset(gi, GEOIP_CHARSET_UTF8); switch(bird){ case COUNTRY: { const char *country= GeoIP_country_code_by_addr(gi, ipaddr); if (country==NULL){ strncpy(area, unknown_geography, MAX_BUF_LENGTH); } else { strncpy(area, country, MAX_BUF_LENGTH); } } break; case REGION:{ GeoIPRegion *gir; gir=GeoIP_region_by_addr(gi,ipaddr); if(gir == NULL || strlen(gir->region)==0){ strncpy(area, unknown_geography, MAX_BUF_LENGTH); } else { strncpy(area, gir->region, MAX_BUF_LENGTH); } if(gir != NULL) { GeoIPRegion_delete(gir); } break; } case CITY:{ GeoIPRecord *grecord; char *city; int mustFreeCity = 0; grecord = GeoIP_record_by_addr(gi, ipaddr); if (grecord !=NULL){ if (grecord->city == NULL){ strncpy(area, unknown_geography, MAX_BUF_LENGTH); } else { int len = strlen(grecord->city); city = strdup(grecord->city); mustFreeCity = 1; strncpy(area,city, MAX_BUF_LENGTH); replace_space_with_underscore(area, len); } if (mustFreeCity) { free(city); } GeoIPRecord_delete(grecord); } else { strncpy(area, unknown_geography, MAX_BUF_LENGTH); } break; } case LAT_LON: { GeoIPRecord *grecord; grecord = GeoIP_record_by_addr(gi, ipaddr); if (grecord!=NULL){ snprintf(area, MAX_BUF_LENGTH, "%f,%f", grecord->latitude, grecord->longitude); GeoIPRecord_delete(grecord); } else { strncpy(area, unknown_geography, MAX_BUF_LENGTH); } break; } case EVERYTHING: { GeoIPRecord *grecord; char *country = unknown_geography, *region = unknown_geography, *city = unknown_geography; int mustFreeCity = 0; float lat = 0.0, lon = 0.0; grecord = GeoIP_record_by_addr(gi, ipaddr); if (grecord != NULL) { if (grecord->city != NULL) { city = strdup(grecord->city); mustFreeCity = 1; } replace_space_with_underscore(city, strlen(city)); if (grecord->region != NULL) { region = grecord->region; } if (grecord->country_code != NULL) { country = grecord->country_code; } lat = grecord->latitude; lon = grecord->longitude; } snprintf(area, MAX_BUF_LENGTH, "%s|%s|%s|%f,%f", country, region, city, lat, lon); if (grecord != NULL) { GeoIPRecord_delete(grecord); } if (mustFreeCity) { free(city); } break; } default: break; } return area; }
int main (int argc, char ** argv) { //*** 2. Define AC variables AC_AUTOMATA_t * acap; AC_TEXT_t input_text = {0, 0}; #define PATTERN_NUMBER (sizeof(allpattern)/sizeof(AC_PATTERN_t)) unsigned int i; /* Sending parameter to call-back function */ struct sample_param my_param; my_param.anum = 1; my_param.achar = 'a'; /* 'a': find all, 'f': find first */ //*** 3. Get a new automata acap = ac_automata_init (match_handler); //*** 4. add patterns to automata for (i=0; i<PATTERN_NUMBER; i++) { allpattern[i].length = strlen(allpattern[i].astring); ac_automata_add (acap, &allpattern[i]); } //*** 5. Finalize automata. ac_automata_finalize (acap); //*** 5.1 Display automata //ac_automata_display (acap, 's'); /* This illustrates how to search big text chunk by chunk * in this example input buffer size is 2500 and input file is pretty * bigger than that. in fact it imitate reading from input file. * in such situations searching must be done inside a loop. the loop * continues until it consumes all input file. **/ FILE *fp; char *line; size_t len=0; int k=0; char tolower_input_line[10000]; fp = fopen(argv[1], "r"); if(fp == NULL) printf("File Couldn't Open\n"); input_line[0]='_'; tolower_input_line[0]='_'; while(getline(&line, &len, fp)!=-1) { strcpy(input_line+1, line); // printf("%s", input_line); //calling function replace_space_with_underscore() replace_space_with_underscore(input_line); *(input_line+len)='_'; k=0; strcpy(tolower_input_line+1, line); //tolower while(tolower_input_line[k]) { *(tolower_input_line+k)= tolower(tolower_input_line[k]); k++; } /*****appending original line and tolower of the same line *(input_line+strcspn(input_line, "\n"))= '/'; strcat(input_line, tolower_input_line); **********/ //calling function replace_space_with_underscore() replace_space_with_underscore(tolower_input_line); *(tolower_input_line+len)='_'; char * chunk_start = input_line; // char * end_of_file = input_line+sizeof(input_line); char * end_of_file = input_line+strlen(input_line); input_text.astring = buffer; /* Search loop */ while (chunk_start<end_of_file) { //*** 6. Set input text input_text.length = (chunk_start<end_of_file)? sizeof(buffer):(sizeof(input_line)%sizeof(buffer)); strncpy(input_text.astring, chunk_start, input_text.length); //*** 7. Do search if(ac_automata_search (acap, &input_text, (void *)(&my_param))) break; /* according to the return value of ac_automata_search() we decide to * continue or break loop. */ chunk_start += sizeof(buffer); } //*** 8. Reset ac_automata_reset(acap); //Checking multi words after tolowering the i/p. strcpy(input_line,tolower_input_line); chunk_start = input_line; end_of_file = input_line+strlen(input_line); input_text.astring = buffer; /* Search loop */ while (chunk_start<end_of_file) { //*** 6. Set input text input_text.length = (chunk_start<end_of_file)? sizeof(buffer):(sizeof(input_line)%sizeof(buffer)); strncpy(input_text.astring, chunk_start, input_text.length); //*** 7. Do search if(ac_automata_search (acap, &input_text, (void *)(&my_param))) break; /* according to the return value of ac_automata_search() we decide to * continue or break loop. */ chunk_start += sizeof(buffer); } ac_automata_reset(acap); printf(";~~~~~~~~~~\n"); } //*** 9. Release automata ac_automata_release (acap); return 0; }
int main (int argc, char ** argv) { unsigned int i; struct parameter my_param; // we use this struct to send/receive input/output parameters to/from automata my_param.position = 250; // input: end position; change it to 1000 and see what happens my_param.match_count = 0; // output: AC_TEXT_t input_text; AC_AUTOMATA_t * atm = ac_automata_init (); for (i=0; i<PATTERN_COUNT; i++) { AC_STATUS_t status; sample_patterns[i].length = strlen (sample_patterns[i].astring); status = ac_automata_add (atm, &sample_patterns[i]); switch (status) { case ACERR_DUPLICATE_PATTERN: // printf ("Add pattern failed: ACERR_DUPLICATE_PATTERN: %s\n", sample_patterns[i].astring); break; case ACERR_LONG_PATTERN: printf ("Add pattern failed: ACERR_LONG_PATTERN: %s\n", sample_patterns[i].astring); break; case ACERR_ZERO_PATTERN: printf ("Add pattern failed: ACERR_ZERO_PATTERN: %s\n", sample_patterns[i].astring); break; case ACERR_AUTOMATA_CLOSED: printf ("Add pattern failed: ACERR_AUTOMATA_CLOSED: %s\n", sample_patterns[i].astring); break; case ACERR_SUCCESS: // printf ("Pattern Added: %s\n", sample_patterns[i].astring); break; } } ac_automata_finalize (atm); // here we illustrates how to search a big text chunk by chunk. // in this example input buffer size is 64 and input file is pretty // bigger than that. we want to imitate reading from input file. // in such situations searching must be done inside a loop. the loop // continues until it consumed all input file. // printf ("Automata finalized.\n\nSearching...\n"); //Added below code by Roja FILE *fp; char *line; size_t len=0; fp = fopen(argv[1], "r"); fp1 = fopen(argv[2], "w"); if(fp == NULL || fp1 == NULL) printf("File Couldn't Open\n"); input_line[0]='_'; while(getline(&line, &len, fp)!=-1) { strcpy(input_line+1, line); // printf("%s", input_line); //calling function replace_space_with_underscore() replace_space_with_underscore(input_line); *(input_line+len)='_'; //Code added by Roja ended char * chunk_start = input_line; char * end_of_file = input_line + sizeof(input_line); input_text.astring = buffer; while (chunk_start<end_of_file) { input_text.length = (chunk_start<end_of_file)?sizeof(buffer):(sizeof(input_line)%sizeof(buffer)); strncpy (buffer, chunk_start, input_text.length); if (ac_automata_search (atm, &input_text, 0, match_handler, (void *)(&my_param))) // if the search stopped in the middle (returned 1) we should break the loop break; chunk_start += sizeof(buffer); } printf(";~~~~~~~~~~\n"); //Added by Roja fprintf(fp1, ";~~~~~~~~~~\n"); //Added by Roja } // printf ("found %d occurrence in the beginning %d bytes\n", my_param.match_count, my_param.position); // TODO: do the same search with settext/findnext interface ac_automata_release (atm); return 0; }
TEST(replace_space_with_underscore, test) { ASSERT_STREQ("a_b", replace_space_with_underscore("a b").c_str()); ASSERT_STREQ("a_b_c", replace_space_with_underscore("a b c").c_str()); }