[qemu.git] / qemu-bridge-helper.c

/*
 * QEMU Bridge Helper
 *
 * Copyright IBM, Corp. 2011
 *
 * Authors:
 * Anthony Liguori   <[email protected]>
 * Richa Marwaha     <[email protected]>
 * Corey Bryant      <[email protected]>
 *
 * This work is licensed under the terms of the GNU GPL, version 2.  See
 * the COPYING file in the top-level directory.
 */

/*
 * Known shortcomings:
 * - There is no manual page
 * - The syntax of the ACL file is not documented anywhere
 * - parse_acl_file() doesn't report fopen() failure properly, fails
 *   to check ferror() after fgets() failure, arbitrarily truncates
 *   long lines, handles whitespace inconsistently, error messages
 *   don't point to the offending file and line, errors in included
 *   files are reported, but otherwise ignored, ...
 */

#include "qemu/osdep.h"


#include <sys/ioctl.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <sys/prctl.h>

#include <net/if.h>

#include <linux/sockios.h>

#ifndef SIOCBRADDIF
#include <linux/if_bridge.h>
#endif

#include "qemu/queue.h"
#include "qemu/cutils.h"

#include "net/tap-linux.h"

#ifdef CONFIG_LIBCAP_NG
#include <cap-ng.h>
#endif

#define DEFAULT_ACL_FILE CONFIG_QEMU_CONFDIR "/bridge.conf"

enum {
    ACL_ALLOW = 0,
    ACL_ALLOW_ALL,
    ACL_DENY,
    ACL_DENY_ALL,
};

typedef struct ACLRule {
    int type;
    char iface[IFNAMSIZ];
    QSIMPLEQ_ENTRY(ACLRule) entry;
} ACLRule;

typedef QSIMPLEQ_HEAD(ACLList, ACLRule) ACLList;

static void usage(void)
{
    fprintf(stderr,
            "Usage: qemu-bridge-helper [--use-vnet] --br=bridge --fd=unixfd\n");
}

static int parse_acl_file(const char *filename, ACLList *acl_list)
{
    FILE *f;
    char line[4096];
    ACLRule *acl_rule;

    f = fopen(filename, "r");
    if (f == NULL) {
        return -1;
    }

    while (fgets(line, sizeof(line), f) != NULL) {
        char *ptr = line;
        char *cmd, *arg, *argend;

        while (g_ascii_isspace(*ptr)) {
            ptr++;
        }

        /* skip comments and empty lines */
        if (*ptr == '#' || *ptr == 0) {
            continue;
        }

        cmd = ptr;
        arg = strchr(cmd, ' ');
        if (arg == NULL) {
            arg = strchr(cmd, '\t');
        }

        if (arg == NULL) {
            fprintf(stderr, "Invalid config line:\n  %s\n", line);
            goto err;
        }

        *arg = 0;
        arg++;
        while (g_ascii_isspace(*arg)) {
            arg++;
        }

        argend = arg + strlen(arg);
        while (arg != argend && g_ascii_isspace(*(argend - 1))) {
            argend--;
        }
        *argend = 0;

        if (!g_str_equal(cmd, "include") && strlen(arg) >= IFNAMSIZ) {
            fprintf(stderr, "name `%s' too long: %zu\n", arg, strlen(arg));
            goto err;
        }

        if (strcmp(cmd, "deny") == 0) {
            acl_rule = g_malloc(sizeof(*acl_rule));
            if (strcmp(arg, "all") == 0) {
                acl_rule->type = ACL_DENY_ALL;
            } else {
                acl_rule->type = ACL_DENY;
                snprintf(acl_rule->iface, IFNAMSIZ, "%s", arg);
            }
            QSIMPLEQ_INSERT_TAIL(acl_list, acl_rule, entry);
        } else if (strcmp(cmd, "allow") == 0) {
            acl_rule = g_malloc(sizeof(*acl_rule));
            if (strcmp(arg, "all") == 0) {
                acl_rule->type = ACL_ALLOW_ALL;
            } else {
                acl_rule->type = ACL_ALLOW;
                snprintf(acl_rule->iface, IFNAMSIZ, "%s", arg);
            }
            QSIMPLEQ_INSERT_TAIL(acl_list, acl_rule, entry);
        } else if (strcmp(cmd, "include") == 0) {
            /* ignore errors */
            parse_acl_file(arg, acl_list);
        } else {
            fprintf(stderr, "Unknown command `%s'\n", cmd);
            goto err;
        }
    }

    fclose(f);
    return 0;

err:
    fclose(f);
    errno = EINVAL;
    return -1;

}

static bool has_vnet_hdr(int fd)
{
    unsigned int features = 0;

    if (ioctl(fd, TUNGETFEATURES, &features) == -1) {
        return false;
    }

    if (!(features & IFF_VNET_HDR)) {
        return false;
    }

    return true;
}

static void prep_ifreq(struct ifreq *ifr, const char *ifname)
{
    memset(ifr, 0, sizeof(*ifr));
    snprintf(ifr->ifr_name, IFNAMSIZ, "%s", ifname);
}

static int send_fd(int c, int fd)
{
    char msgbuf[CMSG_SPACE(sizeof(fd))];
    struct msghdr msg = {
        .msg_control = msgbuf,
        .msg_controllen = sizeof(msgbuf),
    };
    struct cmsghdr *cmsg;
    struct iovec iov;
    char req[1] = { 0x00 };

    cmsg = CMSG_FIRSTHDR(&msg);
    cmsg->cmsg_level = SOL_SOCKET;
    cmsg->cmsg_type = SCM_RIGHTS;
    cmsg->cmsg_len = CMSG_LEN(sizeof(fd));
    msg.msg_controllen = cmsg->cmsg_len;

    iov.iov_base = req;
    iov.iov_len = sizeof(req);

    msg.msg_iov = &iov;
    msg.msg_iovlen = 1;
    memcpy(CMSG_DATA(cmsg), &fd, sizeof(fd));

    return sendmsg(c, &msg, 0);
}

#ifdef CONFIG_LIBCAP_NG
static int drop_privileges(void)
{
    /* clear all capabilities */
    capng_clear(CAPNG_SELECT_BOTH);

    if (capng_update(CAPNG_ADD, CAPNG_EFFECTIVE | CAPNG_PERMITTED,
                     CAP_NET_ADMIN) < 0) {
        return -1;
    }

    /* change to calling user's real uid and gid, retaining supplemental
     * groups and CAP_NET_ADMIN */
    if (capng_change_id(getuid(), getgid(), CAPNG_CLEAR_BOUNDING)) {
        return -1;
    }

    return 0;
}
#endif

int main(int argc, char **argv)
{
    struct ifreq ifr;
#ifndef SIOCBRADDIF
    unsigned long ifargs[4];
#endif
    int ifindex;
    int fd = -1, ctlfd = -1, unixfd = -1;
    int use_vnet = 0;
    int mtu;
    const char *bridge = NULL;
    char iface[IFNAMSIZ];
    int index;
    ACLRule *acl_rule;
    ACLList acl_list;
    int access_allowed, access_denied;
    int ret = EXIT_SUCCESS;
    g_autofree char *acl_file = NULL;

#ifdef CONFIG_LIBCAP_NG
    /* if we're run from an suid binary, immediately drop privileges preserving
     * cap_net_admin */
    if (geteuid() == 0 && getuid() != geteuid()) {
        if (drop_privileges() == -1) {
            fprintf(stderr, "failed to drop privileges\n");
            return 1;
        }
    }
#endif

    qemu_init_exec_dir(argv[0]);

    /* parse arguments */
    for (index = 1; index < argc; index++) {
        if (strcmp(argv[index], "--use-vnet") == 0) {
            use_vnet = 1;
        } else if (strncmp(argv[index], "--br=", 5) == 0) {
            bridge = &argv[index][5];
        } else if (strncmp(argv[index], "--fd=", 5) == 0) {
            unixfd = atoi(&argv[index][5]);
        } else {
            usage();
            return EXIT_FAILURE;
        }
    }

    if (bridge == NULL || unixfd == -1) {
        usage();
        return EXIT_FAILURE;
    }
    if (strlen(bridge) >= IFNAMSIZ) {
        fprintf(stderr, "name `%s' too long: %zu\n", bridge, strlen(bridge));
        return EXIT_FAILURE;
    }

    /* parse default acl file */
    QSIMPLEQ_INIT(&acl_list);
    acl_file = get_relocated_path(DEFAULT_ACL_FILE);
    if (parse_acl_file(acl_file, &acl_list) == -1) {
        fprintf(stderr, "failed to parse default acl file `%s'\n",
                acl_file);
        ret = EXIT_FAILURE;
        goto cleanup;
    }

    /* validate bridge against acl -- default policy is to deny
     * according acl policy if we have a deny and allow both
     * then deny should always win over allow
     */
    access_allowed = 0;
    access_denied = 0;
    QSIMPLEQ_FOREACH(acl_rule, &acl_list, entry) {
        switch (acl_rule->type) {
        case ACL_ALLOW_ALL:
            access_allowed = 1;
            break;
        case ACL_ALLOW:
            if (strcmp(bridge, acl_rule->iface) == 0) {
                access_allowed = 1;
            }
            break;
        case ACL_DENY_ALL:
            access_denied = 1;
            break;
        case ACL_DENY:
            if (strcmp(bridge, acl_rule->iface) == 0) {
                access_denied = 1;
            }
            break;
        }
    }

    if ((access_allowed == 0) || (access_denied == 1)) {
        fprintf(stderr, "access denied by acl file\n");
        ret = EXIT_FAILURE;
        goto cleanup;
    }

    /* open a socket to use to control the network interfaces */
    ctlfd = socket(AF_INET, SOCK_STREAM, 0);
    if (ctlfd == -1) {
        fprintf(stderr, "failed to open control socket: %s\n", strerror(errno));
        ret = EXIT_FAILURE;
        goto cleanup;
    }

    /* open the tap device */
    fd = open("/dev/net/tun", O_RDWR);
    if (fd == -1) {
        fprintf(stderr, "failed to open /dev/net/tun: %s\n", strerror(errno));
        ret = EXIT_FAILURE;
        goto cleanup;
    }

    /* request a tap device, disable PI, and add vnet header support if
     * requested and it's available. */
    prep_ifreq(&ifr, "tap%d");
    ifr.ifr_flags = IFF_TAP|IFF_NO_PI;
    if (use_vnet && has_vnet_hdr(fd)) {
        ifr.ifr_flags |= IFF_VNET_HDR;
    }

    if (ioctl(fd, TUNSETIFF, &ifr) == -1) {
        fprintf(stderr, "failed to create tun device: %s\n", strerror(errno));
        ret = EXIT_FAILURE;
        goto cleanup;
    }

    /* save tap device name */
    snprintf(iface, sizeof(iface), "%s", ifr.ifr_name);

    /* get the mtu of the bridge */
    prep_ifreq(&ifr, bridge);
    if (ioctl(ctlfd, SIOCGIFMTU, &ifr) == -1) {
        fprintf(stderr, "failed to get mtu of bridge `%s': %s\n",
                bridge, strerror(errno));
        ret = EXIT_FAILURE;
        goto cleanup;
    }

    /* save mtu */
    mtu = ifr.ifr_mtu;

    /* set the mtu of the interface based on the bridge */
    prep_ifreq(&ifr, iface);
    ifr.ifr_mtu = mtu;
    if (ioctl(ctlfd, SIOCSIFMTU, &ifr) == -1) {
        fprintf(stderr, "failed to set mtu of device `%s' to %d: %s\n",
                iface, mtu, strerror(errno));
        ret = EXIT_FAILURE;
        goto cleanup;
    }

    /* Linux uses the lowest enslaved MAC address as the MAC address of
     * the bridge.  Set MAC address to a high value so that it doesn't
     * affect the MAC address of the bridge.
     */
    if (ioctl(ctlfd, SIOCGIFHWADDR, &ifr) < 0) {
        fprintf(stderr, "failed to get MAC address of device `%s': %s\n",
                iface, strerror(errno));
        ret = EXIT_FAILURE;
        goto cleanup;
    }
    ifr.ifr_hwaddr.sa_data[0] = 0xFE;
    if (ioctl(ctlfd, SIOCSIFHWADDR, &ifr) < 0) {
        fprintf(stderr, "failed to set MAC address of device `%s': %s\n",
                iface, strerror(errno));
        ret = EXIT_FAILURE;
        goto cleanup;
    }

    /* add the interface to the bridge */
    prep_ifreq(&ifr, bridge);
    ifindex = if_nametoindex(iface);
#ifndef SIOCBRADDIF
    ifargs[0] = BRCTL_ADD_IF;
    ifargs[1] = ifindex;
    ifargs[2] = 0;
    ifargs[3] = 0;
    ifr.ifr_data = (void *)ifargs;
    ret = ioctl(ctlfd, SIOCDEVPRIVATE, &ifr);
#else
    ifr.ifr_ifindex = ifindex;
    ret = ioctl(ctlfd, SIOCBRADDIF, &ifr);
#endif
    if (ret == -1) {
        fprintf(stderr, "failed to add interface `%s' to bridge `%s': %s\n",
                iface, bridge, strerror(errno));
        ret = EXIT_FAILURE;
        goto cleanup;
    }

    /* bring the interface up */
    prep_ifreq(&ifr, iface);
    if (ioctl(ctlfd, SIOCGIFFLAGS, &ifr) == -1) {
        fprintf(stderr, "failed to get interface flags for `%s': %s\n",
                iface, strerror(errno));
        ret = EXIT_FAILURE;
        goto cleanup;
    }

    ifr.ifr_flags |= IFF_UP;
    if (ioctl(ctlfd, SIOCSIFFLAGS, &ifr) == -1) {
        fprintf(stderr, "failed to bring up interface `%s': %s\n",
                iface, strerror(errno));
        ret = EXIT_FAILURE;
        goto cleanup;
    }

    /* write fd to the domain socket */
    if (send_fd(unixfd, fd) == -1) {
        fprintf(stderr, "failed to write fd to unix socket: %s\n",
                strerror(errno));
        ret = EXIT_FAILURE;
        goto cleanup;
    }

    /* ... */

    /* profit! */

cleanup:
    if (fd >= 0) {
        close(fd);
    }
    if (ctlfd >= 0) {
        close(ctlfd);
    }
    while ((acl_rule = QSIMPLEQ_FIRST(&acl_list)) != NULL) {
        QSIMPLEQ_REMOVE_HEAD(&acl_list, entry);
        g_free(acl_rule);
    }

    return ret;
}
Commit	Line	Data
7b93fadf CB	1	/*
	2	* QEMU Bridge Helper
	3	*
	4	* Copyright IBM, Corp. 2011
	5	*
	6	* Authors:
	7	* Anthony Liguori <[email protected]>
	8	* Richa Marwaha <[email protected]>
	9	* Corey Bryant <[email protected]>
	10	*
	11	* This work is licensed under the terms of the GNU GPL, version 2. See
	12	* the COPYING file in the top-level directory.
436e3530 MA	13	*/
	14
	15	/*
	16	* Known shortcomings:
	17	* - There is no manual page
	18	* - The syntax of the ACL file is not documented anywhere
	19	* - parse_acl_file() doesn't report fopen() failure properly, fails
	20	* to check ferror() after fgets() failure, arbitrarily truncates
	21	* long lines, handles whitespace inconsistently, error messages
	22	* don't point to the offending file and line, errors in included
	23	* files are reported, but otherwise ignored, ...
7b93fadf CB	24	*/
7b93fadf CB	25
d38ea87a	26	#include "qemu/osdep.h"
7b93fadf	27
7b93fadf	28
7b93fadf CB	29	#include <sys/ioctl.h>
	30	#include <sys/socket.h>
	31	#include <sys/un.h>
	32	#include <sys/prctl.h>
	33
	34	#include <net/if.h>
	35
	36	#include <linux/sockios.h>
	37
34309d2b CB	38	#ifndef SIOCBRADDIF
	39	#include <linux/if_bridge.h>
	40	#endif
	41
1de7afc9	42	#include "qemu/queue.h"
f761b41a	43	#include "qemu/cutils.h"
bdef79a2	44
7b93fadf CB	45	#include "net/tap-linux.h"
7b93fadf CB	46
a358bca2	47	#ifdef CONFIG_LIBCAP_NG
47e98658 CB	48	#include <cap-ng.h>
	49	#endif
	50
bdef79a2 CB	51	#define DEFAULT_ACL_FILE CONFIG_QEMU_CONFDIR "/bridge.conf"
	52
	53	enum {
	54	ACL_ALLOW = 0,
	55	ACL_ALLOW_ALL,
	56	ACL_DENY,
	57	ACL_DENY_ALL,
	58	};
	59
	60	typedef struct ACLRule {
	61	int type;
	62	char iface[IFNAMSIZ];
	63	QSIMPLEQ_ENTRY(ACLRule) entry;
	64	} ACLRule;
	65
	66	typedef QSIMPLEQ_HEAD(ACLList, ACLRule) ACLList;
	67
7b93fadf CB	68	static void usage(void)
	69	{
	70	fprintf(stderr,
	71	"Usage: qemu-bridge-helper [--use-vnet] --br=bridge --fd=unixfd\n");
	72	}
	73
bdef79a2 CB	74	static int parse_acl_file(const char filename, ACLList acl_list)
	75	{
	76	FILE *f;
	77	char line[4096];
	78	ACLRule *acl_rule;
	79
	80	f = fopen(filename, "r");
	81	if (f == NULL) {
	82	return -1;
	83	}
	84
	85	while (fgets(line, sizeof(line), f) != NULL) {
	86	char *ptr = line;
	87	char cmd, arg, *argend;
	88
b8c3511d	89	while (g_ascii_isspace(*ptr)) {
bdef79a2 CB	90	ptr++;
	91	}
	92
	93	/* skip comments and empty lines */
	94	if (ptr == '#' \|\| ptr == 0) {
	95	continue;
	96	}
	97
	98	cmd = ptr;
	99	arg = strchr(cmd, ' ');
	100	if (arg == NULL) {
	101	arg = strchr(cmd, '\t');
	102	}
	103
	104	if (arg == NULL) {
	105	fprintf(stderr, "Invalid config line:\n %s\n", line);
3283dde4	106	goto err;
bdef79a2 CB	107	}
	108
	109	*arg = 0;
	110	arg++;
b8c3511d	111	while (g_ascii_isspace(*arg)) {
bdef79a2 CB	112	arg++;
	113	}
	114
	115	argend = arg + strlen(arg);
b8c3511d	116	while (arg != argend && g_ascii_isspace(*(argend - 1))) {
bdef79a2 CB	117	argend--;
	118	}
	119	*argend = 0;
	120
6f5d8671 PP	121	if (!g_str_equal(cmd, "include") && strlen(arg) >= IFNAMSIZ) {
6f5d8671 PP	122	fprintf(stderr, "name `%s' too long: %zu\n", arg, strlen(arg));
3283dde4	123	goto err;
6f5d8671 PP	124	}
6f5d8671 PP	125
bdef79a2 CB	126	if (strcmp(cmd, "deny") == 0) {
	127	acl_rule = g_malloc(sizeof(*acl_rule));
	128	if (strcmp(arg, "all") == 0) {
	129	acl_rule->type = ACL_DENY_ALL;
	130	} else {
	131	acl_rule->type = ACL_DENY;
	132	snprintf(acl_rule->iface, IFNAMSIZ, "%s", arg);
	133	}
	134	QSIMPLEQ_INSERT_TAIL(acl_list, acl_rule, entry);
	135	} else if (strcmp(cmd, "allow") == 0) {
	136	acl_rule = g_malloc(sizeof(*acl_rule));
	137	if (strcmp(arg, "all") == 0) {
	138	acl_rule->type = ACL_ALLOW_ALL;
	139	} else {
	140	acl_rule->type = ACL_ALLOW;
	141	snprintf(acl_rule->iface, IFNAMSIZ, "%s", arg);
	142	}
	143	QSIMPLEQ_INSERT_TAIL(acl_list, acl_rule, entry);
	144	} else if (strcmp(cmd, "include") == 0) {
	145	/* ignore errors */
	146	parse_acl_file(arg, acl_list);
	147	} else {
	148	fprintf(stderr, "Unknown command `%s'\n", cmd);
3283dde4	149	goto err;
bdef79a2 CB	150	}
	151	}
	152
	153	fclose(f);
bdef79a2	154	return 0;
3283dde4 PP	155
	156	err:
	157	fclose(f);
	158	errno = EINVAL;
	159	return -1;
	160
bdef79a2 CB	161	}
bdef79a2 CB	162
7b93fadf CB	163	static bool has_vnet_hdr(int fd)
	164	{
	165	unsigned int features = 0;
	166
	167	if (ioctl(fd, TUNGETFEATURES, &features) == -1) {
	168	return false;
	169	}
	170
	171	if (!(features & IFF_VNET_HDR)) {
	172	return false;
	173	}
	174
	175	return true;
	176	}
	177
	178	static void prep_ifreq(struct ifreq ifr, const char ifname)
	179	{
	180	memset(ifr, 0, sizeof(*ifr));
	181	snprintf(ifr->ifr_name, IFNAMSIZ, "%s", ifname);
	182	}
	183
	184	static int send_fd(int c, int fd)
	185	{
	186	char msgbuf[CMSG_SPACE(sizeof(fd))];
	187	struct msghdr msg = {
	188	.msg_control = msgbuf,
	189	.msg_controllen = sizeof(msgbuf),
	190	};
	191	struct cmsghdr *cmsg;
	192	struct iovec iov;
	193	char req[1] = { 0x00 };
	194
	195	cmsg = CMSG_FIRSTHDR(&msg);
	196	cmsg->cmsg_level = SOL_SOCKET;
	197	cmsg->cmsg_type = SCM_RIGHTS;
	198	cmsg->cmsg_len = CMSG_LEN(sizeof(fd));
	199	msg.msg_controllen = cmsg->cmsg_len;
	200
	201	iov.iov_base = req;
	202	iov.iov_len = sizeof(req);
	203
	204	msg.msg_iov = &iov;
	205	msg.msg_iovlen = 1;
	206	memcpy(CMSG_DATA(cmsg), &fd, sizeof(fd));
	207
	208	return sendmsg(c, &msg, 0);
	209	}
	210
a358bca2	211	#ifdef CONFIG_LIBCAP_NG
47e98658 CB	212	static int drop_privileges(void)
	213	{
	214	/* clear all capabilities */
	215	capng_clear(CAPNG_SELECT_BOTH);
	216
	217	if (capng_update(CAPNG_ADD, CAPNG_EFFECTIVE \| CAPNG_PERMITTED,
	218	CAP_NET_ADMIN) < 0) {
	219	return -1;
	220	}
	221
	222	/* change to calling user's real uid and gid, retaining supplemental
	223	* groups and CAP_NET_ADMIN */
	224	if (capng_change_id(getuid(), getgid(), CAPNG_CLEAR_BOUNDING)) {
	225	return -1;
	226	}
	227
	228	return 0;
	229	}
	230	#endif
	231
7b93fadf CB	232	int main(int argc, char **argv)
	233	{
	234	struct ifreq ifr;
34309d2b CB	235	#ifndef SIOCBRADDIF
	236	unsigned long ifargs[4];
	237	#endif
	238	int ifindex;
eb3f45c5	239	int fd = -1, ctlfd = -1, unixfd = -1;
7b93fadf CB	240	int use_vnet = 0;
	241	int mtu;
	242	const char *bridge = NULL;
	243	char iface[IFNAMSIZ];
	244	int index;
bdef79a2 CB	245	ACLRule *acl_rule;
	246	ACLList acl_list;
	247	int access_allowed, access_denied;
7b93fadf	248	int ret = EXIT_SUCCESS;
f761b41a	249	g_autofree char *acl_file = NULL;
7b93fadf	250
a358bca2	251	#ifdef CONFIG_LIBCAP_NG
47e98658 CB	252	/* if we're run from an suid binary, immediately drop privileges preserving
	253	* cap_net_admin */
	254	if (geteuid() == 0 && getuid() != geteuid()) {
	255	if (drop_privileges() == -1) {
	256	fprintf(stderr, "failed to drop privileges\n");
	257	return 1;
	258	}
	259	}
	260	#endif
	261
f761b41a PB	262	qemu_init_exec_dir(argv[0]);
f761b41a PB	263
7b93fadf CB	264	/* parse arguments */
	265	for (index = 1; index < argc; index++) {
	266	if (strcmp(argv[index], "--use-vnet") == 0) {
	267	use_vnet = 1;
	268	} else if (strncmp(argv[index], "--br=", 5) == 0) {
	269	bridge = &argv[index][5];
	270	} else if (strncmp(argv[index], "--fd=", 5) == 0) {
	271	unixfd = atoi(&argv[index][5]);
	272	} else {
	273	usage();
	274	return EXIT_FAILURE;
	275	}
	276	}
	277
	278	if (bridge == NULL \|\| unixfd == -1) {
	279	usage();
	280	return EXIT_FAILURE;
	281	}
6f5d8671 PP	282	if (strlen(bridge) >= IFNAMSIZ) {
	283	fprintf(stderr, "name `%s' too long: %zu\n", bridge, strlen(bridge));
	284	return EXIT_FAILURE;
	285	}
7b93fadf	286
bdef79a2 CB	287	/* parse default acl file */
bdef79a2 CB	288	QSIMPLEQ_INIT(&acl_list);
f761b41a PB	289	acl_file = get_relocated_path(DEFAULT_ACL_FILE);
f761b41a PB	290	if (parse_acl_file(acl_file, &acl_list) == -1) {
bdef79a2	291	fprintf(stderr, "failed to parse default acl file `%s'\n",
f761b41a	292	acl_file);
bdef79a2 CB	293	ret = EXIT_FAILURE;
	294	goto cleanup;
	295	}
	296
	297	/* validate bridge against acl -- default policy is to deny
	298	* according acl policy if we have a deny and allow both
	299	* then deny should always win over allow
	300	*/
	301	access_allowed = 0;
	302	access_denied = 0;
	303	QSIMPLEQ_FOREACH(acl_rule, &acl_list, entry) {
	304	switch (acl_rule->type) {
	305	case ACL_ALLOW_ALL:
	306	access_allowed = 1;
	307	break;
	308	case ACL_ALLOW:
	309	if (strcmp(bridge, acl_rule->iface) == 0) {
	310	access_allowed = 1;
	311	}
	312	break;
	313	case ACL_DENY_ALL:
	314	access_denied = 1;
	315	break;
	316	case ACL_DENY:
	317	if (strcmp(bridge, acl_rule->iface) == 0) {
	318	access_denied = 1;
	319	}
	320	break;
	321	}
	322	}
	323
	324	if ((access_allowed == 0) \|\| (access_denied == 1)) {
	325	fprintf(stderr, "access denied by acl file\n");
	326	ret = EXIT_FAILURE;
	327	goto cleanup;
	328	}
	329
7b93fadf CB	330	/* open a socket to use to control the network interfaces */
	331	ctlfd = socket(AF_INET, SOCK_STREAM, 0);
	332	if (ctlfd == -1) {
	333	fprintf(stderr, "failed to open control socket: %s\n", strerror(errno));
	334	ret = EXIT_FAILURE;
	335	goto cleanup;
	336	}
	337
	338	/* open the tap device */
	339	fd = open("/dev/net/tun", O_RDWR);
	340	if (fd == -1) {
	341	fprintf(stderr, "failed to open /dev/net/tun: %s\n", strerror(errno));
	342	ret = EXIT_FAILURE;
	343	goto cleanup;
	344	}
	345
	346	/* request a tap device, disable PI, and add vnet header support if
	347	* requested and it's available. */
	348	prep_ifreq(&ifr, "tap%d");
	349	ifr.ifr_flags = IFF_TAP\|IFF_NO_PI;
	350	if (use_vnet && has_vnet_hdr(fd)) {
	351	ifr.ifr_flags \|= IFF_VNET_HDR;
	352	}
	353
	354	if (ioctl(fd, TUNSETIFF, &ifr) == -1) {
	355	fprintf(stderr, "failed to create tun device: %s\n", strerror(errno));
	356	ret = EXIT_FAILURE;
	357	goto cleanup;
	358	}
	359
	360	/* save tap device name */
	361	snprintf(iface, sizeof(iface), "%s", ifr.ifr_name);
	362
	363	/* get the mtu of the bridge */
	364	prep_ifreq(&ifr, bridge);
	365	if (ioctl(ctlfd, SIOCGIFMTU, &ifr) == -1) {
	366	fprintf(stderr, "failed to get mtu of bridge `%s': %s\n",
	367	bridge, strerror(errno));
	368	ret = EXIT_FAILURE;
	369	goto cleanup;
	370	}
	371
	372	/* save mtu */
	373	mtu = ifr.ifr_mtu;
	374
	375	/* set the mtu of the interface based on the bridge */
	376	prep_ifreq(&ifr, iface);
	377	ifr.ifr_mtu = mtu;
	378	if (ioctl(ctlfd, SIOCSIFMTU, &ifr) == -1) {
	379	fprintf(stderr, "failed to set mtu of device `%s' to %d: %s\n",
	380	iface, mtu, strerror(errno));
	381	ret = EXIT_FAILURE;
	382	goto cleanup;
	383	}
	384
226ecabf PB	385	/* Linux uses the lowest enslaved MAC address as the MAC address of
	386	* the bridge. Set MAC address to a high value so that it doesn't
	387	* affect the MAC address of the bridge.
	388	*/
	389	if (ioctl(ctlfd, SIOCGIFHWADDR, &ifr) < 0) {
	390	fprintf(stderr, "failed to get MAC address of device `%s': %s\n",
	391	iface, strerror(errno));
	392	ret = EXIT_FAILURE;
	393	goto cleanup;
	394	}
	395	ifr.ifr_hwaddr.sa_data[0] = 0xFE;
	396	if (ioctl(ctlfd, SIOCSIFHWADDR, &ifr) < 0) {
	397	fprintf(stderr, "failed to set MAC address of device `%s': %s\n",
	398	iface, strerror(errno));
	399	ret = EXIT_FAILURE;
	400	goto cleanup;
	401	}
	402
7b93fadf CB	403	/* add the interface to the bridge */
7b93fadf CB	404	prep_ifreq(&ifr, bridge);
34309d2b CB	405	ifindex = if_nametoindex(iface);
	406	#ifndef SIOCBRADDIF
	407	ifargs[0] = BRCTL_ADD_IF;
	408	ifargs[1] = ifindex;
	409	ifargs[2] = 0;
	410	ifargs[3] = 0;
	411	ifr.ifr_data = (void *)ifargs;
	412	ret = ioctl(ctlfd, SIOCDEVPRIVATE, &ifr);
	413	#else
	414	ifr.ifr_ifindex = ifindex;
	415	ret = ioctl(ctlfd, SIOCBRADDIF, &ifr);
	416	#endif
	417	if (ret == -1) {
7b93fadf CB	418	fprintf(stderr, "failed to add interface `%s' to bridge `%s': %s\n",
	419	iface, bridge, strerror(errno));
	420	ret = EXIT_FAILURE;
	421	goto cleanup;
	422	}
	423
	424	/* bring the interface up */
	425	prep_ifreq(&ifr, iface);
	426	if (ioctl(ctlfd, SIOCGIFFLAGS, &ifr) == -1) {
	427	fprintf(stderr, "failed to get interface flags for `%s': %s\n",
	428	iface, strerror(errno));
	429	ret = EXIT_FAILURE;
	430	goto cleanup;
	431	}
	432
	433	ifr.ifr_flags \|= IFF_UP;
	434	if (ioctl(ctlfd, SIOCSIFFLAGS, &ifr) == -1) {
	435	fprintf(stderr, "failed to bring up interface `%s': %s\n",
	436	iface, strerror(errno));
	437	ret = EXIT_FAILURE;
	438	goto cleanup;
	439	}
	440
	441	/* write fd to the domain socket */
	442	if (send_fd(unixfd, fd) == -1) {
	443	fprintf(stderr, "failed to write fd to unix socket: %s\n",
	444	strerror(errno));
	445	ret = EXIT_FAILURE;
	446	goto cleanup;
	447	}
	448
	449	/* ... */
	450
	451	/* profit! */
	452
	453	cleanup:
eb3f45c5 GA	454	if (fd >= 0) {
	455	close(fd);
	456	}
	457	if (ctlfd >= 0) {
	458	close(ctlfd);
	459	}
bdef79a2 CB	460	while ((acl_rule = QSIMPLEQ_FIRST(&acl_list)) != NULL) {
	461	QSIMPLEQ_REMOVE_HEAD(&acl_list, entry);
	462	g_free(acl_rule);
	463	}
	464
7b93fadf CB	465	return ret;
7b93fadf CB	466	}