libnet4r 0.1

data/libnet/src/libnet_build_vrrp.c

@@ -0,0 +1,117 @@
+/*
+ *  $Id: libnet_build_vrrp.c,v 1.9 2004/01/21 19:01:29 mike Exp $
+ *
+ *  libnet
+ *  libnet_build_vrrp.c - VRRP packet assembler
+ *
+ *  Copyright (c) 1998 - 2004 Mike D. Schiffman <mike@infonexus.com>
+ *  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.
+ *
+ */
+
+#if (HAVE_CONFIG_H)
+#include "../include/config.h"
+#endif
+#if (!(_WIN32) || (__CYGWIN__)) 
+#include "../include/libnet.h"
+#else
+#include "../include/win32/libnet.h"
+#endif
+
+libnet_ptag_t
+libnet_build_vrrp(u_int8_t version, u_int8_t type, u_int8_t vrouter_id, 
+u_int8_t priority, u_int8_t ip_count, u_int8_t auth_type, u_int8_t advert_int,
+u_int16_t sum, u_int8_t *payload, u_int32_t payload_s, libnet_t *l,
+libnet_ptag_t ptag)
+{
+    u_int32_t n, h;
+    libnet_pblock_t *p;
+    struct libnet_vrrp_hdr vrrp_hdr;
+
+    if (l == NULL)
+    { 
+        return (-1);
+    } 
+
+    n = LIBNET_VRRP_H + payload_s;
+    h = LIBNET_VRRP_H + payload_s;
+
+    /*
+     *  Find the existing protocol block if a ptag is specified, or create
+     *  a new one.
+     */
+    p = libnet_pblock_probe(l, ptag, n, LIBNET_PBLOCK_VRRP_H);
+    if (p == NULL)
+    {
+        return (-1);
+    }
+
+    memset(&vrrp_hdr, 0, sizeof(vrrp_hdr));
+    vrrp_hdr.vrrp_v          = version;
+    vrrp_hdr.vrrp_t          = type;
+    vrrp_hdr.vrrp_vrouter_id = vrouter_id;
+    vrrp_hdr.vrrp_priority   = priority;
+    vrrp_hdr.vrrp_ip_count   = ip_count;
+    vrrp_hdr.vrrp_auth_type  = auth_type;
+    vrrp_hdr.vrrp_advert_int = advert_int;
+    vrrp_hdr.vrrp_sum        = (sum ? htons(sum) : 0);
+
+    n = libnet_pblock_append(l, p, (u_int8_t *)&vrrp_hdr, LIBNET_VRRP_H);
+    if (n == -1)
+    {
+        goto bad;
+    }
+
+    if ((payload && !payload_s) || (!payload && payload_s))
+    {
+        snprintf(l->err_buf, LIBNET_ERRBUF_SIZE,
+			    "%s(): payload inconsistency\n", __func__);
+        goto bad;
+    }
+
+    if (payload && payload_s)
+    {
+        n = libnet_pblock_append(l, p, payload, payload_s);
+        if (n == -1)
+        {
+            goto bad;
+        }
+    }
+
+    if (sum == 0)
+    {
+        /*
+         *  If checksum is zero, by default libnet will compute a checksum
+         *  for the user.  The programmer can override this by calling
+         *  libnet_toggle_checksum(l, ptag, 1);
+         */
+        libnet_pblock_setflags(p, LIBNET_PBLOCK_DO_CHECKSUM);
+    }
+    return (ptag ? ptag : libnet_pblock_update(l, p, h, LIBNET_PBLOCK_VRRP_H));
+bad:
+    libnet_pblock_delete(l, p);
+    return (-1);
+}
+
+/* EOF */

data/libnet/src/libnet_checksum.c

@@ -0,0 +1,376 @@
+/*
+ *  $Id: libnet_checksum.c,v 1.13 2004/03/01 20:26:12 mike Exp $
+ *
+ *  libnet
+ *  libnet_checksum.c - checksum routines
+ *
+ *  Copyright (c) 1998 - 2004 Mike D. Schiffman <mike@infonexus.com>
+ *  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.
+ *
+ */
+
+#if (HAVE_CONFIG_H)
+#include "../include/config.h"
+#endif
+#if (!(_WIN32) || (__CYGWIN__)) 
+#include "../include/libnet.h"
+#else
+#include "../include/win32/libnet.h"
+#endif
+int
+libnet_in_cksum(u_int16_t *addr, int len)
+{
+    int sum;
+
+    sum = 0;
+
+    while (len > 1)
+    {
+        sum += *addr++;
+        len -= 2;
+    }
+    if (len == 1)
+    {
+        sum += *(u_int16_t *)addr;
+    }
+
+    return (sum);
+}
+
+int
+libnet_toggle_checksum(libnet_t *l, libnet_ptag_t ptag, int mode)
+{
+    libnet_pblock_t *p;
+
+    p = libnet_pblock_find(l, ptag);
+    if (p == NULL)
+    {
+        /* err msg set in libnet_pblock_find() */
+        return (-1);
+    }
+    if (mode == LIBNET_ON)
+    {
+        if ((p->flags) & LIBNET_PBLOCK_DO_CHECKSUM)
+        {
+            return (1);
+        }
+        else
+        {
+            (p->flags) |= LIBNET_PBLOCK_DO_CHECKSUM;
+            return (1);
+        }
+    }
+    else
+    {
+        if ((p->flags) & LIBNET_PBLOCK_DO_CHECKSUM)
+        {
+            (p->flags) &= ~LIBNET_PBLOCK_DO_CHECKSUM;
+            return (1);
+        }
+        else
+        {
+            return (1);
+        }
+    }
+}
+
+
+int
+libnet_do_checksum(libnet_t *l, u_int8_t *buf, int protocol, int len)
+{
+    /* will need to update this for ipv6 at some point */
+    struct libnet_ipv4_hdr *iph_p;
+    struct libnet_ipv6_hdr *ip6h_p;
+    int is_ipv6;
+    int ip_hl;
+    int sum;
+
+    is_ipv6 = 0;    /* default to not using IPv6 */
+    sum     = 0;
+    iph_p   = NULL;
+    ip6h_p  = NULL;
+
+    if (len == 0)
+    {
+        snprintf(l->err_buf, LIBNET_ERRBUF_SIZE,
+            "%s(): header length can't be zero\n", __func__);
+        return (-1);
+    }
+
+    /*
+     *  Figure out which IP version we're dealing with.  We'll assume v4
+     *  and overlay a header structure to yank out the version.
+     */
+    iph_p = (struct libnet_ipv4_hdr *)buf;
+    if (iph_p && iph_p->ip_v == 6)
+    {
+        ip6h_p = (struct libnet_ipv6_hdr *)buf;
+        is_ipv6 = 1;
+        ip_hl   = 40;
+    }
+    else
+    {
+        is_ipv6 = 0;
+        ip_hl = iph_p->ip_hl << 2;
+    }
+
+    /*
+     *  Dug Song came up with this very cool checksuming implementation
+     *  eliminating the need for explicit psuedoheader use.  Check it out.
+     */
+    switch (protocol)
+    {
+        /*
+         *  Style note: normally I don't advocate declaring variables inside
+         *  blocks of control, but it makes good sense here. -- MDS
+         */
+        case IPPROTO_TCP:
+        {
+            struct libnet_tcp_hdr *tcph_p =
+                (struct libnet_tcp_hdr *)(buf + ip_hl);
+
+#if (STUPID_SOLARIS_CHECKSUM_BUG)
+            tcph_p->th_sum = tcph_p->th_off << 2;
+            return (1);
+#endif /* STUPID_SOLARIS_CHECKSUM_BUG */
+#if (HAVE_HPUX11)   
+            if (l->injection_type != LIBNET_LINK)
+            {
+                /*
+                 *  Similiar to the Solaris Checksum bug - but need to add
+                 *  the size of the TCP payload (only for raw sockets).
+                 */
+                tcph_p->th_sum = (tcph_p->th_off << 2) +
+                        (len - (tcph_p->th_off << 2));
+                return (1); 
+            }
+#endif
+            tcph_p->th_sum = 0;
+            if (is_ipv6)
+            {
+                sum = libnet_in_cksum((u_int16_t *)&ip6h_p->ip_src, 32);
+            }
+            else
+            {
+                sum = libnet_in_cksum((u_int16_t *)&iph_p->ip_src, 8);
+            }
+            sum += ntohs(IPPROTO_TCP + len);
+            sum += libnet_in_cksum((u_int16_t *)tcph_p, len);
+            tcph_p->th_sum = LIBNET_CKSUM_CARRY(sum);
+            break;
+        }
+        case IPPROTO_UDP:
+        {
+            struct libnet_udp_hdr *udph_p =
+                (struct libnet_udp_hdr *)(buf + ip_hl);
+            udph_p->uh_sum = 0;
+            if (is_ipv6)
+            {
+                sum = libnet_in_cksum((u_int16_t *)&ip6h_p->ip_src, 32);
+            }
+            else
+            {
+                sum = libnet_in_cksum((u_int16_t *)&iph_p->ip_src, 8);
+            }
+            sum += ntohs(IPPROTO_UDP + len);
+            sum += libnet_in_cksum((u_int16_t *)udph_p, len);
+            udph_p->uh_sum = LIBNET_CKSUM_CARRY(sum);
+            break;
+        }
+        case IPPROTO_ICMP:
+        {
+            struct libnet_icmpv4_hdr *icmph_p =
+                (struct libnet_icmpv4_hdr *)(buf + ip_hl);
+
+            icmph_p->icmp_sum = 0;
+            if (is_ipv6)
+            {
+                sum = libnet_in_cksum((u_int16_t *)&ip6h_p->ip_src, 32);
+                sum += ntohs(IPPROTO_ICMP6 + len);
+            }
+            sum += libnet_in_cksum((u_int16_t *)icmph_p, len);
+            icmph_p->icmp_sum = LIBNET_CKSUM_CARRY(sum);
+            break;
+        }
+        case IPPROTO_IGMP:
+        {
+            struct libnet_igmp_hdr *igmph_p =
+                (struct libnet_igmp_hdr *)(buf + ip_hl);
+
+            igmph_p->igmp_sum = 0;
+            sum = libnet_in_cksum((u_int16_t *)igmph_p, len);
+            igmph_p->igmp_sum = LIBNET_CKSUM_CARRY(sum);
+            break;
+        }
+	case IPPROTO_GRE:
+	{
+            /* checksum is always at the same place in GRE header
+             * in the multiple RFC version of the protocol ... ouf !!!
+             */
+	    struct libnet_gre_hdr *greh_p = 
+		(struct libnet_gre_hdr *)(buf + ip_hl);
+	    u_int16_t fv = ntohs(greh_p->flags_ver);
+	    if (!(fv & (GRE_CSUM|GRE_ROUTING | GRE_VERSION_0)) ||
+                !(fv & (GRE_CSUM|GRE_VERSION_1)))
+	    {
+		snprintf(l->err_buf, LIBNET_ERRBUF_SIZE,
+                "%s(): can't compute GRE checksum (wrong flags_ver bits: 0x%x )\n",  __func__, fv);
+		return (-1);
+	    }
+	    sum = libnet_in_cksum((u_int16_t *)greh_p, len);
+	    greh_p->gre_sum = LIBNET_CKSUM_CARRY(sum);
+	    break;
+	}
+        case IPPROTO_OSPF:
+        {
+            struct libnet_ospf_hdr *oh_p =
+                (struct libnet_ospf_hdr *)(buf + ip_hl);
+
+            oh_p->ospf_sum = 0;
+            sum += libnet_in_cksum((u_int16_t *)oh_p, len);
+            oh_p->ospf_sum = LIBNET_CKSUM_CARRY(sum);
+            break;
+        }
+        case IPPROTO_OSPF_LSA:
+        {
+            struct libnet_ospf_hdr *oh_p =
+                (struct libnet_ospf_hdr *)(buf + ip_hl);
+            struct libnet_lsa_hdr *lsa_p =
+                (struct libnet_lsa_hdr *)(buf + 
+                ip_hl + oh_p->ospf_len);
+
+            lsa_p->lsa_sum = 0;
+            sum += libnet_in_cksum((u_int16_t *)lsa_p, len);
+            lsa_p->lsa_sum = LIBNET_CKSUM_CARRY(sum);
+            break;
+#if 0
+            /*
+             *  Reworked fletcher checksum taken from RFC 1008.
+             */
+            int c0, c1;
+            struct libnet_lsa_hdr *lsa_p = (struct libnet_lsa_hdr *)buf;
+            u_int8_t *p, *p1, *p2, *p3;
+
+            c0 = 0;
+            c1 = 0;
+
+            lsa_p->lsa_cksum = 0;
+
+            p = buf;
+            p1 = buf;
+            p3 = buf + len;             /* beginning and end of buf */
+
+            while (p1 < p3)
+            {
+                p2 = p1 + LIBNET_MODX;
+                if (p2 > p3)
+                {
+                    p2 = p3;
+                }
+  
+                for (p = p1; p < p2; p++)
+                {
+                    c0 += (*p);
+                    c1 += c0;
+                }
+
+                c0 %= 255;
+                c1 %= 255;      /* modular 255 */
+ 
+                p1 = p2;
+            }
+
+#if AWR_PLEASE_REWORK_THIS
+            lsa_p->lsa_cksum[0] = (((len - 17) * c0 - c1) % 255);
+            if (lsa_p->lsa_cksum[0] <= 0)
+            {
+                lsa_p->lsa_cksum[0] += 255;
+            }
+
+            lsa_p->lsa_cksum[1] = (510 - c0 - lsa_p->lsa_cksum[0]);
+            if (lsa_p->lsa_cksum[1] > 255)
+            {
+                lsa_p->lsa_cksum[1] -= 255;
+            }
+#endif
+            break;
+#endif
+        }
+        case IPPROTO_IP:
+        {
+            iph_p->ip_sum = 0;
+            sum = libnet_in_cksum((u_int16_t *)iph_p, ip_hl);
+            iph_p->ip_sum = LIBNET_CKSUM_CARRY(sum);
+            break;
+        }
+        case IPPROTO_VRRP:
+        {
+            struct libnet_vrrp_hdr *vrrph_p =
+                (struct libnet_vrrp_hdr *)(buf + ip_hl);
+
+            vrrph_p->vrrp_sum = 0;
+            sum = libnet_in_cksum((u_int16_t *)vrrph_p, len);
+            vrrph_p->vrrp_sum = LIBNET_CKSUM_CARRY(sum);
+            break;
+        }
+        case LIBNET_PROTO_CDP:
+        {   /* XXX - Broken: how can we easily get the entire packet size? */
+            struct libnet_cdp_hdr *cdph_p =
+                (struct libnet_cdp_hdr *)buf;
+
+            cdph_p->cdp_sum = 0;
+            sum = libnet_in_cksum((u_int16_t *)cdph_p, len);
+            cdph_p->cdp_sum = LIBNET_CKSUM_CARRY(sum);
+            break;
+        }
+        case LIBNET_PROTO_ISL:
+        {
+           // struct libnet_isl_hdr *islh_p =
+           //     (struct libnet_isl_hdr *)buf;
+            /*
+             *  Need to compute 4 byte CRC for the ethernet frame and for
+             *  the ISL frame itself.  Use the libnet_crc function.
+             */
+        }
+        default:
+        {
+            snprintf(l->err_buf, LIBNET_ERRBUF_SIZE,
+                "%s(): unsuported protocol %d\n", __func__, protocol);
+            return (-1);
+        }
+    }
+    return (1);
+}
+
+
+u_int16_t
+libnet_ip_check(u_int16_t *addr, int len)
+{
+    int sum;
+
+    sum = libnet_in_cksum(addr, len);
+    return (LIBNET_CKSUM_CARRY(sum));
+}
+
+/* EOF */