isisd/isis_bpf.c

   1 /*
   2  * IS-IS Rout(e)ing protocol - isis_bpf.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_BPF
  25 #include <net/if.h>
  26 #include <netinet/if_ether.h>
  27 #include <sys/time.h>
  28 #include <sys/ioctl.h>
  29 #include <net/bpf.h>
  30
  31 #include "log.h"
  32 #include "network.h"
  33 #include "stream.h"
  34 #include "if.h"
  35
  36 #include "isisd/dict.h"
  37 #include "isisd/isis_constants.h"
  38 #include "isisd/isis_common.h"
  39 #include "isisd/isis_circuit.h"
  40 #include "isisd/isis_flags.h"
  41 #include "isisd/isisd.h"
  42 #include "isisd/isis_constants.h"
  43 #include "isisd/isis_circuit.h"
  44 #include "isisd/isis_network.h"
  45
  46 #include "privs.h"
  47
  48 extern struct zebra_privs_t isisd_privs;
  49
  50 struct bpf_insn llcfilter[] = {
  51   BPF_STMT (BPF_LD + BPF_B + BPF_ABS, ETHER_HDR_LEN),   /* check first byte */
  52   BPF_JUMP (BPF_JMP + BPF_JEQ + BPF_K, ISO_SAP, 0, 5),
  53   BPF_STMT (BPF_LD + BPF_B + BPF_ABS, ETHER_HDR_LEN + 1),
  54   BPF_JUMP (BPF_JMP + BPF_JEQ + BPF_K, ISO_SAP, 0, 3),  /* check second byte */
  55   BPF_STMT (BPF_LD + BPF_B + BPF_ABS, ETHER_HDR_LEN + 2),
  56   BPF_JUMP (BPF_JMP + BPF_JEQ + BPF_K, 0x03, 0, 1),     /* check third byte */
  57   BPF_STMT (BPF_RET + BPF_K, (u_int) - 1),
  58   BPF_STMT (BPF_RET + BPF_K, 0)
  59 };
  60 u_int readblen = 0;
  61 u_char *readbuff = NULL;
  62
  63 /*
  64  * Table 9 - Architectural constants for use with ISO 8802 subnetworks
  65  * ISO 10589 - 8.4.8
  66  */
  67
  68 u_char ALL_L1_ISS[6] = { 0x01, 0x80, 0xC2, 0x00, 0x00, 0x14 };
  69 u_char ALL_L2_ISS[6] = { 0x01, 0x80, 0xC2, 0x00, 0x00, 0x15 };
  70 u_char ALL_ISS[6] = { 0x09, 0x00, 0x2B, 0x00, 0x00, 0x05 };
  71 u_char ALL_ESS[6] = { 0x09, 0x00, 0x2B, 0x00, 0x00, 0x04 };
  72
  73 static char sock_buff[8192];
  74
  75 static int
  76 open_bpf_dev (struct isis_circuit *circuit)
  77 {
  78   int i = 0, fd;
  79   char bpfdev[128];
  80   struct ifreq ifr;
  81   u_int blen, immediate;
  82 #ifdef BIOCSSEESENT
  83   u_int seesent;
  84 #endif
  85   struct timeval timeout;
  86   struct bpf_program bpf_prog;
  87
  88   do
  89     {
  90       (void) snprintf (bpfdev, sizeof (bpfdev), "/dev/bpf%d", i++);
  91       fd = open (bpfdev, O_RDWR);
  92     }
  93   while (fd < 0 && errno == EBUSY);
  94
  95   if (fd < 0)
  96     {
  97       zlog_warn ("open_bpf_dev(): failed to create bpf socket: %s",
  98                  safe_strerror (errno));
  99       return ISIS_WARNING;
 100     }
 101
 102   zlog_debug ("Opened BPF device %s", bpfdev);
 103
 104   memcpy (ifr.ifr_name, circuit->interface->name, sizeof (ifr.ifr_name));
 105   if (ioctl (fd, BIOCSETIF, (caddr_t) & ifr) < 0)
 106     {
 107       zlog_warn ("open_bpf_dev(): failed to bind to interface: %s",
 108                  safe_strerror (errno));
 109       return ISIS_WARNING;
 110     }
 111
 112   if (ioctl (fd, BIOCGBLEN, (caddr_t) & blen) < 0)
 113     {
 114       zlog_warn ("failed to get BPF buffer len");
 115       blen = circuit->interface->mtu;
 116     }
 117
 118   readblen = blen;
 119
 120   if (readbuff == NULL)
 121     readbuff = malloc (blen);
 122
 123   zlog_debug ("BPF buffer len = %u", blen);
 124
 125   /*  BPF(4): reads return immediately upon packet reception.
 126    *  Otherwise, a read will block until either the kernel
 127    *  buffer becomes full or a timeout occurs.
 128    */
 129   immediate = 1;
 130   if (ioctl (fd, BIOCIMMEDIATE, (caddr_t) & immediate) < 0)
 131     {
 132       zlog_warn ("failed to set BPF dev to immediate mode");
 133     }
 134
 135 #ifdef BIOCSSEESENT
 136   /*
 137    * We want to see only incoming packets
 138    */
 139   seesent = 0;
 140   if (ioctl (fd, BIOCSSEESENT, (caddr_t) & seesent) < 0)
 141     {
 142       zlog_warn ("failed to set BPF dev to incoming only mode");
 143     }
 144 #endif
 145
 146   /*
 147    * ...but all of them
 148    */
 149   if (ioctl (fd, BIOCPROMISC) < 0)
 150     {
 151       zlog_warn ("failed to set BPF dev to promiscuous mode");
 152     }
 153
 154   /*
 155    * If the buffer length is smaller than our mtu, lets try to increase it
 156    */
 157   if (blen < circuit->interface->mtu)
 158     {
 159       if (ioctl (fd, BIOCSBLEN, &circuit->interface->mtu) < 0)
 160         {
 161           zlog_warn ("failed to set BPF buffer len (%u to %u)", blen,
 162                      circuit->interface->mtu);
 163         }
 164     }
 165
 166   /*
 167    * Set a timeout parameter - hope this helps select()
 168    */
 169   timeout.tv_sec = 600;
 170   timeout.tv_usec = 0;
 171   if (ioctl (fd, BIOCSRTIMEOUT, (caddr_t) & timeout) < 0)
 172     {
 173       zlog_warn ("failed to set BPF device timeout");
 174     }
 175
 176   /*
 177    * And set the filter
 178    */
 179   memset (&bpf_prog, 0, sizeof (struct bpf_program));
 180   bpf_prog.bf_len = 8;
 181   bpf_prog.bf_insns = &(llcfilter[0]);
 182   if (ioctl (fd, BIOCSETF, (caddr_t) & bpf_prog) < 0)
 183     {
 184       zlog_warn ("open_bpf_dev(): failed to install filter: %s",
 185                  safe_strerror (errno));
 186       return ISIS_WARNING;
 187     }
 188
 189   assert (fd > 0);
 190
 191   circuit->fd = fd;
 192
 193   return ISIS_OK;
 194 }
 195
 196 /*
 197  * Create the socket and set the tx/rx funcs
 198  */
 199 int
 200 isis_sock_init (struct isis_circuit *circuit)
 201 {
 202   int retval = ISIS_OK;
 203
 204   if (isisd_privs.change (ZPRIVS_RAISE))
 205     zlog_err ("%s: could not raise privs, %s", __func__, safe_strerror (errno));
 206
 207   retval = open_bpf_dev (circuit);
 208
 209   if (retval != ISIS_OK)
 210     {
 211       zlog_warn ("%s: could not initialize the socket", __func__);
 212       goto end;
 213     }
 214
 215   if (circuit->circ_type == CIRCUIT_T_BROADCAST)
 216     {
 217       circuit->tx = isis_send_pdu_bcast;
 218       circuit->rx = isis_recv_pdu_bcast;
 219     }
 220   else if (circuit->circ_type == CIRCUIT_T_P2P)
 221     {
 222       circuit->tx = isis_send_pdu_p2p;
 223       circuit->rx = isis_recv_pdu_p2p;
 224     }
 225   else
 226     {
 227       zlog_warn ("isis_sock_init(): unknown circuit type");
 228       retval = ISIS_WARNING;
 229       goto end;
 230     }
 231
 232 end:
 233   if (isisd_privs.change (ZPRIVS_LOWER))
 234     zlog_err ("%s: could not lower privs, %s", __func__, safe_strerror (errno));
 235
 236   return retval;
 237 }
 238
 239 int
 240 isis_recv_pdu_bcast (struct isis_circuit *circuit, u_char * ssnpa)
 241 {
 242   int bytesread = 0, bytestoread, offset, one = 1;
 243   struct bpf_hdr *bpf_hdr;
 244
 245   assert (circuit->fd > 0);
 246
 247   if (ioctl (circuit->fd, FIONREAD, (caddr_t) & bytestoread) < 0)
 248     {
 249       zlog_warn ("ioctl() FIONREAD failed: %s", safe_strerror (errno));
 250     }
 251
 252   if (bytestoread)
 253     {
 254       bytesread = read (circuit->fd, readbuff, readblen);
 255     }
 256   if (bytesread < 0)
 257     {
 258       zlog_warn ("isis_recv_pdu_bcast(): read() failed: %s",
 259                  safe_strerror (errno));
 260       return ISIS_WARNING;
 261     }
 262
 263   if (bytesread == 0)
 264     return ISIS_WARNING;
 265
 266   bpf_hdr = (struct bpf_hdr *) readbuff;
 267
 268   assert (bpf_hdr->bh_caplen == bpf_hdr->bh_datalen);
 269
 270   offset = bpf_hdr->bh_hdrlen + LLC_LEN + ETHER_HDR_LEN;
 271
 272   /* then we lose the BPF, LLC and ethernet headers */
 273   stream_write (circuit->rcv_stream, readbuff + offset,
 274                 bpf_hdr->bh_caplen - LLC_LEN - ETHER_HDR_LEN);
 275   stream_set_getp (circuit->rcv_stream, 0);
 276
 277   memcpy (ssnpa, readbuff + bpf_hdr->bh_hdrlen + ETHER_ADDR_LEN,
 278           ETHER_ADDR_LEN);
 279
 280   if (ioctl (circuit->fd, BIOCFLUSH, &one) < 0)
 281     zlog_warn ("Flushing failed: %s", safe_strerror (errno));
 282
 283   return ISIS_OK;
 284 }
 285
 286 int
 287 isis_recv_pdu_p2p (struct isis_circuit *circuit, u_char * ssnpa)
 288 {
 289   int bytesread;
 290
 291   bytesread = stream_read (circuit->rcv_stream, circuit->fd,
 292                            circuit->interface->mtu);
 293
 294   if (bytesread < 0)
 295     {
 296       zlog_warn ("isis_recv_pdu_p2p(): read () failed: %s", safe_strerror (errno));
 297       return ISIS_WARNING;
 298     }
 299
 300   return ISIS_OK;
 301 }
 302
 303 int
 304 isis_send_pdu_bcast (struct isis_circuit *circuit, int level)
 305 {
 306   struct ether_header *eth;
 307   ssize_t written;
 308   size_t buflen;
 309
 310   buflen = stream_get_endp (circuit->snd_stream) + LLC_LEN + ETHER_HDR_LEN;
 311   if (buflen > sizeof (sock_buff))
 312     {
 313       zlog_warn ("isis_send_pdu_bcast: sock_buff size %zu is less than "
 314                  "output pdu size %zu on circuit %s",
 315                  sizeof (sock_buff), buflen, circuit->interface->name);
 316       return ISIS_WARNING;
 317     }
 318
 319   stream_set_getp (circuit->snd_stream, 0);
 320
 321   /*
 322    * First the eth header
 323    */
 324   eth = (struct ether_header *) sock_buff;
 325   if (level == 1)
 326     memcpy (eth->ether_dhost, ALL_L1_ISS, ETHER_ADDR_LEN);
 327   else
 328     memcpy (eth->ether_dhost, ALL_L2_ISS, ETHER_ADDR_LEN);
 329   memcpy (eth->ether_shost, circuit->u.bc.snpa, ETHER_ADDR_LEN);
 330   eth->ether_type = htons (stream_get_endp (circuit->snd_stream) + LLC_LEN);
 331
 332   /*
 333    * Then the LLC
 334    */
 335   sock_buff[ETHER_HDR_LEN] = ISO_SAP;
 336   sock_buff[ETHER_HDR_LEN + 1] = ISO_SAP;
 337   sock_buff[ETHER_HDR_LEN + 2] = 0x03;
 338
 339   /* then we copy the data */
 340   memcpy (sock_buff + (LLC_LEN + ETHER_HDR_LEN), circuit->snd_stream->data,
 341           stream_get_endp (circuit->snd_stream));
 342
 343   /* now we can send this */
 344   written = write (circuit->fd, sock_buff, buflen);
 345   if (written < 0)
 346     {
 347       zlog_warn("IS-IS bpf: could not transmit packet on %s: %s",
 348                 circuit->interface->name, safe_strerror(errno));
 349       if (ERRNO_IO_RETRY(errno))
 350         return ISIS_WARNING;
 351       return ISIS_ERROR;
 352     }
 353
 354   return ISIS_OK;
 355 }
 356
 357 int
 358 isis_send_pdu_p2p (struct isis_circuit *circuit, int level)
 359 {
 360   return ISIS_OK;
 361 }
 362
 363 #endif /* ISIS_METHOD == ISIS_METHOD_BPF */