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