Osmocom Libraries » libosmocore

/* Copyright (c) 2020 by sysmocom - s.f.m.c. GmbH

 * Author: Harald Welte <hwelte@sysmocom.de>

 * SPDX-Identifier: MIT */

/* Demo program to show the incredibly unusual semantics of AF_PACKET sockets

 *

 *  - they return ENOBUFS in blocking mode, rather than blocking

 *  - they are marked 'writeable' in select, but still return ENOBUFS when you actually want to write

 */

#include <errno.h>

#include <stdint.h>

#include <inttypes.h>

#include <unistd.h>

#include <stdlib.h>

#include <string.h>

#include <stdio.h>

#include <stdbool.h>

#include <sys/types.h>

#include <sys/ioctl.h>

#include <netpacket/packet.h>

#include <netinet/in.h>

#include <linux/if_ether.h>

#include <linux/if.h>

#include <time.h>

#include <bsd/sys/time.h>

static int devname2ifindex(const char *ifname)

{

	struct ifreq ifr;

	int sk, rc;

	sk = socket(AF_INET, SOCK_DGRAM, IPPROTO_IP);

	if (sk < 0)

		return sk;

	memset(&ifr, 0, sizeof(ifr));

	strncpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));

	ifr.ifr_name[sizeof(ifr.ifr_name)-1] = 0;

	rc = ioctl(sk, SIOCGIFINDEX, &ifr);

	close(sk);

	if (rc < 0)

		return rc;

	return ifr.ifr_ifindex;

}

static int open_socket(int ifindex)

{

	struct sockaddr_ll addr;

	int fd, rc;

	memset(&addr, 0, sizeof(addr));

	addr.sll_family = AF_PACKET;

	addr.sll_protocol = htons(ETH_P_ALL);

	addr.sll_ifindex = ifindex;

	fd = socket(AF_PACKET, SOCK_RAW, htons(ETH_P_ALL));

	if (fd < 0)

		return fd;

	rc = bind(fd, (struct sockaddr *)&addr, sizeof(addr));

	if (rc < 0) {

		close(fd);

		return rc;

	}

	return fd;

}

static int open_socket_devname(const char *netdev_name)

{

	/* resolve ifindex; open the socket; register filedescriptor */

	int ifindex = devname2ifindex(netdev_name);

	if (ifindex < 0) {

		fprintf(stderr, "Cannot resolve interface index of netdev `%s': Does it exist?", netdev_name);

		exit(1);

	}

	int fd = open_socket(ifindex);

	if (fd < 0) {

		fprintf(stderr, "Cannot create/bind AF_PACKET socket: %s\n", strerror(errno));

		exit(1);

	}

	return fd;

}

static int write_flood(int fd, int num_cycles, int size, bool use_select)

{

	int i = 0, ret = 0;

	char buf[2048];

	struct timespec ts_write, ts_write_fail;

	bool recovering = false;

	fd_set writefds;

	memset(buf, 0, sizeof(buf));

	FD_ZERO(&writefds);

	while (i < num_cycles) {

		int rc;

		/* optionally: let's wait until the socket is marked write-able.

		 * Covnentional wisdom would mean this happens when we can actually write.

		 * Unfortunately, in reality this is completely useless as it always returns writable */

		if (use_select) {

			FD_SET(fd, &writefds);

			rc = select(fd+1, NULL, &writefds, NULL, NULL);

			if (!FD_ISSET(fd, &writefds)) {

				fprintf(stderr, "select() returned with %d, but fd not set!\n", rc);

				continue;

			}

		}

		/* Then actually write to it */

		clock_gettime(CLOCK_MONOTONIC, &ts_write);

		rc = write(fd, buf, size);

		if (rc == size) {

			if (recovering) {

				struct timespec diff;

				timespecsub(&ts_write, &ts_write_fail, &diff);

				/* PRINT time between last write */

				printf("%d: time since last success = %lu s, %lu us\n", i,

					diff.tv_sec, diff.tv_nsec/1000);

				recovering = false;

			}

			i++;

		} else if (rc == -1 && errno == ENOBUFS) {

			ret++;

			//fprintf(stderr, "write #%d failed with %d (%s)\n", i, rc, strerror(errno));

			if (!recovering) {

				recovering = true;

				ts_write_fail = ts_write;

			}

			/* HACK: this is the only work-around I could find: sleep some time and retry:

			 * sleep about as much time as is needed by the underlying net-device to transmit

			 * one 1400 byete packet */

			//usleep(5400);

		} else {

			fprintf(stderr, "write #%d failed with %d (%s)\n", i, rc, strerror(errno));

			exit(1);

		}

	}

	return ret;

}

int main(int argc, char **argv)

{

	int fd = open_socket_devname("hdlc1");

	int num_err;

	/* write 1000 packets of 1400 bytes each; last paramter determines if a select()

	 * should be done ahead of each write() or not. */

	num_err = write_flood(fd, 1000, 1400, true);

	printf("total number of ENOBUFS: %d\n", num_err);

}