svn commit: r212297 - in projects/sv/sys: net netinet
Attilio Rao
attilio at FreeBSD.org
Tue Sep 7 17:24:05 UTC 2010
Author: attilio
Date: Tue Sep 7 17:24:05 2010
New Revision: 212297
URL: http://svn.freebsd.org/changeset/base/212297
Log:
Move the netdump file to sys/netinet/ rather than sys/net/ as it is
mostly specific to TCP/IP suite.
Added:
projects/sv/sys/netinet/netdump_client.c
- copied unchanged from r212294, projects/sv/sys/net/netdump_client.c
Deleted:
projects/sv/sys/net/netdump_client.c
Copied: projects/sv/sys/netinet/netdump_client.c (from r212294, projects/sv/sys/net/netdump_client.c)
==============================================================================
--- /dev/null 00:00:00 1970 (empty, because file is newly added)
+++ projects/sv/sys/netinet/netdump_client.c Tue Sep 7 17:24:05 2010 (r212297, copy of r212294, projects/sv/sys/net/netdump_client.c)
@@ -0,0 +1,1349 @@
+/*-
+ * Copyright (c) 2005 Sandvine Incorporated. All rights reserved.
+ * Copyright (c) 2000 Darrell Anderson <anderson at cs.duke.edu>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+/*
+ * netdump_client.c
+ * FreeBSD kernel module supporting netdump network dumps.
+ * netdump_server must be running to accept client dumps.
+ * XXX: This should be split into machdep and non-machdep parts
+ *
+*/
+
+#include "opt_ddb.h"
+#include "opt_device_polling.h"
+#include "opt_netdump.h"
+
+#include <sys/types.h>
+#include <sys/param.h>
+#include <sys/mbuf.h>
+#include <sys/systm.h>
+#include <sys/proc.h>
+#include <sys/kernel.h>
+#include <sys/protosw.h>
+#include <sys/socket.h>
+#include <sys/sysctl.h>
+#include <sys/lock.h>
+#include <sys/reboot.h>
+#include <sys/eventhandler.h>
+#include <sys/module.h>
+#include <sys/conf.h>
+#include <sys/kerneldump.h>
+#include <sys/smp.h>
+#include <net/if.h>
+#include <net/route.h>
+#include <net/ethernet.h>
+#include <net/if_var.h>
+#include <net/if_vlan_var.h>
+#include <net/if_arp.h>
+#include <net/if_dl.h>
+#include <netinet/in.h>
+#include <netinet/in_systm.h>
+#include <netinet/ip.h>
+#include <netinet/ip_var.h>
+#include <netinet/in_var.h>
+#include <netinet/udp.h>
+#include <netinet/udp_var.h>
+#include <machine/md_var.h>
+#include <machine/pcb.h>
+#include <machine/in_cksum.h>
+#include <machine/smp.h>
+#include <machine/elf.h>
+#include <machine/md_var.h>
+#include <machine/_inttypes.h>
+#include <net/if_media.h>
+#include <net/if_mib.h>
+#include <net/netdump.h>
+#include <machine/clock.h>
+
+#ifdef DDB
+#include <ddb/ddb.h>
+#endif
+
+#ifdef NETDUMP_DEBUG
+#define NETDDEBUG(f, ...) printf((f), ## __VA_ARGS__)
+#define NETDDEBUG_IF(i, f, ...) if_printf((i), (f), ## __VA_ARGS__)
+#if NETDUMP_DEBUG > 1
+#define NETDDEBUGV(f, ...) printf((f), ## __VA_ARGS__)
+#define NETDDEBUGV_IF(i, f, ...) if_printf((i), (f), ## __VA_ARGS__)
+#else
+#define NETDDEBUGV(f, ...)
+#define NETDDEBUGV_IF(i, f, ...)
+#endif
+#else
+#define NETDDEBUG(f, ...)
+#define NETDDEBUG_IF(i, f, ...)
+#define NETDDEBUGV(f, ...)
+#define NETDDEBUGV_IF(i, f, ...)
+#endif
+
+#define NETDUMP_BROKEN_STATE_BUFFER_SIZE (5 * sizeof(struct mtx))
+
+static void nd_handle_arp(struct mbuf **mb);
+static void nd_handle_ip(struct mbuf **mb);
+static int netdump_arp_server(void);
+static void netdump_config_defaults(void);
+static int netdump_dumper(void *priv, void *virtual,
+ vm_offset_t physical, off_t offset, size_t length);
+static int netdump_ether_output(struct mbuf *m, struct ifnet *ifp,
+ struct ether_addr dst, u_short etype);
+static void netdump_mbuf_nop(void *ptr, void *opt_args);
+static int netdump_modevent(module_t mod, int type, void *unused);
+static void netdump_network_poll(void);
+static void netdump_pkt_in(struct ifnet *ifp, struct mbuf *m);
+static int netdump_send(uint32_t type, off_t offset, unsigned char *data,
+ uint32_t datalen);
+static int netdump_send_arp(void);
+static void netdump_trigger(void *arg, int howto);
+static int netdump_udp_output(struct mbuf *m);
+
+#ifdef NETDUMP_DEBUG
+static int sysctl_force_crash(SYSCTL_HANDLER_ARGS);
+#endif
+static int sysctl_ip(SYSCTL_HANDLER_ARGS);
+static int sysctl_nic(SYSCTL_HANDLER_ARGS);
+
+static eventhandler_tag nd_tag = NULL; /* record of our shutdown event */
+static uint32_t nd_seqno = 1; /* current sequence number */
+static uint64_t rcvd_acks; /* flags for out of order acks */
+static int dump_failed, have_server_mac;
+static uint16_t nd_server_port = NETDUMP_PORT; /* port to respond on */
+static unsigned char buf[MAXDUMPPGS*PAGE_SIZE]; /* Must be at least as big as
+ * the chunks dumpsys() gives
+ * us */
+static struct ether_addr nd_gw_mac;
+
+static int nd_enable = 0; /* if we should perform a network dump */
+static struct in_addr nd_server = {INADDR_ANY}; /* server address */
+static struct in_addr nd_client = {INADDR_ANY}; /* client (our) address */
+static struct in_addr nd_gw = {INADDR_ANY}; /* gw, if set */
+struct ifnet *nd_nic = NULL;
+static int nd_polls=10000; /* Times to poll the NIC (0.5ms each poll) before
+ * assuming packetloss occurred: 5s by default */
+static int nd_retries=10; /* Times to retransmit lost packets */
+
+/*
+ * [netdump_supported_nic]
+ *
+ * Checks for netdump support on a network interface
+ *
+ * Parameters:
+ * ifn The network interface that is being tested for support
+ *
+ * Returns:
+ * int 1 if the interface is supported, 0 if not
+ */
+static __inline int
+netdump_supported_nic(struct ifnet *ifn)
+{
+ return ifn->if_netdump != NULL;
+}
+
+/*-
+ * Sysctls specific code.
+ */
+
+/*
+ * [sysctl_ip]
+ *
+ * sysctl handler to deal with converting a string sysctl to/from an in_addr
+ *
+ * Parameters:
+ * SYSCTL_HANDLER_ARGS
+ * - arg1 is a pointer to the struct in_addr holding the IP
+ * - arg2 is unused
+ *
+ * Returns:
+ * int see errno.h, 0 for success
+ */
+static int
+sysctl_ip(SYSCTL_HANDLER_ARGS)
+{
+ struct in_addr addr;
+ char buf[INET_ADDRSTRLEN];
+ int error;
+ int len=req->newlen - req->newidx;
+
+ inet_ntoa_r(*(struct in_addr *)arg1, buf);
+ error = SYSCTL_OUT(req, buf, strlen(buf)+1);
+
+ if (error || !req->newptr)
+ return error;
+
+ if (len >= INET_ADDRSTRLEN) {
+ error = EINVAL;
+ } else {
+ error = SYSCTL_IN(req, buf, len);
+ buf[len]='\0';
+ if (error)
+ return error;
+ if (!inet_aton(buf, &addr))
+ return EINVAL;
+ *(struct in_addr *)arg1 = addr;
+ }
+
+ return error;
+}
+
+/*
+ * [sysctl_nic]
+ *
+ * sysctl handler to deal with converting a string sysctl to/from an interface
+ *
+ * Parameters:
+ * SYSCTL_HANDLER_ARGS
+ * - arg1 is a pointer to the struct ifnet to the interface
+ * - arg2 is the maximum string length (IFNAMSIZ)
+ *
+ * Returns:
+ * int see errno.h, 0 for success
+ */
+static int
+sysctl_nic(SYSCTL_HANDLER_ARGS)
+{
+ struct ifnet *ifn;
+ char buf[arg2+1];
+ int error;
+ int len;
+
+ if (*(struct ifnet **)arg1) {
+ error = SYSCTL_OUT(req,
+ (*(struct ifnet **)arg1)->if_xname,
+ strlen((*(struct ifnet **)arg1)->if_xname));
+ } else {
+ error = SYSCTL_OUT(req, "none", 5);
+ }
+
+ if (error || !req->newptr)
+ return error;
+
+ len = req->newlen - req->newidx;
+ if (len >= arg2) {
+ error = EINVAL;
+ } else {
+ error = SYSCTL_IN(req, buf, len);
+ buf[len]='\0';
+ if (error)
+ return error;
+
+ if (!strcmp(buf, "none")) {
+ ifn = NULL;
+ } else {
+ if ((ifn = TAILQ_FIRST(&ifnet)) != NULL) do {
+ if (!strcmp(ifn->if_xname, buf)) break;
+ } while ((ifn = TAILQ_NEXT(ifn, if_link)) != NULL);
+
+ if (!ifn) return ENODEV;
+ if (!netdump_supported_nic(ifn)) return EINVAL;
+ }
+
+ (*(struct ifnet **)arg1) = ifn;
+ }
+
+ return error;
+}
+
+#ifdef NETDUMP_DEBUG
+static int
+sysctl_force_crash(SYSCTL_HANDLER_ARGS)
+{
+ int error, force_crash;
+
+ force_crash = 0;
+ error = sysctl_handle_int(oidp, &force_crash, force_crash, req);
+ if (error || req->newptr == NULL)
+ return error;
+
+ switch (force_crash) {
+ case 1:
+ printf("\nLivelocking system...\n");
+ for (;;);
+ break;
+ case 2:
+ printf("\nPanic'ing system...\n");
+ panic("netdump forced crash");
+ break;
+ case 3:
+ printf("\nLivelocking system while holding the "
+ "interface lock\n");
+ nd_nic->if_netdump->test_get_lock(nd_nic);
+ for (;;);
+ break;
+ case 5:
+ critical_enter();
+ panic("Forcing spourious critical section");
+ break;
+ case 6:
+ critical_enter();
+ printf("\nLivelocking in a critical section\n");
+ for (;;);
+ default:
+ return EINVAL;
+ }
+ return 0;
+}
+#endif
+
+SYSCTL_NODE(_net, OID_AUTO, dump, CTLFLAG_RW, 0, "netdump");
+SYSCTL_PROC(_net_dump, OID_AUTO, server, CTLTYPE_STRING|CTLFLAG_RW, &nd_server,
+ 0, sysctl_ip, "A", "dump server");
+SYSCTL_PROC(_net_dump, OID_AUTO, client, CTLTYPE_STRING|CTLFLAG_RW, &nd_client,
+ 0, sysctl_ip, "A", "dump client");
+SYSCTL_PROC(_net_dump, OID_AUTO, gateway, CTLTYPE_STRING|CTLFLAG_RW, &nd_gw,
+ 0, sysctl_ip, "A", "dump default gateway");
+SYSCTL_PROC(_net_dump, OID_AUTO, nic, CTLTYPE_STRING|CTLFLAG_RW, &nd_nic,
+ IFNAMSIZ, sysctl_nic, "A", "NIC to dump on");
+SYSCTL_INT(_net_dump, OID_AUTO, polls, CTLTYPE_INT|CTLFLAG_RW, &nd_polls, 0,
+ "times to poll NIC per retry");
+SYSCTL_INT(_net_dump, OID_AUTO, retries, CTLTYPE_INT|CTLFLAG_RW, &nd_retries, 0,
+ "times to retransmit lost packets");
+SYSCTL_INT(_net_dump, OID_AUTO, enable, CTLTYPE_INT|CTLFLAG_RW, &nd_enable,
+ 0, "enable network dump");
+TUNABLE_INT("net.dump.enable", &nd_enable);
+#ifdef NETDUMP_DEBUG
+SYSCTL_DECL(_debug_netdump);
+SYSCTL_PROC(_debug_netdump, OID_AUTO, crash, CTLTYPE_INT|CTLFLAG_RW, 0,
+ sizeof(int), sysctl_force_crash, "I", "force crashing");
+#endif
+
+/*-
+ * Network specific primitives.
+ * Following down the code they are divided ordered as:
+ * - Output primitives
+ * - Input primitives
+ * - Polling primitives
+ */
+
+/*
+ * [netdump_mbuf_nop]
+ *
+ * netdump wraps external mbufs around address ranges. unlike most sane
+ * counterparts, netdump uses a stop-and-wait approach to flow control and
+ * retransmission, so the ack obviates the need for mbuf reference
+ * counting. we still need to tell other mbuf handlers not to do anything
+ * special with our mbufs, so specify this nop handler.
+ *
+ * Parameters:
+ * ptr data to free (ignored)
+ * opt_args callback pointer (ignored)
+ *
+ * Returns:
+ * void
+ */
+static void
+netdump_mbuf_nop(void *ptr, void *opt_args)
+{
+ ;
+}
+
+/*
+ * [netdump_ether_output]
+ *
+ * Handles creation of the ethernet header, then places outgoing packets into
+ * the tx buffer for the NIC
+ *
+ * Parameters:
+ * m The mbuf containing the packet to be sent (will be freed by
+ * this function or the NIC driver)
+ * ifp The interface to send on
+ * dst The destination ethernet address (source address will be looked
+ * up using ifp)
+ * etype The ETHERTYPE_* value for the protocol that is being sent
+ *
+ * Returns:
+ * int see errno.h, 0 for success
+ */
+static int
+netdump_ether_output(struct mbuf *m, struct ifnet *ifp, struct ether_addr dst,
+ u_short etype)
+{
+ struct ether_header *eh;
+
+ /* fill in the ethernet header */
+ M_PREPEND(m, ETHER_HDR_LEN, M_DONTWAIT);
+ if (m == 0) {
+ printf("netdump_ether_output: Out of mbufs\n");
+ return ENOBUFS;
+ }
+ eh = mtod(m, struct ether_header *);
+ bcopy(IF_LLADDR(ifp), eh->ether_shost, ETHER_ADDR_LEN);
+ bcopy(dst.octet, eh->ether_dhost, ETHER_ADDR_LEN);
+ eh->ether_type = htons(etype);
+
+ if (((ifp->if_flags & (IFF_MONITOR|IFF_UP)) != IFF_UP) ||
+ (ifp->if_drv_flags & IFF_DRV_RUNNING) != IFF_DRV_RUNNING) {
+ if_printf(ifp, "netdump_ether_output: Interface isn't up\n");
+ m_freem(m);
+ return ENETDOWN;
+ }
+
+ if (_IF_QFULL(&ifp->if_snd)) {
+ if_printf(ifp, "netdump_ether_output: TX queue full\n");
+ m_freem(m);
+ return ENOBUFS;
+ }
+
+ _IF_ENQUEUE(&ifp->if_snd, m);
+ return 0;
+}
+
+/*
+ * [netdump_udp_output]
+ *
+ * unreliable transmission of an mbuf chain to the netdump server
+ * Note: can't handle fragmentation; fails if the packet is larger than
+ * nd_nic->if_mtu after adding the UDP/IP headers
+ *
+ * Parameters:
+ * m mbuf chain
+ *
+ * Returns:
+ * int see errno.h, 0 for success
+ */
+static int
+netdump_udp_output(struct mbuf *m)
+{
+ struct udpiphdr *ui;
+ struct ip *ip;
+
+ M_PREPEND(m, sizeof(struct udpiphdr), M_DONTWAIT);
+ if (m == 0) {
+ printf("netdump_udp_output: Out of mbufs\n");
+ return ENOBUFS;
+ }
+ ui = mtod(m, struct udpiphdr *);
+ bzero(ui->ui_x1, sizeof(ui->ui_x1));
+ ui->ui_pr = IPPROTO_UDP;
+ ui->ui_len = htons(m->m_pkthdr.len - sizeof(struct ip));
+ ui->ui_ulen = ui->ui_len;
+ ui->ui_src = nd_client;
+ ui->ui_dst = nd_server;
+ /* Use this src port so that the server can connect() the socket */
+ ui->ui_sport = htons(NETDUMP_ACKPORT);
+ ui->ui_dport = htons(nd_server_port);
+ ui->ui_sum = 0;
+ if ((ui->ui_sum = in_cksum(m, m->m_pkthdr.len)) == 0)
+ ui->ui_sum = 0xffff;
+
+ ip = mtod(m, struct ip *);
+ ip->ip_v = IPVERSION;
+ ip->ip_hl = sizeof(struct ip) >> 2;
+ ip->ip_tos = 0;
+ ip->ip_len = htons(m->m_pkthdr.len);
+ ip->ip_id = 0;
+ ip->ip_off = htons(IP_DF);
+ ip->ip_ttl = 32;
+ ip->ip_sum = 0;
+ ip->ip_sum = in_cksum(m, sizeof(struct ip));
+
+ if (m->m_pkthdr.len > nd_nic->if_mtu) {
+ /* Whoops. The packet is too big. */
+ printf("netdump_udp_output: Packet is too big: "
+ "%u > MTU %lu\n", m->m_pkthdr.len, nd_nic->if_mtu);
+ m_freem(m);
+ return ENOBUFS;
+ }
+
+ return netdump_ether_output(m, nd_nic, nd_gw_mac, ETHERTYPE_IP);
+}
+
+/*
+ * [netdump_send_arp]
+ *
+ * Builds and sends a single ARP request to locate the server
+ *
+ * Parameters:
+ * void
+ *
+ * Return value:
+ * 0 on success
+ * errno on error
+ */
+static int
+netdump_send_arp()
+{
+ struct mbuf *m;
+ int pktlen = arphdr_len2(ETHER_ADDR_LEN, sizeof(struct in_addr));
+ struct arphdr *ah;
+ struct ether_addr bcast;
+
+ ETHER_SET_BROADCAST(&bcast);
+
+ MGETHDR(m, M_DONTWAIT, MT_DATA);
+ if (m == NULL) {
+ printf("netdump_send_arp: Out of mbufs");
+ return ENOBUFS;
+ }
+ m->m_pkthdr.len = m->m_len = pktlen;
+ MH_ALIGN(m, pktlen); /* Make room for ethernet header */
+ ah = mtod(m, struct arphdr *);
+ ah->ar_hrd = htons(ARPHRD_ETHER);
+ ah->ar_pro = htons(ETHERTYPE_IP);
+ ah->ar_hln = ETHER_ADDR_LEN;
+ ah->ar_pln = sizeof(struct in_addr);
+ ah->ar_op = htons(ARPOP_REQUEST);
+ bcopy(IF_LLADDR(nd_nic), ar_sha(ah), ETHER_ADDR_LEN);
+ ((struct in_addr *)ar_spa(ah))->s_addr = nd_client.s_addr;
+ bzero(ar_tha(ah), ETHER_ADDR_LEN);
+ ((struct in_addr *)ar_tpa(ah))->s_addr = nd_gw.s_addr;
+
+ return netdump_ether_output(m, nd_nic, bcast, ETHERTYPE_ARP);
+}
+
+/*
+ * [netdump_arp_server]
+ *
+ * Sends ARP requests to locate the server and waits for a response
+ *
+ * Parameters:
+ * void
+ *
+ * Return value:
+ * 0 on success
+ * errno on error
+ */
+static int
+netdump_arp_server()
+{
+ int err, polls, retries;
+
+ for (retries=0; retries < nd_retries && !have_server_mac; retries++) {
+ err = netdump_send_arp();
+
+ if (err)
+ return err;
+
+ for (polls=0; polls < nd_polls && !have_server_mac; polls++) {
+ netdump_network_poll();
+ DELAY(500); /* 0.5 ms */
+ }
+
+ if (!have_server_mac) printf("(ARP retry)");
+ }
+
+ if (have_server_mac)
+ return 0;
+
+ printf("\nARP timed out.\n");
+
+ return ETIMEDOUT;
+}
+
+/*
+ * [netdump_send]
+ *
+ * construct and reliably send a netdump packet. may fail from a resource
+ * shortage or extreme number of unacknowledged retransmissions. wait for
+ * an acknowledgement before returning. splits packets into chunks small
+ * enough to be sent without fragmentation (looks up the interface MTU)
+ *
+ * Parameters:
+ * type netdump packet type (HERALD, FINISHED, or VMCORE)
+ * offset vmcore data offset (bytes)
+ * data vmcore data
+ * datalen vmcore data size (bytes)
+ *
+ * Returns:
+ * int see errno.h, 0 for success
+ */
+static int
+netdump_send(uint32_t type, off_t offset,
+ unsigned char *data, uint32_t datalen)
+{
+ struct netdump_msg_hdr *nd_msg_hdr;
+ struct mbuf *m, *m2;
+ int retries = 0, polls, error;
+ uint32_t i, sent_so_far;
+ uint64_t want_acks=0;
+
+ rcvd_acks = 0;
+
+retransmit:
+ /* We might get chunks too big to fit in packets. Yuck. */
+ for (i=sent_so_far=0; sent_so_far < datalen || (i==0 && datalen==0);
+ i++) {
+ uint32_t pktlen = datalen-sent_so_far;
+ /* First bound: the packet structure */
+ pktlen = min(pktlen, NETDUMP_DATASIZE);
+ /* Second bound: the interface MTU (assume no IP options) */
+ pktlen = min(pktlen, nd_nic->if_mtu -
+ sizeof(struct udpiphdr) -
+ sizeof(struct netdump_msg_hdr));
+
+ /* Check if we're retransmitting and this has been ACKed
+ * already */
+ if ((rcvd_acks & (1 << i)) != 0) {
+ sent_so_far += pktlen;
+ continue;
+ }
+
+ /*
+ * get and fill a header mbuf, then chain data as an extended
+ * mbuf.
+ */
+ MGETHDR(m, M_DONTWAIT, MT_DATA);
+ if (m == NULL) {
+ printf("netdump_send: Out of mbufs!\n");
+ return ENOBUFS;
+ }
+ m->m_pkthdr.len = m->m_len = sizeof(struct netdump_msg_hdr);
+ /* leave room for udpip */
+ MH_ALIGN(m, sizeof(struct netdump_msg_hdr));
+ nd_msg_hdr = mtod(m, struct netdump_msg_hdr *);
+ nd_msg_hdr->seqno = htonl(nd_seqno+i);
+ nd_msg_hdr->type = htonl(type);
+ nd_msg_hdr->offset = htonll(offset+sent_so_far);
+ nd_msg_hdr->len = htonl(pktlen);
+ nd_msg_hdr->_pad = 0;
+
+ if (pktlen) {
+ if ((m2 = m_get(M_DONTWAIT, MT_DATA)) == NULL) {
+ m_freem(m);
+ printf("netdump_send: Out of mbufs!\n");
+ return ENOBUFS;
+ }
+ MEXTADD(m2, data+sent_so_far, pktlen, netdump_mbuf_nop,
+ NULL, M_RDONLY, EXT_MOD_TYPE);
+ m2->m_len = pktlen;
+ m->m_next = m2;
+ m->m_pkthdr.len += m2->m_len;
+ }
+
+ if ((error = netdump_udp_output(m)) != 0) {
+ return error;
+ }
+
+ /* Note that we're waiting for this packet in the bitfield */
+ want_acks |= 1 << i;
+
+ sent_so_far += pktlen;
+ }
+
+ if (i >= sizeof(want_acks)*8) {
+ printf("Warning: Sent more than %zd packets (%d). "
+ "Acknowledgements will fail unless the size of "
+ "rcvd_acks/want_acks is increased.\n",
+ sizeof(want_acks)*8, i);
+ }
+
+ /*
+ * wait for acks. a *real* window would speed things up considerably.
+ */
+ polls = 0;
+ while (rcvd_acks != want_acks) {
+ if (polls++ > nd_polls) {
+ if (retries++ > nd_retries) {
+ return ETIMEDOUT; /* 10 s, no ack */
+ }
+ printf(". ");
+ goto retransmit; /* 1 s, no ack */
+ }
+ /*
+ * this is not always necessary, but does no harm.
+ */
+ netdump_network_poll();
+ DELAY(500); /* 0.5 ms */
+ }
+ nd_seqno += i;
+ return 0;
+}
+
+/*
+ * [nd_handle_ip]
+ *
+ * Handler for IP packets: checks their sanity and then processes any netdump
+ * ACK packets it finds.
+ *
+ * It needs to replicate partially the behaviour of ip_input() and
+ * udp_input().
+ *
+ * Parameters:
+ * mb a pointer to an mbuf * containing the packet received
+ * Updates *mb if m_pullup et al change the pointer
+ * Assumes the calling function will take care of freeing the mbuf
+ *
+ * Return value:
+ * void
+ */
+static void
+nd_handle_ip(struct mbuf **mb)
+{
+ unsigned short hlen;
+ struct ip *ip;
+ struct udpiphdr *udp;
+ struct netdump_ack *nd_ack;
+ struct mbuf *m;
+ int rcv_ackno;
+
+ /* IP processing */
+
+ NETDDEBUGV("nd_handle_ip: Processing IP packet...\n");
+
+ m = *mb;
+ if (m->m_pkthdr.len < sizeof(struct ip)) {
+ NETDDEBUG("nd_handle_ip: dropping packet too small for IP "
+ "header\n");
+ return;
+ }
+ if (m->m_len < sizeof(struct ip) &&
+ (*mb = m = m_pullup(m, sizeof(struct ip))) == NULL) {
+ NETDDEBUG("nd_handle_ip: m_pullup failed\n");
+ return;
+ }
+
+ ip = mtod(m, struct ip *);
+
+ /* IP version */
+ if (ip->ip_v != IPVERSION) {
+ NETDDEBUG("nd_handle_ip: Bad IP version %d\n", ip->ip_v);
+ return;
+ }
+
+ /* Header length */
+ hlen = ip->ip_hl << 2;
+ if (hlen < sizeof(struct ip)) {
+ NETDDEBUG("nd_handle_ip: Bad IP header length (%hu)\n", hlen);
+ return;
+ }
+ if (hlen > m->m_len) {
+ if ((*mb = m = m_pullup(m, hlen)) == NULL) {
+ NETDDEBUG("nd_handle_ip: m_pullup failed\n");
+ return;
+ }
+ ip = mtod(m, struct ip *);
+ }
+
+#ifdef INVARIANTS
+ if (((ntohl(ip->ip_dst.s_addr) >> IN_CLASSA_NSHIFT) == IN_LOOPBACKNET ||
+ (ntohl(ip->ip_src.s_addr) >> IN_CLASSA_NSHIFT) == IN_LOOPBACKNET) &&
+ (m->m_pkthdr.rcvif->if_flags & IFF_LOOPBACK) == 0) {
+ NETDDEBUG("nd_handle_ip: Bad IP header (RFC1122)\n");
+ return;
+ }
+#endif
+
+ /* Checksum */
+ if (m->m_pkthdr.csum_flags & CSUM_IP_CHECKED) {
+ if (!(m->m_pkthdr.csum_flags & CSUM_IP_VALID)) {
+ NETDDEBUG("nd_handle_ip: Bad IP checksum\n");
+ return;
+ }
+ } else
+ NETDDEBUG("nd_handle_ip: HW didn't check IP cksum\n");
+
+ /* Convert fields to host byte order */
+ ip->ip_len = ntohs(ip->ip_len);
+ if (ip->ip_len < hlen) {
+ NETDDEBUG("nd_handle_ip: IP packet smaller (%hu) than "
+ "header (%hu)\n", ip->ip_len, hlen);
+ return;
+ }
+ ip->ip_off = ntohs(ip->ip_off);
+
+ if (m->m_pkthdr.len < ip->ip_len) {
+ NETDDEBUG("nd_handle_ip: IP packet bigger (%hu) than "
+ "ethernet packet (%hu)\n", ip->ip_len, m->m_pkthdr.len);
+ return;
+ }
+ if (m->m_pkthdr.len > ip->ip_len) {
+ /* Truncate the packet to the IP length */
+ if (m->m_len == m->m_pkthdr.len) {
+ m->m_len = ip->ip_len;
+ m->m_pkthdr.len = ip->ip_len;
+ } else
+ m_adj(m, ip->ip_len - m->m_pkthdr.len);
+ }
+
+ /* We would process IP options here, but we'll ignore them instead. */
+ /* Strip IP options */
+ if (hlen > sizeof(struct ip)) {
+ ip_stripoptions(m, (struct mbuf *)0);
+ hlen = sizeof(struct ip);
+ }
+
+ /* Check that the source is the server's IP */
+ if (ip->ip_src.s_addr != nd_server.s_addr) {
+ NETDDEBUG("nd_handle_ip: Drop packet not from server\n");
+ return;
+ }
+
+ /* Check if the destination IP is ours */
+ if (ip->ip_dst.s_addr != nd_client.s_addr) {
+ NETDDEBUGV("nd_handle_ip: Drop packet not to our IP\n");
+ return;
+ }
+
+ if (ip->ip_p != IPPROTO_UDP) {
+ NETDDEBUG("nd_handle_ip: Drop non-UDP packet\n");
+ return;
+ }
+
+ /* Let's not deal with fragments */
+ if (ip->ip_off & (IP_MF | IP_OFFMASK)) {
+ NETDDEBUG("nd_handle_ip: Drop fragmented packet\n");
+ return;
+ }
+ /* UDP custom is to have packet length not include IP header */
+ ip->ip_len -= hlen;
+
+ /* IP done */
+ /* UDP processing */
+
+ /* Get IP and UDP headers together, along with the netdump packet */
+ if (m->m_pkthdr.len <
+ sizeof(struct udpiphdr) + sizeof(struct netdump_ack)) {
+ NETDDEBUG("nd_handle_ip: Ignoring small packet\n");
+ return;
+ }
+ if (m->m_len < sizeof(struct udpiphdr) + sizeof(struct netdump_ack) &&
+ (*mb = m = m_pullup(m, sizeof(struct udpiphdr) +
+ sizeof(struct netdump_ack))) == NULL) {
+ NETDDEBUG("nd_handle_ip: m_pullup failed\n");
+ return;
+ }
+ udp = mtod(m, struct udpiphdr *);
+
+ NETDDEBUG("nd_handle_ip: Processing packet...");
+
+ if (ntohs(udp->ui_u.uh_dport) != NETDUMP_ACKPORT) {
+ NETDDEBUG("not on the netdump port.\n");
+ return;
+ }
+
+ /* UDP done */
+ /* Netdump processing */
+
+ /*
+ * packet is meant for us. extract the ack sequence number.
+ * if it's the first ack, extract the port number as well
+ */
+ nd_ack = (struct netdump_ack *)
+ (mtod(m, caddr_t) + sizeof(struct udpiphdr));
+ rcv_ackno = ntohl(nd_ack->seqno);
+
+ if (nd_server_port == NETDUMP_PORT) {
+ nd_server_port = ntohs(udp->ui_u.uh_sport);
+ }
+
+ if (rcv_ackno >= nd_seqno+64) {
+ printf("nd_handle_ip: ACK %d too far in future!\n", rcv_ackno);
+ } else if (rcv_ackno < nd_seqno) {
+ /* Do nothing: A duplicated past ACK */
+ } else {
+ /* We're interested in this ack. Record it. */
+ rcvd_acks |= 1 << (rcv_ackno-nd_seqno);
+ }
+}
+
+/*
+ * [nd_handle_arp]
+ *
+ * Handler for ARP packets: checks their sanity and then
+ * 1. If the ARP is a request for our IP, respond with our MAC address
+ * 2. If the ARP is a response from our server, record its MAC address
+ *
+ * It needs to replicate partially the behaviour of arpintr() and
+ * in_arpinput().
+ *
+ * Parameters:
+ * mb a pointer to an mbuf * containing the packet received
+ * Updates *mb if m_pullup et al change the pointer
+ * Assumes the calling function will take care of freeing the mbuf
+ *
+ * Return value:
+ * void
+ */
+static void
+nd_handle_arp(struct mbuf **mb)
+{
+ struct mbuf *m;
+ struct arphdr *ah;
+ struct ifnet *ifp;
+ int req_len, op;
+ struct in_addr isaddr, itaddr, myaddr;
+ uint8_t *enaddr;
+ struct ether_addr dst;
+
+ m = *mb;
+ ifp = m->m_pkthdr.rcvif;
+ if (m->m_len < sizeof(struct arphdr) && ((*mb = m = m_pullup(m,
+ sizeof(struct arphdr))) == NULL)) {
+ NETDDEBUG("nd_handle_arp: runt packet: m_pullup failed\n");
+ return;
+ }
+ ah = mtod(m, struct arphdr *);
+
+ if (ntohs(ah->ar_hrd) != ARPHRD_ETHER &&
+ ntohs(ar->ar_hrd) != ARPHRD_IEEE802 &&
+ ntohs(ar->ar_hrd) != ARPHRD_ARCNET &&
+ ntohs(ar->ar_hrd) != ARPHRD_IEEE1394) {
+ NETDDEBUG("nd_handle_arp: unknown hardware address fmt "
+ "0x%2D)\n", (unsigned char *)&ah->ar_hrd, "");
+ return;
+ }
+
+ if (ntohs(ah->ar_pro) != ETHERTYPE_IP) {
+ NETDDEBUG("nd_handle_arp: Drop ARP for unknown "
+ "protocol %d\n", ntohs(ah->ar_pro));
+ return;
+ }
+
+ req_len = arphdr_len2(ifp->if_addrlen, sizeof(struct in_addr));
+ if (m->m_len < req_len && (*mb = m = m_pullup(m, req_len)) == NULL) {
+ NETDDEBUG("nd_handle_arp: runt packet: m_pullup failed\n");
+ return;
+ }
+ ah = mtod(m, struct arphdr *);
+
+ op = ntohs(ah->ar_op);
+ bcopy(ar_spa(ah), &isaddr, sizeof(isaddr));
+ bcopy(ar_tpa(ah), &itaddr, sizeof(itaddr));
+ enaddr = (uint8_t *)IF_LLADDR(ifp);
+ myaddr = nd_client;
+
+ if (!bcmp(ar_sha(ah), enaddr, ifp->if_addrlen)) {
+ NETDDEBUG("nd_handle_arp: ignoring ARP from myself\n");
+ return;
+ }
+
+#ifdef INVARIANTS
+ if (!bcmp(ar_sha(ah), ifp->if_broadcastaddr, ifp->if_addrlen)) {
+ NETDDEBUG("nd_handle_arp: ignoring ARP as link address is "
+ "broadcast.\n");
+ return;
+ }
+#endif
+
+ if (isaddr.s_addr == nd_client.s_addr) {
+ printf("nd_handle_arp: %*D is using my IP address %s!\n",
+ ifp->if_addrlen, (u_char *)ar_sha(ah), ":",
+ inet_ntoa(isaddr));
+ return;
+ }
+
+ if (!bcmp(ar_sha(ah), ifp->if_broadcastaddr, ifp->if_addrlen)) {
+ NETDDEBUG("nd_handle_arp: ignoring ARP from broadcast "
+ "address\n");
+ return;
+ }
+
+ if (op == ARPOP_REPLY) {
+ if (isaddr.s_addr != nd_gw.s_addr) {
+ char buf[INET_ADDRSTRLEN];
+ inet_ntoa_r(isaddr, buf);
+ NETDDEBUG("nd_handle_arp: ignoring ARP reply from "
+ "%s (not netdump server)\n", buf);
+ return;
+ }
+ bcopy(ar_sha(ah), nd_gw_mac.octet,
+ min(ah->ar_hln, ETHER_ADDR_LEN));
+ have_server_mac = 1;
+ NETDDEBUG("\nnd_handle_arp: Got server MAC address %6D\n",
+ nd_gw_mac.octet, ":");
+ return;
+ }
+
+ if (op != ARPOP_REQUEST) {
+ NETDDEBUG("nd_handle_arp: Ignoring non-request/non-reply "
+ "ARP\n");
+ return;
+ }
+
+ if (itaddr.s_addr != nd_client.s_addr) {
+ NETDDEBUG("nd_handle_arp: ignoring ARP not to our IP\n");
+ return;
+ }
+
+ bcopy(ar_sha(ah), ar_tha(ah), ah->ar_hln);
+ bcopy(enaddr, ar_sha(ah), ah->ar_hln);
+ bcopy(ar_spa(ah), ar_tpa(ah), ah->ar_pln);
+ bcopy(&itaddr, ar_spa(ah), ah->ar_pln);
+ ah->ar_op = htons(ARPOP_REPLY);
+ ah->ar_pro = htons(ETHERTYPE_IP); /* let's be sure! */
+ m->m_flags &= ~(M_BCAST|M_MCAST); /* never reply by broadcast */
+ m->m_len = sizeof(*ah) + (2 * ah->ar_pln) + (2 * ah->ar_hln);
+ m->m_pkthdr.len = m->m_len;
+
+ bcopy(dst.octet, ar_tha(ah), ETHER_ADDR_LEN);
+ netdump_ether_output(m, ifp, dst, ETHERTYPE_ARP);
+ *mb = NULL; /* Don't m_free upon return */
+}
+
+/*
+ * [netdump_pkt_in]
+ *
+ * Handler for incoming packets directly from the network adapter
*** DIFF OUTPUT TRUNCATED AT 1000 LINES ***
More information about the svn-src-projects
mailing list