|
160
|
1 /* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
|
|
|
2 *
|
|
|
3 * Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
|
4 * of this software and associated documentation files (the "Software"), to
|
|
|
5 * deal in the Software without restriction, including without limitation the
|
|
|
6 * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
|
|
|
7 * sell copies of the Software, and to permit persons to whom the Software is
|
|
|
8 * furnished to do so, subject to the following conditions:
|
|
|
9 *
|
|
|
10 * The above copyright notice and this permission notice shall be included in
|
|
|
11 * all copies or substantial portions of the Software.
|
|
|
12 *
|
|
|
13 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
|
14 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
15 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
|
16 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
|
17 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|
|
18 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
|
|
|
19 * IN THE SOFTWARE.
|
|
|
20 */
|
|
|
21
|
|
|
22 #include <assert.h>
|
|
|
23 #include <stdlib.h>
|
|
|
24
|
|
|
25 #include "uv.h"
|
|
|
26 #include "internal.h"
|
|
|
27 #include "handle-inl.h"
|
|
|
28 #include "stream-inl.h"
|
|
|
29 #include "req-inl.h"
|
|
|
30
|
|
|
31
|
|
|
32 /* A zero-size buffer for use by uv_udp_read */
|
|
|
33 static char uv_zero_[] = "";
|
|
|
34 int uv_udp_getpeername(const uv_udp_t* handle,
|
|
|
35 struct sockaddr* name,
|
|
|
36 int* namelen) {
|
|
|
37
|
|
|
38 return uv__getsockpeername((const uv_handle_t*) handle,
|
|
|
39 getpeername,
|
|
|
40 name,
|
|
|
41 namelen,
|
|
|
42 0);
|
|
|
43 }
|
|
|
44
|
|
|
45
|
|
|
46 int uv_udp_getsockname(const uv_udp_t* handle,
|
|
|
47 struct sockaddr* name,
|
|
|
48 int* namelen) {
|
|
|
49
|
|
|
50 return uv__getsockpeername((const uv_handle_t*) handle,
|
|
|
51 getsockname,
|
|
|
52 name,
|
|
|
53 namelen,
|
|
|
54 0);
|
|
|
55 }
|
|
|
56
|
|
|
57
|
|
|
58 static int uv__udp_set_socket(uv_loop_t* loop, uv_udp_t* handle, SOCKET socket,
|
|
|
59 int family) {
|
|
|
60 DWORD yes = 1;
|
|
|
61 WSAPROTOCOL_INFOW info;
|
|
|
62 int opt_len;
|
|
|
63
|
|
|
64 if (handle->socket != INVALID_SOCKET)
|
|
|
65 return UV_EBUSY;
|
|
|
66
|
|
|
67 /* Set the socket to nonblocking mode */
|
|
|
68 if (ioctlsocket(socket, FIONBIO, &yes) == SOCKET_ERROR) {
|
|
|
69 return WSAGetLastError();
|
|
|
70 }
|
|
|
71
|
|
|
72 /* Make the socket non-inheritable */
|
|
|
73 if (!SetHandleInformation((HANDLE)socket, HANDLE_FLAG_INHERIT, 0)) {
|
|
|
74 return GetLastError();
|
|
|
75 }
|
|
|
76
|
|
|
77 /* Associate it with the I/O completion port. Use uv_handle_t pointer as
|
|
|
78 * completion key. */
|
|
|
79 if (CreateIoCompletionPort((HANDLE)socket,
|
|
|
80 loop->iocp,
|
|
|
81 (ULONG_PTR)socket,
|
|
|
82 0) == NULL) {
|
|
|
83 return GetLastError();
|
|
|
84 }
|
|
|
85
|
|
|
86 /* All known Windows that support SetFileCompletionNotificationModes have a
|
|
|
87 * bug that makes it impossible to use this function in conjunction with
|
|
|
88 * datagram sockets. We can work around that but only if the user is using
|
|
|
89 * the default UDP driver (AFD) and has no other. LSPs stacked on top. Here
|
|
|
90 * we check whether that is the case. */
|
|
|
91 opt_len = (int) sizeof info;
|
|
|
92 if (getsockopt(
|
|
|
93 socket, SOL_SOCKET, SO_PROTOCOL_INFOW, (char*) &info, &opt_len) ==
|
|
|
94 SOCKET_ERROR) {
|
|
|
95 return GetLastError();
|
|
|
96 }
|
|
|
97
|
|
|
98 if (info.ProtocolChain.ChainLen == 1) {
|
|
|
99 if (SetFileCompletionNotificationModes(
|
|
|
100 (HANDLE) socket,
|
|
|
101 FILE_SKIP_SET_EVENT_ON_HANDLE |
|
|
|
102 FILE_SKIP_COMPLETION_PORT_ON_SUCCESS)) {
|
|
|
103 handle->flags |= UV_HANDLE_SYNC_BYPASS_IOCP;
|
|
|
104 handle->func_wsarecv = uv__wsarecv_workaround;
|
|
|
105 handle->func_wsarecvfrom = uv__wsarecvfrom_workaround;
|
|
|
106 } else if (GetLastError() != ERROR_INVALID_FUNCTION) {
|
|
|
107 return GetLastError();
|
|
|
108 }
|
|
|
109 }
|
|
|
110
|
|
|
111 handle->socket = socket;
|
|
|
112
|
|
|
113 if (family == AF_INET6) {
|
|
|
114 handle->flags |= UV_HANDLE_IPV6;
|
|
|
115 } else {
|
|
|
116 assert(!(handle->flags & UV_HANDLE_IPV6));
|
|
|
117 }
|
|
|
118
|
|
|
119 return 0;
|
|
|
120 }
|
|
|
121
|
|
|
122
|
|
|
123 int uv__udp_init_ex(uv_loop_t* loop,
|
|
|
124 uv_udp_t* handle,
|
|
|
125 unsigned flags,
|
|
|
126 int domain) {
|
|
|
127 uv__handle_init(loop, (uv_handle_t*) handle, UV_UDP);
|
|
|
128 handle->socket = INVALID_SOCKET;
|
|
|
129 handle->reqs_pending = 0;
|
|
|
130 handle->activecnt = 0;
|
|
|
131 handle->func_wsarecv = WSARecv;
|
|
|
132 handle->func_wsarecvfrom = WSARecvFrom;
|
|
|
133 handle->send_queue_size = 0;
|
|
|
134 handle->send_queue_count = 0;
|
|
|
135 UV_REQ_INIT(&handle->recv_req, UV_UDP_RECV);
|
|
|
136 handle->recv_req.data = handle;
|
|
|
137
|
|
|
138 /* If anything fails beyond this point we need to remove the handle from
|
|
|
139 * the handle queue, since it was added by uv__handle_init.
|
|
|
140 */
|
|
|
141
|
|
|
142 if (domain != AF_UNSPEC) {
|
|
|
143 SOCKET sock;
|
|
|
144 DWORD err;
|
|
|
145
|
|
|
146 sock = socket(domain, SOCK_DGRAM, 0);
|
|
|
147 if (sock == INVALID_SOCKET) {
|
|
|
148 err = WSAGetLastError();
|
|
|
149 uv__queue_remove(&handle->handle_queue);
|
|
|
150 return uv_translate_sys_error(err);
|
|
|
151 }
|
|
|
152
|
|
|
153 err = uv__udp_set_socket(handle->loop, handle, sock, domain);
|
|
|
154 if (err) {
|
|
|
155 closesocket(sock);
|
|
|
156 uv__queue_remove(&handle->handle_queue);
|
|
|
157 return uv_translate_sys_error(err);
|
|
|
158 }
|
|
|
159 }
|
|
|
160
|
|
|
161 return 0;
|
|
|
162 }
|
|
|
163
|
|
|
164
|
|
|
165 void uv__udp_close(uv_loop_t* loop, uv_udp_t* handle) {
|
|
|
166 uv_udp_recv_stop(handle);
|
|
|
167 closesocket(handle->socket);
|
|
|
168 handle->socket = INVALID_SOCKET;
|
|
|
169
|
|
|
170 uv__handle_closing(handle);
|
|
|
171
|
|
|
172 if (handle->reqs_pending == 0) {
|
|
|
173 uv__want_endgame(loop, (uv_handle_t*) handle);
|
|
|
174 }
|
|
|
175 }
|
|
|
176
|
|
|
177
|
|
|
178 void uv__udp_endgame(uv_loop_t* loop, uv_udp_t* handle) {
|
|
|
179 if (handle->flags & UV_HANDLE_CLOSING &&
|
|
|
180 handle->reqs_pending == 0) {
|
|
|
181 assert(!(handle->flags & UV_HANDLE_CLOSED));
|
|
|
182 uv__handle_close(handle);
|
|
|
183 }
|
|
|
184 }
|
|
|
185
|
|
|
186
|
|
|
187 int uv_udp_using_recvmmsg(const uv_udp_t* handle) {
|
|
|
188 return 0;
|
|
|
189 }
|
|
|
190
|
|
|
191
|
|
|
192 static int uv__udp_maybe_bind(uv_udp_t* handle,
|
|
|
193 const struct sockaddr* addr,
|
|
|
194 unsigned int addrlen,
|
|
|
195 unsigned int flags) {
|
|
|
196 int r;
|
|
|
197 int err;
|
|
|
198 DWORD no = 0;
|
|
|
199
|
|
|
200 if (handle->flags & UV_HANDLE_BOUND)
|
|
|
201 return 0;
|
|
|
202
|
|
|
203 /* There is no SO_REUSEPORT on Windows, Windows only knows SO_REUSEADDR.
|
|
|
204 * so we just return an error directly when UV_UDP_REUSEPORT is requested
|
|
|
205 * for binding the socket. */
|
|
|
206 if (flags & UV_UDP_REUSEPORT)
|
|
|
207 return ERROR_NOT_SUPPORTED;
|
|
|
208
|
|
|
209 if ((flags & UV_UDP_IPV6ONLY) && addr->sa_family != AF_INET6) {
|
|
|
210 /* UV_UDP_IPV6ONLY is supported only for IPV6 sockets */
|
|
|
211 return ERROR_INVALID_PARAMETER;
|
|
|
212 }
|
|
|
213
|
|
|
214 if (handle->socket == INVALID_SOCKET) {
|
|
|
215 SOCKET sock = socket(addr->sa_family, SOCK_DGRAM, 0);
|
|
|
216 if (sock == INVALID_SOCKET) {
|
|
|
217 return WSAGetLastError();
|
|
|
218 }
|
|
|
219
|
|
|
220 err = uv__udp_set_socket(handle->loop, handle, sock, addr->sa_family);
|
|
|
221 if (err) {
|
|
|
222 closesocket(sock);
|
|
|
223 return err;
|
|
|
224 }
|
|
|
225 }
|
|
|
226
|
|
|
227 if (flags & UV_UDP_REUSEADDR) {
|
|
|
228 DWORD yes = 1;
|
|
|
229 /* Set SO_REUSEADDR on the socket. */
|
|
|
230 if (setsockopt(handle->socket,
|
|
|
231 SOL_SOCKET,
|
|
|
232 SO_REUSEADDR,
|
|
|
233 (char*) &yes,
|
|
|
234 sizeof yes) == SOCKET_ERROR) {
|
|
|
235 err = WSAGetLastError();
|
|
|
236 return err;
|
|
|
237 }
|
|
|
238 }
|
|
|
239
|
|
|
240 if (addr->sa_family == AF_INET6)
|
|
|
241 handle->flags |= UV_HANDLE_IPV6;
|
|
|
242
|
|
|
243 if (addr->sa_family == AF_INET6 && !(flags & UV_UDP_IPV6ONLY)) {
|
|
|
244 /* On windows IPV6ONLY is on by default. If the user doesn't specify it
|
|
|
245 * libuv turns it off. */
|
|
|
246
|
|
|
247 /* TODO: how to handle errors? This may fail if there is no ipv4 stack
|
|
|
248 * available, or when run on XP/2003 which have no support for dualstack
|
|
|
249 * sockets. For now we're silently ignoring the error. */
|
|
|
250 setsockopt(handle->socket,
|
|
|
251 IPPROTO_IPV6,
|
|
|
252 IPV6_V6ONLY,
|
|
|
253 (char*) &no,
|
|
|
254 sizeof no);
|
|
|
255 }
|
|
|
256
|
|
|
257 r = bind(handle->socket, addr, addrlen);
|
|
|
258 if (r == SOCKET_ERROR) {
|
|
|
259 return WSAGetLastError();
|
|
|
260 }
|
|
|
261
|
|
|
262 handle->flags |= UV_HANDLE_BOUND;
|
|
|
263
|
|
|
264 return 0;
|
|
|
265 }
|
|
|
266
|
|
|
267
|
|
|
268 static void uv__udp_queue_recv(uv_loop_t* loop, uv_udp_t* handle) {
|
|
|
269 uv_req_t* req;
|
|
|
270 uv_buf_t buf;
|
|
|
271 DWORD bytes, flags;
|
|
|
272 int result;
|
|
|
273
|
|
|
274 assert(handle->flags & UV_HANDLE_READING);
|
|
|
275 assert(!(handle->flags & UV_HANDLE_READ_PENDING));
|
|
|
276
|
|
|
277 req = &handle->recv_req;
|
|
|
278 memset(&req->u.io.overlapped, 0, sizeof(req->u.io.overlapped));
|
|
|
279
|
|
|
280 handle->flags |= UV_HANDLE_ZERO_READ;
|
|
|
281
|
|
|
282 buf.base = (char*) uv_zero_;
|
|
|
283 buf.len = 0;
|
|
|
284 flags = MSG_PEEK;
|
|
|
285
|
|
|
286 result = handle->func_wsarecv(handle->socket,
|
|
|
287 (WSABUF*) &buf,
|
|
|
288 1,
|
|
|
289 &bytes,
|
|
|
290 &flags,
|
|
|
291 &req->u.io.overlapped,
|
|
|
292 NULL);
|
|
|
293
|
|
|
294 if (UV_SUCCEEDED_WITHOUT_IOCP(result == 0)) {
|
|
|
295 /* Process the req without IOCP. */
|
|
|
296 handle->flags |= UV_HANDLE_READ_PENDING;
|
|
|
297 req->u.io.overlapped.InternalHigh = bytes;
|
|
|
298 handle->reqs_pending++;
|
|
|
299 uv__insert_pending_req(loop, req);
|
|
|
300 } else if (UV_SUCCEEDED_WITH_IOCP(result == 0)) {
|
|
|
301 /* The req will be processed with IOCP. */
|
|
|
302 handle->flags |= UV_HANDLE_READ_PENDING;
|
|
|
303 handle->reqs_pending++;
|
|
|
304 } else {
|
|
|
305 /* Make this req pending reporting an error. */
|
|
|
306 SET_REQ_ERROR(req, WSAGetLastError());
|
|
|
307 uv__insert_pending_req(loop, req);
|
|
|
308 handle->reqs_pending++;
|
|
|
309 }
|
|
|
310 }
|
|
|
311
|
|
|
312
|
|
|
313 int uv__udp_recv_start(uv_udp_t* handle, uv_alloc_cb alloc_cb,
|
|
|
314 uv_udp_recv_cb recv_cb) {
|
|
|
315 uv_loop_t* loop = handle->loop;
|
|
|
316 int err;
|
|
|
317
|
|
|
318 if (handle->flags & UV_HANDLE_READING) {
|
|
|
319 return UV_EALREADY;
|
|
|
320 }
|
|
|
321
|
|
|
322 err = uv__udp_maybe_bind(handle,
|
|
|
323 (const struct sockaddr*) &uv_addr_ip4_any_,
|
|
|
324 sizeof(uv_addr_ip4_any_),
|
|
|
325 0);
|
|
|
326 if (err)
|
|
|
327 return uv_translate_sys_error(err);
|
|
|
328
|
|
|
329 handle->flags |= UV_HANDLE_READING;
|
|
|
330 INCREASE_ACTIVE_COUNT(loop, handle);
|
|
|
331
|
|
|
332 handle->recv_cb = recv_cb;
|
|
|
333 handle->alloc_cb = alloc_cb;
|
|
|
334
|
|
|
335 /* If reading was stopped and then started again, there could still be a recv
|
|
|
336 * request pending. */
|
|
|
337 if (!(handle->flags & UV_HANDLE_READ_PENDING))
|
|
|
338 uv__udp_queue_recv(loop, handle);
|
|
|
339
|
|
|
340 return 0;
|
|
|
341 }
|
|
|
342
|
|
|
343
|
|
|
344 int uv__udp_recv_stop(uv_udp_t* handle) {
|
|
|
345 if (handle->flags & UV_HANDLE_READING) {
|
|
|
346 handle->flags &= ~UV_HANDLE_READING;
|
|
|
347 DECREASE_ACTIVE_COUNT(loop, handle);
|
|
|
348 }
|
|
|
349
|
|
|
350 return 0;
|
|
|
351 }
|
|
|
352
|
|
|
353
|
|
|
354 static int uv__send(uv_udp_send_t* req,
|
|
|
355 uv_udp_t* handle,
|
|
|
356 const uv_buf_t bufs[],
|
|
|
357 unsigned int nbufs,
|
|
|
358 const struct sockaddr* addr,
|
|
|
359 unsigned int addrlen,
|
|
|
360 uv_udp_send_cb cb) {
|
|
|
361 uv_loop_t* loop = handle->loop;
|
|
|
362 DWORD result, bytes;
|
|
|
363
|
|
|
364 UV_REQ_INIT(req, UV_UDP_SEND);
|
|
|
365 req->handle = handle;
|
|
|
366 req->cb = cb;
|
|
|
367 memset(&req->u.io.overlapped, 0, sizeof(req->u.io.overlapped));
|
|
|
368
|
|
|
369 result = WSASendTo(handle->socket,
|
|
|
370 (WSABUF*)bufs,
|
|
|
371 nbufs,
|
|
|
372 &bytes,
|
|
|
373 0,
|
|
|
374 addr,
|
|
|
375 addrlen,
|
|
|
376 &req->u.io.overlapped,
|
|
|
377 NULL);
|
|
|
378
|
|
|
379 if (UV_SUCCEEDED_WITHOUT_IOCP(result == 0)) {
|
|
|
380 /* Request completed immediately. */
|
|
|
381 req->u.io.queued_bytes = 0;
|
|
|
382 handle->reqs_pending++;
|
|
|
383 handle->send_queue_size += req->u.io.queued_bytes;
|
|
|
384 handle->send_queue_count++;
|
|
|
385 REGISTER_HANDLE_REQ(loop, handle);
|
|
|
386 uv__insert_pending_req(loop, (uv_req_t*)req);
|
|
|
387 } else if (UV_SUCCEEDED_WITH_IOCP(result == 0)) {
|
|
|
388 /* Request queued by the kernel. */
|
|
|
389 req->u.io.queued_bytes = uv__count_bufs(bufs, nbufs);
|
|
|
390 handle->reqs_pending++;
|
|
|
391 handle->send_queue_size += req->u.io.queued_bytes;
|
|
|
392 handle->send_queue_count++;
|
|
|
393 REGISTER_HANDLE_REQ(loop, handle);
|
|
|
394 } else {
|
|
|
395 /* Send failed due to an error. */
|
|
|
396 return WSAGetLastError();
|
|
|
397 }
|
|
|
398
|
|
|
399 return 0;
|
|
|
400 }
|
|
|
401
|
|
|
402
|
|
|
403 void uv__process_udp_recv_req(uv_loop_t* loop, uv_udp_t* handle,
|
|
|
404 uv_req_t* req) {
|
|
|
405 uv_buf_t buf;
|
|
|
406 int partial;
|
|
|
407
|
|
|
408 assert(handle->type == UV_UDP);
|
|
|
409
|
|
|
410 handle->flags &= ~UV_HANDLE_READ_PENDING;
|
|
|
411
|
|
|
412 if (!REQ_SUCCESS(req)) {
|
|
|
413 DWORD err = GET_REQ_SOCK_ERROR(req);
|
|
|
414 if (err == WSAEMSGSIZE) {
|
|
|
415 /* Not a real error, it just indicates that the received packet was
|
|
|
416 * bigger than the receive buffer. */
|
|
|
417 } else if (err == WSAECONNRESET || err == WSAENETRESET) {
|
|
|
418 /* A previous sendto operation failed; ignore this error. If zero-reading
|
|
|
419 * we need to call WSARecv/WSARecvFrom _without_ the. MSG_PEEK flag to
|
|
|
420 * clear out the error queue. For nonzero reads, immediately queue a new
|
|
|
421 * receive. */
|
|
|
422 if (!(handle->flags & UV_HANDLE_ZERO_READ)) {
|
|
|
423 goto done;
|
|
|
424 }
|
|
|
425 } else {
|
|
|
426 /* A real error occurred. Report the error to the user only if we're
|
|
|
427 * currently reading. */
|
|
|
428 if (handle->flags & UV_HANDLE_READING) {
|
|
|
429 uv_udp_recv_stop(handle);
|
|
|
430 buf = (handle->flags & UV_HANDLE_ZERO_READ) ?
|
|
|
431 uv_buf_init(NULL, 0) : handle->recv_buffer;
|
|
|
432 handle->recv_cb(handle, uv_translate_sys_error(err), &buf, NULL, 0);
|
|
|
433 }
|
|
|
434 goto done;
|
|
|
435 }
|
|
|
436 }
|
|
|
437
|
|
|
438 if (!(handle->flags & UV_HANDLE_ZERO_READ)) {
|
|
|
439 /* Successful read */
|
|
|
440 partial = !REQ_SUCCESS(req);
|
|
|
441 handle->recv_cb(handle,
|
|
|
442 req->u.io.overlapped.InternalHigh,
|
|
|
443 &handle->recv_buffer,
|
|
|
444 (const struct sockaddr*) &handle->recv_from,
|
|
|
445 partial ? UV_UDP_PARTIAL : 0);
|
|
|
446 } else if (handle->flags & UV_HANDLE_READING) {
|
|
|
447 DWORD bytes, err, flags;
|
|
|
448 struct sockaddr_storage from;
|
|
|
449 int from_len;
|
|
|
450 int count;
|
|
|
451
|
|
|
452 /* Prevent loop starvation when the data comes in as fast as
|
|
|
453 * (or faster than) we can read it. */
|
|
|
454 count = 32;
|
|
|
455
|
|
|
456 do {
|
|
|
457 /* Do at most `count` nonblocking receive. */
|
|
|
458 buf = uv_buf_init(NULL, 0);
|
|
|
459 handle->alloc_cb((uv_handle_t*) handle, UV__UDP_DGRAM_MAXSIZE, &buf);
|
|
|
460 if (buf.base == NULL || buf.len == 0) {
|
|
|
461 handle->recv_cb(handle, UV_ENOBUFS, &buf, NULL, 0);
|
|
|
462 goto done;
|
|
|
463 }
|
|
|
464
|
|
|
465 memset(&from, 0, sizeof from);
|
|
|
466 from_len = sizeof from;
|
|
|
467
|
|
|
468 flags = 0;
|
|
|
469
|
|
|
470 if (WSARecvFrom(handle->socket,
|
|
|
471 (WSABUF*)&buf,
|
|
|
472 1,
|
|
|
473 &bytes,
|
|
|
474 &flags,
|
|
|
475 (struct sockaddr*) &from,
|
|
|
476 &from_len,
|
|
|
477 NULL,
|
|
|
478 NULL) != SOCKET_ERROR) {
|
|
|
479
|
|
|
480 /* Message received */
|
|
|
481 err = ERROR_SUCCESS;
|
|
|
482 handle->recv_cb(handle, bytes, &buf, (const struct sockaddr*) &from, 0);
|
|
|
483 } else {
|
|
|
484 err = WSAGetLastError();
|
|
|
485 if (err == WSAEMSGSIZE) {
|
|
|
486 /* Message truncated */
|
|
|
487 handle->recv_cb(handle,
|
|
|
488 bytes,
|
|
|
489 &buf,
|
|
|
490 (const struct sockaddr*) &from,
|
|
|
491 UV_UDP_PARTIAL);
|
|
|
492 } else if (err == WSAEWOULDBLOCK) {
|
|
|
493 /* Kernel buffer empty */
|
|
|
494 handle->recv_cb(handle, 0, &buf, NULL, 0);
|
|
|
495 } else if (err == WSAECONNRESET || err == WSAENETRESET) {
|
|
|
496 /* WSAECONNRESET/WSANETRESET is ignored because this just indicates
|
|
|
497 * that a previous sendto operation failed.
|
|
|
498 */
|
|
|
499 handle->recv_cb(handle, 0, &buf, NULL, 0);
|
|
|
500 } else {
|
|
|
501 /* Any other error that we want to report back to the user. */
|
|
|
502 uv_udp_recv_stop(handle);
|
|
|
503 handle->recv_cb(handle, uv_translate_sys_error(err), &buf, NULL, 0);
|
|
|
504 }
|
|
|
505 }
|
|
|
506 }
|
|
|
507 while (err == ERROR_SUCCESS &&
|
|
|
508 count-- > 0 &&
|
|
|
509 /* The recv_cb callback may decide to pause or close the handle. */
|
|
|
510 (handle->flags & UV_HANDLE_READING) &&
|
|
|
511 !(handle->flags & UV_HANDLE_READ_PENDING));
|
|
|
512 }
|
|
|
513
|
|
|
514 done:
|
|
|
515 /* Post another read if still reading and not closing. */
|
|
|
516 if ((handle->flags & UV_HANDLE_READING) &&
|
|
|
517 !(handle->flags & UV_HANDLE_READ_PENDING)) {
|
|
|
518 uv__udp_queue_recv(loop, handle);
|
|
|
519 }
|
|
|
520
|
|
|
521 DECREASE_PENDING_REQ_COUNT(handle);
|
|
|
522 }
|
|
|
523
|
|
|
524
|
|
|
525 void uv__process_udp_send_req(uv_loop_t* loop, uv_udp_t* handle,
|
|
|
526 uv_udp_send_t* req) {
|
|
|
527 int err;
|
|
|
528
|
|
|
529 assert(handle->type == UV_UDP);
|
|
|
530
|
|
|
531 assert(handle->send_queue_size >= req->u.io.queued_bytes);
|
|
|
532 assert(handle->send_queue_count >= 1);
|
|
|
533 handle->send_queue_size -= req->u.io.queued_bytes;
|
|
|
534 handle->send_queue_count--;
|
|
|
535
|
|
|
536 UNREGISTER_HANDLE_REQ(loop, handle);
|
|
|
537
|
|
|
538 if (req->cb) {
|
|
|
539 err = 0;
|
|
|
540 if (!REQ_SUCCESS(req)) {
|
|
|
541 err = GET_REQ_SOCK_ERROR(req);
|
|
|
542 }
|
|
|
543 req->cb(req, uv_translate_sys_error(err));
|
|
|
544 }
|
|
|
545
|
|
|
546 DECREASE_PENDING_REQ_COUNT(handle);
|
|
|
547 }
|
|
|
548
|
|
|
549
|
|
|
550 static int uv__udp_set_membership4(uv_udp_t* handle,
|
|
|
551 const struct sockaddr_in* multicast_addr,
|
|
|
552 const char* interface_addr,
|
|
|
553 uv_membership membership) {
|
|
|
554 int err;
|
|
|
555 int optname;
|
|
|
556 struct ip_mreq mreq;
|
|
|
557
|
|
|
558 if (handle->flags & UV_HANDLE_IPV6)
|
|
|
559 return UV_EINVAL;
|
|
|
560
|
|
|
561 /* If the socket is unbound, bind to inaddr_any. */
|
|
|
562 err = uv__udp_maybe_bind(handle,
|
|
|
563 (const struct sockaddr*) &uv_addr_ip4_any_,
|
|
|
564 sizeof(uv_addr_ip4_any_),
|
|
|
565 UV_UDP_REUSEADDR);
|
|
|
566 if (err)
|
|
|
567 return uv_translate_sys_error(err);
|
|
|
568
|
|
|
569 memset(&mreq, 0, sizeof mreq);
|
|
|
570
|
|
|
571 if (interface_addr) {
|
|
|
572 err = uv_inet_pton(AF_INET, interface_addr, &mreq.imr_interface.s_addr);
|
|
|
573 if (err)
|
|
|
574 return err;
|
|
|
575 } else {
|
|
|
576 mreq.imr_interface.s_addr = htonl(INADDR_ANY);
|
|
|
577 }
|
|
|
578
|
|
|
579 mreq.imr_multiaddr.s_addr = multicast_addr->sin_addr.s_addr;
|
|
|
580
|
|
|
581 switch (membership) {
|
|
|
582 case UV_JOIN_GROUP:
|
|
|
583 optname = IP_ADD_MEMBERSHIP;
|
|
|
584 break;
|
|
|
585 case UV_LEAVE_GROUP:
|
|
|
586 optname = IP_DROP_MEMBERSHIP;
|
|
|
587 break;
|
|
|
588 default:
|
|
|
589 return UV_EINVAL;
|
|
|
590 }
|
|
|
591
|
|
|
592 if (setsockopt(handle->socket,
|
|
|
593 IPPROTO_IP,
|
|
|
594 optname,
|
|
|
595 (char*) &mreq,
|
|
|
596 sizeof mreq) == SOCKET_ERROR) {
|
|
|
597 return uv_translate_sys_error(WSAGetLastError());
|
|
|
598 }
|
|
|
599
|
|
|
600 return 0;
|
|
|
601 }
|
|
|
602
|
|
|
603
|
|
|
604 int uv__udp_set_membership6(uv_udp_t* handle,
|
|
|
605 const struct sockaddr_in6* multicast_addr,
|
|
|
606 const char* interface_addr,
|
|
|
607 uv_membership membership) {
|
|
|
608 int optname;
|
|
|
609 int err;
|
|
|
610 struct ipv6_mreq mreq;
|
|
|
611 struct sockaddr_in6 addr6;
|
|
|
612
|
|
|
613 if ((handle->flags & UV_HANDLE_BOUND) && !(handle->flags & UV_HANDLE_IPV6))
|
|
|
614 return UV_EINVAL;
|
|
|
615
|
|
|
616 err = uv__udp_maybe_bind(handle,
|
|
|
617 (const struct sockaddr*) &uv_addr_ip6_any_,
|
|
|
618 sizeof(uv_addr_ip6_any_),
|
|
|
619 UV_UDP_REUSEADDR);
|
|
|
620
|
|
|
621 if (err)
|
|
|
622 return uv_translate_sys_error(err);
|
|
|
623
|
|
|
624 memset(&mreq, 0, sizeof(mreq));
|
|
|
625
|
|
|
626 if (interface_addr) {
|
|
|
627 if (uv_ip6_addr(interface_addr, 0, &addr6))
|
|
|
628 return UV_EINVAL;
|
|
|
629 mreq.ipv6mr_interface = addr6.sin6_scope_id;
|
|
|
630 } else {
|
|
|
631 mreq.ipv6mr_interface = 0;
|
|
|
632 }
|
|
|
633
|
|
|
634 mreq.ipv6mr_multiaddr = multicast_addr->sin6_addr;
|
|
|
635
|
|
|
636 switch (membership) {
|
|
|
637 case UV_JOIN_GROUP:
|
|
|
638 optname = IPV6_ADD_MEMBERSHIP;
|
|
|
639 break;
|
|
|
640 case UV_LEAVE_GROUP:
|
|
|
641 optname = IPV6_DROP_MEMBERSHIP;
|
|
|
642 break;
|
|
|
643 default:
|
|
|
644 return UV_EINVAL;
|
|
|
645 }
|
|
|
646
|
|
|
647 if (setsockopt(handle->socket,
|
|
|
648 IPPROTO_IPV6,
|
|
|
649 optname,
|
|
|
650 (char*) &mreq,
|
|
|
651 sizeof mreq) == SOCKET_ERROR) {
|
|
|
652 return uv_translate_sys_error(WSAGetLastError());
|
|
|
653 }
|
|
|
654
|
|
|
655 return 0;
|
|
|
656 }
|
|
|
657
|
|
|
658
|
|
|
659 static int uv__udp_set_source_membership4(uv_udp_t* handle,
|
|
|
660 const struct sockaddr_in* multicast_addr,
|
|
|
661 const char* interface_addr,
|
|
|
662 const struct sockaddr_in* source_addr,
|
|
|
663 uv_membership membership) {
|
|
|
664 struct ip_mreq_source mreq;
|
|
|
665 int optname;
|
|
|
666 int err;
|
|
|
667
|
|
|
668 if (handle->flags & UV_HANDLE_IPV6)
|
|
|
669 return UV_EINVAL;
|
|
|
670
|
|
|
671 /* If the socket is unbound, bind to inaddr_any. */
|
|
|
672 err = uv__udp_maybe_bind(handle,
|
|
|
673 (const struct sockaddr*) &uv_addr_ip4_any_,
|
|
|
674 sizeof(uv_addr_ip4_any_),
|
|
|
675 UV_UDP_REUSEADDR);
|
|
|
676 if (err)
|
|
|
677 return uv_translate_sys_error(err);
|
|
|
678
|
|
|
679 memset(&mreq, 0, sizeof(mreq));
|
|
|
680
|
|
|
681 if (interface_addr != NULL) {
|
|
|
682 err = uv_inet_pton(AF_INET, interface_addr, &mreq.imr_interface.s_addr);
|
|
|
683 if (err)
|
|
|
684 return err;
|
|
|
685 } else {
|
|
|
686 mreq.imr_interface.s_addr = htonl(INADDR_ANY);
|
|
|
687 }
|
|
|
688
|
|
|
689 mreq.imr_multiaddr.s_addr = multicast_addr->sin_addr.s_addr;
|
|
|
690 mreq.imr_sourceaddr.s_addr = source_addr->sin_addr.s_addr;
|
|
|
691
|
|
|
692 if (membership == UV_JOIN_GROUP)
|
|
|
693 optname = IP_ADD_SOURCE_MEMBERSHIP;
|
|
|
694 else if (membership == UV_LEAVE_GROUP)
|
|
|
695 optname = IP_DROP_SOURCE_MEMBERSHIP;
|
|
|
696 else
|
|
|
697 return UV_EINVAL;
|
|
|
698
|
|
|
699 if (setsockopt(handle->socket,
|
|
|
700 IPPROTO_IP,
|
|
|
701 optname,
|
|
|
702 (char*) &mreq,
|
|
|
703 sizeof(mreq)) == SOCKET_ERROR) {
|
|
|
704 return uv_translate_sys_error(WSAGetLastError());
|
|
|
705 }
|
|
|
706
|
|
|
707 return 0;
|
|
|
708 }
|
|
|
709
|
|
|
710
|
|
|
711 int uv__udp_set_source_membership6(uv_udp_t* handle,
|
|
|
712 const struct sockaddr_in6* multicast_addr,
|
|
|
713 const char* interface_addr,
|
|
|
714 const struct sockaddr_in6* source_addr,
|
|
|
715 uv_membership membership) {
|
|
|
716 struct group_source_req mreq;
|
|
|
717 struct sockaddr_in6 addr6;
|
|
|
718 int optname;
|
|
|
719 int err;
|
|
|
720
|
|
|
721 STATIC_ASSERT(sizeof(mreq.gsr_group) >= sizeof(*multicast_addr));
|
|
|
722 STATIC_ASSERT(sizeof(mreq.gsr_source) >= sizeof(*source_addr));
|
|
|
723
|
|
|
724 if ((handle->flags & UV_HANDLE_BOUND) && !(handle->flags & UV_HANDLE_IPV6))
|
|
|
725 return UV_EINVAL;
|
|
|
726
|
|
|
727 err = uv__udp_maybe_bind(handle,
|
|
|
728 (const struct sockaddr*) &uv_addr_ip6_any_,
|
|
|
729 sizeof(uv_addr_ip6_any_),
|
|
|
730 UV_UDP_REUSEADDR);
|
|
|
731
|
|
|
732 if (err)
|
|
|
733 return uv_translate_sys_error(err);
|
|
|
734
|
|
|
735 memset(&mreq, 0, sizeof(mreq));
|
|
|
736
|
|
|
737 if (interface_addr != NULL) {
|
|
|
738 err = uv_ip6_addr(interface_addr, 0, &addr6);
|
|
|
739 if (err)
|
|
|
740 return err;
|
|
|
741 mreq.gsr_interface = addr6.sin6_scope_id;
|
|
|
742 } else {
|
|
|
743 mreq.gsr_interface = 0;
|
|
|
744 }
|
|
|
745
|
|
|
746 memcpy(&mreq.gsr_group, multicast_addr, sizeof(*multicast_addr));
|
|
|
747 memcpy(&mreq.gsr_source, source_addr, sizeof(*source_addr));
|
|
|
748
|
|
|
749 if (membership == UV_JOIN_GROUP)
|
|
|
750 optname = MCAST_JOIN_SOURCE_GROUP;
|
|
|
751 else if (membership == UV_LEAVE_GROUP)
|
|
|
752 optname = MCAST_LEAVE_SOURCE_GROUP;
|
|
|
753 else
|
|
|
754 return UV_EINVAL;
|
|
|
755
|
|
|
756 if (setsockopt(handle->socket,
|
|
|
757 IPPROTO_IPV6,
|
|
|
758 optname,
|
|
|
759 (char*) &mreq,
|
|
|
760 sizeof(mreq)) == SOCKET_ERROR) {
|
|
|
761 return uv_translate_sys_error(WSAGetLastError());
|
|
|
762 }
|
|
|
763
|
|
|
764 return 0;
|
|
|
765 }
|
|
|
766
|
|
|
767
|
|
|
768 int uv_udp_set_membership(uv_udp_t* handle,
|
|
|
769 const char* multicast_addr,
|
|
|
770 const char* interface_addr,
|
|
|
771 uv_membership membership) {
|
|
|
772 struct sockaddr_in addr4;
|
|
|
773 struct sockaddr_in6 addr6;
|
|
|
774
|
|
|
775 if (uv_ip4_addr(multicast_addr, 0, &addr4) == 0)
|
|
|
776 return uv__udp_set_membership4(handle, &addr4, interface_addr, membership);
|
|
|
777 else if (uv_ip6_addr(multicast_addr, 0, &addr6) == 0)
|
|
|
778 return uv__udp_set_membership6(handle, &addr6, interface_addr, membership);
|
|
|
779 else
|
|
|
780 return UV_EINVAL;
|
|
|
781 }
|
|
|
782
|
|
|
783
|
|
|
784 int uv_udp_set_source_membership(uv_udp_t* handle,
|
|
|
785 const char* multicast_addr,
|
|
|
786 const char* interface_addr,
|
|
|
787 const char* source_addr,
|
|
|
788 uv_membership membership) {
|
|
|
789 int err;
|
|
|
790 struct sockaddr_storage mcast_addr;
|
|
|
791 struct sockaddr_in* mcast_addr4;
|
|
|
792 struct sockaddr_in6* mcast_addr6;
|
|
|
793 struct sockaddr_storage src_addr;
|
|
|
794 struct sockaddr_in* src_addr4;
|
|
|
795 struct sockaddr_in6* src_addr6;
|
|
|
796
|
|
|
797 mcast_addr4 = (struct sockaddr_in*)&mcast_addr;
|
|
|
798 mcast_addr6 = (struct sockaddr_in6*)&mcast_addr;
|
|
|
799 src_addr4 = (struct sockaddr_in*)&src_addr;
|
|
|
800 src_addr6 = (struct sockaddr_in6*)&src_addr;
|
|
|
801
|
|
|
802 err = uv_ip4_addr(multicast_addr, 0, mcast_addr4);
|
|
|
803 if (err) {
|
|
|
804 err = uv_ip6_addr(multicast_addr, 0, mcast_addr6);
|
|
|
805 if (err)
|
|
|
806 return err;
|
|
|
807 err = uv_ip6_addr(source_addr, 0, src_addr6);
|
|
|
808 if (err)
|
|
|
809 return err;
|
|
|
810 return uv__udp_set_source_membership6(handle,
|
|
|
811 mcast_addr6,
|
|
|
812 interface_addr,
|
|
|
813 src_addr6,
|
|
|
814 membership);
|
|
|
815 }
|
|
|
816
|
|
|
817 err = uv_ip4_addr(source_addr, 0, src_addr4);
|
|
|
818 if (err)
|
|
|
819 return err;
|
|
|
820 return uv__udp_set_source_membership4(handle,
|
|
|
821 mcast_addr4,
|
|
|
822 interface_addr,
|
|
|
823 src_addr4,
|
|
|
824 membership);
|
|
|
825 }
|
|
|
826
|
|
|
827
|
|
|
828 int uv_udp_set_multicast_interface(uv_udp_t* handle, const char* interface_addr) {
|
|
|
829 struct sockaddr_storage addr_st;
|
|
|
830 struct sockaddr_in* addr4;
|
|
|
831 struct sockaddr_in6* addr6;
|
|
|
832
|
|
|
833 addr4 = (struct sockaddr_in*) &addr_st;
|
|
|
834 addr6 = (struct sockaddr_in6*) &addr_st;
|
|
|
835
|
|
|
836 if (!interface_addr) {
|
|
|
837 memset(&addr_st, 0, sizeof addr_st);
|
|
|
838 if (handle->flags & UV_HANDLE_IPV6) {
|
|
|
839 addr_st.ss_family = AF_INET6;
|
|
|
840 addr6->sin6_scope_id = 0;
|
|
|
841 } else {
|
|
|
842 addr_st.ss_family = AF_INET;
|
|
|
843 addr4->sin_addr.s_addr = htonl(INADDR_ANY);
|
|
|
844 }
|
|
|
845 } else if (uv_ip4_addr(interface_addr, 0, addr4) == 0) {
|
|
|
846 /* nothing, address was parsed */
|
|
|
847 } else if (uv_ip6_addr(interface_addr, 0, addr6) == 0) {
|
|
|
848 /* nothing, address was parsed */
|
|
|
849 } else {
|
|
|
850 return UV_EINVAL;
|
|
|
851 }
|
|
|
852
|
|
|
853 if (handle->socket == INVALID_SOCKET)
|
|
|
854 return UV_EBADF;
|
|
|
855
|
|
|
856 if (addr_st.ss_family == AF_INET) {
|
|
|
857 if (setsockopt(handle->socket,
|
|
|
858 IPPROTO_IP,
|
|
|
859 IP_MULTICAST_IF,
|
|
|
860 (char*) &addr4->sin_addr,
|
|
|
861 sizeof(addr4->sin_addr)) == SOCKET_ERROR) {
|
|
|
862 return uv_translate_sys_error(WSAGetLastError());
|
|
|
863 }
|
|
|
864 } else if (addr_st.ss_family == AF_INET6) {
|
|
|
865 if (setsockopt(handle->socket,
|
|
|
866 IPPROTO_IPV6,
|
|
|
867 IPV6_MULTICAST_IF,
|
|
|
868 (char*) &addr6->sin6_scope_id,
|
|
|
869 sizeof(addr6->sin6_scope_id)) == SOCKET_ERROR) {
|
|
|
870 return uv_translate_sys_error(WSAGetLastError());
|
|
|
871 }
|
|
|
872 } else {
|
|
|
873 assert(0 && "unexpected address family");
|
|
|
874 abort();
|
|
|
875 }
|
|
|
876
|
|
|
877 return 0;
|
|
|
878 }
|
|
|
879
|
|
|
880
|
|
|
881 int uv_udp_set_broadcast(uv_udp_t* handle, int value) {
|
|
|
882 BOOL optval = (BOOL) value;
|
|
|
883
|
|
|
884 if (handle->socket == INVALID_SOCKET)
|
|
|
885 return UV_EBADF;
|
|
|
886
|
|
|
887 if (setsockopt(handle->socket,
|
|
|
888 SOL_SOCKET,
|
|
|
889 SO_BROADCAST,
|
|
|
890 (char*) &optval,
|
|
|
891 sizeof optval)) {
|
|
|
892 return uv_translate_sys_error(WSAGetLastError());
|
|
|
893 }
|
|
|
894
|
|
|
895 return 0;
|
|
|
896 }
|
|
|
897
|
|
|
898
|
|
|
899 int uv__udp_is_bound(uv_udp_t* handle) {
|
|
|
900 struct sockaddr_storage addr;
|
|
|
901 int addrlen;
|
|
|
902
|
|
|
903 addrlen = sizeof(addr);
|
|
|
904 if (uv_udp_getsockname(handle, (struct sockaddr*) &addr, &addrlen) != 0)
|
|
|
905 return 0;
|
|
|
906
|
|
|
907 return addrlen > 0;
|
|
|
908 }
|
|
|
909
|
|
|
910
|
|
|
911 int uv_udp_open(uv_udp_t* handle, uv_os_sock_t sock) {
|
|
|
912 WSAPROTOCOL_INFOW protocol_info;
|
|
|
913 int opt_len;
|
|
|
914 int err;
|
|
|
915
|
|
|
916 /* Detect the address family of the socket. */
|
|
|
917 opt_len = (int) sizeof protocol_info;
|
|
|
918 if (getsockopt(sock,
|
|
|
919 SOL_SOCKET,
|
|
|
920 SO_PROTOCOL_INFOW,
|
|
|
921 (char*) &protocol_info,
|
|
|
922 &opt_len) == SOCKET_ERROR) {
|
|
|
923 return uv_translate_sys_error(GetLastError());
|
|
|
924 }
|
|
|
925
|
|
|
926 err = uv__udp_set_socket(handle->loop,
|
|
|
927 handle,
|
|
|
928 sock,
|
|
|
929 protocol_info.iAddressFamily);
|
|
|
930 if (err)
|
|
|
931 return uv_translate_sys_error(err);
|
|
|
932
|
|
|
933 if (uv__udp_is_bound(handle))
|
|
|
934 handle->flags |= UV_HANDLE_BOUND;
|
|
|
935
|
|
|
936 if (uv__udp_is_connected(handle))
|
|
|
937 handle->flags |= UV_HANDLE_UDP_CONNECTED;
|
|
|
938
|
|
|
939 return 0;
|
|
|
940 }
|
|
|
941
|
|
|
942
|
|
|
943 #define SOCKOPT_SETTER(name, option4, option6, validate) \
|
|
|
944 int uv_udp_set_##name(uv_udp_t* handle, int value) { \
|
|
|
945 DWORD optval = (DWORD) value; \
|
|
|
946 \
|
|
|
947 if (!(validate(value))) { \
|
|
|
948 return UV_EINVAL; \
|
|
|
949 } \
|
|
|
950 \
|
|
|
951 if (handle->socket == INVALID_SOCKET) \
|
|
|
952 return UV_EBADF; \
|
|
|
953 \
|
|
|
954 if (!(handle->flags & UV_HANDLE_IPV6)) { \
|
|
|
955 /* Set IPv4 socket option */ \
|
|
|
956 if (setsockopt(handle->socket, \
|
|
|
957 IPPROTO_IP, \
|
|
|
958 option4, \
|
|
|
959 (char*) &optval, \
|
|
|
960 sizeof optval)) { \
|
|
|
961 return uv_translate_sys_error(WSAGetLastError()); \
|
|
|
962 } \
|
|
|
963 } else { \
|
|
|
964 /* Set IPv6 socket option */ \
|
|
|
965 if (setsockopt(handle->socket, \
|
|
|
966 IPPROTO_IPV6, \
|
|
|
967 option6, \
|
|
|
968 (char*) &optval, \
|
|
|
969 sizeof optval)) { \
|
|
|
970 return uv_translate_sys_error(WSAGetLastError()); \
|
|
|
971 } \
|
|
|
972 } \
|
|
|
973 return 0; \
|
|
|
974 }
|
|
|
975
|
|
|
976 #define VALIDATE_TTL(value) ((value) >= 1 && (value) <= 255)
|
|
|
977 #define VALIDATE_MULTICAST_TTL(value) ((value) >= -1 && (value) <= 255)
|
|
|
978 #define VALIDATE_MULTICAST_LOOP(value) (1)
|
|
|
979
|
|
|
980 SOCKOPT_SETTER(ttl,
|
|
|
981 IP_TTL,
|
|
|
982 IPV6_HOPLIMIT,
|
|
|
983 VALIDATE_TTL)
|
|
|
984 SOCKOPT_SETTER(multicast_ttl,
|
|
|
985 IP_MULTICAST_TTL,
|
|
|
986 IPV6_MULTICAST_HOPS,
|
|
|
987 VALIDATE_MULTICAST_TTL)
|
|
|
988 SOCKOPT_SETTER(multicast_loop,
|
|
|
989 IP_MULTICAST_LOOP,
|
|
|
990 IPV6_MULTICAST_LOOP,
|
|
|
991 VALIDATE_MULTICAST_LOOP)
|
|
|
992
|
|
|
993 #undef SOCKOPT_SETTER
|
|
|
994 #undef VALIDATE_TTL
|
|
|
995 #undef VALIDATE_MULTICAST_TTL
|
|
|
996 #undef VALIDATE_MULTICAST_LOOP
|
|
|
997
|
|
|
998
|
|
|
999 /* This function is an egress point, i.e. it returns libuv errors rather than
|
|
|
1000 * system errors.
|
|
|
1001 */
|
|
|
1002 int uv__udp_bind(uv_udp_t* handle,
|
|
|
1003 const struct sockaddr* addr,
|
|
|
1004 unsigned int addrlen,
|
|
|
1005 unsigned int flags) {
|
|
|
1006 int err;
|
|
|
1007
|
|
|
1008 err = uv__udp_maybe_bind(handle, addr, addrlen, flags);
|
|
|
1009 if (err)
|
|
|
1010 return uv_translate_sys_error(err);
|
|
|
1011
|
|
|
1012 return 0;
|
|
|
1013 }
|
|
|
1014
|
|
|
1015
|
|
|
1016 int uv__udp_connect(uv_udp_t* handle,
|
|
|
1017 const struct sockaddr* addr,
|
|
|
1018 unsigned int addrlen) {
|
|
|
1019 const struct sockaddr* bind_addr;
|
|
|
1020 int err;
|
|
|
1021
|
|
|
1022 if (!(handle->flags & UV_HANDLE_BOUND)) {
|
|
|
1023 if (addrlen == sizeof(uv_addr_ip4_any_))
|
|
|
1024 bind_addr = (const struct sockaddr*) &uv_addr_ip4_any_;
|
|
|
1025 else if (addrlen == sizeof(uv_addr_ip6_any_))
|
|
|
1026 bind_addr = (const struct sockaddr*) &uv_addr_ip6_any_;
|
|
|
1027 else
|
|
|
1028 return UV_EINVAL;
|
|
|
1029
|
|
|
1030 err = uv__udp_maybe_bind(handle, bind_addr, addrlen, 0);
|
|
|
1031 if (err)
|
|
|
1032 return uv_translate_sys_error(err);
|
|
|
1033 }
|
|
|
1034
|
|
|
1035 err = connect(handle->socket, addr, addrlen);
|
|
|
1036 if (err)
|
|
|
1037 return uv_translate_sys_error(WSAGetLastError());
|
|
|
1038
|
|
|
1039 handle->flags |= UV_HANDLE_UDP_CONNECTED;
|
|
|
1040
|
|
|
1041 return 0;
|
|
|
1042 }
|
|
|
1043
|
|
|
1044
|
|
|
1045 int uv__udp_disconnect(uv_udp_t* handle) {
|
|
|
1046 int err;
|
|
|
1047 struct sockaddr_storage addr;
|
|
|
1048
|
|
|
1049 memset(&addr, 0, sizeof(addr));
|
|
|
1050
|
|
|
1051 err = connect(handle->socket, (struct sockaddr*) &addr, sizeof(addr));
|
|
|
1052 if (err)
|
|
|
1053 return uv_translate_sys_error(WSAGetLastError());
|
|
|
1054
|
|
|
1055 handle->flags &= ~UV_HANDLE_UDP_CONNECTED;
|
|
|
1056 return 0;
|
|
|
1057 }
|
|
|
1058
|
|
|
1059
|
|
|
1060 /* This function is an egress point, i.e. it returns libuv errors rather than
|
|
|
1061 * system errors.
|
|
|
1062 */
|
|
|
1063 int uv__udp_send(uv_udp_send_t* req,
|
|
|
1064 uv_udp_t* handle,
|
|
|
1065 const uv_buf_t bufs[],
|
|
|
1066 unsigned int nbufs,
|
|
|
1067 const struct sockaddr* addr,
|
|
|
1068 unsigned int addrlen,
|
|
|
1069 uv_udp_send_cb send_cb) {
|
|
|
1070 const struct sockaddr* bind_addr;
|
|
|
1071 int err;
|
|
|
1072
|
|
|
1073 if (!(handle->flags & UV_HANDLE_BOUND)) {
|
|
|
1074 if (addrlen == sizeof(uv_addr_ip4_any_))
|
|
|
1075 bind_addr = (const struct sockaddr*) &uv_addr_ip4_any_;
|
|
|
1076 else if (addrlen == sizeof(uv_addr_ip6_any_))
|
|
|
1077 bind_addr = (const struct sockaddr*) &uv_addr_ip6_any_;
|
|
|
1078 else
|
|
|
1079 return UV_EINVAL;
|
|
|
1080
|
|
|
1081 err = uv__udp_maybe_bind(handle, bind_addr, addrlen, 0);
|
|
|
1082 if (err)
|
|
|
1083 return uv_translate_sys_error(err);
|
|
|
1084 }
|
|
|
1085
|
|
|
1086 err = uv__send(req, handle, bufs, nbufs, addr, addrlen, send_cb);
|
|
|
1087 if (err)
|
|
|
1088 return uv_translate_sys_error(err);
|
|
|
1089
|
|
|
1090 return 0;
|
|
|
1091 }
|
|
|
1092
|
|
|
1093
|
|
|
1094 int uv__udp_try_send(uv_udp_t* handle,
|
|
|
1095 const uv_buf_t bufs[],
|
|
|
1096 unsigned int nbufs,
|
|
|
1097 const struct sockaddr* addr,
|
|
|
1098 unsigned int addrlen) {
|
|
|
1099 DWORD bytes;
|
|
|
1100 const struct sockaddr* bind_addr;
|
|
|
1101 struct sockaddr_storage converted;
|
|
|
1102 int err;
|
|
|
1103
|
|
|
1104 if (nbufs < 1)
|
|
|
1105 return UV_EINVAL;
|
|
|
1106
|
|
|
1107 if (addr != NULL) {
|
|
|
1108 err = uv__convert_to_localhost_if_unspecified(addr, &converted);
|
|
|
1109 if (err)
|
|
|
1110 return err;
|
|
|
1111 addr = (const struct sockaddr*) &converted;
|
|
|
1112 }
|
|
|
1113
|
|
|
1114 /* Already sending a message.*/
|
|
|
1115 if (handle->send_queue_count != 0)
|
|
|
1116 return UV_EAGAIN;
|
|
|
1117
|
|
|
1118 if (!(handle->flags & UV_HANDLE_BOUND)) {
|
|
|
1119 if (addrlen == sizeof(uv_addr_ip4_any_))
|
|
|
1120 bind_addr = (const struct sockaddr*) &uv_addr_ip4_any_;
|
|
|
1121 else if (addrlen == sizeof(uv_addr_ip6_any_))
|
|
|
1122 bind_addr = (const struct sockaddr*) &uv_addr_ip6_any_;
|
|
|
1123 else
|
|
|
1124 return UV_EINVAL;
|
|
|
1125 err = uv__udp_maybe_bind(handle, bind_addr, addrlen, 0);
|
|
|
1126 if (err)
|
|
|
1127 return uv_translate_sys_error(err);
|
|
|
1128 }
|
|
|
1129
|
|
|
1130 err = WSASendTo(handle->socket,
|
|
|
1131 (WSABUF*)bufs,
|
|
|
1132 nbufs,
|
|
|
1133 &bytes,
|
|
|
1134 0,
|
|
|
1135 addr,
|
|
|
1136 addrlen,
|
|
|
1137 NULL,
|
|
|
1138 NULL);
|
|
|
1139
|
|
|
1140 if (err)
|
|
|
1141 return uv_translate_sys_error(WSAGetLastError());
|
|
|
1142
|
|
|
1143 return bytes;
|
|
|
1144 }
|
|
|
1145
|
|
|
1146
|
|
|
1147 int uv__udp_try_send2(uv_udp_t* handle,
|
|
|
1148 unsigned int count,
|
|
|
1149 uv_buf_t* bufs[/*count*/],
|
|
|
1150 unsigned int nbufs[/*count*/],
|
|
|
1151 struct sockaddr* addrs[/*count*/]) {
|
|
|
1152 unsigned int i;
|
|
|
1153 int r;
|
|
|
1154
|
|
|
1155 for (i = 0; i < count; i++) {
|
|
|
1156 r = uv_udp_try_send(handle, bufs[i], nbufs[i], addrs[i]);
|
|
|
1157 if (r < 0)
|
|
|
1158 return i > 0 ? i : r; /* Error if first packet, else send count. */
|
|
|
1159 }
|
|
|
1160
|
|
|
1161 return i;
|
|
|
1162 }
|
