ShuriZma
/
xemu
mirror of https://github.com/xemu-project/xemu.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge remote-tracking branch 'kiszka/queues/slirp' into staging

This commit is contained in:
Anthony Liguori 2011-08-04 17:12:34 -05:00
parent 5df0a2a5ba 1ab74cea06
commit c00c0dc687
10 changed files with 240 additions and 97 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
MAINTAINERS
View File

@ -431,9 +431,10 @@ S: Maintained
F: net/ F: net/
SLIRP SLIRP
M: qemu-devel@nongnu.org M: Jan Kiszka <jan.kiszka@siemens.com>
S: Orphan S: Maintained
F: slirp/ F: slirp/
T: git://git.kiszka.org/qemu.git queues/slirp
Usermode Emulation Usermode Emulation
------------------ ------------------

2
Makefile.objs
View File

@ -163,7 +163,7 @@ common-obj-y += qemu-timer.o qemu-timer-common.o
slirp-obj-y = cksum.o if.o ip_icmp.o ip_input.o ip_output.o slirp-obj-y = cksum.o if.o ip_icmp.o ip_input.o ip_output.o
slirp-obj-y += slirp.o mbuf.o misc.o sbuf.o socket.o tcp_input.o tcp_output.o slirp-obj-y += slirp.o mbuf.o misc.o sbuf.o socket.o tcp_input.o tcp_output.o
slirp-obj-y += tcp_subr.o tcp_timer.o udp.o bootp.o tftp.o slirp-obj-y += tcp_subr.o tcp_timer.o udp.o bootp.o tftp.o arp_table.o
common-obj-$(CONFIG_SLIRP) += $(addprefix slirp/, $(slirp-obj-y)) common-obj-$(CONFIG_SLIRP) += $(addprefix slirp/, $(slirp-obj-y))
# xen backend driver support # xen backend driver support

95
slirp/arp_table.c Normal file
View File

@ -0,0 +1,95 @@
/*
* ARP table
*
* Copyright (c) 2011 AdaCore
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#include "slirp.h"
void arp_table_add(Slirp *slirp, int ip_addr, uint8_t ethaddr[ETH_ALEN])
{
const in_addr_t broadcast_addr =
~slirp->vnetwork_mask.s_addr | slirp->vnetwork_addr.s_addr;
ArpTable *arptbl = &slirp->arp_table;
int i;
DEBUG_CALL("arp_table_add");
DEBUG_ARG("ip = 0x%x", ip_addr);
DEBUG_ARGS((dfd, " hw addr = %02x:%02x:%02x:%02x:%02x:%02x\n",
ethaddr[0], ethaddr[1], ethaddr[2],
ethaddr[3], ethaddr[4], ethaddr[5]));
/* Check 0.0.0.0/8 invalid source-only addresses */
assert((ip_addr & htonl(~(0xf << 28))) != 0);
if (ip_addr == 0xffffffff || ip_addr == broadcast_addr) {
/* Do not register broadcast addresses */
return;
}
/* Search for an entry */
for (i = 0; i < ARP_TABLE_SIZE; i++) {
if (arptbl->table[i].ar_sip == ip_addr) {
/* Update the entry */
memcpy(arptbl->table[i].ar_sha, ethaddr, ETH_ALEN);
return;
}
}
/* No entry found, create a new one */
arptbl->table[arptbl->next_victim].ar_sip = ip_addr;
memcpy(arptbl->table[arptbl->next_victim].ar_sha, ethaddr, ETH_ALEN);
arptbl->next_victim = (arptbl->next_victim + 1) % ARP_TABLE_SIZE;
}
bool arp_table_search(Slirp *slirp, int in_ip_addr,
uint8_t out_ethaddr[ETH_ALEN])
{
const in_addr_t broadcast_addr =
~slirp->vnetwork_mask.s_addr | slirp->vnetwork_addr.s_addr;
ArpTable *arptbl = &slirp->arp_table;
int i;
DEBUG_CALL("arp_table_search");
DEBUG_ARG("ip = 0x%x", in_ip_addr);
/* Check 0.0.0.0/8 invalid source-only addresses */
assert((in_ip_addr & htonl(~(0xf << 28))) != 0);
/* If broadcast address */
if (in_ip_addr == 0xffffffff || in_ip_addr == broadcast_addr) {
/* return Ethernet broadcast address */
memset(out_ethaddr, 0xff, ETH_ALEN);
return 1;
}
for (i = 0; i < ARP_TABLE_SIZE; i++) {
if (arptbl->table[i].ar_sip == in_ip_addr) {
memcpy(out_ethaddr, arptbl->table[i].ar_sha, ETH_ALEN);
DEBUG_ARGS((dfd, " found hw addr = %02x:%02x:%02x:%02x:%02x:%02x\n",
out_ethaddr[0], out_ethaddr[1], out_ethaddr[2],
out_ethaddr[3], out_ethaddr[4], out_ethaddr[5]));
return 1;
}
}
return 0;
}

21
slirp/bootp.c
View File

@ -149,6 +149,7 @@ static void bootp_reply(Slirp *slirp, const struct bootp_t *bp)
struct in_addr preq_addr; struct in_addr preq_addr;
int dhcp_msg_type, val; int dhcp_msg_type, val;
uint8_t *q; uint8_t *q;
uint8_t client_ethaddr[ETH_ALEN];
/* extract exact DHCP msg type */ /* extract exact DHCP msg type */
dhcp_decode(bp, &dhcp_msg_type, &preq_addr); dhcp_decode(bp, &dhcp_msg_type, &preq_addr);
@ -164,8 +165,9 @@ static void bootp_reply(Slirp *slirp, const struct bootp_t *bp)
if (dhcp_msg_type != DHCPDISCOVER && if (dhcp_msg_type != DHCPDISCOVER &&
dhcp_msg_type != DHCPREQUEST) dhcp_msg_type != DHCPREQUEST)
return; return;
/* XXX: this is a hack to get the client mac address */
memcpy(slirp->client_ethaddr, bp->bp_hwaddr, 6); /* Get client's hardware address from bootp request */
memcpy(client_ethaddr, bp->bp_hwaddr, ETH_ALEN);
m = m_get(slirp); m = m_get(slirp);
if (!m) { if (!m) {
@ -178,25 +180,25 @@ static void bootp_reply(Slirp *slirp, const struct bootp_t *bp)
if (dhcp_msg_type == DHCPDISCOVER) { if (dhcp_msg_type == DHCPDISCOVER) {
if (preq_addr.s_addr != htonl(0L)) { if (preq_addr.s_addr != htonl(0L)) {
bc = request_addr(slirp, &preq_addr, slirp->client_ethaddr); bc = request_addr(slirp, &preq_addr, client_ethaddr);
if (bc) { if (bc) {
daddr.sin_addr = preq_addr; daddr.sin_addr = preq_addr;
} }
} }
if (!bc) { if (!bc) {
new_addr: new_addr:
bc = get_new_addr(slirp, &daddr.sin_addr, slirp->client_ethaddr); bc = get_new_addr(slirp, &daddr.sin_addr, client_ethaddr);
if (!bc) { if (!bc) {
DPRINTF("no address left\n"); DPRINTF("no address left\n");
return; return;
} }
} }
memcpy(bc->macaddr, slirp->client_ethaddr, 6); memcpy(bc->macaddr, client_ethaddr, ETH_ALEN);
} else if (preq_addr.s_addr != htonl(0L)) { } else if (preq_addr.s_addr != htonl(0L)) {
bc = request_addr(slirp, &preq_addr, slirp->client_ethaddr); bc = request_addr(slirp, &preq_addr, client_ethaddr);
if (bc) { if (bc) {
daddr.sin_addr = preq_addr; daddr.sin_addr = preq_addr;
memcpy(bc->macaddr, slirp->client_ethaddr, 6); memcpy(bc->macaddr, client_ethaddr, ETH_ALEN);
} else { } else {
daddr.sin_addr.s_addr = 0; daddr.sin_addr.s_addr = 0;
} }
@ -209,6 +211,9 @@ static void bootp_reply(Slirp *slirp, const struct bootp_t *bp)
} }
} }
/* Update ARP table for this IP address */
arp_table_add(slirp, daddr.sin_addr.s_addr, client_ethaddr);
saddr.sin_addr = slirp->vhost_addr; saddr.sin_addr = slirp->vhost_addr;
saddr.sin_port = htons(BOOTP_SERVER); saddr.sin_port = htons(BOOTP_SERVER);
@ -218,7 +223,7 @@ static void bootp_reply(Slirp *slirp, const struct bootp_t *bp)
rbp->bp_xid = bp->bp_xid; rbp->bp_xid = bp->bp_xid;
rbp->bp_htype = 1; rbp->bp_htype = 1;
rbp->bp_hlen = 6; rbp->bp_hlen = 6;
memcpy(rbp->bp_hwaddr, bp->bp_hwaddr, 6); memcpy(rbp->bp_hwaddr, bp->bp_hwaddr, ETH_ALEN);
rbp->bp_yiaddr = daddr.sin_addr; /* Client IP address */ rbp->bp_yiaddr = daddr.sin_addr; /* Client IP address */
rbp->bp_siaddr = saddr.sin_addr; /* Server IP address */ rbp->bp_siaddr = saddr.sin_addr; /* Server IP address */

28
slirp/if.c
View File

@ -6,6 +6,7 @@
*/ */
#include <slirp.h> #include <slirp.h>
#include "qemu-timer.h"
#define ifs_init(ifm) ((ifm)->ifs_next = (ifm)->ifs_prev = (ifm)) #define ifs_init(ifm) ((ifm)->ifs_next = (ifm)->ifs_prev = (ifm))
@ -105,6 +106,9 @@ if_output(struct socket *so, struct mbuf *ifm)
ifs_init(ifm); ifs_init(ifm);
insque(ifm, ifq); insque(ifm, ifq);
/* Expiration date = Now + 1 second */
ifm->expiration_date = qemu_get_clock_ns(rt_clock) + 1000000000ULL;
diddit: diddit:
slirp->if_queued++; slirp->if_queued++;
@ -153,6 +157,9 @@ diddit:
void void
if_start(Slirp *slirp) if_start(Slirp *slirp)
{ {
int requeued = 0;
uint64_t now;
struct mbuf *ifm, *ifqt; struct mbuf *ifm, *ifqt;
DEBUG_CALL("if_start"); DEBUG_CALL("if_start");
@ -165,6 +172,8 @@ if_start(Slirp *slirp)
if (!slirp_can_output(slirp->opaque)) if (!slirp_can_output(slirp->opaque))
return; return;
now = qemu_get_clock_ns(rt_clock);
/* /*
* See which queue to get next packet from * See which queue to get next packet from
* If there's something in the fastq, select it immediately * If there's something in the fastq, select it immediately
@ -199,11 +208,22 @@ if_start(Slirp *slirp)
ifm->ifq_so->so_nqueued = 0; ifm->ifq_so->so_nqueued = 0;
} }
/* Encapsulate the packet for sending */ if (ifm->expiration_date < now) {
if_encap(slirp, (uint8_t *)ifm->m_data, ifm->m_len); /* Expired */
m_free(ifm);
m_free(ifm); } else {
/* Encapsulate the packet for sending */
if (if_encap(slirp, ifm)) {
m_free(ifm);
} else {
/* re-queue */
insque(ifm, ifqt);
requeued++;
}
}
if (slirp->if_queued) if (slirp->if_queued)
goto again; goto again;
slirp->if_queued = requeued;
} }

2
slirp/main.h
View File

@ -42,5 +42,5 @@ extern int tcp_keepintvl;
#define PROTO_PPP 0x2 #define PROTO_PPP 0x2
#endif #endif
void if_encap(Slirp *slirp, const uint8_t *ip_data, int ip_data_len); int if_encap(Slirp *slirp, struct mbuf *ifm);
ssize_t slirp_send(struct socket *so, const void *buf, size_t len, int flags); ssize_t slirp_send(struct socket *so, const void *buf, size_t len, int flags);

2
slirp/mbuf.c
View File

@ -70,6 +70,8 @@ m_get(Slirp *slirp)
m->m_len = 0; m->m_len = 0;
m->m_nextpkt = NULL; m->m_nextpkt = NULL;
m->m_prevpkt = NULL; m->m_prevpkt = NULL;
m->arp_requested = false;
m->expiration_date = (uint64_t)-1;
end_error: end_error:
DEBUG_ARG("m = %lx", (long )m); DEBUG_ARG("m = %lx", (long )m);
return m; return m;

2
slirp/mbuf.h
View File

@ -86,6 +86,8 @@ struct mbuf {
char m_dat_[1]; /* ANSI don't like 0 sized arrays */ char m_dat_[1]; /* ANSI don't like 0 sized arrays */
char *m_ext_; char *m_ext_;
} M_dat; } M_dat;
bool arp_requested;
uint64_t expiration_date;
}; };
#define m_next m_hdr.mh_next #define m_next m_hdr.mh_next

133
slirp/slirp.c
View File

@ -31,11 +31,11 @@
struct in_addr loopback_addr; struct in_addr loopback_addr;
/* emulated hosts use the MAC addr 52:55:IP:IP:IP:IP */ /* emulated hosts use the MAC addr 52:55:IP:IP:IP:IP */
static const uint8_t special_ethaddr[6] = { static const uint8_t special_ethaddr[ETH_ALEN] = {
0x52, 0x55, 0x00, 0x00, 0x00, 0x00 0x52, 0x55, 0x00, 0x00, 0x00, 0x00
}; };
static const uint8_t zero_ethaddr[6] = { 0, 0, 0, 0, 0, 0 }; static const uint8_t zero_ethaddr[ETH_ALEN] = { 0, 0, 0, 0, 0, 0 };
/* XXX: suppress those select globals */ /* XXX: suppress those select globals */
fd_set *global_readfds, *global_writefds, *global_xfds; fd_set *global_readfds, *global_writefds, *global_xfds;
@ -599,42 +599,8 @@ void slirp_select_poll(fd_set *readfds, fd_set *writefds, fd_set *xfds,
global_xfds = NULL; global_xfds = NULL;
} }
#define ETH_ALEN 6
#define ETH_HLEN 14
#define ETH_P_IP 0x0800 /* Internet Protocol packet */
#define ETH_P_ARP 0x0806 /* Address Resolution packet */
#define ARPOP_REQUEST 1 /* ARP request */
#define ARPOP_REPLY 2 /* ARP reply */
struct ethhdr
{
unsigned char h_dest[ETH_ALEN]; /* destination eth addr */
unsigned char h_source[ETH_ALEN]; /* source ether addr */
unsigned short h_proto; /* packet type ID field */
};
struct arphdr
{
unsigned short ar_hrd; /* format of hardware address */
unsigned short ar_pro; /* format of protocol address */
unsigned char ar_hln; /* length of hardware address */
unsigned char ar_pln; /* length of protocol address */
unsigned short ar_op; /* ARP opcode (command) */
/*
* Ethernet looks like this : This bit is variable sized however...
*/
unsigned char ar_sha[ETH_ALEN]; /* sender hardware address */
uint32_t ar_sip; /* sender IP address */
unsigned char ar_tha[ETH_ALEN]; /* target hardware address */
uint32_t ar_tip ; /* target IP address */
} __attribute__((packed));
static void arp_input(Slirp *slirp, const uint8_t *pkt, int pkt_len) static void arp_input(Slirp *slirp, const uint8_t *pkt, int pkt_len)
{ {
struct ethhdr *eh = (struct ethhdr *)pkt;
struct arphdr *ah = (struct arphdr *)(pkt + ETH_HLEN); struct arphdr *ah = (struct arphdr *)(pkt + ETH_HLEN);
uint8_t arp_reply[max(ETH_HLEN + sizeof(struct arphdr), 64)]; uint8_t arp_reply[max(ETH_HLEN + sizeof(struct arphdr), 64)];
struct ethhdr *reh = (struct ethhdr *)arp_reply; struct ethhdr *reh = (struct ethhdr *)arp_reply;
@ -645,6 +611,12 @@ static void arp_input(Slirp *slirp, const uint8_t *pkt, int pkt_len)
ar_op = ntohs(ah->ar_op); ar_op = ntohs(ah->ar_op);
switch(ar_op) { switch(ar_op) {
case ARPOP_REQUEST: case ARPOP_REQUEST:
if (ah->ar_tip == ah->ar_sip) {
/* Gratuitous ARP */
arp_table_add(slirp, ah->ar_sip, ah->ar_sha);
return;
}
if ((ah->ar_tip & slirp->vnetwork_mask.s_addr) == if ((ah->ar_tip & slirp->vnetwork_mask.s_addr) ==
slirp->vnetwork_addr.s_addr) { slirp->vnetwork_addr.s_addr) {
if (ah->ar_tip == slirp->vnameserver_addr.s_addr || if (ah->ar_tip == slirp->vnameserver_addr.s_addr ||
@ -657,8 +629,8 @@ static void arp_input(Slirp *slirp, const uint8_t *pkt, int pkt_len)
return; return;
arp_ok: arp_ok:
memset(arp_reply, 0, sizeof(arp_reply)); memset(arp_reply, 0, sizeof(arp_reply));
/* XXX: make an ARP request to have the client address */
memcpy(slirp->client_ethaddr, eh->h_source, ETH_ALEN); arp_table_add(slirp, ah->ar_sip, ah->ar_sha);
/* ARP request for alias/dns mac address */ /* ARP request for alias/dns mac address */
memcpy(reh->h_dest, pkt + ETH_ALEN, ETH_ALEN); memcpy(reh->h_dest, pkt + ETH_ALEN, ETH_ALEN);
@ -679,11 +651,7 @@ static void arp_input(Slirp *slirp, const uint8_t *pkt, int pkt_len)
} }
break; break;
case ARPOP_REPLY: case ARPOP_REPLY:
/* reply to request of client mac address ? */ arp_table_add(slirp, ah->ar_sip, ah->ar_sha);
if (!memcmp(slirp->client_ethaddr, zero_ethaddr, ETH_ALEN) &&
ah->ar_sip == slirp->client_ipaddr.s_addr) {
memcpy(slirp->client_ethaddr, ah->ar_sha, ETH_ALEN);
}
break; break;
default: default:
break; break;
@ -724,54 +692,63 @@ void slirp_input(Slirp *slirp, const uint8_t *pkt, int pkt_len)
} }
} }
/* output the IP packet to the ethernet device */ /* Output the IP packet to the ethernet device. Returns 0 if the packet must be
void if_encap(Slirp *slirp, const uint8_t *ip_data, int ip_data_len) * re-queued.
*/
int if_encap(Slirp *slirp, struct mbuf *ifm)
{ {
uint8_t buf[1600]; uint8_t buf[1600];
struct ethhdr *eh = (struct ethhdr *)buf; struct ethhdr *eh = (struct ethhdr *)buf;
uint8_t ethaddr[ETH_ALEN];
const struct ip *iph = (const struct ip *)ifm->m_data;
if (ip_data_len + ETH_HLEN > sizeof(buf)) if (ifm->m_len + ETH_HLEN > sizeof(buf)) {
return; return 1;
}
if (!memcmp(slirp->client_ethaddr, zero_ethaddr, ETH_ALEN)) {
if (!arp_table_search(slirp, iph->ip_dst.s_addr, ethaddr)) {
uint8_t arp_req[ETH_HLEN + sizeof(struct arphdr)]; uint8_t arp_req[ETH_HLEN + sizeof(struct arphdr)];
struct ethhdr *reh = (struct ethhdr *)arp_req; struct ethhdr *reh = (struct ethhdr *)arp_req;
struct arphdr *rah = (struct arphdr *)(arp_req + ETH_HLEN); struct arphdr *rah = (struct arphdr *)(arp_req + ETH_HLEN);
const struct ip *iph = (const struct ip *)ip_data;
/* If the client addr is not known, there is no point in if (!ifm->arp_requested) {
sending the packet to it. Normally the sender should have /* If the client addr is not known, send an ARP request */
done an ARP request to get its MAC address. Here we do it memset(reh->h_dest, 0xff, ETH_ALEN);
in place of sending the packet and we hope that the sender memcpy(reh->h_source, special_ethaddr, ETH_ALEN - 4);
will retry sending its packet. */ memcpy(&reh->h_source[2], &slirp->vhost_addr, 4);
memset(reh->h_dest, 0xff, ETH_ALEN); reh->h_proto = htons(ETH_P_ARP);
memcpy(reh->h_source, special_ethaddr, ETH_ALEN - 4); rah->ar_hrd = htons(1);
memcpy(&reh->h_source[2], &slirp->vhost_addr, 4); rah->ar_pro = htons(ETH_P_IP);
reh->h_proto = htons(ETH_P_ARP); rah->ar_hln = ETH_ALEN;
rah->ar_hrd = htons(1); rah->ar_pln = 4;
rah->ar_pro = htons(ETH_P_IP); rah->ar_op = htons(ARPOP_REQUEST);
rah->ar_hln = ETH_ALEN;
rah->ar_pln = 4; /* source hw addr */
rah->ar_op = htons(ARPOP_REQUEST); memcpy(rah->ar_sha, special_ethaddr, ETH_ALEN - 4);
/* source hw addr */ memcpy(&rah->ar_sha[2], &slirp->vhost_addr, 4);
memcpy(rah->ar_sha, special_ethaddr, ETH_ALEN - 4);
memcpy(&rah->ar_sha[2], &slirp->vhost_addr, 4); /* source IP */
/* source IP */ rah->ar_sip = slirp->vhost_addr.s_addr;
rah->ar_sip = slirp->vhost_addr.s_addr;
/* target hw addr (none) */ /* target hw addr (none) */
memset(rah->ar_tha, 0, ETH_ALEN); memset(rah->ar_tha, 0, ETH_ALEN);
/* target IP */
rah->ar_tip = iph->ip_dst.s_addr; /* target IP */
slirp->client_ipaddr = iph->ip_dst; rah->ar_tip = iph->ip_dst.s_addr;
slirp_output(slirp->opaque, arp_req, sizeof(arp_req)); slirp->client_ipaddr = iph->ip_dst;
slirp_output(slirp->opaque, arp_req, sizeof(arp_req));
ifm->arp_requested = true;
}
return 0;
} else { } else {
memcpy(eh->h_dest, slirp->client_ethaddr, ETH_ALEN); memcpy(eh->h_dest, ethaddr, ETH_ALEN);
memcpy(eh->h_source, special_ethaddr, ETH_ALEN - 4); memcpy(eh->h_source, special_ethaddr, ETH_ALEN - 4);
/* XXX: not correct */ /* XXX: not correct */
memcpy(&eh->h_source[2], &slirp->vhost_addr, 4); memcpy(&eh->h_source[2], &slirp->vhost_addr, 4);
eh->h_proto = htons(ETH_P_IP); eh->h_proto = htons(ETH_P_IP);
memcpy(buf + sizeof(struct ethhdr), ip_data, ip_data_len); memcpy(buf + sizeof(struct ethhdr), ifm->m_data, ifm->m_len);
slirp_output(slirp->opaque, buf, ip_data_len + ETH_HLEN); slirp_output(slirp->opaque, buf, ifm->m_len + ETH_HLEN);
return 1;
} }
} }

47
slirp/slirp.h
View File

@ -170,6 +170,48 @@ int inet_aton(const char *cp, struct in_addr *ia);
/* osdep.c */ /* osdep.c */
int qemu_socket(int domain, int type, int protocol); int qemu_socket(int domain, int type, int protocol);
#define ETH_ALEN 6
#define ETH_HLEN 14
#define ETH_P_IP 0x0800 /* Internet Protocol packet */
#define ETH_P_ARP 0x0806 /* Address Resolution packet */
#define ARPOP_REQUEST 1 /* ARP request */
#define ARPOP_REPLY 2 /* ARP reply */
struct ethhdr {
unsigned char h_dest[ETH_ALEN]; /* destination eth addr */
unsigned char h_source[ETH_ALEN]; /* source ether addr */
unsigned short h_proto; /* packet type ID field */
};
struct arphdr {
unsigned short ar_hrd; /* format of hardware address */
unsigned short ar_pro; /* format of protocol address */
unsigned char ar_hln; /* length of hardware address */
unsigned char ar_pln; /* length of protocol address */
unsigned short ar_op; /* ARP opcode (command) */
/*
* Ethernet looks like this : This bit is variable sized however...
*/
unsigned char ar_sha[ETH_ALEN]; /* sender hardware address */
uint32_t ar_sip; /* sender IP address */
unsigned char ar_tha[ETH_ALEN]; /* target hardware address */
uint32_t ar_tip; /* target IP address */
} __attribute__((packed));
#define ARP_TABLE_SIZE 16
typedef struct ArpTable {
struct arphdr table[ARP_TABLE_SIZE];
int next_victim;
} ArpTable;
void arp_table_add(Slirp *slirp, int ip_addr, uint8_t ethaddr[ETH_ALEN]);
bool arp_table_search(Slirp *slirp, int in_ip_addr,
uint8_t out_ethaddr[ETH_ALEN]);
struct Slirp { struct Slirp {
QTAILQ_ENTRY(Slirp) entry; QTAILQ_ENTRY(Slirp) entry;
@ -181,9 +223,6 @@ struct Slirp {
struct in_addr vdhcp_startaddr; struct in_addr vdhcp_startaddr;
struct in_addr vnameserver_addr; struct in_addr vnameserver_addr;
/* ARP cache for the guest IP addresses (XXX: allow many entries) */
uint8_t client_ethaddr[6];
struct in_addr client_ipaddr; struct in_addr client_ipaddr;
char client_hostname[33]; char client_hostname[33];
@ -227,6 +266,8 @@ struct Slirp {
char *tftp_prefix; char *tftp_prefix;
struct tftp_session tftp_sessions[TFTP_SESSIONS_MAX]; struct tftp_session tftp_sessions[TFTP_SESSIONS_MAX];
ArpTable arp_table;
void *opaque; void *opaque;
}; };