[mirror_iproute2.git] / ip / iptuntap.c

/*
 * iptunnel.c	       "ip tuntap"
 *
 *		This program is free software; you can redistribute it and/or
 *		modify it under the terms of the GNU General Public License
 *		as published by the Free Software Foundation; either version
 *		2 of the License, or (at your option) any later version.
 *
 * Authors:	David Woodhouse <David.Woodhouse@intel.com>
 *
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <sys/ioctl.h>
#include <linux/if.h>
#include <linux/if_tun.h>
#include <linux/if_arp.h>
#include <pwd.h>
#include <grp.h>
#include <fcntl.h>
#include <dirent.h>
#include <errno.h>
#include <glob.h>

#include "rt_names.h"
#include "utils.h"
#include "ip_common.h"

static const char drv_name[] = "tun";

#define TUNDEV "/dev/net/tun"

static void usage(void) __attribute__((noreturn));

static void usage(void)
{
	fprintf(stderr,
		"Usage: ip tuntap { add | del | show | list | lst | help } [ dev PHYS_DEV ]\n"
		"	[ mode { tun | tap } ] [ user USER ] [ group GROUP ]\n"
		"	[ one_queue ] [ pi ] [ vnet_hdr ] [ multi_queue ] [ name NAME ]\n"
		"\n"
		"Where:	USER  := { STRING | NUMBER }\n"
		"	GROUP := { STRING | NUMBER }\n");
	exit(-1);
}

static int tap_add_ioctl(struct ifreq *ifr, uid_t uid, gid_t gid)
{
	int fd;
	int ret = -1;

#ifdef IFF_TUN_EXCL
	ifr->ifr_flags |= IFF_TUN_EXCL;
#endif

	fd = open(TUNDEV, O_RDWR);
	if (fd < 0) {
		perror("open");
		return -1;
	}
	if (ioctl(fd, TUNSETIFF, ifr)) {
		perror("ioctl(TUNSETIFF)");
		goto out;
	}
	if (uid != -1 && ioctl(fd, TUNSETOWNER, uid)) {
		perror("ioctl(TUNSETOWNER)");
		goto out;
	}
	if (gid != -1 && ioctl(fd, TUNSETGROUP, gid)) {
		perror("ioctl(TUNSETGROUP)");
		goto out;
	}
	if (ioctl(fd, TUNSETPERSIST, 1)) {
		perror("ioctl(TUNSETPERSIST)");
		goto out;
	}
	ret = 0;
 out:
	close(fd);
	return ret;
}

static int tap_del_ioctl(struct ifreq *ifr)
{
	int fd = open(TUNDEV, O_RDWR);
	int ret = -1;

	if (fd < 0) {
		perror("open");
		return -1;
	}
	if (ioctl(fd, TUNSETIFF, ifr)) {
		perror("ioctl(TUNSETIFF)");
		goto out;
	}
	if (ioctl(fd, TUNSETPERSIST, 0)) {
		perror("ioctl(TUNSETPERSIST)");
		goto out;
	}
	ret = 0;
 out:
	close(fd);
	return ret;

}
static int parse_args(int argc, char **argv,
		      struct ifreq *ifr, uid_t *uid, gid_t *gid)
{
	int count = 0;

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

	ifr->ifr_flags |= IFF_NO_PI;

	while (argc > 0) {
		if (matches(*argv, "mode") == 0) {
			NEXT_ARG();
			if (matches(*argv, "tun") == 0) {
				if (ifr->ifr_flags & IFF_TAP) {
					fprintf(stderr, "You managed to ask for more than one tunnel mode.\n");
					exit(-1);
				}
				ifr->ifr_flags |= IFF_TUN;
			} else if (matches(*argv, "tap") == 0) {
				if (ifr->ifr_flags & IFF_TUN) {
					fprintf(stderr, "You managed to ask for more than one tunnel mode.\n");
					exit(-1);
				}
				ifr->ifr_flags |= IFF_TAP;
			} else {
				fprintf(stderr, "Unknown tunnel mode \"%s\"\n", *argv);
				exit(-1);
			}
		} else if (uid && matches(*argv, "user") == 0) {
			char *end;
			unsigned long user;

			NEXT_ARG();
			if (**argv && ((user = strtol(*argv, &end, 10)), !*end))
				*uid = user;
			else {
				struct passwd *pw = getpwnam(*argv);

				if (!pw) {
					fprintf(stderr, "invalid user \"%s\"\n", *argv);
					exit(-1);
				}
				*uid = pw->pw_uid;
			}
		} else if (gid && matches(*argv, "group") == 0) {
			char *end;
			unsigned long group;

			NEXT_ARG();

			if (**argv && ((group = strtol(*argv, &end, 10)), !*end))
				*gid = group;
			else {
				struct group *gr = getgrnam(*argv);

				if (!gr) {
					fprintf(stderr, "invalid group \"%s\"\n", *argv);
					exit(-1);
				}
				*gid = gr->gr_gid;
			}
		} else if (matches(*argv, "pi") == 0) {
			ifr->ifr_flags &= ~IFF_NO_PI;
		} else if (matches(*argv, "one_queue") == 0) {
			ifr->ifr_flags |= IFF_ONE_QUEUE;
		} else if (matches(*argv, "vnet_hdr") == 0) {
			ifr->ifr_flags |= IFF_VNET_HDR;
		} else if (matches(*argv, "multi_queue") == 0) {
			ifr->ifr_flags |= IFF_MULTI_QUEUE;
		} else if (matches(*argv, "dev") == 0) {
			NEXT_ARG();
			if (get_ifname(ifr->ifr_name, *argv))
				invarg("\"dev\" not a valid ifname", *argv);
		} else {
			if (matches(*argv, "name") == 0) {
				NEXT_ARG();
			} else if (matches(*argv, "help") == 0)
				usage();
			if (ifr->ifr_name[0])
				duparg2("name", *argv);
			if (get_ifname(ifr->ifr_name, *argv))
				invarg("\"name\" not a valid ifname", *argv);
		}
		count++;
		argc--; argv++;
	}

	if (!(ifr->ifr_flags & TUN_TYPE_MASK)) {
		fprintf(stderr, "You failed to specify a tunnel mode\n");
		return -1;
	}

	return 0;
}


static int do_add(int argc, char **argv)
{
	struct ifreq ifr;
	uid_t uid = -1;
	gid_t gid = -1;

	if (parse_args(argc, argv, &ifr, &uid, &gid) < 0)
		return -1;

	return tap_add_ioctl(&ifr, uid, gid);
}

static int do_del(int argc, char **argv)
{
	struct ifreq ifr;

	if (parse_args(argc, argv, &ifr, NULL, NULL) < 0)
		return -1;

	return tap_del_ioctl(&ifr);
}

static void print_flags(long flags)
{
	open_json_array(PRINT_JSON, "flags");

	if (flags & IFF_TUN)
		print_string(PRINT_ANY, NULL, " %s", "tun");

	if (flags & IFF_TAP)
		print_string(PRINT_ANY, NULL, " %s", "tap");

	if (!(flags & IFF_NO_PI))
		print_string(PRINT_ANY, NULL, " %s", "pi");

	if (flags & IFF_ONE_QUEUE)
		print_string(PRINT_ANY, NULL, " %s", "one_queue");

	if (flags & IFF_VNET_HDR)
		print_string(PRINT_ANY, NULL, " %s", "vnet_hdr");

	if (flags & IFF_PERSIST)
		print_string(PRINT_ANY, NULL, " %s", "persist");

	if (!(flags & IFF_NOFILTER))
		print_string(PRINT_ANY, NULL, " %s", "filter");

	flags &= ~(IFF_TUN | IFF_TAP | IFF_NO_PI | IFF_ONE_QUEUE |
		   IFF_VNET_HDR | IFF_PERSIST | IFF_NOFILTER);
	if (flags)
		print_0xhex(PRINT_ANY, NULL, "%#llx", flags);

	close_json_array(PRINT_JSON, NULL);
}

static char *pid_name(pid_t pid)
{
	char *comm;
	FILE *f;
	int err;

	err = asprintf(&comm, "/proc/%d/comm", pid);
	if (err < 0)
		return NULL;

	f = fopen(comm, "r");
	free(comm);
	if (!f) {
		perror("fopen");
		return NULL;
	}

	if (fscanf(f, "%ms\n", &comm) != 1) {
		perror("fscanf");
		comm = NULL;
	}


	if (fclose(f))
		perror("fclose");

	return comm;
}

static void show_processes(const char *name)
{
	glob_t globbuf = { };
	char **fd_path;
	int err;

	err = glob("/proc/[0-9]*/fd/[0-9]*", GLOB_NOSORT,
		   NULL, &globbuf);
	if (err)
		return;

	open_json_array(PRINT_JSON, "processes");

	fd_path = globbuf.gl_pathv;
	while (*fd_path) {
		const char *dev_net_tun = "/dev/net/tun";
		const size_t linkbuf_len = strlen(dev_net_tun) + 2;
		char linkbuf[linkbuf_len], *fdinfo;
		int pid, fd;
		FILE *f;

		if (sscanf(*fd_path, "/proc/%d/fd/%d", &pid, &fd) != 2)
			goto next;

		if (pid == getpid())
			goto next;

		err = readlink(*fd_path, linkbuf, linkbuf_len - 1);
		if (err < 0) {
			perror("readlink");
			goto next;
		}
		linkbuf[err] = '\0';
		if (strcmp(dev_net_tun, linkbuf))
			goto next;

		if (asprintf(&fdinfo, "/proc/%d/fdinfo/%d", pid, fd) < 0)
			goto next;

		f = fopen(fdinfo, "r");
		free(fdinfo);
		if (!f) {
			perror("fopen");
			goto next;
		}

		while (!feof(f)) {
			char *key = NULL, *value = NULL;

			err = fscanf(f, "%m[^:]: %ms\n", &key, &value);
			if (err == EOF) {
				if (ferror(f))
					perror("fscanf");
				break;
			} else if (err == 2 &&
				   !strcmp("iff", key) &&
				   !strcmp(name, value)) {
				char *pname = pid_name(pid);

				print_string(PRINT_ANY, "name",
					     "%s", pname ? : "<NULL>");

				print_uint(PRINT_ANY, "pid",
					   "(%d)", pid);
				free(pname);
			}

			free(key);
			free(value);
		}
		if (fclose(f))
			perror("fclose");

next:
		++fd_path;
	}
	close_json_array(PRINT_JSON, NULL);

	globfree(&globbuf);
}

static int tuntap_filter_req(struct nlmsghdr *nlh, int reqlen)
{
	struct rtattr *linkinfo;
	int err;

	linkinfo = addattr_nest(nlh, reqlen, IFLA_LINKINFO);

	err = addattr_l(nlh, reqlen, IFLA_INFO_KIND,
			drv_name, sizeof(drv_name) - 1);
	if (err)
		return err;

	addattr_nest_end(nlh, linkinfo);

	return 0;
}

static int print_tuntap(struct nlmsghdr *n, void *arg)
{
	struct ifinfomsg *ifi = NLMSG_DATA(n);
	struct rtattr *tb[IFLA_MAX+1];
	struct rtattr *linkinfo[IFLA_INFO_MAX+1];
	const char *name, *kind;
	long flags, owner = -1, group = -1;

	if (n->nlmsg_type != RTM_NEWLINK && n->nlmsg_type != RTM_DELLINK)
		return 0;

	if (n->nlmsg_len < NLMSG_LENGTH(sizeof(*ifi)))
		return -1;

	switch (ifi->ifi_type) {
	case ARPHRD_NONE:
	case ARPHRD_ETHER:
		break;
	default:
		return 0;
	}

	parse_rtattr(tb, IFLA_MAX, IFLA_RTA(ifi), IFLA_PAYLOAD(n));

	if (!tb[IFLA_IFNAME])
		return 0;

	if (!tb[IFLA_LINKINFO])
		return 0;

	parse_rtattr_nested(linkinfo, IFLA_INFO_MAX, tb[IFLA_LINKINFO]);

	if (!linkinfo[IFLA_INFO_KIND])
		return 0;

	kind = rta_getattr_str(linkinfo[IFLA_INFO_KIND]);
	if (strcmp(kind, drv_name))
		return 0;

	name = rta_getattr_str(tb[IFLA_IFNAME]);

	if (read_prop(name, "tun_flags", &flags))
		return 0;
	if (read_prop(name, "owner", &owner))
		return 0;
	if (read_prop(name, "group", &group))
		return 0;

	open_json_object(NULL);
	print_color_string(PRINT_ANY, COLOR_IFNAME,
			   "ifname", "%s:", name);
	print_flags(flags);
	if (owner != -1)
		print_u64(PRINT_ANY, "user",
			   " user %ld", owner);
	if (group != -1)
		print_u64(PRINT_ANY, "group",
			   " group %ld", group);

	if (show_details) {
		print_string(PRINT_FP, NULL,
			     "%s\tAttached to processes:", _SL_);
		show_processes(name);
	}
	close_json_object();
	print_string(PRINT_FP, NULL, "%s", "\n");

	return 0;
}

static int do_show(int argc, char **argv)
{
	if (rtnl_linkdump_req_filter_fn(&rth, AF_UNSPEC,
					tuntap_filter_req) < 0) {
		perror("Cannot send dump request\n");
		return -1;
	}

	new_json_obj(json);

	if (rtnl_dump_filter(&rth, print_tuntap, NULL) < 0) {
		fprintf(stderr, "Dump terminated\n");
		return -1;
	}

	delete_json_obj();
	fflush(stdout);

	return 0;
}

int do_iptuntap(int argc, char **argv)
{
	if (argc > 0) {
		if (matches(*argv, "add") == 0)
			return do_add(argc-1, argv+1);
		if (matches(*argv, "delete") == 0)
			return do_del(argc-1, argv+1);
		if (matches(*argv, "show") == 0 ||
		    matches(*argv, "lst") == 0 ||
		    matches(*argv, "list") == 0)
			return do_show(argc-1, argv+1);
		if (matches(*argv, "help") == 0)
			usage();
	} else
		return do_show(0, NULL);

	fprintf(stderr, "Command \"%s\" is unknown, try \"ip tuntap help\".\n",
		*argv);
	exit(-1);
}

static void print_owner(FILE *f, uid_t uid)
{
	struct passwd *pw = getpwuid(uid);

	if (pw)
		print_string(PRINT_ANY, "user", "user %s ", pw->pw_name);
	else
		print_uint(PRINT_ANY, "user", "user %u ", uid);
}

static void print_group(FILE *f, gid_t gid)
{
	struct group *group = getgrgid(gid);

	if (group)
		print_string(PRINT_ANY, "group", "group %s ", group->gr_name);
	else
		print_uint(PRINT_ANY, "group", "group %u ", gid);
}

static void print_mq(FILE *f, struct rtattr *tb[])
{
	if (!tb[IFLA_TUN_MULTI_QUEUE] ||
	    !rta_getattr_u8(tb[IFLA_TUN_MULTI_QUEUE])) {
		if (is_json_context())
			print_bool(PRINT_JSON, "multi_queue", NULL, false);
		return;
	}

	print_bool(PRINT_ANY, "multi_queue", "multi_queue ", true);

	if (tb[IFLA_TUN_NUM_QUEUES]) {
		print_uint(PRINT_ANY, "numqueues", "numqueues %u ",
			   rta_getattr_u32(tb[IFLA_TUN_NUM_QUEUES]));
	}

	if (tb[IFLA_TUN_NUM_DISABLED_QUEUES]) {
		print_uint(PRINT_ANY, "numdisabled", "numdisabled %u ",
			   rta_getattr_u32(tb[IFLA_TUN_NUM_DISABLED_QUEUES]));
	}
}

static void print_type(FILE *f, __u8 type)
{
	SPRINT_BUF(buf);
	const char *str = buf;

	if (type == IFF_TUN)
		str = "tun";
	else if (type == IFF_TAP)
		str = "tap";
	else
		snprintf(buf, sizeof(buf), "UNKNOWN:%hhu", type);

	print_string(PRINT_ANY, "type", "type %s ", str);
}

static void tun_print_opt(struct link_util *lu, FILE *f, struct rtattr *tb[])
{
	if (!tb)
		return;

	if (tb[IFLA_TUN_TYPE])
		print_type(f, rta_getattr_u8(tb[IFLA_TUN_TYPE]));

	if (tb[IFLA_TUN_PI])
		print_on_off(PRINT_ANY, "pi", "pi %s ",
			     rta_getattr_u8(tb[IFLA_TUN_PI]));

	if (tb[IFLA_TUN_VNET_HDR]) {
		print_on_off(PRINT_ANY, "vnet_hdr", "vnet_hdr %s ",
			     rta_getattr_u8(tb[IFLA_TUN_VNET_HDR]));
	}

	print_mq(f, tb);

	if (tb[IFLA_TUN_PERSIST])
		print_on_off(PRINT_ANY, "persist", "persist %s ",
			     rta_getattr_u8(tb[IFLA_TUN_PERSIST]));

	if (tb[IFLA_TUN_OWNER])
		print_owner(f, rta_getattr_u32(tb[IFLA_TUN_OWNER]));

	if (tb[IFLA_TUN_GROUP])
		print_group(f, rta_getattr_u32(tb[IFLA_TUN_GROUP]));
}

struct link_util tun_link_util = {
	.id = "tun",
	.maxattr = IFLA_TUN_MAX,
	.print_opt = tun_print_opt,
};
Commit	Line	Data
580fbd88 DW	1	/*
	2	* iptunnel.c "ip tuntap"
	3	*
	4	* This program is free software; you can redistribute it and/or
	5	* modify it under the terms of the GNU General Public License
	6	* as published by the Free Software Foundation; either version
	7	* 2 of the License, or (at your option) any later version.
	8	*
	9	* Authors: David Woodhouse <David.Woodhouse@intel.com>
	10	*
	11	*/
	12
	13	#include <stdio.h>
	14	#include <stdlib.h>
	15	#include <string.h>
	16	#include <unistd.h>
	17	#include <sys/types.h>
	18	#include <sys/socket.h>
	19	#include <arpa/inet.h>
	20	#include <sys/ioctl.h>
	21	#include <linux/if.h>
	22	#include <linux/if_tun.h>
8960d45f	23	#include <linux/if_arp.h>
580fbd88 DW	24	#include <pwd.h>
	25	#include <grp.h>
	26	#include <fcntl.h>
	27	#include <dirent.h>
	28	#include <errno.h>
567e6960	29	#include <glob.h>
580fbd88 DW	30
	31	#include "rt_names.h"
	32	#include "utils.h"
	33	#include "ip_common.h"
	34
8960d45f SP	35	static const char drv_name[] = "tun";
8960d45f SP	36
580fbd88 DW	37	#define TUNDEV "/dev/net/tun"
	38
	39	static void usage(void) __attribute__((noreturn));
	40
	41	static void usage(void)
	42	{
8589eb4e MC	43	fprintf(stderr,
	44	"Usage: ip tuntap { add \| del \| show \| list \| lst \| help } [ dev PHYS_DEV ]\n"
	45	" [ mode { tun \| tap } ] [ user USER ] [ group GROUP ]\n"
	46	" [ one_queue ] [ pi ] [ vnet_hdr ] [ multi_queue ] [ name NAME ]\n"
	47	"\n"
	48	"Where: USER := { STRING \| NUMBER }\n"
	49	" GROUP := { STRING \| NUMBER }\n");
580fbd88 DW	50	exit(-1);
	51	}
	52
	53	static int tap_add_ioctl(struct ifreq *ifr, uid_t uid, gid_t gid)
	54	{
1313ceb4	55	int fd;
580fbd88 DW	56	int ret = -1;
	57
	58	#ifdef IFF_TUN_EXCL
	59	ifr->ifr_flags \|= IFF_TUN_EXCL;
	60	#endif
	61
	62	fd = open(TUNDEV, O_RDWR);
	63	if (fd < 0) {
	64	perror("open");
	65	return -1;
	66	}
	67	if (ioctl(fd, TUNSETIFF, ifr)) {
	68	perror("ioctl(TUNSETIFF)");
	69	goto out;
	70	}
	71	if (uid != -1 && ioctl(fd, TUNSETOWNER, uid)) {
	72	perror("ioctl(TUNSETOWNER)");
	73	goto out;
	74	}
	75	if (gid != -1 && ioctl(fd, TUNSETGROUP, gid)) {
	76	perror("ioctl(TUNSETGROUP)");
	77	goto out;
	78	}
	79	if (ioctl(fd, TUNSETPERSIST, 1)) {
	80	perror("ioctl(TUNSETPERSIST)");
	81	goto out;
	82	}
	83	ret = 0;
	84	out:
	85	close(fd);
	86	return ret;
	87	}
	88
	89	static int tap_del_ioctl(struct ifreq *ifr)
	90	{
	91	int fd = open(TUNDEV, O_RDWR);
	92	int ret = -1;
	93
	94	if (fd < 0) {
	95	perror("open");
	96	return -1;
	97	}
	98	if (ioctl(fd, TUNSETIFF, ifr)) {
	99	perror("ioctl(TUNSETIFF)");
	100	goto out;
	101	}
	102	if (ioctl(fd, TUNSETPERSIST, 0)) {
	103	perror("ioctl(TUNSETPERSIST)");
	104	goto out;
	105	}
	106	ret = 0;
	107	out:
	108	close(fd);
	109	return ret;
	110
	111	}
cc28aad1 SH	112	static int parse_args(int argc, char **argv,
cc28aad1 SH	113	struct ifreq ifr, uid_t uid, gid_t *gid)
580fbd88 DW	114	{
	115	int count = 0;
	116
	117	memset(ifr, 0, sizeof(*ifr));
	118
	119	ifr->ifr_flags \|= IFF_NO_PI;
	120
	121	while (argc > 0) {
	122	if (matches(*argv, "mode") == 0) {
	123	NEXT_ARG();
	124	if (matches(*argv, "tun") == 0) {
	125	if (ifr->ifr_flags & IFF_TAP) {
56f5daac	126	fprintf(stderr, "You managed to ask for more than one tunnel mode.\n");
580fbd88 DW	127	exit(-1);
	128	}
	129	ifr->ifr_flags \|= IFF_TUN;
	130	} else if (matches(*argv, "tap") == 0) {
	131	if (ifr->ifr_flags & IFF_TUN) {
56f5daac	132	fprintf(stderr, "You managed to ask for more than one tunnel mode.\n");
580fbd88 DW	133	exit(-1);
	134	}
	135	ifr->ifr_flags \|= IFF_TAP;
	136	} else {
56f5daac	137	fprintf(stderr, "Unknown tunnel mode \"%s\"\n", *argv);
580fbd88 DW	138	exit(-1);
	139	}
	140	} else if (uid && matches(*argv, "user") == 0) {
	141	char *end;
	142	unsigned long user;
	143
	144	NEXT_ARG();
	145	if (*argv && ((user = strtol(argv, &end, 10)), !*end))
	146	*uid = user;
	147	else {
	148	struct passwd pw = getpwnam(argv);
56f5daac	149
580fbd88 DW	150	if (!pw) {
	151	fprintf(stderr, "invalid user \"%s\"\n", *argv);
	152	exit(-1);
	153	}
	154	*uid = pw->pw_uid;
	155	}
	156	} else if (gid && matches(*argv, "group") == 0) {
	157	char *end;
	158	unsigned long group;
	159
	160	NEXT_ARG();
	161
	162	if (*argv && ((group = strtol(argv, &end, 10)), !*end))
	163	*gid = group;
	164	else {
	165	struct group gr = getgrnam(argv);
56f5daac	166
580fbd88 DW	167	if (!gr) {
	168	fprintf(stderr, "invalid group \"%s\"\n", *argv);
	169	exit(-1);
	170	}
	171	*gid = gr->gr_gid;
	172	}
	173	} else if (matches(*argv, "pi") == 0) {
	174	ifr->ifr_flags &= ~IFF_NO_PI;
	175	} else if (matches(*argv, "one_queue") == 0) {
	176	ifr->ifr_flags \|= IFF_ONE_QUEUE;
	177	} else if (matches(*argv, "vnet_hdr") == 0) {
	178	ifr->ifr_flags \|= IFF_VNET_HDR;
c41e038f SN	179	} else if (matches(*argv, "multi_queue") == 0) {
c41e038f SN	180	ifr->ifr_flags \|= IFF_MULTI_QUEUE;
580fbd88 DW	181	} else if (matches(*argv, "dev") == 0) {
580fbd88 DW	182	NEXT_ARG();
625df645 PS	183	if (get_ifname(ifr->ifr_name, *argv))
625df645 PS	184	invarg("\"dev\" not a valid ifname", *argv);
580fbd88 DW	185	} else {
	186	if (matches(*argv, "name") == 0) {
	187	NEXT_ARG();
	188	} else if (matches(*argv, "help") == 0)
	189	usage();
	190	if (ifr->ifr_name[0])
	191	duparg2("name", *argv);
625df645 PS	192	if (get_ifname(ifr->ifr_name, *argv))
625df645 PS	193	invarg("\"name\" not a valid ifname", *argv);
580fbd88 DW	194	}
	195	count++;
	196	argc--; argv++;
	197	}
	198
f1a505ac	199	if (!(ifr->ifr_flags & TUN_TYPE_MASK)) {
	200	fprintf(stderr, "You failed to specify a tunnel mode\n");
	201	return -1;
	202	}
	203
580fbd88 DW	204	return 0;
	205	}
	206
	207
	208	static int do_add(int argc, char **argv)
	209	{
	210	struct ifreq ifr;
	211	uid_t uid = -1;
	212	gid_t gid = -1;
	213
	214	if (parse_args(argc, argv, &ifr, &uid, &gid) < 0)
	215	return -1;
	216
580fbd88 DW	217	return tap_add_ioctl(&ifr, uid, gid);
	218	}
	219
	220	static int do_del(int argc, char **argv)
	221	{
	222	struct ifreq ifr;
	223
	224	if (parse_args(argc, argv, &ifr, NULL, NULL) < 0)
	225	return -1;
	226
	227	return tap_del_ioctl(&ifr);
	228	}
	229
580fbd88 DW	230	static void print_flags(long flags)
580fbd88 DW	231	{
689bef5d SH	232	open_json_array(PRINT_JSON, "flags");
689bef5d SH	233
580fbd88	234	if (flags & IFF_TUN)
689bef5d	235	print_string(PRINT_ANY, NULL, " %s", "tun");
580fbd88 DW	236
580fbd88 DW	237	if (flags & IFF_TAP)
689bef5d	238	print_string(PRINT_ANY, NULL, " %s", "tap");
580fbd88 DW	239
580fbd88 DW	240	if (!(flags & IFF_NO_PI))
689bef5d	241	print_string(PRINT_ANY, NULL, " %s", "pi");
580fbd88 DW	242
580fbd88 DW	243	if (flags & IFF_ONE_QUEUE)
689bef5d	244	print_string(PRINT_ANY, NULL, " %s", "one_queue");
580fbd88 DW	245
580fbd88 DW	246	if (flags & IFF_VNET_HDR)
689bef5d SH	247	print_string(PRINT_ANY, NULL, " %s", "vnet_hdr");
	248
	249	if (flags & IFF_PERSIST)
	250	print_string(PRINT_ANY, NULL, " %s", "persist");
	251
	252	if (!(flags & IFF_NOFILTER))
	253	print_string(PRINT_ANY, NULL, " %s", "filter");
580fbd88	254
689bef5d SH	255	flags &= ~(IFF_TUN \| IFF_TAP \| IFF_NO_PI \| IFF_ONE_QUEUE \|
689bef5d SH	256	IFF_VNET_HDR \| IFF_PERSIST \| IFF_NOFILTER);
580fbd88	257	if (flags)
90c5c969	258	print_0xhex(PRINT_ANY, NULL, "%#llx", flags);
689bef5d SH	259
689bef5d SH	260	close_json_array(PRINT_JSON, NULL);
580fbd88 DW	261	}
580fbd88 DW	262
567e6960 HFS	263	static char *pid_name(pid_t pid)
	264	{
	265	char *comm;
	266	FILE *f;
	267	int err;
	268
	269	err = asprintf(&comm, "/proc/%d/comm", pid);
	270	if (err < 0)
	271	return NULL;
	272
	273	f = fopen(comm, "r");
	274	free(comm);
	275	if (!f) {
	276	perror("fopen");
	277	return NULL;
	278	}
	279
	280	if (fscanf(f, "%ms\n", &comm) != 1) {
	281	perror("fscanf");
	282	comm = NULL;
	283	}
	284
	285
	286	if (fclose(f))
	287	perror("fclose");
	288
	289	return comm;
	290	}
	291
	292	static void show_processes(const char *name)
	293	{
	294	glob_t globbuf = { };
	295	char **fd_path;
	296	int err;
	297
	298	err = glob("/proc/[0-9]/fd/[0-9]", GLOB_NOSORT,
	299	NULL, &globbuf);
	300	if (err)
	301	return;
	302
689bef5d SH	303	open_json_array(PRINT_JSON, "processes");
689bef5d SH	304
567e6960 HFS	305	fd_path = globbuf.gl_pathv;
	306	while (*fd_path) {
	307	const char *dev_net_tun = "/dev/net/tun";
	308	const size_t linkbuf_len = strlen(dev_net_tun) + 2;
	309	char linkbuf[linkbuf_len], *fdinfo;
	310	int pid, fd;
	311	FILE *f;
	312
	313	if (sscanf(*fd_path, "/proc/%d/fd/%d", &pid, &fd) != 2)
	314	goto next;
	315
	316	if (pid == getpid())
	317	goto next;
	318
	319	err = readlink(*fd_path, linkbuf, linkbuf_len - 1);
	320	if (err < 0) {
	321	perror("readlink");
	322	goto next;
	323	}
	324	linkbuf[err] = '\0';
	325	if (strcmp(dev_net_tun, linkbuf))
	326	goto next;
	327
	328	if (asprintf(&fdinfo, "/proc/%d/fdinfo/%d", pid, fd) < 0)
	329	goto next;
	330
	331	f = fopen(fdinfo, "r");
	332	free(fdinfo);
	333	if (!f) {
	334	perror("fopen");
	335	goto next;
	336	}
	337
	338	while (!feof(f)) {
	339	char key = NULL, value = NULL;
	340
	341	err = fscanf(f, "%m[^:]: %ms\n", &key, &value);
	342	if (err == EOF) {
	343	if (ferror(f))
	344	perror("fscanf");
	345	break;
	346	} else if (err == 2 &&
cc28aad1 SH	347	!strcmp("iff", key) &&
cc28aad1 SH	348	!strcmp(name, value)) {
567e6960	349	char *pname = pid_name(pid);
cc28aad1	350
689bef5d SH	351	print_string(PRINT_ANY, "name",
	352	"%s", pname ? : "<NULL>");
	353
	354	print_uint(PRINT_ANY, "pid",
	355	"(%d)", pid);
567e6960 HFS	356	free(pname);
	357	}
	358
	359	free(key);
	360	free(value);
	361	}
	362	if (fclose(f))
	363	perror("fclose");
	364
	365	next:
	366	++fd_path;
	367	}
689bef5d	368	close_json_array(PRINT_JSON, NULL);
567e6960 HFS	369
567e6960 HFS	370	globfree(&globbuf);
567e6960 HFS	371	}
567e6960 HFS	372
8960d45f SP	373	static int tuntap_filter_req(struct nlmsghdr *nlh, int reqlen)
	374	{
	375	struct rtattr *linkinfo;
	376	int err;
567e6960	377
8960d45f SP	378	linkinfo = addattr_nest(nlh, reqlen, IFLA_LINKINFO);
	379
	380	err = addattr_l(nlh, reqlen, IFLA_INFO_KIND,
	381	drv_name, sizeof(drv_name) - 1);
	382	if (err)
	383	return err;
	384
	385	addattr_nest_end(nlh, linkinfo);
	386
	387	return 0;
	388	}
	389
cd554f2c	390	static int print_tuntap(struct nlmsghdr n, void arg)
580fbd88	391	{
8960d45f SP	392	struct ifinfomsg *ifi = NLMSG_DATA(n);
	393	struct rtattr *tb[IFLA_MAX+1];
	394	struct rtattr *linkinfo[IFLA_INFO_MAX+1];
	395	const char name, kind;
580fbd88 DW	396	long flags, owner = -1, group = -1;
580fbd88 DW	397
8960d45f SP	398	if (n->nlmsg_type != RTM_NEWLINK && n->nlmsg_type != RTM_DELLINK)
	399	return 0;
	400
	401	if (n->nlmsg_len < NLMSG_LENGTH(sizeof(*ifi)))
580fbd88	402	return -1;
8960d45f SP	403
	404	switch (ifi->ifi_type) {
	405	case ARPHRD_NONE:
	406	case ARPHRD_ETHER:
	407	break;
	408	default:
	409	return 0;
580fbd88	410	}
8960d45f SP	411
	412	parse_rtattr(tb, IFLA_MAX, IFLA_RTA(ifi), IFLA_PAYLOAD(n));
	413
	414	if (!tb[IFLA_IFNAME])
	415	return 0;
	416
	417	if (!tb[IFLA_LINKINFO])
	418	return 0;
	419
	420	parse_rtattr_nested(linkinfo, IFLA_INFO_MAX, tb[IFLA_LINKINFO]);
	421
	422	if (!linkinfo[IFLA_INFO_KIND])
	423	return 0;
	424
	425	kind = rta_getattr_str(linkinfo[IFLA_INFO_KIND]);
	426	if (strcmp(kind, drv_name))
	427	return 0;
	428
	429	name = rta_getattr_str(tb[IFLA_IFNAME]);
	430
	431	if (read_prop(name, "tun_flags", &flags))
	432	return 0;
	433	if (read_prop(name, "owner", &owner))
	434	return 0;
	435	if (read_prop(name, "group", &group))
	436	return 0;
	437
689bef5d SH	438	open_json_object(NULL);
	439	print_color_string(PRINT_ANY, COLOR_IFNAME,
	440	"ifname", "%s:", name);
8960d45f SP	441	print_flags(flags);
8960d45f SP	442	if (owner != -1)
4db2ff0d	443	print_u64(PRINT_ANY, "user",
689bef5d	444	" user %ld", owner);
8960d45f	445	if (group != -1)
4db2ff0d	446	print_u64(PRINT_ANY, "group",
689bef5d SH	447	" group %ld", group);
689bef5d SH	448
8960d45f	449	if (show_details) {
689bef5d SH	450	print_string(PRINT_FP, NULL,
689bef5d SH	451	"%s\tAttached to processes:", _SL_);
8960d45f	452	show_processes(name);
580fbd88	453	}
689bef5d SH	454	close_json_object();
689bef5d SH	455	print_string(PRINT_FP, NULL, "%s", "\n");
8960d45f SP	456
	457	return 0;
	458	}
	459
	460	static int do_show(int argc, char **argv)
	461	{
31ae2912	462	if (rtnl_linkdump_req_filter_fn(&rth, AF_UNSPEC,
8960d45f SP	463	tuntap_filter_req) < 0) {
	464	perror("Cannot send dump request\n");
	465	return -1;
	466	}
	467
689bef5d SH	468	new_json_obj(json);
689bef5d SH	469
8960d45f SP	470	if (rtnl_dump_filter(&rth, print_tuntap, NULL) < 0) {
	471	fprintf(stderr, "Dump terminated\n");
	472	return -1;
	473	}
	474
689bef5d SH	475	delete_json_obj();
	476	fflush(stdout);
	477
580fbd88 DW	478	return 0;
	479	}
	480
	481	int do_iptuntap(int argc, char **argv)
	482	{
	483	if (argc > 0) {
	484	if (matches(*argv, "add") == 0)
	485	return do_add(argc-1, argv+1);
6e30461e	486	if (matches(*argv, "delete") == 0)
580fbd88 DW	487	return do_del(argc-1, argv+1);
580fbd88 DW	488	if (matches(*argv, "show") == 0 \|\|
56f5daac SH	489	matches(*argv, "lst") == 0 \|\|
	490	matches(*argv, "list") == 0)
	491	return do_show(argc-1, argv+1);
580fbd88 DW	492	if (matches(*argv, "help") == 0)
	493	usage();
	494	} else
	495	return do_show(0, NULL);
	496
	497	fprintf(stderr, "Command \"%s\" is unknown, try \"ip tuntap help\".\n",
	498	*argv);
	499	exit(-1);
	500	}
118eda77 SD	501
	502	static void print_owner(FILE *f, uid_t uid)
	503	{
	504	struct passwd *pw = getpwuid(uid);
	505
	506	if (pw)
7ba0a77b	507	print_string(PRINT_ANY, "user", "user %s ", pw->pw_name);
118eda77	508	else
7ba0a77b	509	print_uint(PRINT_ANY, "user", "user %u ", uid);
118eda77 SD	510	}
	511
	512	static void print_group(FILE *f, gid_t gid)
	513	{
	514	struct group *group = getgrgid(gid);
	515
	516	if (group)
7ba0a77b	517	print_string(PRINT_ANY, "group", "group %s ", group->gr_name);
118eda77	518	else
7ba0a77b	519	print_uint(PRINT_ANY, "group", "group %u ", gid);
118eda77 SD	520	}
	521
	522	static void print_mq(FILE f, struct rtattr tb[])
	523	{
	524	if (!tb[IFLA_TUN_MULTI_QUEUE] \|\|
7ba0a77b SD	525	!rta_getattr_u8(tb[IFLA_TUN_MULTI_QUEUE])) {
	526	if (is_json_context())
	527	print_bool(PRINT_JSON, "multi_queue", NULL, false);
118eda77	528	return;
7ba0a77b	529	}
118eda77	530
7ba0a77b	531	print_bool(PRINT_ANY, "multi_queue", "multi_queue ", true);
118eda77 SD	532
118eda77 SD	533	if (tb[IFLA_TUN_NUM_QUEUES]) {
7ba0a77b SD	534	print_uint(PRINT_ANY, "numqueues", "numqueues %u ",
7ba0a77b SD	535	rta_getattr_u32(tb[IFLA_TUN_NUM_QUEUES]));
118eda77 SD	536	}
	537
	538	if (tb[IFLA_TUN_NUM_DISABLED_QUEUES]) {
7ba0a77b SD	539	print_uint(PRINT_ANY, "numdisabled", "numdisabled %u ",
7ba0a77b SD	540	rta_getattr_u32(tb[IFLA_TUN_NUM_DISABLED_QUEUES]));
118eda77 SD	541	}
	542	}
	543
7ba0a77b SD	544	static void print_type(FILE *f, __u8 type)
	545	{
	546	SPRINT_BUF(buf);
	547	const char *str = buf;
	548
	549	if (type == IFF_TUN)
	550	str = "tun";
	551	else if (type == IFF_TAP)
	552	str = "tap";
	553	else
	554	snprintf(buf, sizeof(buf), "UNKNOWN:%hhu", type);
	555
	556	print_string(PRINT_ANY, "type", "type %s ", str);
118eda77 SD	557	}
	558
	559	static void tun_print_opt(struct link_util lu, FILE f, struct rtattr *tb[])
	560	{
	561	if (!tb)
	562	return;
	563
7ba0a77b SD	564	if (tb[IFLA_TUN_TYPE])
7ba0a77b SD	565	print_type(f, rta_getattr_u8(tb[IFLA_TUN_TYPE]));
118eda77 SD	566
118eda77 SD	567	if (tb[IFLA_TUN_PI])
ca5ec9a1 PM	568	print_on_off(PRINT_ANY, "pi", "pi %s ",
ca5ec9a1 PM	569	rta_getattr_u8(tb[IFLA_TUN_PI]));
118eda77 SD	570
118eda77 SD	571	if (tb[IFLA_TUN_VNET_HDR]) {
ca5ec9a1 PM	572	print_on_off(PRINT_ANY, "vnet_hdr", "vnet_hdr %s ",
ca5ec9a1 PM	573	rta_getattr_u8(tb[IFLA_TUN_VNET_HDR]));
118eda77 SD	574	}
	575
	576	print_mq(f, tb);
	577
	578	if (tb[IFLA_TUN_PERSIST])
ca5ec9a1 PM	579	print_on_off(PRINT_ANY, "persist", "persist %s ",
ca5ec9a1 PM	580	rta_getattr_u8(tb[IFLA_TUN_PERSIST]));
118eda77 SD	581
	582	if (tb[IFLA_TUN_OWNER])
	583	print_owner(f, rta_getattr_u32(tb[IFLA_TUN_OWNER]));
	584
	585	if (tb[IFLA_TUN_GROUP])
	586	print_group(f, rta_getattr_u32(tb[IFLA_TUN_GROUP]));
	587	}
	588
	589	struct link_util tun_link_util = {
	590	.id = "tun",
	591	.maxattr = IFLA_TUN_MAX,
	592	.print_opt = tun_print_opt,
	593	};