Annotation of embedaddon/dhcp/common/bpf.c, revision 1.1
1.1 ! misho 1: /* bpf.c
! 2:
! 3: BPF socket interface code, originally contributed by Archie Cobbs. */
! 4:
! 5: /*
! 6: * Copyright (c) 2004,2007,2009 by Internet Systems Consortium, Inc. ("ISC")
! 7: * Copyright (c) 1996-2003 by Internet Software Consortium
! 8: *
! 9: * Permission to use, copy, modify, and distribute this software for any
! 10: * purpose with or without fee is hereby granted, provided that the above
! 11: * copyright notice and this permission notice appear in all copies.
! 12: *
! 13: * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES
! 14: * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
! 15: * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR
! 16: * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
! 17: * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
! 18: * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
! 19: * OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
! 20: *
! 21: * Internet Systems Consortium, Inc.
! 22: * 950 Charter Street
! 23: * Redwood City, CA 94063
! 24: * <info@isc.org>
! 25: * https://www.isc.org/
! 26: *
! 27: * This software was contributed to Internet Systems Consortium
! 28: * by Archie Cobbs.
! 29: *
! 30: * Patches for FDDI support on Digital Unix were written by Bill
! 31: * Stapleton, and maintained for a while by Mike Meredith before he
! 32: * managed to get me to integrate them.
! 33: */
! 34:
! 35: #include "dhcpd.h"
! 36: #if defined (USE_BPF_SEND) || defined (USE_BPF_RECEIVE) \
! 37: || defined (USE_LPF_RECEIVE)
! 38: # if defined (USE_LPF_RECEIVE)
! 39: # include <asm/types.h>
! 40: # include <linux/filter.h>
! 41: # define bpf_insn sock_filter /* Linux: dare to be gratuitously different. */
! 42: # else
! 43: # include <sys/ioctl.h>
! 44: # include <sys/uio.h>
! 45: # include <net/bpf.h>
! 46: # include <net/if_types.h>
! 47: # if defined (NEED_OSF_PFILT_HACKS)
! 48: # include <net/pfilt.h>
! 49: # endif
! 50: # endif
! 51:
! 52: #include <netinet/in_systm.h>
! 53: #include "includes/netinet/ip.h"
! 54: #include "includes/netinet/udp.h"
! 55: #include "includes/netinet/if_ether.h"
! 56: #endif
! 57:
! 58: #ifdef USE_BPF_RECEIVE
! 59: #include <ifaddrs.h>
! 60: #endif
! 61:
! 62: #include <errno.h>
! 63:
! 64: /* Reinitializes the specified interface after an address change. This
! 65: is not required for packet-filter APIs. */
! 66:
! 67: #ifdef USE_BPF_SEND
! 68: void if_reinitialize_send (info)
! 69: struct interface_info *info;
! 70: {
! 71: }
! 72: #endif
! 73:
! 74: #ifdef USE_BPF_RECEIVE
! 75: void if_reinitialize_receive (info)
! 76: struct interface_info *info;
! 77: {
! 78: }
! 79: #endif
! 80:
! 81: /* Called by get_interface_list for each interface that's discovered.
! 82: Opens a packet filter for each interface and adds it to the select
! 83: mask. */
! 84:
! 85: #if defined (USE_BPF_SEND) || defined (USE_BPF_RECEIVE)
! 86: int if_register_bpf (info)
! 87: struct interface_info *info;
! 88: {
! 89: int sock;
! 90: char filename[50];
! 91: int b;
! 92:
! 93: /* Open a BPF device */
! 94: for (b = 0; 1; b++) {
! 95: /* %Audit% 31 bytes max. %2004.06.17,Safe% */
! 96: sprintf(filename, BPF_FORMAT, b);
! 97: sock = open (filename, O_RDWR, 0);
! 98: if (sock < 0) {
! 99: if (errno == EBUSY) {
! 100: continue;
! 101: } else {
! 102: if (!b)
! 103: log_fatal ("No bpf devices.%s%s%s",
! 104: " Please read the README",
! 105: " section for your operating",
! 106: " system.");
! 107: log_fatal ("Can't find free bpf: %m");
! 108: }
! 109: } else {
! 110: break;
! 111: }
! 112: }
! 113:
! 114: /* Set the BPF device to point at this interface. */
! 115: if (ioctl (sock, BIOCSETIF, info -> ifp) < 0)
! 116: log_fatal ("Can't attach interface %s to bpf device %s: %m",
! 117: info -> name, filename);
! 118:
! 119: get_hw_addr(info->name, &info->hw_address);
! 120:
! 121: return sock;
! 122: }
! 123: #endif /* USE_BPF_SEND || USE_BPF_RECEIVE */
! 124:
! 125: #ifdef USE_BPF_SEND
! 126: void if_register_send (info)
! 127: struct interface_info *info;
! 128: {
! 129: /* If we're using the bpf API for sending and receiving,
! 130: we don't need to register this interface twice. */
! 131: #ifndef USE_BPF_RECEIVE
! 132: info -> wfdesc = if_register_bpf (info, interface);
! 133: #else
! 134: info -> wfdesc = info -> rfdesc;
! 135: #endif
! 136: if (!quiet_interface_discovery)
! 137: log_info ("Sending on BPF/%s/%s%s%s",
! 138: info -> name,
! 139: print_hw_addr (info -> hw_address.hbuf [0],
! 140: info -> hw_address.hlen - 1,
! 141: &info -> hw_address.hbuf [1]),
! 142: (info -> shared_network ? "/" : ""),
! 143: (info -> shared_network ?
! 144: info -> shared_network -> name : ""));
! 145: }
! 146:
! 147: void if_deregister_send (info)
! 148: struct interface_info *info;
! 149: {
! 150: /* If we're using the bpf API for sending and receiving,
! 151: we don't need to register this interface twice. */
! 152: #ifndef USE_BPF_RECEIVE
! 153: close (info -> wfdesc);
! 154: #endif
! 155: info -> wfdesc = -1;
! 156:
! 157: if (!quiet_interface_discovery)
! 158: log_info ("Disabling output on BPF/%s/%s%s%s",
! 159: info -> name,
! 160: print_hw_addr (info -> hw_address.hbuf [0],
! 161: info -> hw_address.hlen - 1,
! 162: &info -> hw_address.hbuf [1]),
! 163: (info -> shared_network ? "/" : ""),
! 164: (info -> shared_network ?
! 165: info -> shared_network -> name : ""));
! 166: }
! 167: #endif /* USE_BPF_SEND */
! 168:
! 169: #if defined (USE_BPF_RECEIVE) || defined (USE_LPF_RECEIVE)
! 170: /* Packet filter program...
! 171: XXX Changes to the filter program may require changes to the constant
! 172: offsets used in if_register_send to patch the BPF program! XXX */
! 173:
! 174: struct bpf_insn dhcp_bpf_filter [] = {
! 175: /* Make sure this is an IP packet... */
! 176: BPF_STMT (BPF_LD + BPF_H + BPF_ABS, 12),
! 177: BPF_JUMP (BPF_JMP + BPF_JEQ + BPF_K, ETHERTYPE_IP, 0, 8),
! 178:
! 179: /* Make sure it's a UDP packet... */
! 180: BPF_STMT (BPF_LD + BPF_B + BPF_ABS, 23),
! 181: BPF_JUMP (BPF_JMP + BPF_JEQ + BPF_K, IPPROTO_UDP, 0, 6),
! 182:
! 183: /* Make sure this isn't a fragment... */
! 184: BPF_STMT(BPF_LD + BPF_H + BPF_ABS, 20),
! 185: BPF_JUMP(BPF_JMP + BPF_JSET + BPF_K, 0x1fff, 4, 0),
! 186:
! 187: /* Get the IP header length... */
! 188: BPF_STMT (BPF_LDX + BPF_B + BPF_MSH, 14),
! 189:
! 190: /* Make sure it's to the right port... */
! 191: BPF_STMT (BPF_LD + BPF_H + BPF_IND, 16),
! 192: BPF_JUMP (BPF_JMP + BPF_JEQ + BPF_K, 67, 0, 1), /* patch */
! 193:
! 194: /* If we passed all the tests, ask for the whole packet. */
! 195: BPF_STMT(BPF_RET+BPF_K, (u_int)-1),
! 196:
! 197: /* Otherwise, drop it. */
! 198: BPF_STMT(BPF_RET+BPF_K, 0),
! 199: };
! 200:
! 201: #if defined (DEC_FDDI)
! 202: struct bpf_insn *bpf_fddi_filter;
! 203: #endif
! 204:
! 205: int dhcp_bpf_filter_len = sizeof dhcp_bpf_filter / sizeof (struct bpf_insn);
! 206: #if defined (HAVE_TR_SUPPORT)
! 207: struct bpf_insn dhcp_bpf_tr_filter [] = {
! 208: /* accept all token ring packets due to variable length header */
! 209: /* if we want to get clever, insert the program here */
! 210:
! 211: /* If we passed all the tests, ask for the whole packet. */
! 212: BPF_STMT(BPF_RET+BPF_K, (u_int)-1),
! 213:
! 214: /* Otherwise, drop it. */
! 215: BPF_STMT(BPF_RET+BPF_K, 0),
! 216: };
! 217:
! 218: int dhcp_bpf_tr_filter_len = (sizeof dhcp_bpf_tr_filter /
! 219: sizeof (struct bpf_insn));
! 220: #endif /* HAVE_TR_SUPPORT */
! 221: #endif /* USE_LPF_RECEIVE || USE_BPF_RECEIVE */
! 222:
! 223: #if defined (USE_BPF_RECEIVE)
! 224: void if_register_receive (info)
! 225: struct interface_info *info;
! 226: {
! 227: int flag = 1;
! 228: struct bpf_version v;
! 229: struct bpf_program p;
! 230: #ifdef NEED_OSF_PFILT_HACKS
! 231: u_int32_t bits;
! 232: #endif
! 233: #ifdef DEC_FDDI
! 234: int link_layer;
! 235: #endif /* DEC_FDDI */
! 236:
! 237: /* Open a BPF device and hang it on this interface... */
! 238: info -> rfdesc = if_register_bpf (info);
! 239:
! 240: /* Make sure the BPF version is in range... */
! 241: if (ioctl (info -> rfdesc, BIOCVERSION, &v) < 0)
! 242: log_fatal ("Can't get BPF version: %m");
! 243:
! 244: if (v.bv_major != BPF_MAJOR_VERSION ||
! 245: v.bv_minor < BPF_MINOR_VERSION)
! 246: log_fatal ("BPF version mismatch - recompile DHCP!");
! 247:
! 248: /* Set immediate mode so that reads return as soon as a packet
! 249: comes in, rather than waiting for the input buffer to fill with
! 250: packets. */
! 251: if (ioctl (info -> rfdesc, BIOCIMMEDIATE, &flag) < 0)
! 252: log_fatal ("Can't set immediate mode on bpf device: %m");
! 253:
! 254: #ifdef NEED_OSF_PFILT_HACKS
! 255: /* Allow the copyall flag to be set... */
! 256: if (ioctl(info -> rfdesc, EIOCALLOWCOPYALL, &flag) < 0)
! 257: log_fatal ("Can't set ALLOWCOPYALL: %m");
! 258:
! 259: /* Clear all the packet filter mode bits first... */
! 260: bits = 0;
! 261: if (ioctl (info -> rfdesc, EIOCMBIS, &bits) < 0)
! 262: log_fatal ("Can't clear pfilt bits: %m");
! 263:
! 264: /* Set the ENBATCH, ENCOPYALL, ENBPFHDR bits... */
! 265: bits = ENBATCH | ENCOPYALL | ENBPFHDR;
! 266: if (ioctl (info -> rfdesc, EIOCMBIS, &bits) < 0)
! 267: log_fatal ("Can't set ENBATCH|ENCOPYALL|ENBPFHDR: %m");
! 268: #endif
! 269: /* Get the required BPF buffer length from the kernel. */
! 270: if (ioctl (info -> rfdesc, BIOCGBLEN, &info -> rbuf_max) < 0)
! 271: log_fatal ("Can't get bpf buffer length: %m");
! 272: info -> rbuf = dmalloc (info -> rbuf_max, MDL);
! 273: if (!info -> rbuf)
! 274: log_fatal ("Can't allocate %ld bytes for bpf input buffer.",
! 275: (long)(info -> rbuf_max));
! 276: info -> rbuf_offset = 0;
! 277: info -> rbuf_len = 0;
! 278:
! 279: /* Set up the bpf filter program structure. */
! 280: p.bf_len = dhcp_bpf_filter_len;
! 281:
! 282: #ifdef DEC_FDDI
! 283: /* See if this is an FDDI interface, flag it for later. */
! 284: if (ioctl(info -> rfdesc, BIOCGDLT, &link_layer) >= 0 &&
! 285: link_layer == DLT_FDDI) {
! 286: if (!bpf_fddi_filter) {
! 287: bpf_fddi_filter = dmalloc (sizeof bpf_fddi_filter,
! 288: MDL);
! 289: if (!bpf_fddi_filter)
! 290: log_fatal ("No memory for FDDI filter.");
! 291: memcpy (bpf_fddi_filter,
! 292: dhcp_bpf_filter, sizeof dhcp_bpf_filter);
! 293: /* Patch the BPF program to account for the difference
! 294: in length between ethernet headers (14), FDDI and
! 295: 802.2 headers (16 +8=24, +10).
! 296: XXX changes to filter program may require changes to
! 297: XXX the insn number(s) used below! */
! 298: bpf_fddi_filter[0].k += 10;
! 299: bpf_fddi_filter[2].k += 10;
! 300: bpf_fddi_filter[4].k += 10;
! 301: bpf_fddi_filter[6].k += 10;
! 302: bpf_fddi_filter[7].k += 10;
! 303: }
! 304: p.bf_insns = bpf_fddi_filter;
! 305: } else
! 306: #endif /* DEC_FDDI */
! 307: p.bf_insns = dhcp_bpf_filter;
! 308:
! 309: /* Patch the server port into the BPF program...
! 310: XXX changes to filter program may require changes
! 311: to the insn number(s) used below! XXX */
! 312: dhcp_bpf_filter [8].k = ntohs (local_port);
! 313:
! 314: if (ioctl (info -> rfdesc, BIOCSETF, &p) < 0)
! 315: log_fatal ("Can't install packet filter program: %m");
! 316: if (!quiet_interface_discovery)
! 317: log_info ("Listening on BPF/%s/%s%s%s",
! 318: info -> name,
! 319: print_hw_addr (info -> hw_address.hbuf [0],
! 320: info -> hw_address.hlen - 1,
! 321: &info -> hw_address.hbuf [1]),
! 322: (info -> shared_network ? "/" : ""),
! 323: (info -> shared_network ?
! 324: info -> shared_network -> name : ""));
! 325: }
! 326:
! 327: void if_deregister_receive (info)
! 328: struct interface_info *info;
! 329: {
! 330: close (info -> rfdesc);
! 331: info -> rfdesc = -1;
! 332:
! 333: if (!quiet_interface_discovery)
! 334: log_info ("Disabling input on BPF/%s/%s%s%s",
! 335: info -> name,
! 336: print_hw_addr (info -> hw_address.hbuf [0],
! 337: info -> hw_address.hlen - 1,
! 338: &info -> hw_address.hbuf [1]),
! 339: (info -> shared_network ? "/" : ""),
! 340: (info -> shared_network ?
! 341: info -> shared_network -> name : ""));
! 342: }
! 343: #endif /* USE_BPF_RECEIVE */
! 344:
! 345: #ifdef USE_BPF_SEND
! 346: ssize_t send_packet (interface, packet, raw, len, from, to, hto)
! 347: struct interface_info *interface;
! 348: struct packet *packet;
! 349: struct dhcp_packet *raw;
! 350: size_t len;
! 351: struct in_addr from;
! 352: struct sockaddr_in *to;
! 353: struct hardware *hto;
! 354: {
! 355: unsigned hbufp = 0, ibufp = 0;
! 356: double hw [4];
! 357: double ip [32];
! 358: struct iovec iov [3];
! 359: int result;
! 360:
! 361: if (!strcmp (interface -> name, "fallback"))
! 362: return send_fallback (interface, packet, raw,
! 363: len, from, to, hto);
! 364:
! 365: /* Assemble the headers... */
! 366: assemble_hw_header (interface, (unsigned char *)hw, &hbufp, hto);
! 367: assemble_udp_ip_header (interface,
! 368: (unsigned char *)ip, &ibufp, from.s_addr,
! 369: to -> sin_addr.s_addr, to -> sin_port,
! 370: (unsigned char *)raw, len);
! 371:
! 372: /* Fire it off */
! 373: iov [0].iov_base = ((char *)hw);
! 374: iov [0].iov_len = hbufp;
! 375: iov [1].iov_base = ((char *)ip);
! 376: iov [1].iov_len = ibufp;
! 377: iov [2].iov_base = (char *)raw;
! 378: iov [2].iov_len = len;
! 379:
! 380: result = writev(interface -> wfdesc, iov, 3);
! 381: if (result < 0)
! 382: log_error ("send_packet: %m");
! 383: return result;
! 384: }
! 385: #endif /* USE_BPF_SEND */
! 386:
! 387: #ifdef USE_BPF_RECEIVE
! 388: ssize_t receive_packet (interface, buf, len, from, hfrom)
! 389: struct interface_info *interface;
! 390: unsigned char *buf;
! 391: size_t len;
! 392: struct sockaddr_in *from;
! 393: struct hardware *hfrom;
! 394: {
! 395: int length = 0;
! 396: int offset = 0;
! 397: struct bpf_hdr hdr;
! 398: unsigned paylen;
! 399:
! 400: /* All this complexity is because BPF doesn't guarantee
! 401: that only one packet will be returned at a time. We're
! 402: getting what we deserve, though - this is a terrible abuse
! 403: of the BPF interface. Sigh. */
! 404:
! 405: /* Process packets until we get one we can return or until we've
! 406: done a read and gotten nothing we can return... */
! 407:
! 408: do {
! 409: /* If the buffer is empty, fill it. */
! 410: if (interface -> rbuf_offset == interface -> rbuf_len) {
! 411: length = read (interface -> rfdesc,
! 412: interface -> rbuf,
! 413: (size_t)interface -> rbuf_max);
! 414: if (length <= 0) {
! 415: #ifdef __FreeBSD__
! 416: if (errno == ENXIO) {
! 417: #else
! 418: if (errno == EIO) {
! 419: #endif
! 420: dhcp_interface_remove
! 421: ((omapi_object_t *)interface,
! 422: (omapi_object_t *)0);
! 423: }
! 424: return length;
! 425: }
! 426: interface -> rbuf_offset = 0;
! 427: interface -> rbuf_len = BPF_WORDALIGN (length);
! 428: }
! 429:
! 430: /* If there isn't room for a whole bpf header, something went
! 431: wrong, but we'll ignore it and hope it goes away... XXX */
! 432: if (interface -> rbuf_len -
! 433: interface -> rbuf_offset < sizeof hdr) {
! 434: interface -> rbuf_offset = interface -> rbuf_len;
! 435: continue;
! 436: }
! 437:
! 438: /* Copy out a bpf header... */
! 439: memcpy (&hdr, &interface -> rbuf [interface -> rbuf_offset],
! 440: sizeof hdr);
! 441:
! 442: /* If the bpf header plus data doesn't fit in what's left
! 443: of the buffer, stick head in sand yet again... */
! 444: if (interface -> rbuf_offset +
! 445: hdr.bh_hdrlen + hdr.bh_caplen > interface -> rbuf_len) {
! 446: interface -> rbuf_offset = interface -> rbuf_len;
! 447: continue;
! 448: }
! 449:
! 450: /* If the captured data wasn't the whole packet, or if
! 451: the packet won't fit in the input buffer, all we
! 452: can do is drop it. */
! 453: if (hdr.bh_caplen != hdr.bh_datalen) {
! 454: interface -> rbuf_offset =
! 455: BPF_WORDALIGN (interface -> rbuf_offset +
! 456: hdr.bh_hdrlen + hdr.bh_caplen);
! 457: continue;
! 458: }
! 459:
! 460: /* Skip over the BPF header... */
! 461: interface -> rbuf_offset += hdr.bh_hdrlen;
! 462:
! 463: /* Decode the physical header... */
! 464: offset = decode_hw_header (interface,
! 465: interface -> rbuf,
! 466: interface -> rbuf_offset,
! 467: hfrom);
! 468:
! 469: /* If a physical layer checksum failed (dunno of any
! 470: physical layer that supports this, but WTH), skip this
! 471: packet. */
! 472: if (offset < 0) {
! 473: interface -> rbuf_offset =
! 474: BPF_WORDALIGN (interface -> rbuf_offset +
! 475: hdr.bh_caplen);
! 476: continue;
! 477: }
! 478: interface -> rbuf_offset += offset;
! 479: hdr.bh_caplen -= offset;
! 480:
! 481: /* Decode the IP and UDP headers... */
! 482: offset = decode_udp_ip_header (interface,
! 483: interface -> rbuf,
! 484: interface -> rbuf_offset,
! 485: from, hdr.bh_caplen, &paylen);
! 486:
! 487: /* If the IP or UDP checksum was bad, skip the packet... */
! 488: if (offset < 0) {
! 489: interface -> rbuf_offset =
! 490: BPF_WORDALIGN (interface -> rbuf_offset +
! 491: hdr.bh_caplen);
! 492: continue;
! 493: }
! 494: interface -> rbuf_offset = interface -> rbuf_offset + offset;
! 495: hdr.bh_caplen -= offset;
! 496:
! 497: /* If there's not enough room to stash the packet data,
! 498: we have to skip it (this shouldn't happen in real
! 499: life, though). */
! 500: if (hdr.bh_caplen > len) {
! 501: interface -> rbuf_offset =
! 502: BPF_WORDALIGN (interface -> rbuf_offset +
! 503: hdr.bh_caplen);
! 504: continue;
! 505: }
! 506:
! 507: /* Copy out the data in the packet... */
! 508: memcpy(buf, interface->rbuf + interface->rbuf_offset, paylen);
! 509: interface -> rbuf_offset =
! 510: BPF_WORDALIGN (interface -> rbuf_offset +
! 511: hdr.bh_caplen);
! 512: return paylen;
! 513: } while (!length);
! 514: return 0;
! 515: }
! 516:
! 517: int can_unicast_without_arp (ip)
! 518: struct interface_info *ip;
! 519: {
! 520: return 1;
! 521: }
! 522:
! 523: int can_receive_unicast_unconfigured (ip)
! 524: struct interface_info *ip;
! 525: {
! 526: return 1;
! 527: }
! 528:
! 529: int supports_multiple_interfaces (ip)
! 530: struct interface_info *ip;
! 531: {
! 532: return 1;
! 533: }
! 534:
! 535: void maybe_setup_fallback ()
! 536: {
! 537: isc_result_t status;
! 538: struct interface_info *fbi = (struct interface_info *)0;
! 539: if (setup_fallback (&fbi, MDL)) {
! 540: if_register_fallback (fbi);
! 541: status = omapi_register_io_object ((omapi_object_t *)fbi,
! 542: if_readsocket, 0,
! 543: fallback_discard, 0, 0);
! 544: if (status != ISC_R_SUCCESS)
! 545: log_fatal ("Can't register I/O handle for %s: %s",
! 546: fbi -> name, isc_result_totext (status));
! 547: interface_dereference (&fbi, MDL);
! 548: }
! 549: }
! 550:
! 551: void
! 552: get_hw_addr(const char *name, struct hardware *hw) {
! 553: struct ifaddrs *ifa;
! 554: struct ifaddrs *p;
! 555: struct sockaddr_dl *sa;
! 556:
! 557: if (getifaddrs(&ifa) != 0) {
! 558: log_fatal("Error getting interface information; %m");
! 559: }
! 560:
! 561: /*
! 562: * Loop through our interfaces finding a match.
! 563: */
! 564: sa = NULL;
! 565: for (p=ifa; (p != NULL) && (sa == NULL); p = p->ifa_next) {
! 566: if ((p->ifa_addr->sa_family == AF_LINK) &&
! 567: !strcmp(p->ifa_name, name)) {
! 568: sa = (struct sockaddr_dl *)p->ifa_addr;
! 569: }
! 570: }
! 571: if (sa == NULL) {
! 572: log_fatal("No interface called '%s'", name);
! 573: }
! 574:
! 575: /*
! 576: * Pull out the appropriate information.
! 577: */
! 578: switch (sa->sdl_type) {
! 579: case IFT_ETHER:
! 580: hw->hlen = sa->sdl_alen + 1;
! 581: hw->hbuf[0] = HTYPE_ETHER;
! 582: memcpy(&hw->hbuf[1], LLADDR(sa), sa->sdl_alen);
! 583: break;
! 584: case IFT_ISO88023:
! 585: case IFT_ISO88024: /* "token ring" */
! 586: case IFT_ISO88025:
! 587: case IFT_ISO88026:
! 588: hw->hlen = sa->sdl_alen + 1;
! 589: hw->hbuf[0] = HTYPE_IEEE802;
! 590: memcpy(&hw->hbuf[1], LLADDR(sa), sa->sdl_alen);
! 591: break;
! 592: #ifdef IFT_FDDI
! 593: case IFT_FDDI:
! 594: hw->hlen = sa->sdl_alen + 1;
! 595: hw->hbuf[0] = HTYPE_FDDI;
! 596: memcpy(&hw->hbuf[1], LLADDR(sa), sa->sdl_alen);
! 597: break;
! 598: #endif /* IFT_FDDI */
! 599: default:
! 600: log_fatal("Unsupported device type %d for \"%s\"",
! 601: sa->sdl_type, name);
! 602: }
! 603:
! 604: freeifaddrs(ifa);
! 605: }
! 606: #endif
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to bpf.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / dhcp / common