void guess_word(void *arg, out_p out, unsigned char *word) { int index; /* Current position in word */ index = 1; /* Skip the initial blank */ do { index = find_rule(arg, out, word, index, lang->rules(word[index])); } while (word[index] != '\0'); }
// return NULL if error (such as path limit reached) NsRule *find_or_create_rule(void) { struct task_struct *real_parent; // look for an exiting active namespace entry in the list NsRule *ptr = find_rule(current->nsproxy); if (ptr) return ptr; // find the sandbox task real_parent = get_sandbox(); // reuse an inactive entry ptr = head.next; while (ptr) { if (ptr->active == 0) break; ptr = ptr->next; } if (ptr) { // found an inactive entry int i; // clean unix path for (i = 0; i < MAX_UNIX_PATH; i++) { ptr->unix_path_len[i] = 0; if (ptr->unix_path[i]) { char *tmp = ptr->unix_path[i]; ptr->unix_path[i] = NULL; kfree(tmp); } } // set the rule ptr->nsproxy = current->nsproxy; ptr->sandbox_pid = real_parent->pid; ptr->active = 1; printk(KERN_INFO "firejail[%u]: setup sandbox.\n", ptr->sandbox_pid); return ptr; } // allocate a new rule ptr = kmalloc(sizeof(NsRule), GFP_KERNEL); memset(ptr, 0, sizeof(NsRule)); ptr->nsproxy = current->nsproxy; ptr->sandbox_pid = real_parent->pid; // insert the new rule in the rule list ptr->next = head.next; head.next = ptr; ptr->active = 1; printk(KERN_INFO "firejail[%u]: setup sandbox.\n", ptr->sandbox_pid); return ptr; }
void dmk_word(char *word) { int index; /* Current position in word */ int type; /* First letter of match part */ index = 1; /* Skip the initial blank */ do { if (isupper((int)word[index])) type = word[index] - 'A' + 1; else type = 0; index = find_rule(word, index, Rules[type]); } while (word[index] != '\0'); }
void G_parser::find_rule(vector<int>& seq_t){ //cout << "reached 1" << endl; //cout << "seq_t: " << seq_t[2] << " & " << seq_t[3] << endl; // if (previous (in left_str) is rootpitch) { search for its terminal equivalents; } //if IV in previous context (instead of iv) then lookup corresponding chords (IV = iv*, iv6*, iv7*) OR (IV = iv*) //what about IV instead of iv later? (what if already translated as iv from IV?) --> e.g. "IV I_3" ->... // if context not found, look for equivalent rootpitch // perhaps categorise IV as iv|iv6|iv7 bool rule_found = false; bool opt; rule r; int cont_size; vector<int> leftmost_t; //find (if) timed_rule //search existing_times for (int i=0; i<existing_times.size(); i++){//replace with while() //cout << "reached 2" << endl; if (seq_t[2]==existing_times[i][0] && seq_t[3]==existing_times[i][1]){//seq_t[2,3] for beat, bar.. //cout << "reached 3" << endl; //check context (match rule with current context) for (int j=0; j<timed_rules[{seq_t[2], seq_t[3]}].size(); j++){ //cout << "reached 4" << endl; //check_context(seq_t); //i6 could map to I etc. if context not found ? cont_size = timed_rules[{seq_t[2], seq_t[3]}][j].left_str.size(); leftmost_t = timed_rules[{seq_t[2], seq_t[3]}][j].leftmost_time; opt = timed_rules[{seq_t[2], seq_t[3]}][j].is_optional; vector<string> curr_cont = get_context(leftmost_t, cont_size); if (timed_rules[{seq_t[2], seq_t[3]}][j].is_optional){//timed and optional rule r = timed_rules[{seq_t[2], seq_t[3]}][j]; rule_found = check_optional(r, seq_t); if (rule_found) break; } else {//timed, but not optional //cout << "reached 11" << endl; if (curr_cont == timed_rules[{seq_t[2], seq_t[3]}][j].left_str){ //cout << "reached 12" << endl; rule_found = true; //expand to support optional too r = timed_rules[{seq_t[2], seq_t[3]}][j]; the_rule = r; //debug cout << "the_rule: "; for (int j=0; j<the_rule.left_str.size(); j++) cout << the_rule.left_str[j] << ", "; cout << endl; rewrite(r, seq_t); cout << "case 2" << endl;//timed, but not optional break; } } } break; } } //else find general_rule if(!rule_found) {//replace with while() //search general_rules (context again) for (int i=0; i<general_rules.size(); i++){ //check if context exists before or after current chord (elem) int c_off = - general_rules[i].left_str.size();//context offset (back n forth) cont_size = general_rules[i].left_str.size(); //leftmost_t = general_rules[i].leftmost_time;//is {0, 0} opt = general_rules[i].is_optional; //need to access specific general_rule for (int z = c_off; z < 0; z++){ general_rules[i].leftmost_time[1] = seq_t[3] + (z+1) / harm_rh; vector<string> curr_cont = get_context(general_rules[i].leftmost_time, cont_size); //check context if(general_rule[i].is_optional) if (opt){ r = general_rules[i]; rule_found = check_optional(r, seq_t); if (rule_found) break; } //check context if (!general_rule[i].is_optional) else if(get_context(general_rules[i].leftmost_time, cont_size) == general_rules[i].left_str){ rule_found = true; r = general_rules[i]; the_rule = r; //debug cout << "the_rule: "; for (int j=0; j<the_rule.left_str.size(); j++) cout << the_rule.left_str[j] << ", "; cout << endl; rewrite(r, seq_t); cout << "case 5" << endl;//general and not optional break; } } if (rule_found) break; } } cout << "is_terminal?: " << curr_cycle[seq_t[3]].name << endl << endl; //stop if terminal if (!is_terminal(seq_t)) find_rule(seq_t); //else return_terminal(curr_cycle[seq_t[3]].name); else translate_to_midi();//translate / spit out (return_terminal()) }
int main() { FILE *source; int state; char line[100], current_text[100]; char *current, *store; pmstate rule; mtoken first_token; pmtoken current_token; mmacro first_macro; pmmacro current_macro; pmdefine current_define; int tokenclass; source = fopen( "test.S", "r" ); if (source) { state = RST; current_text[0] = '\0'; store = current_text; current_token = &first_token; current_token->next = NULL; current_macro = &first_macro; current_macro->next = NULL; while (!feof(source)) { fgets( line, 100, source ); current = line; while (*current != '\0') { tokenclass = get_token_class( *current ); rule = find_rule( state, tokenclass ); if (rule!=NULL) { if ((rule->current != rule->next)) { if (!((rule->next ==SOPCODE_ARGS_ENDSTRING)&&(rule->current==SOPCODE_ARGS_STRING))) { /* Print what was scanned and what rule it falls under */ *store = '\0'; if (remotely_interesting[state]) { /* printf("[%s] %s\n", state_names[state], current_text );*/ /* Add it on to the list of tokens */ current_token->next = malloc( sizeof( mtoken )); current_token->next->previous = current_token; current_token = current_token->next; current_token->next = NULL; current_token->state = state; strcpy( current_token->text, current_text ); } store = current_text; *store = '\0'; } state = rule->next; } /* else printf("%s -> %s %c\n", state_names[rule->current], state_names[rule->next], *current );*/ *store = *current; store++; } else printf("%s -> ??? \'%c\' %s\n", state_names[state], *current, line ); current++; } } add_macros( first_token.next, &first_macro ); /* Print out the token list */ current_token = first_token.next; print_token_chain( first_token.next, &first_macro, NULL ); current_macro = first_macro.next; printf("\nDefined macros:\n"); while (current_macro) { printf(" [%s]", current_macro->name ); current_define = current_macro->args; while (current_define) { printf(" %s", current_define->find); current_define = current_define->next; } printf("\n"); current_macro = current_macro->next; } return 0; } return -1; };
int main(int argc, char **argv) { int overwrite; int interactive; int remove; int have_colors; struct Colors colors, colors_tmp; struct Cell_stats statf; int have_stats = 0; struct FPRange range; DCELL min, max; char *name, *mapset; char *style, *cmap, *cmapset; char *rules; int fp; struct GModule *module; struct { struct Flag *r, *w, *l, *g, *a, *e, *i, *q, *n; } flag; struct { struct Option *map, *colr, *rast, *rules; } opt; G_gisinit(argv[0]); module = G_define_module(); module->keywords = _("raster, color table"); module->description = _("Creates/modifies the color table associated with a raster map layer."); opt.map = G_define_standard_option(G_OPT_R_MAP); opt.map->required = NO; opt.map->guisection = _("Required"); scan_rules(); opt.colr = G_define_option(); opt.colr->key = "color"; opt.colr->key_desc = "style"; opt.colr->type = TYPE_STRING; opt.colr->required = NO; opt.colr->options = rules_list(); opt.colr->description = _("Type of color table"); opt.colr->descriptions = rules_descriptions(); opt.colr->guisection = _("Colors"); opt.rast = G_define_option(); opt.rast->key = "raster"; opt.rast->type = TYPE_STRING; opt.rast->required = NO; opt.rast->gisprompt = "old,cell,raster"; opt.rast->description = _("Raster map name from which to copy color table"); opt.rules = G_define_standard_option(G_OPT_F_INPUT); opt.rules->key = "rules"; opt.rules->required = NO; opt.rules->description = _("Path to rules file (\"-\" to read rules from stdin)"); opt.rules->guisection = _("Colors"); flag.r = G_define_flag(); flag.r->key = 'r'; flag.r->description = _("Remove existing color table"); flag.w = G_define_flag(); flag.w->key = 'w'; flag.w->description = _("Only write new color table if one doesn't already exist"); flag.l = G_define_flag(); flag.l->key = 'l'; flag.l->description = _("List available rules then exit"); flag.n = G_define_flag(); flag.n->key = 'n'; flag.n->description = _("Invert colors"); flag.n->guisection = _("Colors"); flag.g = G_define_flag(); flag.g->key = 'g'; flag.g->description = _("Logarithmic scaling"); flag.g->guisection = _("Colors"); flag.a = G_define_flag(); flag.a->key = 'a'; flag.a->description = _("Logarithmic-absolute scaling"); flag.a->guisection = _("Colors"); flag.e = G_define_flag(); flag.e->key = 'e'; flag.e->description = _("Histogram equalization"); flag.e->guisection = _("Colors"); flag.i = G_define_flag(); flag.i->key = 'i'; flag.i->description = _("Enter rules interactively"); /* please, remove before GRASS 7 released */ flag.q = G_define_flag(); flag.q->key = 'q'; flag.q->description = _("Run quietly"); if (G_parser(argc, argv)) exit(EXIT_FAILURE); /* please, remove before GRASS 7 released */ if (flag.q->answer) { G_putenv("GRASS_VERBOSE", "0"); G_warning(_("The '-q' flag is superseded and will be removed " "in future. Please use '--quiet' instead.")); } if (flag.l->answer) { list_rules(); return EXIT_SUCCESS; } overwrite = !flag.w->answer; interactive = flag.i->answer; remove = flag.r->answer; name = opt.map->answer; style = opt.colr->answer; cmap = opt.rast->answer; rules = opt.rules->answer; if (!name) G_fatal_error(_("No raster map specified")); if (!cmap && !style && !rules && !interactive && !remove) G_fatal_error(_("One of \"-i\" or \"-r\" or options \"color\", \"rast\" or \"rules\" must be specified!")); if (interactive && (style || rules || cmap)) G_fatal_error(_("Interactive mode is incompatible with \"color\", \"rules\", and \"raster\" options")); if ((style && (cmap || rules)) || (cmap && rules)) { if ((style && rules && !cmap) && strcmp(style, "rules") == 0) style = NULL; else G_fatal_error( _("\"color\", \"rules\", and \"raster\" options are mutually exclusive")); } /* handle rules="-" (from stdin) by translating that to colors=rules */ /* this method should not be ported to GRASS 7 verbatim, as color=rules DNE */ if (rules && strcmp(rules, "-") == 0) { style = G_store("rules"); rules = NULL; } if (flag.g->answer && flag.a->answer) G_fatal_error(_("-g and -a flags are mutually exclusive")); mapset = G_find_cell2(name, ""); if (mapset == NULL) G_fatal_error(_("Raster map <%s> not found"), name); if (remove) { int stat = G_remove_colors(name, mapset); if (stat < 0) G_fatal_error(_("Unable to remove color table of raster map <%s>"), name); if (stat == 0) G_warning(_("Color table of raster map <%s> not found"), name); return EXIT_SUCCESS; } G_suppress_warnings(1); have_colors = G_read_colors(name, mapset, &colors); /*if (have_colors >= 0) G_free_colors(&colors); */ if (have_colors > 0 && !overwrite) { G_warning(_("Color table exists. Exiting.")); exit(EXIT_FAILURE); } G_suppress_warnings(0); fp = G_raster_map_is_fp(name, mapset); G_read_fp_range(name, mapset, &range); G_get_fp_range_min_max(&range, &min, &max); if (interactive) { if (!read_color_rules(stdin, &colors, min, max, fp)) exit(EXIT_FAILURE); } else if (style) { /* * here the predefined color-table color-styles are created by GRASS library calls. */ if (strcmp(style, "random") == 0) { if (fp) G_fatal_error(_("Color table 'random' is not supported for floating point raster map")); G_make_random_colors(&colors, (CELL) min, (CELL) max); } else if (strcmp(style, "grey.eq") == 0) { if (fp) G_fatal_error(_("Color table 'grey.eq' is not supported for floating point raster map")); if (!have_stats) have_stats = get_stats(name, mapset, &statf); G_make_histogram_eq_colors(&colors, &statf); } else if (strcmp(style, "grey.log") == 0) { if (fp) G_fatal_error(_("Color table 'grey.log' is not supported for floating point raster map")); if (!have_stats) have_stats = get_stats(name, mapset, &statf); G_make_histogram_log_colors(&colors, &statf, (CELL) min, (CELL) max); } else if (strcmp(style, "rules") == 0) { if (!read_color_rules(stdin, &colors, min, max, fp)) exit(EXIT_FAILURE); } else if (find_rule(style)) G_make_fp_colors(&colors, style, min, max); else G_fatal_error(_("Unknown color request '%s'"), style); } else if (rules) { if (!G_load_fp_colors(&colors, rules, min, max)) { /* for backwards compatibility try as std name; remove for GRASS 7 */ char path[GPATH_MAX]; /* don't bother with native dirsep as not needed for backwards compatibility */ sprintf(path, "%s/etc/colors/%s", G_gisbase(), rules); if (!G_load_fp_colors(&colors, path, min, max)) G_fatal_error(_("Unable to load rules file <%s>"), rules); } } else { /* use color from another map (cmap) */ cmapset = G_find_cell2(cmap, ""); if (cmapset == NULL) G_fatal_error(_("Raster map <%s> not found"), cmap); if (G_read_colors(cmap, cmapset, &colors) < 0) G_fatal_error(_("Unable to read color table for raster map <%s>"), cmap); } if (fp) G_mark_colors_as_fp(&colors); if (flag.n->answer) G_invert_colors(&colors); if (flag.e->answer) { if (fp) { struct FP_stats fpstats; get_fp_stats(name, mapset, &fpstats, min, max, flag.g->answer, flag.a->answer); G_histogram_eq_colors_fp(&colors_tmp, &colors, &fpstats); } else { if (!have_stats) have_stats = get_stats(name, mapset, &statf); G_histogram_eq_colors(&colors_tmp, &colors, &statf); } colors = colors_tmp; } if (flag.g->answer) { G_log_colors(&colors_tmp, &colors, 100); colors = colors_tmp; } if (flag.a->answer) { G_abs_log_colors(&colors_tmp, &colors, 100); colors = colors_tmp; } if (fp) G_mark_colors_as_fp(&colors); if (G_write_colors(name, mapset, &colors) >= 0) G_message(_("Color table for raster map <%s> set to '%s'"), name, interactive ? "rules" : style ? style : rules ? rules : cmap); exit(EXIT_SUCCESS); }
void callback(u_char *useless,const struct pcap_pkthdr* pkthdr,const u_char* packet){ //static int count = 1; //printf("\nep1s: Packet number [%d], length of this packet is: %d\n", count++, pkthdr->len); struct ether_hdr *ethernet; ethernet = (struct ether_hdr *)packet; if(ntohs(ethernet->ethertype) == ETHERTYPE_ARP){ //printf("Ethertype = %u\n", (unsigned int)ntohs(ethernet->ethertype)); struct arp_hdr *arp; arp = (struct arp_hdr *)ethernet->data; if(memcmp(ep1_mac_addr, arp->sender_mac, ETHER_ADDR_LEN) == 0){ memcpy(ethernet->dst_mac, ethernet->src_mac, ETHER_ADDR_LEN); memcpy(ethernet->src_mac, ep1s_mac_addr, ETHER_ADDR_LEN); memcpy(arp->receiver_mac, arp->sender_mac, ETHER_ADDR_LEN); memcpy(arp->sender_mac, ep1s_mac_addr, ETHER_ADDR_LEN); uint32_t temp; memcpy(&temp, arp->srcip, sizeof(uint32_t)); memcpy(arp->srcip, arp->dstip, sizeof(uint32_t)); memcpy(arp->dstip, &temp, sizeof(uint32_t)); uint16_t temp_oper = htons(2); memcpy(arp->oper, &temp_oper, sizeof(uint16_t)); if(pcap_sendpacket(ep1s_descr, (u_char *)ethernet, pkthdr->len) != 0) printf("Could't send ARP response\n"); else printf("Sent ARP response\n"); } } else if(ntohs(ethernet->ethertype) == ETHERTYPE_IP){ enum PROTOCOL protocol; enum ACTION result = 0; struct ip_hdr *ip; ip = (struct ip_hdr *)ethernet->data; if(ip->protocol == IPPROTO_ICMP){ protocol = ICMP; //No need to modify the icmp packet /*Modifying the ipv4 header Change srcip to ipaddress of wlan0 Recalculate checksum */ uint16_t ipchecksum = 0x0000; struct in_addr tmpip; inet_aton(wlan_ipaddr, &tmpip); ip->srcip = tmpip; memcpy(ip->checksum, &ipchecksum, sizeof(uint16_t)); ipchecksum = ip_checksum(ip, sizeof(ip_hdr_t)); memcpy(ip->checksum, &ipchecksum, sizeof(uint16_t)); /*Modify the ethernet header src_mac is the mac address of wlan0 dst_mac is the mac address of the gateway */ memcpy(ethernet->src_mac, wlan_mac_addr, ETHER_ADDR_LEN); memcpy(ethernet->dst_mac, gateway_mac_addr, ETHER_ADDR_LEN); struct findrule_hdr *find = (struct findrule_hdr *)malloc(sizeof(struct findrule_hdr)); find->protocol = protocol; find->srcip = ntohl(ip->srcip.s_addr); find->dstip = ntohl(ip->dstip.s_addr); find->srcport = 0; find->dstport = 0; result = find_rule(find); free(find); if(result == BLOCK){ printf("Blocked packet.\n"); return; } if(pcap_sendpacket(wlan_descr, (u_char *)ethernet, pkthdr->len) != 0) printf("Couldn't send ICMP packet to physical interface\n"); else printf("Sent ICMP packet to physical interface\n"); } else if(ip->protocol == IPPROTO_TCP){ protocol = TCP; struct tcp_hdr *tcp; tcp = (struct tcp_hdr *)ip->options_and_data; /*Perform NAT on the port numbers Get a random number in the range 50000 to 65535 and if it is already mapped to a port, reroll. This is the outgoing portnumber on the physical interface */ uint16_t natport = ntohs(tcp->srcport); tcpnat[natport].used = 1; /*Modifying the TCP header Set checksum to 0. Change sourceport to the natport. Recompute the checksum. */ uint16_t tcpchecksum = 0x0000; uint16_t blankify = 0x0000; memcpy(&tcpchecksum, tcp->checksum, 16); memcpy(tcp->checksum, &blankify, sizeof(uint16_t)); //Modifying the IP header uint16_t ipchecksum = 0x0000; struct in_addr tmpip; inet_aton(wlan_ipaddr, &tmpip); ip->srcip = tmpip; memcpy(ip->checksum, &ipchecksum, sizeof(uint16_t)); ipchecksum = ip_checksum(ip, sizeof(ip_hdr_t)); memcpy(ip->checksum, &ipchecksum, sizeof(uint16_t)); /*uint16_t totlen; memcpy(&totlen, ip->total_len, sizeof(uint16_t)); totlen = ntohs(totlen); uint16_t tcpoptlen = tcp->offset_rsvd&0x00f0; tcpoptlen = tcpoptlen>>4; tcpoptlen = tcpoptlen * 4 - 20; printf("Offset = %u\n", tcpoptlen); uint16_t iphl = ip->version_ihl&0x000f; iphl *= 4; uint16_t tcpdatalen = totlen - (tcpoptlen + 20) - iphl; uint16_t pseudotcplen = sizeof(struct tcp_hdr) + sizeof(struct pseudo_hdr) + tcpdatalen;*/ /*Create pseudoheader Compute TCP checksum*/ uint16_t iphl = ip->version_ihl&0x000f; iphl *= 4; uint16_t totlen; memcpy(&totlen, ip->total_len, sizeof(uint16_t)); totlen = ntohs(totlen); uint16_t tcplen = totlen - iphl; if(tcplen % 2 == 1) tcplen++; //tcplen = htons(tcplen); struct pseudo_hdr *pseudo = (struct pseudo_hdr *)calloc(1, sizeof(struct pseudo_hdr) + (tcplen - sizeof(struct tcp_hdr))); tcplen = htons(tcplen); //struct pseudo_hdr *pseudo = (struct pseudo_hdr *)malloc(pseudotcplen); if(pseudo == NULL){ printf("Couldn't malloc\n"); exit(1); } //Copying data into the pseudo header pseudo->srcip = ip->srcip; pseudo->dstip = ip->dstip; pseudo->zeroes = 0x00; pseudo->protocol = IPPROTO_TCP; //pseudo->tcplen = htons(sizeof(struct tcp_hdr) + tcpoptlen + tcpdatalen); pseudo->tcplen = tcplen; memcpy(&(pseudo->srcport), &(tcp->srcport), ntohs(pseudo->tcplen)); //Calculate TCP Checksum tcpchecksum = 0x0000; tcpchecksum = ip_checksum(pseudo, 4*3 + ntohs(tcplen)); //tcpchecksum = ip_checksum(pseudo, pseudotcplen); memcpy(tcp->checksum, &tcpchecksum, sizeof(uint16_t)); free(pseudo); //Modifying the Ethernet header memcpy(ethernet->src_mac, wlan_mac_addr, ETHER_ADDR_LEN); memcpy(ethernet->dst_mac, gateway_mac_addr, ETHER_ADDR_LEN); struct findrule_hdr *find = (struct findrule_hdr *)malloc(sizeof(struct findrule_hdr)); find->protocol = protocol; find->srcip = ntohl(ip->srcip.s_addr); find->dstip = ntohl(ip->dstip.s_addr); find->srcport = ntohs(tcp->srcport); find->dstport = ntohs(tcp->dstport); result = find_rule(find); free(find); if(result == BLOCK){ printf("Blocked packet.\n"); return; } if(pcap_sendpacket(wlan_descr, (u_char *)ethernet, pkthdr->len) != 0) printf("Couldn't send TCP packet to physical interface\n"); else printf("Sent TCP packet to physical interface\n"); } else if(ip->protocol == IPPROTO_UDP){ protocol = UDP; struct udp_hdr *udp; udp = (struct udp_hdr *)ip->options_and_data; uint16_t srcport, dstport; memcpy(&srcport, udp->srcport, sizeof(uint16_t)); memcpy(&dstport, udp->dstport, sizeof(uint16_t)); printf("Source port = %u\nDestination port = %u\n", ntohs(srcport), ntohs(dstport)); /*Perform NAT on the port numbers Get a random number in the range 50000 to 65535 and if it is already mapped to a port, reroll. This is the outgoing portnumber on the physical interface */ uint16_t natport = ntohs(srcport); tcpnat[natport].used = 1; uint16_t udpchecksump = 0x0000; memcpy(udp->checksum, &udpchecksump, sizeof(uint16_t)); //Modifying the IP header uint16_t ipchecksum = 0x0000; struct in_addr tmpip; inet_aton(wlan_ipaddr, &tmpip); ip->srcip = tmpip; memcpy(ip->checksum, &ipchecksum, sizeof(uint16_t)); ipchecksum = ip_checksum(ip, sizeof(ip_hdr_t)); memcpy(ip->checksum, &ipchecksum, sizeof(uint16_t)); /*Modify the ethernet header src_mac is the mac address of wlan0 dst_mac is the mac address of the gateway */ memcpy(ethernet->src_mac, wlan_mac_addr, ETHER_ADDR_LEN); memcpy(ethernet->dst_mac, gateway_mac_addr, ETHER_ADDR_LEN); struct findrule_hdr *find = (struct findrule_hdr *)malloc(sizeof(struct findrule_hdr)); find->protocol = protocol; find->srcip = ntohl(ip->srcip.s_addr); find->dstip = ntohl(ip->dstip.s_addr); find->srcport = ntohs(srcport); find->dstport = ntohs(dstport); result = find_rule(find); free(find); if(result == BLOCK){ printf("Blocked packet.\n"); return; } if(pcap_sendpacket(wlan_descr, (u_char *)ethernet, pkthdr->len) != 0) printf("Couldn't send UDP packet to physical interface\n"); else printf("Sent UDP packet to physical interface\n"); } } }