Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	usr.sbin/npppd/npppd/../common/recvfromto.c	Lines:	0	87	0.0 %
Date:	2017-11-07	Branches:	0	40	0.0 %


/*	$OpenBSD: recvfromto.c,v 1.6 2015/12/17 08:01:55 tb Exp $ */
/* adapted from ipsec-tools 0.6 src/racoon/sockmisc.c */
/*
 * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. Neither the name of the project nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/uio.h>
#include <netinet/in.h>
#include <string.h>

#include "recvfromto.h"

/*
 * Receive packet, with src/dst information.  It is assumed that necessary
 * setsockopt() have already performed on socket.
 */
int
recvfromto_nat_t(s, buf, buflen, flags, from, fromlen, to, tolen,
    ipsec, ipseclen)
	int s;
	void *buf;
	size_t buflen;
	int flags;
	struct sockaddr *from;
	u_int *fromlen;
	struct sockaddr *to;
	u_int *tolen;
	void *ipsec;
	u_int *ipseclen;
{
	int otolen;
	u_int oipseclen = 0;
	ssize_t len;
	struct sockaddr_storage ss;
	struct msghdr m;
	struct cmsghdr *cm;
	struct iovec iov[2];
	u_char cmsgbuf[256];
	struct in6_pktinfo *pi;
	struct sockaddr_in *sin4;
	socklen_t sslen;
	struct sockaddr_in6 *sin6;

	sslen = sizeof(ss);
	if (getsockname(s, (struct sockaddr *)&ss, &sslen) < 0)
		return -1;

	m.msg_name = (caddr_t)from;
	m.msg_namelen = *fromlen;
	iov[0].iov_base = (caddr_t)buf;
	iov[0].iov_len = buflen;
	m.msg_iov = iov;
	m.msg_iovlen = 1;
	memset(cmsgbuf, 0, sizeof(cmsgbuf));
	cm = (struct cmsghdr *)cmsgbuf;
	m.msg_control = (caddr_t)cm;
	m.msg_controllen = sizeof(cmsgbuf);
	if ((len = recvmsg(s, &m, flags)) <= 0) {
		return len;
	}
	*fromlen = m.msg_namelen;

	if (ipsec && ipseclen) {
		oipseclen = *ipseclen;
		*ipseclen = 0;
	}
	otolen = *tolen;
	*tolen = 0;
	for (cm = (struct cmsghdr *)CMSG_FIRSTHDR(&m);
	     m.msg_controllen != 0 && cm;
	     cm = (struct cmsghdr *)CMSG_NXTHDR(&m, cm)) {
		if (ss.ss_family == AF_INET6
		 && cm->cmsg_level == IPPROTO_IPV6
		 && cm->cmsg_type == IPV6_PKTINFO
		 && otolen >= sizeof(*sin6)) {
			pi = (struct in6_pktinfo *)(CMSG_DATA(cm));
			*tolen = sizeof(*sin6);
			sin6 = (struct sockaddr_in6 *)to;
			memset(sin6, 0, sizeof(*sin6));
			sin6->sin6_family = AF_INET6;
#ifndef __linux__
			sin6->sin6_len = sizeof(*sin6);
#endif
			memcpy(&sin6->sin6_addr, &pi->ipi6_addr,
				sizeof(sin6->sin6_addr));
			/* XXX other cases, such as site-local? */
			if (IN6_IS_ADDR_LINKLOCAL(&sin6->sin6_addr))
				sin6->sin6_scope_id = pi->ipi6_ifindex;
			else
				sin6->sin6_scope_id = 0;
			sin6->sin6_port =
				((struct sockaddr_in6 *)&ss)->sin6_port;
			otolen = -1;	/* "to" already set */
			continue;
		}
#ifdef IP_IPSECFLOWINFO
		if (ss.ss_family == AF_INET	/* ?? */
		 && cm->cmsg_level == IPPROTO_IP
		 && cm->cmsg_type == IP_IPSECFLOWINFO
		 && oipseclen >= sizeof(u_int32_t)) {
			*ipseclen = sizeof(u_int32_t);
			memcpy(ipsec, CMSG_DATA(cm), *ipseclen);
			continue;
		}
#endif
#ifdef __linux__
		if (ss.ss_family == AF_INET
		 && cm->cmsg_level == IPPROTO_IP
		 && cm->cmsg_type == IP_PKTINFO
		 && otolen >= sizeof(sin4)) {
			struct in_pktinfo *pi = (struct in_pktinfo *)(CMSG_DATA(cm));
			*tolen = sizeof(*sin4);
			sin4 = (struct sockaddr_in *)to;
			memset(sin4, 0, sizeof(*sin4));
			sin4->sin_family = AF_INET;
			memcpy(&sin4->sin_addr, &pi->ipi_addr,
				sizeof(sin4->sin_addr));
			sin4->sin_port =
				((struct sockaddr_in *)&ss)->sin_port;
			otolen = -1;	/* "to" already set */
			continue;
		}
#endif
#ifdef IPV6_RECVDSTADDR
		if (ss.ss_family == AF_INET6
		      && cm->cmsg_level == IPPROTO_IPV6
		      && cm->cmsg_type == IPV6_RECVDSTADDR
		      && otolen >= sizeof(*sin6)) {
			*tolen = sizeof(*sin6);
			sin6 = (struct sockaddr_in6 *)to;
			memset(sin6, 0, sizeof(*sin6));
			sin6->sin6_family = AF_INET6;
			sin6->sin6_len = sizeof(*sin6);
			memcpy(&sin6->sin6_addr, CMSG_DATA(cm),
				sizeof(sin6->sin6_addr));
			sin6->sin6_port =
				((struct sockaddr_in6 *)&ss)->sin6_port;
			otolen = -1;	/* "to" already set */
			continue;
		}
#endif
#ifndef __linux__
		if (ss.ss_family == AF_INET
		 && cm->cmsg_level == IPPROTO_IP
		 && cm->cmsg_type == IP_RECVDSTADDR
		 && otolen >= sizeof(*sin4)) {
			*tolen = sizeof(*sin4);
			sin4 = (struct sockaddr_in *)to;
			memset(sin4, 0, sizeof(*sin4));
			sin4->sin_family = AF_INET;
			sin4->sin_len = sizeof(*sin4);
			memcpy(&sin4->sin_addr, CMSG_DATA(cm),
				sizeof(sin4->sin_addr));
			sin4->sin_port = ((struct sockaddr_in *)&ss)->sin_port;
			otolen = -1;	/* "to" already set */
			continue;
		}
#endif
	}

	return len;
}

int
recvfromto(s, buf, buflen, flags, from, fromlen, to, tolen)
	int s;
	void *buf;
	size_t buflen;
	int flags;
	struct sockaddr *from;
	u_int *fromlen;
	struct sockaddr *to;
	u_int *tolen;
{
	return recvfromto_nat_t(s, buf, buflen, flags, from, fromlen,
	    to, tolen, NULL, NULL);
}

int
sendto_nat_t(s, buf, buflen, flags, to, tolen, ipsec)
	int s;
	const void *buf;
	size_t buflen;
	int flags;
	struct sockaddr *to;
	u_int tolen;
	void *ipsec;
{
#ifdef IP_IPSECFLOWINFO
	if (ipsec) {
		struct iovec iov[1];
		struct msghdr msg;
		struct cmsghdr  *cmsg;
		union {
			struct cmsghdr  hdr;
			char            buf[CMSG_SPACE(sizeof(u_int32_t))];
		} cmsgbuf;

		iov[0].iov_base = (char *)buf;
		iov[0].iov_len = buflen;
		memset(&msg, 0, sizeof(msg));
		memset(&cmsgbuf, 0, sizeof(cmsgbuf));
		msg.msg_name = to;
		msg.msg_namelen = tolen;
		msg.msg_iov = iov;
		msg.msg_iovlen = 1;
		msg.msg_control = (caddr_t)&cmsgbuf.buf;
		msg.msg_controllen = sizeof(cmsgbuf.buf);
		cmsg = CMSG_FIRSTHDR(&msg);
		cmsg->cmsg_len = CMSG_LEN(sizeof(u_int32_t));
		cmsg->cmsg_level = IPPROTO_IP;
		cmsg->cmsg_type = IP_IPSECFLOWINFO;
		memcpy(CMSG_DATA(cmsg), ipsec, sizeof(u_int32_t));
		return sendmsg(s, &msg, flags);
	}
#endif
	return sendto(s, buf, buflen, flags, to, tolen);
}


Generated by: GCOVR (Version 3.3)

Line	Branch	Exec	Source
1			/* $OpenBSD: recvfromto.c,v 1.6 2015/12/17 08:01:55 tb Exp $ */
2			/* adapted from ipsec-tools 0.6 src/racoon/sockmisc.c */
3			/*
4			* Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.
5			* All rights reserved.
6			*
7			* Redistribution and use in source and binary forms, with or without
8			* modification, are permitted provided that the following conditions
9			* are met:
10			* 1. Redistributions of source code must retain the above copyright
11			* notice, this list of conditions and the following disclaimer.
12			* 2. Redistributions in binary form must reproduce the above copyright
13			* notice, this list of conditions and the following disclaimer in the
14			* documentation and/or other materials provided with the distribution.
15			* 3. Neither the name of the project nor the names of its contributors
16			* may be used to endorse or promote products derived from this software
17			* without specific prior written permission.
18			*
19			* THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
20			* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21			* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22			* ARE DISCLAIMED. IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
23			* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
24			* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
25			* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
26			* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27			* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
28			* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29			* SUCH DAMAGE.
30			*/
31			#include <sys/types.h>
32			#include <sys/socket.h>
33			#include <sys/uio.h>
34			#include <netinet/in.h>
35			#include <string.h>
36
37			#include "recvfromto.h"
38
39			/*
40			* Receive packet, with src/dst information. It is assumed that necessary
41			* setsockopt() have already performed on socket.
42			*/
43			int
44			recvfromto_nat_t(s, buf, buflen, flags, from, fromlen, to, tolen,
45			ipsec, ipseclen)
46			int s;
47			void *buf;
48			size_t buflen;
49			int flags;
50			struct sockaddr *from;
51			u_int *fromlen;
52			struct sockaddr *to;
53			u_int *tolen;
54			void *ipsec;
55			u_int *ipseclen;
56			{
57			int otolen;
58			u_int oipseclen = 0;
59			ssize_t len;
60			struct sockaddr_storage ss;
61			struct msghdr m;
62			struct cmsghdr *cm;
63			struct iovec iov[2];
64			u_char cmsgbuf[256];
65			struct in6_pktinfo *pi;
66			struct sockaddr_in *sin4;
67			socklen_t sslen;
68			struct sockaddr_in6 *sin6;
69
70			sslen = sizeof(ss);
71			if (getsockname(s, (struct sockaddr *)&ss, &sslen) < 0)
72			return -1;
73
74			m.msg_name = (caddr_t)from;
75			m.msg_namelen = *fromlen;
76			iov[0].iov_base = (caddr_t)buf;
77			iov[0].iov_len = buflen;
78			m.msg_iov = iov;
79			m.msg_iovlen = 1;
80			memset(cmsgbuf, 0, sizeof(cmsgbuf));
81			cm = (struct cmsghdr *)cmsgbuf;
82			m.msg_control = (caddr_t)cm;
83			m.msg_controllen = sizeof(cmsgbuf);
84			if ((len = recvmsg(s, &m, flags)) <= 0) {
85			return len;
86			}
87			*fromlen = m.msg_namelen;
88
89			if (ipsec && ipseclen) {
90			oipseclen = *ipseclen;
91			*ipseclen = 0;
92			}
93			otolen = *tolen;
94			*tolen = 0;
95			for (cm = (struct cmsghdr *)CMSG_FIRSTHDR(&m);
96			m.msg_controllen != 0 && cm;
97			cm = (struct cmsghdr *)CMSG_NXTHDR(&m, cm)) {
98			if (ss.ss_family == AF_INET6
99			&& cm->cmsg_level == IPPROTO_IPV6
100			&& cm->cmsg_type == IPV6_PKTINFO
101			&& otolen >= sizeof(*sin6)) {
102			pi = (struct in6_pktinfo *)(CMSG_DATA(cm));
103			tolen = sizeof(sin6);
104			sin6 = (struct sockaddr_in6 *)to;
105			memset(sin6, 0, sizeof(*sin6));
106			sin6->sin6_family = AF_INET6;
107			#ifndef __linux__
108			sin6->sin6_len = sizeof(*sin6);
109			#endif
110			memcpy(&sin6->sin6_addr, &pi->ipi6_addr,
111			sizeof(sin6->sin6_addr));
112			/* XXX other cases, such as site-local? */
113			if (IN6_IS_ADDR_LINKLOCAL(&sin6->sin6_addr))
114			sin6->sin6_scope_id = pi->ipi6_ifindex;
115			else
116			sin6->sin6_scope_id = 0;
117			sin6->sin6_port =
118			((struct sockaddr_in6 *)&ss)->sin6_port;
119			otolen = -1; /* "to" already set */
120			continue;
121			}
122			#ifdef IP_IPSECFLOWINFO
123			if (ss.ss_family == AF_INET /* ?? */
124			&& cm->cmsg_level == IPPROTO_IP
125			&& cm->cmsg_type == IP_IPSECFLOWINFO
126			&& oipseclen >= sizeof(u_int32_t)) {
127			*ipseclen = sizeof(u_int32_t);
128			memcpy(ipsec, CMSG_DATA(cm), *ipseclen);
129			continue;
130			}
131			#endif
132			#ifdef __linux__
133			if (ss.ss_family == AF_INET
134			&& cm->cmsg_level == IPPROTO_IP
135			&& cm->cmsg_type == IP_PKTINFO
136			&& otolen >= sizeof(sin4)) {
137			struct in_pktinfo pi = (struct in_pktinfo )(CMSG_DATA(cm));
138			tolen = sizeof(sin4);
139			sin4 = (struct sockaddr_in *)to;
140			memset(sin4, 0, sizeof(*sin4));
141			sin4->sin_family = AF_INET;
142			memcpy(&sin4->sin_addr, &pi->ipi_addr,
143			sizeof(sin4->sin_addr));
144			sin4->sin_port =
145			((struct sockaddr_in *)&ss)->sin_port;
146			otolen = -1; /* "to" already set */
147			continue;
148			}
149			#endif
150			#ifdef IPV6_RECVDSTADDR
151			if (ss.ss_family == AF_INET6
152			&& cm->cmsg_level == IPPROTO_IPV6
153			&& cm->cmsg_type == IPV6_RECVDSTADDR
154			&& otolen >= sizeof(*sin6)) {
155			tolen = sizeof(sin6);
156			sin6 = (struct sockaddr_in6 *)to;
157			memset(sin6, 0, sizeof(*sin6));
158			sin6->sin6_family = AF_INET6;
159			sin6->sin6_len = sizeof(*sin6);
160			memcpy(&sin6->sin6_addr, CMSG_DATA(cm),
161			sizeof(sin6->sin6_addr));
162			sin6->sin6_port =
163			((struct sockaddr_in6 *)&ss)->sin6_port;
164			otolen = -1; /* "to" already set */
165			continue;
166			}
167			#endif
168			#ifndef __linux__
169			if (ss.ss_family == AF_INET
170			&& cm->cmsg_level == IPPROTO_IP
171			&& cm->cmsg_type == IP_RECVDSTADDR
172			&& otolen >= sizeof(*sin4)) {
173			tolen = sizeof(sin4);
174			sin4 = (struct sockaddr_in *)to;
175			memset(sin4, 0, sizeof(*sin4));
176			sin4->sin_family = AF_INET;
177			sin4->sin_len = sizeof(*sin4);
178			memcpy(&sin4->sin_addr, CMSG_DATA(cm),
179			sizeof(sin4->sin_addr));
180			sin4->sin_port = ((struct sockaddr_in *)&ss)->sin_port;
181			otolen = -1; /* "to" already set */
182			continue;
183			}
184			#endif
185			}
186
187			return len;
188			}
189
190			int
191			recvfromto(s, buf, buflen, flags, from, fromlen, to, tolen)
192			int s;
193			void *buf;
194			size_t buflen;
195			int flags;
196			struct sockaddr *from;
197			u_int *fromlen;
198			struct sockaddr *to;
199			u_int *tolen;
200			{
201			return recvfromto_nat_t(s, buf, buflen, flags, from, fromlen,
202			to, tolen, NULL, NULL);
203			}
204
205			int
206			sendto_nat_t(s, buf, buflen, flags, to, tolen, ipsec)
207			int s;
208			const void *buf;
209			size_t buflen;
210			int flags;
211			struct sockaddr *to;
212			u_int tolen;
213			void *ipsec;
214			{
215			#ifdef IP_IPSECFLOWINFO
216			if (ipsec) {
217			struct iovec iov[1];
218			struct msghdr msg;
219			struct cmsghdr *cmsg;
220			union {
221			struct cmsghdr hdr;
222			char buf[CMSG_SPACE(sizeof(u_int32_t))];
223			} cmsgbuf;
224
225			iov[0].iov_base = (char *)buf;
226			iov[0].iov_len = buflen;
227			memset(&msg, 0, sizeof(msg));
228			memset(&cmsgbuf, 0, sizeof(cmsgbuf));
229			msg.msg_name = to;
230			msg.msg_namelen = tolen;
231			msg.msg_iov = iov;
232			msg.msg_iovlen = 1;
233			msg.msg_control = (caddr_t)&cmsgbuf.buf;
234			msg.msg_controllen = sizeof(cmsgbuf.buf);
235			cmsg = CMSG_FIRSTHDR(&msg);
236			cmsg->cmsg_len = CMSG_LEN(sizeof(u_int32_t));
237			cmsg->cmsg_level = IPPROTO_IP;
238			cmsg->cmsg_type = IP_IPSECFLOWINFO;
239			memcpy(CMSG_DATA(cmsg), ipsec, sizeof(u_int32_t));
240			return sendmsg(s, &msg, flags);
241			}
242			#endif
243			return sendto(s, buf, buflen, flags, to, tolen);
244			}