Annotation of embedaddon/dhcp/common/dlpi.c, revision 1.1
1.1 ! misho 1: /* dlpi.c
! 2:
! 3: Data Link Provider Interface (DLPI) network interface code. */
! 4:
! 5: /*
! 6: * Copyright (c) 2009-2011 by Internet Systems Consortium, Inc. ("ISC")
! 7: * Copyright (c) 2004,2007 by Internet Systems Consortium, Inc. ("ISC")
! 8: * Copyright (c) 1996-2003 by Internet Software Consortium
! 9: *
! 10: * Permission to use, copy, modify, and distribute this software for any
! 11: * purpose with or without fee is hereby granted, provided that the above
! 12: * copyright notice and this permission notice appear in all copies.
! 13: *
! 14: * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES
! 15: * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
! 16: * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR
! 17: * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
! 18: * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
! 19: * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
! 20: * OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
! 21: *
! 22: * Internet Systems Consortium, Inc.
! 23: * 950 Charter Street
! 24: * Redwood City, CA 94063
! 25: * <info@isc.org>
! 26: * https://www.isc.org/
! 27: *
! 28: * This software was written for Internet Systems Consortium
! 29: * by Eric James Negaard, <lmdejn@lmd.ericsson.se>. To learn more about
! 30: * Internet Systems Consortium, see ``https://www.isc.org''.
! 31: *
! 32: * Joost Mulders has also done considerable work in debugging the DLPI API
! 33: * support on Solaris and getting this code to work properly on a variety
! 34: * of different Solaris platforms.
! 35: */
! 36:
! 37: /*
! 38: * Based largely in part to the existing NIT code in nit.c.
! 39: *
! 40: * This code has been developed and tested on sparc-based machines running
! 41: * SunOS 5.5.1, with le and hme network interfaces. It should be pretty
! 42: * generic, though.
! 43: */
! 44:
! 45: /*
! 46: * Implementation notes:
! 47: *
! 48: * I first tried to write this code to the "vanilla" DLPI 2.0 API.
! 49: * It worked on a Sun Ultra-1 with a hme interface, but didn't work
! 50: * on Sun SparcStation 5's with "le" interfaces (the packets sent out
! 51: * via dlpiunitdatareq contained an Ethernet type of 0x0000 instead
! 52: * of the expected 0x0800).
! 53: *
! 54: * Therefore I added the "DLPI_RAW" code which is a Sun extension to
! 55: * the DLPI standard. This code works on both of the above machines.
! 56: * This is configurable in the OS-dependent include file by defining
! 57: * USE_DLPI_RAW.
! 58: *
! 59: * It quickly became apparant that I should also use the "pfmod"
! 60: * STREAMS module to cut down on the amount of user level packet
! 61: * processing. I don't know how widely available "pfmod" is, so it's
! 62: * use is conditionally included. This is configurable in the
! 63: * OS-dependent include file by defining USE_DLPI_PFMOD.
! 64: *
! 65: * A major quirk on the Sun's at least, is that no packets seem to get
! 66: * sent out the interface until six seconds after the interface is
! 67: * first "attached" to [per system reboot] (it's actually from when
! 68: * the interface is attached, not when it is plumbed, so putting a
! 69: * sleep into the dhclient-script at PREINIT time doesn't help). I
! 70: * HAVE tried, without success to poll the fd to see when it is ready
! 71: * for writing. This doesn't help at all. If the sleeps are not done,
! 72: * the initial DHCPREQUEST or DHCPDISCOVER never gets sent out, so
! 73: * I've put them here, when register_send and register_receive are
! 74: * called (split up into two three-second sleeps between the notices,
! 75: * so that it doesn't seem like so long when you're watching :-). The
! 76: * amount of time to sleep is configurable in the OS-dependent include
! 77: * file by defining DLPI_FIRST_SEND_WAIT to be the number of seconds
! 78: * to sleep.
! 79: */
! 80:
! 81: /*
! 82: * The Open Group Technical Standard can be found here:
! 83: * http://www.opengroup.org/onlinepubs/009618899/index.htm
! 84: *
! 85: * The HP DLPI Programmer's Guide can be found here:
! 86: * http://docs.hp.com/en/B2355-90139/index.html
! 87: */
! 88:
! 89: #include "dhcpd.h"
! 90:
! 91: #if defined (USE_DLPI_SEND) || defined (USE_DLPI_RECEIVE) || \
! 92: defined(USE_DLPI_HWADDR)
! 93:
! 94: # include <sys/ioctl.h>
! 95: # include <sys/time.h>
! 96: # include <sys/dlpi.h>
! 97: # include <stropts.h>
! 98: # ifdef USE_DLPI_PFMOD
! 99: # include <sys/pfmod.h>
! 100: # endif
! 101: #include <poll.h>
! 102: #include <errno.h>
! 103:
! 104: # include <netinet/in_systm.h>
! 105: # include "includes/netinet/ip.h"
! 106: # include "includes/netinet/udp.h"
! 107: # include "includes/netinet/if_ether.h"
! 108:
! 109: # ifdef USE_DLPI_PFMOD
! 110: # ifdef USE_DLPI_RAW
! 111: # define DLPI_MODNAME "DLPI+RAW+PFMOD"
! 112: # else
! 113: # define DLPI_MODNAME "DLPI+PFMOD"
! 114: # endif
! 115: # else
! 116: # ifdef USE_DLPI_RAW
! 117: # define DLPI_MODNAME "DLPI+RAW"
! 118: # else
! 119: # define DLPI_MODNAME "DLPI"
! 120: # endif
! 121: # endif
! 122:
! 123: # ifndef ABS
! 124: # define ABS(x) ((x) >= 0 ? (x) : 0-(x))
! 125: # endif
! 126:
! 127: #if defined(USE_DLPI_PFMOD) || defined(USE_DLPI_RAW)
! 128: static int strioctl (int fd, int cmd, int timeout, int len, char *dp);
! 129: #endif
! 130:
! 131: #define DLPI_MAXDLBUF 8192 /* Buffer size */
! 132: #define DLPI_MAXDLADDR 1024 /* Max address size */
! 133: #define DLPI_DEVDIR "/dev/" /* Device directory */
! 134:
! 135: static int dlpiopen(const char *ifname);
! 136: static int dlpiunit (char *ifname);
! 137: static int dlpiinforeq (int fd);
! 138: static int dlpiphysaddrreq (int fd, unsigned long addrtype);
! 139: static int dlpiattachreq (int fd, unsigned long ppa);
! 140: static int dlpibindreq (int fd, unsigned long sap, unsigned long max_conind,
! 141: unsigned long service_mode, unsigned long conn_mgmt,
! 142: unsigned long xidtest);
! 143: #if defined(UNUSED_DLPI_INTERFACE)
! 144: /* These functions are unused at present, but may be used at a later date.
! 145: * defined out to avoid compiler warnings about unused static functions.
! 146: */
! 147: static int dlpidetachreq (int fd);
! 148: static int dlpiunbindreq (int fd);
! 149: #endif
! 150: static int dlpiokack (int fd, char *bufp);
! 151: static int dlpiinfoack (int fd, char *bufp);
! 152: static int dlpiphysaddrack (int fd, char *bufp);
! 153: static int dlpibindack (int fd, char *bufp);
! 154: #if defined(USE_DLPI_SEND) || defined(USE_DLPI_RECEIVE)
! 155: /* These functions are not used if we're only sourcing the get_hw_addr()
! 156: * function (for USE_SOCKETS).
! 157: */
! 158: static int dlpiunitdatareq (int fd, unsigned char *addr, int addrlen,
! 159: unsigned long minpri, unsigned long maxpri,
! 160: unsigned char *data, int datalen);
! 161: static int dlpiunitdataind (int fd,
! 162: unsigned char *dstaddr,
! 163: unsigned long *dstaddrlen,
! 164: unsigned char *srcaddr,
! 165: unsigned long *srcaddrlen,
! 166: unsigned long *grpaddr,
! 167: unsigned char *data,
! 168: int datalen);
! 169: #endif /* !USE_DLPI_HWADDR: USE_DLPI_SEND || USE_DLPI_RECEIVE */
! 170: static int expected (unsigned long prim, union DL_primitives *dlp,
! 171: int msgflags);
! 172: static int strgetmsg (int fd, struct strbuf *ctlp, struct strbuf *datap,
! 173: int *flagsp, char *caller);
! 174:
! 175: /* Reinitializes the specified interface after an address change. This
! 176: is not required for packet-filter APIs. */
! 177:
! 178: #ifdef USE_DLPI_SEND
! 179: void if_reinitialize_send (info)
! 180: struct interface_info *info;
! 181: {
! 182: }
! 183: #endif
! 184:
! 185: #ifdef USE_DLPI_RECEIVE
! 186: void if_reinitialize_receive (info)
! 187: struct interface_info *info;
! 188: {
! 189: }
! 190: #endif
! 191:
! 192: /* Called by get_interface_list for each interface that's discovered.
! 193: Opens a packet filter for each interface and adds it to the select
! 194: mask. */
! 195:
! 196: int if_register_dlpi (info)
! 197: struct interface_info *info;
! 198: {
! 199: int sock;
! 200: int unit;
! 201: long buf [DLPI_MAXDLBUF];
! 202: union DL_primitives *dlp;
! 203:
! 204: dlp = (union DL_primitives *)buf;
! 205:
! 206: /* Open a DLPI device */
! 207: if ((sock = dlpiopen (info -> name)) < 0) {
! 208: log_fatal ("Can't open DLPI device for %s: %m", info -> name);
! 209: }
! 210:
! 211: /*
! 212: * Submit a DL_INFO_REQ request, to find the dl_mac_type and
! 213: * dl_provider_style
! 214: */
! 215: if (dlpiinforeq(sock) < 0 || dlpiinfoack(sock, (char *)buf) < 0) {
! 216: log_fatal ("Can't get DLPI MAC type for %s: %m", info -> name);
! 217: } else {
! 218: switch (dlp -> info_ack.dl_mac_type) {
! 219: case DL_CSMACD: /* IEEE 802.3 */
! 220: case DL_ETHER:
! 221: info -> hw_address.hbuf [0] = HTYPE_ETHER;
! 222: break;
! 223: /* adding token ring 5/1999 - mayer@ping.at */
! 224: case DL_TPR:
! 225: info -> hw_address.hbuf [0] = HTYPE_IEEE802;
! 226: break;
! 227: case DL_FDDI:
! 228: info -> hw_address.hbuf [0] = HTYPE_FDDI;
! 229: break;
! 230: default:
! 231: log_fatal("%s: unsupported DLPI MAC type %lu", info->name,
! 232: (unsigned long)dlp->info_ack.dl_mac_type);
! 233: break;
! 234: }
! 235: /*
! 236: * copy the sap length and broadcast address of this interface
! 237: * to interface_info. This fixes nothing but seemed nicer than to
! 238: * assume -2 and ffffff.
! 239: */
! 240: info -> dlpi_sap_length = dlp -> info_ack.dl_sap_length;
! 241: info -> dlpi_broadcast_addr.hlen =
! 242: dlp -> info_ack.dl_brdcst_addr_length;
! 243: memcpy (info -> dlpi_broadcast_addr.hbuf,
! 244: (char *)dlp + dlp -> info_ack.dl_brdcst_addr_offset,
! 245: dlp -> info_ack.dl_brdcst_addr_length);
! 246: }
! 247:
! 248: if (dlp -> info_ack.dl_provider_style == DL_STYLE2) {
! 249: /*
! 250: * Attach to the device. If this fails, the device
! 251: * does not exist.
! 252: */
! 253: unit = dlpiunit (info -> name);
! 254:
! 255: if (dlpiattachreq (sock, unit) < 0
! 256: || dlpiokack (sock, (char *)buf) < 0) {
! 257: log_fatal ("Can't attach DLPI device for %s: %m", info -> name);
! 258: }
! 259: }
! 260:
! 261: /*
! 262: * Bind to the IP service access point (SAP), connectionless (CLDLS).
! 263: */
! 264: if (dlpibindreq (sock, ETHERTYPE_IP, 0, DL_CLDLS, 0, 0) < 0
! 265: || dlpibindack (sock, (char *)buf) < 0) {
! 266: log_fatal ("Can't bind DLPI device for %s: %m", info -> name);
! 267: }
! 268:
! 269: /*
! 270: * Submit a DL_PHYS_ADDR_REQ request, to find
! 271: * the hardware address
! 272: */
! 273: if (dlpiphysaddrreq (sock, DL_CURR_PHYS_ADDR) < 0
! 274: || dlpiphysaddrack (sock, (char *)buf) < 0) {
! 275: log_fatal ("Can't get DLPI hardware address for %s: %m",
! 276: info -> name);
! 277: }
! 278:
! 279: info -> hw_address.hlen = dlp -> physaddr_ack.dl_addr_length + 1;
! 280: memcpy (&info -> hw_address.hbuf [1],
! 281: (char *)buf + dlp -> physaddr_ack.dl_addr_offset,
! 282: dlp -> physaddr_ack.dl_addr_length);
! 283:
! 284: #ifdef USE_DLPI_RAW
! 285: if (strioctl (sock, DLIOCRAW, INFTIM, 0, 0) < 0) {
! 286: log_fatal ("Can't set DLPI RAW mode for %s: %m",
! 287: info -> name);
! 288: }
! 289: #endif
! 290:
! 291: #ifdef USE_DLPI_PFMOD
! 292: if (ioctl (sock, I_PUSH, "pfmod") < 0) {
! 293: log_fatal ("Can't push packet filter onto DLPI for %s: %m",
! 294: info -> name);
! 295: }
! 296: #endif
! 297:
! 298: return sock;
! 299: }
! 300:
! 301: #if defined(USE_DLPI_PFMOD) || defined(USE_DLPI_RAW)
! 302: static int
! 303: strioctl (fd, cmd, timeout, len, dp)
! 304: int fd;
! 305: int cmd;
! 306: int timeout;
! 307: int len;
! 308: char *dp;
! 309: {
! 310: struct strioctl sio;
! 311: int rslt;
! 312:
! 313: sio.ic_cmd = cmd;
! 314: sio.ic_timout = timeout;
! 315: sio.ic_len = len;
! 316: sio.ic_dp = dp;
! 317:
! 318: if ((rslt = ioctl (fd, I_STR, &sio)) < 0) {
! 319: return rslt;
! 320: } else {
! 321: return sio.ic_len;
! 322: }
! 323: }
! 324: #endif /* USE_DPI_PFMOD || USE_DLPI_RAW */
! 325:
! 326: #ifdef USE_DLPI_SEND
! 327: void if_register_send (info)
! 328: struct interface_info *info;
! 329: {
! 330: /* If we're using the DLPI API for sending and receiving,
! 331: we don't need to register this interface twice. */
! 332: #ifndef USE_DLPI_RECEIVE
! 333: # ifdef USE_DLPI_PFMOD
! 334: struct packetfilt pf;
! 335: # endif
! 336:
! 337: info -> wfdesc = if_register_dlpi (info);
! 338:
! 339: # ifdef USE_DLPI_PFMOD
! 340: /* Set up an PFMOD filter that rejects everything... */
! 341: pf.Pf_Priority = 0;
! 342: pf.Pf_FilterLen = 1;
! 343: pf.Pf_Filter [0] = ENF_PUSHZERO;
! 344:
! 345: /* Install the filter */
! 346: if (strioctl (info -> wfdesc, PFIOCSETF, INFTIM,
! 347: sizeof (pf), (char *)&pf) < 0) {
! 348: log_fatal ("Can't set PFMOD send filter on %s: %m", info -> name);
! 349: }
! 350:
! 351: # endif /* USE_DLPI_PFMOD */
! 352: #else /* !defined (USE_DLPI_RECEIVE) */
! 353: /*
! 354: * If using DLPI for both send and receive, simply re-use
! 355: * the read file descriptor that was set up earlier.
! 356: */
! 357: info -> wfdesc = info -> rfdesc;
! 358: #endif
! 359:
! 360: if (!quiet_interface_discovery)
! 361: log_info ("Sending on DLPI/%s/%s%s%s",
! 362: info -> name,
! 363: print_hw_addr (info -> hw_address.hbuf [0],
! 364: info -> hw_address.hlen - 1,
! 365: &info -> hw_address.hbuf [1]),
! 366: (info -> shared_network ? "/" : ""),
! 367: (info -> shared_network ?
! 368: info -> shared_network -> name : ""));
! 369:
! 370: #ifdef DLPI_FIRST_SEND_WAIT
! 371: /* See the implementation notes at the beginning of this file */
! 372: # ifdef USE_DLPI_RECEIVE
! 373: sleep (DLPI_FIRST_SEND_WAIT - (DLPI_FIRST_SEND_WAIT / 2));
! 374: # else
! 375: sleep (DLPI_FIRST_SEND_WAIT);
! 376: # endif
! 377: #endif
! 378: }
! 379:
! 380: void if_deregister_send (info)
! 381: struct interface_info *info;
! 382: {
! 383: /* If we're using the DLPI API for sending and receiving,
! 384: we don't need to register this interface twice. */
! 385: #ifndef USE_DLPI_RECEIVE
! 386: close (info -> wfdesc);
! 387: #endif
! 388: info -> wfdesc = -1;
! 389:
! 390: if (!quiet_interface_discovery)
! 391: log_info ("Disabling output on DLPI/%s/%s%s%s",
! 392: info -> name,
! 393: print_hw_addr (info -> hw_address.hbuf [0],
! 394: info -> hw_address.hlen - 1,
! 395: &info -> hw_address.hbuf [1]),
! 396: (info -> shared_network ? "/" : ""),
! 397: (info -> shared_network ?
! 398: info -> shared_network -> name : ""));
! 399: }
! 400: #endif /* USE_DLPI_SEND */
! 401:
! 402: #ifdef USE_DLPI_RECEIVE
! 403: /* Packet filter program...
! 404: XXX Changes to the filter program may require changes to the constant
! 405: offsets used in if_register_send to patch the NIT program! XXX */
! 406:
! 407: void if_register_receive (info)
! 408: struct interface_info *info;
! 409: {
! 410: #ifdef USE_DLPI_PFMOD
! 411: struct packetfilt pf;
! 412: struct ip iphdr;
! 413: u_int16_t offset;
! 414: #endif
! 415:
! 416: /* Open a DLPI device and hang it on this interface... */
! 417: info -> rfdesc = if_register_dlpi (info);
! 418:
! 419: #ifdef USE_DLPI_PFMOD
! 420: /* Set up the PFMOD filter program. */
! 421: /* XXX Unlike the BPF filter program, this one won't work if the
! 422: XXX IP packet is fragmented or if there are options on the IP
! 423: XXX header. */
! 424: pf.Pf_Priority = 0;
! 425: pf.Pf_FilterLen = 0;
! 426:
! 427: #if defined (USE_DLPI_RAW)
! 428: # define ETHER_H_PREFIX (14) /* sizeof (ethernet_header) */
! 429: /*
! 430: * ethertype == ETHERTYPE_IP
! 431: */
! 432: offset = 12;
! 433: pf.Pf_Filter [pf.Pf_FilterLen++] = ENF_PUSHWORD + (offset / 2);
! 434: pf.Pf_Filter [pf.Pf_FilterLen++] = ENF_PUSHLIT | ENF_CAND;
! 435: pf.Pf_Filter [pf.Pf_FilterLen++] = htons (ETHERTYPE_IP);
! 436: # else
! 437: # define ETHER_H_PREFIX (0)
! 438: # endif /* USE_DLPI_RAW */
! 439: /*
! 440: * The packets that will be received on this file descriptor
! 441: * will be IP packets (due to the SAP that was specified in
! 442: * the dlbind call). There will be no ethernet header.
! 443: * Therefore, setup the packet filter to check the protocol
! 444: * field for UDP, and the destination port number equal
! 445: * to the local port. All offsets are relative to the start
! 446: * of an IP packet.
! 447: */
! 448:
! 449: /*
! 450: * BOOTPS destination port
! 451: */
! 452: offset = ETHER_H_PREFIX + sizeof (iphdr) + sizeof (u_int16_t);
! 453: pf.Pf_Filter [pf.Pf_FilterLen++] = ENF_PUSHWORD + (offset / 2);
! 454: pf.Pf_Filter [pf.Pf_FilterLen++] = ENF_PUSHLIT | ENF_CAND;
! 455: pf.Pf_Filter [pf.Pf_FilterLen++] = local_port;
! 456:
! 457: /*
! 458: * protocol should be udp. this is a byte compare, test for
! 459: * endianess.
! 460: */
! 461: offset = ETHER_H_PREFIX + ((u_int8_t *)&(iphdr.ip_p) - (u_int8_t *)&iphdr);
! 462: pf.Pf_Filter [pf.Pf_FilterLen++] = ENF_PUSHWORD + (offset / 2);
! 463: pf.Pf_Filter [pf.Pf_FilterLen++] = ENF_PUSHLIT | ENF_AND;
! 464: pf.Pf_Filter [pf.Pf_FilterLen++] = htons (0x00FF);
! 465: pf.Pf_Filter [pf.Pf_FilterLen++] = ENF_PUSHLIT | ENF_CAND;
! 466: pf.Pf_Filter [pf.Pf_FilterLen++] = htons (IPPROTO_UDP);
! 467:
! 468: /* Install the filter... */
! 469: if (strioctl (info -> rfdesc, PFIOCSETF, INFTIM,
! 470: sizeof (pf), (char *)&pf) < 0) {
! 471: log_fatal ("Can't set PFMOD receive filter on %s: %m", info -> name);
! 472: }
! 473: #endif /* USE_DLPI_PFMOD */
! 474:
! 475: if (!quiet_interface_discovery)
! 476: log_info ("Listening on DLPI/%s/%s%s%s",
! 477: info -> name,
! 478: print_hw_addr (info -> hw_address.hbuf [0],
! 479: info -> hw_address.hlen - 1,
! 480: &info -> hw_address.hbuf [1]),
! 481: (info -> shared_network ? "/" : ""),
! 482: (info -> shared_network ?
! 483: info -> shared_network -> name : ""));
! 484:
! 485: #ifdef DLPI_FIRST_SEND_WAIT
! 486: /* See the implementation notes at the beginning of this file */
! 487: # ifdef USE_DLPI_SEND
! 488: sleep (DLPI_FIRST_SEND_WAIT / 2);
! 489: # else
! 490: sleep (DLPI_FIRST_SEND_WAIT);
! 491: # endif
! 492: #endif
! 493: }
! 494:
! 495: void if_deregister_receive (info)
! 496: struct interface_info *info;
! 497: {
! 498: /* If we're using the DLPI API for sending and receiving,
! 499: we don't need to register this interface twice. */
! 500: #ifndef USE_DLPI_SEND
! 501: close (info -> rfdesc);
! 502: #endif
! 503: info -> rfdesc = -1;
! 504:
! 505: if (!quiet_interface_discovery)
! 506: log_info ("Disabling input on DLPI/%s/%s%s%s",
! 507: info -> name,
! 508: print_hw_addr (info -> hw_address.hbuf [0],
! 509: info -> hw_address.hlen - 1,
! 510: &info -> hw_address.hbuf [1]),
! 511: (info -> shared_network ? "/" : ""),
! 512: (info -> shared_network ?
! 513: info -> shared_network -> name : ""));
! 514: }
! 515: #endif /* USE_DLPI_RECEIVE */
! 516:
! 517: #ifdef USE_DLPI_SEND
! 518: ssize_t send_packet (interface, packet, raw, len, from, to, hto)
! 519: struct interface_info *interface;
! 520: struct packet *packet;
! 521: struct dhcp_packet *raw;
! 522: size_t len;
! 523: struct in_addr from;
! 524: struct sockaddr_in *to;
! 525: struct hardware *hto;
! 526: {
! 527: #ifdef USE_DLPI_RAW
! 528: double hh [32];
! 529: #endif
! 530: double ih [1536 / sizeof (double)];
! 531: unsigned char *dbuf = (unsigned char *)ih;
! 532: unsigned dbuflen;
! 533: unsigned char dstaddr [DLPI_MAXDLADDR];
! 534: unsigned addrlen;
! 535: int result;
! 536: int fudge;
! 537:
! 538: if (!strcmp (interface -> name, "fallback"))
! 539: return send_fallback (interface, packet, raw,
! 540: len, from, to, hto);
! 541:
! 542: dbuflen = 0;
! 543:
! 544: /* Assemble the headers... */
! 545: #ifdef USE_DLPI_RAW
! 546: assemble_hw_header (interface, (unsigned char *)hh, &dbuflen, hto);
! 547: if (dbuflen > sizeof hh)
! 548: log_fatal ("send_packet: hh buffer too small.\n");
! 549: fudge = dbuflen % 4; /* IP header must be word-aligned. */
! 550: memcpy (dbuf + fudge, (unsigned char *)hh, dbuflen);
! 551: dbuflen += fudge;
! 552: #else
! 553: fudge = 0;
! 554: #endif
! 555: assemble_udp_ip_header (interface, dbuf, &dbuflen, from.s_addr,
! 556: to -> sin_addr.s_addr, to -> sin_port,
! 557: (unsigned char *)raw, len);
! 558:
! 559: /* Copy the data into the buffer (yuk). */
! 560: memcpy (dbuf + dbuflen, raw, len);
! 561: dbuflen += len;
! 562:
! 563: #ifdef USE_DLPI_RAW
! 564: result = write (interface -> wfdesc, dbuf + fudge, dbuflen - fudge);
! 565: #else
! 566:
! 567: /*
! 568: * Setup the destination address (DLSAP) in dstaddr
! 569: *
! 570: * If sap_length < 0 we must deliver the DLSAP as phys+sap.
! 571: * If sap_length > 0 we must deliver the DLSAP as sap+phys.
! 572: *
! 573: * sap = Service Access Point == ETHERTYPE_IP
! 574: * sap + datalink address is called DLSAP in dlpi speak.
! 575: */
! 576: { /* ENCODE DLSAP */
! 577: unsigned char phys [DLPI_MAXDLADDR];
! 578: unsigned char sap [4];
! 579: int sap_len = interface -> dlpi_sap_length;
! 580: int phys_len = interface -> hw_address.hlen - 1;
! 581:
! 582: /* sap = htons (ETHERTYPE_IP) kludge */
! 583: memset (sap, 0, sizeof (sap));
! 584: # if (BYTE_ORDER == LITTLE_ENDIAN)
! 585: sap [0] = 0x00;
! 586: sap [1] = 0x08;
! 587: # else
! 588: sap [0] = 0x08;
! 589: sap [1] = 0x00;
! 590: # endif
! 591:
! 592: if (hto && hto -> hlen == interface -> hw_address.hlen)
! 593: memcpy ( phys, (char *) &hto -> hbuf [1], phys_len);
! 594: else
! 595: memcpy ( phys, interface -> dlpi_broadcast_addr.hbuf,
! 596: interface -> dlpi_broadcast_addr.hlen);
! 597:
! 598: if (sap_len < 0) {
! 599: memcpy ( dstaddr, phys, phys_len);
! 600: memcpy ( (char *) &dstaddr [phys_len], sap, ABS (sap_len));
! 601: }
! 602: else {
! 603: memcpy ( dstaddr, (void *) sap, sap_len);
! 604: memcpy ( (char *) &dstaddr [sap_len], phys, phys_len);
! 605: }
! 606: addrlen = phys_len + ABS (sap_len);
! 607: } /* ENCODE DLSAP */
! 608:
! 609: result = dlpiunitdatareq (interface -> wfdesc, dstaddr, addrlen,
! 610: 0, 0, dbuf, dbuflen);
! 611: #endif /* USE_DLPI_RAW */
! 612: if (result < 0)
! 613: log_error ("send_packet: %m");
! 614: return result;
! 615: }
! 616: #endif /* USE_DLPI_SEND */
! 617:
! 618: #ifdef USE_DLPI_RECEIVE
! 619: ssize_t receive_packet (interface, buf, len, from, hfrom)
! 620: struct interface_info *interface;
! 621: unsigned char *buf;
! 622: size_t len;
! 623: struct sockaddr_in *from;
! 624: struct hardware *hfrom;
! 625: {
! 626: unsigned char dbuf [1536];
! 627: unsigned char srcaddr [DLPI_MAXDLADDR];
! 628: unsigned long srcaddrlen;
! 629: int length = 0;
! 630: int offset = 0;
! 631: int bufix = 0;
! 632: unsigned paylen;
! 633:
! 634: #ifdef USE_DLPI_RAW
! 635: length = read (interface -> rfdesc, dbuf, sizeof (dbuf));
! 636: #else
! 637: length = dlpiunitdataind (interface -> rfdesc, (unsigned char *)NULL,
! 638: (unsigned long *)NULL, srcaddr, &srcaddrlen,
! 639: (unsigned long *)NULL, dbuf, sizeof (dbuf));
! 640: #endif
! 641:
! 642: if (length <= 0) {
! 643: log_error("receive_packet: %m");
! 644: return length;
! 645: }
! 646:
! 647: # if !defined (USE_DLPI_RAW)
! 648: /*
! 649: * Copy the sender's hw address into hfrom
! 650: * If sap_len < 0 the DLSAP is as phys+sap.
! 651: * If sap_len > 0 the DLSAP is as sap+phys.
! 652: *
! 653: * sap is discarded here.
! 654: */
! 655: { /* DECODE DLSAP */
! 656: int sap_len = interface -> dlpi_sap_length;
! 657: int phys_len = interface -> hw_address.hlen - 1;
! 658:
! 659: if (hfrom && (srcaddrlen == ABS (sap_len) + phys_len )) {
! 660: hfrom -> hbuf [0] = interface -> hw_address.hbuf [0];
! 661: hfrom -> hlen = interface -> hw_address.hlen;
! 662:
! 663: if (sap_len < 0) {
! 664: memcpy ((char *) &hfrom -> hbuf [1], srcaddr, phys_len);
! 665: }
! 666: else {
! 667: memcpy((char *)&hfrom->hbuf[1], srcaddr + sap_len, phys_len);
! 668: }
! 669: }
! 670: else if (hfrom) {
! 671: memset (hfrom, '\0', sizeof *hfrom);
! 672: }
! 673: } /* DECODE_DLSAP */
! 674:
! 675: # endif /* !defined (USE_DLPI_RAW) */
! 676:
! 677: /* Decode the IP and UDP headers... */
! 678: bufix = 0;
! 679: #ifdef USE_DLPI_RAW
! 680: /* Decode the physical header... */
! 681: offset = decode_hw_header (interface, dbuf, bufix, hfrom);
! 682:
! 683: /* If a physical layer checksum failed (dunno of any
! 684: physical layer that supports this, but WTH), skip this
! 685: packet. */
! 686: if (offset < 0) {
! 687: return 0;
! 688: }
! 689: bufix += offset;
! 690: length -= offset;
! 691: #endif
! 692: offset = decode_udp_ip_header (interface, dbuf, bufix,
! 693: from, length, &paylen);
! 694:
! 695: /*
! 696: * If the IP or UDP checksum was bad, skip the packet...
! 697: *
! 698: * Note: this happens all the time when writing packets via the
! 699: * fallback socket. The packet received by streams does not have
! 700: * the IP or UDP checksums filled in, as those are calculated by
! 701: * the hardware.
! 702: */
! 703: if (offset < 0) {
! 704: return 0;
! 705: }
! 706:
! 707: bufix += offset;
! 708: length -= offset;
! 709:
! 710: if (length < paylen)
! 711: log_fatal("Internal inconsistency at %s:%d.", MDL);
! 712:
! 713: /* Copy out the data in the packet... */
! 714: memcpy(buf, &dbuf [bufix], paylen);
! 715: return paylen;
! 716: }
! 717: #endif
! 718:
! 719: /* Common DLPI routines ...
! 720: *
! 721: * Written by Eric James Negaard, <lmdejn@lmd.ericsson.se>
! 722: *
! 723: * Based largely in part to the example code contained in the document
! 724: * "How to Use the STREAMS Data Link Provider Interface (DLPI)", written
! 725: * by Neal Nuckolls of SunSoft Internet Engineering.
! 726: *
! 727: * This code has been developed and tested on sparc-based machines running
! 728: * SunOS 5.5.1, with le and hme network interfaces. It should be pretty
! 729: * generic, though.
! 730: *
! 731: * The usual disclaimers apply. This code works for me. Don't blame me
! 732: * if it makes your machine or network go down in flames. That taken
! 733: * into consideration, use this code as you wish. If you make usefull
! 734: * modifications I'd appreciate hearing about it.
! 735: */
! 736:
! 737: #define DLPI_MAXWAIT 15 /* Max timeout */
! 738:
! 739:
! 740: /*
! 741: * Parse an interface name and extract the unit number
! 742: */
! 743:
! 744: static int dlpiunit (ifname)
! 745: char *ifname;
! 746: {
! 747: char *cp;
! 748: int unit;
! 749:
! 750: if (!ifname) {
! 751: return 0;
! 752: }
! 753:
! 754: /* Advance to the end of the name */
! 755: cp = ifname;
! 756: while (*cp) cp++;
! 757: /* Back up to the start of the first digit */
! 758: while ((*(cp-1) >= '0' && *(cp-1) <= '9') || *(cp - 1) == ':') cp--;
! 759:
! 760: /* Convert the unit number */
! 761: unit = 0;
! 762: while (*cp >= '0' && *cp <= '9') {
! 763: unit *= 10;
! 764: unit += (*cp++ - '0');
! 765: }
! 766:
! 767: return unit;
! 768: }
! 769:
! 770: /*
! 771: * dlpiopen - open the DLPI device for a given interface name
! 772: */
! 773: static int
! 774: dlpiopen(const char *ifname) {
! 775: char devname [50];
! 776: char *dp;
! 777: const char *cp, *ep;
! 778:
! 779: if (!ifname) {
! 780: return -1;
! 781: }
! 782:
! 783: /* Open a DLPI device */
! 784: if (*ifname == '/') {
! 785: dp = devname;
! 786: } else {
! 787: /* Prepend the device directory */
! 788: memcpy (devname, DLPI_DEVDIR, strlen (DLPI_DEVDIR));
! 789: dp = &devname [strlen (DLPI_DEVDIR)];
! 790: }
! 791:
! 792: /* Find the end of the interface name */
! 793: ep = cp = ifname;
! 794: while (*ep)
! 795: ep++;
! 796: /* And back up to the first digit (unit number) */
! 797: while ((*(ep - 1) >= '0' && *(ep - 1) <= '9') || *(ep - 1) == ':')
! 798: ep--;
! 799:
! 800: /* Copy everything up to the unit number */
! 801: while (cp < ep) {
! 802: *dp++ = *cp++;
! 803: }
! 804: *dp = '\0';
! 805:
! 806: return open (devname, O_RDWR, 0);
! 807: }
! 808:
! 809: /*
! 810: * dlpiinforeq - request information about the data link provider.
! 811: */
! 812:
! 813: static int dlpiinforeq (fd)
! 814: int fd;
! 815: {
! 816: dl_info_req_t info_req;
! 817: struct strbuf ctl;
! 818: int flags;
! 819:
! 820: info_req.dl_primitive = DL_INFO_REQ;
! 821:
! 822: ctl.maxlen = 0;
! 823: ctl.len = sizeof (info_req);
! 824: ctl.buf = (char *)&info_req;
! 825:
! 826: flags = RS_HIPRI;
! 827:
! 828: return putmsg (fd, &ctl, (struct strbuf *)NULL, flags);
! 829: }
! 830:
! 831: /*
! 832: * dlpiphysaddrreq - request the current physical address.
! 833: */
! 834: static int dlpiphysaddrreq (fd, addrtype)
! 835: int fd;
! 836: unsigned long addrtype;
! 837: {
! 838: dl_phys_addr_req_t physaddr_req;
! 839: struct strbuf ctl;
! 840: int flags;
! 841:
! 842: physaddr_req.dl_primitive = DL_PHYS_ADDR_REQ;
! 843: physaddr_req.dl_addr_type = addrtype;
! 844:
! 845: ctl.maxlen = 0;
! 846: ctl.len = sizeof (physaddr_req);
! 847: ctl.buf = (char *)&physaddr_req;
! 848:
! 849: flags = RS_HIPRI;
! 850:
! 851: return putmsg (fd, &ctl, (struct strbuf *)NULL, flags);
! 852: }
! 853:
! 854: /*
! 855: * dlpiattachreq - send a request to attach to a specific unit.
! 856: */
! 857: static int dlpiattachreq (fd, ppa)
! 858: unsigned long ppa;
! 859: int fd;
! 860: {
! 861: dl_attach_req_t attach_req;
! 862: struct strbuf ctl;
! 863: int flags;
! 864:
! 865: attach_req.dl_primitive = DL_ATTACH_REQ;
! 866: attach_req.dl_ppa = ppa;
! 867:
! 868: ctl.maxlen = 0;
! 869: ctl.len = sizeof (attach_req);
! 870: ctl.buf = (char *)&attach_req;
! 871:
! 872: flags = 0;
! 873:
! 874: return putmsg (fd, &ctl, (struct strbuf*)NULL, flags);
! 875: }
! 876:
! 877: /*
! 878: * dlpibindreq - send a request to bind to a specific SAP address.
! 879: */
! 880: static int dlpibindreq (fd, sap, max_conind, service_mode, conn_mgmt, xidtest)
! 881: unsigned long sap;
! 882: unsigned long max_conind;
! 883: unsigned long service_mode;
! 884: unsigned long conn_mgmt;
! 885: unsigned long xidtest;
! 886: int fd;
! 887: {
! 888: dl_bind_req_t bind_req;
! 889: struct strbuf ctl;
! 890: int flags;
! 891:
! 892: bind_req.dl_primitive = DL_BIND_REQ;
! 893: bind_req.dl_sap = sap;
! 894: bind_req.dl_max_conind = max_conind;
! 895: bind_req.dl_service_mode = service_mode;
! 896: bind_req.dl_conn_mgmt = conn_mgmt;
! 897: bind_req.dl_xidtest_flg = xidtest;
! 898:
! 899: ctl.maxlen = 0;
! 900: ctl.len = sizeof (bind_req);
! 901: ctl.buf = (char *)&bind_req;
! 902:
! 903: flags = 0;
! 904:
! 905: return putmsg (fd, &ctl, (struct strbuf*)NULL, flags);
! 906: }
! 907:
! 908: #if defined(UNUSED_DLPI_INTERFACE)
! 909: /*
! 910: * dlpiunbindreq - send a request to unbind. This function is not actually
! 911: * used by ISC DHCP, but is included for completeness in case it is
! 912: * ever required for new work.
! 913: */
! 914: static int dlpiunbindreq (fd)
! 915: int fd;
! 916: {
! 917: dl_unbind_req_t unbind_req;
! 918: struct strbuf ctl;
! 919: int flags;
! 920:
! 921: unbind_req.dl_primitive = DL_UNBIND_REQ;
! 922:
! 923: ctl.maxlen = 0;
! 924: ctl.len = sizeof (unbind_req);
! 925: ctl.buf = (char *)&unbind_req;
! 926:
! 927: flags = 0;
! 928:
! 929: return putmsg (fd, &ctl, (struct strbuf*)NULL, flags);
! 930: }
! 931:
! 932:
! 933: /*
! 934: * dlpidetachreq - send a request to detach. This function is not actually
! 935: * used by ISC DHCP, but is included for completeness in case it is
! 936: * ever required for new work.
! 937: */
! 938: static int dlpidetachreq (fd)
! 939: int fd;
! 940: {
! 941: dl_detach_req_t detach_req;
! 942: struct strbuf ctl;
! 943: int flags;
! 944:
! 945: detach_req.dl_primitive = DL_DETACH_REQ;
! 946:
! 947: ctl.maxlen = 0;
! 948: ctl.len = sizeof (detach_req);
! 949: ctl.buf = (char *)&detach_req;
! 950:
! 951: flags = 0;
! 952:
! 953: return putmsg (fd, &ctl, (struct strbuf*)NULL, flags);
! 954: }
! 955: #endif /* UNUSED_DLPI_INTERFACE */
! 956:
! 957:
! 958: /*
! 959: * dlpibindack - receive an ack to a dlbindreq.
! 960: */
! 961: static int dlpibindack (fd, bufp)
! 962: char *bufp;
! 963: int fd;
! 964: {
! 965: union DL_primitives *dlp;
! 966: struct strbuf ctl;
! 967: int flags;
! 968:
! 969: ctl.maxlen = DLPI_MAXDLBUF;
! 970: ctl.len = 0;
! 971: ctl.buf = bufp;
! 972:
! 973: if (strgetmsg (fd, &ctl,
! 974: (struct strbuf*)NULL, &flags, "dlpibindack") < 0) {
! 975: return -1;
! 976: }
! 977:
! 978: dlp = (union DL_primitives *)ctl.buf;
! 979:
! 980: if (expected (DL_BIND_ACK, dlp, flags) == -1) {
! 981: return -1;
! 982: }
! 983:
! 984: if (ctl.len < sizeof (dl_bind_ack_t)) {
! 985: /* Returned structure is too short */
! 986: return -1;
! 987: }
! 988:
! 989: return 0;
! 990: }
! 991:
! 992: /*
! 993: * dlpiokack - general acknowledgement reception.
! 994: */
! 995: static int dlpiokack (fd, bufp)
! 996: char *bufp;
! 997: int fd;
! 998: {
! 999: union DL_primitives *dlp;
! 1000: struct strbuf ctl;
! 1001: int flags;
! 1002:
! 1003: ctl.maxlen = DLPI_MAXDLBUF;
! 1004: ctl.len = 0;
! 1005: ctl.buf = bufp;
! 1006:
! 1007: if (strgetmsg (fd, &ctl,
! 1008: (struct strbuf*)NULL, &flags, "dlpiokack") < 0) {
! 1009: return -1;
! 1010: }
! 1011:
! 1012: dlp = (union DL_primitives *)ctl.buf;
! 1013:
! 1014: if (expected (DL_OK_ACK, dlp, flags) == -1) {
! 1015: return -1;
! 1016: }
! 1017:
! 1018: if (ctl.len < sizeof (dl_ok_ack_t)) {
! 1019: /* Returned structure is too short */
! 1020: return -1;
! 1021: }
! 1022:
! 1023: return 0;
! 1024: }
! 1025:
! 1026: /*
! 1027: * dlpiinfoack - receive an ack to a dlinforeq.
! 1028: */
! 1029: static int dlpiinfoack (fd, bufp)
! 1030: char *bufp;
! 1031: int fd;
! 1032: {
! 1033: union DL_primitives *dlp;
! 1034: struct strbuf ctl;
! 1035: int flags;
! 1036:
! 1037: ctl.maxlen = DLPI_MAXDLBUF;
! 1038: ctl.len = 0;
! 1039: ctl.buf = bufp;
! 1040:
! 1041: if (strgetmsg (fd, &ctl, (struct strbuf *)NULL, &flags,
! 1042: "dlpiinfoack") < 0) {
! 1043: return -1;
! 1044: }
! 1045:
! 1046: dlp = (union DL_primitives *) ctl.buf;
! 1047:
! 1048: if (expected (DL_INFO_ACK, dlp, flags) == -1) {
! 1049: return -1;
! 1050: }
! 1051:
! 1052: if (ctl.len < sizeof (dl_info_ack_t)) {
! 1053: /* Returned structure is too short */
! 1054: return -1;
! 1055: }
! 1056:
! 1057: return 0;
! 1058: }
! 1059:
! 1060: /*
! 1061: * dlpiphysaddrack - receive an ack to a dlpiphysaddrreq.
! 1062: */
! 1063: int dlpiphysaddrack (fd, bufp)
! 1064: char *bufp;
! 1065: int fd;
! 1066: {
! 1067: union DL_primitives *dlp;
! 1068: struct strbuf ctl;
! 1069: int flags;
! 1070:
! 1071: ctl.maxlen = DLPI_MAXDLBUF;
! 1072: ctl.len = 0;
! 1073: ctl.buf = bufp;
! 1074:
! 1075: if (strgetmsg (fd, &ctl, (struct strbuf *)NULL, &flags,
! 1076: "dlpiphysaddrack") < 0) {
! 1077: return -1;
! 1078: }
! 1079:
! 1080: dlp = (union DL_primitives *)ctl.buf;
! 1081:
! 1082: if (expected (DL_PHYS_ADDR_ACK, dlp, flags) == -1) {
! 1083: return -1;
! 1084: }
! 1085:
! 1086: if (ctl.len < sizeof (dl_phys_addr_ack_t)) {
! 1087: /* Returned structure is too short */
! 1088: return -1;
! 1089: }
! 1090:
! 1091: return 0;
! 1092: }
! 1093:
! 1094: #if defined(USE_DLPI_SEND) || defined(USE_DLPI_RECEIVE)
! 1095: int dlpiunitdatareq (fd, addr, addrlen, minpri, maxpri, dbuf, dbuflen)
! 1096: int fd;
! 1097: unsigned char *addr;
! 1098: int addrlen;
! 1099: unsigned long minpri;
! 1100: unsigned long maxpri;
! 1101: unsigned char *dbuf;
! 1102: int dbuflen;
! 1103: {
! 1104: long buf [DLPI_MAXDLBUF];
! 1105: union DL_primitives *dlp;
! 1106: struct strbuf ctl, data;
! 1107:
! 1108: /* Set up the control information... */
! 1109: dlp = (union DL_primitives *)buf;
! 1110: dlp -> unitdata_req.dl_primitive = DL_UNITDATA_REQ;
! 1111: dlp -> unitdata_req.dl_dest_addr_length = addrlen;
! 1112: dlp -> unitdata_req.dl_dest_addr_offset = sizeof (dl_unitdata_req_t);
! 1113: dlp -> unitdata_req.dl_priority.dl_min = minpri;
! 1114: dlp -> unitdata_req.dl_priority.dl_max = maxpri;
! 1115:
! 1116: /* Append the destination address */
! 1117: memcpy ((char *)buf + dlp -> unitdata_req.dl_dest_addr_offset,
! 1118: addr, addrlen);
! 1119:
! 1120: ctl.maxlen = 0;
! 1121: ctl.len = dlp -> unitdata_req.dl_dest_addr_offset + addrlen;
! 1122: ctl.buf = (char *)buf;
! 1123:
! 1124: data.maxlen = 0;
! 1125: data.buf = (char *)dbuf;
! 1126: data.len = dbuflen;
! 1127:
! 1128: /* Send the packet down the wire... */
! 1129: return putmsg (fd, &ctl, &data, 0);
! 1130: }
! 1131:
! 1132: static int dlpiunitdataind (fd, daddr, daddrlen,
! 1133: saddr, saddrlen, grpaddr, dbuf, dlen)
! 1134: int fd;
! 1135: unsigned char *daddr;
! 1136: unsigned long *daddrlen;
! 1137: unsigned char *saddr;
! 1138: unsigned long *saddrlen;
! 1139: unsigned long *grpaddr;
! 1140: unsigned char *dbuf;
! 1141: int dlen;
! 1142: {
! 1143: long buf [DLPI_MAXDLBUF];
! 1144: union DL_primitives *dlp;
! 1145: struct strbuf ctl, data;
! 1146: int flags = 0;
! 1147: int result;
! 1148:
! 1149: /* Set up the msg_buf structure... */
! 1150: dlp = (union DL_primitives *)buf;
! 1151: dlp -> unitdata_ind.dl_primitive = DL_UNITDATA_IND;
! 1152:
! 1153: ctl.maxlen = DLPI_MAXDLBUF;
! 1154: ctl.len = 0;
! 1155: ctl.buf = (char *)buf;
! 1156:
! 1157: data.maxlen = dlen;
! 1158: data.len = 0;
! 1159: data.buf = (char *)dbuf;
! 1160:
! 1161: result = getmsg (fd, &ctl, &data, &flags);
! 1162:
! 1163: if (result < 0) {
! 1164: log_debug("dlpiunitdataind: %m");
! 1165: return -1;
! 1166: }
! 1167:
! 1168: if (ctl.len < sizeof (dl_unitdata_ind_t) ||
! 1169: dlp -> unitdata_ind.dl_primitive != DL_UNITDATA_IND) {
! 1170: return -1;
! 1171: }
! 1172:
! 1173: if (data.len <= 0) {
! 1174: return data.len;
! 1175: }
! 1176:
! 1177: /* Copy sender info */
! 1178: if (saddr) {
! 1179: memcpy (saddr,
! 1180: (char *)buf + dlp -> unitdata_ind.dl_src_addr_offset,
! 1181: dlp -> unitdata_ind.dl_src_addr_length);
! 1182: }
! 1183: if (saddrlen) {
! 1184: *saddrlen = dlp -> unitdata_ind.dl_src_addr_length;
! 1185: }
! 1186:
! 1187: /* Copy destination info */
! 1188: if (daddr) {
! 1189: memcpy (daddr,
! 1190: (char *)buf + dlp -> unitdata_ind.dl_dest_addr_offset,
! 1191: dlp -> unitdata_ind.dl_dest_addr_length);
! 1192: }
! 1193: if (daddrlen) {
! 1194: *daddrlen = dlp -> unitdata_ind.dl_dest_addr_length;
! 1195: }
! 1196:
! 1197: if (grpaddr) {
! 1198: *grpaddr = dlp -> unitdata_ind.dl_group_address;
! 1199: }
! 1200:
! 1201: return data.len;
! 1202: }
! 1203: #endif /* !USE_DLPI_HWADDR: USE_DLPI_RECEIVE || USE_DLPI_SEND */
! 1204:
! 1205: /*
! 1206: * expected - see if we got what we wanted.
! 1207: */
! 1208: static int expected (prim, dlp, msgflags)
! 1209: unsigned long prim;
! 1210: union DL_primitives *dlp;
! 1211: int msgflags;
! 1212: {
! 1213: if (msgflags != RS_HIPRI) {
! 1214: /* Message was not M_PCPROTO */
! 1215: return -1;
! 1216: }
! 1217:
! 1218: if (dlp->dl_primitive != prim) {
! 1219: /* Incorrect/unexpected return message */
! 1220: return -1;
! 1221: }
! 1222:
! 1223: return 0;
! 1224: }
! 1225:
! 1226: /*
! 1227: * strgetmsg - get a message from a stream, with timeout.
! 1228: */
! 1229: static int strgetmsg (fd, ctlp, datap, flagsp, caller)
! 1230: struct strbuf *ctlp, *datap;
! 1231: char *caller;
! 1232: int *flagsp;
! 1233: int fd;
! 1234: {
! 1235: int result;
! 1236: struct pollfd pfd;
! 1237: int count;
! 1238: time_t now;
! 1239: time_t starttime;
! 1240: int to_msec;
! 1241:
! 1242: pfd.fd = fd;
! 1243: pfd.events = POLLPRI; /* We're only interested in knowing
! 1244: * when we can receive the next high
! 1245: * priority message.
! 1246: */
! 1247: pfd.revents = 0;
! 1248:
! 1249: now = time (&starttime);
! 1250: while (now <= starttime + DLPI_MAXWAIT) {
! 1251: to_msec = ((starttime + DLPI_MAXWAIT) - now) * 1000;
! 1252: count = poll (&pfd, 1, to_msec);
! 1253:
! 1254: if (count == 0) {
! 1255: /* log_fatal ("strgetmsg: timeout"); */
! 1256: return -1;
! 1257: } else if (count < 0) {
! 1258: if (errno == EAGAIN || errno == EINTR) {
! 1259: time (&now);
! 1260: continue;
! 1261: } else {
! 1262: /* log_fatal ("poll: %m"); */
! 1263: return -1;
! 1264: }
! 1265: } else {
! 1266: break;
! 1267: }
! 1268: }
! 1269:
! 1270: /*
! 1271: * Set flags argument and issue getmsg ().
! 1272: */
! 1273: *flagsp = 0;
! 1274: if ((result = getmsg (fd, ctlp, datap, flagsp)) < 0) {
! 1275: return result;
! 1276: }
! 1277:
! 1278: /*
! 1279: * Check for MOREDATA and/or MORECTL.
! 1280: */
! 1281: if (result & (MORECTL|MOREDATA)) {
! 1282: return -1;
! 1283: }
! 1284:
! 1285: /*
! 1286: * Check for at least sizeof (long) control data portion.
! 1287: */
! 1288: if (ctlp -> len < sizeof (long)) {
! 1289: return -1;
! 1290: }
! 1291:
! 1292: return 0;
! 1293: }
! 1294:
! 1295: #if defined(USE_DLPI_SEND)
! 1296: int can_unicast_without_arp (ip)
! 1297: struct interface_info *ip;
! 1298: {
! 1299: return 1;
! 1300: }
! 1301:
! 1302: int can_receive_unicast_unconfigured (ip)
! 1303: struct interface_info *ip;
! 1304: {
! 1305: return 1;
! 1306: }
! 1307:
! 1308: int supports_multiple_interfaces (ip)
! 1309: struct interface_info *ip;
! 1310: {
! 1311: return 1;
! 1312: }
! 1313:
! 1314: void maybe_setup_fallback ()
! 1315: {
! 1316: isc_result_t status;
! 1317: struct interface_info *fbi = (struct interface_info *)0;
! 1318: if (setup_fallback (&fbi, MDL)) {
! 1319: if_register_fallback (fbi);
! 1320: status = omapi_register_io_object ((omapi_object_t *)fbi,
! 1321: if_readsocket, 0,
! 1322: fallback_discard, 0, 0);
! 1323: if (status != ISC_R_SUCCESS)
! 1324: log_fatal ("Can't register I/O handle for %s: %s",
! 1325: fbi -> name, isc_result_totext (status));
! 1326: interface_dereference (&fbi, MDL);
! 1327: }
! 1328: }
! 1329: #endif /* USE_DLPI_SEND */
! 1330:
! 1331: void
! 1332: get_hw_addr(const char *name, struct hardware *hw) {
! 1333: int sock, unit;
! 1334: long buf[DLPI_MAXDLBUF];
! 1335: union DL_primitives *dlp;
! 1336:
! 1337: dlp = (union DL_primitives *)buf;
! 1338:
! 1339: /*
! 1340: * Open a DLPI device.
! 1341: */
! 1342: sock = dlpiopen(name);
! 1343: if (sock < 0) {
! 1344: log_fatal("Can't open DLPI device for %s: %m", name);
! 1345: }
! 1346:
! 1347: /*
! 1348: * Submit a DL_INFO_REQ request, to find the dl_mac_type and
! 1349: * dl_provider_style
! 1350: */
! 1351: if (dlpiinforeq(sock) < 0) {
! 1352: log_fatal("Can't request DLPI MAC type for %s: %m", name);
! 1353: }
! 1354: if (dlpiinfoack(sock, (char *)buf) < 0) {
! 1355: log_fatal("Can't get DLPI MAC type for %s: %m", name);
! 1356: }
! 1357: switch (dlp->info_ack.dl_mac_type) {
! 1358: case DL_CSMACD: /* IEEE 802.3 */
! 1359: case DL_ETHER:
! 1360: hw->hbuf[0] = HTYPE_ETHER;
! 1361: break;
! 1362: case DL_TPR:
! 1363: hw->hbuf[0] = HTYPE_IEEE802;
! 1364: break;
! 1365: case DL_FDDI:
! 1366: hw->hbuf[0] = HTYPE_FDDI;
! 1367: break;
! 1368: default:
! 1369: log_fatal("%s: unsupported DLPI MAC type %lu", name,
! 1370: (unsigned long)dlp->info_ack.dl_mac_type);
! 1371: }
! 1372:
! 1373: if (dlp->info_ack.dl_provider_style == DL_STYLE2) {
! 1374: /*
! 1375: * Attach to the device. If this fails, the device
! 1376: * does not exist.
! 1377: */
! 1378: unit = dlpiunit((char *)name);
! 1379:
! 1380: if (dlpiattachreq(sock, unit) < 0 ||
! 1381: dlpiokack(sock, (char *)buf) < 0) {
! 1382: log_fatal("Can't attach DLPI device for %s: %m",
! 1383: name);
! 1384: }
! 1385: }
! 1386:
! 1387: /*
! 1388: * Submit a DL_PHYS_ADDR_REQ request, to find
! 1389: * the hardware address.
! 1390: */
! 1391: if (dlpiphysaddrreq(sock, DL_CURR_PHYS_ADDR) < 0) {
! 1392: log_fatal("Can't request DLPI hardware address for %s: %m",
! 1393: name);
! 1394: }
! 1395: if (dlpiphysaddrack(sock, (char *)buf) < 0) {
! 1396: log_fatal("Can't get DLPI hardware address for %s: %m",
! 1397: name);
! 1398: }
! 1399: if (dlp->physaddr_ack.dl_addr_length < sizeof(hw->hbuf)) {
! 1400: memcpy(hw->hbuf+1,
! 1401: (char *)buf + dlp->physaddr_ack.dl_addr_offset,
! 1402: dlp->physaddr_ack.dl_addr_length);
! 1403: hw->hlen = dlp->physaddr_ack.dl_addr_length + 1;
! 1404: } else {
! 1405: memcpy(hw->hbuf+1,
! 1406: (char *)buf + dlp->physaddr_ack.dl_addr_offset,
! 1407: sizeof(hw->hbuf)-1);
! 1408: hw->hlen = sizeof(hw->hbuf);
! 1409: }
! 1410:
! 1411: close(sock);
! 1412: }
! 1413: #endif /* USE_DLPI_SEND || USE_DLPI_RECEIVE || USE_DLPI_HWADDR */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to dlpi.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