2661

pending completion

Build # 2661

Build Type

push

travis-ci

Committed by

jaltman

Commit Message

asn1: function ptrs passed as ASN1CALL ptrs must be ASN1CALL

On Windows i386 the asn1 tests would crash due to stack corruption
as a result of functions being executed with the wrong calling
conventions.

Change-Id: Ic4f8b3a05

Run Details

76888 of 145819 relevant lines covered (52.73%)

889479.8 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

23.71

/lib/roken/socket.c

/*
 * Copyright (c) 1999 - 2000 Kungliga Tekniska Högskolan
 * (Royal Institute of Technology, Stockholm, Sweden).
 * 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 Institute 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 INSTITUTE 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 INSTITUTE 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 <config.h>

#include "roken.h"
#include <err.h>

/*
 * Set `sa' to the unitialized address of address family `af'
 */

ROKEN_LIB_FUNCTION void ROKEN_LIB_CALL
socket_set_any (struct sockaddr *sa, int af)
{
    switch (af) {
    case AF_INET : {
        struct sockaddr_in *sin4 = (struct sockaddr_in *)sa;

        memset (sin4, 0, sizeof(*sin4));
        sin4->sin_family = AF_INET;
        sin4->sin_port   = 0;
        sin4->sin_addr.s_addr = INADDR_ANY;
        break;
    }
#ifdef HAVE_IPV6
    case AF_INET6 : {
        struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)sa;

        memset (sin6, 0, sizeof(*sin6));
        sin6->sin6_family = AF_INET6;
        sin6->sin6_port   = 0;
        sin6->sin6_addr   = in6addr_any;
        break;
    }
#endif
    default :
        errx (1, "unknown address family %d", sa->sa_family);
        break;
    }
}

/*
 * set `sa' to (`ptr', `port')
 */

ROKEN_LIB_FUNCTION void ROKEN_LIB_CALL
socket_set_address_and_port (struct sockaddr *sa, const void *ptr, int port)
{
    switch (sa->sa_family) {
    case AF_INET : {
        struct sockaddr_in *sin4 = (struct sockaddr_in *)sa;

        memset (sin4, 0, sizeof(*sin4));
        sin4->sin_family = AF_INET;
        sin4->sin_port   = port;
        memcpy (&sin4->sin_addr, ptr, sizeof(struct in_addr));
        break;
    }
#ifdef HAVE_IPV6
    case AF_INET6 : {
        struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)sa;

        memset (sin6, 0, sizeof(*sin6));
        sin6->sin6_family = AF_INET6;
        sin6->sin6_port   = port;
        memcpy (&sin6->sin6_addr, ptr, sizeof(struct in6_addr));
        break;
    }
#endif
    default :
        errx (1, "unknown address family %d", sa->sa_family);
        break;
    }
}

/*
 * Return the size of an address of the type in `sa'
 */

ROKEN_LIB_FUNCTION size_t ROKEN_LIB_CALL
socket_addr_size (const struct sockaddr *sa)
{
    switch (sa->sa_family) {
    case AF_INET :
        return sizeof(struct in_addr);
#ifdef HAVE_IPV6
    case AF_INET6 :
        return sizeof(struct in6_addr);
#endif
    default :
        return 0;
    }
}

/*
 * Return the size of a `struct sockaddr' in `sa'.
 */

ROKEN_LIB_FUNCTION size_t ROKEN_LIB_CALL
socket_sockaddr_size (const struct sockaddr *sa)
{
    switch (sa->sa_family) {
    case AF_INET :
        return sizeof(struct sockaddr_in);
#ifdef HAVE_IPV6
    case AF_INET6 :
        return sizeof(struct sockaddr_in6);
#endif
    default:
        return 0;
    }
}

/*
 * Return the binary address of `sa'.
 */

ROKEN_LIB_FUNCTION void * ROKEN_LIB_CALL
socket_get_address (const struct sockaddr *sa)
{
    switch (sa->sa_family) {
    case AF_INET : {
        const struct sockaddr_in *sin4 = (const struct sockaddr_in *)sa;
        return rk_UNCONST(&sin4->sin_addr);
    }
#ifdef HAVE_IPV6
    case AF_INET6 : {
        const struct sockaddr_in6 *sin6 = (const struct sockaddr_in6 *)sa;
        return rk_UNCONST(&sin6->sin6_addr);
    }
#endif
    default:
        return NULL;
    }
}

/*
 * Return the port number from `sa'.
 */

ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL
socket_get_port (const struct sockaddr *sa)
{
    switch (sa->sa_family) {
    case AF_INET : {
        const struct sockaddr_in *sin4 = (const struct sockaddr_in *)sa;
        return sin4->sin_port;
    }
#ifdef HAVE_IPV6
    case AF_INET6 : {
        const struct sockaddr_in6 *sin6 = (const struct sockaddr_in6 *)sa;
        return sin6->sin6_port;
    }
#endif
    default :
        return 0;
    }
}

/*
 * Set the port in `sa' to `port'.
 */

ROKEN_LIB_FUNCTION void ROKEN_LIB_CALL
socket_set_port (struct sockaddr *sa, int port)
{
    switch (sa->sa_family) {
    case AF_INET : {
        struct sockaddr_in *sin4 = (struct sockaddr_in *)sa;
        sin4->sin_port = port;
        break;
    }
#ifdef HAVE_IPV6
    case AF_INET6 : {
        struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)sa;
        sin6->sin6_port = port;
        break;
    }
#endif
    default :
        errx (1, "unknown address family %d", sa->sa_family);
        break;
    }
}

/*
 * Set the range of ports to use when binding with port = 0.
 */
ROKEN_LIB_FUNCTION void ROKEN_LIB_CALL
socket_set_portrange (rk_socket_t sock, int restr, int af)
{
#if defined(IP_PORTRANGE)
        if (af == AF_INET) {
                int on = restr ? IP_PORTRANGE_HIGH : IP_PORTRANGE_DEFAULT;
                setsockopt (sock, IPPROTO_IP, IP_PORTRANGE, &on, sizeof(on));
        }
#endif
#if defined(IPV6_PORTRANGE)
        if (af == AF_INET6) {
                int on = restr ? IPV6_PORTRANGE_HIGH : IPV6_PORTRANGE_DEFAULT;
                setsockopt (sock, IPPROTO_IPV6, IPV6_PORTRANGE, &on, sizeof(on));
        }
#endif
}

/*
 * Enable debug on `sock'.
 */

ROKEN_LIB_FUNCTION void ROKEN_LIB_CALL
socket_set_debug (rk_socket_t sock)
{
#if defined(SO_DEBUG) && defined(HAVE_SETSOCKOPT)
    int on = 1;
    setsockopt (sock, SOL_SOCKET, SO_DEBUG, (void *) &on, sizeof (on));
#endif
}

/*
 * Set the type-of-service of `sock' to `tos'.
 */

ROKEN_LIB_FUNCTION void ROKEN_LIB_CALL
socket_set_tos (rk_socket_t sock, int tos)
{
#if defined(IP_TOS) && defined(HAVE_SETSOCKOPT)
    setsockopt (sock, IPPROTO_IP, IP_TOS, (void *) &tos, sizeof(int));
#endif
}

/*
 * Set the non-blocking-ness of the socket.
 */

ROKEN_LIB_FUNCTION void ROKEN_LIB_CALL
socket_set_nonblocking(rk_socket_t sock, int nonblock)
{
#if defined(O_NONBLOCK)
    int flags = fcntl(sock, F_GETFL, 0);
    if (flags == -1)
        return;
    if (nonblock)
        flags |= O_NONBLOCK;
    else
        flags &= ~O_NONBLOCK;
    fcntl(sock, F_SETFL, flags);
#elif defined(FIOBIO)
    int flags = !!nonblock;
    return ioctl(sock, FIOBIO, &flags);
#endif
}

/*
 * set the reuse of addresses on `sock' to `val'.
 */

ROKEN_LIB_FUNCTION void ROKEN_LIB_CALL
socket_set_reuseaddr (rk_socket_t sock, int val)
{
#if defined(SO_REUSEADDR) && defined(HAVE_SETSOCKOPT)
    setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (void *)&val, sizeof(val));
#endif
}

/*
 * Set the that the `sock' should bind to only IPv6 addresses.
 */

ROKEN_LIB_FUNCTION void ROKEN_LIB_CALL
socket_set_ipv6only (rk_socket_t sock, int val)
{
#if defined(IPV6_V6ONLY) && defined(HAVE_SETSOCKOPT)
    setsockopt(sock, IPPROTO_IPV6, IPV6_V6ONLY, (void *)&val, sizeof(val));
#endif
}

/**
 * Create a file descriptor from a socket
 *
 * While the socket handle in \a sock can be used with WinSock
 * functions after calling socket_to_fd(), it should not be closed
 * with rk_closesocket().  The socket will be closed when the associated
 * file descriptor is closed.
 */
ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL
socket_to_fd(rk_socket_t sock, int flags)
{
#ifndef _WIN32
    return sock;
#else
    return _open_osfhandle((intptr_t) sock, flags);
#endif
}

#ifdef HAVE_WINSOCK
ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL
rk_SOCK_IOCTL(SOCKET s, long cmd, int * argp) {
    u_long ul = (argp)? *argp : 0;
    int rv;

    rv = ioctlsocket(s, cmd, &ul);
    if (argp)
        *argp = (int) ul;
    return rv;
}
#endif

#ifndef HEIMDAL_SMALLER
#undef socket

int rk_socket(int, int, int);

int
rk_socket(int domain, int type, int protocol)
{
    int s;
    s = socket (domain, type, protocol);
#ifdef SOCK_CLOEXEC
    if ((SOCK_CLOEXEC & type) && s < 0 && errno == EINVAL) {
        type &= ~SOCK_CLOEXEC;
        s = socket (domain, type, protocol);
    }
#endif
    return s;
}

#endif /* HEIMDAL_SMALLER */

1	/*
2	* Copyright (c) 1999 - 2000 Kungliga Tekniska Högskolan
3	* (Royal Institute of Technology, Stockholm, Sweden).
4	* All rights reserved.
5	*
6	* Redistribution and use in source and binary forms, with or without
7	* modification, are permitted provided that the following conditions
8	* are met:
9	*
10	* 1. Redistributions of source code must retain the above copyright
11	* notice, this list of conditions and the following disclaimer.
12	*
13	* 2. Redistributions in binary form must reproduce the above copyright
14	* notice, this list of conditions and the following disclaimer in the
15	* documentation and/or other materials provided with the distribution.
16	*
17	* 3. Neither the name of the Institute nor the names of its contributors
18	* may be used to endorse or promote products derived from this software
19	* without specific prior written permission.
20	*
21	* THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
22	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24	* ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
25	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30	* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31	* SUCH DAMAGE.
32	*/
33
34	#include <config.h>
35
36	#include "roken.h"
37	#include <err.h>
38
39	/*
40	* Set `sa' to the unitialized address of address family `af'
41	*/
42
43	ROKEN_LIB_FUNCTION void ROKEN_LIB_CALL
44	socket_set_any (struct sockaddr *sa, int af)	×
45	{
46	switch (af) {	×
47	case AF_INET : {
48	struct sockaddr_in sin4 = (struct sockaddr_in )sa;	×
49
50	memset (sin4, 0, sizeof(*sin4));	×
51	sin4->sin_family = AF_INET;	×
52	sin4->sin_port = 0;	×
53	sin4->sin_addr.s_addr = INADDR_ANY;	×
54	break;	×
55	}
56	#ifdef HAVE_IPV6
57	case AF_INET6 : {
58	struct sockaddr_in6 sin6 = (struct sockaddr_in6 )sa;	×
59
60	memset (sin6, 0, sizeof(*sin6));	×
61	sin6->sin6_family = AF_INET6;	×
62	sin6->sin6_port = 0;	×
63	sin6->sin6_addr = in6addr_any;	×
64	break;	×
65	}
66	#endif
67	default :
68	errx (1, "unknown address family %d", sa->sa_family);	×
69	break;
70	}
71	}	×
72
73	/*
74	* set `sa' to (`ptr', `port')
75	*/
76
77	ROKEN_LIB_FUNCTION void ROKEN_LIB_CALL
78	socket_set_address_and_port (struct sockaddr sa, const void ptr, int port)	×
79	{
80	switch (sa->sa_family) {	×
81	case AF_INET : {
82	struct sockaddr_in sin4 = (struct sockaddr_in )sa;	×
83
84	memset (sin4, 0, sizeof(*sin4));	×
85	sin4->sin_family = AF_INET;	×
86	sin4->sin_port = port;	×
87	memcpy (&sin4->sin_addr, ptr, sizeof(struct in_addr));	×
88	break;	×
89	}
90	#ifdef HAVE_IPV6
91	case AF_INET6 : {
92	struct sockaddr_in6 sin6 = (struct sockaddr_in6 )sa;	×
93
94	memset (sin6, 0, sizeof(*sin6));	×
95	sin6->sin6_family = AF_INET6;	×
96	sin6->sin6_port = port;	×
97	memcpy (&sin6->sin6_addr, ptr, sizeof(struct in6_addr));	×
98	break;	×
99	}
100	#endif
101	default :
102	errx (1, "unknown address family %d", sa->sa_family);	×
103	break;
104	}
105	}	×
106
107	/*
108	* Return the size of an address of the type in `sa'
109	*/
110
111	ROKEN_LIB_FUNCTION size_t ROKEN_LIB_CALL
112	socket_addr_size (const struct sockaddr *sa)	×
113	{
114	switch (sa->sa_family) {	×
115	case AF_INET :
116	return sizeof(struct in_addr);	×
117	#ifdef HAVE_IPV6
118	case AF_INET6 :
119	return sizeof(struct in6_addr);	×
120	#endif
121	default :
122	return 0;	×
123	}
124	}
125
126	/*
127	* Return the size of a `struct sockaddr' in `sa'.
128	*/
129
130	ROKEN_LIB_FUNCTION size_t ROKEN_LIB_CALL
131	socket_sockaddr_size (const struct sockaddr *sa)	1✔
132	{
133	switch (sa->sa_family) {	1✔
134	case AF_INET :
135	return sizeof(struct sockaddr_in);	1✔
136	#ifdef HAVE_IPV6
137	case AF_INET6 :
138	return sizeof(struct sockaddr_in6);	×
139	#endif
140	default:
141	return 0;	×
142	}
143	}
144
145	/*
146	* Return the binary address of `sa'.
147	*/
148
149	ROKEN_LIB_FUNCTION void * ROKEN_LIB_CALL
150	socket_get_address (const struct sockaddr *sa)	×
151	{
152	switch (sa->sa_family) {	×
153	case AF_INET : {
154	const struct sockaddr_in sin4 = (const struct sockaddr_in )sa;	×
155	return rk_UNCONST(&sin4->sin_addr);	×
156	}
157	#ifdef HAVE_IPV6
158	case AF_INET6 : {
159	const struct sockaddr_in6 sin6 = (const struct sockaddr_in6 )sa;	×
160	return rk_UNCONST(&sin6->sin6_addr);	×
161	}
162	#endif
163	default:
164	return NULL;	×
165	}
166	}
167
168	/*
169	* Return the port number from `sa'.
170	*/
171
172	ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL
173	socket_get_port (const struct sockaddr *sa)	1✔
174	{
175	switch (sa->sa_family) {	1✔
176	case AF_INET : {
177	const struct sockaddr_in sin4 = (const struct sockaddr_in )sa;	1✔
178	return sin4->sin_port;	1✔
179	}
180	#ifdef HAVE_IPV6
181	case AF_INET6 : {
182	const struct sockaddr_in6 sin6 = (const struct sockaddr_in6 )sa;	×
183	return sin6->sin6_port;	×
184	}
185	#endif
186	default :
187	return 0;	×
188	}
189	}
190
191	/*
192	* Set the port in `sa' to `port'.
193	*/
194
195	ROKEN_LIB_FUNCTION void ROKEN_LIB_CALL
196	socket_set_port (struct sockaddr *sa, int port)	×
197	{
198	switch (sa->sa_family) {	×
199	case AF_INET : {
200	struct sockaddr_in sin4 = (struct sockaddr_in )sa;	×
201	sin4->sin_port = port;	×
202	break;	×
203	}
204	#ifdef HAVE_IPV6
205	case AF_INET6 : {
206	struct sockaddr_in6 sin6 = (struct sockaddr_in6 )sa;	×
207	sin6->sin6_port = port;	×
208	break;	×
209	}
210	#endif
211	default :
212	errx (1, "unknown address family %d", sa->sa_family);	×
213	break;
214	}
215	}	×
216
217	/*
218	* Set the range of ports to use when binding with port = 0.
219	*/
220	ROKEN_LIB_FUNCTION void ROKEN_LIB_CALL
221	socket_set_portrange (rk_socket_t sock, int restr, int af)	×
222	{
223	#if defined(IP_PORTRANGE)
224	if (af == AF_INET) {
225	int on = restr ? IP_PORTRANGE_HIGH : IP_PORTRANGE_DEFAULT;
226	setsockopt (sock, IPPROTO_IP, IP_PORTRANGE, &on, sizeof(on));
227	}
228	#endif
229	#if defined(IPV6_PORTRANGE)
230	if (af == AF_INET6) {
231	int on = restr ? IPV6_PORTRANGE_HIGH : IPV6_PORTRANGE_DEFAULT;
232	setsockopt (sock, IPPROTO_IPV6, IPV6_PORTRANGE, &on, sizeof(on));
233	}
234	#endif
235	}	×
236
237	/*
238	* Enable debug on `sock'.
239	*/
240
241	ROKEN_LIB_FUNCTION void ROKEN_LIB_CALL
242	socket_set_debug (rk_socket_t sock)	×
243	{
244	#if defined(SO_DEBUG) && defined(HAVE_SETSOCKOPT)
245	int on = 1;	×
246	setsockopt (sock, SOL_SOCKET, SO_DEBUG, (void *) &on, sizeof (on));	×
247	#endif
248	}	×
249
250	/*
251	* Set the type-of-service of `sock' to `tos'.
252	*/
253
254	ROKEN_LIB_FUNCTION void ROKEN_LIB_CALL
255	socket_set_tos (rk_socket_t sock, int tos)	×
256	{
257	#if defined(IP_TOS) && defined(HAVE_SETSOCKOPT)
258	setsockopt (sock, IPPROTO_IP, IP_TOS, (void *) &tos, sizeof(int));	×
259	#endif
260	}	×
261
262	/*
263	* Set the non-blocking-ness of the socket.
264	*/
265
266	ROKEN_LIB_FUNCTION void ROKEN_LIB_CALL
267	socket_set_nonblocking(rk_socket_t sock, int nonblock)	1,674✔
268	{
269	#if defined(O_NONBLOCK)
270	int flags = fcntl(sock, F_GETFL, 0);	1,674✔
271	if (flags == -1)	1,674✔
272	return;	×
273	if (nonblock)	1,674✔
274	flags \|= O_NONBLOCK;	1,674✔
275	else
276	flags &= ~O_NONBLOCK;	×
277	fcntl(sock, F_SETFL, flags);	1,674✔
278	#elif defined(FIOBIO)
279	int flags = !!nonblock;
280	return ioctl(sock, FIOBIO, &flags);
281	#endif
282	}
283
284	/*
285	* set the reuse of addresses on `sock' to `val'.
286	*/
287
288	ROKEN_LIB_FUNCTION void ROKEN_LIB_CALL
289	socket_set_reuseaddr (rk_socket_t sock, int val)	44✔
290	{
291	#if defined(SO_REUSEADDR) && defined(HAVE_SETSOCKOPT)
292	setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (void *)&val, sizeof(val));	44✔
293	#endif
294	}	44✔
295
296	/*
297	* Set the that the `sock' should bind to only IPv6 addresses.
298	*/
299
300	ROKEN_LIB_FUNCTION void ROKEN_LIB_CALL
301	socket_set_ipv6only (rk_socket_t sock, int val)	45✔
302	{
303	#if defined(IPV6_V6ONLY) && defined(HAVE_SETSOCKOPT)
304	setsockopt(sock, IPPROTO_IPV6, IPV6_V6ONLY, (void *)&val, sizeof(val));	45✔
305	#endif
306	}	45✔
307
308	/**
309	* Create a file descriptor from a socket
310	*
311	* While the socket handle in \a sock can be used with WinSock
312	* functions after calling socket_to_fd(), it should not be closed
313	* with rk_closesocket(). The socket will be closed when the associated
314	* file descriptor is closed.
315	*/
316	ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL
317	socket_to_fd(rk_socket_t sock, int flags)	×
318	{
319	#ifndef _WIN32
320	return sock;	×
321	#else
322	return _open_osfhandle((intptr_t) sock, flags);
323	#endif
324	}
325
326	#ifdef HAVE_WINSOCK
327	ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL
328	rk_SOCK_IOCTL(SOCKET s, long cmd, int * argp) {
329	u_long ul = (argp)? *argp : 0;
330	int rv;
331
332	rv = ioctlsocket(s, cmd, &ul);
333	if (argp)
334	*argp = (int) ul;
335	return rv;
336	}
337	#endif
338
339	#ifndef HEIMDAL_SMALLER
340	#undef socket
341
342	int rk_socket(int, int, int);
343
344	int
345	rk_socket(int domain, int type, int protocol)	1,814✔
346	{
347	int s;
348	s = socket (domain, type, protocol);	1,814✔
349	#ifdef SOCK_CLOEXEC
350	if ((SOCK_CLOEXEC & type) && s < 0 && errno == EINVAL) {	1,814✔
351	type &= ~SOCK_CLOEXEC;	×
352	s = socket (domain, type, protocol);	×
353	}
354	#endif
355	return s;	1,814✔
356	}
357
358	#endif /* HEIMDAL_SMALLER */

heimdal / heimdal / 2661

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous