?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ifpps: Remove unused 'forks' member from struct ifstat
[netsniff-ng.git] / ct_server.c
blobeb53bd3ad41dd26181752282cd233808fd691791
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 <sys/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 "ct_usermgmt.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 const 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 curve25519_alloc_or_maybe_die(ws->c);
459
460 buff = xmalloc_aligned(blen, 64);
461
462 syslog(LOG_INFO, "curvetun thread on CPU%u up!\n", ws->cpu);
463
464 pthread_cleanup_push(xfree_func, ws->c);
465 pthread_cleanup_push(curve25519_free, ws->c);
466 pthread_cleanup_push(xfree_func, buff);
467
468 while (likely(!sigint)) {
469 poll(&fds, 1, -1);
470 if ((fds.revents & POLLIN) != POLLIN)
471 continue;
472
473 pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &old_state);
474
475 while ((ret = read_exact(ws->efd[0], &fd, sizeof(fd), 1)) > 0) {
476 if (ret != sizeof(fd)) {
477 sched_yield();
478 continue;
479 }
480
481 ret = ws->handler(fd, ws, buff, blen);
482 if (ret)
483 write_exact(ws->parent.refd, &fd, sizeof(fd), 1);
484 }
485
486 pthread_setcancelstate(old_state, NULL);
487 }
488
489 syslog(LOG_INFO, "curvetun thread on CPU%u down!\n", ws->cpu);
490
491 pthread_cleanup_pop(1);
492 pthread_cleanup_pop(1);
493 pthread_cleanup_pop(1);
494
495 pthread_exit((void *) ((long) ws->cpu));
496 }
497
498 static void thread_spawn_or_panic(unsigned int cpus, int efd, int refd,
499 int tunfd, int ipv4, int udp)
500 {
501 int i, ret;
502 cpu_set_t cpuset;
503 unsigned int threads;
504
505 threads = cpus * THREADS_PER_CPU;
506
507 for (i = 0; i < threads; ++i) {
508 CPU_ZERO(&cpuset);
509 threadpool[i].cpu = i % cpus;
510 CPU_SET(threadpool[i].cpu, &cpuset);
511
512 ret = pipe2(threadpool[i].efd, O_NONBLOCK);
513 if (ret < 0)
514 syslog_panic("Cannot create event socket!\n");
515
516 threadpool[i].c = xmalloc_aligned(sizeof(*threadpool[i].c), 64);
517 threadpool[i].parent.efd = efd;
518 threadpool[i].parent.refd = refd;
519 threadpool[i].parent.tunfd = tunfd;
520 threadpool[i].parent.ipv4 = ipv4;
521 threadpool[i].parent.udp = udp;
522 threadpool[i].handler = udp ? handler_udp : handler_tcp;
523
524 ret = pthread_create(&threadpool[i].trid, NULL,
525 worker, &threadpool[i]);
526 if (ret < 0)
527 syslog_panic("Thread creation failed!\n");
528
529 ret = pthread_setaffinity_np(threadpool[i].trid,
530 sizeof(cpuset), &cpuset);
531 if (ret < 0)
532 syslog_panic("Thread CPU migration failed!\n");
533
534 pthread_detach(threadpool[i].trid);
535 }
536
537 sleep(1);
538 }
539
540 static void thread_finish(unsigned int cpus)
541 {
542 int i;
543 unsigned int threads;
544
545 threads = cpus * THREADS_PER_CPU;
546
547 for (i = 0; i < threads; ++i) {
548 while (pthread_join(threadpool[i].trid, NULL) < 0)
549 ;
550
551 close(threadpool[i].efd[0]);
552 close(threadpool[i].efd[1]);
553 }
554 }
555
556 int server_main(char *home, char *dev, char *port, int udp, int ipv4, int log)
557 {
558 int lfd = -1, kdpfd, nfds, nfd, curfds, efd[2], refd[2], tunfd, i;
559 unsigned int cpus = 0, threads, udp_cpu = 0;
560 ssize_t ret;
561 struct epoll_event *events;
562 struct addrinfo hints, *ahead, *ai;
563
564 auth_log = !!log;
565 openlog("curvetun", LOG_PID | LOG_CONS | LOG_NDELAY, LOG_DAEMON);
566
567 syslog(LOG_INFO, "curvetun server booting!\n");
568 syslog_maybe(!auth_log, LOG_INFO, "curvetun user logging disabled!\n");
569
570 parse_userfile_and_generate_user_store_or_die(home);
571
572 memset(&hints, 0, sizeof(hints));
573 hints.ai_family = PF_UNSPEC;
574 hints.ai_socktype = udp ? SOCK_DGRAM : SOCK_STREAM;
575 hints.ai_protocol = udp ? IPPROTO_UDP : IPPROTO_TCP;
576 hints.ai_flags = AI_PASSIVE;
577
578 ret = getaddrinfo(NULL, port, &hints, &ahead);
579 if (ret < 0)
580 syslog_panic("Cannot get address info!\n");
581
582 for (ai = ahead; ai != NULL && lfd < 0; ai = ai->ai_next) {
583 lfd = socket(ai->ai_family, ai->ai_socktype, ai->ai_protocol);
584 if (lfd < 0)
585 continue;
586 if (ai->ai_family == AF_INET6) {
587 #ifdef IPV6_V6ONLY
588 ret = set_ipv6_only(lfd);
589 if (ret < 0) {
590 close(lfd);
591 lfd = -1;
592 continue;
593 }
594 #else
595 close(lfd);
596 lfd = -1;
597 continue;
598 #endif /* IPV6_V6ONLY */
599 }
600
601 set_reuseaddr(lfd);
602 set_mtu_disc_dont(lfd);
603
604 ret = bind(lfd, ai->ai_addr, ai->ai_addrlen);
605 if (ret < 0) {
606 close(lfd);
607 lfd = -1;
608 continue;
609 }
610
611 if (!udp) {
612 ret = listen(lfd, 5);
613 if (ret < 0) {
614 close(lfd);
615 lfd = -1;
616 continue;
617 }
618 }
619
620 if (ipv4 == -1) {
621 ipv4 = (ai->ai_family == AF_INET6 ? 0 :
622 (ai->ai_family == AF_INET ? 1 : -1));
623 }
624
625 syslog_maybe(auth_log, LOG_INFO, "curvetun on IPv%d via %s "
626 "on port %s!\n", ai->ai_family == AF_INET ? 4 : 6,
627 udp ? "UDP" : "TCP", port);
628 syslog_maybe(auth_log, LOG_INFO, "Allowed overlay proto is "
629 "IPv%d!\n", ipv4 ? 4 : 6);
630 }
631
632 freeaddrinfo(ahead);
633
634 if (lfd < 0 || ipv4 < 0)
635 syslog_panic("Cannot create socket!\n");
636
637 tunfd = tun_open_or_die(dev ? dev : DEVNAME_SERVER, IFF_TUN | IFF_NO_PI);
638
639 pipe_or_die(efd, O_NONBLOCK);
640 pipe_or_die(refd, O_NONBLOCK);
641
642 set_nonblocking(lfd);
643
644 events = xzmalloc(MAX_EPOLL_SIZE * sizeof(*events));
645 for (i = 0; i < MAX_EPOLL_SIZE; ++i)
646 events[i].data.fd = -1;
647
648 kdpfd = epoll_create(MAX_EPOLL_SIZE);
649 if (kdpfd < 0)
650 syslog_panic("Cannot create socket!\n");
651
652 set_epoll_descriptor(kdpfd, EPOLL_CTL_ADD, lfd,
653 udp ? EPOLLIN | EPOLLET | EPOLLONESHOT : EPOLLIN);
654 set_epoll_descriptor(kdpfd, EPOLL_CTL_ADD, efd[0], EPOLLIN);
655 set_epoll_descriptor(kdpfd, EPOLL_CTL_ADD, refd[0], EPOLLIN);
656 set_epoll_descriptor(kdpfd, EPOLL_CTL_ADD, tunfd,
657 EPOLLIN | EPOLLET | EPOLLONESHOT);
658 curfds = 4;
659
660 trie_init();
661
662 cpus = get_number_cpus_online();
663 threads = cpus * THREADS_PER_CPU;
664 if (!ispow2(threads))
665 syslog_panic("Thread number not power of two!\n");
666
667 threadpool = xzmalloc(sizeof(*threadpool) * threads);
668 thread_spawn_or_panic(cpus, efd[1], refd[1], tunfd, ipv4, udp);
669
670 init_cpusched(threads);
671
672 register_socket(tunfd);
673 register_socket(lfd);
674
675 syslog(LOG_INFO, "curvetun up and running!\n");
676
677 while (likely(!sigint)) {
678 nfds = epoll_wait(kdpfd, events, curfds, -1);
679 if (nfds < 0) {
680 syslog(LOG_ERR, "epoll_wait error: %s\n",
681 strerror(errno));
682 break;
683 }
684
685 for (i = 0; i < nfds; ++i) {
686 if (unlikely(events[i].data.fd < 0))
687 continue;
688
689 if (events[i].data.fd == lfd && !udp) {
690 int ncpu;
691 char hbuff[256], sbuff[256];
692 struct sockaddr_storage taddr;
693 socklen_t tlen;
694
695 tlen = sizeof(taddr);
696 nfd = accept(lfd, (struct sockaddr *) &taddr,
697 &tlen);
698 if (nfd < 0) {
699 syslog(LOG_ERR, "accept error: %s\n",
700 strerror(errno));
701 continue;
702 }
703
704 if (curfds + 1 > MAX_EPOLL_SIZE) {
705 close(nfd);
706 continue;
707 }
708
709 curfds++;
710
711 ncpu = register_socket(nfd);
712
713 memset(hbuff, 0, sizeof(hbuff));
714 memset(sbuff, 0, sizeof(sbuff));
715 getnameinfo((struct sockaddr *) &taddr, tlen,
716 hbuff, sizeof(hbuff),
717 sbuff, sizeof(sbuff),
718 NI_NUMERICHOST | NI_NUMERICSERV);
719
720 syslog_maybe(auth_log, LOG_INFO, "New connection "
721 "from %s:%s (%d active client connections) - id %d on CPU%d",
722 hbuff, sbuff, curfds-4, nfd, ncpu);
723
724 set_nonblocking(nfd);
725 set_socket_keepalive(nfd);
726 set_tcp_nodelay(nfd);
727 ret = set_epoll_descriptor2(kdpfd, EPOLL_CTL_ADD,
728 nfd, EPOLLIN | EPOLLET | EPOLLONESHOT);
729 if (ret < 0) {
730 close(nfd);
731 curfds--;
732 continue;
733 }
734 } else if (events[i].data.fd == refd[0]) {
735 int fd_one;
736
737 ret = read_exact(refd[0], &fd_one,
738 sizeof(fd_one), 1);
739 if (ret != sizeof(fd_one) || fd_one <= 0)
740 continue;
741
742 ret = set_epoll_descriptor2(kdpfd, EPOLL_CTL_MOD,
743 fd_one, EPOLLIN | EPOLLET | EPOLLONESHOT);
744 if (ret < 0) {
745 close(fd_one);
746 continue;
747 }
748 } else if (events[i].data.fd == efd[0]) {
749 int fd_del, test;
750
751 ret = read_exact(efd[0], &fd_del,
752 sizeof(fd_del), 1);
753 if (ret != sizeof(fd_del) || fd_del <= 0)
754 continue;
755
756 ret = read(fd_del, &test, sizeof(test));
757 if (ret < 0 && errno == EBADF)
758 continue;
759
760 ret = set_epoll_descriptor2(kdpfd, EPOLL_CTL_DEL,
761 fd_del, 0);
762 if (ret < 0) {
763 close(fd_del);
764 continue;
765 }
766
767 close(fd_del);
768 curfds--;
769 unregister_socket(fd_del);
770
771 syslog_maybe(auth_log, LOG_INFO, "Closed connection "
772 "with id %d (%d active client connections remain)\n", fd_del,
773 curfds-4);
774 } else {
775 int cpu, fd_work = events[i].data.fd;
776
777 if (!udp)
778 cpu = socket_to_cpu(fd_work);
779 else
780 udp_cpu = (udp_cpu + 1) & (threads - 1);
781
782 write_exact(threadpool[udp ? udp_cpu : cpu].efd[1],
783 &fd_work, sizeof(fd_work), 1);
784 }
785 }
786 }
787
788 syslog(LOG_INFO, "curvetun prepare shut down!\n");
789
790 close(lfd);
791 close(efd[0]);
792 close(efd[1]);
793 close(refd[0]);
794 close(refd[1]);
795 close(tunfd);
796
797 thread_finish(cpus);
798
799 xfree(threadpool);
800 xfree(events);
801
802 unregister_socket(lfd);
803 unregister_socket(tunfd);
804
805 destroy_cpusched();
806
807 trie_cleanup();
808
809 destroy_user_store();
810
811 syslog(LOG_INFO, "curvetun shut down!\n");
812 closelog();
813
814 return 0;
815 }
netsniff-ng toolkit, the packet sniffing beast, staging tree