[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");
	fprintf(stderr, "          [ mode { tun | tap } ] [ user USER ] [ group GROUP ]\n");
	fprintf(stderr, "          [ one_queue ] [ pi ] [ vnet_hdr ] [ multi_queue ] [ name NAME ]\n");
	fprintf(stderr, "\n");
	fprintf(stderr, "Where: USER  := { STRING | NUMBER }\n");
	fprintf(stderr, "       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, "%#x", 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(const struct sockaddr_nl *who,
			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_onoff(FILE *f, const char *flag, __u8 val)
{
	if (is_json_context())
		print_bool(PRINT_JSON, flag, NULL, !!val);
	else
		fprintf(f, "%s %s ", flag, val ? "on" : "off");
}

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_onoff(f, "pi", rta_getattr_u8(tb[IFLA_TUN_PI]));

	if (tb[IFLA_TUN_VNET_HDR]) {
		print_onoff(f, "vnet_hdr",
			    rta_getattr_u8(tb[IFLA_TUN_VNET_HDR]));
	}

	print_mq(f, tb);

	if (tb[IFLA_TUN_PERSIST])
		print_onoff(f, "persist", 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	{
56f5daac	43	fprintf(stderr, "Usage: ip tuntap { add \| del \| show \| list \| lst \| help } [ dev PHYS_DEV ]\n");
580fbd88	44	fprintf(stderr, " [ mode { tun \| tap } ] [ user USER ] [ group GROUP ]\n");
113fab78	45	fprintf(stderr, " [ one_queue ] [ pi ] [ vnet_hdr ] [ multi_queue ] [ name NAME ]\n");
580fbd88 DW	46	fprintf(stderr, "\n");
	47	fprintf(stderr, "Where: USER := { STRING \| NUMBER }\n");
	48	fprintf(stderr, " GROUP := { STRING \| NUMBER }\n");
	49	exit(-1);
	50	}
	51
	52	static int tap_add_ioctl(struct ifreq *ifr, uid_t uid, gid_t gid)
	53	{
1313ceb4	54	int fd;
580fbd88 DW	55	int ret = -1;
	56
	57	#ifdef IFF_TUN_EXCL
	58	ifr->ifr_flags \|= IFF_TUN_EXCL;
	59	#endif
	60
	61	fd = open(TUNDEV, O_RDWR);
	62	if (fd < 0) {
	63	perror("open");
	64	return -1;
	65	}
	66	if (ioctl(fd, TUNSETIFF, ifr)) {
	67	perror("ioctl(TUNSETIFF)");
	68	goto out;
	69	}
	70	if (uid != -1 && ioctl(fd, TUNSETOWNER, uid)) {
	71	perror("ioctl(TUNSETOWNER)");
	72	goto out;
	73	}
	74	if (gid != -1 && ioctl(fd, TUNSETGROUP, gid)) {
	75	perror("ioctl(TUNSETGROUP)");
	76	goto out;
	77	}
	78	if (ioctl(fd, TUNSETPERSIST, 1)) {
	79	perror("ioctl(TUNSETPERSIST)");
	80	goto out;
	81	}
	82	ret = 0;
	83	out:
	84	close(fd);
	85	return ret;
	86	}
	87
	88	static int tap_del_ioctl(struct ifreq *ifr)
	89	{
	90	int fd = open(TUNDEV, O_RDWR);
	91	int ret = -1;
	92
	93	if (fd < 0) {
	94	perror("open");
	95	return -1;
	96	}
	97	if (ioctl(fd, TUNSETIFF, ifr)) {
	98	perror("ioctl(TUNSETIFF)");
	99	goto out;
	100	}
	101	if (ioctl(fd, TUNSETPERSIST, 0)) {
	102	perror("ioctl(TUNSETPERSIST)");
	103	goto out;
	104	}
	105	ret = 0;
	106	out:
	107	close(fd);
	108	return ret;
	109
	110	}
cc28aad1 SH	111	static int parse_args(int argc, char **argv,
cc28aad1 SH	112	struct ifreq ifr, uid_t uid, gid_t *gid)
580fbd88 DW	113	{
	114	int count = 0;
	115
	116	memset(ifr, 0, sizeof(*ifr));
	117
	118	ifr->ifr_flags \|= IFF_NO_PI;
	119
	120	while (argc > 0) {
	121	if (matches(*argv, "mode") == 0) {
	122	NEXT_ARG();
	123	if (matches(*argv, "tun") == 0) {
	124	if (ifr->ifr_flags & IFF_TAP) {
56f5daac	125	fprintf(stderr, "You managed to ask for more than one tunnel mode.\n");
580fbd88 DW	126	exit(-1);
	127	}
	128	ifr->ifr_flags \|= IFF_TUN;
	129	} else if (matches(*argv, "tap") == 0) {
	130	if (ifr->ifr_flags & IFF_TUN) {
56f5daac	131	fprintf(stderr, "You managed to ask for more than one tunnel mode.\n");
580fbd88 DW	132	exit(-1);
	133	}
	134	ifr->ifr_flags \|= IFF_TAP;
	135	} else {
56f5daac	136	fprintf(stderr, "Unknown tunnel mode \"%s\"\n", *argv);
580fbd88 DW	137	exit(-1);
	138	}
	139	} else if (uid && matches(*argv, "user") == 0) {
	140	char *end;
	141	unsigned long user;
	142
	143	NEXT_ARG();
	144	if (*argv && ((user = strtol(argv, &end, 10)), !*end))
	145	*uid = user;
	146	else {
	147	struct passwd pw = getpwnam(argv);
56f5daac	148
580fbd88 DW	149	if (!pw) {
	150	fprintf(stderr, "invalid user \"%s\"\n", *argv);
	151	exit(-1);
	152	}
	153	*uid = pw->pw_uid;
	154	}
	155	} else if (gid && matches(*argv, "group") == 0) {
	156	char *end;
	157	unsigned long group;
	158
	159	NEXT_ARG();
	160
	161	if (*argv && ((group = strtol(argv, &end, 10)), !*end))
	162	*gid = group;
	163	else {
	164	struct group gr = getgrnam(argv);
56f5daac	165
580fbd88 DW	166	if (!gr) {
	167	fprintf(stderr, "invalid group \"%s\"\n", *argv);
	168	exit(-1);
	169	}
	170	*gid = gr->gr_gid;
	171	}
	172	} else if (matches(*argv, "pi") == 0) {
	173	ifr->ifr_flags &= ~IFF_NO_PI;
	174	} else if (matches(*argv, "one_queue") == 0) {
	175	ifr->ifr_flags \|= IFF_ONE_QUEUE;
	176	} else if (matches(*argv, "vnet_hdr") == 0) {
	177	ifr->ifr_flags \|= IFF_VNET_HDR;
c41e038f SN	178	} else if (matches(*argv, "multi_queue") == 0) {
c41e038f SN	179	ifr->ifr_flags \|= IFF_MULTI_QUEUE;
580fbd88 DW	180	} else if (matches(*argv, "dev") == 0) {
580fbd88 DW	181	NEXT_ARG();
625df645 PS	182	if (get_ifname(ifr->ifr_name, *argv))
625df645 PS	183	invarg("\"dev\" not a valid ifname", *argv);
580fbd88 DW	184	} else {
	185	if (matches(*argv, "name") == 0) {
	186	NEXT_ARG();
	187	} else if (matches(*argv, "help") == 0)
	188	usage();
	189	if (ifr->ifr_name[0])
	190	duparg2("name", *argv);
625df645 PS	191	if (get_ifname(ifr->ifr_name, *argv))
625df645 PS	192	invarg("\"name\" not a valid ifname", *argv);
580fbd88 DW	193	}
	194	count++;
	195	argc--; argv++;
	196	}
	197
f1a505ac	198	if (!(ifr->ifr_flags & TUN_TYPE_MASK)) {
	199	fprintf(stderr, "You failed to specify a tunnel mode\n");
	200	return -1;
	201	}
	202
580fbd88 DW	203	return 0;
	204	}
	205
	206
	207	static int do_add(int argc, char **argv)
	208	{
	209	struct ifreq ifr;
	210	uid_t uid = -1;
	211	gid_t gid = -1;
	212
	213	if (parse_args(argc, argv, &ifr, &uid, &gid) < 0)
	214	return -1;
	215
580fbd88 DW	216	return tap_add_ioctl(&ifr, uid, gid);
	217	}
	218
	219	static int do_del(int argc, char **argv)
	220	{
	221	struct ifreq ifr;
	222
	223	if (parse_args(argc, argv, &ifr, NULL, NULL) < 0)
	224	return -1;
	225
	226	return tap_del_ioctl(&ifr);
	227	}
	228
580fbd88 DW	229	static void print_flags(long flags)
580fbd88 DW	230	{
689bef5d SH	231	open_json_array(PRINT_JSON, "flags");
689bef5d SH	232
580fbd88	233	if (flags & IFF_TUN)
689bef5d	234	print_string(PRINT_ANY, NULL, " %s", "tun");
580fbd88 DW	235
580fbd88 DW	236	if (flags & IFF_TAP)
689bef5d	237	print_string(PRINT_ANY, NULL, " %s", "tap");
580fbd88 DW	238
580fbd88 DW	239	if (!(flags & IFF_NO_PI))
689bef5d	240	print_string(PRINT_ANY, NULL, " %s", "pi");
580fbd88 DW	241
580fbd88 DW	242	if (flags & IFF_ONE_QUEUE)
689bef5d	243	print_string(PRINT_ANY, NULL, " %s", "one_queue");
580fbd88 DW	244
580fbd88 DW	245	if (flags & IFF_VNET_HDR)
689bef5d SH	246	print_string(PRINT_ANY, NULL, " %s", "vnet_hdr");
	247
	248	if (flags & IFF_PERSIST)
	249	print_string(PRINT_ANY, NULL, " %s", "persist");
	250
	251	if (!(flags & IFF_NOFILTER))
	252	print_string(PRINT_ANY, NULL, " %s", "filter");
580fbd88	253
689bef5d SH	254	flags &= ~(IFF_TUN \| IFF_TAP \| IFF_NO_PI \| IFF_ONE_QUEUE \|
689bef5d SH	255	IFF_VNET_HDR \| IFF_PERSIST \| IFF_NOFILTER);
580fbd88	256	if (flags)
689bef5d SH	257	print_0xhex(PRINT_ANY, NULL, "%#x", flags);
	258
	259	close_json_array(PRINT_JSON, NULL);
580fbd88 DW	260	}
580fbd88 DW	261
567e6960 HFS	262	static char *pid_name(pid_t pid)
	263	{
	264	char *comm;
	265	FILE *f;
	266	int err;
	267
	268	err = asprintf(&comm, "/proc/%d/comm", pid);
	269	if (err < 0)
	270	return NULL;
	271
	272	f = fopen(comm, "r");
	273	free(comm);
	274	if (!f) {
	275	perror("fopen");
	276	return NULL;
	277	}
	278
	279	if (fscanf(f, "%ms\n", &comm) != 1) {
	280	perror("fscanf");
	281	comm = NULL;
	282	}
	283
	284
	285	if (fclose(f))
	286	perror("fclose");
	287
	288	return comm;
	289	}
	290
	291	static void show_processes(const char *name)
	292	{
	293	glob_t globbuf = { };
	294	char **fd_path;
	295	int err;
	296
	297	err = glob("/proc/[0-9]/fd/[0-9]", GLOB_NOSORT,
	298	NULL, &globbuf);
	299	if (err)
	300	return;
	301
689bef5d SH	302	open_json_array(PRINT_JSON, "processes");
689bef5d SH	303
567e6960 HFS	304	fd_path = globbuf.gl_pathv;
	305	while (*fd_path) {
	306	const char *dev_net_tun = "/dev/net/tun";
	307	const size_t linkbuf_len = strlen(dev_net_tun) + 2;
	308	char linkbuf[linkbuf_len], *fdinfo;
	309	int pid, fd;
	310	FILE *f;
	311
	312	if (sscanf(*fd_path, "/proc/%d/fd/%d", &pid, &fd) != 2)
	313	goto next;
	314
	315	if (pid == getpid())
	316	goto next;
	317
	318	err = readlink(*fd_path, linkbuf, linkbuf_len - 1);
	319	if (err < 0) {
	320	perror("readlink");
	321	goto next;
	322	}
	323	linkbuf[err] = '\0';
	324	if (strcmp(dev_net_tun, linkbuf))
	325	goto next;
	326
	327	if (asprintf(&fdinfo, "/proc/%d/fdinfo/%d", pid, fd) < 0)
	328	goto next;
	329
	330	f = fopen(fdinfo, "r");
	331	free(fdinfo);
	332	if (!f) {
	333	perror("fopen");
	334	goto next;
	335	}
	336
	337	while (!feof(f)) {
	338	char key = NULL, value = NULL;
	339
	340	err = fscanf(f, "%m[^:]: %ms\n", &key, &value);
	341	if (err == EOF) {
	342	if (ferror(f))
	343	perror("fscanf");
	344	break;
	345	} else if (err == 2 &&
cc28aad1 SH	346	!strcmp("iff", key) &&
cc28aad1 SH	347	!strcmp(name, value)) {
567e6960	348	char *pname = pid_name(pid);
cc28aad1	349
689bef5d SH	350	print_string(PRINT_ANY, "name",
	351	"%s", pname ? : "<NULL>");
	352
	353	print_uint(PRINT_ANY, "pid",
	354	"(%d)", pid);
567e6960 HFS	355	free(pname);
	356	}
	357
	358	free(key);
	359	free(value);
	360	}
	361	if (fclose(f))
	362	perror("fclose");
	363
	364	next:
	365	++fd_path;
	366	}
689bef5d	367	close_json_array(PRINT_JSON, NULL);
567e6960 HFS	368
567e6960 HFS	369	globfree(&globbuf);
567e6960 HFS	370	}
567e6960 HFS	371
8960d45f SP	372	static int tuntap_filter_req(struct nlmsghdr *nlh, int reqlen)
	373	{
	374	struct rtattr *linkinfo;
	375	int err;
567e6960	376
8960d45f SP	377	linkinfo = addattr_nest(nlh, reqlen, IFLA_LINKINFO);
	378
	379	err = addattr_l(nlh, reqlen, IFLA_INFO_KIND,
	380	drv_name, sizeof(drv_name) - 1);
	381	if (err)
	382	return err;
	383
	384	addattr_nest_end(nlh, linkinfo);
	385
	386	return 0;
	387	}
	388
	389	static int print_tuntap(const struct sockaddr_nl *who,
	390	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
	544	static void print_onoff(FILE f, const char flag, __u8 val)
	545	{
7ba0a77b SD	546	if (is_json_context())
	547	print_bool(PRINT_JSON, flag, NULL, !!val);
	548	else
	549	fprintf(f, "%s %s ", flag, val ? "on" : "off");
	550	}
	551
	552	static void print_type(FILE *f, __u8 type)
	553	{
	554	SPRINT_BUF(buf);
	555	const char *str = buf;
	556
	557	if (type == IFF_TUN)
	558	str = "tun";
	559	else if (type == IFF_TAP)
	560	str = "tap";
	561	else
	562	snprintf(buf, sizeof(buf), "UNKNOWN:%hhu", type);
	563
	564	print_string(PRINT_ANY, "type", "type %s ", str);
118eda77 SD	565	}
	566
	567	static void tun_print_opt(struct link_util lu, FILE f, struct rtattr *tb[])
	568	{
	569	if (!tb)
	570	return;
	571
7ba0a77b SD	572	if (tb[IFLA_TUN_TYPE])
7ba0a77b SD	573	print_type(f, rta_getattr_u8(tb[IFLA_TUN_TYPE]));
118eda77 SD	574
	575	if (tb[IFLA_TUN_PI])
	576	print_onoff(f, "pi", rta_getattr_u8(tb[IFLA_TUN_PI]));
	577
	578	if (tb[IFLA_TUN_VNET_HDR]) {
	579	print_onoff(f, "vnet_hdr",
	580	rta_getattr_u8(tb[IFLA_TUN_VNET_HDR]));
	581	}
	582
	583	print_mq(f, tb);
	584
	585	if (tb[IFLA_TUN_PERSIST])
	586	print_onoff(f, "persist", rta_getattr_u8(tb[IFLA_TUN_PERSIST]));
	587
	588	if (tb[IFLA_TUN_OWNER])
	589	print_owner(f, rta_getattr_u32(tb[IFLA_TUN_OWNER]));
	590
	591	if (tb[IFLA_TUN_GROUP])
	592	print_group(f, rta_getattr_u32(tb[IFLA_TUN_GROUP]));
	593	}
	594
	595	struct link_util tun_link_util = {
	596	.id = "tun",
	597	.maxattr = IFLA_TUN_MAX,
	598	.print_opt = tun_print_opt,
	599	};