![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to socket_win_socket.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / strongswan / src / libcharon / plugins / socket_win|
Return to socket_win_socket.c CVS log | Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / strongswan / src / libcharon / plugins / socket_win |
1.1 misho 1: /*
2: * Copyright (C) 2013 Martin Willi
3: * Copyright (C) 2013 revosec AG
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
7: * Free Software Foundation; either version 2 of the License, or (at your
8: * option) any later version. See <http://www.fsf.org/copyleft/gpl.txt>.
9: *
10: * This program is distributed in the hope that it will be useful, but
11: * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
12: * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
13: * for more details.
14: */
15:
16: /* for WSAID_WSASENDMSG, Windows 7 */
17: #define _WIN32_WINNT 0x0601
18:
19: #include "socket_win_socket.h"
20:
21: #include <library.h>
22: #include <threading/thread.h>
23: #include <daemon.h>
24:
25: #include <mswsock.h>
26:
27: /* number of sockets in use */
28: #define SOCKET_COUNT 2
29:
30: /* missing on MinGW */
31: #ifndef IPV6_V6ONLY
32: # define IPV6_V6ONLY 27
33: #endif
34:
35: /* GUIDS to lookup WSASend/RecvMsg */
36: static GUID WSARecvMsgGUID = WSAID_WSARECVMSG;
37: static GUID WSASendMsgGUID = WSAID_WSASENDMSG;
38:
39: typedef struct private_socket_win_socket_t private_socket_win_socket_t;
40:
41: /**
42: * Private data of an socket_t object
43: */
44: struct private_socket_win_socket_t {
45:
46: /**
47: * public functions
48: */
49: socket_win_socket_t public;
50:
51: /**
52: * Port for each socket
53: */
54: uint16_t ports[SOCKET_COUNT];
55:
56: /**
57: * IPv4/IPv6 dual-use sockets
58: */
59: SOCKET socks[SOCKET_COUNT];
60:
61: /**
62: * Events to wait for socket data
63: */
64: HANDLE events[SOCKET_COUNT];
65:
66: /**
67: * Maximum packet size to receive
68: */
69: int max_packet;
70:
71: /**
72: * WSASendMsg function
73: */
74: int WINAPI (*WSASendMsg)(SOCKET, LPWSAMSG, DWORD, LPDWORD,
75: LPWSAOVERLAPPED, LPWSAOVERLAPPED_COMPLETION_ROUTINE);
76:
77: /**
78: * WSARecvMsg function
79: */
80: int WINAPI (*WSARecvMsg)(SOCKET, LPWSAMSG, LPDWORD,
81: LPWSAOVERLAPPED, LPWSAOVERLAPPED_COMPLETION_ROUTINE);
82: };
83:
84: METHOD(socket_t, receiver, status_t,
85: private_socket_win_socket_t *this, packet_t **out)
86: {
87: char buf[this->max_packet], cbuf[128];
88: bool old;
89: DWORD i, len, err;
90: WSAMSG msg;
91: WSABUF data;
92: WSACMSGHDR *cmsg;
93: SOCKADDR_IN6 addr;
94: host_t *src = NULL, *dst = NULL;
95: packet_t *pkt;
96:
97: data.buf = buf;
98: data.len = sizeof(buf);
99:
100: memset(&msg, 0, sizeof(msg));
101: msg.name = (struct sockaddr*)&addr;
102: msg.namelen = sizeof(addr);
103: msg.lpBuffers = &data;
104: msg.dwBufferCount = 1;
105: msg.Control.buf = cbuf;
106: msg.Control.len = sizeof(cbuf);
107:
108: /* wait for socket events */
109: old = thread_cancelability(TRUE);
110: i = WSAWaitForMultipleEvents(SOCKET_COUNT, this->events,
111: FALSE, INFINITE, TRUE);
112: thread_cancelability(old);
113: if (i < WSA_WAIT_EVENT_0 || i >= WSA_WAIT_EVENT_0 + SOCKET_COUNT)
114: {
115: DBG1(DBG_NET, "waiting on sockets failed: %d", WSAGetLastError());
116: return FAILED;
117: }
118: i -= WSA_WAIT_EVENT_0;
119:
120: /* WSAEvents must be reset manually */
121: WSAResetEvent(this->events[i]);
122:
123: if (this->WSARecvMsg(this->socks[i], &msg, &len,
124: NULL, NULL) == SOCKET_ERROR)
125: {
126: err = WSAGetLastError();
127: /* ignore WSAECONNRESET; this is returned for any ICMP port unreachable,
128: * for a packet we sent, but is most likely not related to the packet
129: * we try to receive. */
130: if (err != WSAECONNRESET)
131: {
132: DBG1(DBG_NET, "reading from socket failed: %d", WSAGetLastError());
133: }
134: return FAILED;
135: }
136:
137: DBG3(DBG_NET, "received packet %b", buf, (int)len);
138:
139: for (cmsg = WSA_CMSG_FIRSTHDR(&msg); dst == NULL && cmsg != NULL;
140: cmsg = WSA_CMSG_NXTHDR(&msg, cmsg))
141: {
142: if (cmsg->cmsg_level == IPPROTO_IP &&
143: cmsg->cmsg_type == IP_PKTINFO)
144: {
145: struct in_pktinfo *pktinfo;
146: struct sockaddr_in sin = {
147: .sin_family = AF_INET,
148: };
149:
150: pktinfo = (struct in_pktinfo*)WSA_CMSG_DATA(cmsg);
151: sin.sin_addr = pktinfo->ipi_addr;
152: sin.sin_port = htons(this->ports[i]);
153: dst = host_create_from_sockaddr((struct sockaddr*)&sin);
154: }
155: if (cmsg->cmsg_level == IPPROTO_IPV6 &&
156: cmsg->cmsg_type == IPV6_PKTINFO)
157: {
158: struct in6_pktinfo *pktinfo;
159: struct sockaddr_in6 sin = {
160: .sin6_family = AF_INET6,
161: };
162:
163: pktinfo = (struct in6_pktinfo*)WSA_CMSG_DATA(cmsg);
164: sin.sin6_addr = pktinfo->ipi6_addr;
165: sin.sin6_port = htons(this->ports[i]);
166: dst = host_create_from_sockaddr((struct sockaddr*)&sin);
167: }
168: }
169:
170: if (!dst)
171: {
172: DBG1(DBG_NET, "receiving IP destination address failed");
173: return FAILED;
174: }
175:
176: switch (dst->get_family(dst))
177: {
178: case AF_INET6:
179: src = host_create_from_sockaddr((struct sockaddr*)&addr);
180: break;
181: case AF_INET:
182: /* extract v4 address from mapped v6 */
183: src = host_create_from_chunk(AF_INET,
184: chunk_create(addr.sin6_addr.u.Byte + 12, 4),
185: ntohs(addr.sin6_port));
186: break;
187: }
188: if (!src)
189: {
190: DBG1(DBG_NET, "receiving IP source address failed");
191: dst->destroy(dst);
192: return FAILED;
193: }
194:
195: pkt = packet_create();
196: pkt->set_source(pkt, src);
197: pkt->set_destination(pkt, dst);
198: DBG2(DBG_NET, "received packet: from %#H to %#H", src, dst);
199: pkt->set_data(pkt, chunk_clone(chunk_create(buf, len)));
200:
201: *out = pkt;
202: return SUCCESS;
203: }
204:
205: METHOD(socket_t, sender, status_t,
206: private_socket_win_socket_t *this, packet_t *packet)
207: {
208: uint16_t port;
209: int i = -1, j;
210: host_t *src, *dst;
211: WSAMSG msg;
212: DWORD len;
213: WSABUF data;
214: WSACMSGHDR *cmsg;
215: SOCKADDR_IN6 addr = {
216: .sin6_family = AF_INET6,
217: .sin6_addr = {
218: .u = {
219: .Byte = {
220: /* v6-mapped-v4 by default */
221: 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
222: 0x00,0x00,0xFF,0xFF,0x00,0x00,0x00,0x00,
223: },
224: },
225: },
226: };
227: char buf[WSA_CMSG_SPACE(max(sizeof(struct in6_pktinfo),
228: sizeof(struct in_pktinfo)))];
229:
230: src = packet->get_source(packet);
231: dst = packet->get_destination(packet);
232: data.len = packet->get_data(packet).len;
233: data.buf = packet->get_data(packet).ptr;
234:
235: DBG2(DBG_NET, "sending packet: from %#H to %#H", src, dst);
236:
237: DBG3(DBG_NET, "sending packet %b", data.buf, (int)data.len);
238:
239: port = src->get_port(src);
240: for (j = 0; j < SOCKET_COUNT; j++)
241: {
242: if (!port || this->ports[j] == port)
243: {
244: i = j;
245: break;
246: }
247: }
248: if (i == -1)
249: {
250: DBG1(DBG_NET, "no socket found to send packet from port %u", port);
251: return FAILED;
252: }
253:
254: /* copy destination IPv6, or last 32 bits of mapped IPv4 address */
255: len = dst->get_address(dst).len;
256: if (len > sizeof(addr.sin6_addr))
257: {
258: return FAILED;
259: }
260: memcpy(addr.sin6_addr.u.Byte + sizeof(addr.sin6_addr) - len,
261: dst->get_address(dst).ptr, len);
262: addr.sin6_port = htons(dst->get_port(dst));
263:
264: memset(&msg, 0, sizeof(msg));
265: msg.name = (struct sockaddr*)&addr;
266: msg.namelen = sizeof(addr);
267: msg.lpBuffers = &data;
268: msg.dwBufferCount = 1;
269:
270: if (!src->is_anyaddr(src))
271: {
272: memset(buf, 0, sizeof(buf));
273: msg.Control.buf = buf;
274:
275: switch (src->get_family(src))
276: {
277: case AF_INET:
278: {
279: struct in_pktinfo *pktinfo;
280: SOCKADDR_IN *sin;
281:
282: msg.Control.len = WSA_CMSG_SPACE(sizeof(*pktinfo));
283: cmsg = WSA_CMSG_FIRSTHDR(&msg);
284: cmsg->cmsg_level = IPPROTO_IP;
285: cmsg->cmsg_type = IP_PKTINFO;
286: cmsg->cmsg_len = WSA_CMSG_LEN(sizeof(*pktinfo));
287: pktinfo = (struct in_pktinfo*)WSA_CMSG_DATA(cmsg);
288: sin = (SOCKADDR_IN*)src->get_sockaddr(src);
289: pktinfo->ipi_addr = sin->sin_addr;
290: break;
291: }
292: case AF_INET6:
293: {
294: struct in6_pktinfo *pktinfo;
295: SOCKADDR_IN6 *sin;
296:
297: msg.Control.len = WSA_CMSG_SPACE(sizeof(*pktinfo));
298: cmsg = WSA_CMSG_FIRSTHDR(&msg);
299: cmsg->cmsg_level = IPPROTO_IPV6;
300: cmsg->cmsg_type = IPV6_PKTINFO;
301: cmsg->cmsg_len = WSA_CMSG_LEN(sizeof(*pktinfo));
302: pktinfo = (struct in6_pktinfo*)WSA_CMSG_DATA(cmsg);
303: sin = (SOCKADDR_IN6*)src->get_sockaddr(src);
304: pktinfo->ipi6_addr = sin->sin6_addr;
305: break;
306: }
307: }
308: }
309:
310: if (this->WSASendMsg(this->socks[i], &msg, 0, &len,
311: NULL, NULL) == SOCKET_ERROR)
312: {
313: DBG1(DBG_NET, "sending packet failed: %d", WSAGetLastError());
314: return FAILED;
315: }
316: return SUCCESS;
317: }
318:
319: METHOD(socket_t, get_port, uint16_t,
320: private_socket_win_socket_t *this, bool nat)
321: {
322: return this->ports[nat != 0];
323: }
324:
325: METHOD(socket_t, supported_families, socket_family_t,
326: private_socket_win_socket_t *this)
327: {
328: return SOCKET_FAMILY_IPV4 | SOCKET_FAMILY_IPV6;
329: }
330:
331: /**
332: * Open an IPv4/IPv6 dual-use socket to send and receive packets
333: */
334: static SOCKET open_socket(private_socket_win_socket_t *this, int i)
335: {
336: SOCKADDR_IN6 addr = {
337: .sin6_family = AF_INET6,
338: .sin6_port = htons(this->ports[i]),
339: };
340: int addrlen = sizeof(addr);
341: BOOL on = TRUE, off = FALSE;
342: DWORD dwon = TRUE;
343: SOCKET s;
344:
345: s = WSASocket(AF_INET6, SOCK_DGRAM, IPPROTO_UDP, NULL, 0, 0);
346: if (s == INVALID_SOCKET)
347: {
348: DBG1(DBG_NET, "creating socket failed: %d", WSAGetLastError());
349: return INVALID_SOCKET;
350: }
351: /* enable IPv4 on IPv6 socket */
352: if (setsockopt(s, IPPROTO_IPV6, IPV6_V6ONLY,
353: (const char*)&off, sizeof(off)) == SOCKET_ERROR)
354: {
355: DBG1(DBG_NET, "using dual-mode socket failed: %d", WSAGetLastError());
356: closesocket(s);
357: return INVALID_SOCKET;
358: }
359: if (setsockopt(s, SOL_SOCKET, SO_REUSEADDR,
360: (const char*)&on, sizeof(on)) == SOCKET_ERROR)
361: {
362: DBG1(DBG_NET, "enabling SO_REUSEADDR failed: %d", WSAGetLastError());
363: closesocket(s);
364: return INVALID_SOCKET;
365: }
366: if (bind(s, (const struct sockaddr*)&addr, addrlen) == SOCKET_ERROR)
367: {
368: DBG1(DBG_NET, "unable to bind socket: %d", WSAGetLastError());
369: closesocket(s);
370: return INVALID_SOCKET;
371: }
372: /* retrieve randomly allocated port if needed */
373: if (this->ports[i] == 0)
374: {
375: if (getsockname(s, (struct sockaddr*)&addr,
376: &addrlen) == SOCKET_ERROR)
377: {
378: DBG1(DBG_NET, "unable to determine port: %d", WSAGetLastError());
379: closesocket(s);
380: return INVALID_SOCKET;
381: }
382: this->ports[i] = ntohs(addr.sin6_port);
383: }
384: /* PKTINFO is required for both protocol families */
385: if (setsockopt(s, IPPROTO_IP, IP_PKTINFO,
386: (char*)&dwon, sizeof(dwon)) == SOCKET_ERROR)
387: {
388: DBG1(DBG_NET, "unable to set IP_PKTINFO: %d", WSAGetLastError());
389: closesocket(s);
390: return INVALID_SOCKET;
391: }
392: if (setsockopt(s, IPPROTO_IPV6, IPV6_PKTINFO,
393: (char*)&dwon, sizeof(dwon)) == SOCKET_ERROR)
394: {
395: DBG1(DBG_NET, "unable to set IP6_PKTINFO: %d", WSAGetLastError());
396: closesocket(s);
397: return INVALID_SOCKET;
398: }
399: if (!charon->kernel->bypass_socket(charon->kernel, s, AF_INET))
400: {
401: DBG1(DBG_NET, "installing IPv4 IKE bypass policy failed");
402: }
403: if (!charon->kernel->bypass_socket(charon->kernel, s, AF_INET6))
404: {
405: DBG1(DBG_NET, "installing IPv6 IKE bypass policy failed");
406: }
407: return s;
408: }
409:
410: METHOD(socket_t, destroy, void,
411: private_socket_win_socket_t *this)
412: {
413: int i;
414:
415: for (i = 0; i < SOCKET_COUNT; i++)
416: {
417: if (this->socks[i] != INVALID_SOCKET)
418: {
419: closesocket(this->socks[i]);
420: }
421: if (this->events[i] != WSA_INVALID_EVENT)
422: {
423: WSACloseEvent(this->events[i]);
424: }
425: }
426: free(this);
427: }
428:
429: /*
430: * See header for description
431: */
432: socket_win_socket_t *socket_win_socket_create()
433: {
434: private_socket_win_socket_t *this;
435: DWORD len;
436: int i;
437:
438: INIT(this,
439: .public = {
440: .socket = {
441: .send = _sender,
442: .receive = _receiver,
443: .get_port = _get_port,
444: .supported_families = _supported_families,
445: .destroy = _destroy,
446: },
447: },
448: .ports = {
449: lib->settings->get_int(lib->settings,
450: "%s.port", CHARON_UDP_PORT, lib->ns),
451: lib->settings->get_int(lib->settings,
452: "%s.port_nat_t", CHARON_NATT_PORT, lib->ns),
453: },
454: .max_packet = lib->settings->get_int(lib->settings,
455: "%s.max_packet", PACKET_MAX_DEFAULT, lib->ns),
456: );
457:
458: for (i = 0; i < SOCKET_COUNT; i++)
459: {
460: this->socks[i] = open_socket(this, i);
461: this->events[i] = WSACreateEvent();
462: }
463:
464: for (i = 0; i < SOCKET_COUNT; i++)
465: {
466: if (this->events[i] == WSA_INVALID_EVENT ||
467: this->socks[i] == INVALID_SOCKET)
468: {
469: DBG1(DBG_NET, "creating socket failed: %d", WSAGetLastError());
470: destroy(this);
471: return NULL;
472: }
473: if (WSAEventSelect(this->socks[i], this->events[i],
474: FD_READ) == SOCKET_ERROR)
475: {
476: DBG1(DBG_NET, "WSAEventSelect() failed: %d", WSAGetLastError());
477: destroy(this);
478: return NULL;
479: }
480: }
481:
482: if (WSAIoctl(this->socks[0], SIO_GET_EXTENSION_FUNCTION_POINTER,
483: &WSASendMsgGUID, sizeof(WSASendMsgGUID), &this->WSASendMsg,
484: sizeof(this->WSASendMsg), &len, NULL, NULL) != 0 ||
485: WSAIoctl(this->socks[0], SIO_GET_EXTENSION_FUNCTION_POINTER,
486: &WSARecvMsgGUID, sizeof(WSARecvMsgGUID), &this->WSARecvMsg,
487: sizeof(this->WSARecvMsg), &len, NULL, NULL) != 0)
488: {
489: DBG1(DBG_NET, "send/recvmsg() lookup failed: %d", WSAGetLastError());
490: destroy(this);
491: return NULL;
492: }
493:
494: return &this->public;
495: }