Annotation of embedaddon/quagga/isisd/isis_dlpi.c, revision 1.1
1.1 ! misho 1: /*
! 2: * IS-IS Rout(e)ing protocol - isis_dlpi.c
! 3: *
! 4: * Copyright (C) 2001,2002 Sampo Saaristo
! 5: * Tampere University of Technology
! 6: * Institute of Communications Engineering
! 7: *
! 8: * This program is free software; you can redistribute it and/or modify it
! 9: * under the terms of the GNU General Public Licenseas published by the Free
! 10: * Software Foundation; either version 2 of the License, or (at your option)
! 11: * any later version.
! 12: *
! 13: * This program is distributed in the hope that it will be useful,but WITHOUT
! 14: * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
! 15: * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
! 16: * more details.
! 17:
! 18: * You should have received a copy of the GNU General Public License along
! 19: * with this program; if not, write to the Free Software Foundation, Inc.,
! 20: * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
! 21: */
! 22:
! 23: #include <zebra.h>
! 24: #if ISIS_METHOD == ISIS_METHOD_DLPI
! 25: #include <net/if.h>
! 26: #include <netinet/if_ether.h>
! 27: #include <sys/types.h>
! 28: #include <unistd.h>
! 29: #include <fcntl.h>
! 30: #include <stropts.h>
! 31: #include <poll.h>
! 32: #include <sys/dlpi.h>
! 33: #include <sys/pfmod.h>
! 34:
! 35: #include "log.h"
! 36: #include "stream.h"
! 37: #include "if.h"
! 38:
! 39: #include "isisd/dict.h"
! 40: #include "isisd/include-netbsd/iso.h"
! 41: #include "isisd/isis_constants.h"
! 42: #include "isisd/isis_common.h"
! 43: #include "isisd/isis_circuit.h"
! 44: #include "isisd/isis_flags.h"
! 45: #include "isisd/isisd.h"
! 46: #include "isisd/isis_network.h"
! 47:
! 48: #include "privs.h"
! 49:
! 50: extern struct zebra_privs_t isisd_privs;
! 51:
! 52: static t_uscalar_t dlpi_ctl[1024]; /* DLPI control messages */
! 53:
! 54: /*
! 55: * Table 9 - Architectural constants for use with ISO 8802 subnetworks
! 56: * ISO 10589 - 8.4.8
! 57: */
! 58:
! 59: u_char ALL_L1_ISS[6] = { 0x01, 0x80, 0xC2, 0x00, 0x00, 0x14 };
! 60: u_char ALL_L2_ISS[6] = { 0x01, 0x80, 0xC2, 0x00, 0x00, 0x15 };
! 61: u_char ALL_ISS[6] = { 0x09, 0x00, 0x2B, 0x00, 0x00, 0x05 };
! 62: u_char ALL_ESS[6] = { 0x09, 0x00, 0x2B, 0x00, 0x00, 0x04 };
! 63:
! 64: static u_char sock_buff[8192];
! 65:
! 66: static u_short pf_filter[] =
! 67: {
! 68: ENF_PUSHWORD + 0, /* Get the SSAP/DSAP values */
! 69: ENF_PUSHLIT | ENF_CAND, /* Check them */
! 70: ISO_SAP | (ISO_SAP << 8),
! 71: ENF_PUSHWORD + 1, /* Get the control value */
! 72: ENF_PUSHLIT | ENF_AND, /* Isolate it */
! 73: #ifdef _BIG_ENDIAN
! 74: 0xFF00,
! 75: #else
! 76: 0x00FF,
! 77: #endif
! 78: ENF_PUSHLIT | ENF_CAND, /* Test for expected value */
! 79: #ifdef _BIG_ENDIAN
! 80: 0x0300
! 81: #else
! 82: 0x0003
! 83: #endif
! 84: };
! 85:
! 86: /*
! 87: * We would like to use something like libdlpi here, but that's not present on
! 88: * all versions of Solaris or on any non-Solaris system, so it's nowhere near
! 89: * as portable as we'd like. Thus, we use the standards-conformant DLPI
! 90: * interfaces plus the (optional; not needed) Solaris packet filter module.
! 91: */
! 92:
! 93: static void
! 94: dlpisend (int fd, const void *cbuf, size_t cbuflen,
! 95: const void *dbuf, size_t dbuflen, int flags)
! 96: {
! 97: const struct strbuf *ctlptr = NULL;
! 98: const struct strbuf *dataptr = NULL;
! 99: struct strbuf ctlbuf, databuf;
! 100:
! 101: if (cbuf != NULL)
! 102: {
! 103: memset (&ctlbuf, 0, sizeof (ctlbuf));
! 104: ctlbuf.len = cbuflen;
! 105: ctlbuf.buf = (void *)cbuf;
! 106: ctlptr = &ctlbuf;
! 107: }
! 108:
! 109: if (dbuf != NULL)
! 110: {
! 111: memset (&databuf, 0, sizeof (databuf));
! 112: databuf.len = dbuflen;
! 113: databuf.buf = (void *)dbuf;
! 114: dataptr = &databuf;
! 115: }
! 116:
! 117: /* We assume this doesn't happen often and isn't operationally significant */
! 118: if (putmsg (fd, ctlptr, dataptr, flags) == -1)
! 119: zlog_debug ("%s: putmsg: %s", __func__, safe_strerror (errno));
! 120: }
! 121:
! 122: static ssize_t
! 123: dlpirctl (int fd)
! 124: {
! 125: struct pollfd fds[1];
! 126: struct strbuf ctlbuf, databuf;
! 127: int flags, retv;
! 128:
! 129: do
! 130: {
! 131: /* Poll is used here in case the device doesn't speak DLPI correctly */
! 132: memset (fds, 0, sizeof (fds));
! 133: fds[0].fd = fd;
! 134: fds[0].events = POLLIN | POLLPRI;
! 135: if (poll (fds, 1, 1000) <= 0)
! 136: return -1;
! 137:
! 138: memset (&ctlbuf, 0, sizeof (ctlbuf));
! 139: memset (&databuf, 0, sizeof (databuf));
! 140: ctlbuf.maxlen = sizeof (dlpi_ctl);
! 141: ctlbuf.buf = (void *)dlpi_ctl;
! 142: databuf.maxlen = sizeof (sock_buff);
! 143: databuf.buf = (void *)sock_buff;
! 144: flags = 0;
! 145: retv = getmsg (fd, &ctlbuf, &databuf, &flags);
! 146:
! 147: if (retv < 0)
! 148: return -1;
! 149: }
! 150: while (ctlbuf.len == 0);
! 151:
! 152: if (!(retv & MORECTL))
! 153: {
! 154: while (retv & MOREDATA)
! 155: {
! 156: flags = 0;
! 157: retv = getmsg (fd, NULL, &databuf, &flags);
! 158: }
! 159: return ctlbuf.len;
! 160: }
! 161:
! 162: while (retv & MORECTL)
! 163: {
! 164: flags = 0;
! 165: retv = getmsg (fd, &ctlbuf, &databuf, &flags);
! 166: }
! 167: return -1;
! 168: }
! 169:
! 170: static int
! 171: dlpiok (int fd, t_uscalar_t oprim)
! 172: {
! 173: int retv;
! 174: dl_ok_ack_t *doa = (dl_ok_ack_t *)dlpi_ctl;
! 175:
! 176: retv = dlpirctl (fd);
! 177: if (retv < DL_OK_ACK_SIZE || doa->dl_primitive != DL_OK_ACK ||
! 178: doa->dl_correct_primitive != oprim)
! 179: {
! 180: return -1;
! 181: }
! 182: else
! 183: {
! 184: return 0;
! 185: }
! 186: }
! 187:
! 188: static int
! 189: dlpiinfo (int fd)
! 190: {
! 191: dl_info_req_t dir;
! 192: ssize_t retv;
! 193:
! 194: memset (&dir, 0, sizeof (dir));
! 195: dir.dl_primitive = DL_INFO_REQ;
! 196: /* Info_req uses M_PCPROTO. */
! 197: dlpisend (fd, &dir, sizeof (dir), NULL, 0, RS_HIPRI);
! 198: retv = dlpirctl (fd);
! 199: if (retv < DL_INFO_ACK_SIZE || dlpi_ctl[0] != DL_INFO_ACK)
! 200: return -1;
! 201: else
! 202: return retv;
! 203: }
! 204:
! 205: static int
! 206: dlpiopen (const char *devpath, ssize_t *acklen)
! 207: {
! 208: int fd, flags;
! 209:
! 210: fd = open (devpath, O_RDWR | O_NONBLOCK | O_NOCTTY);
! 211: if (fd == -1)
! 212: return -1;
! 213:
! 214: /* All that we want is for the open itself to be non-blocking, not I/O. */
! 215: flags = fcntl (fd, F_GETFL, 0);
! 216: if (flags != -1)
! 217: fcntl (fd, F_SETFL, flags & ~O_NONBLOCK);
! 218:
! 219: /* After opening, ask for information */
! 220: if ((*acklen = dlpiinfo (fd)) == -1)
! 221: {
! 222: close (fd);
! 223: return -1;
! 224: }
! 225:
! 226: return fd;
! 227: }
! 228:
! 229: static int
! 230: dlpiattach (int fd, int unit)
! 231: {
! 232: dl_attach_req_t dar;
! 233:
! 234: memset (&dar, 0, sizeof (dar));
! 235: dar.dl_primitive = DL_ATTACH_REQ;
! 236: dar.dl_ppa = unit;
! 237: dlpisend (fd, &dar, sizeof (dar), NULL, 0, 0);
! 238: return dlpiok (fd, dar.dl_primitive);
! 239: }
! 240:
! 241: static int
! 242: dlpibind (int fd)
! 243: {
! 244: dl_bind_req_t dbr;
! 245: int retv;
! 246: dl_bind_ack_t *dba = (dl_bind_ack_t *)dlpi_ctl;
! 247:
! 248: memset (&dbr, 0, sizeof (dbr));
! 249: dbr.dl_primitive = DL_BIND_REQ;
! 250: dbr.dl_service_mode = DL_CLDLS;
! 251: dlpisend (fd, &dbr, sizeof (dbr), NULL, 0, 0);
! 252:
! 253: retv = dlpirctl (fd);
! 254: if (retv < DL_BIND_ACK_SIZE || dba->dl_primitive != DL_BIND_ACK)
! 255: return -1;
! 256: else
! 257: return 0;
! 258: }
! 259:
! 260: static int
! 261: dlpimcast (int fd, const u_char *mcaddr)
! 262: {
! 263: struct {
! 264: dl_enabmulti_req_t der;
! 265: u_char addr[ETHERADDRL];
! 266: } dler;
! 267:
! 268: memset (&dler, 0, sizeof (dler));
! 269: dler.der.dl_primitive = DL_ENABMULTI_REQ;
! 270: dler.der.dl_addr_length = sizeof (dler.addr);
! 271: dler.der.dl_addr_offset = dler.addr - (u_char *)&dler;
! 272: memcpy (dler.addr, mcaddr, sizeof (dler.addr));
! 273: dlpisend (fd, &dler, sizeof (dler), NULL, 0, 0);
! 274: return dlpiok (fd, dler.der.dl_primitive);
! 275: }
! 276:
! 277: static int
! 278: dlpiaddr (int fd, u_char *addr)
! 279: {
! 280: dl_phys_addr_req_t dpar;
! 281: dl_phys_addr_ack_t *dpaa = (dl_phys_addr_ack_t *)dlpi_ctl;
! 282: int retv;
! 283:
! 284: memset (&dpar, 0, sizeof (dpar));
! 285: dpar.dl_primitive = DL_PHYS_ADDR_REQ;
! 286: dpar.dl_addr_type = DL_CURR_PHYS_ADDR;
! 287: dlpisend (fd, &dpar, sizeof (dpar), NULL, 0, 0);
! 288:
! 289: retv = dlpirctl (fd);
! 290: if (retv < DL_PHYS_ADDR_ACK_SIZE || dpaa->dl_primitive != DL_PHYS_ADDR_ACK)
! 291: return -1;
! 292:
! 293: if (dpaa->dl_addr_offset < DL_PHYS_ADDR_ACK_SIZE ||
! 294: dpaa->dl_addr_length != ETHERADDRL ||
! 295: dpaa->dl_addr_offset + dpaa->dl_addr_length > retv)
! 296: return -1;
! 297:
! 298: bcopy((char *)dpaa + dpaa->dl_addr_offset, addr, ETHERADDRL);
! 299: return 0;
! 300: }
! 301:
! 302: static int
! 303: open_dlpi_dev (struct isis_circuit *circuit)
! 304: {
! 305: int fd, unit, retval;
! 306: char devpath[MAXPATHLEN];
! 307: dl_info_ack_t *dia = (dl_info_ack_t *)dlpi_ctl;
! 308: ssize_t acklen;
! 309:
! 310: /* Only broadcast-type are supported at the moment */
! 311: if (circuit->circ_type != CIRCUIT_T_BROADCAST)
! 312: {
! 313: zlog_warn ("%s: non-broadcast interface %s", __func__,
! 314: circuit->interface->name);
! 315: return ISIS_WARNING;
! 316: }
! 317:
! 318: /* Try the vanity node first, if permitted */
! 319: if (getenv("DLPI_DEVONLY") == NULL)
! 320: {
! 321: (void) snprintf (devpath, sizeof(devpath), "/dev/net/%s",
! 322: circuit->interface->name);
! 323: fd = dlpiopen (devpath, &acklen);
! 324: }
! 325:
! 326: /* Now try as an ordinary Style 1 node */
! 327: if (fd == -1)
! 328: {
! 329: (void) snprintf (devpath, sizeof (devpath), "/dev/%s",
! 330: circuit->interface->name);
! 331: unit = -1;
! 332: fd = dlpiopen (devpath, &acklen);
! 333: }
! 334:
! 335: /* If that fails, try again as Style 2 */
! 336: if (fd == -1)
! 337: {
! 338: char *cp;
! 339:
! 340: cp = devpath + strlen (devpath);
! 341: while (--cp >= devpath && isdigit(*cp))
! 342: ;
! 343: unit = strtol(cp, NULL, 0);
! 344: *cp = '\0';
! 345: fd = dlpiopen (devpath, &acklen);
! 346:
! 347: /* If that too fails, then the device really doesn't exist */
! 348: if (fd == -1)
! 349: {
! 350: zlog_warn ("%s: unknown interface %s", __func__,
! 351: circuit->interface->name);
! 352: return ISIS_WARNING;
! 353: }
! 354:
! 355: /* Double check the DLPI style */
! 356: if (dia->dl_provider_style != DL_STYLE2)
! 357: {
! 358: zlog_warn ("open_dlpi_dev(): interface %s: %s is not style 2",
! 359: circuit->interface->name, devpath);
! 360: close (fd);
! 361: return ISIS_WARNING;
! 362: }
! 363:
! 364: /* If it succeeds, then we need to attach to the unit specified */
! 365: dlpiattach (fd, unit);
! 366:
! 367: /* Reget the information, as it may be different per node */
! 368: if ((acklen = dlpiinfo (fd)) == -1)
! 369: {
! 370: close (fd);
! 371: return ISIS_WARNING;
! 372: }
! 373: }
! 374: else
! 375: {
! 376: /* Double check the DLPI style */
! 377: if (dia->dl_provider_style != DL_STYLE1)
! 378: {
! 379: zlog_warn ("open_dlpi_dev(): interface %s: %s is not style 1",
! 380: circuit->interface->name, devpath);
! 381: close (fd);
! 382: return ISIS_WARNING;
! 383: }
! 384: }
! 385:
! 386: /* Check that the interface we've got is the kind we expect */
! 387: if ((dia->dl_sap_length != 2 && dia->dl_sap_length != -2) ||
! 388: dia->dl_service_mode != DL_CLDLS || dia->dl_addr_length != ETHERADDRL + 2 ||
! 389: dia->dl_brdcst_addr_length != ETHERADDRL)
! 390: {
! 391: zlog_warn ("%s: unsupported interface type for %s", __func__,
! 392: circuit->interface->name);
! 393: close (fd);
! 394: return ISIS_WARNING;
! 395: }
! 396: switch (dia->dl_mac_type)
! 397: {
! 398: case DL_CSMACD:
! 399: case DL_ETHER:
! 400: case DL_100VG:
! 401: case DL_100VGTPR:
! 402: case DL_ETH_CSMA:
! 403: case DL_100BT:
! 404: break;
! 405: default:
! 406: zlog_warn ("%s: unexpected mac type on %s: %d", __func__,
! 407: circuit->interface->name, dia->dl_mac_type);
! 408: close (fd);
! 409: return ISIS_WARNING;
! 410: }
! 411:
! 412: circuit->sap_length = dia->dl_sap_length;
! 413:
! 414: /*
! 415: * The local hardware address is something that should be provided by way of
! 416: * sockaddr_dl for the interface, but isn't on Solaris. We set it here based
! 417: * on DLPI's reported address to avoid roto-tilling the world.
! 418: * (Note that isis_circuit_if_add on Solaris doesn't set the snpa.)
! 419: *
! 420: * Unfortunately, GLD is broken and doesn't provide the address after attach,
! 421: * so we need to be careful and use DL_PHYS_ADDR_REQ instead.
! 422: */
! 423: if (dlpiaddr (fd, circuit->u.bc.snpa) == -1)
! 424: {
! 425: zlog_warn ("open_dlpi_dev(): interface %s: unable to get MAC address",
! 426: circuit->interface->name);
! 427: close (fd);
! 428: return ISIS_WARNING;
! 429: }
! 430:
! 431: /* Now bind to SAP 0. This gives us 802-type traffic. */
! 432: if (dlpibind (fd) == -1)
! 433: {
! 434: zlog_warn ("%s: cannot bind SAP 0 on %s", __func__,
! 435: circuit->interface->name);
! 436: close (fd);
! 437: return ISIS_WARNING;
! 438: }
! 439:
! 440: /*
! 441: * Join to multicast groups according to
! 442: * 8.4.2 - Broadcast subnetwork IIH PDUs
! 443: */
! 444: retval = 0;
! 445: if (circuit->circuit_is_type & IS_LEVEL_1)
! 446: {
! 447: retval |= dlpimcast (fd, ALL_L1_ISS);
! 448: retval |= dlpimcast (fd, ALL_ISS);
! 449: }
! 450: if (circuit->circuit_is_type & IS_LEVEL_2)
! 451: retval |= dlpimcast (fd, ALL_L2_ISS);
! 452:
! 453: if (retval != 0)
! 454: {
! 455: zlog_warn ("%s: unable to join multicast on %s", __func__,
! 456: circuit->interface->name);
! 457: close (fd);
! 458: return ISIS_WARNING;
! 459: }
! 460:
! 461: /* Push on the packet filter to avoid stray 802 packets */
! 462: if (ioctl (fd, I_PUSH, "pfmod") == 0)
! 463: {
! 464: struct packetfilt pfil;
! 465: struct strioctl sioc;
! 466:
! 467: pfil.Pf_Priority = 0;
! 468: pfil.Pf_FilterLen = sizeof (pf_filter) / sizeof (u_short);
! 469: memcpy (pfil.Pf_Filter, pf_filter, sizeof (pf_filter));
! 470: /* pfmod does not support transparent ioctls */
! 471: sioc.ic_cmd = PFIOCSETF;
! 472: sioc.ic_timout = 5;
! 473: sioc.ic_len = sizeof (struct packetfilt);
! 474: sioc.ic_dp = (char *)&pfil;
! 475: if (ioctl (fd, I_STR, &sioc) == -1)
! 476: zlog_warn("%s: could not perform PF_IOCSETF on %s",
! 477: __func__, circuit->interface->name);
! 478: }
! 479:
! 480: circuit->fd = fd;
! 481:
! 482: return ISIS_OK;
! 483: }
! 484:
! 485: /*
! 486: * Create the socket and set the tx/rx funcs
! 487: */
! 488: int
! 489: isis_sock_init (struct isis_circuit *circuit)
! 490: {
! 491: int retval = ISIS_OK;
! 492:
! 493: if (isisd_privs.change (ZPRIVS_RAISE))
! 494: zlog_err ("%s: could not raise privs, %s", __func__, safe_strerror (errno));
! 495:
! 496: retval = open_dlpi_dev (circuit);
! 497:
! 498: if (retval != ISIS_OK)
! 499: {
! 500: zlog_warn ("%s: could not initialize the socket", __func__);
! 501: goto end;
! 502: }
! 503:
! 504: if (circuit->circ_type == CIRCUIT_T_BROADCAST)
! 505: {
! 506: circuit->tx = isis_send_pdu_bcast;
! 507: circuit->rx = isis_recv_pdu_bcast;
! 508: }
! 509: else
! 510: {
! 511: zlog_warn ("isis_sock_init(): unknown circuit type");
! 512: retval = ISIS_WARNING;
! 513: goto end;
! 514: }
! 515:
! 516: end:
! 517: if (isisd_privs.change (ZPRIVS_LOWER))
! 518: zlog_err ("%s: could not lower privs, %s", __func__, safe_strerror (errno));
! 519:
! 520: return retval;
! 521: }
! 522:
! 523: int
! 524: isis_recv_pdu_bcast (struct isis_circuit *circuit, u_char * ssnpa)
! 525: {
! 526: struct pollfd fds[1];
! 527: struct strbuf ctlbuf, databuf;
! 528: int flags, retv;
! 529: dl_unitdata_ind_t *dui = (dl_unitdata_ind_t *)dlpi_ctl;
! 530:
! 531: memset (fds, 0, sizeof (fds));
! 532: fds[0].fd = circuit->fd;
! 533: fds[0].events = POLLIN | POLLPRI;
! 534: if (poll (fds, 1, 0) <= 0)
! 535: return ISIS_WARNING;
! 536:
! 537: memset (&ctlbuf, 0, sizeof (ctlbuf));
! 538: memset (&databuf, 0, sizeof (databuf));
! 539: ctlbuf.maxlen = sizeof (dlpi_ctl);
! 540: ctlbuf.buf = (void *)dlpi_ctl;
! 541: databuf.maxlen = sizeof (sock_buff);
! 542: databuf.buf = (void *)sock_buff;
! 543: flags = 0;
! 544: retv = getmsg (circuit->fd, &ctlbuf, &databuf, &flags);
! 545:
! 546: if (retv < 0)
! 547: {
! 548: zlog_warn ("isis_recv_pdu_bcast: getmsg failed: %s",
! 549: safe_strerror (errno));
! 550: return ISIS_WARNING;
! 551: }
! 552:
! 553: if (retv & (MORECTL | MOREDATA))
! 554: {
! 555: while (retv & (MORECTL | MOREDATA))
! 556: {
! 557: flags = 0;
! 558: retv = getmsg (circuit->fd, &ctlbuf, &databuf, &flags);
! 559: }
! 560: return ISIS_WARNING;
! 561: }
! 562:
! 563: if (ctlbuf.len < DL_UNITDATA_IND_SIZE ||
! 564: dui->dl_primitive != DL_UNITDATA_IND)
! 565: return ISIS_WARNING;
! 566:
! 567: if (dui->dl_src_addr_length != ETHERADDRL + 2 ||
! 568: dui->dl_src_addr_offset < DL_UNITDATA_IND_SIZE ||
! 569: dui->dl_src_addr_offset + dui->dl_src_addr_length > ctlbuf.len)
! 570: return ISIS_WARNING;
! 571:
! 572: memcpy (ssnpa, (char *)dui + dui->dl_src_addr_offset +
! 573: (circuit->sap_length > 0 ? circuit->sap_length : 0), ETHERADDRL);
! 574:
! 575: if (databuf.len < LLC_LEN || sock_buff[0] != ISO_SAP ||
! 576: sock_buff[1] != ISO_SAP || sock_buff[2] != 3)
! 577: return ISIS_WARNING;
! 578:
! 579: stream_write (circuit->rcv_stream, sock_buff + LLC_LEN,
! 580: databuf.len - LLC_LEN);
! 581: stream_set_getp (circuit->rcv_stream, 0);
! 582:
! 583: return ISIS_OK;
! 584: }
! 585:
! 586: int
! 587: isis_send_pdu_bcast (struct isis_circuit *circuit, int level)
! 588: {
! 589: dl_unitdata_req_t *dur = (dl_unitdata_req_t *)dlpi_ctl;
! 590: char *dstaddr;
! 591: u_short *dstsap;
! 592:
! 593: stream_set_getp (circuit->snd_stream, 0);
! 594:
! 595: memset (dur, 0, sizeof (*dur));
! 596: dur->dl_primitive = DL_UNITDATA_REQ;
! 597: dur->dl_dest_addr_length = ETHERADDRL + 2;
! 598: dur->dl_dest_addr_offset = sizeof (*dur);
! 599:
! 600: dstaddr = (char *)(dur + 1);
! 601: if (circuit->sap_length < 0)
! 602: {
! 603: dstsap = (u_short *)(dstaddr + ETHERADDRL);
! 604: }
! 605: else
! 606: {
! 607: dstsap = (u_short *)dstaddr;
! 608: dstaddr += circuit->sap_length;
! 609: }
! 610: if (level == 1)
! 611: memcpy (dstaddr, ALL_L1_ISS, ETHERADDRL);
! 612: else
! 613: memcpy (dstaddr, ALL_L2_ISS, ETHERADDRL);
! 614: /* Note: DLPI SAP values are in host byte order */
! 615: *dstsap = stream_get_endp (circuit->snd_stream) + LLC_LEN;
! 616:
! 617: sock_buff[0] = ISO_SAP;
! 618: sock_buff[1] = ISO_SAP;
! 619: sock_buff[2] = 0x03;
! 620: memcpy (sock_buff + LLC_LEN, circuit->snd_stream->data,
! 621: stream_get_endp (circuit->snd_stream));
! 622: dlpisend (circuit->fd, dur, sizeof (*dur) + dur->dl_dest_addr_length,
! 623: sock_buff, stream_get_endp (circuit->snd_stream) + LLC_LEN, 0);
! 624: return ISIS_OK;
! 625: }
! 626:
! 627: #endif /* ISIS_METHOD == ISIS_METHOD_DLPI */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to isis_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 / quagga / isisd