![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to net.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / ntp / lib / isc / win32|
Return to net.c CVS log | Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / ntp / lib / isc / win32 |
1.1 misho 1: /*
2: * Copyright (C) 2004, 2005, 2007, 2008 Internet Systems Consortium, Inc. ("ISC")
3: * Copyright (C) 1999-2003 Internet Software Consortium.
4: *
5: * Permission to use, copy, modify, and/or distribute this software for any
6: * purpose with or without fee is hereby granted, provided that the above
7: * copyright notice and this permission notice appear in all copies.
8: *
9: * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
10: * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
11: * AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
12: * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
13: * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
14: * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
15: * PERFORMANCE OF THIS SOFTWARE.
16: */
17:
18: /* $Id: net.c,v 1.18 2008/08/08 05:06:49 marka Exp $ */
19:
20: #include <config.h>
21:
22: #include <errno.h>
23: #include <unistd.h>
24:
25: #include <isc/log.h>
26: #include <isc/msgs.h>
27: #include <isc/net.h>
28: #include <isc/once.h>
29: #include <isc/strerror.h>
30: #include <isc/string.h>
31: #include <isc/util.h>
32:
33: /*%
34: * Definitions about UDP port range specification. This is a total mess of
35: * portability variants: some use sysctl (but the sysctl names vary), some use
36: * system-specific interfaces, some have the same interface for IPv4 and IPv6,
37: * some separate them, etc...
38: */
39:
40: /*%
41: * The last resort defaults: use all non well known port space
42: */
43: #ifndef ISC_NET_PORTRANGELOW
44: #define ISC_NET_PORTRANGELOW 1024
45: #endif /* ISC_NET_PORTRANGELOW */
46: #ifndef ISC_NET_PORTRANGEHIGH
47: #define ISC_NET_PORTRANGEHIGH 65535
48: #endif /* ISC_NET_PORTRANGEHIGH */
49:
50: #if defined(ISC_PLATFORM_NEEDIN6ADDRANY)
51: const struct in6_addr isc_net_in6addrany = IN6ADDR_ANY_INIT;
52: #endif
53:
54: #if defined(ISC_PLATFORM_NEEDIN6ADDRLOOPBACK)
55: const struct in6_addr isc_net_in6addrloop = IN6ADDR_LOOPBACK_INIT;
56: #endif
57:
58:
59: static isc_once_t once = ISC_ONCE_INIT;
60: static isc_once_t once_ipv6only = ISC_ONCE_INIT;
61: static isc_once_t once_ipv6pktinfo = ISC_ONCE_INIT;
62: static isc_result_t ipv4_result = ISC_R_NOTFOUND;
63: static isc_result_t ipv6_result = ISC_R_NOTFOUND;
64: static isc_result_t ipv6only_result = ISC_R_NOTFOUND;
65: static isc_result_t ipv6pktinfo_result = ISC_R_NOTFOUND;
66:
67: void InitSockets(void);
68:
69: static isc_result_t
70: try_proto(int domain) {
71: SOCKET s;
72: char strbuf[ISC_STRERRORSIZE];
73: int errval;
74:
75: s = socket(domain, SOCK_STREAM, IPPROTO_TCP);
76: if (s == INVALID_SOCKET) {
77: errval = WSAGetLastError();
78: switch (errval) {
79: case WSAEAFNOSUPPORT:
80: case WSAEPROTONOSUPPORT:
81: case WSAEINVAL:
82: return (ISC_R_NOTFOUND);
83: default:
84: isc__strerror(errval, strbuf, sizeof(strbuf));
85: UNEXPECTED_ERROR(__FILE__, __LINE__,
86: "socket() %s: %s",
87: isc_msgcat_get(isc_msgcat,
88: ISC_MSGSET_GENERAL,
89: ISC_MSG_FAILED,
90: "failed"),
91: strbuf);
92: return (ISC_R_UNEXPECTED);
93: }
94: }
95:
96: closesocket(s);
97:
98: return (ISC_R_SUCCESS);
99: }
100:
101: static void
102: initialize_action(void) {
103: InitSockets();
104: ipv4_result = try_proto(PF_INET);
105: #ifdef ISC_PLATFORM_HAVEIPV6
106: #ifdef WANT_IPV6
107: #ifdef ISC_PLATFORM_HAVEIN6PKTINFO
108: ipv6_result = try_proto(PF_INET6);
109: #endif
110: #endif
111: #endif
112: }
113:
114: static void
115: initialize(void) {
116: RUNTIME_CHECK(isc_once_do(&once, initialize_action) == ISC_R_SUCCESS);
117: }
118:
119: isc_result_t
120: isc_net_probeipv4(void) {
121: initialize();
122: return (ipv4_result);
123: }
124:
125: isc_result_t
126: isc_net_probeipv6(void) {
127: initialize();
128: return (ipv6_result);
129: }
130:
131: isc_result_t
132: isc_net_probeunix(void) {
133: return (ISC_R_NOTFOUND);
134: }
135:
136: #ifdef ISC_PLATFORM_HAVEIPV6
137: #ifdef WANT_IPV6
138: static void
139: try_ipv6only(void) {
140: #ifdef IPV6_V6ONLY
141: SOCKET s;
142: int on;
143: char strbuf[ISC_STRERRORSIZE];
144: #endif
145: isc_result_t result;
146:
147: result = isc_net_probeipv6();
148: if (result != ISC_R_SUCCESS) {
149: ipv6only_result = result;
150: return;
151: }
152:
153: #ifndef IPV6_V6ONLY
154: ipv6only_result = ISC_R_NOTFOUND;
155: return;
156: #else
157: /* check for TCP sockets */
158: s = socket(PF_INET6, SOCK_STREAM, 0);
159: if (s == INVALID_SOCKET) {
160: isc__strerror(errno, strbuf, sizeof(strbuf));
161: UNEXPECTED_ERROR(__FILE__, __LINE__,
162: "socket() %s: %s",
163: isc_msgcat_get(isc_msgcat,
164: ISC_MSGSET_GENERAL,
165: ISC_MSG_FAILED,
166: "failed"),
167: strbuf);
168: ipv6only_result = ISC_R_UNEXPECTED;
169: return;
170: }
171:
172: on = 1;
173: if (setsockopt(s, IPPROTO_IPV6, IPV6_V6ONLY, (char *)&on, sizeof(on)) < 0) {
174: ipv6only_result = ISC_R_NOTFOUND;
175: goto close;
176: }
177:
178: closesocket(s);
179:
180: /* check for UDP sockets */
181: s = socket(PF_INET6, SOCK_DGRAM, 0);
182: if (s == INVALID_SOCKET) {
183: isc__strerror(errno, strbuf, sizeof(strbuf));
184: UNEXPECTED_ERROR(__FILE__, __LINE__,
185: "socket() %s: %s",
186: isc_msgcat_get(isc_msgcat,
187: ISC_MSGSET_GENERAL,
188: ISC_MSG_FAILED,
189: "failed"),
190: strbuf);
191: ipv6only_result = ISC_R_UNEXPECTED;
192: return;
193: }
194:
195: on = 1;
196: if (setsockopt(s, IPPROTO_IPV6, IPV6_V6ONLY, (char *)&on, sizeof(on)) < 0) {
197: ipv6only_result = ISC_R_NOTFOUND;
198: goto close;
199: }
200:
201: ipv6only_result = ISC_R_SUCCESS;
202:
203: close:
204: closesocket(s);
205: return;
206: #endif /* IPV6_V6ONLY */
207: }
208:
209: static void
210: initialize_ipv6only(void) {
211: RUNTIME_CHECK(isc_once_do(&once_ipv6only,
212: try_ipv6only) == ISC_R_SUCCESS);
213: }
214:
215: static void
216: try_ipv6pktinfo(void) {
217: int s, on;
218: char strbuf[ISC_STRERRORSIZE];
219: isc_result_t result;
220: int optname;
221:
222: result = isc_net_probeipv6();
223: if (result != ISC_R_SUCCESS) {
224: ipv6pktinfo_result = result;
225: return;
226: }
227:
228: /* we only use this for UDP sockets */
229: s = socket(PF_INET6, SOCK_DGRAM, IPPROTO_UDP);
230: if (s == INVALID_SOCKET) {
231: isc__strerror(errno, strbuf, sizeof(strbuf));
232: UNEXPECTED_ERROR(__FILE__, __LINE__,
233: "socket() %s: %s",
234: isc_msgcat_get(isc_msgcat,
235: ISC_MSGSET_GENERAL,
236: ISC_MSG_FAILED,
237: "failed"),
238: strbuf);
239: ipv6pktinfo_result = ISC_R_UNEXPECTED;
240: return;
241: }
242:
243: #ifdef IPV6_RECVPKTINFO
244: optname = IPV6_RECVPKTINFO;
245: #else
246: optname = IPV6_PKTINFO;
247: #endif
248: on = 1;
249: if (setsockopt(s, IPPROTO_IPV6, optname, (const char *) &on,
250: sizeof(on)) < 0) {
251: ipv6pktinfo_result = ISC_R_NOTFOUND;
252: goto close;
253: }
254:
255: ipv6pktinfo_result = ISC_R_SUCCESS;
256:
257: close:
258: closesocket(s);
259: return;
260: }
261:
262: static void
263: initialize_ipv6pktinfo(void) {
264: RUNTIME_CHECK(isc_once_do(&once_ipv6pktinfo,
265: try_ipv6pktinfo) == ISC_R_SUCCESS);
266: }
267: #endif /* WANT_IPV6 */
268: #endif /* ISC_PLATFORM_HAVEIPV6 */
269:
270: isc_result_t
271: isc_net_probe_ipv6only(void) {
272: #ifdef ISC_PLATFORM_HAVEIPV6
273: #ifdef WANT_IPV6
274: initialize_ipv6only();
275: #else
276: ipv6only_result = ISC_R_NOTFOUND;
277: #endif
278: #endif
279: return (ipv6only_result);
280: }
281:
282: isc_result_t
283: isc_net_probe_ipv6pktinfo(void) {
284: #ifdef ISC_PLATFORM_HAVEIPV6
285: #ifdef WANT_IPV6
286: initialize_ipv6pktinfo();
287: #else
288: ipv6pktinfo_result = ISC_R_NOTFOUND;
289: #endif
290: #endif
291: return (ipv6pktinfo_result);
292: }
293:
294: isc_result_t
295: isc_net_getudpportrange(int af, in_port_t *low, in_port_t *high) {
296: int result = ISC_R_FAILURE;
297:
298: REQUIRE(low != NULL && high != NULL);
299:
300: UNUSED(af);
301:
302: if (result != ISC_R_SUCCESS) {
303: *low = ISC_NET_PORTRANGELOW;
304: *high = ISC_NET_PORTRANGEHIGH;
305: }
306:
307: return (ISC_R_SUCCESS); /* we currently never fail in this function */
308: }
309:
310: void
311: isc_net_disableipv4(void) {
312: initialize();
313: if (ipv4_result == ISC_R_SUCCESS)
314: ipv4_result = ISC_R_DISABLED;
315: }
316:
317: void
318: isc_net_disableipv6(void) {
319: initialize();
320: if (ipv6_result == ISC_R_SUCCESS)
321: ipv6_result = ISC_R_DISABLED;
322: }
323:
324: void
325: isc_net_enableipv4(void) {
326: initialize();
327: if (ipv4_result == ISC_R_DISABLED)
328: ipv4_result = ISC_R_SUCCESS;
329: }
330:
331: void
332: isc_net_enableipv6(void) {
333: initialize();
334: if (ipv6_result == ISC_R_DISABLED)
335: ipv6_result = ISC_R_SUCCESS;
336: }