Service-name was not being set correctly in PPPoE plugin.
[ppp.git] / pppd / plugins / rp-pppoe / if.c
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 */