[mirror_frr.git] / zebra / zebra_netns_id.c

/* zebra NETNS ID handling routines
 * those routines are implemented locally to avoid having external dependencies.
 * Copyright (C) 2018 6WIND
 *
 * 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.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
 * more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; see the file COPYING; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
 */

#include <zebra.h>

#include "ns.h"
#include "vrf.h"
#include "log.h"
#include "lib_errors.h"

#include "zebra/rib.h"
#include "zebra/zebra_dplane.h"
#if defined(HAVE_NETLINK)

#include <linux/net_namespace.h>
#include <linux/netlink.h>
#include <linux/rtnetlink.h>

#include "zebra_ns.h"
#include "kernel_netlink.h"
#endif /* defined(HAVE_NETLINK) */

#include "zebra/zebra_netns_id.h"
#include "zebra/zebra_errors.h"

/* default NS ID value used when VRF backend is not NETNS */
#define NS_DEFAULT_INTERNAL 0

/* in case NEWNSID not available, the NSID will be locally obtained
 */
#define NS_BASE_NSID 0

#if defined(HAVE_NETLINK)

#define NETLINK_SOCKET_BUFFER_SIZE 512
#define NETLINK_ALIGNTO             4
#define NETLINK_ALIGN(len)                                                     \
	(((len) + NETLINK_ALIGNTO - 1) & ~(NETLINK_ALIGNTO - 1))
#define NETLINK_NLATTR_LEN(_a, _b)   (unsigned int)((char *)_a - (char *)_b)

#endif /* defined(HAVE_NETLINK) */

static ns_id_t zebra_ns_id_get_fallback(const char *netnspath)
{
	static int zebra_ns_id_local;

	return zebra_ns_id_local++;
}

#if defined(HAVE_NETLINK)

static struct nlmsghdr *initiate_nlh(char *buf, unsigned int *seq, int type)
{
	struct nlmsghdr *nlh;

	nlh = (struct nlmsghdr *)buf;
	nlh->nlmsg_len = NETLINK_ALIGN(sizeof(struct nlmsghdr));

	nlh->nlmsg_type = type;
	nlh->nlmsg_flags = NLM_F_REQUEST;
	if (type == RTM_NEWNSID)
		nlh->nlmsg_flags |= NLM_F_ACK;
	nlh->nlmsg_seq = *seq = time(NULL);
	return nlh;
}

static int send_receive(int sock, struct nlmsghdr *nlh, unsigned int seq,
			char *buf)
{
	int ret;
	static const struct sockaddr_nl snl = {.nl_family = AF_NETLINK};

	ret = sendto(sock, (const void *)nlh, (size_t)nlh->nlmsg_len, 0,
		     (struct sockaddr *)&snl, (socklen_t)sizeof(snl));
	if (ret < 0) {
		flog_err_sys(EC_LIB_SOCKET, "netlink( %u) sendmsg() error: %s",
			     sock, safe_strerror(errno));
		return -1;
	}

	/* reception */
	struct sockaddr_nl addr;
	struct iovec iov = {
		.iov_base = buf, .iov_len = NETLINK_SOCKET_BUFFER_SIZE,
	};
	struct msghdr msg = {
		.msg_name = &addr,
		.msg_namelen = sizeof(struct sockaddr_nl),
		.msg_iov = &iov,
		.msg_iovlen = 1,
		.msg_control = NULL,
		.msg_controllen = 0,
		.msg_flags = 0,
	};
	ret = recvmsg(sock, &msg, 0);
	if (ret < 0) {
		flog_err_sys(EC_LIB_SOCKET,
			     "netlink recvmsg: error %d (errno %u)", ret,
			     errno);
		return -1;
	}
	if (msg.msg_flags & MSG_TRUNC) {
		flog_err(EC_ZEBRA_NETLINK_LENGTH_ERROR,
			 "netlink recvmsg : error message truncated");
		return -1;
	}
	/* nlh already points to buf */
	if (nlh->nlmsg_seq != seq) {
		flog_err(
			EC_ZEBRA_NETLINK_BAD_SEQUENCE,
			"netlink recvmsg: bad sequence number %x (expected %x)",
			seq, nlh->nlmsg_seq);
		return -1;
	}
	return ret;
}

/* extract on a valid nlmsg the nsid
 * valid nlmsghdr - not a nlmsgerr
 */
static ns_id_t extract_nsid(struct nlmsghdr *nlh, char *buf)
{
	ns_id_t ns_id = NS_UNKNOWN;
	int offset = NETLINK_ALIGN(sizeof(struct nlmsghdr))
		     + NETLINK_ALIGN(sizeof(struct rtgenmsg));
	int curr_length = offset;
	void *tail = (void *)((char *)nlh + NETLINK_ALIGN(nlh->nlmsg_len));
	struct nlattr *attr;

	for (attr = (struct nlattr *)((char *)buf + offset);
	     NETLINK_NLATTR_LEN(tail, attr) >= sizeof(struct nlattr)
	     && attr->nla_len >= sizeof(struct nlattr)
	     && attr->nla_len <= NETLINK_NLATTR_LEN(tail, attr);
	     attr += NETLINK_ALIGN(attr->nla_len)) {
		curr_length += attr->nla_len;
		if ((attr->nla_type & NLA_TYPE_MASK) == NETNSA_NSID) {
			uint32_t *ptr = (uint32_t *)(attr);

			ns_id = ptr[1];
			break;
		}
	}
	return ns_id;
}

ns_id_t zebra_ns_id_get(const char *netnspath)
{
	int ns_id = -1;
	struct sockaddr_nl snl;
	int fd, sock, ret;
	unsigned int seq;
	ns_id_t return_nsid = NS_UNKNOWN;

	/* netns path check */
	if (!netnspath)
		return NS_UNKNOWN;
	fd = open(netnspath, O_RDONLY);
	if (fd == -1)
		return NS_UNKNOWN;

	/* netlink socket */
	sock = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
	if (sock < 0) {
		flog_err_sys(EC_LIB_SOCKET, "netlink( %u) socket() error: %s",
			     sock, safe_strerror(errno));
		close(fd);
		return NS_UNKNOWN;
	}
	memset(&snl, 0, sizeof(snl));
	snl.nl_family = AF_NETLINK;
	snl.nl_groups = RTNLGRP_NSID;
	snl.nl_pid = 0; /* AUTO PID */
	ret = bind(sock, (struct sockaddr *)&snl, sizeof(snl));
	if (ret < 0) {
		flog_err_sys(EC_LIB_SOCKET,
			     "netlink( %u) socket() bind error: %s", sock,
			     safe_strerror(errno));
		close(sock);
		close(fd);
		return NS_UNKNOWN;
	}

	/* message to send to netlink,and response : NEWNSID */
	char buf[NETLINK_SOCKET_BUFFER_SIZE];
	struct nlmsghdr *nlh;
	struct rtgenmsg *rt;
	int len;

	memset(buf, 0, NETLINK_SOCKET_BUFFER_SIZE);
	nlh = initiate_nlh(buf, &seq, RTM_NEWNSID);
	rt = (struct rtgenmsg *)(buf + nlh->nlmsg_len);
	nlh->nlmsg_len += NETLINK_ALIGN(sizeof(struct rtgenmsg));
	rt->rtgen_family = AF_UNSPEC;

	addattr32(nlh, NETLINK_SOCKET_BUFFER_SIZE, NETNSA_FD, fd);
	addattr32(nlh, NETLINK_SOCKET_BUFFER_SIZE, NETNSA_NSID, ns_id);

	ret = send_receive(sock, nlh, seq, buf);
	if (ret < 0) {
		close(sock);
		close(fd);
		return NS_UNKNOWN;
	}
	nlh = (struct nlmsghdr *)buf;

	/* message to analyse : NEWNSID response */
	ret = 0;
	if (nlh->nlmsg_type >= NLMSG_MIN_TYPE) {
		return_nsid = extract_nsid(nlh, buf);
	} else {
		if (nlh->nlmsg_type == NLMSG_ERROR) {
			struct nlmsgerr *err =
				(struct nlmsgerr
					 *)((char *)nlh
					    + NETLINK_ALIGN(
						      sizeof(struct nlmsghdr)));

			ret = -1;
			if (err->error < 0)
				errno = -err->error;
			else
				errno = err->error;
			if (errno == 0) {
				/* request NEWNSID was successfull
				 * return EEXIST error to get GETNSID
				 */
				errno = EEXIST;
			}
		} else {
			/* other errors ignored
			 * attempt to get nsid
			 */
			ret = -1;
			errno = EEXIST;
		}
	}

	if (ret <= 0) {
		if (errno != EEXIST && ret != 0) {
			flog_err(
				EC_LIB_SOCKET,
				"netlink( %u) recvfrom() error 2 when reading: %s",
				fd, safe_strerror(errno));
			close(sock);
			close(fd);
			if (errno == ENOTSUP) {
				zlog_debug("NEWNSID locally generated");
				return zebra_ns_id_get_fallback(netnspath);
			}
			return NS_UNKNOWN;
		}
		/* message to send to netlink : GETNSID */
		memset(buf, 0, NETLINK_SOCKET_BUFFER_SIZE);
		nlh = initiate_nlh(buf, &seq, RTM_GETNSID);
		rt = (struct rtgenmsg *)(buf + nlh->nlmsg_len);
		nlh->nlmsg_len += NETLINK_ALIGN(sizeof(struct rtgenmsg));
		rt->rtgen_family = AF_UNSPEC;

		addattr32(nlh, NETLINK_SOCKET_BUFFER_SIZE, NETNSA_FD, fd);
		addattr32(nlh, NETLINK_SOCKET_BUFFER_SIZE, NETNSA_NSID, ns_id);

		ret = send_receive(sock, nlh, seq, buf);
		if (ret < 0) {
			close(sock);
			close(fd);
			return NS_UNKNOWN;
		}
		nlh = (struct nlmsghdr *)buf;
		len = ret;
		ret = 0;
		do {
			if (nlh->nlmsg_type >= NLMSG_MIN_TYPE) {
				return_nsid = extract_nsid(nlh, buf);
				if (return_nsid != NS_UNKNOWN)
					break;
			} else if (nlh->nlmsg_type == NLMSG_ERROR) {
				struct nlmsgerr *err =
					(struct nlmsgerr
						 *)((char *)nlh
						    + NETLINK_ALIGN(sizeof(
							      struct
							      nlmsghdr)));
				if (err->error < 0)
					errno = -err->error;
				else
					errno = err->error;
				break;
			}
			len = len - NETLINK_ALIGN(nlh->nlmsg_len);
			nlh = (struct nlmsghdr *)((char *)nlh
						  + NETLINK_ALIGN(
							    nlh->nlmsg_len));
		} while (len != 0 && ret == 0);
	}

	close(fd);
	close(sock);
	return return_nsid;
}

#else
ns_id_t zebra_ns_id_get(const char *netnspath)
{
	return zebra_ns_id_get_fallback(netnspath);
}
#endif /* ! defined(HAVE_NETLINK) */

#ifdef HAVE_NETNS
static void zebra_ns_create_netns_directory(void)
{
	/* check that /var/run/netns is created */
	/* S_IRWXU|S_IRGRP|S_IXGRP|S_IROTH|S_IXOTH */
	if (mkdir(NS_RUN_DIR, 0755)) {
		if (errno != EEXIST) {
			flog_warn(EC_ZEBRA_NAMESPACE_DIR_INACCESSIBLE,
				  "NS check: failed to access %s", NS_RUN_DIR);
			return;
		}
	}
}
#endif

ns_id_t zebra_ns_id_get_default(void)
{
#ifdef HAVE_NETNS
	int fd;
#endif /* !HAVE_NETNS */

#ifdef HAVE_NETNS
	if (vrf_is_backend_netns())
		zebra_ns_create_netns_directory();
	fd = open(NS_DEFAULT_NAME, O_RDONLY);

	if (fd == -1)
		return NS_DEFAULT_INTERNAL;
	if (!vrf_is_backend_netns()) {
		close(fd);
		return NS_DEFAULT_INTERNAL;
	}
	close(fd);
	return zebra_ns_id_get((char *)NS_DEFAULT_NAME);
#else  /* HAVE_NETNS */
	return NS_DEFAULT_INTERNAL;
#endif /* !HAVE_NETNS */
}
Commit	Line	Data
05895ad0 PG	1	/* zebra NETNS ID handling routines
	2	* those routines are implemented locally to avoid having external dependencies.
	3	* Copyright (C) 2018 6WIND
	4	*
	5	* This program is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License as published by the Free
	7	* Software Foundation; either version 2 of the License, or (at your option)
	8	* any later version.
	9	*
	10	* This program is distributed in the hope that it will be useful, but WITHOUT
	11	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	12	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
	13	* more details.
	14	*
	15	* You should have received a copy of the GNU General Public License along
	16	* with this program; see the file COPYING; if not, write to the Free Software
	17	* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
	18	*/
	19
	20	#include <zebra.h>
	21
	22	#include "ns.h"
ec31f30d	23	#include "vrf.h"
05895ad0	24	#include "log.h"
43e52561	25	#include "lib_errors.h"
05895ad0	26
85a75f1e MS	27	#include "zebra/rib.h"
85a75f1e MS	28	#include "zebra/zebra_dplane.h"
05895ad0 PG	29	#if defined(HAVE_NETLINK)
	30
	31	#include <linux/net_namespace.h>
	32	#include <linux/netlink.h>
	33	#include <linux/rtnetlink.h>
	34
05895ad0 PG	35	#include "zebra_ns.h"
	36	#include "kernel_netlink.h"
	37	#endif /* defined(HAVE_NETLINK) */
	38
43e52561 QY	39	#include "zebra/zebra_netns_id.h"
43e52561 QY	40	#include "zebra/zebra_errors.h"
05895ad0	41
ec31f30d PG	42	/* default NS ID value used when VRF backend is not NETNS */
	43	#define NS_DEFAULT_INTERNAL 0
	44
05895ad0 PG	45	/* in case NEWNSID not available, the NSID will be locally obtained
	46	*/
	47	#define NS_BASE_NSID 0
	48
	49	#if defined(HAVE_NETLINK)
	50
	51	#define NETLINK_SOCKET_BUFFER_SIZE 512
	52	#define NETLINK_ALIGNTO 4
996c9314 LB	53	#define NETLINK_ALIGN(len) \
996c9314 LB	54	(((len) + NETLINK_ALIGNTO - 1) & ~(NETLINK_ALIGNTO - 1))
05895ad0 PG	55	#define NETLINK_NLATTR_LEN(_a, _b) (unsigned int)((char )_a - (char )_b)
	56
	57	#endif /* defined(HAVE_NETLINK) */
	58
	59	static ns_id_t zebra_ns_id_get_fallback(const char *netnspath)
	60	{
	61	static int zebra_ns_id_local;
	62
	63	return zebra_ns_id_local++;
	64	}
	65
	66	#if defined(HAVE_NETLINK)
	67
	68	static struct nlmsghdr initiate_nlh(char buf, unsigned int *seq, int type)
	69	{
	70	struct nlmsghdr *nlh;
	71
	72	nlh = (struct nlmsghdr *)buf;
	73	nlh->nlmsg_len = NETLINK_ALIGN(sizeof(struct nlmsghdr));
	74
	75	nlh->nlmsg_type = type;
	76	nlh->nlmsg_flags = NLM_F_REQUEST;
	77	if (type == RTM_NEWNSID)
	78	nlh->nlmsg_flags \|= NLM_F_ACK;
	79	nlh->nlmsg_seq = *seq = time(NULL);
	80	return nlh;
	81	}
	82
996c9314 LB	83	static int send_receive(int sock, struct nlmsghdr *nlh, unsigned int seq,
996c9314 LB	84	char *buf)
05895ad0 PG	85	{
05895ad0 PG	86	int ret;
996c9314	87	static const struct sockaddr_nl snl = {.nl_family = AF_NETLINK};
05895ad0 PG	88
05895ad0 PG	89	ret = sendto(sock, (const void *)nlh, (size_t)nlh->nlmsg_len, 0,
996c9314	90	(struct sockaddr *)&snl, (socklen_t)sizeof(snl));
05895ad0	91	if (ret < 0) {
450971aa	92	flog_err_sys(EC_LIB_SOCKET, "netlink( %u) sendmsg() error: %s",
09c866e3	93	sock, safe_strerror(errno));
05895ad0 PG	94	return -1;
	95	}
	96
	97	/* reception */
	98	struct sockaddr_nl addr;
	99	struct iovec iov = {
996c9314	100	.iov_base = buf, .iov_len = NETLINK_SOCKET_BUFFER_SIZE,
05895ad0 PG	101	};
05895ad0 PG	102	struct msghdr msg = {
996c9314 LB	103	.msg_name = &addr,
	104	.msg_namelen = sizeof(struct sockaddr_nl),
	105	.msg_iov = &iov,
	106	.msg_iovlen = 1,
	107	.msg_control = NULL,
05895ad0	108	.msg_controllen = 0,
996c9314	109	.msg_flags = 0,
05895ad0 PG	110	};
	111	ret = recvmsg(sock, &msg, 0);
	112	if (ret < 0) {
450971aa	113	flog_err_sys(EC_LIB_SOCKET,
09c866e3 QY	114	"netlink recvmsg: error %d (errno %u)", ret,
09c866e3 QY	115	errno);
05895ad0 PG	116	return -1;
	117	}
	118	if (msg.msg_flags & MSG_TRUNC) {
e914ccbe	119	flog_err(EC_ZEBRA_NETLINK_LENGTH_ERROR,
1c50c1c0	120	"netlink recvmsg : error message truncated");
05895ad0 PG	121	return -1;
	122	}
	123	/* nlh already points to buf */
	124	if (nlh->nlmsg_seq != seq) {
af4c2728	125	flog_err(
e914ccbe	126	EC_ZEBRA_NETLINK_BAD_SEQUENCE,
996c9314 LB	127	"netlink recvmsg: bad sequence number %x (expected %x)",
996c9314 LB	128	seq, nlh->nlmsg_seq);
05895ad0 PG	129	return -1;
	130	}
	131	return ret;
	132	}
	133
	134	/* extract on a valid nlmsg the nsid
	135	* valid nlmsghdr - not a nlmsgerr
	136	*/
	137	static ns_id_t extract_nsid(struct nlmsghdr nlh, char buf)
	138	{
	139	ns_id_t ns_id = NS_UNKNOWN;
996c9314 LB	140	int offset = NETLINK_ALIGN(sizeof(struct nlmsghdr))
996c9314 LB	141	+ NETLINK_ALIGN(sizeof(struct rtgenmsg));
05895ad0 PG	142	int curr_length = offset;
	143	void tail = (void )((char *)nlh + NETLINK_ALIGN(nlh->nlmsg_len));
	144	struct nlattr *attr;
	145
	146	for (attr = (struct nlattr )((char )buf + offset);
996c9314 LB	147	NETLINK_NLATTR_LEN(tail, attr) >= sizeof(struct nlattr)
	148	&& attr->nla_len >= sizeof(struct nlattr)
	149	&& attr->nla_len <= NETLINK_NLATTR_LEN(tail, attr);
05895ad0 PG	150	attr += NETLINK_ALIGN(attr->nla_len)) {
	151	curr_length += attr->nla_len;
	152	if ((attr->nla_type & NLA_TYPE_MASK) == NETNSA_NSID) {
d7c0a89a	153	uint32_t ptr = (uint32_t )(attr);
05895ad0 PG	154
	155	ns_id = ptr[1];
	156	break;
	157	}
	158	}
	159	return ns_id;
	160	}
	161
	162	ns_id_t zebra_ns_id_get(const char *netnspath)
	163	{
	164	int ns_id = -1;
	165	struct sockaddr_nl snl;
	166	int fd, sock, ret;
	167	unsigned int seq;
	168	ns_id_t return_nsid = NS_UNKNOWN;
	169
	170	/* netns path check */
	171	if (!netnspath)
	172	return NS_UNKNOWN;
	173	fd = open(netnspath, O_RDONLY);
	174	if (fd == -1)
	175	return NS_UNKNOWN;
	176
	177	/* netlink socket */
	178	sock = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
	179	if (sock < 0) {
450971aa	180	flog_err_sys(EC_LIB_SOCKET, "netlink( %u) socket() error: %s",
09c866e3	181	sock, safe_strerror(errno));
af734bc7	182	close(fd);
05895ad0 PG	183	return NS_UNKNOWN;
	184	}
	185	memset(&snl, 0, sizeof(snl));
	186	snl.nl_family = AF_NETLINK;
	187	snl.nl_groups = RTNLGRP_NSID;
	188	snl.nl_pid = 0; /* AUTO PID */
	189	ret = bind(sock, (struct sockaddr *)&snl, sizeof(snl));
	190	if (ret < 0) {
450971aa	191	flog_err_sys(EC_LIB_SOCKET,
09c866e3 QY	192	"netlink( %u) socket() bind error: %s", sock,
09c866e3 QY	193	safe_strerror(errno));
05895ad0 PG	194	close(sock);
	195	close(fd);
	196	return NS_UNKNOWN;
	197	}
	198
	199	/* message to send to netlink,and response : NEWNSID */
	200	char buf[NETLINK_SOCKET_BUFFER_SIZE];
	201	struct nlmsghdr *nlh;
	202	struct rtgenmsg *rt;
	203	int len;
	204
	205	memset(buf, 0, NETLINK_SOCKET_BUFFER_SIZE);
	206	nlh = initiate_nlh(buf, &seq, RTM_NEWNSID);
	207	rt = (struct rtgenmsg *)(buf + nlh->nlmsg_len);
	208	nlh->nlmsg_len += NETLINK_ALIGN(sizeof(struct rtgenmsg));
	209	rt->rtgen_family = AF_UNSPEC;
	210
	211	addattr32(nlh, NETLINK_SOCKET_BUFFER_SIZE, NETNSA_FD, fd);
	212	addattr32(nlh, NETLINK_SOCKET_BUFFER_SIZE, NETNSA_NSID, ns_id);
	213
	214	ret = send_receive(sock, nlh, seq, buf);
	215	if (ret < 0) {
	216	close(sock);
	217	close(fd);
	218	return NS_UNKNOWN;
	219	}
	220	nlh = (struct nlmsghdr *)buf;
	221
	222	/* message to analyse : NEWNSID response */
05895ad0	223	ret = 0;
b5891e15 A	224	if (nlh->nlmsg_type >= NLMSG_MIN_TYPE) {
	225	return_nsid = extract_nsid(nlh, buf);
	226	} else {
	227	if (nlh->nlmsg_type == NLMSG_ERROR) {
	228	struct nlmsgerr *err =
	229	(struct nlmsgerr
	230	)((char )nlh
	231	+ NETLINK_ALIGN(
	232	sizeof(struct nlmsghdr)));
	233
	234	ret = -1;
	235	if (err->error < 0)
	236	errno = -err->error;
	237	else
	238	errno = err->error;
	239	if (errno == 0) {
	240	/* request NEWNSID was successfull
	241	* return EEXIST error to get GETNSID
05895ad0	242	*/
05895ad0	243	errno = EEXIST;
05895ad0	244	}
b5891e15 A	245	} else {
	246	/* other errors ignored
	247	* attempt to get nsid
	248	*/
	249	ret = -1;
	250	errno = EEXIST;
05895ad0	251	}
b5891e15	252	}
05895ad0 PG	253
	254	if (ret <= 0) {
	255	if (errno != EEXIST && ret != 0) {
af4c2728	256	flog_err(
450971aa	257	EC_LIB_SOCKET,
996c9314 LB	258	"netlink( %u) recvfrom() error 2 when reading: %s",
996c9314 LB	259	fd, safe_strerror(errno));
05895ad0 PG	260	close(sock);
	261	close(fd);
	262	if (errno == ENOTSUP) {
9df414fe	263	zlog_debug("NEWNSID locally generated");
05895ad0 PG	264	return zebra_ns_id_get_fallback(netnspath);
	265	}
	266	return NS_UNKNOWN;
	267	}
	268	/* message to send to netlink : GETNSID */
	269	memset(buf, 0, NETLINK_SOCKET_BUFFER_SIZE);
	270	nlh = initiate_nlh(buf, &seq, RTM_GETNSID);
	271	rt = (struct rtgenmsg *)(buf + nlh->nlmsg_len);
	272	nlh->nlmsg_len += NETLINK_ALIGN(sizeof(struct rtgenmsg));
	273	rt->rtgen_family = AF_UNSPEC;
	274
	275	addattr32(nlh, NETLINK_SOCKET_BUFFER_SIZE, NETNSA_FD, fd);
	276	addattr32(nlh, NETLINK_SOCKET_BUFFER_SIZE, NETNSA_NSID, ns_id);
	277
	278	ret = send_receive(sock, nlh, seq, buf);
	279	if (ret < 0) {
	280	close(sock);
	281	close(fd);
	282	return NS_UNKNOWN;
	283	}
	284	nlh = (struct nlmsghdr *)buf;
	285	len = ret;
	286	ret = 0;
	287	do {
	288	if (nlh->nlmsg_type >= NLMSG_MIN_TYPE) {
	289	return_nsid = extract_nsid(nlh, buf);
	290	if (return_nsid != NS_UNKNOWN)
	291	break;
	292	} else if (nlh->nlmsg_type == NLMSG_ERROR) {
996c9314 LB	293	struct nlmsgerr *err =
	294	(struct nlmsgerr
	295	)((char )nlh
	296	+ NETLINK_ALIGN(sizeof(
	297	struct
	298	nlmsghdr)));
05895ad0 PG	299	if (err->error < 0)
	300	errno = -err->error;
	301	else
	302	errno = err->error;
	303	break;
	304	}
	305	len = len - NETLINK_ALIGN(nlh->nlmsg_len);
996c9314 LB	306	nlh = (struct nlmsghdr )((char )nlh
	307	+ NETLINK_ALIGN(
	308	nlh->nlmsg_len));
0cfbff74	309	} while (len != 0 && ret == 0);
05895ad0 PG	310	}
	311
	312	close(fd);
	313	close(sock);
	314	return return_nsid;
	315	}
	316
	317	#else
	318	ns_id_t zebra_ns_id_get(const char *netnspath)
	319	{
	320	return zebra_ns_id_get_fallback(netnspath);
	321	}
	322	#endif /* ! defined(HAVE_NETLINK) */
ec31f30d PG	323
	324	#ifdef HAVE_NETNS
	325	static void zebra_ns_create_netns_directory(void)
	326	{
	327	/* check that /var/run/netns is created */
	328	/* S_IRWXU\|S_IRGRP\|S_IXGRP\|S_IROTH\|S_IXOTH */
	329	if (mkdir(NS_RUN_DIR, 0755)) {
	330	if (errno != EEXIST) {
e914ccbe	331	flog_warn(EC_ZEBRA_NAMESPACE_DIR_INACCESSIBLE,
9df414fe	332	"NS check: failed to access %s", NS_RUN_DIR);
ec31f30d PG	333	return;
	334	}
	335	}
	336	}
	337	#endif
	338
	339	ns_id_t zebra_ns_id_get_default(void)
	340	{
	341	#ifdef HAVE_NETNS
	342	int fd;
	343	#endif /* !HAVE_NETNS */
	344
	345	#ifdef HAVE_NETNS
	346	if (vrf_is_backend_netns())
	347	zebra_ns_create_netns_directory();
	348	fd = open(NS_DEFAULT_NAME, O_RDONLY);
	349
	350	if (fd == -1)
	351	return NS_DEFAULT_INTERNAL;
4307629f DS	352	if (!vrf_is_backend_netns()) {
4307629f DS	353	close(fd);
ec31f30d	354	return NS_DEFAULT_INTERNAL;
4307629f	355	}
ec31f30d PG	356	close(fd);
ec31f30d PG	357	return zebra_ns_id_get((char *)NS_DEFAULT_NAME);
996c9314	358	#else /* HAVE_NETNS */
ec31f30d PG	359	return NS_DEFAULT_INTERNAL;
	360	#endif /* !HAVE_NETNS */
	361	}