1 /*********************************************************************** 2 * 3 * if.c 4 * 5 * Implementation of user-space PPPoE redirector for Linux. 6 * 7 * Functions for opening a raw socket and reading/writing raw Ethernet frames. 8 * 9 * Copyright (C) 2000 by Roaring Penguin Software Inc. 10 * 11 * This program may be distributed according to the terms of the GNU 12 * General Public License, version 2 or (at your option) any later version. 13 * 14 ***********************************************************************/ 15 16 static char const RCSID[] = 17 "$Id: if.c,v 1.1 2001/12/14 02:55:20 mostrows Exp $"; 18 19 #include "pppoe.h" 20 21 #ifdef HAVE_UNISTD_H 22 #include <unistd.h> 23 #endif 24 25 #ifdef HAVE_NETPACKET_PACKET_H 26 #include <netpacket/packet.h> 27 #elif defined(HAVE_LINUX_IF_PACKET_H) 28 #include <linux/if_packet.h> 29 #endif 30 31 #ifdef HAVE_NET_ETHERNET_H 32 #include <net/ethernet.h> 33 #endif 34 35 #ifdef HAVE_ASM_TYPES_H 36 #include <asm/types.h> 37 #endif 38 39 #ifdef HAVE_SYS_IOCTL_H 40 #include <sys/ioctl.h> 41 #endif 42 43 #ifdef HAVE_SYSLOG_H 44 #include <syslog.h> 45 #endif 46 47 #include <errno.h> 48 #include <stdlib.h> 49 #include <string.h> 50 51 #ifdef HAVE_NET_IF_ARP_H 52 #include <net/if_arp.h> 53 #endif 54 55 #ifdef USE_DLPI 56 57 #include <limits.h> 58 #include <fcntl.h> 59 #include <stdlib.h> 60 #include <sys/types.h> 61 #include <sys/time.h> 62 #include <sys/stream.h> 63 #include <sys/stropts.h> 64 #include <sys/dlpi.h> 65 #include <sys/bufmod.h> 66 #include <stdio.h> 67 #include <signal.h> 68 #include <stropts.h> 69 70 /* function declarations */ 71 72 void dlpromisconreq( int fd, u_long level); 73 void dlinforeq(int fd); 74 void dlunitdatareq(int fd, u_char *addrp, int addrlen, u_long minpri, u_long maxpri, u_char *datap, int datalen); 75 void dlinfoack(int fd, char *bufp); 76 void dlbindreq(int fd, u_long sap, u_long max_conind, u_long service_mode, u_long conn_mgmt, u_long xidtest); 77 void dlattachreq(int fd, u_long ppa); 78 void dlokack(int fd, char *bufp); 79 void dlbindack(int fd, char *bufp); 80 int strioctl(int fd, int cmd, int timout, int len, char *dp); 81 void strgetmsg(int fd, struct strbuf *ctlp, struct strbuf *datap, int *flagsp, char *caller); 82 void sigalrm(int sig); 83 void expecting(int prim, union DL_primitives *dlp); 84 char *dlprim(u_long prim); 85 86 /* #define DL_DEBUG */ 87 88 static int dl_abssaplen; 89 static int dl_saplen; 90 static int dl_addrlen; 91 92 #endif 93 94 #ifdef USE_BPF 95 #include <net/bpf.h> 96 #include <fcntl.h> 97 98 unsigned char *bpfBuffer; /* Packet filter buffer */ 99 int bpfLength = 0; /* Packet filter buffer length */ 100 int bpfSize = 0; /* Number of unread bytes in buffer */ 101 int bpfOffset = 0; /* Current offset in bpfBuffer */ 102 #endif 103 104 /* Initialize frame types to RFC 2516 values. Some broken peers apparently 105 use different frame types... sigh... */ 106 107 UINT16_t Eth_PPPOE_Discovery = ETH_PPPOE_DISCOVERY; 108 UINT16_t Eth_PPPOE_Session = ETH_PPPOE_SESSION; 109 110 /********************************************************************** 111 *%FUNCTION: etherType 112 *%ARGUMENTS: 113 * packet -- a received PPPoE packet 114 *%RETURNS: 115 * ethernet packet type (see /usr/include/net/ethertypes.h) 116 *%DESCRIPTION: 117 * Checks the ethernet packet header to determine its type. 118 * We should only be receveing DISCOVERY and SESSION types if the BPF 119 * is set up correctly. Logs an error if an unexpected type is received. 120 * Note that the ethernet type names come from "pppoe.h" and the packet 121 * packet structure names use the LINUX dialect to maintain consistency 122 * with the rest of this file. See the BSD section of "pppoe.h" for 123 * translations of the data structure names. 124 ***********************************************************************/ 125 UINT16_t 126 etherType(PPPoEPacket *packet) 127 { 128 UINT16_t type = (UINT16_t) ntohs(packet->ethHdr.h_proto); 129 if (type != Eth_PPPOE_Discovery && type != Eth_PPPOE_Session) { 130 syslog(LOG_ERR, "Invalid ether type 0x%x", type); 131 } 132 return type; 133 } 134 135 #ifdef USE_BPF 136 /********************************************************************** 137 *%FUNCTION: getHWaddr 138 *%ARGUMENTS: 139 * ifname -- name of interface 140 * hwaddr -- buffer for ehthernet address 141 *%RETURNS: 142 * Nothing 143 *%DESCRIPTION: 144 * Locates the Ethernet hardware address for an interface. 145 ***********************************************************************/ 146 void 147 getHWaddr(int sock, char const *ifname, unsigned char *hwaddr) 148 { 149 char inbuf[8192]; 150 const struct sockaddr_dl *sdl; 151 struct ifconf ifc; 152 struct ifreq ifreq, *ifr; 153 int i; 154 int found = 0; 155 156 ifc.ifc_len = sizeof(inbuf); 157 ifc.ifc_buf = inbuf; 158 if (ioctl(sock, SIOCGIFCONF, &ifc) < 0) { 159 fatalSys("SIOCGIFCONF"); 160 } 161 ifr = ifc.ifc_req; 162 ifreq.ifr_name[0] = '\0'; 163 for (i = 0; i < ifc.ifc_len; ) { 164 ifr = (struct ifreq *)((caddr_t)ifc.ifc_req + i); 165 i += sizeof(ifr->ifr_name) + 166 (ifr->ifr_addr.sa_len > sizeof(struct sockaddr) 167 ? ifr->ifr_addr.sa_len 168 : sizeof(struct sockaddr)); 169 if (ifr->ifr_addr.sa_family == AF_LINK) { 170 sdl = (const struct sockaddr_dl *) &ifr->ifr_addr; 171 if ((sdl->sdl_type == IFT_ETHER) && 172 (sdl->sdl_alen == ETH_ALEN) && 173 !strncmp(ifname, ifr->ifr_name, sizeof(ifr->ifr_name))) { 174 if (found) { 175 char buffer[256]; 176 sprintf(buffer, "interface %.16s has more than one ethernet address", ifname); 177 rp_fatal(buffer); 178 } else { 179 found = 1; 180 memcpy(hwaddr, LLADDR(sdl), ETH_ALEN); 181 } 182 } 183 } 184 } 185 if (!found) { 186 char buffer[256]; 187 sprintf(buffer, "interface %.16s has no ethernet address", ifname); 188 rp_fatal(buffer); 189 } 190 } 191 192 /********************************************************************** 193 *%FUNCTION: initFilter 194 *%ARGUMENTS: 195 * fd -- file descriptor of BSD device 196 * type -- Ethernet frame type (0 for watch mode) 197 * hwaddr -- buffer with ehthernet address 198 *%RETURNS: 199 * Nothing 200 *%DESCRIPTION: 201 * Initializes the packet filter rules. 202 ***********************************************************************/ 203 void 204 initFilter(int fd, UINT16_t type, unsigned char *hwaddr) 205 { 206 /* Packet Filter Instructions: 207 * Note that the ethernet type names come from "pppoe.h" and are 208 * used here to maintain consistency with the rest of this file. */ 209 static struct bpf_insn bpfRun[] = { /* run PPPoE */ 210 BPF_STMT(BPF_LD+BPF_H+BPF_ABS, 12), /* ethernet type */ 211 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, ETH_PPPOE_SESSION, 5, 0), 212 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, ETH_PPPOE_DISCOVERY, 0, 9), 213 BPF_STMT(BPF_LD+BPF_W+BPF_ABS, 0), /* first word of dest. addr */ 214 #define PPPOE_BCAST_CMPW 4 /* offset of word compare */ 215 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0, 0, 2), 216 BPF_STMT(BPF_LD+BPF_H+BPF_ABS, 4), /* next 1/2 word of dest. */ 217 #define PPPOE_BCAST_CMPH 6 /* offset of 1/2 word compare */ 218 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0, 4, 0), 219 BPF_STMT(BPF_LD+BPF_W+BPF_ABS, 0), /* first word of dest. addr */ 220 #define PPPOE_FILTER_CMPW 8 /* offset of word compare */ 221 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0, 0, 3), 222 BPF_STMT(BPF_LD+BPF_H+BPF_ABS, 4), /* next 1/2 word of dest. */ 223 #define PPPOE_FILTER_CMPH 10 /* offset of 1/rd compare */ 224 BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0, 0, 1), 225 BPF_STMT(BPF_RET+BPF_K, (u_int) -1), /* keep packet */ 226 BPF_STMT(BPF_RET+BPF_K, 0), /* drop packet */ 227 }; 228 229 /* Fix the potentially varying parts */ 230 bpfRun[1].code = (u_short) BPF_JMP+BPF_JEQ+BPF_K; 231 bpfRun[1].jt = 5; 232 bpfRun[1].jf = 0; 233 bpfRun[1].k = Eth_PPPOE_Session; 234 235 bpfRun[2].code = (u_short) BPF_JMP+BPF_JEQ+BPF_K; 236 bpfRun[2].jt = 0; 237 bpfRun[2].jf = 9; 238 bpfRun[2].k = Eth_PPPOE_Discovery; 239 240 { 241 struct bpf_insn bpfInsn[sizeof(bpfRun) / sizeof(bpfRun[0])]; 242 struct bpf_program bpfProgram; 243 memcpy(bpfInsn, bpfRun, sizeof(bpfRun)); 244 bpfInsn[PPPOE_BCAST_CMPW].k = ((0xff << 24) | (0xff << 16) | 245 (0xff << 8) | 0xff); 246 bpfInsn[PPPOE_BCAST_CMPH].k = ((0xff << 8) | 0xff); 247 bpfInsn[PPPOE_FILTER_CMPW].k = ((hwaddr[0] << 24) | (hwaddr[1] << 16) | 248 (hwaddr[2] << 8) | hwaddr[3]); 249 bpfInsn[PPPOE_FILTER_CMPH].k = ((hwaddr[4] << 8) | hwaddr[5]); 250 bpfProgram.bf_len = (sizeof(bpfInsn) / sizeof(bpfInsn[0])); 251 bpfProgram.bf_insns = &bpfInsn[0]; 252 253 /* Apply the filter */ 254 if (ioctl(fd, BIOCSETF, &bpfProgram) < 0) { 255 fatalSys("ioctl(BIOCSETF)"); 256 } 257 } 258 } 259 260 /********************************************************************** 261 *%FUNCTION: openInterface 262 *%ARGUMENTS: 263 * ifname -- name of interface 264 * type -- Ethernet frame type (0 for any frame type) 265 * hwaddr -- if non-NULL, set to the hardware address 266 *%RETURNS: 267 * A file descriptor for talking with the Ethernet card. Exits on error. 268 * Note that the Linux version of this routine returns a socket instead. 269 *%DESCRIPTION: 270 * Opens a BPF on an interface for all PPPoE traffic (discovery and 271 * session). If 'type' is 0, uses promiscuous mode to watch any PPPoE 272 * traffic on this network. 273 ***********************************************************************/ 274 int 275 openInterface(char const *ifname, UINT16_t type, unsigned char *hwaddr) 276 { 277 static int fd = -1; 278 char bpfName[32]; 279 u_int optval; 280 struct bpf_version bpf_ver; 281 struct ifreq ifr; 282 int sock; 283 int i; 284 285 /* BSD only opens one socket for both Discovery and Session packets */ 286 if (fd >= 0) { 287 return fd; 288 } 289 290 /* Find a free BPF device */ 291 for (i = 0; i < 256; i++) { 292 sprintf(bpfName, "/dev/bpf%d", i); 293 if (((fd = open(bpfName, O_RDWR, 0)) >= 0) || 294 (errno != EBUSY)) { 295 break; 296 } 297 } 298 if (fd < 0) { 299 switch (errno) { 300 case EACCES: /* permission denied */ 301 { 302 char buffer[256]; 303 sprintf(buffer, "Cannot open %.32s -- pppoe must be run as root.", bpfName); 304 rp_fatal(buffer); 305 } 306 break; 307 case EBUSY: 308 case ENOENT: /* no such file */ 309 if (i == 0) { 310 rp_fatal("No /dev/bpf* devices (check your kernel configuration for BPF support)"); 311 } else { 312 rp_fatal("All /dev/bpf* devices are in use"); 313 } 314 break; 315 } 316 fatalSys(bpfName); 317 } 318 319 if ((sock = socket(AF_LOCAL, SOCK_DGRAM, 0)) < 0) { 320 fatalSys("socket"); 321 } 322 323 /* Check that the interface is up */ 324 strncpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name)); 325 if (ioctl(sock, SIOCGIFFLAGS, &ifr) < 0) { 326 fatalSys("ioctl(SIOCGIFFLAGS)"); 327 } 328 if ((ifr.ifr_flags & IFF_UP) == 0) { 329 char buffer[256]; 330 sprintf(buffer, "Interface %.16s is not up\n", ifname); 331 rp_fatal(buffer); 332 } 333 334 /* Fill in hardware address and initialize the packet filter rules */ 335 if (hwaddr == NULL) { 336 rp_fatal("openInterface: no hwaddr arg."); 337 } 338 getHWaddr(sock, ifname, hwaddr); 339 initFilter(fd, type, hwaddr); 340 341 /* Sanity check on MTU -- apparently does not work on OpenBSD */ 342 #if !defined(__OpenBSD__) 343 strncpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name)); 344 if (ioctl(sock, SIOCGIFMTU, &ifr) < 0) { 345 fatalSys("ioctl(SIOCGIFMTU)"); 346 } 347 if (ifr.ifr_mtu < ETH_DATA_LEN) { 348 char buffer[256]; 349 sprintf(buffer, "Interface %.16s has MTU of %d -- should be %d. You may have serious connection problems.", 350 ifname, ifr.ifr_mtu, ETH_DATA_LEN); 351 printErr(buffer); 352 } 353 #endif 354 355 /* done with the socket */ 356 if (close(sock) < 0) { 357 fatalSys("close"); 358 } 359 360 /* Check the BPF version number */ 361 if (ioctl(fd, BIOCVERSION, &bpf_ver) < 0) { 362 fatalSys("ioctl(BIOCVERSION)"); 363 } 364 if ((bpf_ver.bv_major != BPF_MAJOR_VERSION) || 365 (bpf_ver.bv_minor < BPF_MINOR_VERSION)) { 366 char buffer[256]; 367 sprintf(buffer, "Unsupported BPF version: %d.%d (kernel: %d.%d)", 368 BPF_MAJOR_VERSION, BPF_MINOR_VERSION, 369 bpf_ver.bv_major, bpf_ver.bv_minor); 370 rp_fatal(buffer); 371 } 372 373 /* allocate a receive packet buffer */ 374 if (ioctl(fd, BIOCGBLEN, &bpfLength) < 0) { 375 fatalSys("ioctl(BIOCGBLEN)"); 376 } 377 if (!(bpfBuffer = (unsigned char *) malloc(bpfLength))) { 378 rp_fatal("malloc"); 379 } 380 381 /* reads should return as soon as there is a packet available */ 382 optval = 1; 383 if (ioctl(fd, BIOCIMMEDIATE, &optval) < 0) { 384 fatalSys("ioctl(BIOCIMMEDIATE)"); 385 } 386 387 /* Bind the interface to the filter */ 388 strncpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name)); 389 if (ioctl(fd, BIOCSETIF, &ifr) < 0) { 390 char buffer[256]; 391 sprintf(buffer, "ioctl(BIOCSETIF) can't select interface %.16s", 392 ifname); 393 rp_fatal(buffer); 394 } 395 396 syslog(LOG_INFO, "Interface=%.16s HWaddr=%02X:%02X:%02X:%02X:%02X:%02X Device=%.32s Buffer size=%d", 397 ifname, 398 hwaddr[0], hwaddr[1], hwaddr[2], 399 hwaddr[3], hwaddr[4], hwaddr[5], 400 bpfName, bpfLength); 401 return fd; 402 } 403 404 #endif /* USE_BPF */ 405 406 #ifdef USE_LINUX_PACKET 407 /********************************************************************** 408 *%FUNCTION: openInterface 409 *%ARGUMENTS: 410 * ifname -- name of interface 411 * type -- Ethernet frame type 412 * hwaddr -- if non-NULL, set to the hardware address 413 *%RETURNS: 414 * A raw socket for talking to the Ethernet card. Exits on error. 415 *%DESCRIPTION: 416 * Opens a raw Ethernet socket 417 ***********************************************************************/ 418 int 419 openInterface(char const *ifname, UINT16_t type, unsigned char *hwaddr) 420 { 421 int optval=1; 422 int fd; 423 struct ifreq ifr; 424 int domain, stype; 425 426 #ifdef HAVE_STRUCT_SOCKADDR_LL 427 struct sockaddr_ll sa; 428 #else 429 struct sockaddr sa; 430 #endif 431 432 memset(&sa, 0, sizeof(sa)); 433 434 #ifdef HAVE_STRUCT_SOCKADDR_LL 435 domain = PF_PACKET; 436 stype = SOCK_RAW; 437 #else 438 domain = PF_INET; 439 stype = SOCK_PACKET; 440 #endif 441 442 if ((fd = socket(domain, stype, htons(type))) < 0) { 443 /* Give a more helpful message for the common error case */ 444 if (errno == EPERM) { 445 rp_fatal("Cannot create raw socket -- pppoe must be run as root."); 446 } 447 fatalSys("socket"); 448 } 449 450 if (setsockopt(fd, SOL_SOCKET, SO_BROADCAST, &optval, sizeof(optval)) < 0) { 451 fatalSys("setsockopt"); 452 } 453 454 /* Fill in hardware address */ 455 if (hwaddr) { 456 strncpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name)); 457 if (ioctl(fd, SIOCGIFHWADDR, &ifr) < 0) { 458 fatalSys("ioctl(SIOCGIFHWADDR)"); 459 } 460 memcpy(hwaddr, ifr.ifr_hwaddr.sa_data, ETH_ALEN); 461 #ifdef ARPHRD_ETHER 462 if (ifr.ifr_hwaddr.sa_family != ARPHRD_ETHER) { 463 char buffer[256]; 464 sprintf(buffer, "Interface %.16s is not Ethernet", ifname); 465 rp_fatal(buffer); 466 } 467 #endif 468 if (NOT_UNICAST(hwaddr)) { 469 char buffer[256]; 470 sprintf(buffer, 471 "Interface %.16s has broadcast/multicast MAC address??", 472 ifname); 473 rp_fatal(buffer); 474 } 475 } 476 477 /* Sanity check on MTU */ 478 strncpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name)); 479 if (ioctl(fd, SIOCGIFMTU, &ifr) < 0) { 480 fatalSys("ioctl(SIOCGIFMTU)"); 481 } 482 if (ifr.ifr_mtu < ETH_DATA_LEN) { 483 char buffer[256]; 484 sprintf(buffer, "Interface %.16s has MTU of %d -- should be %d. You may have serious connection problems.", 485 ifname, ifr.ifr_mtu, ETH_DATA_LEN); 486 printErr(buffer); 487 } 488 489 #ifdef HAVE_STRUCT_SOCKADDR_LL 490 /* Get interface index */ 491 sa.sll_family = AF_PACKET; 492 sa.sll_protocol = htons(type); 493 494 strncpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name)); 495 if (ioctl(fd, SIOCGIFINDEX, &ifr) < 0) { 496 fatalSys("ioctl(SIOCFIGINDEX): Could not get interface index"); 497 } 498 sa.sll_ifindex = ifr.ifr_ifindex; 499 500 #else 501 strcpy(sa.sa_data, ifname); 502 #endif 503 504 /* We're only interested in packets on specified interface */ 505 if (bind(fd, (struct sockaddr *) &sa, sizeof(sa)) < 0) { 506 fatalSys("bind"); 507 } 508 509 return fd; 510 } 511 512 #endif /* USE_LINUX */ 513 514 /*********************************************************************** 515 *%FUNCTION: sendPacket 516 *%ARGUMENTS: 517 * sock -- socket to send to 518 * pkt -- the packet to transmit 519 * size -- size of packet (in bytes) 520 *%RETURNS: 521 * 0 on success; -1 on failure 522 *%DESCRIPTION: 523 * Transmits a packet 524 ***********************************************************************/ 525 int 526 sendPacket(PPPoEConnection *conn, int sock, PPPoEPacket *pkt, int size) 527 { 528 #if defined(USE_BPF) 529 if (write(sock, pkt, size) < 0) { 530 sysErr("write (sendPacket)"); 531 return -1; 532 } 533 #elif defined(HAVE_STRUCT_SOCKADDR_LL) 534 if (send(sock, pkt, size, 0) < 0) { 535 sysErr("send (sendPacket)"); 536 return -1; 537 } 538 #else 539 #ifdef USE_DLPI 540 541 #define ABS(x) ((x) < 0 ? -(x) : (x)) 542 543 u_char addr[MAXDLADDR]; 544 u_char phys[MAXDLADDR]; 545 u_char sap[MAXDLADDR]; 546 u_char xmitbuf[MAXDLBUF]; 547 int data_size; 548 549 short tmp_sap; 550 551 tmp_sap = htons(pkt->ethHdr.h_proto); 552 data_size = size - sizeof(struct ethhdr); 553 554 memcpy((char *)phys, (char *)pkt->ethHdr.h_dest, ETHERADDRL); 555 memcpy((char *)sap, (char *)&tmp_sap, sizeof(ushort_t)); 556 memcpy((char *)xmitbuf, (char *)pkt + sizeof(struct ethhdr), data_size); 557 558 if (dl_saplen > 0) { /* order is sap+phys */ 559 (void) memcpy((char*)addr, (char*)&sap, dl_abssaplen); 560 (void) memcpy((char*)addr+dl_abssaplen, (char*)phys, ETHERADDRL); 561 } else { /* order is phys+sap */ 562 (void) memcpy((char*)addr, (char*)phys, ETHERADDRL); 563 (void) memcpy((char*)addr+ETHERADDRL, (char*)&sap, dl_abssaplen); 564 } 565 566 #ifdef DL_DEBUG 567 printf("%02x:%02x:%02x:%02x:%02x:%02x %02x:%02x\n", 568 addr[0],addr[1],addr[2],addr[3],addr[4],addr[5], 569 addr[6],addr[7]); 570 #endif 571 572 dlunitdatareq(sock, addr, dl_addrlen, 0, 0, xmitbuf, data_size); 573 574 575 576 #else 577 struct sockaddr sa; 578 579 if (!conn) { 580 rp_fatal("relay and server not supported on Linux 2.0 kernels"); 581 } 582 strcpy(sa.sa_data, conn->ifName); 583 if (sendto(sock, pkt, size, 0, &sa, sizeof(sa)) < 0) { 584 sysErr("sendto (sendPacket)"); 585 return -1; 586 } 587 #endif 588 #endif 589 return 0; 590 } 591 592 #ifdef USE_BPF 593 /*********************************************************************** 594 *%FUNCTION: clearPacketHeader 595 *%ARGUMENTS: 596 * pkt -- packet that needs its head clearing 597 *%RETURNS: 598 * nothing 599 *%DESCRIPTION: 600 * Clears a PPPoE packet header after a truncated packet has been 601 * received. Insures that the packet will fail any integrity tests 602 * and will be discarded by upper level routines. Also resets the 603 * bpfSize and bpfOffset variables to force a new read on the next 604 * call to receivePacket(). 605 ***********************************************************************/ 606 void 607 clearPacketHeader(PPPoEPacket *pkt) 608 { 609 bpfSize = bpfOffset = 0; 610 memset(pkt, 0, HDR_SIZE); 611 } 612 #endif 613 614 /*********************************************************************** 615 *%FUNCTION: receivePacket 616 *%ARGUMENTS: 617 * sock -- socket to read from 618 * pkt -- place to store the received packet 619 * size -- set to size of packet in bytes 620 *%RETURNS: 621 * >= 0 if all OK; < 0 if error 622 *%DESCRIPTION: 623 * Receives a packet 624 ***********************************************************************/ 625 int 626 receivePacket(int sock, PPPoEPacket *pkt, int *size) 627 { 628 #ifdef USE_BPF 629 struct bpf_hdr hdr; 630 int seglen, copylen; 631 632 if (bpfSize <= 0) { 633 bpfOffset = 0; 634 if ((bpfSize = read(sock, bpfBuffer, bpfLength)) < 0) { 635 sysErr("read (receivePacket)"); 636 return -1; 637 } 638 } 639 if (bpfSize < sizeof(hdr)) { 640 syslog(LOG_ERR, "Truncated bpf packet header: len=%d", bpfSize); 641 clearPacketHeader(pkt); /* resets bpfSize and bpfOffset */ 642 return 0; 643 } 644 memcpy(&hdr, bpfBuffer + bpfOffset, sizeof(hdr)); 645 if (hdr.bh_caplen != hdr.bh_datalen) { 646 syslog(LOG_ERR, "Truncated bpf packet: caplen=%d, datalen=%d", 647 hdr.bh_caplen, hdr.bh_datalen); 648 clearPacketHeader(pkt); /* resets bpfSize and bpfOffset */ 649 return 0; 650 } 651 seglen = hdr.bh_hdrlen + hdr.bh_caplen; 652 if (seglen > bpfSize) { 653 syslog(LOG_ERR, "Truncated bpf packet: seglen=%d, bpfSize=%d", 654 seglen, bpfSize); 655 clearPacketHeader(pkt); /* resets bpfSize and bpfOffset */ 656 return 0; 657 } 658 seglen = BPF_WORDALIGN(seglen); 659 *size = copylen = ((hdr.bh_caplen < sizeof(PPPoEPacket)) ? 660 hdr.bh_caplen : sizeof(PPPoEPacket)); 661 memcpy(pkt, bpfBuffer + bpfOffset + hdr.bh_hdrlen, copylen); 662 if (seglen >= bpfSize) { 663 bpfSize = bpfOffset = 0; 664 } else { 665 bpfSize -= seglen; 666 bpfOffset += seglen; 667 } 668 #else 669 #ifdef USE_DLPI 670 struct strbuf data; 671 int flags = 0; 672 int retval; 673 674 data.buf = (char *) pkt; 675 data.maxlen = MAXDLBUF; 676 data.len = 0; 677 678 if ((retval = getmsg(sock, NULL, &data, &flags)) < 0) { 679 sysErr("read (receivePacket)"); 680 return -1; 681 } 682 683 *size = data.len; 684 685 #else 686 if ((*size = recv(sock, pkt, sizeof(PPPoEPacket), 0)) < 0) { 687 sysErr("recv (receivePacket)"); 688 return -1; 689 } 690 #endif 691 #endif 692 return 0; 693 } 694 695 #ifdef USE_DLPI 696 /********************************************************************** 697 *%FUNCTION: openInterface 698 *%ARGUMENTS: 699 * ifname -- name of interface 700 * type -- Ethernet frame type 701 * hwaddr -- if non-NULL, set to the hardware address 702 *%RETURNS: 703 * A raw socket for talking to the Ethernet card. Exits on error. 704 *%DESCRIPTION: 705 * Opens a raw Ethernet socket 706 ***********************************************************************/ 707 int 708 openInterface(char const *ifname, UINT16_t type, unsigned char *hwaddr) 709 { 710 int fd; 711 long buf[MAXDLBUF]; 712 713 union DL_primitives *dlp; 714 715 char base_dev[PATH_MAX]; 716 int ppa; 717 718 if(strlen(ifname) > PATH_MAX) { 719 rp_fatal("socket: string to long"); 720 } 721 722 ppa = atoi(&ifname[strlen(ifname)-1]); 723 strncpy(base_dev, ifname, PATH_MAX); 724 base_dev[strlen(base_dev)-1] = '\0'; 725 726 /* rearranged order of DLPI code - delphys 20010803 */ 727 dlp = (union DL_primitives*) buf; 728 729 if (( fd = open(base_dev, O_RDWR)) < 0) { 730 /* Give a more helpful message for the common error case */ 731 if (errno == EPERM) { 732 rp_fatal("Cannot create raw socket -- pppoe must be run as root."); 733 } 734 fatalSys("socket"); 735 } 736 737 /* rearranged order of DLPI code - delphys 20010803 */ 738 dlattachreq(fd, ppa); 739 dlokack(fd, (char *)buf); 740 741 dlbindreq(fd, type, 0, DL_CLDLS, 0, 0); 742 dlbindack(fd, (char *)buf); 743 744 dlinforeq(fd); 745 dlinfoack(fd, (char *)buf); 746 747 dl_abssaplen = ABS(dlp->info_ack.dl_sap_length); 748 dl_saplen = dlp->info_ack.dl_sap_length; 749 if (ETHERADDRL != (dlp->info_ack.dl_addr_length - dl_abssaplen)) 750 fatalSys("invalid destination physical address length"); 751 dl_addrlen = dl_abssaplen + ETHERADDRL; 752 753 /* ethernet address retrieved as part of DL_INFO_ACK - delphys 20010803 */ 754 memcpy(hwaddr, (u_char*)((char*)(dlp) + (int)(dlp->info_ack.dl_addr_offset)), ETHERADDRL); 755 756 if ( strioctl(fd, DLIOCRAW, -1, 0, NULL) < 0 ) { 757 fatalSys("DLIOCRAW"); 758 } 759 760 if (ioctl(fd, I_FLUSH, FLUSHR) < 0) fatalSys("I_FLUSH"); 761 762 return fd; 763 } 764 765 /* cloned from dlcommon.c */ 766 767 void dlpromisconreq(int fd, u_long level) 768 { 769 dl_promiscon_req_t promiscon_req; 770 struct strbuf ctl; 771 int flags; 772 773 promiscon_req.dl_primitive = DL_PROMISCON_REQ; 774 promiscon_req.dl_level = level; 775 776 ctl.maxlen = 0; 777 ctl.len = sizeof (promiscon_req); 778 ctl.buf = (char *) &promiscon_req; 779 780 flags = 0; 781 782 if (putmsg(fd, &ctl, (struct strbuf*) NULL, flags) < 0) 783 fatalSys("dlpromiscon: putmsg"); 784 785 } 786 787 void dlinforeq(int fd) 788 { 789 dl_info_req_t info_req; 790 struct strbuf ctl; 791 int flags; 792 793 info_req.dl_primitive = DL_INFO_REQ; 794 795 ctl.maxlen = 0; 796 ctl.len = sizeof (info_req); 797 ctl.buf = (char *) &info_req; 798 799 flags = RS_HIPRI; 800 801 if (putmsg(fd, &ctl, (struct strbuf*) NULL, flags) < 0) 802 fatalSys("dlinforeq: putmsg"); 803 } 804 805 void dlunitdatareq(int fd, u_char *addrp, int addrlen, u_long minpri, u_long maxpri, u_char *datap, int datalen) 806 { 807 long buf[MAXDLBUF]; 808 union DL_primitives *dlp; 809 struct strbuf data, ctl; 810 811 dlp = (union DL_primitives*) buf; 812 813 dlp->unitdata_req.dl_primitive = DL_UNITDATA_REQ; 814 dlp->unitdata_req.dl_dest_addr_length = addrlen; 815 dlp->unitdata_req.dl_dest_addr_offset = sizeof (dl_unitdata_req_t); 816 dlp->unitdata_req.dl_priority.dl_min = minpri; 817 dlp->unitdata_req.dl_priority.dl_max = maxpri; 818 819 (void) memcpy(OFFADDR(dlp, sizeof (dl_unitdata_req_t)), addrp, addrlen); 820 821 ctl.maxlen = 0; 822 ctl.len = sizeof (dl_unitdata_req_t) + addrlen; 823 ctl.buf = (char *) buf; 824 825 data.maxlen = 0; 826 data.len = datalen; 827 data.buf = (char *) datap; 828 829 if (putmsg(fd, &ctl, &data, 0) < 0) 830 fatalSys("dlunitdatareq: putmsg"); 831 } 832 833 void dlinfoack(int fd, char *bufp) 834 { 835 union DL_primitives *dlp; 836 struct strbuf ctl; 837 int flags; 838 839 ctl.maxlen = MAXDLBUF; 840 ctl.len = 0; 841 ctl.buf = bufp; 842 843 strgetmsg(fd, &ctl, (struct strbuf*)NULL, &flags, "dlinfoack"); 844 845 dlp = (union DL_primitives *) ctl.buf; 846 847 expecting(DL_INFO_ACK, dlp); 848 849 if (ctl.len < sizeof (dl_info_ack_t)) { 850 char buffer[256]; 851 sprintf(buffer, "dlinfoack: response ctl.len too short: %d", ctl.len); 852 rp_fatal(buffer); 853 } 854 855 if (flags != RS_HIPRI) 856 rp_fatal("dlinfoack: DL_INFO_ACK was not M_PCPROTO"); 857 858 if (ctl.len < sizeof (dl_info_ack_t)) { 859 char buffer[256]; 860 sprintf(buffer, "dlinfoack: short response ctl.len: %d", ctl.len); 861 rp_fatal(buffer); 862 } 863 } 864 865 void dlbindreq(int fd, u_long sap, u_long max_conind, u_long service_mode, u_long conn_mgmt, u_long xidtest) 866 { 867 dl_bind_req_t bind_req; 868 struct strbuf ctl; 869 int flags; 870 871 bind_req.dl_primitive = DL_BIND_REQ; 872 bind_req.dl_sap = sap; 873 bind_req.dl_max_conind = max_conind; 874 bind_req.dl_service_mode = service_mode; 875 bind_req.dl_conn_mgmt = conn_mgmt; 876 bind_req.dl_xidtest_flg = xidtest; 877 878 ctl.maxlen = 0; 879 ctl.len = sizeof (bind_req); 880 ctl.buf = (char *) &bind_req; 881 882 flags = 0; 883 884 if (putmsg(fd, &ctl, (struct strbuf*) NULL, flags) < 0) 885 fatalSys("dlbindreq: putmsg"); 886 } 887 888 void dlattachreq(int fd, u_long ppa) 889 { 890 dl_attach_req_t attach_req; 891 struct strbuf ctl; 892 int flags; 893 894 attach_req.dl_primitive = DL_ATTACH_REQ; 895 attach_req.dl_ppa = ppa; 896 897 ctl.maxlen = 0; 898 ctl.len = sizeof (attach_req); 899 ctl.buf = (char *) &attach_req; 900 901 flags = 0; 902 903 if (putmsg(fd, &ctl, (struct strbuf*) NULL, flags) < 0) 904 fatalSys("dlattachreq: putmsg"); 905 } 906 907 void dlokack(int fd, char *bufp) 908 { 909 union DL_primitives *dlp; 910 struct strbuf ctl; 911 int flags; 912 913 ctl.maxlen = MAXDLBUF; 914 ctl.len = 0; 915 ctl.buf = bufp; 916 917 strgetmsg(fd, &ctl, (struct strbuf*)NULL, &flags, "dlokack"); 918 919 dlp = (union DL_primitives *) ctl.buf; 920 921 expecting(DL_OK_ACK, dlp); 922 923 if (ctl.len < sizeof (dl_ok_ack_t)) { 924 char buffer[256]; 925 sprintf(buffer, "dlokack: response ctl.len too short: %d", ctl.len); 926 rp_fatal(buffer); 927 } 928 929 if (flags != RS_HIPRI) 930 rp_fatal("dlokack: DL_OK_ACK was not M_PCPROTO"); 931 932 if (ctl.len < sizeof (dl_ok_ack_t)) { 933 char buffer[256]; 934 sprintf(buffer, "dlokack: short response ctl.len: %d", ctl.len); 935 rp_fatal(buffer); 936 } 937 } 938 939 void dlbindack(int fd, char *bufp) 940 { 941 union DL_primitives *dlp; 942 struct strbuf ctl; 943 int flags; 944 945 ctl.maxlen = MAXDLBUF; 946 ctl.len = 0; 947 ctl.buf = bufp; 948 949 strgetmsg(fd, &ctl, (struct strbuf*)NULL, &flags, "dlbindack"); 950 951 dlp = (union DL_primitives *) ctl.buf; 952 953 expecting(DL_BIND_ACK, dlp); 954 955 if (flags != RS_HIPRI) 956 rp_fatal("dlbindack: DL_OK_ACK was not M_PCPROTO"); 957 958 if (ctl.len < sizeof (dl_bind_ack_t)) { 959 char buffer[256]; 960 sprintf(buffer, "dlbindack: short response ctl.len: %d", ctl.len); 961 rp_fatal(buffer); 962 } 963 } 964 965 int strioctl(int fd, int cmd, int timout, int len, char *dp) 966 { 967 struct strioctl sioc; 968 int rc; 969 970 sioc.ic_cmd = cmd; 971 sioc.ic_timout = timout; 972 sioc.ic_len = len; 973 sioc.ic_dp = dp; 974 rc = ioctl(fd, I_STR, &sioc); 975 976 if (rc < 0) 977 return (rc); 978 else 979 return (sioc.ic_len); 980 } 981 982 void strgetmsg(int fd, struct strbuf *ctlp, struct strbuf *datap, int *flagsp, char *caller) 983 { 984 int rc; 985 static char errmsg[80]; 986 987 /* 988 * Start timer. 989 */ 990 (void) signal(SIGALRM, sigalrm); 991 if (alarm(MAXWAIT) < 0) { 992 (void) sprintf(errmsg, "%s: alarm", caller); 993 fatalSys(errmsg); 994 } 995 996 /* 997 * Set flags argument and issue getmsg(). 998 */ 999 *flagsp = 0; 1000 if ((rc = getmsg(fd, ctlp, datap, flagsp)) < 0) { 1001 (void) sprintf(errmsg, "%s: getmsg", caller); 1002 fatalSys(errmsg); 1003 } 1004 1005 /* 1006 * Stop timer. 1007 */ 1008 if (alarm(0) < 0) { 1009 (void) sprintf(errmsg, "%s: alarm", caller); 1010 fatalSys(errmsg); 1011 } 1012 1013 /* 1014 * Check for MOREDATA and/or MORECTL. 1015 */ 1016 if ((rc & (MORECTL | MOREDATA)) == (MORECTL | MOREDATA)) { 1017 char buffer[256]; 1018 sprintf(buffer, "%s: MORECTL|MOREDATA", caller); 1019 rp_fatal(buffer); 1020 } 1021 1022 if (rc & MORECTL) { 1023 char buffer[256]; 1024 sprintf(buffer, "%s: MORECTL", caller); 1025 rp_fatal(buffer); 1026 } 1027 1028 if (rc & MOREDATA) { 1029 char buffer[256]; 1030 sprintf(buffer, "%s: MOREDATA", caller); 1031 rp_fatal(buffer); 1032 } 1033 1034 /* 1035 * Check for at least sizeof (long) control data portion. 1036 */ 1037 if (ctlp->len < sizeof (long)) { 1038 char buffer[256]; 1039 sprintf(buffer, "getmsg: control portion length < sizeof (long): %d", ctlp->len); 1040 rp_fatal(buffer); 1041 } 1042 } 1043 1044 void sigalrm(int sig) 1045 { 1046 (void) rp_fatal("sigalrm: TIMEOUT"); 1047 } 1048 1049 void expecting(int prim, union DL_primitives *dlp) 1050 { 1051 if (dlp->dl_primitive != (u_long)prim) { 1052 char buffer[256]; 1053 sprintf(buffer, "expected %s got %s", dlprim(prim), dlprim(dlp->dl_primitive)); 1054 rp_fatal(buffer); 1055 exit(1); 1056 } 1057 } 1058 1059 char *dlprim(u_long prim) 1060 { 1061 static char primbuf[80]; 1062 1063 switch ((int)prim) { 1064 CASERET(DL_INFO_REQ); 1065 CASERET(DL_INFO_ACK); 1066 CASERET(DL_ATTACH_REQ); 1067 CASERET(DL_DETACH_REQ); 1068 CASERET(DL_BIND_REQ); 1069 CASERET(DL_BIND_ACK); 1070 CASERET(DL_UNBIND_REQ); 1071 CASERET(DL_OK_ACK); 1072 CASERET(DL_ERROR_ACK); 1073 CASERET(DL_SUBS_BIND_REQ); 1074 CASERET(DL_SUBS_BIND_ACK); 1075 CASERET(DL_UNITDATA_REQ); 1076 CASERET(DL_UNITDATA_IND); 1077 CASERET(DL_UDERROR_IND); 1078 CASERET(DL_UDQOS_REQ); 1079 CASERET(DL_CONNECT_REQ); 1080 CASERET(DL_CONNECT_IND); 1081 CASERET(DL_CONNECT_RES); 1082 CASERET(DL_CONNECT_CON); 1083 CASERET(DL_TOKEN_REQ); 1084 CASERET(DL_TOKEN_ACK); 1085 CASERET(DL_DISCONNECT_REQ); 1086 CASERET(DL_DISCONNECT_IND); 1087 CASERET(DL_RESET_REQ); 1088 CASERET(DL_RESET_IND); 1089 CASERET(DL_RESET_RES); 1090 CASERET(DL_RESET_CON); 1091 default: 1092 (void) sprintf(primbuf, "unknown primitive 0x%lx", prim); 1093 return (primbuf); 1094 } 1095 } 1096 1097 #endif /* USE_DLPI */ 1098
