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 50extern struct zebra_privs_t isisd_privs; 51 52static 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 59u_char ALL_L1_ISS[6] = { 0x01, 0x80, 0xC2, 0x00, 0x00, 0x14 }; 60u_char ALL_L2_ISS[6] = { 0x01, 0x80, 0xC2, 0x00, 0x00, 0x15 }; 61u_char ALL_ISS[6] = { 0x09, 0x00, 0x2B, 0x00, 0x00, 0x05 }; 62u_char ALL_ESS[6] = { 0x09, 0x00, 0x2B, 0x00, 0x00, 0x04 }; 63 64static u_char sock_buff[8192]; 65 66static 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 93static void 94dlpisend (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 122static ssize_t 123dlpirctl (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 170static int 171dlpiok (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 188static int 189dlpiinfo (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 205static int 206dlpiopen (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 229static int 230dlpiattach (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 241static int 242dlpibind (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 260static int 261dlpimcast (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 277static int 278dlpiaddr (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 302static int 303open_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 retval |= dlpimcast (fd, ALL_L1_ISS); 446 retval |= dlpimcast (fd, ALL_ISS); 447 retval |= dlpimcast (fd, ALL_L2_ISS); 448 449 if (retval != 0) 450 { 451 zlog_warn ("%s: unable to join multicast on %s", __func__, 452 circuit->interface->name); 453 close (fd); 454 return ISIS_WARNING; 455 } 456 457 /* Push on the packet filter to avoid stray 802 packets */ 458 if (ioctl (fd, I_PUSH, "pfmod") == 0) 459 { 460 struct packetfilt pfil; 461 struct strioctl sioc; 462 463 pfil.Pf_Priority = 0; 464 pfil.Pf_FilterLen = sizeof (pf_filter) / sizeof (u_short); 465 memcpy (pfil.Pf_Filter, pf_filter, sizeof (pf_filter)); 466 /* pfmod does not support transparent ioctls */ 467 sioc.ic_cmd = PFIOCSETF; 468 sioc.ic_timout = 5; 469 sioc.ic_len = sizeof (struct packetfilt); 470 sioc.ic_dp = (char *)&pfil; 471 if (ioctl (fd, I_STR, &sioc) == -1) 472 zlog_warn("%s: could not perform PF_IOCSETF on %s", 473 __func__, circuit->interface->name); 474 } 475 476 circuit->fd = fd; 477 478 return ISIS_OK; 479} 480 481/* 482 * Create the socket and set the tx/rx funcs 483 */ 484int 485isis_sock_init (struct isis_circuit *circuit) 486{ 487 int retval = ISIS_OK; 488 489 if (isisd_privs.change (ZPRIVS_RAISE)) 490 zlog_err ("%s: could not raise privs, %s", __func__, safe_strerror (errno)); 491 492 retval = open_dlpi_dev (circuit); 493 494 if (retval != ISIS_OK) 495 { 496 zlog_warn ("%s: could not initialize the socket", __func__); 497 goto end; 498 } 499 500 if (circuit->circ_type == CIRCUIT_T_BROADCAST) 501 { 502 circuit->tx = isis_send_pdu_bcast; 503 circuit->rx = isis_recv_pdu_bcast; 504 } 505 else 506 { 507 zlog_warn ("isis_sock_init(): unknown circuit type"); 508 retval = ISIS_WARNING; 509 goto end; 510 } 511 512end: 513 if (isisd_privs.change (ZPRIVS_LOWER)) 514 zlog_err ("%s: could not lower privs, %s", __func__, safe_strerror (errno)); 515 516 return retval; 517} 518 519int 520isis_recv_pdu_bcast (struct isis_circuit *circuit, u_char * ssnpa) 521{ 522 struct pollfd fds[1]; 523 struct strbuf ctlbuf, databuf; 524 int flags, retv; 525 dl_unitdata_ind_t *dui = (dl_unitdata_ind_t *)dlpi_ctl; 526 527 memset (fds, 0, sizeof (fds)); 528 fds[0].fd = circuit->fd; 529 fds[0].events = POLLIN | POLLPRI; 530 if (poll (fds, 1, 0) <= 0) 531 return ISIS_WARNING; 532 533 memset (&ctlbuf, 0, sizeof (ctlbuf)); 534 memset (&databuf, 0, sizeof (databuf)); 535 ctlbuf.maxlen = sizeof (dlpi_ctl); 536 ctlbuf.buf = (void *)dlpi_ctl; 537 databuf.maxlen = sizeof (sock_buff); 538 databuf.buf = (void *)sock_buff; 539 flags = 0; 540 retv = getmsg (circuit->fd, &ctlbuf, &databuf, &flags); 541 542 if (retv < 0) 543 { 544 zlog_warn ("isis_recv_pdu_bcast: getmsg failed: %s", 545 safe_strerror (errno)); 546 return ISIS_WARNING; 547 } 548 549 if (retv & (MORECTL | MOREDATA)) 550 { 551 while (retv & (MORECTL | MOREDATA)) 552 { 553 flags = 0; 554 retv = getmsg (circuit->fd, &ctlbuf, &databuf, &flags); 555 } 556 return ISIS_WARNING; 557 } 558 559 if (ctlbuf.len < DL_UNITDATA_IND_SIZE || 560 dui->dl_primitive != DL_UNITDATA_IND) 561 return ISIS_WARNING; 562 563 if (dui->dl_src_addr_length != ETHERADDRL + 2 || 564 dui->dl_src_addr_offset < DL_UNITDATA_IND_SIZE || 565 dui->dl_src_addr_offset + dui->dl_src_addr_length > ctlbuf.len) 566 return ISIS_WARNING; 567 568 memcpy (ssnpa, (char *)dui + dui->dl_src_addr_offset + 569 (circuit->sap_length > 0 ? circuit->sap_length : 0), ETHERADDRL); 570 571 if (databuf.len < LLC_LEN || sock_buff[0] != ISO_SAP || 572 sock_buff[1] != ISO_SAP || sock_buff[2] != 3) 573 return ISIS_WARNING; 574 575 stream_write (circuit->rcv_stream, sock_buff + LLC_LEN, 576 databuf.len - LLC_LEN); 577 stream_set_getp (circuit->rcv_stream, 0); 578 579 return ISIS_OK; 580} 581 582int 583isis_send_pdu_bcast (struct isis_circuit *circuit, int level) 584{ 585 dl_unitdata_req_t *dur = (dl_unitdata_req_t *)dlpi_ctl; 586 char *dstaddr; 587 u_short *dstsap; 588 int buflen; 589 590 buflen = stream_get_endp (circuit->snd_stream) + LLC_LEN; 591 if (buflen > sizeof (sock_buff)) 592 { 593 zlog_warn ("isis_send_pdu_bcast: sock_buff size %lu is less than " 594 "output pdu size %d on circuit %s", 595 sizeof (sock_buff), buflen, circuit->interface->name); 596 return ISIS_WARNING; 597 } 598 599 stream_set_getp (circuit->snd_stream, 0); 600 601 memset (dur, 0, sizeof (*dur)); 602 dur->dl_primitive = DL_UNITDATA_REQ; 603 dur->dl_dest_addr_length = ETHERADDRL + 2; 604 dur->dl_dest_addr_offset = sizeof (*dur); 605 606 dstaddr = (char *)(dur + 1); 607 if (circuit->sap_length < 0) 608 { 609 dstsap = (u_short *)(dstaddr + ETHERADDRL); 610 } 611 else 612 { 613 dstsap = (u_short *)dstaddr; 614 dstaddr += circuit->sap_length; 615 } 616 if (level == 1) 617 memcpy (dstaddr, ALL_L1_ISS, ETHERADDRL); 618 else 619 memcpy (dstaddr, ALL_L2_ISS, ETHERADDRL); 620 /* Note: DLPI SAP values are in host byte order */ 621 *dstsap = buflen; 622 623 sock_buff[0] = ISO_SAP; 624 sock_buff[1] = ISO_SAP; 625 sock_buff[2] = 0x03; 626 memcpy (sock_buff + LLC_LEN, circuit->snd_stream->data, 627 stream_get_endp (circuit->snd_stream)); 628 dlpisend (circuit->fd, dur, sizeof (*dur) + dur->dl_dest_addr_length, 629 sock_buff, buflen, 0); 630 return ISIS_OK; 631} 632 633#endif /* ISIS_METHOD == ISIS_METHOD_DLPI */ 634