From patchwork Mon Mar 11 18:26:17 2013 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: Guillaume Subiron X-Patchwork-Id: 226640 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Received: from lists.gnu.org (lists.gnu.org [208.118.235.17]) (using TLSv1 with cipher AES256-SHA (256/256 bits)) (Client did not present a certificate) by ozlabs.org (Postfix) with ESMTPS id 199472C02A0 for ; Tue, 12 Mar 2013 05:26:58 +1100 (EST) Received: from localhost ([::1]:38258 helo=lists.gnu.org) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1UF7R1-0000eW-TJ for incoming@patchwork.ozlabs.org; Mon, 11 Mar 2013 14:26:55 -0400 Received: from eggs.gnu.org ([208.118.235.92]:35864) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1UF7QZ-0000eM-PL for qemu-devel@nongnu.org; Mon, 11 Mar 2013 14:26:33 -0400 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1UF7QS-0006vi-Tw for qemu-devel@nongnu.org; Mon, 11 Mar 2013 14:26:27 -0400 Received: from galactus.lahouze.org ([88.191.120.158]:37560) by eggs.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1UF7QS-0006u6-Dn for qemu-devel@nongnu.org; Mon, 11 Mar 2013 14:26:20 -0400 Received: by galactus.lahouze.org (Postfix, from userid 1001) id 02AF9200B2; Mon, 11 Mar 2013 19:26:17 +0100 (CET) Date: Mon, 11 Mar 2013 19:26:17 +0100 From: Guillaume Subiron To: qemu-devel@nongnu.org Message-ID: <20130311182617.GA20436@subiron.org> MIME-Version: 1.0 Content-Disposition: inline User-Agent: Mutt/1.5.20 (2009-06-14) X-detected-operating-system: by eggs.gnu.org: GNU/Linux 2.6.x X-Received-From: 88.191.120.158 Cc: jan.kiszka@siemens.com, ped@listes.subiron.org Subject: [Qemu-devel] [RFC] slirp: Adding IPv6 NDP autoconfiguration X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.14 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: qemu-devel-bounces+incoming=patchwork.ozlabs.org@nongnu.org Sender: qemu-devel-bounces+incoming=patchwork.ozlabs.org@nongnu.org Hi, We are developing IPv6 in Qemu -net user case, starting with ICMPv6 NDP. With this patch, a Debian guest can perform autoconfiguration using NDP. We have added a full IPv6->ICMPv6->NDP stack starting from slirp_input and based on slirp IPv6 implementation. In the end, SLIRP responds to Router Solicitations by sending the fc00:: prefix in a Router Advertisement and the host computes a global IPv6. SLIRP also responds to Neighbor Solicitations, of course. The next thing is to send Neighbor Solicitations when if_encap needs an IPv6 that is not in ndp_table, similarly to ARP. This patch will be cut into 2 subpatchs to follow the submit rules of Qemu (refactoring, then the NDP feature), but we'd like to get some feedback on the general approach, to know if we are going in the good direction. Our next goals are to develop ICMPv6 router ping (not external ping) and to adapt UDP. diff --git a/roms/seabios b/roms/seabios --- a/roms/seabios +++ b/roms/seabios @@ -1 +1 @@ -Subproject commit 4bd8aebf3534e10d9aa21e820903f2cf9120708c +Subproject commit 4bd8aebf3534e10d9aa21e820903f2cf9120708c-dirty diff --git a/roms/vgabios b/roms/vgabios --- a/roms/vgabios +++ b/roms/vgabios @@ -1 +1 @@ -Subproject commit 19ea12c230ded95928ecaef0db47a82231c2e485 +Subproject commit 19ea12c230ded95928ecaef0db47a82231c2e485-dirty diff --git a/slirp/Makefile.objs b/slirp/Makefile.objs index 2daa9dc..08ed5d8 100644 --- a/slirp/Makefile.objs +++ b/slirp/Makefile.objs @@ -1,3 +1,3 @@ -common-obj-y = cksum.o if.o ip_icmp.o ip_input.o ip_output.o dnssearch.o +common-obj-y = cksum.o if.o ip_icmp.o icmp6.o ip6_input.o ip6_output.o ip_input.o ip_output.o dnssearch.o common-obj-y += slirp.o mbuf.o misc.o sbuf.o socket.o tcp_input.o tcp_output.o -common-obj-y += tcp_subr.o tcp_timer.o udp.o bootp.o tftp.o arp_table.o +common-obj-y += tcp_subr.o tcp_timer.o udp.o bootp.o tftp.o arp_table.o ndp_table.o diff --git a/slirp/cksum.c b/slirp/cksum.c index 6328660..913dd7d 100644 --- a/slirp/cksum.c +++ b/slirp/cksum.c @@ -137,3 +137,28 @@ cont: REDUCE; return (~sum & 0xffff); } + +int ip6_cksum(struct mbuf *m) +{ + struct ip6 save_ip, *ip = mtod(m, struct ip6 *); + struct ip6_pseudohdr *ih = mtod(m, struct ip6_pseudohdr *); + int sum; + + save_ip = *ip; + + ih->ih_src = save_ip.ip_src; + ih->ih_dst = save_ip.ip_dst; + ih->ih_pl = htonl((uint32_t)ntohs(save_ip.ip_pl)); + ih->ih_zero_hi = 0; + ih->ih_zero_lo = 0; + ih->ih_nh = save_ip.ip_nh; + + sum = cksum(m, ((int)sizeof(struct ip6_pseudohdr)) + + ntohl(ih->ih_pl)); + + *ip = save_ip; + + return sum; +} + + diff --git a/slirp/icmp6.c b/slirp/icmp6.c new file mode 100644 index 0000000..64fb015 --- /dev/null +++ b/slirp/icmp6.c @@ -0,0 +1,281 @@ +#include "slirp.h" +#include "icmp6.h" + +/* emulated hosts use the MAC addr 52:55:IP:IP:IP:IP */ +static const uint8_t special_ethaddr[ETH_ALEN] = { + 0x52, 0x55, 0x00, 0x00, 0x00, 0x00 +}; + +void icmp6_init(Slirp *slirp) +{ + slirp->icmp6.so_next = slirp->icmp6.so_prev = &slirp->icmp6; + slirp->icmp6_last_so = &slirp->icmp6; +} + +void icmp6_cleanup(Slirp *slirp) +{ + while (slirp->icmp6.so_next != &slirp->icmp6) { + icmp6_detach(slirp->icmp6.so_next); + } +} + +void icmp6_detach(struct socket *so) +{ + closesocket(so->s); + sofree(so); +} + +static void ndp_input(struct mbuf *m, Slirp *slirp, struct ip6 *ip, + struct icmp6 *icmp) +{ + m->m_len += ETH_HLEN; + m->m_data -= ETH_HLEN; + struct ethhdr *eth = mtod(m, struct ethhdr *); + m->m_len -= ETH_HLEN; + m->m_data += ETH_HLEN; + + switch (icmp->icmp6_type) { + case ICMP6_NDP_ROUTER_SOL: + DEBUG_CALL(" type = Routeur Solicitation"); + if (ip->ip_hl == 255 + && icmp->icmp6_code == 0 + && ip->ip_pl >= ICMP6_NDP_RS_MINLEN) { + // :TODO:maethor:130308: 2 check missing + + /* Gratuitous NDP */ + ndp_table_add(slirp, ip->ip_src, eth->h_source); + + /* Build IPv6 packet */ + struct mbuf *t = m_get(slirp); + struct ip6 *rip = mtod(t, struct ip6 *); + rip->ip_src = (struct in6_addr)LINKLOCAL_ADDR; + rip->ip_dst = (struct in6_addr)ALLNODES_MULTICAST; + rip->ip_nh = IPPROTO_ICMPV6; + rip->ip_pl = htons(ICMP6_NDP_RA_MINLEN + + NDPOPT_LINKLAYER_LENGTH + + NDPOPT_PREFIXINFO_LENGTH); + t->m_len = sizeof(struct ip6) + ntohs(rip->ip_pl); + + /* Build ICMPv6 packet */ + t->m_data += sizeof(struct ip6); + struct icmp6 *ricmp = mtod(t, struct icmp6 *); + ricmp->icmp6_type = ICMP6_NDP_ROUTER_ADV; + ricmp->icmp6_code = 0; + ricmp->icmp6_cksum = 0; + + /* NDP */ + ricmp->icmp6_nra.chl = NDP_AdvCurHopLimit; + ricmp->icmp6_nra.M = NDP_AdvManagedFlag; + ricmp->icmp6_nra.O = NDP_AdvOtherConfigFlag; + ricmp->icmp6_nra.reserved = 0; + ricmp->icmp6_nra.lifetime = htons(NDP_AdvDefaultLifetime); + ricmp->icmp6_nra.reach_time = htonl(NDP_AdvReachableTime); + ricmp->icmp6_nra.retrans_time = htonl(NDP_AdvRetransTime); + + /* Source link-layer address (NDP option) */ + t->m_data += ICMP6_NDP_RA_MINLEN; + struct ndpopt *opt = mtod(t, struct ndpopt *); + opt->ndpopt_type = NDPOPT_LINKLAYER_SOURCE; + opt->ndpopt_len = NDPOPT_LINKLAYER_LENGTH / 8; + memcpy(opt->ndpopt_linklayer, special_ethaddr, ETH_ALEN - 4); + memcpy(&opt->ndpopt_linklayer[2], &slirp->vhost_addr, 4); + + /* Prefix information (NDP option) */ + t->m_data += NDPOPT_LINKLAYER_LENGTH; + struct ndpopt *opt2 = mtod(t, struct ndpopt *); + opt2->ndpopt_type = NDPOPT_PREFIX_INFO; + opt2->ndpopt_len = NDPOPT_PREFIXINFO_LENGTH / 8; + opt2->ndpopt_prefixinfo.prefix_length = slirp->vprefix_len; + opt2->ndpopt_prefixinfo.L = 1; + opt2->ndpopt_prefixinfo.A = 1; + opt2->ndpopt_prefixinfo.reserved1 = 0; + opt2->ndpopt_prefixinfo.valid_lt = htonl(NDP_AdvValidLifetime); + opt2->ndpopt_prefixinfo.pref_lt = htonl(NDP_AdvPrefLifetime); + opt2->ndpopt_prefixinfo.reserved2 = 0; + opt2->ndpopt_prefixinfo.prefix = slirp->vprefix_addr6; + + /* ICMPv6 Checksum */ + t->m_data -= NDPOPT_LINKLAYER_LENGTH; + t->m_data -= ICMP6_NDP_RA_MINLEN; + t->m_data -= sizeof(struct ip6); + ricmp->icmp6_cksum = ip6_cksum(t); + + ip6_output(NULL, t); + } + break; + + case ICMP6_NDP_ROUTER_ADV: + DEBUG_CALL(" type = Routeur Advertisement"); + fprintf(stderr, + "Warning: guest sent NDP RA, but shouldn't\n"); + break; + + case ICMP6_NDP_NEIGH_SOL: + DEBUG_CALL(" type = Neighbor Solicitation"); + if (ip->ip_hl == 255 + && icmp->icmp6_code == 0 + && !in6_multicast(icmp->icmp6_nns.target) + && ip->ip_pl >= ICMP6_NDP_NS_MINLEN + && (!in6_unspecified(ip->ip_src) + || in6_multicast(ip->ip_dst))) { + // :TODO:maethor:130308: 1 check missing + if (in6_equal_host(icmp->icmp6_nns.target)) { + + /* Gratuitous NDP */ + ndp_table_add(slirp, ip->ip_src, eth->h_source); + + /* Build IPv6 packet */ + struct mbuf *t = m_get(slirp); + struct ip6 *rip = mtod(t, struct ip6 *); + rip->ip_src = icmp->icmp6_nns.target; + if (in6_unspecified(ip->ip_src)) { + rip->ip_dst = (struct in6_addr)ALLNODES_MULTICAST; + } else { + rip->ip_dst = ip->ip_src; + } + rip->ip_nh = IPPROTO_ICMPV6; + rip->ip_pl = htons(ICMP6_NDP_NA_MINLEN + NDPOPT_LINKLAYER_LENGTH); + t->m_len = sizeof(struct ip6) + ntohs(rip->ip_pl); + + /* Build ICMPv6 packet */ + t->m_data += sizeof(struct ip6); + struct icmp6 *ricmp = mtod(t, struct icmp6 *); + ricmp->icmp6_type = ICMP6_NDP_NEIGH_ADV; + ricmp->icmp6_code = 0; + ricmp->icmp6_cksum = 0; + + /* NDP */ + ricmp->icmp6_nna.R = NDP_IsRouter; + ricmp->icmp6_nna.S = !in6_multicast(rip->ip_dst); + ricmp->icmp6_nna.O = 1; + ricmp->icmp6_nna.reserved_hi = 0; + ricmp->icmp6_nna.reserved_lo = 0; + ricmp->icmp6_nna.target = icmp->icmp6_nns.target; + + /* Build NDP option */ + t->m_data += ICMP6_NDP_NA_MINLEN; + struct ndpopt *opt = mtod(t, struct ndpopt *); + opt->ndpopt_type = NDPOPT_LINKLAYER_TARGET; + opt->ndpopt_len = NDPOPT_LINKLAYER_LENGTH / 8; + memcpy(opt->ndpopt_linklayer, special_ethaddr, ETH_ALEN - 4); + memcpy(&opt->ndpopt_linklayer[2], &slirp->vhost_addr, 4); + + /* ICMPv6 Checksum */ + t->m_data -= ICMP6_NDP_NA_MINLEN; + t->m_data -= sizeof(struct ip6); + ricmp->icmp6_cksum = ip6_cksum(t); + + ip6_output(NULL, t); + } + } + break; + + case ICMP6_NDP_NEIGH_ADV: + DEBUG_CALL(" type = Neighbor Advertisement"); + if (ip->ip_hl == 255 + && icmp->icmp6_code == 0 + && ip->ip_pl >= ICMP6_NDP_NA_MINLEN + && !in6_multicast(icmp->icmp6_nna.target) + && (!in6_multicast(ip->ip_dst) || icmp->icmp6_nna.S == 0)) { + ndp_table_add(slirp, ip->ip_src, eth->h_source); + } + break; + + case ICMP6_NDP_REDIRECT: + DEBUG_CALL(" type = Redirect"); + fprintf(stderr, + "Warning: guest sent NDP REDIRECT, but shouldn't\n"); + break; + + default: + return; + } + return; +} + +/* + * Process a received ICMPv6 message. + */ +void icmp6_input(struct mbuf *m) +{ + struct icmp6 *icmp; + struct ip6 *ip=mtod(m, struct ip6 *); + Slirp *slirp = m->slirp; + int hlen = sizeof(struct ip6); + + DEBUG_CALL("icmp6_input"); + DEBUG_ARG("m = %lx", (long )m); + DEBUG_ARG("m_len = %d", m->m_len); + + if (ip->ip_pl < ICMP6_MINLEN) { + goto end; + } + + if (ip6_cksum(m)) { + goto end; + } + + m->m_len -= hlen; + m->m_data += hlen; + icmp = mtod(m, struct icmp6 *); + m->m_len += hlen; + m->m_data -= hlen; + + DEBUG_ARG("icmp6_type = %d", icmp->icmp6_type); + switch (icmp->icmp6_type) { + case ICMP6_NDP_ROUTER_SOL: + case ICMP6_NDP_ROUTER_ADV: + case ICMP6_NDP_NEIGH_SOL: + case ICMP6_NDP_NEIGH_ADV: + case ICMP6_NDP_REDIRECT: + ndp_input(m, slirp, ip, icmp); + break; + + case ICMP6_UNREACH: + case ICMP6_TOOBIG: + case ICMP6_TIMXCEED: + case ICMP6_PARAMPROB: + /* XXX? report error? close socket? */ + default: + break; + } /* swith */ + +end: + m_free(m); + return; +} + +void icmp6_receive(struct socket *so) +{ + struct mbuf *m = so->so_m; + int hlen = sizeof(struct ip6); + /*u_char error_code;*/ + struct icmp6 *icmp; + int len; + + m->m_data += hlen; + m->m_len -= hlen; + icmp = mtod(m, struct icmp6 *); + + len = qemu_recv(so->s, icmp, m->m_len, 0); + + m->m_data -= hlen; + m->m_len += hlen; + + if (len == -1 || len == 0) { + /* + if (errno == ENETUNREACH) { + error_code = ICMP_UNREACH_NET; + } else { + error_code = ICMP_UNREACH_HOST; + } + DEBUG_MISC((dfd, " udp icmp rx errno = %d-%s\n", errno, + strerror(errno))); + icmp_error(so->so_m, ICMP_UNREACH, error_code, 0, strerror(errno)); + */ + } else { + /*icmp_reflect(so->so_m);*/ + so->so_m = NULL; /* Don't m_free() it again! */ + } + icmp6_detach(so); +} diff --git a/slirp/icmp6.h b/slirp/icmp6.h new file mode 100644 index 0000000..7c6f253 --- /dev/null +++ b/slirp/icmp6.h @@ -0,0 +1,234 @@ +#ifndef _NETINET_ICMP6_H_ +#define _NETINET_ICMP6_H_ + +/* + * Interface Control Message Protocol version 6 Definitions. + * Per RFC 4443, March 2006. + */ + +typedef uint32_t n_time; + +/* + * NDP Messages + */ +struct ndp_router_sol { + uint32_t reserved; +}; + +struct ndp_router_adv { + uint8_t chl; /* Cur Hop Limit */ +#ifdef HOST_WORDS_BIGENDIAN + uint8_t + M:1, + O:1, + reserved:6; +#else + uint8_t + reserved:6, + O:1, + M:1; +#endif + uint16_t lifetime; /* Router Lifetime */ + uint32_t reach_time; /* Reachable Time */ + uint32_t retrans_time; /* Retrans Timer */ +} QEMU_PACKED; + +struct ndp_neigh_sol { + uint32_t reserved; + struct in6_addr target; /* Target Address */ +} QEMU_PACKED; + +struct ndp_neigh_adv { +#ifdef HOST_WORDS_BIGENDIAN + uint32_t + R:1, /* Router Flag */ + S:1, /* Solicited Flag */ + O:1, /* Override Flag */ + reserved_hi:5, + reserved_lo:24; +#else + uint32_t + reserved_hi:5, + O:1, + S:1, + R:1, + reserved_lo:24; +#endif + struct in6_addr target; /* Target Address */ +} QEMU_PACKED; + +struct ndp_redirect { + uint32_t reserved; + struct in6_addr target; /* Target Address */ + struct in6_addr dest; /* Destination Address */ +} QEMU_PACKED; + +/* + * Structure of an icmpv6 header. + */ +struct icmp6 { + uint8_t icmp6_type; /* type of message, see below */ + uint8_t icmp6_code; /* type sub code */ + uint16_t icmp6_cksum; /* ones complement cksum of struct */ + union { + struct ndp_router_sol ndp_router_sol; + struct ndp_router_adv ndp_router_adv; + struct ndp_neigh_sol ndp_neigh_sol; + struct ndp_neigh_adv ndp_neigh_adv; + struct ndp_redirect ndp_redirect; + } icmp6_body; +#define icmp6_nrs icmp6_body.ndp_router_sol +#define icmp6_nra icmp6_body.ndp_router_adv +#define icmp6_nns icmp6_body.ndp_neigh_sol +#define icmp6_nna icmp6_body.ndp_neigh_adv +#define icmp6_redirect icmp6_body.ndp_redirect +} QEMU_PACKED; + +/* + * icmp6 + ip6 pseudo-header, used to compute et verify checksum. + */ +struct icmp6ip6 { + struct ip6_pseudohdr ip6; /* overlaid ip structure */ + struct icmp6 icmp6; /* tcp header */ +}; + + +#define ICMP6_MINLEN 4 /* abs minimum: 32 bits */ +#define ICMP6_NDP_RS_MINLEN 8 +#define ICMP6_NDP_RA_MINLEN 16 +#define ICMP6_NDP_NS_MINLEN 24 +#define ICMP6_NDP_NA_MINLEN 24 +#define ICMP6_NDP_REDIRECT_MINLEN 40 + +struct ndpopt { + uint8_t ndpopt_type; /* Option type */ + uint8_t ndpopt_len; /* /!\ In units of 8 octets */ + union { + unsigned char linklayer_addr[6]; /* Source/Target Link-layer */ + struct prefixinfo { /* Prefix Information */ + uint8_t prefix_length; +#ifdef HOST_WORDS_BIGENDIAN + uint8_t L:1, A:1, reserved1:6; +#else + uint8_t reserved1:6, A:1, L:1; +#endif + uint32_t valid_lt; /* Valid Lifetime */ + uint32_t pref_lt; /* Preferred Lifetime */ + uint32_t reserved2; + struct in6_addr prefix; + } QEMU_PACKED prefixinfo; + } ndpopt_body; +#define ndpopt_linklayer ndpopt_body.linklayer_addr +#define ndpopt_prefixinfo ndpopt_body.prefixinfo +} QEMU_PACKED; + +/* NDP options type */ +#define NDPOPT_LINKLAYER_SOURCE 1 /* Source Link-Layer Address */ +#define NDPOPT_LINKLAYER_TARGET 2 /* Target Link-Layer Address */ +#define NDPOPT_PREFIX_INFO 3 /* Prefix Information */ +#define NDPOPT_REDIRECTED_HDR 4 /* Redirected Header */ +#define MTU 5 /* MTU */ + +/* NDP options size, in octets. */ +#define NDPOPT_LINKLAYER_LENGTH 8 +#define NDPOPT_PREFIXINFO_LENGTH 32 + +/* + * Definition of type and code field values. + * Per https://www.iana.org/assignments/icmpv6-parameters/icmpv6-parameters.xml + * Last Updated 2012-11-12 + */ + +/* Errors */ +#define ICMP6_UNREACH 1 /* Destination Unreachable */ +#define ICMP6_UNREACH_NO_ROUTE 0 /* no route to dest */ +#define ICMP6_UNREACH_DEST_PROHIB 1 /* com with dest prohibited */ +#define ICMP6_UNREACH_SCOPE 2 /* beyond scope of src addr */ +#define ICMP6_UNREACH_ADDRESS 3 /* address unreachable */ +#define ICMP6_UNREACH_PORT 4 /* port unreachable */ +#define ICMP6_UNREACH_SRC_FAIL 5 /* src addr failed */ +#define ICMP6_UNREACH_REJECT_ROUTE 6 /* reject route to dest */ +#define ICMP6_UNREACH_SRC_HDR_ERROR 7 /* error in src routing header */ +#define ICMP6_TOOBIG 2 /* Packet Too Big */ +#define ICMP6_TIMXCEED 3 /* Time Exceeded */ +#define ICMP6_TIMXCEED_INTRANS 0 /* hop limit exceeded in transit */ +#define ICMP6_TIMXCEED_REASS 1 /* ttl=0 in reass */ +#define ICMP6_PARAMPROB 4 /* Parameter Problem */ +#define ICMP6_PARAMPROB_HDR_FIELD 0 /* err header field */ +#define ICMP6_PARAMPROB_NXTHDR_TYPE 1 /* unrecognized Next Header type */ +#define ICMP6_PARAMPROB_IPV6_OPT 2 /* unrecognized IPv6 option */ + +/* Informational Messages */ +#define ICMP6_ECHO_REQUEST 128 /* Echo Request */ +#define ICMP6_ECHO_REPLY 129 /* Echo Reply */ +#define ICMP6_MCASTLST_QUERY 130 /* Multicast Listener Query */ +#define ICMP6_MCASTLST_REPORT 131 /* Multicast Listener Report */ +#define ICMP6_MCASTLST_DONE 132 /* Multicast Listener Done */ +#define ICMP6_NDP_ROUTER_SOL 133 /* Router Solicitation (NDP) */ +#define ICMP6_NDP_ROUTER_ADV 134 /* Router Advertisement (NDP) */ +#define ICMP6_NDP_NEIGH_SOL 135 /* Neighbor Solicitation (NDP) */ +#define ICMP6_NDP_NEIGH_ADV 136 /* Neighbor Advertisement (NDP) */ +#define ICMP6_NDP_REDIRECT 137 /* Redirect Message (NDP) */ +#define ICMP6_ROUTERRENUM 138 /* Router Renumbering */ +#define ICMP6_ROUTERRENUM_COMMAND 0 /* router renum command */ +#define ICMP6_ROUTERRENUM_RESULT 1 /* router renum result */ +#define ICMP6_ROUTERRENUM_RESET 255 /* sequence number reset */ +#define ICMP6_NODEINFO_QUERY 139 /* ICMP Node Information Query */ +#define ICMP6_NODEINFO_QUERY_IPV6 0 /* subject is an IPv6 */ +#define ICMP6_NODEINFO_QUERY_NAME 1 /* subj is a name (or empty) */ +#define ICMP6_NODEINFO_QUERY_IPV4 2 /* subject is an IPv4 */ +#define ICMP6_NODEINFO_RESP 140 /* ICMP Node Information Response */ +#define ICMP6_NODEINFO_RESP_SUCCESS 0 /* successful reply */ +#define ICMP6_NODEINFO_RESP_REFUSAL 1 /* refuses to supply answer */ +#define ICMP6_NODEINFO_RESP_UNKNOWN 2 /* Qtype unknown to the resp */ +#define ICMP6_IND_SOL 141 /* Inverse Neighbor Discovery Solicitation */ +#define ICMP6_IND_ADV 142 /* Inverse Neighbor Discovery Advertisement */ +#define ICMP6_MLD 143 /* Multicast Listener Discovery reports */ +#define ICMP6_HAAD_REQUEST 144 /* Home Agent Address Discovery Request */ +#define ICMP6_HAAD_REPLY 145 /* Home Agent Address Discovery Reply */ +#define ICMP6_MP_SOL 146 /* Mobile Prefix Solicitation */ +#define ICMP6_MP_ADV 147 /* Mobile Prefix Advertisement */ +#define ICMP6_SEND_CP_SOL 148 /* Certification Path Solicitation (SEND) */ +#define ICMP6_SEND_CP_ADV 149 /* Certification Path Advertisement (SEND) */ +#define ICMP6_MRD_ADV 151 /* Multicast Router Advertisement (MRD) */ +#define ICMP6_MRD_SOL 152 /* Multicast Router Solicitation (MRD) */ +#define ICMP6_MRD_TERM 153 /* Multicast Router Termination (MRD) */ +#define ICMP6_FMIP6 154 /* FMIPv6 Messages */ +#define ICMP6_FMIP6_RTSOLPR 2 /* RtSolPr */ +#define ICMP6_FMIP6_PRRTADV 3 /* PrRtAdv */ +#define ICMP6_RPL_CONTROL 155 /* RPL Control Message */ +#define ICMP6_ILNP6_LU 156 /* ILNPv6 Locator Update Message */ +#define ICMP6_DUPADDR_REQUEST 157 /* Duplicate Address Request */ +#define ICMP6_DUPADDR_CONFIRM 158 /* Duplicate Address Confirmation */ + +#define ICMP6_INFOTYPE(type) ((type) >= 128) + +/* Router Configuration Variables (rfc4861#section-6) */ +#define NDP_IsRouter 1 +#define NDP_AdvSendAdvertisements 1 +#define NDP_MaxRtrAdvInterval 600 +#define NDP_MinRtrAdvInterval ((NDP_MaxRtrAdvInterval>=9)?\ + 0.33*NDP_MaxRtrAdvInterval:9) +#define NDP_AdvManagedFlag 0 +#define NDP_AdvOtherConfigFlag 0 +#define NDP_AdvLinkMTU 0 +#define NDP_AdvReachableTime 0 +#define NDP_AdvRetransTime 0 +#define NDP_AdvCurHopLimit 64 +#define NDP_AdvDefaultLifetime (3 * NDP_MaxRtrAdvInterval) +#define NDP_AdvValidLifetime 86400 +#define NDP_AdvOnLinkFlag 1 +#define NDP_AdvPrefLifetime 14400 +#define NDP_AdvAutonomousFlag 1 + +void icmp6_init(Slirp *slirp); +void icmp6_cleanup(Slirp *slirp); +void icmp6_input(struct mbuf *); +void icmp6_error(struct mbuf *msrc, u_char type, u_char code, int minsize, + const char *message); +// :TODO:maethor:130307: +//void icmp6_reflect(struct mbuf *); +void icmp6_receive(struct socket *so); +void icmp6_detach(struct socket *so); + +#endif diff --git a/slirp/if.c b/slirp/if.c index dcd5faf..a957ce2 100644 --- a/slirp/if.c +++ b/slirp/if.c @@ -158,7 +158,7 @@ void if_start(Slirp *slirp) bool from_batchq, next_from_batchq; struct mbuf *ifm, *ifm_next, *ifqt; - DEBUG_CALL("if_start"); + /*DEBUG_CALL("if_start");*/ if (slirp->if_start_busy) { return; @@ -193,7 +193,7 @@ void if_start(Slirp *slirp) /* Try to send packet unless it already expired */ if (ifm->expiration_date >= now && !if_encap(slirp, ifm)) { - /* Packet is delayed due to pending ARP resolution */ + /* Packet is delayed due to pending ARP or NDP resolution */ continue; } diff --git a/slirp/ip6.h b/slirp/ip6.h new file mode 100644 index 0000000..c853cd7 --- /dev/null +++ b/slirp/ip6.h @@ -0,0 +1,98 @@ +#ifndef _IP6_H_ +#define _IP6_H_ + +#define in6_multicast(a) IN6_IS_ADDR_MULTICAST(&(a)) +#define in6_linklocal(a) IN6_IS_ADDR_LINKLOCAL(&(a)) +#define in6_unspecified(a) IN6_IS_ADDR_UNSPECIFIED(&(a)) + +#define ALLNODES_MULTICAST { .s6_addr = \ + { 0xff, 0x02, 0x00, 0x00,\ + 0x00, 0x00, 0x00, 0x00,\ + 0x00, 0x00, 0x00, 0x00,\ + 0x00, 0x00, 0x00, 0x01 } } + +#define LINKLOCAL_ADDR { .s6_addr = \ + { 0xfe, 0x80, 0x00, 0x00,\ + 0x00, 0x00, 0x00, 0x00,\ + 0x00, 0x00, 0x00, 0x00,\ + 0x00, 0x00, 0x00, 0x01 } } + +static inline int in6_equal(struct in6_addr a, struct in6_addr b) { + return (memcmp(&a, &b, sizeof(a)) == 0); +} + +static inline int in6_equal_net(struct in6_addr a, struct in6_addr b, int prefix_len) { + if (prefix_len % 8) { + assert(0); // ::TODO:maethor:130311: Manage this case + } else { + return (memcmp(&a, &b, prefix_len / 8) == 0); + } +} + +static inline int in6_equal_mach(struct in6_addr a, struct in6_addr b, int prefix_len) { + if (prefix_len % 8) { + assert(0); // :TODO:maethor:130311: Manage this case + } else { + return (memcmp(&(a.s6_addr[prefix_len / 8]), + &(b.s6_addr[prefix_len / 8]), 16 - prefix_len / 8) == 0); + } +} + +#define in6_equal_router(a)\ + ((in6_equal_net(a, slirp->vprefix_addr6, slirp->vprefix_len)\ + || in6_equal_net(a, (struct in6_addr)LINKLOCAL_ADDR, 64))\ + && in6_equal_mach(a, slirp->vhost_addr6, slirp->vprefix_len)) + +#define in6_equal_dns(a) 0 + +#define in6_equal_host(a)\ + (in6_equal_router(a) || in6_equal_dns(a)) + +typedef uint32_t n_long; /* long as received from the net */ + +/* + * Definitions for internet protocol version 6. + * Per RFC 2460, December 1998. + */ +#define IP6VERSION 6 +#define IP6_HOP_LIMIT 255 + +/* + * Structure of an internet header, naked of options. + */ +struct ip6 { +#ifdef HOST_WORDS_BIGENDIAN + uint32_t + ip_v:4, /* version */ + ip_tc_hi:4, /* traffic class */ + ip_tc_lo:4, + ip_fl_hi:4, /* flow label */ + ip_fl_lo:16; +#else + uint32_t + ip_tc_hi:4, + ip_v:4, + ip_fl_hi:4, + ip_tc_lo:4, + ip_fl_lo:16; +#endif + uint16_t ip_pl; /* payload length */ + uint8_t ip_nh; /* next header */ + uint8_t ip_hl; /* hop limit */ + struct in6_addr ip_src,ip_dst; /* source and dest address */ +} QEMU_PACKED; + +/* + * IPv6 pseudo-header used by upper-layer protocols + */ +struct ip6_pseudohdr { + struct in6_addr ih_src; /* source internet address */ + struct in6_addr ih_dst; /* destination internet address */ + uint32_t ih_pl; /* upper-layer packet length */ + uint16_t ih_zero_hi; /* zero */ + uint8_t ih_zero_lo; /* zero */ + uint8_t ih_nh; /* next header */ +} QEMU_PACKED; + + +#endif diff --git a/slirp/ip6_input.c b/slirp/ip6_input.c new file mode 100644 index 0000000..32b4ea2 --- /dev/null +++ b/slirp/ip6_input.c @@ -0,0 +1,68 @@ +#include +#include +#include "icmp6.h" + +/* + * IP initialization: fill in IP protocol switch table. + * All protocols not implemented in kernel go to raw IP protocol handler. + */ +void ip6_init(Slirp *slirp) +{ + /*slirp->ipq.ip_link.next = slirp->ipq.ip_link.prev = &slirp->ipq.ip_link;*/ + /*udp_init(slirp);*/ + /*tcp_init(slirp);*/ + icmp6_init(slirp); +} + +void ip6_cleanup(Slirp *slirp) +{ + /*udp_cleanup(slirp);*/ + /*tcp_cleanup(slirp);*/ + icmp6_cleanup(slirp); +} + +void ip6_input(struct mbuf *m) +{ + register struct ip6 *ip6; + + DEBUG_CALL("ip6_input"); + DEBUG_ARG("m = %lx", (long)m); + DEBUG_ARG("m_len = %d", m->m_len); + + if (m->m_len < sizeof (struct ip6)) { + return; + } + + ip6 = mtod(m, struct ip6 *); + + if (ip6->ip_v != IP6VERSION) { + goto bad; + } + + /* check ip_ttl for a correct ICMP reply */ + if(ip6->ip_hl==0) { + /*icmp_error(m, ICMP_TIMXCEED,ICMP_TIMXCEED_INTRANS, 0,"ttl");*/ // :TODO:maethor:130307: + goto bad; + } + + /* + * Switch out to protocol's input routine. + */ + switch (ip6->ip_nh) { + //case IPPROTO_TCP: :TODO:maethor:130307: + // tcp_input(m, hlen, (struct socket *)NULL); + // break; + //case IPPROTO_UDP: + // udp_input(m, hlen); + // break; + case IPPROTO_ICMPV6: + icmp6_input(m); + break; + default: + m_free(m); + } + return; +bad: + m_free(m); +} + diff --git a/slirp/ip6_output.c b/slirp/ip6_output.c new file mode 100644 index 0000000..e38b421 --- /dev/null +++ b/slirp/ip6_output.c @@ -0,0 +1,29 @@ +#include + +/* Number of packets queued before we start sending + * (to prevent allocing too many mbufs) */ +#define IF6_THRESH 10 + +/* + * IPv6 output. The packet in mbuf chain m contains a IP header + */ +int ip6_output(struct socket *so, struct mbuf *m) +{ + struct ip6 *ip = mtod(m, struct ip6 *); + + DEBUG_CALL("ip6_output"); + DEBUG_ARG("so = %lx", (long)so); + DEBUG_ARG("m = %lx", (long)m); + + /* Fill IPv6 header */ + ip->ip_v = IP6VERSION; + ip->ip_hl = IP6_HOP_LIMIT; + ip->ip_tc_hi = 0; + ip->ip_tc_lo = 0; + ip->ip_fl_hi = 0; + ip->ip_fl_lo = 0; + + if_output(so, m); + + return 0; +} diff --git a/slirp/mbuf.c b/slirp/mbuf.c index 4fefb04..92c429e 100644 --- a/slirp/mbuf.c +++ b/slirp/mbuf.c @@ -91,7 +91,7 @@ m_get(Slirp *slirp) m->m_len = 0; m->m_nextpkt = NULL; m->m_prevpkt = NULL; - m->arp_requested = false; + m->resolution_requested = false; m->expiration_date = (uint64_t)-1; end_error: DEBUG_ARG("m = %lx", (long )m); diff --git a/slirp/mbuf.h b/slirp/mbuf.h index 3f3ab09..4110184 100644 --- a/slirp/mbuf.h +++ b/slirp/mbuf.h @@ -82,7 +82,7 @@ struct m_hdr { struct mbuf { struct m_hdr m_hdr; Slirp *slirp; - bool arp_requested; + bool resolution_requested; uint64_t expiration_date; /* start of dynamic buffer area, must be last element */ union M_dat { diff --git a/slirp/ndp_table.c b/slirp/ndp_table.c new file mode 100644 index 0000000..b556d25 --- /dev/null +++ b/slirp/ndp_table.c @@ -0,0 +1,79 @@ +#include "slirp.h" + +void ndp_table_add(Slirp *slirp, struct in6_addr ip_addr, + uint8_t ethaddr[ETH_ALEN]) +{ + NdpTable *ndp_table = &slirp->ndp_table; + int i; + char addrstr[INET6_ADDRSTRLEN]; + + DEBUG_CALL("ndp_table_add"); + inet_ntop(AF_INET6, &(ip_addr), addrstr, INET6_ADDRSTRLEN); + DEBUG_ARG("ip = %s", addrstr); + DEBUG_ARGS((dfd, " hw addr = %02x:%02x:%02x:%02x:%02x:%02x\n", + ethaddr[0], ethaddr[1], ethaddr[2], + ethaddr[3], ethaddr[4], ethaddr[5])); + + if (in6_multicast(ip_addr) || in6_unspecified(ip_addr)) { + /* Do not register multicast or unspecified addresses */ + DEBUG_CALL(" abort: do not register multicast or unspecified address"); + return; + } + + /* Search for an entry */ + for (i = 0; i < NDP_TABLE_SIZE; i++) { + if (in6_equal(ndp_table->table[i].ip_addr, ip_addr)) { + DEBUG_CALL(" already in table: update the entry"); + /* Update the entry */ + memcpy(ndp_table->table[i].eth_addr, ethaddr, ETH_ALEN); + return; + } + } + + /* No entry found, create a new one */ + DEBUG_CALL(" create new entry"); + ndp_table->table[ndp_table->next_victim].ip_addr = ip_addr; + memcpy(ndp_table->table[ndp_table->next_victim].eth_addr, + ethaddr, ETH_ALEN); + ndp_table->next_victim = (ndp_table->next_victim + 1) % NDP_TABLE_SIZE; +} + +bool ndp_table_search(Slirp *slirp, struct in6_addr ip_addr, + uint8_t out_ethaddr[ETH_ALEN]) +{ + NdpTable *ndp_table = &slirp->ndp_table; + int i; + char addrstr[INET6_ADDRSTRLEN]; + + DEBUG_CALL("ndp_table_search"); + inet_ntop(AF_INET6, &(ip_addr), addrstr, INET6_ADDRSTRLEN); + DEBUG_ARG("ip = %s", addrstr); + + assert(!in6_unspecified(ip_addr)); + + /* Multicast address: fc00::abcd:efgh/8 -> 33:33:ab:cd:ef:gh */ + if (in6_multicast(ip_addr)) { + out_ethaddr[0] = 0x33; out_ethaddr[1] = 0x33; + out_ethaddr[2] = ip_addr.s6_addr[12]; + out_ethaddr[3] = ip_addr.s6_addr[13]; + out_ethaddr[4] = ip_addr.s6_addr[14]; + out_ethaddr[5] = ip_addr.s6_addr[15]; + DEBUG_ARGS((dfd, " multicast 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; + } + + for (i = 0; i < NDP_TABLE_SIZE; i++) { + if (in6_equal(ndp_table->table[i].ip_addr, ip_addr)){ + memcpy(out_ethaddr, ndp_table->table[i].eth_addr, 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; + } + } + + DEBUG_CALL(" ip not found in table"); + return 0; +} diff --git a/slirp/slirp.c b/slirp/slirp.c index 0e6e232..e46212a 100644 --- a/slirp/slirp.c +++ b/slirp/slirp.c @@ -135,8 +135,10 @@ int get_dns_addr(struct in_addr *pdns_addr) } f = fopen("/etc/resolv.conf", "r"); - if (!f) + if (!f) { + fprintf(stderr, "Unable to open /etc/resolv.conf\n"); return -1; + } #ifdef DEBUG lprint("IP address of your DNS(s): "); @@ -168,8 +170,10 @@ int get_dns_addr(struct in_addr *pdns_addr) } } fclose(f); - if (!found) + if (!found) { + fprintf(stderr, "No IPv4 found in /etc/resolv.conf\n"); return -1; + } return 0; } @@ -214,6 +218,7 @@ Slirp *slirp_init(int restricted, struct in_addr vnetwork, if_init(slirp); ip_init(slirp); + ip6_init(slirp); /* Initialise mbufs *after* setting the MTU */ m_init(slirp); @@ -221,6 +226,9 @@ Slirp *slirp_init(int restricted, struct in_addr vnetwork, slirp->vnetwork_addr = vnetwork; slirp->vnetwork_mask = vnetmask; slirp->vhost_addr = vhost; + inet_pton(AF_INET6, "fc00::0", &slirp->vprefix_addr6); // :TODO:maethor:130311: Utiliser un argument passé à la fonction + slirp->vprefix_len = 64; // :TODO:maethor:130311: Utiliser un argument passé à la fonction + inet_pton(AF_INET6, "fc00::1", &slirp->vhost_addr6); // :TODO:maethor:130311: Utiliser un argument passé à la fonction if (vhostname) { pstrcpy(slirp->client_hostname, sizeof(slirp->client_hostname), vhostname); @@ -251,6 +259,7 @@ void slirp_cleanup(Slirp *slirp) unregister_savevm(NULL, "slirp", slirp); ip_cleanup(slirp); + ip6_cleanup(slirp); m_cleanup(slirp); g_free(slirp->vdnssearch); @@ -413,6 +422,31 @@ void slirp_select_fill(int *pnfds, UPD_NFDS(so->s); } } + + /* + * ICMPv6 sockets + */ + for (so = slirp->icmp6.so_next; so != &slirp->icmp6; + so = so_next) { + so_next = so->so_next; + + /* + * See if it's timed out + */ + if (so->so_expire) { + if (so->so_expire <= curtime) { + icmp6_detach(so); + continue; + } else { + do_slowtimo = 1; /* Let socket expire */ + } + } + + if (so->so_state & SS_ISFCONNECTED) { + FD_SET(so->s, readfds); + UPD_NFDS(so->s); + } + } } *pnfds = nfds; @@ -594,6 +628,18 @@ void slirp_select_poll(fd_set *readfds, fd_set *writefds, fd_set *xfds, icmp_receive(so); } } + + /* + * Check incoming ICMPv6 relies. + */ + for (so = slirp->icmp6.so_next; so != &slirp->icmp6; + so = so_next) { + so_next = so->so_next; + + if (so->s != -1 && FD_ISSET(so->s, readfds)) { + icmp6_receive(so); + } + } } if_start(slirp); @@ -682,6 +728,7 @@ void slirp_input(Slirp *slirp, const uint8_t *pkt, int pkt_len) arp_input(slirp, pkt, pkt_len); break; case ETH_P_IP: + case ETH_P_IP6: m = m_get(slirp); if (!m) return; @@ -695,8 +742,13 @@ void slirp_input(Slirp *slirp, const uint8_t *pkt, int pkt_len) m->m_data += 2 + ETH_HLEN; m->m_len -= 2 + ETH_HLEN; + if (proto == ETH_P_IP) { ip_input(m); + } else if (proto == ETH_P_IP6) { + ip6_input(m); + } break; + default: break; } @@ -707,21 +759,26 @@ void slirp_input(Slirp *slirp, const uint8_t *pkt, int pkt_len) */ int if_encap(Slirp *slirp, struct mbuf *ifm) { + DEBUG_CALL("if_encap"); uint8_t buf[1600]; struct ethhdr *eh = (struct ethhdr *)buf; uint8_t ethaddr[ETH_ALEN]; const struct ip *iph = (const struct ip *)ifm->m_data; + const struct ip6 *ip6h = mtod(ifm, const struct ip6 *); + char addrstr[INET6_ADDRSTRLEN]; if (ifm->m_len + ETH_HLEN > sizeof(buf)) { return 1; } + switch (iph->ip_v) { + case IPVERSION: if (!arp_table_search(slirp, iph->ip_dst.s_addr, ethaddr)) { uint8_t arp_req[ETH_HLEN + sizeof(struct arphdr)]; struct ethhdr *reh = (struct ethhdr *)arp_req; struct arphdr *rah = (struct arphdr *)(arp_req + ETH_HLEN); - if (!ifm->arp_requested) { + if (!ifm->resolution_requested) { /* If the client addr is not known, send an ARP request */ memset(reh->h_dest, 0xff, ETH_ALEN); memcpy(reh->h_source, special_ethaddr, ETH_ALEN - 4); @@ -747,23 +804,47 @@ int if_encap(Slirp *slirp, struct mbuf *ifm) rah->ar_tip = iph->ip_dst.s_addr; slirp->client_ipaddr = iph->ip_dst; slirp_output(slirp->opaque, arp_req, sizeof(arp_req)); - ifm->arp_requested = true; + ifm->resolution_requested = true; /* Expire request and drop outgoing packet after 1 second */ ifm->expiration_date = qemu_get_clock_ns(rt_clock) + 1000000000ULL; } return 0; } else { + eh->h_proto = htons(ETH_P_IP); + break; + } + + case IP6VERSION: + inet_ntop(AF_INET6, &(ip6h->ip_dst), addrstr, INET6_ADDRSTRLEN); + if (!ndp_table_search(slirp, ip6h->ip_dst, ethaddr)) { + // :TODO:maethor:130311: NS + return 0; + } else { + eh->h_proto = htons(ETH_P_IP6); + } + break; + + default: + assert(0); + break; + } + memcpy(eh->h_dest, ethaddr, ETH_ALEN); memcpy(eh->h_source, special_ethaddr, ETH_ALEN - 4); /* XXX: not correct */ memcpy(&eh->h_source[2], &slirp->vhost_addr, 4); - eh->h_proto = htons(ETH_P_IP); + DEBUG_ARGS((dfd, " SOURCE = %02x:%02x:%02x:%02x:%02x:%02x\n", + eh->h_source[0], eh->h_source[1], eh->h_source[2], + eh->h_source[3], eh->h_source[4], eh->h_source[5])); + DEBUG_ARGS((dfd, " DEST = %02x:%02x:%02x:%02x:%02x:%02x\n", + eh->h_dest[0], eh->h_dest[1], eh->h_dest[2], + eh->h_dest[3], eh->h_dest[4], eh->h_dest[5])); memcpy(buf + sizeof(struct ethhdr), ifm->m_data, ifm->m_len); + printf("TAILLE: = %d\n", ifm->m_len); slirp_output(slirp->opaque, buf, ifm->m_len + ETH_HLEN); return 1; } -} /* Drop host forwarding rule, return 0 if found. */ int slirp_remove_hostfwd(Slirp *slirp, int is_udp, struct in_addr host_addr, diff --git a/slirp/slirp.h b/slirp/slirp.h index fe0e65d..816a494 100644 --- a/slirp/slirp.h +++ b/slirp/slirp.h @@ -138,12 +138,14 @@ void free(void *ptr); #include "libslirp.h" #include "ip.h" +#include "ip6.h" #include "tcp.h" #include "tcp_timer.h" #include "tcp_var.h" #include "tcpip.h" #include "udp.h" #include "ip_icmp.h" +#include "icmp6.h" #include "mbuf.h" #include "sbuf.h" #include "socket.h" @@ -163,6 +165,7 @@ void free(void *ptr); #define ETH_P_IP 0x0800 /* Internet Protocol packet */ #define ETH_P_ARP 0x0806 /* Address Resolution packet */ +#define ETH_P_IP6 0x86DD /* IPv6 packet */ #define ARPOP_REQUEST 1 /* ARP request */ #define ARPOP_REPLY 2 /* ARP reply */ @@ -201,6 +204,22 @@ void arp_table_add(Slirp *slirp, uint32_t ip_addr, uint8_t ethaddr[ETH_ALEN]); bool arp_table_search(Slirp *slirp, uint32_t ip_addr, uint8_t out_ethaddr[ETH_ALEN]); +struct ndpentry { + unsigned char eth_addr[ETH_ALEN]; /* sender hardware address */ + struct in6_addr ip_addr; /* sender IP address */ +} QEMU_PACKED; + +#define NDP_TABLE_SIZE 16 + +typedef struct NdpTable { + struct ndpentry table[NDP_TABLE_SIZE]; + int next_victim; +} NdpTable; + +void ndp_table_add(Slirp *slirp, struct in6_addr ip_addr, uint8_t ethaddr[ETH_ALEN]); +bool ndp_table_search(Slirp *slirp, struct in6_addr ip_addr, + uint8_t out_ethaddr[ETH_ALEN]); + struct Slirp { QTAILQ_ENTRY(Slirp) entry; @@ -208,6 +227,9 @@ struct Slirp { struct in_addr vnetwork_addr; struct in_addr vnetwork_mask; struct in_addr vhost_addr; + struct in6_addr vprefix_addr6; + uint8_t vprefix_len; + struct in6_addr vhost_addr6; struct in_addr vdhcp_startaddr; struct in_addr vnameserver_addr; @@ -250,12 +272,15 @@ struct Slirp { /* icmp states */ struct socket icmp; struct socket *icmp_last_so; + struct socket icmp6; + struct socket *icmp6_last_so; /* tftp states */ char *tftp_prefix; struct tftp_session tftp_sessions[TFTP_SESSIONS_MAX]; ArpTable arp_table; + NdpTable ndp_table; void *opaque; }; @@ -300,6 +325,7 @@ int translate_dnssearch(Slirp *s, const char ** names); /* cksum.c */ int cksum(struct mbuf *m, int len); +int ip6_cksum(struct mbuf *m); /* if.c */ void if_init(Slirp *); @@ -315,6 +341,14 @@ void ip_stripoptions(register struct mbuf *, struct mbuf *); /* ip_output.c */ int ip_output(struct socket *, struct mbuf *); +/* ip6_input.c */ +void ip6_init(Slirp *); +void ip6_cleanup(Slirp *); +void ip6_input(struct mbuf *); + +/* ip6_output */ +int ip6_output(struct socket *, struct mbuf *); + /* tcp_input.c */ void tcp_input(register struct mbuf *, int, struct socket *); int tcp_mss(register struct tcpcb *, u_int);