tests/bpflib.c

   1 /*
   2  * Copyright (c) 2000-2018 Apple Inc. All rights reserved.
   3  *
   4  * @APPLE_LICENSE_HEADER_START@
   5  *
   6  * This file contains Original Code and/or Modifications of Original Code
   7  * as defined in and that are subject to the Apple Public Source License
   8  * Version 2.0 (the 'License'). You may not use this file except in
   9  * compliance with the License. Please obtain a copy of the License at
  10  * http://www.opensource.apple.com/apsl/ and read it before using this
  11  * file.
  12  *
  13  * The Original Code and all software distributed under the License are
  14  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  15  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  16  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
  18  * Please see the License for the specific language governing rights and
  19  * limitations under the License.
  20  *
  21  * @APPLE_LICENSE_HEADER_END@
  22  */
  23
  24 #include <stdlib.h>
  25 #include <unistd.h>
  26 #include <stdio.h>
  27 #include <sys/types.h>
  28 #include <sys/time.h>
  29 #include <sys/ioctl.h>
  30 #include <sys/stat.h>
  31 #include <fcntl.h>
  32 #include <net/bpf.h>
  33 #include <string.h>
  34 #include <sys/socket.h>
  35 #include <errno.h>
  36 #include <net/if.h>
  37 #include <stdbool.h>
  38 #define PRIVATE_EXTERN __private_extern__
  39
  40 #include "bpflib.h"
  41
  42 #ifdef TESTING
  43 #include "util.h"
  44 #endif /* TESTING */
  45
  46 PRIVATE_EXTERN int
  47 bpf_set_timeout(int fd, struct timeval * tv_p)
  48 {
  49         return ioctl(fd, BIOCSRTIMEOUT, tv_p);
  50 }
  51
  52 PRIVATE_EXTERN int
  53 bpf_get_blen(int fd, int * blen)
  54 {
  55         return ioctl(fd, BIOCGBLEN, blen);
  56 }
  57
  58 PRIVATE_EXTERN int
  59 bpf_set_header_complete(int fd, u_int header_complete)
  60 {
  61         return ioctl(fd, BIOCSHDRCMPLT, &header_complete);
  62 }
  63
  64 PRIVATE_EXTERN int
  65 bpf_set_see_sent(int fd, u_int see_sent)
  66 {
  67         return ioctl(fd, BIOCSSEESENT, &see_sent);
  68 }
  69
  70 PRIVATE_EXTERN int
  71 bpf_dispose(int bpf_fd)
  72 {
  73         if (bpf_fd >= 0) {
  74                 return close(bpf_fd);
  75         }
  76         return 0;
  77 }
  78
  79 PRIVATE_EXTERN int
  80 bpf_new(void)
  81 {
  82         char bpfdev[256];
  83         int i;
  84         int fd = -1;
  85
  86         for (i = 0; true; i++) {
  87                 snprintf(bpfdev, sizeof(bpfdev), "/dev/bpf%d", i);
  88                 fd = open(bpfdev, O_RDWR, 0);
  89                 if (fd >= 0) {
  90 #ifdef SO_TC_CTL
  91                         int tc = SO_TC_CTL;
  92                         (void) ioctl(fd, BIOCSETTC, &tc);
  93 #endif /* SO_TC_CTL */
  94                         break;
  95                 }
  96                 if (errno != EBUSY) {
  97                         break;
  98                 }
  99         }
 100         return fd;
 101 }
 102
 103 PRIVATE_EXTERN int
 104 bpf_setif(int fd, const char * en_name)
 105 {
 106         struct ifreq ifr;
 107
 108         strlcpy(ifr.ifr_name, en_name, sizeof(ifr.ifr_name));
 109         return ioctl(fd, BIOCSETIF, &ifr);
 110 }
 111
 112 PRIVATE_EXTERN int
 113 bpf_set_immediate(int fd, u_int value)
 114 {
 115         return ioctl(fd, BIOCIMMEDIATE, &value);
 116 }
 117
 118 PRIVATE_EXTERN int
 119 bpf_filter_receive_none(int fd)
 120 {
 121         struct bpf_insn insns[] = {
 122                 BPF_STMT(BPF_RET + BPF_K, 0),
 123         };
 124         struct bpf_program prog;
 125
 126         prog.bf_len = sizeof(insns) / sizeof(struct bpf_insn);
 127         prog.bf_insns = insns;
 128         return ioctl(fd, BIOCSETF, &prog);
 129 }
 130
 131 PRIVATE_EXTERN int
 132 bpf_arp_filter(int fd, int type_offset, int type, u_int pkt_size)
 133 {
 134         struct bpf_insn insns[] = {
 135                 BPF_STMT(BPF_LD + BPF_H + BPF_ABS, type_offset),
 136                 BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, type, 0, 1),
 137                 BPF_STMT(BPF_RET + BPF_K, pkt_size),
 138                 BPF_STMT(BPF_RET + BPF_K, 0),
 139         };
 140         struct bpf_program prog;
 141
 142         prog.bf_len = sizeof(insns) / sizeof(struct bpf_insn);
 143         prog.bf_insns = insns;
 144         return ioctl(fd, BIOCSETF, &prog);
 145 }
 146
 147 #ifdef TESTING
 148 #include <net/if_arp.h>
 149 #include <net/ethernet.h>
 150 #include <netinet/if_ether.h>
 151
 152
 153 void
 154 bpf_read_continuously(int fd, u_int blen)
 155 {
 156         int n;
 157         char * rxbuf = malloc(blen);
 158
 159         printf("rx buf len is %d\n", blen);
 160         while (1) {
 161                 n = read(fd, rxbuf, blen);
 162                 if (n < 0) {
 163                         perror("bpf_read_continuously");
 164                         return;
 165                 }
 166                 if (n == 0) {
 167                         continue;
 168                 }
 169                 print_data(rxbuf, n);
 170         }
 171 }
 172
 173 int
 174 main(int argc, char * argv[])
 175 {
 176         int fd = bpf_new();
 177         char * en_name = "en0";
 178         u_int bpf_blen = 0;
 179
 180         if (fd < 0) {
 181                 perror("no bpf devices");
 182                 exit(1);
 183         }
 184
 185         if (argc > 1) {
 186                 en_name = argv[1];
 187         }
 188         (void)bpf_set_immediate(fd, 1);
 189         if (bpf_arp_filter(fd, 12, ETHERTYPE_ARP,
 190             sizeof(struct ether_arp) + sizeof(struct ether_header))
 191             < 0) {
 192                 perror("bpf_arp_filter");
 193         }
 194         if (bpf_setif(fd, en_name) < 0) {
 195                 perror("bpf_attach");
 196                 exit(1);
 197         }
 198
 199         if (bpf_get_blen(fd, &bpf_blen) < 0) {
 200                 perror("bpf_get_blen");
 201                 exit(1);
 202         }
 203         bpf_read_continuously(fd, bpf_blen);
 204         exit(0);
 205         return 0;
 206 }
 207 #endif /* TESTING */