home *** CD-ROM | disk | FTP | other *** search
/ Hackers Toolkit v2.0 / Hackers_Toolkit_v2.0.iso / HTML / archive / Unix / libpcap-0_4_tar.tar / libpcap-0_4_tar / libpcap-0.4 / pcap-bpf.c < prev    next >
C/C++ Source or Header  |  1998-07-12  |  6KB  |  264 lines
  1. /*
  2.  * Copyright (c) 1993, 1994, 1995, 1996, 1998
  3.  *    The Regents of the University of California.  All rights reserved.
  4.  *
  5.  * Redistribution and use in source and binary forms, with or without
  6.  * modification, are permitted provided that: (1) source code distributions
  7.  * retain the above copyright notice and this paragraph in its entirety, (2)
  8.  * distributions including binary code include the above copyright notice and
  9.  * this paragraph in its entirety in the documentation or other materials
  10.  * provided with the distribution, and (3) all advertising materials mentioning
  11.  * features or use of this software display the following acknowledgement:
  12.  * ``This product includes software developed by the University of California,
  13.  * Lawrence Berkeley Laboratory and its contributors.'' Neither the name of
  14.  * the University nor the names of its contributors may be used to endorse
  15.  * or promote products derived from this software without specific prior
  16.  * written permission.
  17.  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
  18.  * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
  19.  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  20.  */
  21. #ifndef lint
  22. static const char rcsid[] =
  23.     "@(#) $Header: pcap-bpf.c,v 1.31 98/07/12 13:14:55 leres Exp $ (LBL)";
  24. #endif
  25.  
  26. #include <sys/param.h>            /* optionally get BSD define */
  27. #include <sys/time.h>
  28. #include <sys/timeb.h>
  29. #include <sys/socket.h>
  30. #include <sys/file.h>
  31. #include <sys/ioctl.h>
  32.  
  33. #include <net/if.h>
  34.  
  35. #include <ctype.h>
  36. #include <errno.h>
  37. #include <netdb.h>
  38. #include <stdio.h>
  39. #include <stdlib.h>
  40. #include <string.h>
  41. #include <unistd.h>
  42.  
  43. #include "pcap-int.h"
  44.  
  45. #include "gnuc.h"
  46. #ifdef HAVE_OS_PROTO_H
  47. #include "os-proto.h"
  48. #endif
  49.  
  50. int
  51. pcap_stats(pcap_t *p, struct pcap_stat *ps)
  52. {
  53.     struct bpf_stat s;
  54.  
  55.     if (ioctl(p->fd, BIOCGSTATS, (caddr_t)&s) < 0) {
  56.         sprintf(p->errbuf, "BIOCGSTATS: %s", pcap_strerror(errno));
  57.         return (-1);
  58.     }
  59.  
  60.     ps->ps_recv = s.bs_recv;
  61.     ps->ps_drop = s.bs_drop;
  62.     return (0);
  63. }
  64.  
  65. int
  66. pcap_read(pcap_t *p, int cnt, pcap_handler callback, u_char *user)
  67. {
  68.     int cc;
  69.     int n = 0;
  70.     register u_char *bp, *ep;
  71.  
  72.  again:
  73.     cc = p->cc;
  74.     if (p->cc == 0) {
  75.         cc = read(p->fd, (char *)p->buffer, p->bufsize);
  76.         if (cc < 0) {
  77.             /* Don't choke when we get ptraced */
  78.             switch (errno) {
  79.  
  80.             case EINTR:
  81.                 goto again;
  82.  
  83.             case EWOULDBLOCK:
  84.                 return (0);
  85. #if defined(sun) && !defined(BSD)
  86.             /*
  87.              * Due to a SunOS bug, after 2^31 bytes, the kernel
  88.              * file offset overflows and read fails with EINVAL.
  89.              * The lseek() to 0 will fix things.
  90.              */
  91.             case EINVAL:
  92.                 if (lseek(p->fd, 0L, SEEK_CUR) +
  93.                     p->bufsize < 0) {
  94.                     (void)lseek(p->fd, 0L, SEEK_SET);
  95.                     goto again;
  96.                 }
  97.                 /* fall through */
  98. #endif
  99.             }
  100.             sprintf(p->errbuf, "read: %s", pcap_strerror(errno));
  101.             return (-1);
  102.         }
  103.         bp = p->buffer;
  104.     } else
  105.         bp = p->bp;
  106.  
  107.     /*
  108.      * Loop through each packet.
  109.      */
  110. #define bhp ((struct bpf_hdr *)bp)
  111.     ep = bp + cc;
  112.     while (bp < ep) {
  113.         register int caplen, hdrlen;
  114.         caplen = bhp->bh_caplen;
  115.         hdrlen = bhp->bh_hdrlen;
  116.         /*
  117.          * XXX A bpf_hdr matches a pcap_pkthdr.
  118.          */
  119.         (*callback)(user, (struct pcap_pkthdr*)bp, bp + hdrlen);
  120.         bp += BPF_WORDALIGN(caplen + hdrlen);
  121.         if (++n >= cnt && cnt > 0) {
  122.             p->bp = bp;
  123.             p->cc = ep - bp;
  124.             return (n);
  125.         }
  126.     }
  127. #undef bhp
  128.     p->cc = 0;
  129.     return (n);
  130. }
  131.  
  132. static inline int
  133. bpf_open(pcap_t *p, char *errbuf)
  134. {
  135.     int fd;
  136.     int n = 0;
  137.     char device[sizeof "/dev/bpf000"];
  138.  
  139.     /*
  140.      * Go through all the minors and find one that isn't in use.
  141.      */
  142.     do {
  143.         (void)sprintf(device, "/dev/bpf%d", n++);
  144.         fd = open(device, O_RDONLY);
  145.     } while (fd < 0 && errno == EBUSY);
  146.  
  147.     /*
  148.      * XXX better message for all minors used
  149.      */
  150.     if (fd < 0)
  151.         sprintf(errbuf, "%s: %s", device, pcap_strerror(errno));
  152.  
  153.     return (fd);
  154. }
  155.  
  156. pcap_t *
  157. pcap_open_live(char *device, int snaplen, int promisc, int to_ms, char *ebuf)
  158. {
  159.     int fd;
  160.     struct ifreq ifr;
  161.     struct bpf_version bv;
  162.     u_int v;
  163.     pcap_t *p;
  164.  
  165.     p = (pcap_t *)malloc(sizeof(*p));
  166.     if (p == NULL) {
  167.         sprintf(ebuf, "malloc: %s", pcap_strerror(errno));
  168.         return (NULL);
  169.     }
  170.     bzero(p, sizeof(*p));
  171.     fd = bpf_open(p, ebuf);
  172.     if (fd < 0)
  173.         goto bad;
  174.  
  175.     p->fd = fd;
  176.     p->snapshot = snaplen;
  177.  
  178.     if (ioctl(fd, BIOCVERSION, (caddr_t)&bv) < 0) {
  179.         sprintf(ebuf, "BIOCVERSION: %s", pcap_strerror(errno));
  180.         goto bad;
  181.     }
  182.     if (bv.bv_major != BPF_MAJOR_VERSION ||
  183.         bv.bv_minor < BPF_MINOR_VERSION) {
  184.         sprintf(ebuf, "kernel bpf filter out of date");
  185.         goto bad;
  186.     }
  187.     v = 32768;    /* XXX this should be a user-accessible hook */
  188.     /* Ignore the return value - this is because the call fails on
  189.      * BPF systems that don't have kernel malloc.  And if the call
  190.      * fails, it's no big deal, we just continue to use the standard
  191.      * buffer size.
  192.      */
  193.     (void) ioctl(fd, BIOCSBLEN, (caddr_t)&v);
  194.  
  195.     (void)strncpy(ifr.ifr_name, device, sizeof(ifr.ifr_name));
  196.     if (ioctl(fd, BIOCSETIF, (caddr_t)&ifr) < 0) {
  197.         sprintf(ebuf, "%s: %s", device, pcap_strerror(errno));
  198.         goto bad;
  199.     }
  200.     /* Get the data link layer type. */
  201.     if (ioctl(fd, BIOCGDLT, (caddr_t)&v) < 0) {
  202.         sprintf(ebuf, "BIOCGDLT: %s", pcap_strerror(errno));
  203.         goto bad;
  204.     }
  205. #if _BSDI_VERSION - 0 >= 199510
  206.     /* The SLIP and PPP link layer header changed in BSD/OS 2.1 */
  207.     switch (v) {
  208.  
  209.     case DLT_SLIP:
  210.         v = DLT_SLIP_BSDOS;
  211.         break;
  212.  
  213.     case DLT_PPP:
  214.         v = DLT_PPP_BSDOS;
  215.         break;
  216.     }
  217. #endif
  218.     p->linktype = v;
  219.  
  220.     /* set timeout */
  221.     if (to_ms != 0) {
  222.         struct timeval to;
  223.         to.tv_sec = to_ms / 1000;
  224.         to.tv_usec = (to_ms * 1000) % 1000000;
  225.         if (ioctl(p->fd, BIOCSRTIMEOUT, (caddr_t)&to) < 0) {
  226.             sprintf(ebuf, "BIOCSRTIMEOUT: %s",
  227.                 pcap_strerror(errno));
  228.             goto bad;
  229.         }
  230.     }
  231.     if (promisc)
  232.         /* set promiscuous mode, okay if it fails */
  233.         (void)ioctl(p->fd, BIOCPROMISC, NULL);
  234.  
  235.     if (ioctl(fd, BIOCGBLEN, (caddr_t)&v) < 0) {
  236.         sprintf(ebuf, "BIOCGBLEN: %s", pcap_strerror(errno));
  237.         goto bad;
  238.     }
  239.     p->bufsize = v;
  240.     p->buffer = (u_char *)malloc(p->bufsize);
  241.     if (p->buffer == NULL) {
  242.         sprintf(ebuf, "malloc: %s", pcap_strerror(errno));
  243.         goto bad;
  244.     }
  245.  
  246.     return (p);
  247.  bad:
  248.     (void)close(fd);
  249.     free(p);
  250.     return (NULL);
  251. }
  252.  
  253. int
  254. pcap_setfilter(pcap_t *p, struct bpf_program *fp)
  255. {
  256.     if (p->sf.rfile != NULL)
  257.         p->fcode = *fp;
  258.     else if (ioctl(p->fd, BIOCSETF, (caddr_t)fp) < 0) {
  259.         sprintf(p->errbuf, "BIOCSETF: %s", pcap_strerror(errno));
  260.         return (-1);
  261.     }
  262.     return (0);
  263. }
  264.