um: Remove obsolete pcap driver (12b8e7e6) · Commits · git / linux-net

arch/um/drivers/Kconfig

+0 −20

Original line number	Diff line number	Diff line
		@@ -297,26 +297,6 @@ config UML_NET_MCAST

		If unsure, say N.

		config UML_NET_PCAP
		bool "pcap transport (obsolete)"
		depends on UML_NET
		depends on !MODVERSIONS
		select MAY_HAVE_RUNTIME_DEPS
		help
		The pcap transport makes a pcap packet stream on the host look
		like an ethernet device inside UML. This is useful for making
		UML act as a network monitor for the host. You must have libcap
		installed in order to build the pcap transport into UML.

		For more information, see
		<http://user-mode-linux.sourceforge.net/old/networking.html> That site
		has examples of the UML command line to use to enable this option.

		NOTE: THIS TRANSPORT IS DEPRECATED AND WILL BE REMOVED SOON!!! Please
		migrate to UML_NET_VECTOR.

		If unsure, say N.

		config UML_NET_SLIRP
		bool "SLiRP transport (obsolete)"
		depends on UML_NET

arch/um/drivers/Makefile

+2 −8

Original line number	Diff line number	Diff line
		@@ -20,14 +20,9 @@ harddog-objs := harddog_kern.o
		harddog-builtin-$(CONFIG_UML_WATCHDOG) := harddog_user.o harddog_user_exp.o
		rtc-objs := rtc_kern.o rtc_user.o

		LDFLAGS_pcap.o = $(shell $(CC) $(KBUILD_CFLAGS) -print-file-name=libpcap.a)

		LDFLAGS_vde.o = $(shell $(CC) $(CFLAGS) -print-file-name=libvdeplug.a)

		targets := pcap_kern.o pcap_user.o vde_kern.o vde_user.o

		$(obj)/pcap.o: $(obj)/pcap_kern.o $(obj)/pcap_user.o
		$(LD) -r -dp -o $@ $^ $(ld_flags)
		targets := vde_kern.o vde_user.o

		$(obj)/vde.o: $(obj)/vde_kern.o $(obj)/vde_user.o
		$(LD) -r -dp -o $@ $^ $(ld_flags)
		@@ -49,7 +44,6 @@ obj-$(CONFIG_UML_NET_DAEMON) += daemon.o
		obj-$(CONFIG_UML_NET_VECTOR) += vector.o
		obj-$(CONFIG_UML_NET_VDE) += vde.o
		obj-$(CONFIG_UML_NET_MCAST) += umcast.o
		obj-$(CONFIG_UML_NET_PCAP) += pcap.o
		obj-$(CONFIG_UML_NET) += net.o
		obj-$(CONFIG_MCONSOLE) += mconsole.o
		obj-$(CONFIG_MMAPPER) += mmapper_kern.o
		@@ -69,7 +63,7 @@ obj-$(CONFIG_UML_RTC) += rtc.o
		obj-$(CONFIG_UML_PCI_OVER_VIRTIO) += virt-pci.o

		# pcap_user.o must be added explicitly.
		USER_OBJS := fd.o null.o pty.o tty.o xterm.o slip_common.o pcap_user.o vde_user.o vector_user.o
		USER_OBJS := fd.o null.o pty.o tty.o xterm.o slip_common.o vde_user.o vector_user.o
		CFLAGS_null.o = -DDEV_NULL=$(DEV_NULL_PATH)

		CFLAGS_xterm.o += '-DCONFIG_XTERM_CHAN_DEFAULT_EMULATOR="$(CONFIG_XTERM_CHAN_DEFAULT_EMULATOR)"'

arch/um/drivers/pcap_kern.c

deleted100644 → 0

+0 −113

Original line number	Diff line number	Diff line
		// SPDX-License-Identifier: GPL-2.0
		/*
		* Copyright (C) 2002 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com)
		*/

		#include <linux/init.h>
		#include <linux/netdevice.h>
		#include <net_kern.h>
		#include "pcap_user.h"

		struct pcap_init {
		char *host_if;
		int promisc;
		int optimize;
		char *filter;
		};

		static void pcap_init_kern(struct net_device dev, void data)
		{
		struct uml_net_private *pri;
		struct pcap_data *ppri;
		struct pcap_init *init = data;

		pri = netdev_priv(dev);
		ppri = (struct pcap_data *) pri->user;
		ppri->host_if = init->host_if;
		ppri->promisc = init->promisc;
		ppri->optimize = init->optimize;
		ppri->filter = init->filter;

		printk("pcap backend, host interface %s\n", ppri->host_if);
		}

		static int pcap_read(int fd, struct sk_buff skb, struct uml_net_private lp)
		{
		return pcap_user_read(fd, skb_mac_header(skb),
		skb->dev->mtu + ETH_HEADER_OTHER,
		(struct pcap_data *) &lp->user);
		}

		static int pcap_write(int fd, struct sk_buff skb, struct uml_net_private lp)
		{
		return -EPERM;
		}

		static const struct net_kern_info pcap_kern_info = {
		.init = pcap_init_kern,
		.protocol = eth_protocol,
		.read = pcap_read,
		.write = pcap_write,
		};

		static int pcap_setup(char str, char mac_out, void data)
		{
		struct pcap_init *init = data;
		char remain, host_if = NULL, *options[2] = { NULL, NULL };
		int i;

		*init = ((struct pcap_init)
		{ .host_if = "eth0",
		.promisc = 1,
		.optimize = 0,
		.filter = NULL });

		remain = split_if_spec(str, &host_if, &init->filter,
		&options[0], &options[1], mac_out, NULL);
		if (remain != NULL) {
		printk(KERN_ERR "pcap_setup - Extra garbage on "
		"specification : '%s'\n", remain);
		return 0;
		}

		if (host_if != NULL)
		init->host_if = host_if;

		for (i = 0; i < ARRAY_SIZE(options); i++) {
		if (options[i] == NULL)
		continue;
		if (!strcmp(options[i], "promisc"))
		init->promisc = 1;
		else if (!strcmp(options[i], "nopromisc"))
		init->promisc = 0;
		else if (!strcmp(options[i], "optimize"))
		init->optimize = 1;
		else if (!strcmp(options[i], "nooptimize"))
		init->optimize = 0;
		else {
		printk(KERN_ERR "pcap_setup : bad option - '%s'\n",
		options[i]);
		return 0;
		}
		}

		return 1;
		}

		static struct transport pcap_transport = {
		.list = LIST_HEAD_INIT(pcap_transport.list),
		.name = "pcap",
		.setup = pcap_setup,
		.user = &pcap_user_info,
		.kern = &pcap_kern_info,
		.private_size = sizeof(struct pcap_data),
		.setup_size = sizeof(struct pcap_init),
		};

		static int register_pcap(void)
		{
		register_transport(&pcap_transport);
		return 0;
		}

		late_initcall(register_pcap);

arch/um/drivers/pcap_user.c

deleted100644 → 0

+0 −137

Original line number	Diff line number	Diff line
		// SPDX-License-Identifier: GPL-2.0
		/*
		* Copyright (C) 2002 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com)
		*/

		#include <errno.h>
		#include <pcap.h>
		#include <string.h>
		#include <asm/types.h>
		#include <net_user.h>
		#include "pcap_user.h"
		#include <um_malloc.h>

		#define PCAP_FD(p) ((int )(p))

		static int pcap_user_init(void data, void dev)
		{
		struct pcap_data *pri = data;
		pcap_t *p;
		char errors[PCAP_ERRBUF_SIZE];

		p = pcap_open_live(pri->host_if, ETH_MAX_PACKET + ETH_HEADER_OTHER,
		pri->promisc, 0, errors);
		if (p == NULL) {
		printk(UM_KERN_ERR "pcap_user_init : pcap_open_live failed - "
		"'%s'\n", errors);
		return -EINVAL;
		}

		pri->dev = dev;
		pri->pcap = p;
		return 0;
		}

		static int pcap_user_open(void *data)
		{
		struct pcap_data *pri = data;
		__u32 netmask;
		int err;

		if (pri->pcap == NULL)
		return -ENODEV;

		if (pri->filter != NULL) {
		err = dev_netmask(pri->dev, &netmask);
		if (err < 0) {
		printk(UM_KERN_ERR "pcap_user_open : dev_netmask failed\n");
		return -EIO;
		}

		pri->compiled = uml_kmalloc(sizeof(struct bpf_program),
		UM_GFP_KERNEL);
		if (pri->compiled == NULL) {
		printk(UM_KERN_ERR "pcap_user_open : kmalloc failed\n");
		return -ENOMEM;
		}

		err = pcap_compile(pri->pcap,
		(struct bpf_program *) pri->compiled,
		pri->filter, pri->optimize, netmask);
		if (err < 0) {
		printk(UM_KERN_ERR "pcap_user_open : pcap_compile failed - "
		"'%s'\n", pcap_geterr(pri->pcap));
		goto out;
		}

		err = pcap_setfilter(pri->pcap, pri->compiled);
		if (err < 0) {
		printk(UM_KERN_ERR "pcap_user_open : pcap_setfilter "
		"failed - '%s'\n", pcap_geterr(pri->pcap));
		goto out;
		}
		}

		return PCAP_FD(pri->pcap);

		out:
		kfree(pri->compiled);
		return -EIO;
		}

		static void pcap_remove(void *data)
		{
		struct pcap_data *pri = data;

		if (pri->compiled != NULL)
		pcap_freecode(pri->compiled);

		if (pri->pcap != NULL)
		pcap_close(pri->pcap);
		}

		struct pcap_handler_data {
		char *buffer;
		int len;
		};

		static void handler(u_char data, const struct pcap_pkthdr header,
		const u_char *packet)
		{
		int len;

		struct pcap_handler_data hdata = (struct pcap_handler_data ) data;

		len = hdata->len < header->caplen ? hdata->len : header->caplen;
		memcpy(hdata->buffer, packet, len);
		hdata->len = len;
		}

		int pcap_user_read(int fd, void buffer, int len, struct pcap_data pri)
		{
		struct pcap_handler_data hdata = ((struct pcap_handler_data)
		{ .buffer = buffer,
		.len = len });
		int n;

		n = pcap_dispatch(pri->pcap, 1, handler, (u_char *) &hdata);
		if (n < 0) {
		printk(UM_KERN_ERR "pcap_dispatch failed - %s\n",
		pcap_geterr(pri->pcap));
		return -EIO;
		}
		else if (n == 0)
		return 0;
		return hdata.len;
		}

		const struct net_user_info pcap_user_info = {
		.init = pcap_user_init,
		.open = pcap_user_open,
		.close = NULL,
		.remove = pcap_remove,
		.add_address = NULL,
		.delete_address = NULL,
		.mtu = ETH_MAX_PACKET,
		.max_packet = ETH_MAX_PACKET + ETH_HEADER_OTHER,
		};

arch/um/drivers/pcap_user.h

deleted100644 → 0

+0 −21

Original line number	Diff line number	Diff line
		/* SPDX-License-Identifier: GPL-2.0 */
		/*
		* Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
		*/

		#include <net_user.h>

		struct pcap_data {
		char *host_if;
		int promisc;
		int optimize;
		char *filter;
		void *compiled;
		void *pcap;
		void *dev;
		};

		extern const struct net_user_info pcap_user_info;

		extern int pcap_user_read(int fd, void buf, int len, struct pcap_data pri);