Annotation of embedaddon/quagga/isisd/isis_bpf.c, revision 1.1.1.1
1.1 misho 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 "stream.h"
33: #include "if.h"
34:
35: #include "isisd/dict.h"
36: #include "isisd/include-netbsd/iso.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, seesent;
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: immediate = 1;
127: if (ioctl (fd, BIOCIMMEDIATE, (caddr_t) & immediate) < 0)
128: {
129: zlog_warn ("failed to set BPF dev to immediate mode");
130: }
131:
132: #ifdef BIOCSSEESENT
133: /*
134: * We want to see only incoming packets
135: */
136: seesent = 0;
137: if (ioctl (fd, BIOCSSEESENT, (caddr_t) & seesent) < 0)
138: {
139: zlog_warn ("failed to set BPF dev to incoming only mode");
140: }
141: #endif
142:
143: /*
144: * ...but all of them
145: */
146: if (ioctl (fd, BIOCPROMISC) < 0)
147: {
148: zlog_warn ("failed to set BPF dev to promiscuous mode");
149: }
150:
151: /*
152: * If the buffer length is smaller than our mtu, lets try to increase it
153: */
154: if (blen < circuit->interface->mtu)
155: {
156: if (ioctl (fd, BIOCSBLEN, &circuit->interface->mtu) < 0)
157: {
158: zlog_warn ("failed to set BPF buffer len (%u to %u)", blen,
159: circuit->interface->mtu);
160: }
161: }
162:
163: /*
164: * Set a timeout parameter - hope this helps select()
165: */
166: timeout.tv_sec = 600;
167: timeout.tv_usec = 0;
168: if (ioctl (fd, BIOCSRTIMEOUT, (caddr_t) & timeout) < 0)
169: {
170: zlog_warn ("failed to set BPF device timeout");
171: }
172:
173: /*
174: * And set the filter
175: */
176: memset (&bpf_prog, 0, sizeof (struct bpf_program));
177: bpf_prog.bf_len = 8;
178: bpf_prog.bf_insns = &(llcfilter[0]);
179: if (ioctl (fd, BIOCSETF, (caddr_t) & bpf_prog) < 0)
180: {
181: zlog_warn ("open_bpf_dev(): failed to install filter: %s",
182: safe_strerror (errno));
183: return ISIS_WARNING;
184: }
185:
186: assert (fd > 0);
187:
188: circuit->fd = fd;
189:
190: return ISIS_OK;
191: }
192:
193: /*
194: * Create the socket and set the tx/rx funcs
195: */
196: int
197: isis_sock_init (struct isis_circuit *circuit)
198: {
199: int retval = ISIS_OK;
200:
201: if (isisd_privs.change (ZPRIVS_RAISE))
202: zlog_err ("%s: could not raise privs, %s", __func__, safe_strerror (errno));
203:
204: retval = open_bpf_dev (circuit);
205:
206: if (retval != ISIS_OK)
207: {
208: zlog_warn ("%s: could not initialize the socket", __func__);
209: goto end;
210: }
211:
212: if (circuit->circ_type == CIRCUIT_T_BROADCAST)
213: {
214: circuit->tx = isis_send_pdu_bcast;
215: circuit->rx = isis_recv_pdu_bcast;
216: }
217: else if (circuit->circ_type == CIRCUIT_T_P2P)
218: {
219: circuit->tx = isis_send_pdu_p2p;
220: circuit->rx = isis_recv_pdu_p2p;
221: }
222: else
223: {
224: zlog_warn ("isis_sock_init(): unknown circuit type");
225: retval = ISIS_WARNING;
226: goto end;
227: }
228:
229: end:
230: if (isisd_privs.change (ZPRIVS_LOWER))
231: zlog_err ("%s: could not lower privs, %s", __func__, safe_strerror (errno));
232:
233: return retval;
234: }
235:
236: int
237: isis_recv_pdu_bcast (struct isis_circuit *circuit, u_char * ssnpa)
238: {
239: int bytesread = 0, bytestoread, offset, one = 1;
240: struct bpf_hdr *bpf_hdr;
241:
242: assert (circuit->fd > 0);
243:
244: if (ioctl (circuit->fd, FIONREAD, (caddr_t) & bytestoread) < 0)
245: {
246: zlog_warn ("ioctl() FIONREAD failed: %s", safe_strerror (errno));
247: }
248:
249: if (bytestoread)
250: {
251: bytesread = read (circuit->fd, readbuff, readblen);
252: }
253: if (bytesread < 0)
254: {
255: zlog_warn ("isis_recv_pdu_bcast(): read() failed: %s",
256: safe_strerror (errno));
257: return ISIS_WARNING;
258: }
259:
260: if (bytesread == 0)
261: return ISIS_WARNING;
262:
263: bpf_hdr = (struct bpf_hdr *) readbuff;
264:
265: assert (bpf_hdr->bh_caplen == bpf_hdr->bh_datalen);
266:
267: offset = bpf_hdr->bh_hdrlen + LLC_LEN + ETHER_HDR_LEN;
268:
269: /* then we lose the BPF, LLC and ethernet headers */
270: stream_write (circuit->rcv_stream, readbuff + offset,
271: bpf_hdr->bh_caplen - LLC_LEN - ETHER_HDR_LEN);
272: stream_set_getp (circuit->rcv_stream, 0);
273:
274: memcpy (ssnpa, readbuff + bpf_hdr->bh_hdrlen + ETHER_ADDR_LEN,
275: ETHER_ADDR_LEN);
276:
277: if (ioctl (circuit->fd, BIOCFLUSH, &one) < 0)
278: zlog_warn ("Flushing failed: %s", safe_strerror (errno));
279:
280: return ISIS_OK;
281: }
282:
283: int
284: isis_recv_pdu_p2p (struct isis_circuit *circuit, u_char * ssnpa)
285: {
286: int bytesread;
287:
288: bytesread = stream_read (circuit->rcv_stream, circuit->fd,
289: circuit->interface->mtu);
290:
291: if (bytesread < 0)
292: {
293: zlog_warn ("isis_recv_pdu_p2p(): read () failed: %s", safe_strerror (errno));
294: return ISIS_WARNING;
295: }
296:
297: return ISIS_OK;
298: }
299:
300: int
301: isis_send_pdu_bcast (struct isis_circuit *circuit, int level)
302: {
303: struct ether_header *eth;
304: int written;
305:
306: stream_set_getp (circuit->snd_stream, 0);
307:
308: /*
309: * First the eth header
310: */
311: eth = (struct ether_header *) sock_buff;
312: if (level == 1)
313: memcpy (eth->ether_dhost, ALL_L1_ISS, ETHER_ADDR_LEN);
314: else
315: memcpy (eth->ether_dhost, ALL_L2_ISS, ETHER_ADDR_LEN);
316: memcpy (eth->ether_shost, circuit->u.bc.snpa, ETHER_ADDR_LEN);
317: eth->ether_type = htons (stream_get_endp (circuit->snd_stream) + LLC_LEN);
318:
319: /*
320: * Then the LLC
321: */
322: sock_buff[ETHER_HDR_LEN] = ISO_SAP;
323: sock_buff[ETHER_HDR_LEN + 1] = ISO_SAP;
324: sock_buff[ETHER_HDR_LEN + 2] = 0x03;
325:
326: /* then we copy the data */
327: memcpy (sock_buff + (LLC_LEN + ETHER_HDR_LEN), circuit->snd_stream->data,
328: stream_get_endp (circuit->snd_stream));
329:
330: /* now we can send this */
331: written = write (circuit->fd, sock_buff,
332: stream_get_endp (circuit->snd_stream)
333: + LLC_LEN + ETHER_HDR_LEN);
334:
335: return ISIS_OK;
336: }
337:
338: int
339: isis_send_pdu_p2p (struct isis_circuit *circuit, int level)
340: {
341: return ISIS_OK;
342: }
343:
344: #endif /* ISIS_METHOD == ISIS_METHOD_BPF */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to isis_bpf.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / quagga / isisd