Exemplo n.º 1
0
int is_localhost(char *address)
{
    unsigned int i_user  = ip_to_int(address);
    unsigned int i_127   = ip_to_int("127.0.0.1");

    if (i_user == i_127)
    {
        return 0;
    }
    return -1;
}
Exemplo n.º 2
0
int is_our_country(char *address, request_rec *r)
{
    int  x;
    char * read, * temp, * c_low, * c_high, *state;
    unsigned int i_user,i_low,i_high;

    i_user = ip_to_int(address);
    for(x = 0; x < num_lines; x++)
    {
        read   = apr_pstrdup(r->pool,lines[x]);
        temp   = apr_strtok(read,",",&state);
        c_low  = apr_pstrdup(r->pool,temp);
        temp   = apr_strtok(NULL,",",&state);
        c_high = apr_pstrdup(r->pool,temp);
        i_low  = ip_to_int(c_low);
        i_high = ip_to_int(c_high);

        if (i_user >= i_low && i_user <= i_high)
        {
            return 0;
        }
    }
    return -1;
}
Exemplo n.º 3
0
int is_rfc_1918(char *address)
{
    unsigned int i_user  = ip_to_int(address);
    unsigned int i_10_l  = ip_to_int("10.0.0.0");
    unsigned int i_10_h  = ip_to_int("10.255.255.255");
    unsigned int i_172_l = ip_to_int("172.16.0.0");
    unsigned int i_172_h = ip_to_int("172.31.255.255");
    unsigned int i_192_l = ip_to_int("192.168.0.0");
    unsigned int i_192_h = ip_to_int("192.168.255.255");

    if ((i_user >= i_10_l  && i_user <= i_10_h)   ||
        (i_user >= i_172_l && i_user <= i_172_h)  ||
        (i_user >= i_192_l && i_user <= i_192_h))
    {
        return 0;
    }
    return -1;
}
Exemplo n.º 4
0
IpRange* find_range_for_ip(IPDB *db, char *ip) {
  IpRange* search;
  IpRange* result;
  search = (IpRange *)malloc(sizeof(IpRange));

  if(db == NULL)
  {
    printf("ERROR: DB ist NULL! ");
    return NULL;
  }

  if(db->ranges_count == 0)
  {
    printf("ERROR: DB has no Ranges Data. Can not search!\n");
    return NULL;
  }

  search->from = ip_to_int(ip);
  search->to=0;
  search->city_index = 0;
  if(DEBUG)
    printf("Searching for: ip=%s, ipnum=%lu \n", ip, search->from);
  result = (IpRange*)bsearch(search, db->ranges, db->ranges_count, sizeof(IpRange), compare_ranges);
  if(search != NULL)
    free(search);

  if(result == NULL)
  {
    if(DEBUG)
      printf("ERROR: Could not find the IP: %s! THIS SHOULD NOT HAPPEN!\n", ip);
    return NULL;
  } else {
    if(DEBUG) {
      printf("Found Range: \t");
      print_range(result);
    }
    return (IpRange*)result;
  }
}
Exemplo n.º 5
0
MD read_pcap(std::string inFile,std::string target_ip,int quit_early, short exture_version){
	
	unsigned target = ip_to_int(target_ip.c_str());
	unsigned their_ip;
	long raw_time; 
	long n = 20000000;
	//struct top2 *bbos = (struct top2 *)malloc(n*sizeof(struct top2));
	printf("Parsing pcap file %s ... with target:: %u", inFile.c_str(),target);
	pcap_t *handle;
	char errbuf[PCAP_ERRBUF_SIZE]; //not sure what to do with this, oh well
	handle = pcap_open_offline(inFile.c_str(), errbuf);   //call pcap library function


	MD md;


	if (handle == NULL) {
		fprintf(stderr,"Couldn't open pcap file %s: %s\n", inFile.c_str(), errbuf);
		return(md);
	}
	
	
	md.tick_data.reserve(20000000);

	const u_char *packet;
	struct pcap_pkthdr header;
	unsigned int pktNum(0);

	while (packet = pcap_next(handle, &header)) {
		u_char *pktPtr = (u_char *)packet;

		

		// Parse the header, grabbing the type field.
		int ether_type = ((int)(pktPtr[12]) << 8) | (int)pktPtr[13];
		int ether_offset = 0;

		if (ether_type == ETHER_TYPE_IP) { //most common
			ether_offset = 14;
		} else {
			continue;
		}

		raw_time = header.ts.tv_sec * 1000000000 +header.ts.tv_usec*1000;


		//parse the IP header
		pktPtr += ether_offset;  //skip past the Ethernet II header
		struct ip *ipHdr = (struct ip *)pktPtr; //point to an IP header structure
		int pktLen = ntohs(ipHdr->ip_len);
		int msg_type; //used to branch a0/a1/normal md accordingly

		tick bbo;
		
		if (ipHdr->ip_p == 17) { //UDP BRO
				//TCP MESSAGE EITHER TO OR FROM OUR TARGET IP
				msg_type = processUDP(pktNum,raw_time,ipHdr,pktLen,bbo,exture_version);
				if ( msg_type >= 1){
					//bbos[pktNum] = bbo;
					md.tick_data.push_back(bbo);
				}
		}

		pktNum++; //increment number of packets seen
		if (unlikely(quit_early>0)&&(unlikely(pktNum>quit_early) || unlikely(pktNum>n)))
			break;
	}
	printf("\nParsed %u packets\n",pktNum);
	return md;
	pcap_close(handle);
}	
Exemplo n.º 6
0
int main()
{

	struct ip_addr ipaddr, netmask, gw;
	unsigned FPGA_port_number;
	char *FPGA_ip_address;
	char *FPGA_netmask;
	char *FPGA_gateway;
	unsigned integer_ip;

	unsigned int  FPGA_ip_address_a1,FPGA_ip_address_a2,FPGA_ip_address_a3,FPGA_ip_address_a4;
	unsigned int  FPGA_netmask_a1,FPGA_netmask_a2,FPGA_netmask_a3,FPGA_netmask_a4;
	unsigned int  FPGA_gateway_a1,FPGA_gateway_a2,FPGA_gateway_a3,FPGA_gateway_a4;

	//EXAMPLE: set FPGA IP and port number
	FPGA_ip_address=FPGA_IP;
	FPGA_netmask=FPGA_NM;
	FPGA_gateway=FPGA_GW;
	FPGA_port_number=FPGA_PORT;

	//extract FPGA IP address from string
	if (ip_to_int (FPGA_ip_address,&FPGA_ip_address_a1,&FPGA_ip_address_a2,&FPGA_ip_address_a3,&FPGA_ip_address_a4) == INVALID) {
		printf ("'%s' is not a valid IP address for FPGA server.\n", FPGA_ip_address);
		return 1;
	}

	//extract FPGA netmask address from string
	if (ip_to_int (FPGA_netmask,&FPGA_netmask_a1,&FPGA_netmask_a2,&FPGA_netmask_a3,&FPGA_netmask_a4) == INVALID) {
		printf ("'%s' is not a valid netmask address for FPGA server.\n", FPGA_netmask);
		return 1;
	}

	//extract FPGA gateway address from string
	if (ip_to_int (FPGA_gateway,&FPGA_gateway_a1,&FPGA_gateway_a2,&FPGA_gateway_a3,&FPGA_gateway_a4) == INVALID) {
		printf ("'%s' is not a valid gateway address for FPGA server.\n", FPGA_gateway);
		return 1;
	}

	/* the mac address of the board. this should be unique per board */
	unsigned char mac_ethernet_address[] =
	{ 0x00, 0x0a, 0x35, 0x00, 0x01, 0x02 };

	echo_netif = &server_netif;

	init_platform();
	Xil_DCacheDisable();

	/* initliaze IP addresses to be used */
	IP4_ADDR(&ipaddr,  FPGA_ip_address_a4, FPGA_ip_address_a3,   FPGA_ip_address_a2, FPGA_ip_address_a1);
	IP4_ADDR(&netmask, FPGA_netmask_a4, FPGA_netmask_a3, FPGA_netmask_a2,  FPGA_netmask_a1);
	IP4_ADDR(&gw,      FPGA_gateway_a4, FPGA_gateway_a3,   FPGA_gateway_a2,  FPGA_gateway_a1);
	print_app_header();
	print_ip_settings(&ipaddr, &netmask, &gw);
	lwip_init();



  	/* Add network interface to the netif_list, and set it as default */
	if (!xemac_add(echo_netif, &ipaddr, &netmask,&gw, mac_ethernet_address,PLATFORM_EMAC_BASEADDR)) {
		xil_printf("Error adding N/W interface\n\r");
		return -1;
	}
	netif_set_default(echo_netif);

	/* specify that the network if is up */
	netif_set_up(echo_netif);

	/* now enable interrupts */
	platform_enable_interrupts();


	/* start the application (web server, rxtest, txtest, etc..) */
	start_application();

	/* receive and process packets */
	while (1) {
		xemacif_input(echo_netif);
		transfer_data();
	}
  
	/* never reached */
	cleanup_platform();

	return 0;
}
Exemplo n.º 7
0
// read ip-ranges from csv file, of format:
// from_ip|to_ip|contype|city_code
void
read_ranges_csv(IPDB * db){
  struct timeval tim;
  double t1 = get_time(&tim);

  db->ranges = malloc(sizeof(IpRange) * db->max_ranges_count);

  if(DEBUG)
    printf("Parsing RANGES-CSV-file: %s\n", db->ranges_csv_file);
  FILE * f = fopen(db->ranges_csv_file, "rt");
  if(f == NULL)
  {
    if(DEBUG)
      printf("Could not open the CSV-file: %s", db->ranges_csv_file);
    return;
  }
  char line[256];
  char* from;
  char* to;
  char* city_code;
  int city_index;

  char* con_type;
	char* isp_name;
  uint16 isp_index;

  int invalid_cities_count = 0;

  IpRange* entry;
  db->ranges_count = 0;
  while (fgets(line, sizeof(line) ,f) && db->ranges_count < db->max_ranges_count){
    from = NULL;
    to = NULL;
    city_code = NULL;
    city_index = 0;

    con_type = NULL;
  	isp_name = NULL;
    int16 isp_index = -1;

    if(DEBUG && db->ranges_count % 1000000 == 0)
      printf("Worked lines: %i\n", db->ranges_count);

    from =      strtok(line, RANGES_DELIM);
    to =        strtok(NULL, RANGES_DELIM);
    con_type =  strtok(NULL, RANGES_DELIM);
    city_code = strtok(NULL, RANGES_DELIM);
    isp_name =  strtok(NULL, RANGES_DELIM);

    city_index = city_index_by_code(db, atoi(city_code));
    isp_index = isp_index_by_name(db, isp_name);

    if(city_index < 0)
    {
      if(DEBUG)
        printf("Could not find city for code: %i", atoi(city_code));
      invalid_cities_count ++;
      continue;
    }else{
      entry = &(db->ranges[db->ranges_count]);
      entry->from = ip_to_int(from);
      entry->to = ip_to_int(to);
      entry->is_mobile = con_type_to_int(con_type);
      entry->city_index = city_index;
      entry->isp_index = isp_index;

      db->ranges_count++;
    }
  }
  if(invalid_cities_count)
  {
    printf("Found invalid cities: %i", invalid_cities_count);
  }
  printf("\n Parsing of %i records needed %.6lf seconds\n", db->ranges_count, get_time(&tim)-t1);
}