[mirror_frr.git] / isisd / isis_bpf.c

/*
 * IS-IS Rout(e)ing protocol - isis_bpf.c
 *
 * Copyright (C) 2001,2002    Sampo Saaristo
 *                            Tampere University of Technology
 *                            Institute of Communications Engineering
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public Licenseas published by the Free
 * Software Foundation; either version 2 of the License, or (at your option)
 * any later version.
 *
 * This program is distributed in the hope that it will be useful,but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
 * more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; see the file COPYING; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
 */

#include <zebra.h>
#if ISIS_METHOD == ISIS_METHOD_BPF
#include <net/if.h>
#include <netinet/if_ether.h>
#include <sys/time.h>
#include <sys/ioctl.h>
#include <net/bpf.h>

#include "log.h"
#include "network.h"
#include "stream.h"
#include "if.h"
#include "lib_errors.h"

#include "isisd/dict.h"
#include "isisd/isis_constants.h"
#include "isisd/isis_common.h"
#include "isisd/isis_circuit.h"
#include "isisd/isis_flags.h"
#include "isisd/isisd.h"
#include "isisd/isis_constants.h"
#include "isisd/isis_circuit.h"
#include "isisd/isis_network.h"

#include "privs.h"

struct bpf_insn llcfilter[] = {
	BPF_STMT(BPF_LD + BPF_B + BPF_ABS,
		 ETHER_HDR_LEN), /* check first byte */
	BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, ISO_SAP, 0, 5),
	BPF_STMT(BPF_LD + BPF_B + BPF_ABS, ETHER_HDR_LEN + 1),
	BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, ISO_SAP, 0,
		 3), /* check second byte */
	BPF_STMT(BPF_LD + BPF_B + BPF_ABS, ETHER_HDR_LEN + 2),
	BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, 0x03, 0, 1), /* check third byte */
	BPF_STMT(BPF_RET + BPF_K, (unsigned int)-1),
	BPF_STMT(BPF_RET + BPF_K, 0)};
unsigned int readblen = 0;
uint8_t *readbuff = NULL;

/*
 * Table 9 - Architectural constants for use with ISO 8802 subnetworks
 * ISO 10589 - 8.4.8
 */

uint8_t ALL_L1_ISS[6] = {0x01, 0x80, 0xC2, 0x00, 0x00, 0x14};
uint8_t ALL_L2_ISS[6] = {0x01, 0x80, 0xC2, 0x00, 0x00, 0x15};
uint8_t ALL_ISS[6] = {0x09, 0x00, 0x2B, 0x00, 0x00, 0x05};
uint8_t ALL_ESS[6] = {0x09, 0x00, 0x2B, 0x00, 0x00, 0x04};

static char sock_buff[8192];

static int open_bpf_dev(struct isis_circuit *circuit)
{
	int i = 0, fd;
	char bpfdev[128];
	struct ifreq ifr;
	unsigned int blen, immediate;
#ifdef BIOCSSEESENT
	unsigned int seesent;
#endif
	struct timeval timeout;
	struct bpf_program bpf_prog;

	do {
		(void)snprintf(bpfdev, sizeof(bpfdev), "/dev/bpf%d", i++);
		fd = open(bpfdev, O_RDWR);
	} while (fd < 0 && errno == EBUSY);

	if (fd < 0) {
		zlog_warn("open_bpf_dev(): failed to create bpf socket: %s",
			  safe_strerror(errno));
		return ISIS_WARNING;
	}

	zlog_debug("Opened BPF device %s", bpfdev);

	memcpy(ifr.ifr_name, circuit->interface->name, sizeof(ifr.ifr_name));
	if (ioctl(fd, BIOCSETIF, (caddr_t)&ifr) < 0) {
		zlog_warn("open_bpf_dev(): failed to bind to interface: %s",
			  safe_strerror(errno));
		return ISIS_WARNING;
	}

	if (ioctl(fd, BIOCGBLEN, (caddr_t)&blen) < 0) {
		zlog_warn("failed to get BPF buffer len");
		blen = circuit->interface->mtu;
	}

	readblen = blen;

	if (readbuff == NULL)
		readbuff = malloc(blen);

	zlog_debug("BPF buffer len = %u", blen);

	/*  BPF(4): reads return immediately upon packet reception.
	 *  Otherwise, a read will block until either the kernel
	 *  buffer becomes full or a timeout occurs.
	 */
	immediate = 1;
	if (ioctl(fd, BIOCIMMEDIATE, (caddr_t)&immediate) < 0) {
		zlog_warn("failed to set BPF dev to immediate mode");
	}

#ifdef BIOCSSEESENT
	/*
	 * We want to see only incoming packets
	 */
	seesent = 0;
	if (ioctl(fd, BIOCSSEESENT, (caddr_t)&seesent) < 0) {
		zlog_warn("failed to set BPF dev to incoming only mode");
	}
#endif

	/*
	 * ...but all of them
	 */
	if (ioctl(fd, BIOCPROMISC) < 0) {
		zlog_warn("failed to set BPF dev to promiscuous mode");
	}

	/*
	 * If the buffer length is smaller than our mtu, lets try to increase it
	 */
	if (blen < circuit->interface->mtu) {
		if (ioctl(fd, BIOCSBLEN, &circuit->interface->mtu) < 0) {
			zlog_warn("failed to set BPF buffer len (%u to %u)",
				  blen, circuit->interface->mtu);
		}
	}

	/*
	 * Set a timeout parameter - hope this helps select()
	 */
	timeout.tv_sec = 600;
	timeout.tv_usec = 0;
	if (ioctl(fd, BIOCSRTIMEOUT, (caddr_t)&timeout) < 0) {
		zlog_warn("failed to set BPF device timeout");
	}

	/*
	 * And set the filter
	 */
	memset(&bpf_prog, 0, sizeof(struct bpf_program));
	bpf_prog.bf_len = 8;
	bpf_prog.bf_insns = &(llcfilter[0]);
	if (ioctl(fd, BIOCSETF, (caddr_t)&bpf_prog) < 0) {
		zlog_warn("open_bpf_dev(): failed to install filter: %s",
			  safe_strerror(errno));
		return ISIS_WARNING;
	}

	assert(fd > 0);

	circuit->fd = fd;

	return ISIS_OK;
}

/*
 * Create the socket and set the tx/rx funcs
 */
int isis_sock_init(struct isis_circuit *circuit)
{
	int retval = ISIS_OK;

	frr_elevate_privs(&isisd_privs) {

		retval = open_bpf_dev(circuit);

		if (retval != ISIS_OK) {
			zlog_warn("%s: could not initialize the socket",
				  __func__);
			break;
		}

		if (if_is_broadcast(circuit->interface)) {
			circuit->tx = isis_send_pdu_bcast;
			circuit->rx = isis_recv_pdu_bcast;
		} else {
			zlog_warn("isis_sock_init(): unknown circuit type");
			retval = ISIS_WARNING;
			break;
		}
	}

	return retval;
}

int isis_recv_pdu_bcast(struct isis_circuit *circuit, uint8_t *ssnpa)
{
	int bytesread = 0, bytestoread, offset, one = 1, err = ISIS_OK;
	uint8_t *buff_ptr;
	struct bpf_hdr *bpf_hdr;

	assert(circuit->fd > 0);

	if (ioctl(circuit->fd, FIONREAD, (caddr_t)&bytestoread) < 0) {
		zlog_warn("ioctl() FIONREAD failed: %s", safe_strerror(errno));
	}

	if (bytestoread) {
		bytesread = read(circuit->fd, readbuff, readblen);
	}
	if (bytesread < 0) {
		zlog_warn("isis_recv_pdu_bcast(): read() failed: %s",
				safe_strerror(errno));
		return ISIS_WARNING;
	}

	if (bytesread == 0)
		return ISIS_WARNING;

	buff_ptr = readbuff;
	while (buff_ptr < readbuff + bytesread) {
		bpf_hdr = (struct bpf_hdr *) buff_ptr;
		assert(bpf_hdr->bh_caplen == bpf_hdr->bh_datalen);
		offset = bpf_hdr->bh_hdrlen + LLC_LEN + ETHER_HDR_LEN;

		/* then we lose the BPF, LLC and ethernet headers */
		stream_write(circuit->rcv_stream, buff_ptr + offset,
			     bpf_hdr->bh_caplen - LLC_LEN - ETHER_HDR_LEN);
		stream_set_getp(circuit->rcv_stream, 0);

		memcpy(ssnpa, buff_ptr + bpf_hdr->bh_hdrlen + ETHER_ADDR_LEN,
		ETHER_ADDR_LEN);

		err = isis_handle_pdu(circuit, ssnpa);
		stream_reset(circuit->rcv_stream);
		buff_ptr += BPF_WORDALIGN(bpf_hdr->bh_hdrlen +
						bpf_hdr->bh_datalen);
	}


	if (ioctl(circuit->fd, BIOCFLUSH, &one) < 0)
		zlog_warn("Flushing failed: %s", safe_strerror(errno));

	return ISIS_OK;
}

int isis_send_pdu_bcast(struct isis_circuit *circuit, int level)
{
	struct ether_header *eth;
	ssize_t written;
	size_t buflen;

	buflen = stream_get_endp(circuit->snd_stream) + LLC_LEN + ETHER_HDR_LEN;
	if (buflen > sizeof(sock_buff)) {
		zlog_warn(
			"isis_send_pdu_bcast: sock_buff size %zu is less than "
			"output pdu size %zu on circuit %s",
			sizeof(sock_buff), buflen, circuit->interface->name);
		return ISIS_WARNING;
	}

	stream_set_getp(circuit->snd_stream, 0);

	/*
	 * First the eth header
	 */
	eth = (struct ether_header *)sock_buff;
	if (level == 1)
		memcpy(eth->ether_dhost, ALL_L1_ISS, ETH_ALEN);
	else
		memcpy(eth->ether_dhost, ALL_L2_ISS, ETH_ALEN);
	memcpy(eth->ether_shost, circuit->u.bc.snpa, ETH_ALEN);
	size_t frame_size = stream_get_endp(circuit->snd_stream) + LLC_LEN;
	eth->ether_type = htons(isis_ethertype(frame_size));

	/*
	 * Then the LLC
	 */
	sock_buff[ETHER_HDR_LEN] = ISO_SAP;
	sock_buff[ETHER_HDR_LEN + 1] = ISO_SAP;
	sock_buff[ETHER_HDR_LEN + 2] = 0x03;

	/* then we copy the data */
	memcpy(sock_buff + (LLC_LEN + ETHER_HDR_LEN), circuit->snd_stream->data,
	       stream_get_endp(circuit->snd_stream));

	/* now we can send this */
	written = write(circuit->fd, sock_buff, buflen);
	if (written < 0) {
		zlog_warn("IS-IS bpf: could not transmit packet on %s: %s",
			  circuit->interface->name, safe_strerror(errno));
		if (ERRNO_IO_RETRY(errno))
			return ISIS_WARNING;
		return ISIS_ERROR;
	}

	return ISIS_OK;
}

#endif /* ISIS_METHOD == ISIS_METHOD_BPF */
Commit	Line	Data
8bc98059 PJ	1	/*
	2	* IS-IS Rout(e)ing protocol - isis_bpf.c
	3	*
	4	* Copyright (C) 2001,2002 Sampo Saaristo
d62a17ae	5	* Tampere University of Technology
8bc98059 PJ	6	* Institute of Communications Engineering
8bc98059 PJ	7	*
d62a17ae	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)
8bc98059 PJ	11	* any later version.
8bc98059 PJ	12	*
d62a17ae	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
8bc98059	16	* more details.
896014f4 DL	17	*
	18	* You should have received a copy of the GNU General Public License along
	19	* with this program; see the file COPYING; if not, write to the Free Software
	20	* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
8bc98059 PJ	21	*/
	22
	23	#include <zebra.h>
745bf05f	24	#if ISIS_METHOD == ISIS_METHOD_BPF
8bc98059 PJ	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"
cfd1f27b	32	#include "network.h"
8bc98059 PJ	33	#include "stream.h"
8bc98059 PJ	34	#include "if.h"
38937bd5	35	#include "lib_errors.h"
8bc98059 PJ	36
8bc98059 PJ	37	#include "isisd/dict.h"
8bc98059 PJ	38	#include "isisd/isis_constants.h"
	39	#include "isisd/isis_common.h"
	40	#include "isisd/isis_circuit.h"
	41	#include "isisd/isis_flags.h"
	42	#include "isisd/isisd.h"
	43	#include "isisd/isis_constants.h"
	44	#include "isisd/isis_circuit.h"
	45	#include "isisd/isis_network.h"
	46
	47	#include "privs.h"
	48
8bc98059	49	struct bpf_insn llcfilter[] = {
12386e86 RZ	50	BPF_STMT(BPF_LD + BPF_B + BPF_ABS,
12386e86 RZ	51	ETHER_HDR_LEN), /* check first byte */
d62a17ae	52	BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, ISO_SAP, 0, 5),
12386e86 RZ	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,
	55	3), /* check second byte */
	56	BPF_STMT(BPF_LD + BPF_B + BPF_ABS, ETHER_HDR_LEN + 2),
	57	BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, 0x03, 0, 1), /* check third byte */
d7c0a89a	58	BPF_STMT(BPF_RET + BPF_K, (unsigned int)-1),
d62a17ae	59	BPF_STMT(BPF_RET + BPF_K, 0)};
d7c0a89a QY	60	unsigned int readblen = 0;
d7c0a89a QY	61	uint8_t *readbuff = NULL;
8bc98059 PJ	62
	63	/*
	64	* Table 9 - Architectural constants for use with ISO 8802 subnetworks
	65	* ISO 10589 - 8.4.8
	66	*/
	67
d7c0a89a QY	68	uint8_t ALL_L1_ISS[6] = {0x01, 0x80, 0xC2, 0x00, 0x00, 0x14};
	69	uint8_t ALL_L2_ISS[6] = {0x01, 0x80, 0xC2, 0x00, 0x00, 0x15};
	70	uint8_t ALL_ISS[6] = {0x09, 0x00, 0x2B, 0x00, 0x00, 0x05};
	71	uint8_t ALL_ESS[6] = {0x09, 0x00, 0x2B, 0x00, 0x00, 0x04};
8bc98059 PJ	72
	73	static char sock_buff[8192];
	74
d62a17ae	75	static int open_bpf_dev(struct isis_circuit *circuit)
8bc98059	76	{
d62a17ae	77	int i = 0, fd;
	78	char bpfdev[128];
	79	struct ifreq ifr;
d7c0a89a	80	unsigned int blen, immediate;
f94d4e70	81	#ifdef BIOCSSEESENT
d7c0a89a	82	unsigned int seesent;
f94d4e70	83	#endif
d62a17ae	84	struct timeval timeout;
	85	struct bpf_program bpf_prog;
	86
	87	do {
	88	(void)snprintf(bpfdev, sizeof(bpfdev), "/dev/bpf%d", i++);
	89	fd = open(bpfdev, O_RDWR);
	90	} while (fd < 0 && errno == EBUSY);
	91
	92	if (fd < 0) {
	93	zlog_warn("open_bpf_dev(): failed to create bpf socket: %s",
	94	safe_strerror(errno));
	95	return ISIS_WARNING;
	96	}
	97
	98	zlog_debug("Opened BPF device %s", bpfdev);
	99
	100	memcpy(ifr.ifr_name, circuit->interface->name, sizeof(ifr.ifr_name));
	101	if (ioctl(fd, BIOCSETIF, (caddr_t)&ifr) < 0) {
	102	zlog_warn("open_bpf_dev(): failed to bind to interface: %s",
	103	safe_strerror(errno));
	104	return ISIS_WARNING;
	105	}
	106
	107	if (ioctl(fd, BIOCGBLEN, (caddr_t)&blen) < 0) {
	108	zlog_warn("failed to get BPF buffer len");
	109	blen = circuit->interface->mtu;
	110	}
	111
	112	readblen = blen;
	113
	114	if (readbuff == NULL)
	115	readbuff = malloc(blen);
	116
	117	zlog_debug("BPF buffer len = %u", blen);
	118
	119	/* BPF(4): reads return immediately upon packet reception.
	120	* Otherwise, a read will block until either the kernel
	121	* buffer becomes full or a timeout occurs.
	122	*/
	123	immediate = 1;
	124	if (ioctl(fd, BIOCIMMEDIATE, (caddr_t)&immediate) < 0) {
	125	zlog_warn("failed to set BPF dev to immediate mode");
	126	}
8bc98059 PJ	127
8bc98059 PJ	128	#ifdef BIOCSSEESENT
d62a17ae	129	/*
	130	* We want to see only incoming packets
	131	*/
	132	seesent = 0;
	133	if (ioctl(fd, BIOCSSEESENT, (caddr_t)&seesent) < 0) {
	134	zlog_warn("failed to set BPF dev to incoming only mode");
	135	}
8bc98059 PJ	136	#endif
8bc98059 PJ	137
d62a17ae	138	/*
	139	* ...but all of them
	140	*/
	141	if (ioctl(fd, BIOCPROMISC) < 0) {
	142	zlog_warn("failed to set BPF dev to promiscuous mode");
	143	}
	144
	145	/*
	146	* If the buffer length is smaller than our mtu, lets try to increase it
	147	*/
	148	if (blen < circuit->interface->mtu) {
	149	if (ioctl(fd, BIOCSBLEN, &circuit->interface->mtu) < 0) {
	150	zlog_warn("failed to set BPF buffer len (%u to %u)",
	151	blen, circuit->interface->mtu);
	152	}
	153	}
	154
	155	/*
	156	* Set a timeout parameter - hope this helps select()
	157	*/
	158	timeout.tv_sec = 600;
	159	timeout.tv_usec = 0;
	160	if (ioctl(fd, BIOCSRTIMEOUT, (caddr_t)&timeout) < 0) {
	161	zlog_warn("failed to set BPF device timeout");
	162	}
	163
	164	/*
	165	* And set the filter
	166	*/
	167	memset(&bpf_prog, 0, sizeof(struct bpf_program));
	168	bpf_prog.bf_len = 8;
	169	bpf_prog.bf_insns = &(llcfilter[0]);
	170	if (ioctl(fd, BIOCSETF, (caddr_t)&bpf_prog) < 0) {
	171	zlog_warn("open_bpf_dev(): failed to install filter: %s",
	172	safe_strerror(errno));
	173	return ISIS_WARNING;
8bc98059	174	}
d62a17ae	175
	176	assert(fd > 0);
	177
	178	circuit->fd = fd;
	179
	180	return ISIS_OK;
8bc98059 PJ	181	}
	182
	183	/*
	184	* Create the socket and set the tx/rx funcs
	185	*/
d62a17ae	186	int isis_sock_init(struct isis_circuit *circuit)
8bc98059	187	{
d62a17ae	188	int retval = ISIS_OK;
d62a17ae	189
01b9e3fd	190	frr_elevate_privs(&isisd_privs) {
d62a17ae	191
01b9e3fd	192	retval = open_bpf_dev(circuit);
d62a17ae	193
01b9e3fd	194	if (retval != ISIS_OK) {
633fc9b1 DL	195	zlog_warn("%s: could not initialize the socket",
633fc9b1 DL	196	__func__);
01b9e3fd DL	197	break;
01b9e3fd DL	198	}
d62a17ae	199
01b9e3fd DL	200	if (if_is_broadcast(circuit->interface)) {
	201	circuit->tx = isis_send_pdu_bcast;
	202	circuit->rx = isis_recv_pdu_bcast;
	203	} else {
	204	zlog_warn("isis_sock_init(): unknown circuit type");
	205	retval = ISIS_WARNING;
	206	break;
	207	}
633fc9b1	208	}
8bc98059	209
d62a17ae	210	return retval;
8bc98059 PJ	211	}
8bc98059 PJ	212
d7c0a89a	213	int isis_recv_pdu_bcast(struct isis_circuit circuit, uint8_t ssnpa)
8bc98059	214	{
b9347997	215	int bytesread = 0, bytestoread, offset, one = 1, err = ISIS_OK;
d7c0a89a	216	uint8_t *buff_ptr;
d62a17ae	217	struct bpf_hdr *bpf_hdr;
8bc98059	218
d62a17ae	219	assert(circuit->fd > 0);
8bc98059	220
d62a17ae	221	if (ioctl(circuit->fd, FIONREAD, (caddr_t)&bytestoread) < 0) {
	222	zlog_warn("ioctl() FIONREAD failed: %s", safe_strerror(errno));
	223	}
8bc98059	224
d62a17ae	225	if (bytestoread) {
	226	bytesread = read(circuit->fd, readbuff, readblen);
	227	}
	228	if (bytesread < 0) {
	229	zlog_warn("isis_recv_pdu_bcast(): read() failed: %s",
b9347997	230	safe_strerror(errno));
d62a17ae	231	return ISIS_WARNING;
d62a17ae	232	}
8bc98059	233
d62a17ae	234	if (bytesread == 0)
d62a17ae	235	return ISIS_WARNING;
8bc98059	236
b9347997	237	buff_ptr = readbuff;
	238	while (buff_ptr < readbuff + bytesread) {
	239	bpf_hdr = (struct bpf_hdr *) buff_ptr;
	240	assert(bpf_hdr->bh_caplen == bpf_hdr->bh_datalen);
	241	offset = bpf_hdr->bh_hdrlen + LLC_LEN + ETHER_HDR_LEN;
8bc98059	242
b9347997	243	/* then we lose the BPF, LLC and ethernet headers */
	244	stream_write(circuit->rcv_stream, buff_ptr + offset,
	245	bpf_hdr->bh_caplen - LLC_LEN - ETHER_HDR_LEN);
	246	stream_set_getp(circuit->rcv_stream, 0);
8bc98059	247
b9347997	248	memcpy(ssnpa, buff_ptr + bpf_hdr->bh_hdrlen + ETHER_ADDR_LEN,
b9347997	249	ETHER_ADDR_LEN);
8bc98059	250
b9347997	251	err = isis_handle_pdu(circuit, ssnpa);
	252	stream_reset(circuit->rcv_stream);
	253	buff_ptr += BPF_WORDALIGN(bpf_hdr->bh_hdrlen +
	254	bpf_hdr->bh_datalen);
	255	}
8bc98059	256
8bc98059	257
d62a17ae	258	if (ioctl(circuit->fd, BIOCFLUSH, &one) < 0)
d62a17ae	259	zlog_warn("Flushing failed: %s", safe_strerror(errno));
8bc98059	260
d62a17ae	261	return ISIS_OK;
8bc98059 PJ	262	}
8bc98059 PJ	263
d62a17ae	264	int isis_send_pdu_bcast(struct isis_circuit *circuit, int level)
8bc98059	265	{
d62a17ae	266	struct ether_header *eth;
	267	ssize_t written;
	268	size_t buflen;
	269
12386e86	270	buflen = stream_get_endp(circuit->snd_stream) + LLC_LEN + ETHER_HDR_LEN;
d62a17ae	271	if (buflen > sizeof(sock_buff)) {
	272	zlog_warn(
	273	"isis_send_pdu_bcast: sock_buff size %zu is less than "
	274	"output pdu size %zu on circuit %s",
	275	sizeof(sock_buff), buflen, circuit->interface->name);
	276	return ISIS_WARNING;
	277	}
	278
	279	stream_set_getp(circuit->snd_stream, 0);
	280
	281	/*
	282	* First the eth header
	283	*/
	284	eth = (struct ether_header *)sock_buff;
	285	if (level == 1)
d1be6968	286	memcpy(eth->ether_dhost, ALL_L1_ISS, ETH_ALEN);
d62a17ae	287	else
d1be6968 DS	288	memcpy(eth->ether_dhost, ALL_L2_ISS, ETH_ALEN);
d1be6968 DS	289	memcpy(eth->ether_shost, circuit->u.bc.snpa, ETH_ALEN);
d62a17ae	290	size_t frame_size = stream_get_endp(circuit->snd_stream) + LLC_LEN;
	291	eth->ether_type = htons(isis_ethertype(frame_size));
	292
	293	/*
	294	* Then the LLC
	295	*/
12386e86 RZ	296	sock_buff[ETHER_HDR_LEN] = ISO_SAP;
	297	sock_buff[ETHER_HDR_LEN + 1] = ISO_SAP;
	298	sock_buff[ETHER_HDR_LEN + 2] = 0x03;
d62a17ae	299
d62a17ae	300	/* then we copy the data */
12386e86	301	memcpy(sock_buff + (LLC_LEN + ETHER_HDR_LEN), circuit->snd_stream->data,
d62a17ae	302	stream_get_endp(circuit->snd_stream));
	303
	304	/* now we can send this */
	305	written = write(circuit->fd, sock_buff, buflen);
	306	if (written < 0) {
	307	zlog_warn("IS-IS bpf: could not transmit packet on %s: %s",
	308	circuit->interface->name, safe_strerror(errno));
	309	if (ERRNO_IO_RETRY(errno))
	310	return ISIS_WARNING;
	311	return ISIS_ERROR;
	312	}
	313
	314	return ISIS_OK;
8bc98059 PJ	315	}
8bc98059 PJ	316
745bf05f	317	#endif /* ISIS_METHOD == ISIS_METHOD_BPF */