?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
pkt_buff: Change type of link_type field
[netsniff-ng.git] / curvetun_server.c
blobc1d547722e0ea57b3d892c31de3685ee393b6219
1 /*
2 * curvetun - the cipherspace wormhole creator
3 * Part of the netsniff-ng project
4 * Copyright 2011 Daniel Borkmann <daniel@netsniff-ng.org>,
5 * Subject to the GPL, version 2.
6 */
7
8 #define _GNU_SOURCE
9 #include <stdio.h>
10 #include <stdlib.h>
11 #include <fcntl.h>
12 #include <errno.h>
13 #include <string.h>
14 #include <unistd.h>
15 #include <pthread.h>
16 #include <syslog.h>
17 #include <signal.h>
18 #include <netdb.h>
19 #include <stdint.h>
20 #include <netinet/in.h>
21 #include <netinet/tcp.h>
22 #include <netinet/udp.h>
23 #include <poll.h>
24 #include <sys/types.h>
25 #include <sys/socket.h>
26 #include <sys/wait.h>
27 #include <sys/epoll.h>
28 #include <arpa/inet.h>
29 #include <linux/if_tun.h>
30
31 #include "die.h"
32 #include "epoll2.h"
33 #include "ioops.h"
34 #include "xmalloc.h"
35 #include "curvetun.h"
36 #include "curve.h"
37 #include "ioexact.h"
38 #include "corking.h"
39 #include "cpus.h"
40 #include "sock.h"
41 #include "built_in.h"
42 #include "curvetun_mgmt.h"
43 #include "cpusched.h"
44 #include "trie.h"
45
46 struct parent_info {
47 int efd;
48 int refd;
49 int tunfd;
50 int ipv4;
51 int udp;
52 };
53
54 struct worker_struct {
55 pthread_t trid;
56 int efd[2];
57 unsigned int cpu;
58 struct parent_info parent;
59 int (*handler)(int fd, const struct worker_struct *ws,
60 char *buff, size_t len);
61 struct curve25519_struct *c;
62 };
63
64 static struct worker_struct *threadpool = NULL;
65
66 static int auth_log = 1;
67
68 extern volatile sig_atomic_t sigint;
69
70 static int handler_udp_tun_to_net(int fd, const struct worker_struct *ws,
71 char *buff, size_t len) __pure;
72 static int handler_udp_net_to_tun(int fd, const struct worker_struct *ws,
73 char *buff, size_t len) __pure;
74 static int handler_udp(int fd, const struct worker_struct *ws,
75 char *buff, size_t len) __pure;
76 static int handler_tcp_tun_to_net(int fd, const struct worker_struct *ws,
77 char *buff, size_t len) __pure;
78 static int handler_tcp_net_to_tun(int fd, const struct worker_struct *ws,
79 char *buff, size_t len) __pure;
80 static int handler_tcp(int fd, const struct worker_struct *ws,
81 char *buff, size_t len) __pure;
82 ssize_t handler_tcp_read(int fd, char *buff, size_t len);
83 static void *worker(void *self) __pure;
84
85 static int handler_udp_tun_to_net(int fd, const struct worker_struct *ws,
86 char *buff, size_t len)
87 {
88 int dfd, keep = 1;
89 char *cbuff;
90 ssize_t rlen, err, clen;
91 struct ct_proto *hdr;
92 struct curve25519_proto *p;
93 struct sockaddr_storage naddr;
94 socklen_t nlen;
95 size_t off = sizeof(struct ct_proto) + crypto_box_zerobytes;
96
97 if (!buff || len <= off)
98 return 0;
99
100 memset(buff, 0, len);
101 while ((rlen = read(fd, buff + off, len - off)) > 0) {
102 dfd = -1; nlen = 0; p = NULL;
103
104 memset(&naddr, 0, sizeof(naddr));
105
106 hdr = (struct ct_proto *) buff;
107 memset(hdr, 0, sizeof(*hdr));
108 hdr->flags = 0;
109
110 trie_addr_lookup(buff + off, rlen, ws->parent.ipv4, &dfd, &naddr,
111 (size_t *) &nlen);
112 if (unlikely(dfd < 0 || nlen == 0)) {
113 memset(buff, 0, len);
114 continue;
115 }
116
117 err = get_user_by_sockaddr(&naddr, nlen, &p);
118 if (unlikely(err || !p)) {
119 memset(buff, 0, len);
120 continue;
121 }
122
123 clen = curve25519_encode(ws->c, p, (unsigned char *) (buff + off -
124 crypto_box_zerobytes), (rlen +
125 crypto_box_zerobytes), (unsigned char **)
126 &cbuff);
127 if (unlikely(clen <= 0)) {
128 memset(buff, 0, len);
129 continue;
130 }
131
132 hdr->payload = htons((uint16_t) clen);
133
134 set_udp_cork(dfd);
135
136 sendto(dfd, hdr, sizeof(struct ct_proto), 0, (struct sockaddr *)
137 &naddr, nlen);
138 sendto(dfd, cbuff, clen, 0, (struct sockaddr *) &naddr, nlen);
139
140 set_udp_uncork(dfd);
141
142 memset(buff, 0, len);
143 }
144
145 return keep;
146 }
147
148 static void handler_udp_notify_close(int fd, struct sockaddr_storage *addr)
149 {
150 struct ct_proto hdr;
151
152 memset(&hdr, 0, sizeof(hdr));
153 hdr.flags |= PROTO_FLAG_EXIT;
154 hdr.payload = 0;
155
156 sendto(fd, &hdr, sizeof(hdr), 0, (struct sockaddr *) addr,
157 sizeof(*addr));
158 }
159
160 static int handler_udp_net_to_tun(int fd, const struct worker_struct *ws,
161 char *buff, size_t len)
162 {
163 int keep = 1;
164 char *cbuff;
165 ssize_t rlen, err, clen;
166 struct ct_proto *hdr;
167 struct curve25519_proto *p;
168 struct sockaddr_storage naddr;
169 socklen_t nlen = sizeof(naddr);
170
171 if (!buff || !len)
172 return 0;
173
174 memset(&naddr, 0, sizeof(naddr));
175 while ((rlen = recvfrom(fd, buff, len, 0, (struct sockaddr *) &naddr,
176 &nlen)) > 0) {
177 p = NULL;
178
179 hdr = (struct ct_proto *) buff;
180
181 if (unlikely(rlen < sizeof(struct ct_proto)))
182 goto close;
183 if (unlikely(rlen - sizeof(*hdr) != ntohs(hdr->payload)))
184 goto close;
185 if (unlikely(ntohs(hdr->payload) == 0))
186 goto close;
187 if (hdr->flags & PROTO_FLAG_EXIT) {
188 close:
189 remove_user_by_sockaddr(&naddr, nlen);
190 trie_addr_remove_addr(&naddr, nlen);
191 handler_udp_notify_close(fd, &naddr);
192
193 return keep;
194 }
195 if (hdr->flags & PROTO_FLAG_INIT) {
196 syslog_maybe(auth_log, LOG_INFO, "Got initial userhash "
197 "from remote end!\n");
198
199 if (unlikely(rlen - sizeof(*hdr) <
200 sizeof(struct username_struct)))
201 goto close;
202
203 err = try_register_user_by_sockaddr(ws->c,
204 buff + sizeof(struct ct_proto),
205 rlen - sizeof(struct ct_proto),
206 &naddr, nlen, auth_log);
207 if (unlikely(err))
208 goto close;
209
210 goto next;
211 }
212
213 err = get_user_by_sockaddr(&naddr, nlen, &p);
214 if (unlikely(err || !p))
215 goto close;
216
217 clen = curve25519_decode(ws->c, p, (unsigned char *) buff +
218 sizeof(struct ct_proto),
219 rlen - sizeof(struct ct_proto),
220 (unsigned char **) &cbuff, NULL);
221 if (unlikely(clen <= 0))
222 goto close;
223
224 cbuff += crypto_box_zerobytes;
225 clen -= crypto_box_zerobytes;
226
227 err = trie_addr_maybe_update(cbuff, clen, ws->parent.ipv4,
228 fd, &naddr, nlen);
229 if (unlikely(err))
230 goto next;
231
232 err = write(ws->parent.tunfd, cbuff, clen);
233 next:
234 nlen = sizeof(naddr);
235 memset(&naddr, 0, sizeof(naddr));
236 }
237
238 return keep;
239 }
240
241 static int handler_udp(int fd, const struct worker_struct *ws,
242 char *buff, size_t len)
243 {
244 int ret = 0;
245
246 if (fd == ws->parent.tunfd)
247 ret = handler_udp_tun_to_net(fd, ws, buff, len);
248 else
249 ret = handler_udp_net_to_tun(fd, ws, buff, len);
250
251 return ret;
252 }
253
254 static int handler_tcp_tun_to_net(int fd, const struct worker_struct *ws,
255 char *buff, size_t len)
256 {
257 int dfd, keep = 1;
258 char *cbuff;
259 ssize_t rlen, err, clen;
260 struct ct_proto *hdr;
261 struct curve25519_proto *p;
262 socklen_t nlen;
263 size_t off = sizeof(struct ct_proto) + crypto_box_zerobytes;
264
265 if (!buff || len <= off)
266 return 0;
267
268 memset(buff, 0, len);
269 while ((rlen = read(fd, buff + off, len - off)) > 0) {
270 dfd = -1; p = NULL;
271
272 hdr = (struct ct_proto *) buff;
273 memset(hdr, 0, sizeof(*hdr));
274 hdr->flags = 0;
275
276 trie_addr_lookup(buff + off, rlen, ws->parent.ipv4, &dfd, NULL,
277 (size_t *) &nlen);
278 if (unlikely(dfd < 0)) {
279 memset(buff, 0, len);
280 continue;
281 }
282
283 err = get_user_by_socket(dfd, &p);
284 if (unlikely(err || !p)) {
285 memset(buff, 0, len);
286 continue;
287 }
288
289 clen = curve25519_encode(ws->c, p, (unsigned char *) (buff + off -
290 crypto_box_zerobytes), (rlen +
291 crypto_box_zerobytes), (unsigned char **)
292 &cbuff);
293 if (unlikely(clen <= 0)) {
294 memset(buff, 0, len);
295 continue;
296 }
297
298 hdr->payload = htons((uint16_t) clen);
299
300 set_tcp_cork(dfd);
301
302 write_exact(dfd, hdr, sizeof(struct ct_proto), 0);
303 write_exact(dfd, cbuff, clen, 0);
304
305 set_tcp_uncork(dfd);
306
307 memset(buff, 0, len);
308 }
309
310 return keep;
311 }
312
313 ssize_t handler_tcp_read(int fd, char *buff, size_t len)
314 {
315 ssize_t rlen;
316 struct ct_proto *hdr = (struct ct_proto *) buff;
317
318 if (!buff || !len)
319 return 0;
320
321 /* May exit on EAGAIN if 0 Byte read */
322 rlen = read_exact(fd, buff, sizeof(struct ct_proto), 1);
323 if (rlen < 0)
324 return rlen;
325 if (unlikely(ntohs(hdr->payload) > len - sizeof(struct ct_proto))) {
326 errno = ENOMEM;
327 return 1; /* Force server to close connection */
328 }
329
330 /* May not exit on EAGAIN if 0 Byte read */
331 rlen = read_exact(fd, buff + sizeof(struct ct_proto),
332 ntohs(hdr->payload), 0);
333 if (rlen < 0)
334 return rlen;
335
336 return sizeof(struct ct_proto) + rlen;
337 }
338
339 static void handler_tcp_notify_close(int fd)
340 {
341 struct ct_proto hdr;
342
343 memset(&hdr, 0, sizeof(hdr));
344 hdr.flags |= PROTO_FLAG_EXIT;
345 hdr.payload = 0;
346
347 if (write(fd, &hdr, sizeof(hdr))) { ; }
348 }
349
350 static int handler_tcp_net_to_tun(int fd, const struct worker_struct *ws,
351 char *buff, size_t len)
352 {
353 int keep = 1, count = 0;
354 char *cbuff;
355 ssize_t rlen, err, clen;
356 struct ct_proto *hdr;
357 struct curve25519_proto *p;
358
359 if (!buff || !len)
360 return 0;
361
362 while ((rlen = handler_tcp_read(fd, buff, len)) > 0) {
363 p = NULL;
364
365 hdr = (struct ct_proto *) buff;
366
367 if (unlikely(rlen < sizeof(struct ct_proto)))
368 goto close;
369 if (unlikely(rlen - sizeof(*hdr) != ntohs(hdr->payload)))
370 goto close;
371 if (unlikely(ntohs(hdr->payload) == 0))
372 goto close;
373 if (hdr->flags & PROTO_FLAG_EXIT) {
374 close:
375 remove_user_by_socket(fd);
376 trie_addr_remove(fd);
377 handler_tcp_notify_close(fd);
378 rlen = write(ws->parent.efd, &fd, sizeof(fd));
379
380 keep = 0;
381 return keep;
382 }
383 if (hdr->flags & PROTO_FLAG_INIT) {
384 syslog_maybe(auth_log, LOG_INFO, "Got initial userhash "
385 "from remote end!\n");
386
387 if (unlikely(rlen - sizeof(*hdr) <
388 sizeof(struct username_struct)))
389 goto close;
390
391 err = try_register_user_by_socket(ws->c,
392 buff + sizeof(struct ct_proto),
393 rlen - sizeof(struct ct_proto),
394 fd, auth_log);
395 if (unlikely(err))
396 goto close;
397
398 continue;
399 }
400
401 err = get_user_by_socket(fd, &p);
402 if (unlikely(err || !p))
403 continue;
404
405 clen = curve25519_decode(ws->c, p, (unsigned char *) buff +
406 sizeof(struct ct_proto),
407 rlen - sizeof(struct ct_proto),
408 (unsigned char **) &cbuff, NULL);
409 if (unlikely(clen <= 0))
410 continue;
411
412 cbuff += crypto_box_zerobytes;
413 clen -= crypto_box_zerobytes;
414
415 err = trie_addr_maybe_update(cbuff, clen, ws->parent.ipv4,
416 fd, NULL, 0);
417 if (unlikely(err))
418 continue;
419
420 err = write(ws->parent.tunfd, cbuff, clen);
421
422 count++;
423 if (count == 10) {
424 write_exact(ws->efd[1], &fd, sizeof(fd), 1);
425 /* Read later next data and let others process */
426 return keep;
427 }
428 }
429
430 return keep;
431 }
432
433 static int handler_tcp(int fd, const struct worker_struct *ws,
434 char *buff, size_t len)
435 {
436 int ret = 0;
437
438 if (fd == ws->parent.tunfd)
439 ret = handler_tcp_tun_to_net(fd, ws, buff, len);
440 else
441 ret = handler_tcp_net_to_tun(fd, ws, buff, len);
442
443 return ret;
444 }
445
446 static void *worker(void *self)
447 {
448 int fd, old_state;
449 ssize_t ret;
450 size_t blen = TUNBUFF_SIZ; //FIXME
451 struct worker_struct *ws = self;
452 struct pollfd fds;
453 char *buff;
454
455 fds.fd = ws->efd[0];
456 fds.events = POLLIN;
457
458 ws->c = curve25519_tfm_alloc();
459 buff = xmalloc_aligned(blen, 64);
460
461 syslog(LOG_INFO, "curvetun thread on CPU%u up!\n", ws->cpu);
462
463 pthread_cleanup_push(curve25519_tfm_free_void, ws->c);
464 pthread_cleanup_push(xfree_func, buff);
465
466 while (likely(!sigint)) {
467 poll(&fds, 1, -1);
468 if ((fds.revents & POLLIN) != POLLIN)
469 continue;
470
471 pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &old_state);
472
473 while ((ret = read_exact(ws->efd[0], &fd, sizeof(fd), 1)) > 0) {
474 if (ret != sizeof(fd)) {
475 sched_yield();
476 continue;
477 }
478
479 ret = ws->handler(fd, ws, buff, blen);
480 if (ret)
481 write_exact(ws->parent.refd, &fd, sizeof(fd), 1);
482 }
483
484 pthread_setcancelstate(old_state, NULL);
485 }
486
487 syslog(LOG_INFO, "curvetun thread on CPU%u down!\n", ws->cpu);
488
489 pthread_cleanup_pop(1);
490 pthread_cleanup_pop(1);
491
492 pthread_exit((void *) ((long) ws->cpu));
493 }
494
495 static void thread_spawn_or_panic(unsigned int cpus, int efd, int refd,
496 int tunfd, int ipv4, int udp)
497 {
498 int i, ret;
499 cpu_set_t cpuset;
500 unsigned int threads;
501
502 threads = cpus * THREADS_PER_CPU;
503
504 for (i = 0; i < threads; ++i) {
505 CPU_ZERO(&cpuset);
506 threadpool[i].cpu = i % cpus;
507 CPU_SET(threadpool[i].cpu, &cpuset);
508
509 ret = pipe2(threadpool[i].efd, O_NONBLOCK);
510 if (ret < 0)
511 syslog_panic("Cannot create event socket!\n");
512
513 threadpool[i].c = xmalloc_aligned(sizeof(*threadpool[i].c), 64);
514 threadpool[i].parent.efd = efd;
515 threadpool[i].parent.refd = refd;
516 threadpool[i].parent.tunfd = tunfd;
517 threadpool[i].parent.ipv4 = ipv4;
518 threadpool[i].parent.udp = udp;
519 threadpool[i].handler = udp ? handler_udp : handler_tcp;
520
521 ret = pthread_create(&threadpool[i].trid, NULL,
522 worker, &threadpool[i]);
523 if (ret < 0)
524 syslog_panic("Thread creation failed!\n");
525
526 ret = pthread_setaffinity_np(threadpool[i].trid,
527 sizeof(cpuset), &cpuset);
528 if (ret < 0)
529 syslog_panic("Thread CPU migration failed!\n");
530
531 pthread_detach(threadpool[i].trid);
532 }
533
534 sleep(1);
535 }
536
537 static void thread_finish(unsigned int cpus)
538 {
539 int i;
540 unsigned int threads;
541
542 threads = cpus * THREADS_PER_CPU;
543
544 for (i = 0; i < threads; ++i) {
545 while (pthread_join(threadpool[i].trid, NULL) < 0)
546 ;
547
548 close(threadpool[i].efd[0]);
549 close(threadpool[i].efd[1]);
550 }
551 }
552
553 int server_main(char *home, char *dev, char *port, int udp, int ipv4, int log)
554 {
555 int lfd = -1, kdpfd, nfds, nfd, curfds, efd[2], refd[2], tunfd, i;
556 unsigned int cpus = 0, threads, udp_cpu = 0;
557 ssize_t ret;
558 struct epoll_event *events;
559 struct addrinfo hints, *ahead, *ai;
560
561 auth_log = !!log;
562 openlog("curvetun", LOG_PID | LOG_CONS | LOG_NDELAY, LOG_DAEMON);
563
564 syslog(LOG_INFO, "curvetun server booting!\n");
565 syslog_maybe(!auth_log, LOG_INFO, "curvetun user logging disabled!\n");
566
567 parse_userfile_and_generate_user_store_or_die(home);
568
569 memset(&hints, 0, sizeof(hints));
570 hints.ai_family = PF_UNSPEC;
571 hints.ai_socktype = udp ? SOCK_DGRAM : SOCK_STREAM;
572 hints.ai_protocol = udp ? IPPROTO_UDP : IPPROTO_TCP;
573 hints.ai_flags = AI_PASSIVE;
574
575 ret = getaddrinfo(NULL, port, &hints, &ahead);
576 if (ret < 0)
577 syslog_panic("Cannot get address info!\n");
578
579 for (ai = ahead; ai != NULL && lfd < 0; ai = ai->ai_next) {
580 lfd = socket(ai->ai_family, ai->ai_socktype, ai->ai_protocol);
581 if (lfd < 0)
582 continue;
583 if (ai->ai_family == AF_INET6) {
584 #ifdef IPV6_V6ONLY
585 ret = set_ipv6_only(lfd);
586 if (ret < 0) {
587 close(lfd);
588 lfd = -1;
589 continue;
590 }
591 #else
592 close(lfd);
593 lfd = -1;
594 continue;
595 #endif /* IPV6_V6ONLY */
596 }
597
598 set_reuseaddr(lfd);
599 set_mtu_disc_dont(lfd);
600
601 ret = bind(lfd, ai->ai_addr, ai->ai_addrlen);
602 if (ret < 0) {
603 close(lfd);
604 lfd = -1;
605 continue;
606 }
607
608 if (!udp) {
609 ret = listen(lfd, 5);
610 if (ret < 0) {
611 close(lfd);
612 lfd = -1;
613 continue;
614 }
615 }
616
617 if (ipv4 == -1) {
618 ipv4 = (ai->ai_family == AF_INET6 ? 0 :
619 (ai->ai_family == AF_INET ? 1 : -1));
620 }
621
622 syslog_maybe(auth_log, LOG_INFO, "curvetun on IPv%d via %s "
623 "on port %s!\n", ai->ai_family == AF_INET ? 4 : 6,
624 udp ? "UDP" : "TCP", port);
625 syslog_maybe(auth_log, LOG_INFO, "Allowed overlay proto is "
626 "IPv%d!\n", ipv4 ? 4 : 6);
627 }
628
629 freeaddrinfo(ahead);
630
631 if (lfd < 0 || ipv4 < 0)
632 syslog_panic("Cannot create socket!\n");
633
634 tunfd = tun_open_or_die(dev ? dev : DEVNAME_SERVER, IFF_TUN | IFF_NO_PI);
635
636 pipe_or_die(efd, O_NONBLOCK);
637 pipe_or_die(refd, O_NONBLOCK);
638
639 set_nonblocking(lfd);
640
641 events = xcalloc(MAX_EPOLL_SIZE, sizeof(*events));
642 for (i = 0; i < MAX_EPOLL_SIZE; ++i)
643 events[i].data.fd = -1;
644
645 kdpfd = epoll_create(MAX_EPOLL_SIZE);
646 if (kdpfd < 0)
647 syslog_panic("Cannot create socket!\n");
648
649 set_epoll_descriptor(kdpfd, EPOLL_CTL_ADD, lfd,
650 udp ? EPOLLIN | EPOLLET | EPOLLONESHOT : EPOLLIN);
651 set_epoll_descriptor(kdpfd, EPOLL_CTL_ADD, efd[0], EPOLLIN);
652 set_epoll_descriptor(kdpfd, EPOLL_CTL_ADD, refd[0], EPOLLIN);
653 set_epoll_descriptor(kdpfd, EPOLL_CTL_ADD, tunfd,
654 EPOLLIN | EPOLLET | EPOLLONESHOT);
655 curfds = 4;
656
657 trie_init();
658
659 cpus = get_number_cpus_online();
660 threads = cpus * THREADS_PER_CPU;
661 if (!ispow2(threads))
662 syslog_panic("Thread number not power of two!\n");
663
664 threadpool = xcalloc(threads, sizeof(*threadpool));
665 thread_spawn_or_panic(cpus, efd[1], refd[1], tunfd, ipv4, udp);
666
667 init_cpusched(threads);
668
669 register_socket(tunfd);
670 register_socket(lfd);
671
672 syslog(LOG_INFO, "curvetun up and running!\n");
673
674 while (likely(!sigint)) {
675 nfds = epoll_wait(kdpfd, events, curfds, -1);
676 if (nfds < 0) {
677 syslog(LOG_ERR, "epoll_wait error: %s\n",
678 strerror(errno));
679 break;
680 }
681
682 for (i = 0; i < nfds; ++i) {
683 if (unlikely(events[i].data.fd < 0))
684 continue;
685
686 if (events[i].data.fd == lfd && !udp) {
687 int ncpu;
688 char hbuff[256], sbuff[256];
689 struct sockaddr_storage taddr;
690 socklen_t tlen;
691
692 tlen = sizeof(taddr);
693 nfd = accept(lfd, (struct sockaddr *) &taddr,
694 &tlen);
695 if (nfd < 0) {
696 syslog(LOG_ERR, "accept error: %s\n",
697 strerror(errno));
698 continue;
699 }
700
701 if (curfds + 1 > MAX_EPOLL_SIZE) {
702 close(nfd);
703 continue;
704 }
705
706 curfds++;
707
708 ncpu = register_socket(nfd);
709
710 memset(hbuff, 0, sizeof(hbuff));
711 memset(sbuff, 0, sizeof(sbuff));
712 getnameinfo((struct sockaddr *) &taddr, tlen,
713 hbuff, sizeof(hbuff),
714 sbuff, sizeof(sbuff),
715 NI_NUMERICHOST | NI_NUMERICSERV);
716
717 syslog_maybe(auth_log, LOG_INFO, "New connection "
718 "from %s:%s (%d active client connections) - id %d on CPU%d",
719 hbuff, sbuff, curfds-4, nfd, ncpu);
720
721 set_nonblocking(nfd);
722 set_socket_keepalive(nfd);
723 set_tcp_nodelay(nfd);
724 ret = set_epoll_descriptor2(kdpfd, EPOLL_CTL_ADD,
725 nfd, EPOLLIN | EPOLLET | EPOLLONESHOT);
726 if (ret < 0) {
727 close(nfd);
728 curfds--;
729 continue;
730 }
731 } else if (events[i].data.fd == refd[0]) {
732 int fd_one;
733
734 ret = read_exact(refd[0], &fd_one,
735 sizeof(fd_one), 1);
736 if (ret != sizeof(fd_one) || fd_one <= 0)
737 continue;
738
739 ret = set_epoll_descriptor2(kdpfd, EPOLL_CTL_MOD,
740 fd_one, EPOLLIN | EPOLLET | EPOLLONESHOT);
741 if (ret < 0) {
742 close(fd_one);
743 continue;
744 }
745 } else if (events[i].data.fd == efd[0]) {
746 int fd_del, test;
747
748 ret = read_exact(efd[0], &fd_del,
749 sizeof(fd_del), 1);
750 if (ret != sizeof(fd_del) || fd_del <= 0)
751 continue;
752
753 ret = read(fd_del, &test, sizeof(test));
754 if (ret < 0 && errno == EBADF)
755 continue;
756
757 ret = set_epoll_descriptor2(kdpfd, EPOLL_CTL_DEL,
758 fd_del, 0);
759 if (ret < 0) {
760 close(fd_del);
761 continue;
762 }
763
764 close(fd_del);
765 curfds--;
766 unregister_socket(fd_del);
767
768 syslog_maybe(auth_log, LOG_INFO, "Closed connection "
769 "with id %d (%d active client connections remain)\n", fd_del,
770 curfds-4);
771 } else {
772 int cpu, fd_work = events[i].data.fd;
773
774 if (!udp)
775 cpu = socket_to_cpu(fd_work);
776 else
777 udp_cpu = (udp_cpu + 1) & (threads - 1);
778
779 write_exact(threadpool[udp ? udp_cpu : cpu].efd[1],
780 &fd_work, sizeof(fd_work), 1);
781 }
782 }
783 }
784
785 syslog(LOG_INFO, "curvetun prepare shut down!\n");
786
787 close(lfd);
788 close(efd[0]);
789 close(efd[1]);
790 close(refd[0]);
791 close(refd[1]);
792 close(tunfd);
793
794 thread_finish(cpus);
795
796 xfree(threadpool);
797 xfree(events);
798
799 unregister_socket(lfd);
800 unregister_socket(tunfd);
801
802 destroy_cpusched();
803
804 trie_cleanup();
805
806 destroy_user_store();
807
808 syslog(LOG_INFO, "curvetun shut down!\n");
809 closelog();
810
811 return 0;
812 }
netsniff-ng toolkit, the packet sniffing beast, staging tree