1 /* $NetBSD: listener.c,v 1.1.1.2 2015/01/29 06:38:08 spz Exp $ */
2 /*
3 * Copyright (c) 2009-2012 Niels Provos, Nick Mathewson
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 * 3. The name of the author may not be used to endorse or promote products
14 * derived from this software without specific prior written permission.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
17 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
18 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
19 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
20 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
21 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
22 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
23 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
24 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
25 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26 */
27
28 #include <sys/types.h>
29
30 #include "event2/event-config.h"
31 #include <sys/cdefs.h>
32 __RCSID("$NetBSD: listener.c,v 1.1.1.2 2015/01/29 06:38:08 spz Exp $");
33
34 #ifdef WIN32
35 #ifndef _WIN32_WINNT
36 /* Minimum required for InitializeCriticalSectionAndSpinCount */
37 #define _WIN32_WINNT 0x0403
38 #endif
39 #include <winsock2.h>
40 #include <ws2tcpip.h>
41 #include <mswsock.h>
42 #endif
43 #include <errno.h>
44 #ifdef _EVENT_HAVE_SYS_SOCKET_H
45 #include <sys/socket.h>
46 #endif
47 #ifdef _EVENT_HAVE_FCNTL_H
48 #include <fcntl.h>
49 #endif
50 #ifdef _EVENT_HAVE_UNISTD_H
51 #include <unistd.h>
52 #endif
53
54 #include "event2/listener.h"
55 #include "event2/util.h"
56 #include "event2/event.h"
57 #include "event2/event_struct.h"
58 #include "mm-internal.h"
59 #include "util-internal.h"
60 #include "log-internal.h"
61 #include "evthread-internal.h"
62 #ifdef WIN32
63 #include "iocp-internal.h"
64 #include "defer-internal.h"
65 #include "event-internal.h"
66 #endif
67
68 struct evconnlistener_ops {
69 int (*enable)(struct evconnlistener *);
70 int (*disable)(struct evconnlistener *);
71 void (*destroy)(struct evconnlistener *);
72 void (*shutdown)(struct evconnlistener *);
73 evutil_socket_t (*getfd)(struct evconnlistener *);
74 struct event_base *(*getbase)(struct evconnlistener *);
75 };
76
77 struct evconnlistener {
78 const struct evconnlistener_ops *ops;
79 void *lock;
80 evconnlistener_cb cb;
81 evconnlistener_errorcb errorcb;
82 void *user_data;
83 unsigned flags;
84 short refcnt;
85 unsigned enabled : 1;
86 };
87
88 struct evconnlistener_event {
89 struct evconnlistener base;
90 struct event listener;
91 };
92
93 #ifdef WIN32
94 struct evconnlistener_iocp {
95 struct evconnlistener base;
96 evutil_socket_t fd;
97 struct event_base *event_base;
98 struct event_iocp_port *port;
99 short n_accepting;
100 unsigned shutting_down : 1;
101 unsigned event_added : 1;
102 struct accepting_socket **accepting;
103 };
104 #endif
105
106 #define LOCK(listener) EVLOCK_LOCK((listener)->lock, 0)
107 #define UNLOCK(listener) EVLOCK_UNLOCK((listener)->lock, 0)
108
109 struct evconnlistener *
110 evconnlistener_new_async(struct event_base *base,
111 evconnlistener_cb cb, void *ptr, unsigned flags, int backlog,
112 evutil_socket_t fd); /* XXXX export this? */
113
114 static int event_listener_enable(struct evconnlistener *);
115 static int event_listener_disable(struct evconnlistener *);
116 static void event_listener_destroy(struct evconnlistener *);
117 static evutil_socket_t event_listener_getfd(struct evconnlistener *);
118 static struct event_base *event_listener_getbase(struct evconnlistener *);
119
120 #if 0
121 static void
122 listener_incref_and_lock(struct evconnlistener *listener)
123 {
124 LOCK(listener);
125 ++listener->refcnt;
126 }
127 #endif
128
129 static int
listener_decref_and_unlock(struct evconnlistener * listener)130 listener_decref_and_unlock(struct evconnlistener *listener)
131 {
132 int refcnt = --listener->refcnt;
133 if (refcnt == 0) {
134 listener->ops->destroy(listener);
135 UNLOCK(listener);
136 EVTHREAD_FREE_LOCK(listener->lock, EVTHREAD_LOCKTYPE_RECURSIVE);
137 mm_free(listener);
138 return 1;
139 } else {
140 UNLOCK(listener);
141 return 0;
142 }
143 }
144
145 static const struct evconnlistener_ops evconnlistener_event_ops = {
146 event_listener_enable,
147 event_listener_disable,
148 event_listener_destroy,
149 NULL, /* shutdown */
150 event_listener_getfd,
151 event_listener_getbase
152 };
153
154 static void listener_read_cb(evutil_socket_t, short, void *);
155
156 struct evconnlistener *
evconnlistener_new(struct event_base * base,evconnlistener_cb cb,void * ptr,unsigned flags,int backlog,evutil_socket_t fd)157 evconnlistener_new(struct event_base *base,
158 evconnlistener_cb cb, void *ptr, unsigned flags, int backlog,
159 evutil_socket_t fd)
160 {
161 struct evconnlistener_event *lev;
162
163 #ifdef WIN32
164 if (base && event_base_get_iocp(base)) {
165 const struct win32_extension_fns *ext =
166 event_get_win32_extension_fns();
167 if (ext->AcceptEx && ext->GetAcceptExSockaddrs)
168 return evconnlistener_new_async(base, cb, ptr, flags,
169 backlog, fd);
170 }
171 #endif
172
173 if (backlog > 0) {
174 if (listen(fd, backlog) < 0)
175 return NULL;
176 } else if (backlog < 0) {
177 if (listen(fd, 128) < 0)
178 return NULL;
179 }
180
181 lev = mm_calloc(1, sizeof(struct evconnlistener_event));
182 if (!lev)
183 return NULL;
184
185 lev->base.ops = &evconnlistener_event_ops;
186 lev->base.cb = cb;
187 lev->base.user_data = ptr;
188 lev->base.flags = flags;
189 lev->base.refcnt = 1;
190
191 if (flags & LEV_OPT_THREADSAFE) {
192 EVTHREAD_ALLOC_LOCK(lev->base.lock, EVTHREAD_LOCKTYPE_RECURSIVE);
193 }
194
195 event_assign(&lev->listener, base, fd, EV_READ|EV_PERSIST,
196 listener_read_cb, lev);
197
198 evconnlistener_enable(&lev->base);
199
200 return &lev->base;
201 }
202
203 struct evconnlistener *
evconnlistener_new_bind(struct event_base * base,evconnlistener_cb cb,void * ptr,unsigned flags,int backlog,const struct sockaddr * sa,int socklen)204 evconnlistener_new_bind(struct event_base *base, evconnlistener_cb cb,
205 void *ptr, unsigned flags, int backlog, const struct sockaddr *sa,
206 int socklen)
207 {
208 struct evconnlistener *listener;
209 evutil_socket_t fd;
210 int on = 1;
211 int family = sa ? sa->sa_family : AF_UNSPEC;
212
213 if (backlog == 0)
214 return NULL;
215
216 fd = socket(family, SOCK_STREAM, 0);
217 if (fd == -1)
218 return NULL;
219
220 if (evutil_make_socket_nonblocking(fd) < 0) {
221 evutil_closesocket(fd);
222 return NULL;
223 }
224
225 if (flags & LEV_OPT_CLOSE_ON_EXEC) {
226 if (evutil_make_socket_closeonexec(fd) < 0) {
227 evutil_closesocket(fd);
228 return NULL;
229 }
230 }
231
232 if (setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, (void*)&on, sizeof(on))<0) {
233 evutil_closesocket(fd);
234 return NULL;
235 }
236 if (flags & LEV_OPT_REUSEABLE) {
237 if (evutil_make_listen_socket_reuseable(fd) < 0) {
238 evutil_closesocket(fd);
239 return NULL;
240 }
241 }
242
243 if (sa) {
244 if (bind(fd, sa, socklen)<0) {
245 evutil_closesocket(fd);
246 return NULL;
247 }
248 }
249
250 listener = evconnlistener_new(base, cb, ptr, flags, backlog, fd);
251 if (!listener) {
252 evutil_closesocket(fd);
253 return NULL;
254 }
255
256 return listener;
257 }
258
259 void
evconnlistener_free(struct evconnlistener * lev)260 evconnlistener_free(struct evconnlistener *lev)
261 {
262 LOCK(lev);
263 lev->cb = NULL;
264 lev->errorcb = NULL;
265 if (lev->ops->shutdown)
266 lev->ops->shutdown(lev);
267 listener_decref_and_unlock(lev);
268 }
269
270 static void
event_listener_destroy(struct evconnlistener * lev)271 event_listener_destroy(struct evconnlistener *lev)
272 {
273 struct evconnlistener_event *lev_e =
274 EVUTIL_UPCAST(lev, struct evconnlistener_event, base);
275
276 event_del(&lev_e->listener);
277 if (lev->flags & LEV_OPT_CLOSE_ON_FREE)
278 evutil_closesocket(event_get_fd(&lev_e->listener));
279 event_debug_unassign(&lev_e->listener);
280 }
281
282 int
evconnlistener_enable(struct evconnlistener * lev)283 evconnlistener_enable(struct evconnlistener *lev)
284 {
285 int r;
286 LOCK(lev);
287 lev->enabled = 1;
288 if (lev->cb)
289 r = lev->ops->enable(lev);
290 else
291 r = 0;
292 UNLOCK(lev);
293 return r;
294 }
295
296 int
evconnlistener_disable(struct evconnlistener * lev)297 evconnlistener_disable(struct evconnlistener *lev)
298 {
299 int r;
300 LOCK(lev);
301 lev->enabled = 0;
302 r = lev->ops->disable(lev);
303 UNLOCK(lev);
304 return r;
305 }
306
307 static int
event_listener_enable(struct evconnlistener * lev)308 event_listener_enable(struct evconnlistener *lev)
309 {
310 struct evconnlistener_event *lev_e =
311 EVUTIL_UPCAST(lev, struct evconnlistener_event, base);
312 return event_add(&lev_e->listener, NULL);
313 }
314
315 static int
event_listener_disable(struct evconnlistener * lev)316 event_listener_disable(struct evconnlistener *lev)
317 {
318 struct evconnlistener_event *lev_e =
319 EVUTIL_UPCAST(lev, struct evconnlistener_event, base);
320 return event_del(&lev_e->listener);
321 }
322
323 evutil_socket_t
evconnlistener_get_fd(struct evconnlistener * lev)324 evconnlistener_get_fd(struct evconnlistener *lev)
325 {
326 evutil_socket_t fd;
327 LOCK(lev);
328 fd = lev->ops->getfd(lev);
329 UNLOCK(lev);
330 return fd;
331 }
332
333 static evutil_socket_t
event_listener_getfd(struct evconnlistener * lev)334 event_listener_getfd(struct evconnlistener *lev)
335 {
336 struct evconnlistener_event *lev_e =
337 EVUTIL_UPCAST(lev, struct evconnlistener_event, base);
338 return event_get_fd(&lev_e->listener);
339 }
340
341 struct event_base *
evconnlistener_get_base(struct evconnlistener * lev)342 evconnlistener_get_base(struct evconnlistener *lev)
343 {
344 struct event_base *base;
345 LOCK(lev);
346 base = lev->ops->getbase(lev);
347 UNLOCK(lev);
348 return base;
349 }
350
351 static struct event_base *
event_listener_getbase(struct evconnlistener * lev)352 event_listener_getbase(struct evconnlistener *lev)
353 {
354 struct evconnlistener_event *lev_e =
355 EVUTIL_UPCAST(lev, struct evconnlistener_event, base);
356 return event_get_base(&lev_e->listener);
357 }
358
359 void
evconnlistener_set_cb(struct evconnlistener * lev,evconnlistener_cb cb,void * arg)360 evconnlistener_set_cb(struct evconnlistener *lev,
361 evconnlistener_cb cb, void *arg)
362 {
363 int enable = 0;
364 LOCK(lev);
365 if (lev->enabled && !lev->cb)
366 enable = 1;
367 lev->cb = cb;
368 lev->user_data = arg;
369 if (enable)
370 evconnlistener_enable(lev);
371 UNLOCK(lev);
372 }
373
374 void
evconnlistener_set_error_cb(struct evconnlistener * lev,evconnlistener_errorcb errorcb)375 evconnlistener_set_error_cb(struct evconnlistener *lev,
376 evconnlistener_errorcb errorcb)
377 {
378 LOCK(lev);
379 lev->errorcb = errorcb;
380 UNLOCK(lev);
381 }
382
383 static void
listener_read_cb(evutil_socket_t fd,short what,void * p)384 listener_read_cb(evutil_socket_t fd, short what, void *p)
385 {
386 struct evconnlistener *lev = p;
387 int err;
388 evconnlistener_cb cb;
389 evconnlistener_errorcb errorcb;
390 void *user_data;
391 LOCK(lev);
392 while (1) {
393 struct sockaddr_storage ss;
394 #ifdef WIN32
395 int socklen = sizeof(ss);
396 #else
397 socklen_t socklen = sizeof(ss);
398 #endif
399 evutil_socket_t new_fd = accept(fd, (struct sockaddr*)&ss, &socklen);
400 if (new_fd < 0)
401 break;
402 if (socklen == 0) {
403 /* This can happen with some older linux kernels in
404 * response to nmap. */
405 evutil_closesocket(new_fd);
406 continue;
407 }
408
409 if (!(lev->flags & LEV_OPT_LEAVE_SOCKETS_BLOCKING))
410 evutil_make_socket_nonblocking(new_fd);
411
412 if (lev->cb == NULL) {
413 evutil_closesocket(new_fd);
414 UNLOCK(lev);
415 return;
416 }
417 ++lev->refcnt;
418 cb = lev->cb;
419 user_data = lev->user_data;
420 UNLOCK(lev);
421 cb(lev, new_fd, (struct sockaddr*)&ss, (int)socklen,
422 user_data);
423 LOCK(lev);
424 if (lev->refcnt == 1) {
425 int freed = listener_decref_and_unlock(lev);
426 EVUTIL_ASSERT(freed);
427 return;
428 }
429 --lev->refcnt;
430 }
431 err = evutil_socket_geterror(fd);
432 if (EVUTIL_ERR_ACCEPT_RETRIABLE(err)) {
433 UNLOCK(lev);
434 return;
435 }
436 if (lev->errorcb != NULL) {
437 ++lev->refcnt;
438 errorcb = lev->errorcb;
439 user_data = lev->user_data;
440 UNLOCK(lev);
441 errorcb(lev, user_data);
442 LOCK(lev);
443 listener_decref_and_unlock(lev);
444 } else {
445 event_sock_warn(fd, "Error from accept() call");
446 }
447 }
448
449 #ifdef WIN32
450 struct accepting_socket {
451 CRITICAL_SECTION lock;
452 struct event_overlapped overlapped;
453 SOCKET s;
454 int error;
455 struct deferred_cb deferred;
456 struct evconnlistener_iocp *lev;
457 ev_uint8_t buflen;
458 ev_uint8_t family;
459 unsigned free_on_cb:1;
460 char addrbuf[1];
461 };
462
463 static void accepted_socket_cb(struct event_overlapped *o, ev_uintptr_t key,
464 ev_ssize_t n, int ok);
465 static void accepted_socket_invoke_user_cb(struct deferred_cb *cb, void *arg);
466
467 static void
iocp_listener_event_add(struct evconnlistener_iocp * lev)468 iocp_listener_event_add(struct evconnlistener_iocp *lev)
469 {
470 if (lev->event_added)
471 return;
472
473 lev->event_added = 1;
474 event_base_add_virtual(lev->event_base);
475 }
476
477 static void
iocp_listener_event_del(struct evconnlistener_iocp * lev)478 iocp_listener_event_del(struct evconnlistener_iocp *lev)
479 {
480 if (!lev->event_added)
481 return;
482
483 lev->event_added = 0;
484 event_base_del_virtual(lev->event_base);
485 }
486
487 static struct accepting_socket *
new_accepting_socket(struct evconnlistener_iocp * lev,int family)488 new_accepting_socket(struct evconnlistener_iocp *lev, int family)
489 {
490 struct accepting_socket *res;
491 int addrlen;
492 int buflen;
493
494 if (family == AF_INET)
495 addrlen = sizeof(struct sockaddr_in);
496 else if (family == AF_INET6)
497 addrlen = sizeof(struct sockaddr_in6);
498 else
499 return NULL;
500 buflen = (addrlen+16)*2;
501
502 res = mm_calloc(1,sizeof(struct accepting_socket)-1+buflen);
503 if (!res)
504 return NULL;
505
506 event_overlapped_init(&res->overlapped, accepted_socket_cb);
507 res->s = INVALID_SOCKET;
508 res->lev = lev;
509 res->buflen = buflen;
510 res->family = family;
511
512 event_deferred_cb_init(&res->deferred,
513 accepted_socket_invoke_user_cb, res);
514
515 InitializeCriticalSectionAndSpinCount(&res->lock, 1000);
516
517 return res;
518 }
519
520 static void
free_and_unlock_accepting_socket(struct accepting_socket * as)521 free_and_unlock_accepting_socket(struct accepting_socket *as)
522 {
523 /* requires lock. */
524 if (as->s != INVALID_SOCKET)
525 closesocket(as->s);
526
527 LeaveCriticalSection(&as->lock);
528 DeleteCriticalSection(&as->lock);
529 mm_free(as);
530 }
531
532 static int
start_accepting(struct accepting_socket * as)533 start_accepting(struct accepting_socket *as)
534 {
535 /* requires lock */
536 const struct win32_extension_fns *ext = event_get_win32_extension_fns();
537 DWORD pending = 0;
538 SOCKET s = socket(as->family, SOCK_STREAM, 0);
539 int error = 0;
540
541 if (!as->lev->base.enabled)
542 return 0;
543
544 if (s == INVALID_SOCKET) {
545 error = WSAGetLastError();
546 goto report_err;
547 }
548
549 /* XXXX It turns out we need to do this again later. Does this call
550 * have any effect? */
551 setsockopt(s, SOL_SOCKET, SO_UPDATE_ACCEPT_CONTEXT,
552 (char *)&as->lev->fd, sizeof(&as->lev->fd));
553
554 if (!(as->lev->base.flags & LEV_OPT_LEAVE_SOCKETS_BLOCKING))
555 evutil_make_socket_nonblocking(s);
556
557 if (event_iocp_port_associate(as->lev->port, s, 1) < 0) {
558 closesocket(s);
559 return -1;
560 }
561
562 as->s = s;
563
564 if (ext->AcceptEx(as->lev->fd, s, as->addrbuf, 0,
565 as->buflen/2, as->buflen/2, &pending, &as->overlapped.overlapped))
566 {
567 /* Immediate success! */
568 accepted_socket_cb(&as->overlapped, 1, 0, 1);
569 } else {
570 error = WSAGetLastError();
571 if (error != ERROR_IO_PENDING) {
572 goto report_err;
573 }
574 }
575
576 return 0;
577
578 report_err:
579 as->error = error;
580 event_deferred_cb_schedule(
581 event_base_get_deferred_cb_queue(as->lev->event_base),
582 &as->deferred);
583 return 0;
584 }
585
586 static void
stop_accepting(struct accepting_socket * as)587 stop_accepting(struct accepting_socket *as)
588 {
589 /* requires lock. */
590 SOCKET s = as->s;
591 as->s = INVALID_SOCKET;
592 closesocket(s);
593 }
594
595 static void
accepted_socket_invoke_user_cb(struct deferred_cb * dcb,void * arg)596 accepted_socket_invoke_user_cb(struct deferred_cb *dcb, void *arg)
597 {
598 struct accepting_socket *as = arg;
599
600 struct sockaddr *sa_local=NULL, *sa_remote=NULL;
601 int socklen_local=0, socklen_remote=0;
602 const struct win32_extension_fns *ext = event_get_win32_extension_fns();
603 struct evconnlistener *lev = &as->lev->base;
604 evutil_socket_t sock=-1;
605 void *data;
606 evconnlistener_cb cb=NULL;
607 evconnlistener_errorcb errorcb=NULL;
608 int error;
609
610 EVUTIL_ASSERT(ext->GetAcceptExSockaddrs);
611
612 LOCK(lev);
613 EnterCriticalSection(&as->lock);
614 if (as->free_on_cb) {
615 free_and_unlock_accepting_socket(as);
616 listener_decref_and_unlock(lev);
617 return;
618 }
619
620 ++lev->refcnt;
621
622 error = as->error;
623 if (error) {
624 as->error = 0;
625 errorcb = lev->errorcb;
626 } else {
627 ext->GetAcceptExSockaddrs(
628 as->addrbuf, 0, as->buflen/2, as->buflen/2,
629 &sa_local, &socklen_local, &sa_remote,
630 &socklen_remote);
631 sock = as->s;
632 cb = lev->cb;
633 as->s = INVALID_SOCKET;
634
635 /* We need to call this so getsockname, getpeername, and
636 * shutdown work correctly on the accepted socket. */
637 /* XXXX handle error? */
638 setsockopt(sock, SOL_SOCKET, SO_UPDATE_ACCEPT_CONTEXT,
639 (char *)&as->lev->fd, sizeof(&as->lev->fd));
640 }
641 data = lev->user_data;
642
643 LeaveCriticalSection(&as->lock);
644 UNLOCK(lev);
645
646 if (errorcb) {
647 WSASetLastError(error);
648 errorcb(lev, data);
649 } else if (cb) {
650 cb(lev, sock, sa_remote, socklen_remote, data);
651 }
652
653 LOCK(lev);
654 if (listener_decref_and_unlock(lev))
655 return;
656
657 EnterCriticalSection(&as->lock);
658 start_accepting(as);
659 LeaveCriticalSection(&as->lock);
660 }
661
662 static void
accepted_socket_cb(struct event_overlapped * o,ev_uintptr_t key,ev_ssize_t n,int ok)663 accepted_socket_cb(struct event_overlapped *o, ev_uintptr_t key, ev_ssize_t n, int ok)
664 {
665 struct accepting_socket *as =
666 EVUTIL_UPCAST(o, struct accepting_socket, overlapped);
667
668 LOCK(&as->lev->base);
669 EnterCriticalSection(&as->lock);
670 if (ok) {
671 /* XXXX Don't do this if some EV_MT flag is set. */
672 event_deferred_cb_schedule(
673 event_base_get_deferred_cb_queue(as->lev->event_base),
674 &as->deferred);
675 LeaveCriticalSection(&as->lock);
676 } else if (as->free_on_cb) {
677 struct evconnlistener *lev = &as->lev->base;
678 free_and_unlock_accepting_socket(as);
679 listener_decref_and_unlock(lev);
680 return;
681 } else if (as->s == INVALID_SOCKET) {
682 /* This is okay; we were disabled by iocp_listener_disable. */
683 LeaveCriticalSection(&as->lock);
684 } else {
685 /* Some error on accept that we couldn't actually handle. */
686 BOOL ok;
687 DWORD transfer = 0, flags=0;
688 event_sock_warn(as->s, "Unexpected error on AcceptEx");
689 ok = WSAGetOverlappedResult(as->s, &o->overlapped,
690 &transfer, FALSE, &flags);
691 if (ok) {
692 /* well, that was confusing! */
693 as->error = 1;
694 } else {
695 as->error = WSAGetLastError();
696 }
697 event_deferred_cb_schedule(
698 event_base_get_deferred_cb_queue(as->lev->event_base),
699 &as->deferred);
700 LeaveCriticalSection(&as->lock);
701 }
702 UNLOCK(&as->lev->base);
703 }
704
705 static int
iocp_listener_enable(struct evconnlistener * lev)706 iocp_listener_enable(struct evconnlistener *lev)
707 {
708 int i;
709 struct evconnlistener_iocp *lev_iocp =
710 EVUTIL_UPCAST(lev, struct evconnlistener_iocp, base);
711
712 LOCK(lev);
713 iocp_listener_event_add(lev_iocp);
714 for (i = 0; i < lev_iocp->n_accepting; ++i) {
715 struct accepting_socket *as = lev_iocp->accepting[i];
716 if (!as)
717 continue;
718 EnterCriticalSection(&as->lock);
719 if (!as->free_on_cb && as->s == INVALID_SOCKET)
720 start_accepting(as);
721 LeaveCriticalSection(&as->lock);
722 }
723 UNLOCK(lev);
724 return 0;
725 }
726
727 static int
iocp_listener_disable_impl(struct evconnlistener * lev,int shutdown)728 iocp_listener_disable_impl(struct evconnlistener *lev, int shutdown)
729 {
730 int i;
731 struct evconnlistener_iocp *lev_iocp =
732 EVUTIL_UPCAST(lev, struct evconnlistener_iocp, base);
733
734 LOCK(lev);
735 iocp_listener_event_del(lev_iocp);
736 for (i = 0; i < lev_iocp->n_accepting; ++i) {
737 struct accepting_socket *as = lev_iocp->accepting[i];
738 if (!as)
739 continue;
740 EnterCriticalSection(&as->lock);
741 if (!as->free_on_cb && as->s != INVALID_SOCKET) {
742 if (shutdown)
743 as->free_on_cb = 1;
744 stop_accepting(as);
745 }
746 LeaveCriticalSection(&as->lock);
747 }
748
749 if (shutdown && lev->flags & LEV_OPT_CLOSE_ON_FREE)
750 evutil_closesocket(lev_iocp->fd);
751
752 UNLOCK(lev);
753 return 0;
754 }
755
756 static int
iocp_listener_disable(struct evconnlistener * lev)757 iocp_listener_disable(struct evconnlistener *lev)
758 {
759 return iocp_listener_disable_impl(lev,0);
760 }
761
762 static void
iocp_listener_destroy(struct evconnlistener * lev)763 iocp_listener_destroy(struct evconnlistener *lev)
764 {
765 struct evconnlistener_iocp *lev_iocp =
766 EVUTIL_UPCAST(lev, struct evconnlistener_iocp, base);
767
768 if (! lev_iocp->shutting_down) {
769 lev_iocp->shutting_down = 1;
770 iocp_listener_disable_impl(lev,1);
771 }
772
773 }
774
775 static evutil_socket_t
iocp_listener_getfd(struct evconnlistener * lev)776 iocp_listener_getfd(struct evconnlistener *lev)
777 {
778 struct evconnlistener_iocp *lev_iocp =
779 EVUTIL_UPCAST(lev, struct evconnlistener_iocp, base);
780 return lev_iocp->fd;
781 }
782 static struct event_base *
iocp_listener_getbase(struct evconnlistener * lev)783 iocp_listener_getbase(struct evconnlistener *lev)
784 {
785 struct evconnlistener_iocp *lev_iocp =
786 EVUTIL_UPCAST(lev, struct evconnlistener_iocp, base);
787 return lev_iocp->event_base;
788 }
789
790 static const struct evconnlistener_ops evconnlistener_iocp_ops = {
791 iocp_listener_enable,
792 iocp_listener_disable,
793 iocp_listener_destroy,
794 iocp_listener_destroy, /* shutdown */
795 iocp_listener_getfd,
796 iocp_listener_getbase
797 };
798
799 /* XXX define some way to override this. */
800 #define N_SOCKETS_PER_LISTENER 4
801
802 struct evconnlistener *
evconnlistener_new_async(struct event_base * base,evconnlistener_cb cb,void * ptr,unsigned flags,int backlog,evutil_socket_t fd)803 evconnlistener_new_async(struct event_base *base,
804 evconnlistener_cb cb, void *ptr, unsigned flags, int backlog,
805 evutil_socket_t fd)
806 {
807 struct sockaddr_storage ss;
808 int socklen = sizeof(ss);
809 struct evconnlistener_iocp *lev;
810 int i;
811
812 flags |= LEV_OPT_THREADSAFE;
813
814 if (!base || !event_base_get_iocp(base))
815 goto err;
816
817 /* XXXX duplicate code */
818 if (backlog > 0) {
819 if (listen(fd, backlog) < 0)
820 goto err;
821 } else if (backlog < 0) {
822 if (listen(fd, 128) < 0)
823 goto err;
824 }
825 if (getsockname(fd, (struct sockaddr*)&ss, &socklen)) {
826 event_sock_warn(fd, "getsockname");
827 goto err;
828 }
829 lev = mm_calloc(1, sizeof(struct evconnlistener_iocp));
830 if (!lev) {
831 event_warn("calloc");
832 goto err;
833 }
834 lev->base.ops = &evconnlistener_iocp_ops;
835 lev->base.cb = cb;
836 lev->base.user_data = ptr;
837 lev->base.flags = flags;
838 lev->base.refcnt = 1;
839 lev->base.enabled = 1;
840
841 lev->port = event_base_get_iocp(base);
842 lev->fd = fd;
843 lev->event_base = base;
844
845
846 if (event_iocp_port_associate(lev->port, fd, 1) < 0)
847 goto err_free_lev;
848
849 EVTHREAD_ALLOC_LOCK(lev->base.lock, EVTHREAD_LOCKTYPE_RECURSIVE);
850
851 lev->n_accepting = N_SOCKETS_PER_LISTENER;
852 lev->accepting = mm_calloc(lev->n_accepting,
853 sizeof(struct accepting_socket *));
854 if (!lev->accepting) {
855 event_warn("calloc");
856 goto err_delete_lock;
857 }
858 for (i = 0; i < lev->n_accepting; ++i) {
859 lev->accepting[i] = new_accepting_socket(lev, ss.ss_family);
860 if (!lev->accepting[i]) {
861 event_warnx("Couldn't create accepting socket");
862 goto err_free_accepting;
863 }
864 if (cb && start_accepting(lev->accepting[i]) < 0) {
865 event_warnx("Couldn't start accepting on socket");
866 EnterCriticalSection(&lev->accepting[i]->lock);
867 free_and_unlock_accepting_socket(lev->accepting[i]);
868 goto err_free_accepting;
869 }
870 ++lev->base.refcnt;
871 }
872
873 iocp_listener_event_add(lev);
874
875 return &lev->base;
876
877 err_free_accepting:
878 mm_free(lev->accepting);
879 /* XXXX free the other elements. */
880 err_delete_lock:
881 EVTHREAD_FREE_LOCK(lev->base.lock, EVTHREAD_LOCKTYPE_RECURSIVE);
882 err_free_lev:
883 mm_free(lev);
884 err:
885 /* Don't close the fd, it is caller's responsibility. */
886 return NULL;
887 }
888
889 #endif
890