sbin/dhclient/packet.c

   1 /*      $OpenBSD: packet.c,v 1.9 2004/05/04 18:58:50 deraadt Exp $      */
   2
   3 /* Packet assembly code, originally contributed by Archie Cobbs. */
   4
   5 /*
   6  * Copyright (c) 1995, 1996, 1999 The Internet Software Consortium.
   7  * All rights reserved.
   8  *
   9  * Redistribution and use in source and binary forms, with or without
  10  * modification, are permitted provided that the following conditions
  11  * are met:
  12  *
  13  * 1. Redistributions of source code must retain the above copyright
  14  *    notice, this list of conditions and the following disclaimer.
  15  * 2. Redistributions in binary form must reproduce the above copyright
  16  *    notice, this list of conditions and the following disclaimer in the
  17  *    documentation and/or other materials provided with the distribution.
  18  * 3. Neither the name of The Internet Software Consortium nor the names
  19  *    of its contributors may be used to endorse or promote products derived
  20  *    from this software without specific prior written permission.
  21  *
  22  * THIS SOFTWARE IS PROVIDED BY THE INTERNET SOFTWARE CONSORTIUM AND
  23  * CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
  24  * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  25  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  26  * DISCLAIMED.  IN NO EVENT SHALL THE INTERNET SOFTWARE CONSORTIUM OR
  27  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  28  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  29  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
  30  * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  31  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  32  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  33  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  34  * SUCH DAMAGE.
  35  *
  36  * This software has been written for the Internet Software Consortium
  37  * by Ted Lemon <mellon@fugue.com> in cooperation with Vixie
  38  * Enterprises.  To learn more about the Internet Software Consortium,
  39  * see ``http://www.vix.com/isc''.  To learn more about Vixie
  40  * Enterprises, see ``http://www.vix.com''.
  41  */
  42
  43 #include <sys/cdefs.h>
  44 __FBSDID("$FreeBSD$");
  45
  46 #include "dhcpd.h"
  47
  48 #include <netinet/in_systm.h>
  49 #include <netinet/ip.h>
  50 #include <netinet/udp.h>
  51 #include <netinet/if_ether.h>
  52
  53 #define ETHER_HEADER_SIZE (ETHER_ADDR_LEN * 2 + sizeof(u_int16_t))
  54
  55 u_int32_t       checksum(unsigned char *, unsigned, u_int32_t);
  56 u_int32_t       wrapsum(u_int32_t);
  57
  58 u_int32_t
  59 checksum(unsigned char *buf, unsigned nbytes, u_int32_t sum)
  60 {
  61         int i;
  62
  63         /* Checksum all the pairs of bytes first... */
  64         for (i = 0; i < (nbytes & ~1U); i += 2) {
  65                 sum += (u_int16_t)ntohs(*((u_int16_t *)(buf + i)));
  66                 if (sum > 0xFFFF)
  67                         sum -= 0xFFFF;
  68         }
  69
  70         /*
  71          * If there's a single byte left over, checksum it, too.
  72          * Network byte order is big-endian, so the remaining byte is
  73          * the high byte.
  74          */
  75         if (i < nbytes) {
  76                 sum += buf[i] << 8;
  77                 if (sum > 0xFFFF)
  78                         sum -= 0xFFFF;
  79         }
  80
  81         return (sum);
  82 }
  83
  84 u_int32_t
  85 wrapsum(u_int32_t sum)
  86 {
  87         sum = ~sum & 0xFFFF;
  88         return (htons(sum));
  89 }
  90
  91 void
  92 assemble_hw_header(struct interface_info *interface, unsigned char *buf,
  93     int *bufix)
  94 {
  95         struct ether_header eh;
  96
  97         memset(eh.ether_dhost, 0xff, sizeof(eh.ether_dhost));
  98         if (interface->hw_address.hlen == sizeof(eh.ether_shost))
  99                 memcpy(eh.ether_shost, interface->hw_address.haddr,
 100                     sizeof(eh.ether_shost));
 101         else
 102                 memset(eh.ether_shost, 0x00, sizeof(eh.ether_shost));
 103
 104         eh.ether_type = htons(ETHERTYPE_IP);
 105
 106         memcpy(&buf[*bufix], &eh, ETHER_HEADER_SIZE);
 107         *bufix += ETHER_HEADER_SIZE;
 108 }
 109
 110 void
 111 assemble_udp_ip_header(unsigned char *buf, int *bufix, u_int32_t from,
 112     u_int32_t to, unsigned int port, unsigned char *data, int len)
 113 {
 114         struct ip ip;
 115         struct udphdr udp;
 116
 117         ip.ip_v = 4;
 118         ip.ip_hl = 5;
 119         ip.ip_tos = IPTOS_LOWDELAY;
 120         ip.ip_len = htons(sizeof(ip) + sizeof(udp) + len);
 121         ip.ip_id = 0;
 122         ip.ip_off = 0;
 123         ip.ip_ttl = 128;
 124         ip.ip_p = IPPROTO_UDP;
 125         ip.ip_sum = 0;
 126         ip.ip_src.s_addr = from;
 127         ip.ip_dst.s_addr = to;
 128
 129         ip.ip_sum = wrapsum(checksum((unsigned char *)&ip, sizeof(ip), 0));
 130
 131         /*
 132          * While the BPF -- used for broadcasts -- expects a "true" IP header
 133          * with all the bytes in network byte order, the raw socket interface
 134          * which is used for unicasts expects the ip_len field to be in host
 135          * byte order.  In both cases, the checksum has to be correct, so this
 136          * is as good a place as any to turn the bytes around again.
 137          */
 138         if (to != INADDR_BROADCAST)
 139                 ip.ip_len = ntohs(ip.ip_len);
 140
 141         memcpy(&buf[*bufix], &ip, sizeof(ip));
 142         *bufix += sizeof(ip);
 143
 144         udp.uh_sport = htons(LOCAL_PORT);       /* XXX */
 145         udp.uh_dport = port;                    /* XXX */
 146         udp.uh_ulen = htons(sizeof(udp) + len);
 147         memset(&udp.uh_sum, 0, sizeof(udp.uh_sum));
 148
 149         udp.uh_sum = wrapsum(checksum((unsigned char *)&udp, sizeof(udp),
 150             checksum(data, len, checksum((unsigned char *)&ip.ip_src,
 151             2 * sizeof(ip.ip_src),
 152             IPPROTO_UDP + (u_int32_t)ntohs(udp.uh_ulen)))));
 153
 154         memcpy(&buf[*bufix], &udp, sizeof(udp));
 155         *bufix += sizeof(udp);
 156 }
 157
 158 ssize_t
 159 decode_hw_header(unsigned char *buf, int bufix, struct hardware *from)
 160 {
 161         struct ether_header eh;
 162
 163         memcpy(&eh, buf + bufix, ETHER_HEADER_SIZE);
 164
 165         memcpy(from->haddr, eh.ether_shost, sizeof(eh.ether_shost));
 166         from->htype = ARPHRD_ETHER;
 167         from->hlen = sizeof(eh.ether_shost);
 168
 169         return (sizeof(eh));
 170 }
 171
 172 ssize_t
 173 decode_udp_ip_header(unsigned char *buf, int bufix, struct sockaddr_in *from,
 174     unsigned char *data, int buflen)
 175 {
 176         struct ip *ip;
 177         struct udphdr *udp;
 178         u_int32_t ip_len = (buf[bufix] & 0xf) << 2;
 179         u_int32_t sum, usum;
 180         static int ip_packets_seen;
 181         static int ip_packets_bad_checksum;
 182         static int udp_packets_seen;
 183         static int udp_packets_bad_checksum;
 184         static int udp_packets_length_checked;
 185         static int udp_packets_length_overflow;
 186         int len = 0;
 187
 188         ip = (struct ip *)(buf + bufix);
 189         udp = (struct udphdr *)(buf + bufix + ip_len);
 190
 191         /* Check the IP header checksum - it should be zero. */
 192         ip_packets_seen++;
 193         if (wrapsum(checksum(buf + bufix, ip_len, 0)) != 0) {
 194                 ip_packets_bad_checksum++;
 195                 if (ip_packets_seen > 4 &&
 196                     (ip_packets_seen / ip_packets_bad_checksum) < 2) {
 197                         note("%d bad IP checksums seen in %d packets",
 198                             ip_packets_bad_checksum, ip_packets_seen);
 199                         ip_packets_seen = ip_packets_bad_checksum = 0;
 200                 }
 201                 return (-1);
 202         }
 203
 204         if (ntohs(ip->ip_len) != buflen)
 205                 debug("ip length %d disagrees with bytes received %d.",
 206                     ntohs(ip->ip_len), buflen);
 207
 208         memcpy(&from->sin_addr, &ip->ip_src, 4);
 209
 210         /*
 211          * Compute UDP checksums, including the ``pseudo-header'', the
 212          * UDP header and the data.   If the UDP checksum field is zero,
 213          * we're not supposed to do a checksum.
 214          */
 215         if (!data) {
 216                 data = buf + bufix + ip_len + sizeof(*udp);
 217                 len = ntohs(udp->uh_ulen) - sizeof(*udp);
 218                 udp_packets_length_checked++;
 219                 if (len + data > buf + bufix + buflen) {
 220                         udp_packets_length_overflow++;
 221                         if (udp_packets_length_checked > 4 &&
 222                             (udp_packets_length_checked /
 223                             udp_packets_length_overflow) < 2) {
 224                                 note("%d udp packets in %d too long - dropped",
 225                                     udp_packets_length_overflow,
 226                                     udp_packets_length_checked);
 227                                 udp_packets_length_overflow =
 228                                     udp_packets_length_checked = 0;
 229                         }
 230                         return (-1);
 231                 }
 232                 if (len + data != buf + bufix + buflen)
 233                         debug("accepting packet with data after udp payload.");
 234         }
 235
 236         usum = udp->uh_sum;
 237         udp->uh_sum = 0;
 238
 239         sum = wrapsum(checksum((unsigned char *)udp, sizeof(*udp),
 240             checksum(data, len, checksum((unsigned char *)&ip->ip_src,
 241             2 * sizeof(ip->ip_src),
 242             IPPROTO_UDP + (u_int32_t)ntohs(udp->uh_ulen)))));
 243
 244         udp_packets_seen++;
 245         if (usum && usum != sum) {
 246                 udp_packets_bad_checksum++;
 247                 if (udp_packets_seen > 4 &&
 248                     (udp_packets_seen / udp_packets_bad_checksum) < 2) {
 249                         note("%d bad udp checksums in %d packets",
 250                             udp_packets_bad_checksum, udp_packets_seen);
 251                         udp_packets_seen = udp_packets_bad_checksum = 0;
 252                 }
 253                 return (-1);
 254         }
 255
 256         memcpy(&from->sin_port, &udp->uh_sport, sizeof(udp->uh_sport));
 257
 258         return (ip_len + sizeof(*udp));
 259 }