int main(void)
{
apt_t my1, my2, winxp, gateway;
memset(winxp.ip, 0, sizeof(winxp));
memcpy(winxp.ip, "192.168.15.55", strlen("192.168.15.55"));
winxp.mac[0] = 0x00;
winxp.mac[1] = 0x27;
winxp.mac[2] = 0x13;
winxp.mac[3] = 0xb4;
winxp.mac[4] = 0x6e;
winxp.mac[5] = 0x08;
memset(gateway.ip, 0, sizeof(gateway));
memcpy(gateway.ip, "192.168.15.254", strlen("192.168.15.254"));
gateway.mac[0] = 0x00;
gateway.mac[1] = 0x22;
gateway.mac[2] = 0xa1;
gateway.mac[3] = 0x08;
gateway.mac[4] = 0xf4;
gateway.mac[5] = 0x04;
memset(my1.ip, 0, sizeof(my1));
memcpy(my1.ip, "192.168.15.55", strlen("192.168.15.55"));
my1.mac[0] = 0x00;
my1.mac[1] = 0x01;
my1.mac[2] = 0x02;
my1.mac[3] = 0x05;
my1.mac[4] = 0x06;
my1.mac[5] = 0x01;
memset(my2.ip, 0, sizeof(my2));
memcpy(my2.ip, "192.168.15.254", strlen("192.168.15.254"));
gateway.mac[0] = 0x02;
gateway.mac[1] = 0x05;
gateway.mac[2] = 0x08;
gateway.mac[3] = 0x04;
gateway.mac[4] = 0x23;
gateway.mac[5] = 0x01;
while(1)
{
printf("send arp reply...\n");
send_arp_reply(my1, gateway);
usleep(1000);
send_arp_reply(my2, winxp);
usleep(1000);
}
return 0;
}
int
arp_in (struct rte_mbuf *mbuf)
{
assert(mbuf->buf_len >= sizeof(struct arp));
struct arp *arp_pkt;
struct ether_hdr *eth;
uint32_t ip_add = 0;
eth = rte_pktmbuf_mtod(mbuf, struct ether_hdr *);
assert(rte_pktmbuf_data_len(mbuf) >= (sizeof(struct arp) + sizeof(struct ether_hdr)));
arp_pkt = rte_pktmbuf_mtod(mbuf, char *) + sizeof(struct ether_hdr);
switch(ntohs(arp_pkt->opcode)) {
case ARP_REQ ://
send_arp_reply(arp_pkt->dst_pr_add, arp_pkt->src_pr_add);
break;
/*
uint32_t ip_add = GetIntAddFromChar(arp_pkt->src_pr_add, 0);
add_mac((ip_add), arp_pkt->src_hw_add);
logger(ARP, NORMAL, "seen arp packet\n");
break;
*/
case ARP_REPLY ://
ip_add = GetIntAddFromChar(arp_pkt->src_pr_add, 0);
add_mac((ip_add), arp_pkt->src_hw_add);
break;
// default : assert(0);
}
}
void process_arp_request( struct sr_instance *sr, const uint8_t *packet, unsigned int len, const char *interface)
{
assert(sr);
assert(packet);
assert(interface);
arp_hdr* arp = get_arp_hdr(packet, len);
router_state *rs = get_router_state(sr);
/* get interface list read lock */
lock_if_list_rd(rs);
/* scan the interface list
* match the requested ip
*/
node* n = get_router_state(sr)->if_list;
while (n) {
/* see if we have an interface matching the requested ip */
if (((iface_entry*)n->data)->ip == arp->arp_tip.s_addr) {
send_arp_reply(sr, packet, len, (iface_entry*)(n->data));
break;
}
n = n->next;
}
/* release the interface list lock */
unlock_if_list(rs);
}
static int handle_arp(uint8_t *packet,
uint8_t *curptr, uint32_t curlen, bool outgoing) {
// TODO add IPv6 support
if (curlen < ARP_LEN) {
return DROP_FRAME;
}
if (MASK(curptr, 0xFFFF, 0) == 1 /*Ethernet*/ &&
MASK(OFFSET(curptr, 2), 0xFFFF, 0) == 0x0800) {
curptr += 4;
if (CMASK(curptr, 0xFF, 0) != MAC_LEN ||
CMASK(OFFSET(curptr, 1), 0xFF, 0) != IP_LEN) {
return DROP_FRAME;
}
curptr += 2;
// choose operation
int op = MASK(curptr, 0xFFFF, 0);
curptr += 2;
uint8_t arp_target_mac[MAC_LEN], arp_source_mac[MAC_LEN],
arp_target_ip[IP_LEN], arp_source_ip[IP_LEN];
CPYMAC(arp_source_mac, curptr);
curptr += MAC_LEN;
CPYIP(arp_source_ip, curptr);
curptr += IP_LEN;
CPYMAC(arp_target_mac, curptr);
curptr += MAC_LEN;
CPYIP(arp_target_ip, curptr);
if (op == 1) {
//handle ARP request
if (EQIP(arp_target_ip, &ip_address) && !outgoing) {
send_arp_reply(packet, arp_source_mac, arp_source_ip);
return FRAME_TO_TAP;
} else if (outgoing) {
return FRAME_TO_TAP;
}
} else if (op == 2) {
//handle ARP reply
if (outgoing) {
return FRAME_TO_TAP;
} else {
return FRAME_TO_ALL;
}
}
}
return DROP_FRAME;
}
void main() {
struct hw_ip_pair *hi_pair;
char IP_str[20], cache_hw_addr[6];
fd_set rset;
int cache_ifindex, cache_hatype;
struct hw_addr HWaddr;
hi_pair = malloc(sizeof(struct hw_ip_pair));
get_hw_ip_pair(hi_pair);
printf("My IP :%s,\t HW addr", hi_pair->ip_addr);
print_mac_to_string(hi_pair->hw_addr);
printf("\n");
int pf_pack_sockfd = create_pf_pack_socket();
void* buffer = (void*)malloc(ETH_FRAME_LEN);
int listen_sockfd, conn_sockfd, clilen, n;
struct sockaddr_un servaddr, cliaddr;
char sendline[MAXLINE], recvline[MAXLINE];
struct sockaddr_in *destIP = malloc(sizeof(struct sockaddr_in));
char ip_addr[20];
struct arp_packet *arp_req = malloc(sizeof(struct arp_packet));
struct arp_packet *arp_rep = malloc(sizeof(struct arp_packet));
struct arp_packet *arp_recv = malloc(sizeof(struct arp_packet));
struct sockaddr_ll socket_address;
int ll_len = sizeof(struct sockaddr_ll);
int i=0;
listen_sockfd = Socket(AF_LOCAL, SOCK_STREAM, 0);
unlink(SUN_PATH_ARP);
bzero(&servaddr, sizeof(servaddr));
servaddr.sun_family = AF_LOCAL;
strcpy(servaddr.sun_path, SUN_PATH_ARP);
Bind(listen_sockfd, (SA *) &servaddr, sizeof(servaddr));
Listen(listen_sockfd, LISTENQ);
int lookup_flag=0;
clilen = sizeof(struct sockaddr_un);
while(1) {
FD_ZERO(&rset);
FD_SET(listen_sockfd, &rset);
FD_SET(pf_pack_sockfd, &rset);
FD_SET(conn_sockfd, &rset);
int max;
if(conn_sockfd != 0)
max = max(max(listen_sockfd, conn_sockfd),pf_pack_sockfd);
else
max = max(listen_sockfd,pf_pack_sockfd);
int ret = select(max+1, &rset, NULL, NULL, NULL);
if(FD_ISSET(listen_sockfd, &rset)) {
conn_sockfd = Accept(listen_sockfd, (SA *) &cliaddr, &clilen);
/* n = read(conn_sockfd, destIP, sizeof(struct sockaddr_in));
Inet_ntop(AF_INET, &(destIP->sin_addr), ip_addr, 20);
// Lookup for the <HW,IP> pair in the ARP cache
lookup_arp_cache(ip_addr, cache_hw_addr, &cache_ifindex, &cache_hatype,&lookup_flag);
if(lookup_flag == 0) {
printf("Entry not found from cache\n");
create_arp_request_packet(arp_req, ip_addr, hi_pair);
send_arp_request(pf_pack_sockfd, arp_req, hi_pair, conn_sockfd);
}
else{
printf("Entry found from cache\n");
// Send from cache
HWaddr.sll_ifindex = cache_ifindex;
HWaddr.sll_hatype = cache_hatype;
HWaddr.sll_halen = sizeof(cache_hatype);
memcpy(HWaddr.mac_addr, cache_hw_addr,6);
print_mac_to_string(HWaddr.mac_addr);
Write(conn_sockfd, (void *)&HWaddr, sizeof(HWaddr));
close(conn_sockfd);
}
printf("Sent ARP request\n");
*/ }
else if(ret!= -1 && FD_ISSET(conn_sockfd, &rset)) {
n = read(conn_sockfd, destIP, sizeof(struct sockaddr_in));
Inet_ntop(AF_INET, &(destIP->sin_addr), ip_addr, 20);
// Lookup for the <HW,IP> pair in the ARP cache
lookup_arp_cache(ip_addr, cache_hw_addr, &cache_ifindex, &cache_hatype,&lookup_flag);
if(lookup_flag == 0) {
create_arp_request_packet(arp_req, ip_addr, hi_pair);
printf("send 1\n");
send_arp_request(pf_pack_sockfd, arp_req, hi_pair, conn_sockfd);
}
else{
// Send from cache
HWaddr.sll_ifindex = cache_ifindex;
HWaddr.sll_hatype = cache_hatype;
HWaddr.sll_halen = sizeof(cache_hatype);
memcpy(HWaddr.mac_addr, cache_hw_addr,6);
// print_mac_to_string(HWaddr.mac_addr);
Write(conn_sockfd, (void *)&HWaddr, sizeof(HWaddr));
close(conn_sockfd);
conn_sockfd = 0;
}
}
else if(FD_ISSET(pf_pack_sockfd, &rset)) {
Recvfrom(pf_pack_sockfd, buffer, ETH_FRAME_LEN, 0, (SA *)&socket_address, &ll_len);
void *data = buffer + 14;
arp_rep = (struct arp_packet *)data;
if (arp_rep->id == ARP_ID){
if(arp_rep->op == ARP_REQ) {
if(strcmp(arp_rep->dest_IP, hi_pair->ip_addr) == 0) {
printf("Printing Ethernet Header and ARP Request Packet Received\n");
print_ethernet_and_arp(arp_rep->src_mac, arp_rep->dest_mac, arp_rep);
add_to_arp_cache_list(arp_rep->src_IP, arp_rep->src_mac, socket_address.sll_ifindex, socket_address.sll_hatype, conn_sockfd, 1);
// print_arp_cache_list();
create_arp_reply_packet(arp_recv, arp_rep->src_IP, hi_pair, arp_rep->src_mac, arp_rep->id);
send_arp_reply(pf_pack_sockfd, arp_recv, hi_pair, socket_address.sll_ifindex);
}
else {
update_arp_cache(arp_rep->src_IP, arp_rep->src_mac, socket_address.sll_ifindex, 0, conn_sockfd);
}
continue;
}
else if(arp_rep->op == ARP_REP) {
if(ret == -1) {
delete_from_arp_cache(arp_rep->src_IP);
// print_arp_cache_list();
continue;
}
printf("Printing Ethernet Header and ARP Reply Packet Received\n");
print_ethernet_and_arp(arp_rep->src_mac, arp_rep->dest_mac, arp_rep);
update_arp_cache(arp_rep->src_IP, arp_rep->src_mac, socket_address.sll_ifindex, 0, conn_sockfd);
// print_arp_cache_list();
HWaddr.sll_ifindex = socket_address.sll_ifindex;
HWaddr.sll_hatype = socket_address.sll_hatype;
HWaddr.sll_halen = socket_address.sll_halen;
memcpy(HWaddr.mac_addr, arp_rep->src_mac,6);
// print_mac_to_string(HWaddr.mac_addr);
Write(conn_sockfd, (void *)&HWaddr, sizeof(HWaddr));
close(conn_sockfd);
conn_sockfd = 0;
update_arp_cache(arp_rep->src_IP, arp_rep->src_mac, socket_address.sll_ifindex, 0, -1);
// print_arp_cache_list();
}
}
}
}
}