int main( void ) { HWADDR hwaddr; if( gethwaddr( IFNAME, hwaddr ) == -1 ) { fprintf( stderr, "Failed to get MAC address of %s\n", IFNAME ); return 1; } printf("MAC address of %s = %02x:%02x:%02x:%02x:%02x:%02x\n", IFNAME, hwaddr[ 0 ], hwaddr[ 1 ], hwaddr[ 2 ], hwaddr[ 3 ], hwaddr[ 4 ], hwaddr[ 5 ]); return 0; }
void config_BSP(void) { #if defined(CONFIG_UCBOOTSTRAP) unsigned char *p; printk("Arcturus Networks Inc. uC5471DSP uCbootstrap system calls\n"); printk(" Serial number: [%s]\n", getserialnum()); p = gethwaddr(0); if (p == NULL) { memcpy (fec_hwaddr, "\0x00\0xde\0xad\0xbe\0xef\0x27", 6); p = fec_hwaddr; printk ("Warning: HWADDR0 not set in uCbootloader. Using default.\n"); } else { memcpy (fec_hwaddr, p, 6); } printk("uCbootstrap eth addr 0 %02x:%02x:%02x:%02x:%02x:%02x\n", p[0], p[1], p[2], p[3], p[4], p[5]); #endif }
signed openchannel (struct channel * channel) { #if defined (__linux__) struct ifreq ifreq; struct sockaddr_ll sockaddr_ll = { PF_PACKET, 0x0000, 0x0000, ARPHRD_ETHER, PACKET_HOST, ETHER_ADDR_LEN, { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } }; /* * raw packets require root privileges on linux; one does not have to be * root when this program is installed setuid using 'chown root:root' and * 'chmod 4555'; */ if (geteuid ()) { error (1, EPERM, ERROR_NOTROOT); } memset (&ifreq, 0, sizeof (ifreq)); sockaddr_ll.sll_protocol = htons (channel->type); if ((channel->fd = socket (sockaddr_ll.sll_family, SOCK_RAW, sockaddr_ll.sll_protocol)) == -1) { error (1, errno, "%s", channel->ifname); } memcpy (ifreq.ifr_name, channel->ifname, sizeof (ifreq.ifr_name)); if (ioctl (channel->fd, SIOCGIFINDEX, &ifreq) == -1) { error (1, errno, "%s", ifreq.ifr_name); } channel->ifindex = sockaddr_ll.sll_ifindex = ifreq.ifr_ifindex; if (ioctl (channel->fd, SIOCGIFHWADDR, &ifreq) == -1) { error (1, errno, "%s", ifreq.ifr_name); } memcpy (sockaddr_ll.sll_addr, ifreq.ifr_ifru.ifru_hwaddr.sa_data, sizeof (sockaddr_ll.sll_addr)); if (bind (channel->fd, (struct sockaddr *) (&sockaddr_ll), sizeof (sockaddr_ll)) == -1) { error (1, errno, "%s", ifreq.ifr_name); } memcpy (channel->host, sockaddr_ll.sll_addr, sizeof (channel->host)); if (ioctl (channel->fd, SIOCGIFFLAGS, &ifreq) == -1) { error (1, errno, "%s", ifreq.ifr_name); } channel->ifstate = ifreq.ifr_flags; _setbits (ifreq.ifr_flags, (IFF_UP | IFF_BROADCAST | IFF_MULTICAST)); _clrbits (ifreq.ifr_flags, (IFF_ALLMULTI | IFF_PROMISC)); if (ioctl (channel->fd, SIOCSIFFLAGS, &ifreq) == -1) { error (1, errno, "%s", ifreq.ifr_name); } #else struct bpf_program bpf_program; static struct bpf_insn bpf_insn [] = { { BPF_LD + BPF_H + BPF_ABS, 0, 0, 12 }, { BPF_JMP + BPF_JEQ + BPF_K, 0, 18, 0 }, { BPF_LD + BPF_B + BPF_ABS, 0, 0, 0 }, { BPF_JMP + BPF_JEQ + BPF_K, 0, 10, 0 }, { BPF_LD + BPF_B + BPF_ABS, 0, 0, 1 }, { BPF_JMP + BPF_JEQ + BPF_K, 0, 8, 0 }, { BPF_LD + BPF_B + BPF_ABS, 0, 0, 2 }, { BPF_JMP + BPF_JEQ + BPF_K, 0, 6, 0 }, { BPF_LD + BPF_B + BPF_ABS, 0, 0, 3 }, { BPF_JMP + BPF_JEQ + BPF_K, 0, 4, 0 }, { BPF_LD + BPF_B + BPF_ABS, 0, 0, 4 }, { BPF_JMP + BPF_JEQ + BPF_K, 0, 2, 0 }, { BPF_LD + BPF_B + BPF_ABS, 0, 0, 5 }, { BPF_JMP + BPF_JEQ + BPF_K, 4, 0, 0 }, { BPF_LD + BPF_W + BPF_ABS, 0, 0, 0 }, { BPF_JMP + BPF_JEQ + BPF_K, 0, 4, 0xFFFFFFFF }, { BPF_LD + BPF_H + BPF_ABS, 0, 0, 4 }, { BPF_JMP + BPF_JEQ + BPF_K, 0, 2, 0xFFFF }, { BPF_LD + BPF_W + BPF_LEN, 0, 0, 0 }, { BPF_RET + BPF_A, 0, 0, 0 }, { BPF_RET + BPF_K, 0, 0, 0 } }; #if defined (__APPLE__) || defined (__OpenBSD__) || defined (__NetBSD__) struct ifreq ifreq; struct timeval timeval; struct bpf * bpf; char filename [sizeof (CHANNEL_BPFDEVICE) + 1]; unsigned count; unsigned state; int stat_errno = 0; int open_errno = 0; for (count = 0; count < 100; count++) { struct stat st; snprintf (filename, sizeof (filename), CHANNEL_BPFDEVICE, count); if (stat(filename, &st) == -1) { stat_errno = errno; continue; } if ((channel->fd = open (filename, O_RDWR)) != -1) { break; } else { open_errno = errno; } } if (channel->fd == -1) { if (open_errno) { error (1, open_errno, "Could not open bpf device"); } else { error (1, stat_errno, "No bpf device found"); } } memcpy (ifreq.ifr_name, channel->ifname, sizeof (ifreq.ifr_name)); if (ioctl (channel->fd, BIOCSETIF, &ifreq) == -1) { error (1, errno, "%s", ifreq.ifr_name); } channel->bpf = bpf = malloc (sizeof (* bpf)); if (ioctl (channel->fd, BIOCGBLEN, &bpf->bpf_length) == -1) { error (1, errno, "Can't determine buffer length: %s", ifreq.ifr_name); } bpf->bpf_bp = bpf->bpf_buffer = malloc (bpf->bpf_length); if (bpf->bpf_buffer == NULL) { error (1, errno, "Can't allocate receive buffer"); } #if defined (__APPLE__) || defined (__NetBSD__) state = 0; if (ioctl (channel->fd, BIOCSSEESENT, &state) == -1) { error (1, errno, "Can't hide outgoing frames: %s", ifreq.ifr_name); } #elif defined (__OpenBSD__) state = BPF_DIRECTION_OUT; if (ioctl (channel->fd, BIOCSDIRFILT, &state) == -1) { error (0, errno, "Can't hide outgoing frames"); } #else #error "Abandon all hope" #endif if (channel->capture > 1000) { timeval.tv_sec = channel->capture / 1000; timeval.tv_usec = 0; } else { #if defined (__MAC_10_6) /* * accommodate known bug in BPF on MAC OS X 10.6; shorter times cause socket read * operations to block indefinitely if no frames are waiting because tv_usec gets * clobbered; */ timeval.tv_sec = 1; timeval.tv_usec = 0; #else timeval.tv_sec = 0; timeval.tv_usec = channel->capture * 1000; #endif } if (ioctl (channel->fd, BIOCSRTIMEOUT, &timeval) == -1) { error (1, errno, "Can't set channel timeout: %s", ifreq.ifr_name); } state = 1; if (ioctl (channel->fd, BIOCIMMEDIATE, &state) == -1) { error (1, errno, "Can't set immediate mode: %s", ifreq.ifr_name); } #if 1 state = 1; if (ioctl (channel->fd, BIOCSHDRCMPLT, &state) == -1) { error (1, errno, "Can't set header complete mode: %s", ifreq.ifr_name); } #endif #if 1 gethwaddr (channel->host, channel->ifname); #else if (ioctl (channel->fd, SIOCGIFADDR, &ifreq) > 0) { error (1, errno, "%s", ifreq.ifr_name); } memcpy (channel->host, LLADDR (ifreq.ifr_ifru.ifru_addr), sizeof (channel->host)); #endif bpf_program.bf_len = sizeof (bpf_insn) / sizeof (struct bpf_insn); bpf_program.bf_insns = bpf_insn; if (channel->type == ETH_P_802_2) { bpf_insn [1].code = BPF_JMP + BPF_JGT + BPF_K; bpf_insn [1].jt = 18; bpf_insn [1].jf = 0; bpf_insn [1].k = ETHERMTU; } else { bpf_insn [1].code = BPF_JMP + BPF_JEQ + BPF_K; bpf_insn [1].jt = 0; bpf_insn [1].jf = 18; bpf_insn [1].k = channel->type; } bpf_insn [3].k = channel->host [0]; bpf_insn [5].k = channel->host [1]; bpf_insn [7].k = channel->host [2]; bpf_insn [9].k = channel->host [3]; bpf_insn [11].k = channel->host [4]; bpf_insn [13].k = channel->host [5]; if (ioctl (channel->fd, BIOCSETF, &bpf_program) == -1) { error (1, errno, "Can't store filter: %s", channel->ifname); } #elif defined (WINPCAP) || defined (LIBPCAP) channel->ifname = getifname (channel->ifindex); gethwaddr (channel->host, channel->ifname); channel->socket = pcap_open_live (channel->ifname, 65536, 0, channel->capture, channel->errbuf); snprintf ((char *)(channel->ifname), strlen (channel->ifname), "nic%d", channel->ifindex); if (!channel->socket) { error (1, errno, "Can't open interface: %s", channel->ifname); } bpf_program.bf_len = sizeof (bpf_insn)/sizeof (struct bpf_insn); bpf_program.bf_insns = bpf_insn; if (channel->type == ETH_P_802_2) { bpf_insn [1].code = BPF_JMP + BPF_JGT + BPF_K; bpf_insn [1].jt = 18; bpf_insn [1].jf = 0; bpf_insn [1].k = ETHERMTU; } else { bpf_insn [1].code = BPF_JMP + BPF_JEQ + BPF_K; bpf_insn [1].jt = 0; bpf_insn [1].jf = 18; bpf_insn [1].k = channel->type; } bpf_insn [3].k = channel->host [0]; bpf_insn [5].k = channel->host [1]; bpf_insn [7].k = channel->host [2]; bpf_insn [9].k = channel->host [3]; bpf_insn [11].k = channel->host [4]; bpf_insn [13].k = channel->host [5]; if (pcap_setfilter (channel->socket, &bpf_program) < 0) { error (1, errno, "Can't store filter: %s", channel->ifname); } if (pcap_setmintocopy (channel->socket, ETHER_MIN_LEN) < 0) { error (1, errno, "Can't set pcap mintocopy: %s", channel->ifname); } #else #error "Unknown Environment" #endif #endif return (0); }
int main(){ int sock,size,flags; char buf[1024]; struct sockaddr_ll addr; struct ifreq ifr; unsigned char hwaddr[6]; PACKET pk_start; if((sock=socket(PF_PACKET,SOCK_RAW,htons(ETH_P_PAE)))<0){ printf("create raw socket error\n"); return -1; } /*flags=fcntl(sock,F_GETFL,0); printf("%d\n",flags); if(fcntl(sock,F_SETFL,flags|O_NONBLOCK)<0) { printf("set nonblock error\n"); return -1; }*/ strcpy(ifr.ifr_name,"eth0"); if(ioctl(sock,SIOCGIFINDEX,&ifr)<0) { printf("get ifindex error\n"); return -1; } printf("%d\n",ifr.ifr_ifindex); bzero(&addr,sizeof(struct sockaddr_ll)); addr.sll_family=PF_PACKET; addr.sll_protocol=htons(ETH_P_PAE); addr.sll_ifindex=ifr.ifr_ifindex; if(bind(sock,(struct sockaddr *)&addr,sizeof(struct sockaddr_ll))<0) { printf("bind error\n"); return -1; } if(gethwaddr(hwaddr)<0) { printf("get hwaddr error\n"); return -1; } printf("mac %02x:%02x:%02x:%02x:%02x:%02x\n",hwaddr[0],hwaddr[1],hwaddr[2],hwaddr[3],hwaddr[4],hwaddr[5]); get_start_packet(&pk_start,hwaddr); if(sendto(sock,&pk_start,sizeof(pk_start),0,(struct sockaddr *)&addr,sizeof(struct sockaddr_ll))<0) { printf("send packet error"); return -1; } PACKET pkt_recv; printf("recv message\n"); //block until receive message size=recvfrom(sock,(void *)&pkt_recv,sizeof(pkt_recv),0,NULL,NULL); int type = packet_type(&pkt_recv); int id = pkt_recv.body.test.id; printf("id is %d\n",id); if(type!=1) { printf("warning:identity packet type is 1\n"); return -1; } PACKET pkt_id; get_identity_packet(&pkt_id,id,hwaddr); if(sendto(sock,&pkt_id,sizeof(pk_start),0,(struct sockaddr *)&addr,sizeof(struct sockaddr_ll))<0) { printf("send packet error"); return -1; } bzero(&pkt_recv,sizeof(pkt_recv)); size=recvfrom(sock,(void *)&pkt_recv,sizeof(pkt_recv),0,NULL,NULL); printf("%d\n",size); return 0; }
void pcap_enum (flag_t flags) { char report [PCAP_ERRBUF_SIZE]; char string [ETHER_ADDR_LEN * 3]; byte number [ETHER_ADDR_LEN]; pcap_if_t * device; pcap_if_t * devices = (pcap_if_t *)(0); unsigned index; if (pcap_findalldevs (&devices, report) == -1) { error (1, 0, "Can't enumerate interfaces"); } if (!devices) { error (1, 0, "No interfaces available"); } if (_anyset (flags, PCAP_DEVICES)) { for (device = devices, index = 1; device; device = device->next, index++) { gethwaddr (number, device->name); hexdecode (number, sizeof (number), string, sizeof (string)); printf ("%2d %s %s", index, string, device->name); if (device->description) { printf ("\t(%s)", device->description); } printf ("\n"); } } if (_anyset (flags, PCAP_NICS)) { for (device = devices, index = 1; device; device = device->next, index++) { #if defined (WIN32) printf ("ETH%d=%d", index, index); #else printf ("ETH%d=%s", index, device->name); #endif if (device->description) { printf ("\t# %s", device->description); } printf ("\n"); } printf ("\n"); } if (_anyset (flags, PCAP_MACS)) { for (device = devices, index = 1; device; device = device->next, index++) { gethwaddr (number, device->name); hexdecode (number, sizeof (number), string, sizeof (string)); printf ("NIC%d=%s", index, string); if (device->description) { printf ("\t# %s", device->description); } printf ("\n"); } printf ("\n"); } pcap_freealldevs (devices); return; }