1: /*
2: * BIRD Internet Routing Daemon -- Unix I/O
3: *
4: * (c) 1998--2004 Martin Mares <mj@ucw.cz>
5: * (c) 2004 Ondrej Filip <feela@network.cz>
6: *
7: * Can be freely distributed and used under the terms of the GNU GPL.
8: */
9:
10: /* Unfortunately, some glibc versions hide parts of RFC 3542 API
11: if _GNU_SOURCE is not defined. */
12: #ifndef _GNU_SOURCE
13: #define _GNU_SOURCE
14: #endif
15:
16: #include <stdio.h>
17: #include <stdlib.h>
18: #include <time.h>
19: #include <sys/time.h>
20: #include <sys/types.h>
21: #include <sys/socket.h>
22: #include <sys/uio.h>
23: #include <sys/un.h>
24: #include <poll.h>
25: #include <unistd.h>
26: #include <fcntl.h>
27: #include <errno.h>
28: #include <net/if.h>
29: #include <netinet/in.h>
30: #include <netinet/tcp.h>
31: #include <netinet/udp.h>
32: #include <netinet/icmp6.h>
33:
34: #include "nest/bird.h"
35: #include "lib/lists.h"
36: #include "lib/resource.h"
37: #include "lib/socket.h"
38: #include "lib/event.h"
39: #include "lib/timer.h"
40: #include "lib/string.h"
41: #include "nest/iface.h"
42: #include "conf/conf.h"
43:
44: #include "sysdep/unix/unix.h"
45: #include CONFIG_INCLUDE_SYSIO_H
46:
47: /* Maximum number of calls of tx handler for one socket in one
48: * poll iteration. Should be small enough to not monopolize CPU by
49: * one protocol instance.
50: */
51: #define MAX_STEPS 4
52:
53: /* Maximum number of calls of rx handler for all sockets in one poll
54: iteration. RX callbacks are often much more costly so we limit
55: this to gen small latencies */
56: #define MAX_RX_STEPS 4
57:
58:
59: /*
60: * Tracked Files
61: */
62:
63: struct rfile {
64: resource r;
65: FILE *f;
66: };
67:
68: static void
69: rf_free(resource *r)
70: {
71: struct rfile *a = (struct rfile *) r;
72:
73: fclose(a->f);
74: }
75:
76: static void
77: rf_dump(resource *r)
78: {
79: struct rfile *a = (struct rfile *) r;
80:
81: debug("(FILE *%p)\n", a->f);
82: }
83:
84: static struct resclass rf_class = {
85: "FILE",
86: sizeof(struct rfile),
87: rf_free,
88: rf_dump,
89: NULL,
90: NULL
91: };
92:
93: struct rfile *
94: rf_open(pool *p, char *name, char *mode)
95: {
96: FILE *f = fopen(name, mode);
97:
98: if (!f)
99: return NULL;
100:
101: struct rfile *r = ralloc(p, &rf_class);
102: r->f = f;
103: return r;
104: }
105:
106: void *
107: rf_file(struct rfile *f)
108: {
109: return f->f;
110: }
111:
112: int
113: rf_fileno(struct rfile *f)
114: {
115: return fileno(f->f);
116: }
117:
118:
119: /*
120: * Time clock
121: */
122:
123: btime boot_time;
124:
125: void
126: times_init(struct timeloop *loop)
127: {
128: struct timespec ts;
129: int rv;
130:
131: rv = clock_gettime(CLOCK_MONOTONIC, &ts);
132: if (rv < 0)
133: die("Monotonic clock is missing");
134:
135: if ((ts.tv_sec < 0) || (((u64) ts.tv_sec) > ((u64) 1 << 40)))
136: log(L_WARN "Monotonic clock is crazy");
137:
138: loop->last_time = ts.tv_sec S + ts.tv_nsec NS;
139: loop->real_time = 0;
140: }
141:
142: void
143: times_update(struct timeloop *loop)
144: {
145: struct timespec ts;
146: int rv;
147:
148: rv = clock_gettime(CLOCK_MONOTONIC, &ts);
149: if (rv < 0)
150: die("clock_gettime: %m");
151:
152: btime new_time = ts.tv_sec S + ts.tv_nsec NS;
153:
154: if (new_time < loop->last_time)
155: log(L_ERR "Monotonic clock is broken");
156:
157: loop->last_time = new_time;
158: loop->real_time = 0;
159: }
160:
161: void
162: times_update_real_time(struct timeloop *loop)
163: {
164: struct timespec ts;
165: int rv;
166:
167: rv = clock_gettime(CLOCK_REALTIME, &ts);
168: if (rv < 0)
169: die("clock_gettime: %m");
170:
171: loop->real_time = ts.tv_sec S + ts.tv_nsec NS;
172: }
173:
174:
175: /**
176: * DOC: Sockets
177: *
178: * Socket resources represent network connections. Their data structure (&socket)
179: * contains a lot of fields defining the exact type of the socket, the local and
180: * remote addresses and ports, pointers to socket buffers and finally pointers to
181: * hook functions to be called when new data have arrived to the receive buffer
182: * (@rx_hook), when the contents of the transmit buffer have been transmitted
183: * (@tx_hook) and when an error or connection close occurs (@err_hook).
184: *
185: * Freeing of sockets from inside socket hooks is perfectly safe.
186: */
187:
188: #ifndef SOL_IP
189: #define SOL_IP IPPROTO_IP
190: #endif
191:
192: #ifndef SOL_IPV6
193: #define SOL_IPV6 IPPROTO_IPV6
194: #endif
195:
196: #ifndef SOL_ICMPV6
197: #define SOL_ICMPV6 IPPROTO_ICMPV6
198: #endif
199:
200:
201: /*
202: * Sockaddr helper functions
203: */
204:
205: static inline int UNUSED sockaddr_length(int af)
206: { return (af == AF_INET) ? sizeof(struct sockaddr_in) : sizeof(struct sockaddr_in6); }
207:
208: static inline void
209: sockaddr_fill4(struct sockaddr_in *sa, ip_addr a, uint port)
210: {
211: memset(sa, 0, sizeof(struct sockaddr_in));
212: #ifdef HAVE_STRUCT_SOCKADDR_SA_LEN
213: sa->sin_len = sizeof(struct sockaddr_in);
214: #endif
215: sa->sin_family = AF_INET;
216: sa->sin_port = htons(port);
217: sa->sin_addr = ipa_to_in4(a);
218: }
219:
220: static inline void
221: sockaddr_fill6(struct sockaddr_in6 *sa, ip_addr a, struct iface *ifa, uint port)
222: {
223: memset(sa, 0, sizeof(struct sockaddr_in6));
224: #ifdef SIN6_LEN
225: sa->sin6_len = sizeof(struct sockaddr_in6);
226: #endif
227: sa->sin6_family = AF_INET6;
228: sa->sin6_port = htons(port);
229: sa->sin6_flowinfo = 0;
230: sa->sin6_addr = ipa_to_in6(a);
231:
232: if (ifa && ipa_is_link_local(a))
233: sa->sin6_scope_id = ifa->index;
234: }
235:
236: void
237: sockaddr_fill(sockaddr *sa, int af, ip_addr a, struct iface *ifa, uint port)
238: {
239: if (af == AF_INET)
240: sockaddr_fill4((struct sockaddr_in *) sa, a, port);
241: else if (af == AF_INET6)
242: sockaddr_fill6((struct sockaddr_in6 *) sa, a, ifa, port);
243: else
244: bug("Unknown AF");
245: }
246:
247: static inline void
248: sockaddr_read4(struct sockaddr_in *sa, ip_addr *a, uint *port)
249: {
250: *port = ntohs(sa->sin_port);
251: *a = ipa_from_in4(sa->sin_addr);
252: }
253:
254: static inline void
255: sockaddr_read6(struct sockaddr_in6 *sa, ip_addr *a, struct iface **ifa, uint *port)
256: {
257: *port = ntohs(sa->sin6_port);
258: *a = ipa_from_in6(sa->sin6_addr);
259:
260: if (ifa && ipa_is_link_local(*a))
261: *ifa = if_find_by_index(sa->sin6_scope_id);
262: }
263:
264: int
265: sockaddr_read(sockaddr *sa, int af, ip_addr *a, struct iface **ifa, uint *port)
266: {
267: if (sa->sa.sa_family != af)
268: goto fail;
269:
270: if (af == AF_INET)
271: sockaddr_read4((struct sockaddr_in *) sa, a, port);
272: else if (af == AF_INET6)
273: sockaddr_read6((struct sockaddr_in6 *) sa, a, ifa, port);
274: else
275: goto fail;
276:
277: return 0;
278:
279: fail:
280: *a = IPA_NONE;
281: *port = 0;
282: return -1;
283: }
284:
285:
286: /*
287: * IPv6 multicast syscalls
288: */
289:
290: /* Fortunately standardized in RFC 3493 */
291:
292: #define INIT_MREQ6(maddr,ifa) \
293: { .ipv6mr_multiaddr = ipa_to_in6(maddr), .ipv6mr_interface = ifa->index }
294:
295: static inline int
296: sk_setup_multicast6(sock *s)
297: {
298: int index = s->iface->index;
299: int ttl = s->ttl;
300: int n = 0;
301:
302: if (setsockopt(s->fd, SOL_IPV6, IPV6_MULTICAST_IF, &index, sizeof(index)) < 0)
303: ERR("IPV6_MULTICAST_IF");
304:
305: if (setsockopt(s->fd, SOL_IPV6, IPV6_MULTICAST_HOPS, &ttl, sizeof(ttl)) < 0)
306: ERR("IPV6_MULTICAST_HOPS");
307:
308: if (setsockopt(s->fd, SOL_IPV6, IPV6_MULTICAST_LOOP, &n, sizeof(n)) < 0)
309: ERR("IPV6_MULTICAST_LOOP");
310:
311: return 0;
312: }
313:
314: static inline int
315: sk_join_group6(sock *s, ip_addr maddr)
316: {
317: struct ipv6_mreq mr = INIT_MREQ6(maddr, s->iface);
318:
319: if (setsockopt(s->fd, SOL_IPV6, IPV6_JOIN_GROUP, &mr, sizeof(mr)) < 0)
320: ERR("IPV6_JOIN_GROUP");
321:
322: return 0;
323: }
324:
325: static inline int
326: sk_leave_group6(sock *s, ip_addr maddr)
327: {
328: struct ipv6_mreq mr = INIT_MREQ6(maddr, s->iface);
329:
330: if (setsockopt(s->fd, SOL_IPV6, IPV6_LEAVE_GROUP, &mr, sizeof(mr)) < 0)
331: ERR("IPV6_LEAVE_GROUP");
332:
333: return 0;
334: }
335:
336:
337: /*
338: * IPv6 packet control messages
339: */
340:
341: /* Also standardized, in RFC 3542 */
342:
343: /*
344: * RFC 2292 uses IPV6_PKTINFO for both the socket option and the cmsg
345: * type, RFC 3542 changed the socket option to IPV6_RECVPKTINFO. If we
346: * don't have IPV6_RECVPKTINFO we suppose the OS implements the older
347: * RFC and we use IPV6_PKTINFO.
348: */
349: #ifndef IPV6_RECVPKTINFO
350: #define IPV6_RECVPKTINFO IPV6_PKTINFO
351: #endif
352: /*
353: * Same goes for IPV6_HOPLIMIT -> IPV6_RECVHOPLIMIT.
354: */
355: #ifndef IPV6_RECVHOPLIMIT
356: #define IPV6_RECVHOPLIMIT IPV6_HOPLIMIT
357: #endif
358:
359:
360: #define CMSG6_SPACE_PKTINFO CMSG_SPACE(sizeof(struct in6_pktinfo))
361: #define CMSG6_SPACE_TTL CMSG_SPACE(sizeof(int))
362:
363: static inline int
364: sk_request_cmsg6_pktinfo(sock *s)
365: {
366: int y = 1;
367:
368: if (setsockopt(s->fd, SOL_IPV6, IPV6_RECVPKTINFO, &y, sizeof(y)) < 0)
369: ERR("IPV6_RECVPKTINFO");
370:
371: return 0;
372: }
373:
374: static inline int
375: sk_request_cmsg6_ttl(sock *s)
376: {
377: int y = 1;
378:
379: if (setsockopt(s->fd, SOL_IPV6, IPV6_RECVHOPLIMIT, &y, sizeof(y)) < 0)
380: ERR("IPV6_RECVHOPLIMIT");
381:
382: return 0;
383: }
384:
385: static inline void
386: sk_process_cmsg6_pktinfo(sock *s, struct cmsghdr *cm)
387: {
388: if (cm->cmsg_type == IPV6_PKTINFO)
389: {
390: struct in6_pktinfo *pi = (struct in6_pktinfo *) CMSG_DATA(cm);
391: s->laddr = ipa_from_in6(pi->ipi6_addr);
392: s->lifindex = pi->ipi6_ifindex;
393: }
394: }
395:
396: static inline void
397: sk_process_cmsg6_ttl(sock *s, struct cmsghdr *cm)
398: {
399: if (cm->cmsg_type == IPV6_HOPLIMIT)
400: s->rcv_ttl = * (int *) CMSG_DATA(cm);
401: }
402:
403: static inline void
404: sk_prepare_cmsgs6(sock *s, struct msghdr *msg, void *cbuf, size_t cbuflen)
405: {
406: struct cmsghdr *cm;
407: struct in6_pktinfo *pi;
408: int controllen = 0;
409:
410: msg->msg_control = cbuf;
411: msg->msg_controllen = cbuflen;
412:
413: cm = CMSG_FIRSTHDR(msg);
414: cm->cmsg_level = SOL_IPV6;
415: cm->cmsg_type = IPV6_PKTINFO;
416: cm->cmsg_len = CMSG_LEN(sizeof(*pi));
417: controllen += CMSG_SPACE(sizeof(*pi));
418:
419: pi = (struct in6_pktinfo *) CMSG_DATA(cm);
420: pi->ipi6_ifindex = s->iface ? s->iface->index : 0;
421: pi->ipi6_addr = ipa_to_in6(s->saddr);
422:
423: msg->msg_controllen = controllen;
424: }
425:
426:
427: /*
428: * Miscellaneous socket syscalls
429: */
430:
431: static inline int
432: sk_set_ttl4(sock *s, int ttl)
433: {
434: if (setsockopt(s->fd, SOL_IP, IP_TTL, &ttl, sizeof(ttl)) < 0)
435: ERR("IP_TTL");
436:
437: return 0;
438: }
439:
440: static inline int
441: sk_set_ttl6(sock *s, int ttl)
442: {
443: if (setsockopt(s->fd, SOL_IPV6, IPV6_UNICAST_HOPS, &ttl, sizeof(ttl)) < 0)
444: ERR("IPV6_UNICAST_HOPS");
445:
446: return 0;
447: }
448:
449: static inline int
450: sk_set_tos4(sock *s, int tos)
451: {
452: if (setsockopt(s->fd, SOL_IP, IP_TOS, &tos, sizeof(tos)) < 0)
453: ERR("IP_TOS");
454:
455: return 0;
456: }
457:
458: static inline int
459: sk_set_tos6(sock *s, int tos)
460: {
461: if (setsockopt(s->fd, SOL_IPV6, IPV6_TCLASS, &tos, sizeof(tos)) < 0)
462: ERR("IPV6_TCLASS");
463:
464: return 0;
465: }
466:
467: static inline int
468: sk_set_high_port(sock *s UNUSED)
469: {
470: /* Port range setting is optional, ignore it if not supported */
471:
472: #ifdef IP_PORTRANGE
473: if (sk_is_ipv4(s))
474: {
475: int range = IP_PORTRANGE_HIGH;
476: if (setsockopt(s->fd, SOL_IP, IP_PORTRANGE, &range, sizeof(range)) < 0)
477: ERR("IP_PORTRANGE");
478: }
479: #endif
480:
481: #ifdef IPV6_PORTRANGE
482: if (sk_is_ipv6(s))
483: {
484: int range = IPV6_PORTRANGE_HIGH;
485: if (setsockopt(s->fd, SOL_IPV6, IPV6_PORTRANGE, &range, sizeof(range)) < 0)
486: ERR("IPV6_PORTRANGE");
487: }
488: #endif
489:
490: return 0;
491: }
492:
493: static inline byte *
494: sk_skip_ip_header(byte *pkt, int *len)
495: {
496: if ((*len < 20) || ((*pkt & 0xf0) != 0x40))
497: return NULL;
498:
499: int hlen = (*pkt & 0x0f) * 4;
500: if ((hlen < 20) || (hlen > *len))
501: return NULL;
502:
503: *len -= hlen;
504: return pkt + hlen;
505: }
506:
507: byte *
508: sk_rx_buffer(sock *s, int *len)
509: {
510: if (sk_is_ipv4(s) && (s->type == SK_IP))
511: return sk_skip_ip_header(s->rbuf, len);
512: else
513: return s->rbuf;
514: }
515:
516:
517: /*
518: * Public socket functions
519: */
520:
521: /**
522: * sk_setup_multicast - enable multicast for given socket
523: * @s: socket
524: *
525: * Prepare transmission of multicast packets for given datagram socket.
526: * The socket must have defined @iface.
527: *
528: * Result: 0 for success, -1 for an error.
529: */
530:
531: int
532: sk_setup_multicast(sock *s)
533: {
534: ASSERT(s->iface);
535:
536: if (sk_is_ipv4(s))
537: return sk_setup_multicast4(s);
538: else
539: return sk_setup_multicast6(s);
540: }
541:
542: /**
543: * sk_join_group - join multicast group for given socket
544: * @s: socket
545: * @maddr: multicast address
546: *
547: * Join multicast group for given datagram socket and associated interface.
548: * The socket must have defined @iface.
549: *
550: * Result: 0 for success, -1 for an error.
551: */
552:
553: int
554: sk_join_group(sock *s, ip_addr maddr)
555: {
556: if (sk_is_ipv4(s))
557: return sk_join_group4(s, maddr);
558: else
559: return sk_join_group6(s, maddr);
560: }
561:
562: /**
563: * sk_leave_group - leave multicast group for given socket
564: * @s: socket
565: * @maddr: multicast address
566: *
567: * Leave multicast group for given datagram socket and associated interface.
568: * The socket must have defined @iface.
569: *
570: * Result: 0 for success, -1 for an error.
571: */
572:
573: int
574: sk_leave_group(sock *s, ip_addr maddr)
575: {
576: if (sk_is_ipv4(s))
577: return sk_leave_group4(s, maddr);
578: else
579: return sk_leave_group6(s, maddr);
580: }
581:
582: /**
583: * sk_setup_broadcast - enable broadcast for given socket
584: * @s: socket
585: *
586: * Allow reception and transmission of broadcast packets for given datagram
587: * socket. The socket must have defined @iface. For transmission, packets should
588: * be send to @brd address of @iface.
589: *
590: * Result: 0 for success, -1 for an error.
591: */
592:
593: int
594: sk_setup_broadcast(sock *s)
595: {
596: int y = 1;
597:
598: if (setsockopt(s->fd, SOL_SOCKET, SO_BROADCAST, &y, sizeof(y)) < 0)
599: ERR("SO_BROADCAST");
600:
601: return 0;
602: }
603:
604: /**
605: * sk_set_ttl - set transmit TTL for given socket
606: * @s: socket
607: * @ttl: TTL value
608: *
609: * Set TTL for already opened connections when TTL was not set before. Useful
610: * for accepted connections when different ones should have different TTL.
611: *
612: * Result: 0 for success, -1 for an error.
613: */
614:
615: int
616: sk_set_ttl(sock *s, int ttl)
617: {
618: s->ttl = ttl;
619:
620: if (sk_is_ipv4(s))
621: return sk_set_ttl4(s, ttl);
622: else
623: return sk_set_ttl6(s, ttl);
624: }
625:
626: /**
627: * sk_set_min_ttl - set minimal accepted TTL for given socket
628: * @s: socket
629: * @ttl: TTL value
630: *
631: * Set minimal accepted TTL for given socket. Can be used for TTL security.
632: * implementations.
633: *
634: * Result: 0 for success, -1 for an error.
635: */
636:
637: int
638: sk_set_min_ttl(sock *s, int ttl)
639: {
640: if (sk_is_ipv4(s))
641: return sk_set_min_ttl4(s, ttl);
642: else
643: return sk_set_min_ttl6(s, ttl);
644: }
645:
646: #if 0
647: /**
648: * sk_set_md5_auth - add / remove MD5 security association for given socket
649: * @s: socket
650: * @local: IP address of local side
651: * @remote: IP address of remote side
652: * @ifa: Interface for link-local IP address
653: * @passwd: Password used for MD5 authentication
654: * @setkey: Update also system SA/SP database
655: *
656: * In TCP MD5 handling code in kernel, there is a set of security associations
657: * used for choosing password and other authentication parameters according to
658: * the local and remote address. This function is useful for listening socket,
659: * for active sockets it may be enough to set s->password field.
660: *
661: * When called with passwd != NULL, the new pair is added,
662: * When called with passwd == NULL, the existing pair is removed.
663: *
664: * Note that while in Linux, the MD5 SAs are specific to socket, in BSD they are
665: * stored in global SA/SP database (but the behavior also must be enabled on
666: * per-socket basis). In case of multiple sockets to the same neighbor, the
667: * socket-specific state must be configured for each socket while global state
668: * just once per src-dst pair. The @setkey argument controls whether the global
669: * state (SA/SP database) is also updated.
670: *
671: * Result: 0 for success, -1 for an error.
672: */
673:
674: int
675: sk_set_md5_auth(sock *s, ip_addr local, ip_addr remote, struct iface *ifa, char *passwd, int setkey)
676: { DUMMY; }
677: #endif
678:
679: /**
680: * sk_set_ipv6_checksum - specify IPv6 checksum offset for given socket
681: * @s: socket
682: * @offset: offset
683: *
684: * Specify IPv6 checksum field offset for given raw IPv6 socket. After that, the
685: * kernel will automatically fill it for outgoing packets and check it for
686: * incoming packets. Should not be used on ICMPv6 sockets, where the position is
687: * known to the kernel.
688: *
689: * Result: 0 for success, -1 for an error.
690: */
691:
692: int
693: sk_set_ipv6_checksum(sock *s, int offset)
694: {
695: if (setsockopt(s->fd, SOL_IPV6, IPV6_CHECKSUM, &offset, sizeof(offset)) < 0)
696: ERR("IPV6_CHECKSUM");
697:
698: return 0;
699: }
700:
701: int
702: sk_set_icmp6_filter(sock *s, int p1, int p2)
703: {
704: /* a bit of lame interface, but it is here only for Radv */
705: struct icmp6_filter f;
706:
707: ICMP6_FILTER_SETBLOCKALL(&f);
708: ICMP6_FILTER_SETPASS(p1, &f);
709: ICMP6_FILTER_SETPASS(p2, &f);
710:
711: if (setsockopt(s->fd, SOL_ICMPV6, ICMP6_FILTER, &f, sizeof(f)) < 0)
712: ERR("ICMP6_FILTER");
713:
714: return 0;
715: }
716:
717: void
718: sk_log_error(sock *s, const char *p)
719: {
720: log(L_ERR "%s: Socket error: %s%#m", p, s->err);
721: }
722:
723:
724: /*
725: * Actual struct birdsock code
726: */
727:
728: static list sock_list;
729: static struct birdsock *current_sock;
730: static struct birdsock *stored_sock;
731:
732: static inline sock *
733: sk_next(sock *s)
734: {
735: if (!s->n.next->next)
736: return NULL;
737: else
738: return SKIP_BACK(sock, n, s->n.next);
739: }
740:
741: static void
742: sk_alloc_bufs(sock *s)
743: {
744: if (!s->rbuf && s->rbsize)
745: s->rbuf = s->rbuf_alloc = xmalloc(s->rbsize);
746: s->rpos = s->rbuf;
747: if (!s->tbuf && s->tbsize)
748: s->tbuf = s->tbuf_alloc = xmalloc(s->tbsize);
749: s->tpos = s->ttx = s->tbuf;
750: }
751:
752: static void
753: sk_free_bufs(sock *s)
754: {
755: if (s->rbuf_alloc)
756: {
757: xfree(s->rbuf_alloc);
758: s->rbuf = s->rbuf_alloc = NULL;
759: }
760: if (s->tbuf_alloc)
761: {
762: xfree(s->tbuf_alloc);
763: s->tbuf = s->tbuf_alloc = NULL;
764: }
765: }
766:
767: #ifdef HAVE_LIBSSH
768: static void
769: sk_ssh_free(sock *s)
770: {
771: struct ssh_sock *ssh = s->ssh;
772:
773: if (s->ssh == NULL)
774: return;
775:
776: s->ssh = NULL;
777:
778: if (ssh->channel)
779: {
780: if (ssh_channel_is_open(ssh->channel))
781: ssh_channel_close(ssh->channel);
782: ssh_channel_free(ssh->channel);
783: ssh->channel = NULL;
784: }
785:
786: if (ssh->session)
787: {
788: ssh_disconnect(ssh->session);
789: ssh_free(ssh->session);
790: ssh->session = NULL;
791: }
792: }
793: #endif
794:
795: static void
796: sk_free(resource *r)
797: {
798: sock *s = (sock *) r;
799:
800: sk_free_bufs(s);
801:
802: #ifdef HAVE_LIBSSH
803: if (s->type == SK_SSH || s->type == SK_SSH_ACTIVE)
804: sk_ssh_free(s);
805: #endif
806:
807: if (s->fd < 0)
808: return;
809:
810: /* FIXME: we should call sk_stop() for SKF_THREAD sockets */
811: if (!(s->flags & SKF_THREAD))
812: {
813: if (s == current_sock)
814: current_sock = sk_next(s);
815: if (s == stored_sock)
816: stored_sock = sk_next(s);
817: rem_node(&s->n);
818: }
819:
820: if (s->type != SK_SSH && s->type != SK_SSH_ACTIVE)
821: close(s->fd);
822:
823: s->fd = -1;
824: }
825:
826: void
827: sk_set_rbsize(sock *s, uint val)
828: {
829: ASSERT(s->rbuf_alloc == s->rbuf);
830:
831: if (s->rbsize == val)
832: return;
833:
834: s->rbsize = val;
835: xfree(s->rbuf_alloc);
836: s->rbuf_alloc = xmalloc(val);
837: s->rpos = s->rbuf = s->rbuf_alloc;
838: }
839:
840: void
841: sk_set_tbsize(sock *s, uint val)
842: {
843: ASSERT(s->tbuf_alloc == s->tbuf);
844:
845: if (s->tbsize == val)
846: return;
847:
848: byte *old_tbuf = s->tbuf;
849:
850: s->tbsize = val;
851: s->tbuf = s->tbuf_alloc = xrealloc(s->tbuf_alloc, val);
852: s->tpos = s->tbuf + (s->tpos - old_tbuf);
853: s->ttx = s->tbuf + (s->ttx - old_tbuf);
854: }
855:
856: void
857: sk_set_tbuf(sock *s, void *tbuf)
858: {
859: s->tbuf = tbuf ?: s->tbuf_alloc;
860: s->ttx = s->tpos = s->tbuf;
861: }
862:
863: void
864: sk_reallocate(sock *s)
865: {
866: sk_free_bufs(s);
867: sk_alloc_bufs(s);
868: }
869:
870: static void
871: sk_dump(resource *r)
872: {
873: sock *s = (sock *) r;
874: static char *sk_type_names[] = { "TCP<", "TCP>", "TCP", "UDP", NULL, "IP", NULL, "MAGIC", "UNIX<", "UNIX", "SSH>", "SSH", "DEL!" };
875:
876: debug("(%s, ud=%p, sa=%I, sp=%d, da=%I, dp=%d, tos=%d, ttl=%d, if=%s)\n",
877: sk_type_names[s->type],
878: s->data,
879: s->saddr,
880: s->sport,
881: s->daddr,
882: s->dport,
883: s->tos,
884: s->ttl,
885: s->iface ? s->iface->name : "none");
886: }
887:
888: static struct resclass sk_class = {
889: "Socket",
890: sizeof(sock),
891: sk_free,
892: sk_dump,
893: NULL,
894: NULL
895: };
896:
897: /**
898: * sk_new - create a socket
899: * @p: pool
900: *
901: * This function creates a new socket resource. If you want to use it,
902: * you need to fill in all the required fields of the structure and
903: * call sk_open() to do the actual opening of the socket.
904: *
905: * The real function name is sock_new(), sk_new() is a macro wrapper
906: * to avoid collision with OpenSSL.
907: */
908: sock *
909: sock_new(pool *p)
910: {
911: sock *s = ralloc(p, &sk_class);
912: s->pool = p;
913: // s->saddr = s->daddr = IPA_NONE;
914: s->tos = s->priority = s->ttl = -1;
915: s->fd = -1;
916: return s;
917: }
918:
919: static int
920: sk_setup(sock *s)
921: {
922: int y = 1;
923: int fd = s->fd;
924:
925: if (s->type == SK_SSH_ACTIVE)
926: return 0;
927:
928: if (fcntl(fd, F_SETFL, O_NONBLOCK) < 0)
929: ERR("O_NONBLOCK");
930:
931: if (!s->af)
932: return 0;
933:
934: if (ipa_nonzero(s->saddr) && !(s->flags & SKF_BIND))
935: s->flags |= SKF_PKTINFO;
936:
937: #ifdef CONFIG_USE_HDRINCL
938: if (sk_is_ipv4(s) && (s->type == SK_IP) && (s->flags & SKF_PKTINFO))
939: {
940: s->flags &= ~SKF_PKTINFO;
941: s->flags |= SKF_HDRINCL;
942: if (setsockopt(fd, SOL_IP, IP_HDRINCL, &y, sizeof(y)) < 0)
943: ERR("IP_HDRINCL");
944: }
945: #endif
946:
947: if (s->vrf && !s->iface)
948: {
949: /* Bind socket to associated VRF interface.
950: This is Linux-specific, but so is SO_BINDTODEVICE. */
951: #ifdef SO_BINDTODEVICE
952: struct ifreq ifr = {};
953: strcpy(ifr.ifr_name, s->vrf->name);
954: if (setsockopt(s->fd, SOL_SOCKET, SO_BINDTODEVICE, &ifr, sizeof(ifr)) < 0)
955: ERR("SO_BINDTODEVICE");
956: #endif
957: }
958:
959: if (s->iface)
960: {
961: #ifdef SO_BINDTODEVICE
962: struct ifreq ifr = {};
963: strcpy(ifr.ifr_name, s->iface->name);
964: if (setsockopt(s->fd, SOL_SOCKET, SO_BINDTODEVICE, &ifr, sizeof(ifr)) < 0)
965: ERR("SO_BINDTODEVICE");
966: #endif
967:
968: #ifdef CONFIG_UNIX_DONTROUTE
969: if (setsockopt(s->fd, SOL_SOCKET, SO_DONTROUTE, &y, sizeof(y)) < 0)
970: ERR("SO_DONTROUTE");
971: #endif
972: }
973:
974: if (sk_is_ipv4(s))
975: {
976: if (s->flags & SKF_LADDR_RX)
977: if (sk_request_cmsg4_pktinfo(s) < 0)
978: return -1;
979:
980: if (s->flags & SKF_TTL_RX)
981: if (sk_request_cmsg4_ttl(s) < 0)
982: return -1;
983:
984: if ((s->type == SK_UDP) || (s->type == SK_IP))
985: if (sk_disable_mtu_disc4(s) < 0)
986: return -1;
987:
988: if (s->ttl >= 0)
989: if (sk_set_ttl4(s, s->ttl) < 0)
990: return -1;
991:
992: if (s->tos >= 0)
993: if (sk_set_tos4(s, s->tos) < 0)
994: return -1;
995: }
996:
997: if (sk_is_ipv6(s))
998: {
999: if ((s->type == SK_TCP_PASSIVE) || (s->type == SK_TCP_ACTIVE) || (s->type == SK_UDP))
1000: if (setsockopt(fd, SOL_IPV6, IPV6_V6ONLY, &y, sizeof(y)) < 0)
1001: ERR("IPV6_V6ONLY");
1002:
1003: if (s->flags & SKF_LADDR_RX)
1004: if (sk_request_cmsg6_pktinfo(s) < 0)
1005: return -1;
1006:
1007: if (s->flags & SKF_TTL_RX)
1008: if (sk_request_cmsg6_ttl(s) < 0)
1009: return -1;
1010:
1011: if ((s->type == SK_UDP) || (s->type == SK_IP))
1012: if (sk_disable_mtu_disc6(s) < 0)
1013: return -1;
1014:
1015: if (s->ttl >= 0)
1016: if (sk_set_ttl6(s, s->ttl) < 0)
1017: return -1;
1018:
1019: if (s->tos >= 0)
1020: if (sk_set_tos6(s, s->tos) < 0)
1021: return -1;
1022: }
1023:
1024: /* Must be after sk_set_tos4() as setting ToS on Linux also mangles priority */
1025: if (s->priority >= 0)
1026: if (sk_set_priority(s, s->priority) < 0)
1027: return -1;
1028:
1029: return 0;
1030: }
1031:
1032: static void
1033: sk_insert(sock *s)
1034: {
1035: add_tail(&sock_list, &s->n);
1036: }
1037:
1038: static void
1039: sk_tcp_connected(sock *s)
1040: {
1041: sockaddr sa;
1042: int sa_len = sizeof(sa);
1043:
1044: if ((getsockname(s->fd, &sa.sa, &sa_len) < 0) ||
1045: (sockaddr_read(&sa, s->af, &s->saddr, &s->iface, &s->sport) < 0))
1046: log(L_WARN "SOCK: Cannot get local IP address for TCP>");
1047:
1048: s->type = SK_TCP;
1049: sk_alloc_bufs(s);
1050: s->tx_hook(s);
1051: }
1052:
1053: #ifdef HAVE_LIBSSH
1054: static void
1055: sk_ssh_connected(sock *s)
1056: {
1057: sk_alloc_bufs(s);
1058: s->type = SK_SSH;
1059: s->tx_hook(s);
1060: }
1061: #endif
1062:
1063: static int
1064: sk_passive_connected(sock *s, int type)
1065: {
1066: sockaddr loc_sa, rem_sa;
1067: int loc_sa_len = sizeof(loc_sa);
1068: int rem_sa_len = sizeof(rem_sa);
1069:
1070: int fd = accept(s->fd, ((type == SK_TCP) ? &rem_sa.sa : NULL), &rem_sa_len);
1071: if (fd < 0)
1072: {
1073: if ((errno != EINTR) && (errno != EAGAIN))
1074: s->err_hook(s, errno);
1075: return 0;
1076: }
1077:
1078: sock *t = sk_new(s->pool);
1079: t->type = type;
1080: t->data = s->data;
1081: t->af = s->af;
1082: t->fd = fd;
1083: t->ttl = s->ttl;
1084: t->tos = s->tos;
1085: t->vrf = s->vrf;
1086: t->rbsize = s->rbsize;
1087: t->tbsize = s->tbsize;
1088:
1089: if (type == SK_TCP)
1090: {
1091: if ((getsockname(fd, &loc_sa.sa, &loc_sa_len) < 0) ||
1092: (sockaddr_read(&loc_sa, s->af, &t->saddr, &t->iface, &t->sport) < 0))
1093: log(L_WARN "SOCK: Cannot get local IP address for TCP<");
1094:
1095: if (sockaddr_read(&rem_sa, s->af, &t->daddr, &t->iface, &t->dport) < 0)
1096: log(L_WARN "SOCK: Cannot get remote IP address for TCP<");
1097: }
1098:
1099: if (sk_setup(t) < 0)
1100: {
1101: /* FIXME: Call err_hook instead ? */
1102: log(L_ERR "SOCK: Incoming connection: %s%#m", t->err);
1103:
1104: /* FIXME: handle it better in rfree() */
1105: close(t->fd);
1106: t->fd = -1;
1107: rfree(t);
1108: return 1;
1109: }
1110:
1111: sk_insert(t);
1112: sk_alloc_bufs(t);
1113: s->rx_hook(t, 0);
1114: return 1;
1115: }
1116:
1117: #ifdef HAVE_LIBSSH
1118: /*
1119: * Return SSH_OK or SSH_AGAIN or SSH_ERROR
1120: */
1121: static int
1122: sk_ssh_connect(sock *s)
1123: {
1124: s->fd = ssh_get_fd(s->ssh->session);
1125:
1126: /* Big fall thru automata */
1127: switch (s->ssh->state)
1128: {
1129: case SK_SSH_CONNECT:
1130: {
1131: switch (ssh_connect(s->ssh->session))
1132: {
1133: case SSH_AGAIN:
1134: /* A quick look into libSSH shows that ssh_get_fd() should return non-(-1)
1135: * after SSH_AGAIN is returned by ssh_connect(). This is however nowhere
1136: * documented but our code relies on that.
1137: */
1138: return SSH_AGAIN;
1139:
1140: case SSH_OK:
1141: break;
1142:
1143: default:
1144: return SSH_ERROR;
1145: }
1146: } /* fallthrough */
1147:
1148: case SK_SSH_SERVER_KNOWN:
1149: {
1150: s->ssh->state = SK_SSH_SERVER_KNOWN;
1151:
1152: if (s->ssh->server_hostkey_path)
1153: {
1154: int server_identity_is_ok = 1;
1155:
1156: /* Check server identity */
1157: switch (ssh_is_server_known(s->ssh->session))
1158: {
1159: #define LOG_WARN_ABOUT_SSH_SERVER_VALIDATION(s,msg,args...) log(L_WARN "SSH Identity %s@%s:%u: " msg, (s)->ssh->username, (s)->host, (s)->dport, ## args);
1160: case SSH_SERVER_KNOWN_OK:
1161: /* The server is known and has not changed. */
1162: break;
1163:
1164: case SSH_SERVER_NOT_KNOWN:
1165: LOG_WARN_ABOUT_SSH_SERVER_VALIDATION(s, "The server is unknown, its public key was not found in the known host file %s", s->ssh->server_hostkey_path);
1166: break;
1167:
1168: case SSH_SERVER_KNOWN_CHANGED:
1169: LOG_WARN_ABOUT_SSH_SERVER_VALIDATION(s, "The server key has changed. Either you are under attack or the administrator changed the key.");
1170: server_identity_is_ok = 0;
1171: break;
1172:
1173: case SSH_SERVER_FILE_NOT_FOUND:
1174: LOG_WARN_ABOUT_SSH_SERVER_VALIDATION(s, "The known host file %s does not exist", s->ssh->server_hostkey_path);
1175: server_identity_is_ok = 0;
1176: break;
1177:
1178: case SSH_SERVER_ERROR:
1179: LOG_WARN_ABOUT_SSH_SERVER_VALIDATION(s, "Some error happened");
1180: server_identity_is_ok = 0;
1181: break;
1182:
1183: case SSH_SERVER_FOUND_OTHER:
1184: LOG_WARN_ABOUT_SSH_SERVER_VALIDATION(s, "The server gave use a key of a type while we had an other type recorded. " \
1185: "It is a possible attack.");
1186: server_identity_is_ok = 0;
1187: break;
1188: }
1189:
1190: if (!server_identity_is_ok)
1191: return SSH_ERROR;
1192: }
1193: } /* fallthrough */
1194:
1195: case SK_SSH_USERAUTH:
1196: {
1197: s->ssh->state = SK_SSH_USERAUTH;
1198: switch (ssh_userauth_publickey_auto(s->ssh->session, NULL, NULL))
1199: {
1200: case SSH_AUTH_AGAIN:
1201: return SSH_AGAIN;
1202:
1203: case SSH_AUTH_SUCCESS:
1204: break;
1205:
1206: default:
1207: return SSH_ERROR;
1208: }
1209: } /* fallthrough */
1210:
1211: case SK_SSH_CHANNEL:
1212: {
1213: s->ssh->state = SK_SSH_CHANNEL;
1214: s->ssh->channel = ssh_channel_new(s->ssh->session);
1215: if (s->ssh->channel == NULL)
1216: return SSH_ERROR;
1217: } /* fallthrough */
1218:
1219: case SK_SSH_SESSION:
1220: {
1221: s->ssh->state = SK_SSH_SESSION;
1222: switch (ssh_channel_open_session(s->ssh->channel))
1223: {
1224: case SSH_AGAIN:
1225: return SSH_AGAIN;
1226:
1227: case SSH_OK:
1228: break;
1229:
1230: default:
1231: return SSH_ERROR;
1232: }
1233: } /* fallthrough */
1234:
1235: case SK_SSH_SUBSYSTEM:
1236: {
1237: s->ssh->state = SK_SSH_SUBSYSTEM;
1238: if (s->ssh->subsystem)
1239: {
1240: switch (ssh_channel_request_subsystem(s->ssh->channel, s->ssh->subsystem))
1241: {
1242: case SSH_AGAIN:
1243: return SSH_AGAIN;
1244:
1245: case SSH_OK:
1246: break;
1247:
1248: default:
1249: return SSH_ERROR;
1250: }
1251: }
1252: } /* fallthrough */
1253:
1254: case SK_SSH_ESTABLISHED:
1255: s->ssh->state = SK_SSH_ESTABLISHED;
1256: }
1257:
1258: return SSH_OK;
1259: }
1260:
1261: /*
1262: * Return file descriptor number if success
1263: * Return -1 if failed
1264: */
1265: static int
1266: sk_open_ssh(sock *s)
1267: {
1268: if (!s->ssh)
1269: bug("sk_open() sock->ssh is not allocated");
1270:
1271: ssh_session sess = ssh_new();
1272: if (sess == NULL)
1273: ERR2("Cannot create a ssh session");
1274: s->ssh->session = sess;
1275:
1276: const int verbosity = SSH_LOG_NOLOG;
1277: ssh_options_set(sess, SSH_OPTIONS_LOG_VERBOSITY, &verbosity);
1278: ssh_options_set(sess, SSH_OPTIONS_HOST, s->host);
1279: ssh_options_set(sess, SSH_OPTIONS_PORT, &(s->dport));
1280: /* TODO: Add SSH_OPTIONS_BINDADDR */
1281: ssh_options_set(sess, SSH_OPTIONS_USER, s->ssh->username);
1282:
1283: if (s->ssh->server_hostkey_path)
1284: ssh_options_set(sess, SSH_OPTIONS_KNOWNHOSTS, s->ssh->server_hostkey_path);
1285:
1286: if (s->ssh->client_privkey_path)
1287: ssh_options_set(sess, SSH_OPTIONS_IDENTITY, s->ssh->client_privkey_path);
1288:
1289: ssh_set_blocking(sess, 0);
1290:
1291: switch (sk_ssh_connect(s))
1292: {
1293: case SSH_AGAIN:
1294: break;
1295:
1296: case SSH_OK:
1297: sk_ssh_connected(s);
1298: break;
1299:
1300: case SSH_ERROR:
1301: ERR2(ssh_get_error(sess));
1302: break;
1303: }
1304:
1305: return ssh_get_fd(sess);
1306:
1307: err:
1308: return -1;
1309: }
1310: #endif
1311:
1312: /**
1313: * sk_open - open a socket
1314: * @s: socket
1315: *
1316: * This function takes a socket resource created by sk_new() and
1317: * initialized by the user and binds a corresponding network connection
1318: * to it.
1319: *
1320: * Result: 0 for success, -1 for an error.
1321: */
1322: int
1323: sk_open(sock *s)
1324: {
1325: int af = AF_UNSPEC;
1326: int fd = -1;
1327: int do_bind = 0;
1328: int bind_port = 0;
1329: ip_addr bind_addr = IPA_NONE;
1330: sockaddr sa;
1331:
1332: if (s->type <= SK_IP)
1333: {
1334: /*
1335: * For TCP/IP sockets, Address family (IPv4 or IPv6) can be specified either
1336: * explicitly (SK_IPV4 or SK_IPV6) or implicitly (based on saddr, daddr).
1337: * But the specifications have to be consistent.
1338: */
1339:
1340: switch (s->subtype)
1341: {
1342: case 0:
1343: ASSERT(ipa_zero(s->saddr) || ipa_zero(s->daddr) ||
1344: (ipa_is_ip4(s->saddr) == ipa_is_ip4(s->daddr)));
1345: af = (ipa_is_ip4(s->saddr) || ipa_is_ip4(s->daddr)) ? AF_INET : AF_INET6;
1346: break;
1347:
1348: case SK_IPV4:
1349: ASSERT(ipa_zero(s->saddr) || ipa_is_ip4(s->saddr));
1350: ASSERT(ipa_zero(s->daddr) || ipa_is_ip4(s->daddr));
1351: af = AF_INET;
1352: break;
1353:
1354: case SK_IPV6:
1355: ASSERT(ipa_zero(s->saddr) || !ipa_is_ip4(s->saddr));
1356: ASSERT(ipa_zero(s->daddr) || !ipa_is_ip4(s->daddr));
1357: af = AF_INET6;
1358: break;
1359:
1360: default:
1361: bug("Invalid subtype %d", s->subtype);
1362: }
1363: }
1364:
1365: switch (s->type)
1366: {
1367: case SK_TCP_ACTIVE:
1368: s->ttx = ""; /* Force s->ttx != s->tpos */
1369: /* Fall thru */
1370: case SK_TCP_PASSIVE:
1371: fd = socket(af, SOCK_STREAM, IPPROTO_TCP);
1372: bind_port = s->sport;
1373: bind_addr = s->saddr;
1374: do_bind = bind_port || ipa_nonzero(bind_addr);
1375: break;
1376:
1377: #ifdef HAVE_LIBSSH
1378: case SK_SSH_ACTIVE:
1379: s->ttx = ""; /* Force s->ttx != s->tpos */
1380: fd = sk_open_ssh(s);
1381: break;
1382: #endif
1383:
1384: case SK_UDP:
1385: fd = socket(af, SOCK_DGRAM, IPPROTO_UDP);
1386: bind_port = s->sport;
1387: bind_addr = (s->flags & SKF_BIND) ? s->saddr : IPA_NONE;
1388: do_bind = 1;
1389: break;
1390:
1391: case SK_IP:
1392: fd = socket(af, SOCK_RAW, s->dport);
1393: bind_port = 0;
1394: bind_addr = (s->flags & SKF_BIND) ? s->saddr : IPA_NONE;
1395: do_bind = ipa_nonzero(bind_addr);
1396: break;
1397:
1398: case SK_MAGIC:
1399: af = 0;
1400: fd = s->fd;
1401: break;
1402:
1403: default:
1404: bug("sk_open() called for invalid sock type %d", s->type);
1405: }
1406:
1407: if (fd < 0)
1408: ERR("socket");
1409:
1410: s->af = af;
1411: s->fd = fd;
1412:
1413: if (sk_setup(s) < 0)
1414: goto err;
1415:
1416: if (do_bind)
1417: {
1418: if (bind_port)
1419: {
1420: int y = 1;
1421:
1422: if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &y, sizeof(y)) < 0)
1423: ERR2("SO_REUSEADDR");
1424:
1425: #ifdef CONFIG_NO_IFACE_BIND
1426: /* Workaround missing ability to bind to an iface */
1427: if ((s->type == SK_UDP) && s->iface && ipa_zero(bind_addr))
1428: {
1429: if (setsockopt(fd, SOL_SOCKET, SO_REUSEPORT, &y, sizeof(y)) < 0)
1430: ERR2("SO_REUSEPORT");
1431: }
1432: #endif
1433: }
1434: else
1435: if (s->flags & SKF_HIGH_PORT)
1436: if (sk_set_high_port(s) < 0)
1437: log(L_WARN "Socket error: %s%#m", s->err);
1438:
1439: sockaddr_fill(&sa, s->af, bind_addr, s->iface, bind_port);
1440: if (bind(fd, &sa.sa, SA_LEN(sa)) < 0)
1441: ERR2("bind");
1442: }
1443:
1444: if (s->password)
1445: if (sk_set_md5_auth(s, s->saddr, s->daddr, s->iface, s->password, 0) < 0)
1446: goto err;
1447:
1448: switch (s->type)
1449: {
1450: case SK_TCP_ACTIVE:
1451: sockaddr_fill(&sa, s->af, s->daddr, s->iface, s->dport);
1452: if (connect(fd, &sa.sa, SA_LEN(sa)) >= 0)
1453: sk_tcp_connected(s);
1454: else if (errno != EINTR && errno != EAGAIN && errno != EINPROGRESS &&
1455: errno != ECONNREFUSED && errno != EHOSTUNREACH && errno != ENETUNREACH)
1456: ERR2("connect");
1457: break;
1458:
1459: case SK_TCP_PASSIVE:
1460: if (listen(fd, 8) < 0)
1461: ERR2("listen");
1462: break;
1463:
1464: case SK_SSH_ACTIVE:
1465: case SK_MAGIC:
1466: break;
1467:
1468: default:
1469: sk_alloc_bufs(s);
1470: }
1471:
1472: if (!(s->flags & SKF_THREAD))
1473: sk_insert(s);
1474:
1475: return 0;
1476:
1477: err:
1478: close(fd);
1479: s->fd = -1;
1480: return -1;
1481: }
1482:
1483: int
1484: sk_open_unix(sock *s, char *name)
1485: {
1486: struct sockaddr_un sa;
1487: int fd;
1488:
1489: /* We are sloppy during error (leak fd and not set s->err), but we die anyway */
1490:
1491: fd = socket(AF_UNIX, SOCK_STREAM, 0);
1492: if (fd < 0)
1493: return -1;
1494:
1495: if (fcntl(fd, F_SETFL, O_NONBLOCK) < 0)
1496: return -1;
1497:
1498: /* Path length checked in test_old_bird() */
1499: sa.sun_family = AF_UNIX;
1500: strcpy(sa.sun_path, name);
1501:
1502: if (bind(fd, (struct sockaddr *) &sa, SUN_LEN(&sa)) < 0)
1503: return -1;
1504:
1505: if (listen(fd, 8) < 0)
1506: return -1;
1507:
1508: s->fd = fd;
1509: sk_insert(s);
1510: return 0;
1511: }
1512:
1513:
1514: #define CMSG_RX_SPACE MAX(CMSG4_SPACE_PKTINFO+CMSG4_SPACE_TTL, \
1515: CMSG6_SPACE_PKTINFO+CMSG6_SPACE_TTL)
1516: #define CMSG_TX_SPACE MAX(CMSG4_SPACE_PKTINFO,CMSG6_SPACE_PKTINFO)
1517:
1518: static void
1519: sk_prepare_cmsgs(sock *s, struct msghdr *msg, void *cbuf, size_t cbuflen)
1520: {
1521: if (sk_is_ipv4(s))
1522: sk_prepare_cmsgs4(s, msg, cbuf, cbuflen);
1523: else
1524: sk_prepare_cmsgs6(s, msg, cbuf, cbuflen);
1525: }
1526:
1527: static void
1528: sk_process_cmsgs(sock *s, struct msghdr *msg)
1529: {
1530: struct cmsghdr *cm;
1531:
1532: s->laddr = IPA_NONE;
1533: s->lifindex = 0;
1534: s->rcv_ttl = -1;
1535:
1536: for (cm = CMSG_FIRSTHDR(msg); cm != NULL; cm = CMSG_NXTHDR(msg, cm))
1537: {
1538: if ((cm->cmsg_level == SOL_IP) && sk_is_ipv4(s))
1539: {
1540: sk_process_cmsg4_pktinfo(s, cm);
1541: sk_process_cmsg4_ttl(s, cm);
1542: }
1543:
1544: if ((cm->cmsg_level == SOL_IPV6) && sk_is_ipv6(s))
1545: {
1546: sk_process_cmsg6_pktinfo(s, cm);
1547: sk_process_cmsg6_ttl(s, cm);
1548: }
1549: }
1550: }
1551:
1552:
1553: static inline int
1554: sk_sendmsg(sock *s)
1555: {
1556: struct iovec iov = {s->tbuf, s->tpos - s->tbuf};
1557: byte cmsg_buf[CMSG_TX_SPACE];
1558: sockaddr dst;
1559: int flags = 0;
1560:
1561: sockaddr_fill(&dst, s->af, s->daddr, s->iface, s->dport);
1562:
1563: struct msghdr msg = {
1564: .msg_name = &dst.sa,
1565: .msg_namelen = SA_LEN(dst),
1566: .msg_iov = &iov,
1567: .msg_iovlen = 1
1568: };
1569:
1570: #ifdef CONFIG_DONTROUTE_UNICAST
1571: /* FreeBSD silently changes TTL to 1 when MSG_DONTROUTE is used, therefore we
1572: cannot use it for other cases (e.g. when TTL security is used). */
1573: if (ipa_is_ip4(s->daddr) && ip4_is_unicast(ipa_to_ip4(s->daddr)) && (s->ttl == 1))
1574: flags = MSG_DONTROUTE;
1575: #endif
1576:
1577: #ifdef CONFIG_USE_HDRINCL
1578: byte hdr[20];
1579: struct iovec iov2[2] = { {hdr, 20}, iov };
1580:
1581: if (s->flags & SKF_HDRINCL)
1582: {
1583: sk_prepare_ip_header(s, hdr, iov.iov_len);
1584: msg.msg_iov = iov2;
1585: msg.msg_iovlen = 2;
1586: }
1587: #endif
1588:
1589: if (s->flags & SKF_PKTINFO)
1590: sk_prepare_cmsgs(s, &msg, cmsg_buf, sizeof(cmsg_buf));
1591:
1592: return sendmsg(s->fd, &msg, flags);
1593: }
1594:
1595: static inline int
1596: sk_recvmsg(sock *s)
1597: {
1598: struct iovec iov = {s->rbuf, s->rbsize};
1599: byte cmsg_buf[CMSG_RX_SPACE];
1600: sockaddr src;
1601:
1602: struct msghdr msg = {
1603: .msg_name = &src.sa,
1604: .msg_namelen = sizeof(src), // XXXX ??
1605: .msg_iov = &iov,
1606: .msg_iovlen = 1,
1607: .msg_control = cmsg_buf,
1608: .msg_controllen = sizeof(cmsg_buf),
1609: .msg_flags = 0
1610: };
1611:
1612: int rv = recvmsg(s->fd, &msg, 0);
1613: if (rv < 0)
1614: return rv;
1615:
1616: //ifdef IPV4
1617: // if (cf_type == SK_IP)
1618: // rv = ipv4_skip_header(pbuf, rv);
1619: //endif
1620:
1621: sockaddr_read(&src, s->af, &s->faddr, NULL, &s->fport);
1622: sk_process_cmsgs(s, &msg);
1623:
1624: if (msg.msg_flags & MSG_TRUNC)
1625: s->flags |= SKF_TRUNCATED;
1626: else
1627: s->flags &= ~SKF_TRUNCATED;
1628:
1629: return rv;
1630: }
1631:
1632:
1633: static inline void reset_tx_buffer(sock *s) { s->ttx = s->tpos = s->tbuf; }
1634:
1635: static int
1636: sk_maybe_write(sock *s)
1637: {
1638: int e;
1639:
1640: switch (s->type)
1641: {
1642: case SK_TCP:
1643: case SK_MAGIC:
1644: case SK_UNIX:
1645: while (s->ttx != s->tpos)
1646: {
1647: e = write(s->fd, s->ttx, s->tpos - s->ttx);
1648:
1649: if (e < 0)
1650: {
1651: if (errno != EINTR && errno != EAGAIN)
1652: {
1653: reset_tx_buffer(s);
1654: /* EPIPE is just a connection close notification during TX */
1655: s->err_hook(s, (errno != EPIPE) ? errno : 0);
1656: return -1;
1657: }
1658: return 0;
1659: }
1660: s->ttx += e;
1661: }
1662: reset_tx_buffer(s);
1663: return 1;
1664:
1665: #ifdef HAVE_LIBSSH
1666: case SK_SSH:
1667: while (s->ttx != s->tpos)
1668: {
1669: e = ssh_channel_write(s->ssh->channel, s->ttx, s->tpos - s->ttx);
1670:
1671: if (e < 0)
1672: {
1673: s->err = ssh_get_error(s->ssh->session);
1674: s->err_hook(s, ssh_get_error_code(s->ssh->session));
1675:
1676: reset_tx_buffer(s);
1677: /* EPIPE is just a connection close notification during TX */
1678: s->err_hook(s, (errno != EPIPE) ? errno : 0);
1679: return -1;
1680: }
1681: s->ttx += e;
1682: }
1683: reset_tx_buffer(s);
1684: return 1;
1685: #endif
1686:
1687: case SK_UDP:
1688: case SK_IP:
1689: {
1690: if (s->tbuf == s->tpos)
1691: return 1;
1692:
1693: e = sk_sendmsg(s);
1694:
1695: if (e < 0)
1696: {
1697: if (errno != EINTR && errno != EAGAIN)
1698: {
1699: reset_tx_buffer(s);
1700: s->err_hook(s, errno);
1701: return -1;
1702: }
1703:
1704: if (!s->tx_hook)
1705: reset_tx_buffer(s);
1706: return 0;
1707: }
1708: reset_tx_buffer(s);
1709: return 1;
1710: }
1711:
1712: default:
1713: bug("sk_maybe_write: unknown socket type %d", s->type);
1714: }
1715: }
1716:
1717: int
1718: sk_rx_ready(sock *s)
1719: {
1720: int rv;
1721: struct pollfd pfd = { .fd = s->fd };
1722: pfd.events |= POLLIN;
1723:
1724: redo:
1725: rv = poll(&pfd, 1, 0);
1726:
1727: if ((rv < 0) && (errno == EINTR || errno == EAGAIN))
1728: goto redo;
1729:
1730: return rv;
1731: }
1732:
1733: /**
1734: * sk_send - send data to a socket
1735: * @s: socket
1736: * @len: number of bytes to send
1737: *
1738: * This function sends @len bytes of data prepared in the
1739: * transmit buffer of the socket @s to the network connection.
1740: * If the packet can be sent immediately, it does so and returns
1741: * 1, else it queues the packet for later processing, returns 0
1742: * and calls the @tx_hook of the socket when the tranmission
1743: * takes place.
1744: */
1745: int
1746: sk_send(sock *s, unsigned len)
1747: {
1748: s->ttx = s->tbuf;
1749: s->tpos = s->tbuf + len;
1750: return sk_maybe_write(s);
1751: }
1752:
1753: /**
1754: * sk_send_to - send data to a specific destination
1755: * @s: socket
1756: * @len: number of bytes to send
1757: * @addr: IP address to send the packet to
1758: * @port: port to send the packet to
1759: *
1760: * This is a sk_send() replacement for connection-less packet sockets
1761: * which allows destination of the packet to be chosen dynamically.
1762: * Raw IP sockets should use 0 for @port.
1763: */
1764: int
1765: sk_send_to(sock *s, unsigned len, ip_addr addr, unsigned port)
1766: {
1767: s->daddr = addr;
1768: if (port)
1769: s->dport = port;
1770:
1771: s->ttx = s->tbuf;
1772: s->tpos = s->tbuf + len;
1773: return sk_maybe_write(s);
1774: }
1775:
1776: /*
1777: int
1778: sk_send_full(sock *s, unsigned len, struct iface *ifa,
1779: ip_addr saddr, ip_addr daddr, unsigned dport)
1780: {
1781: s->iface = ifa;
1782: s->saddr = saddr;
1783: s->daddr = daddr;
1784: s->dport = dport;
1785: s->ttx = s->tbuf;
1786: s->tpos = s->tbuf + len;
1787: return sk_maybe_write(s);
1788: }
1789: */
1790:
1791: static void
1792: call_rx_hook(sock *s, int size)
1793: {
1794: if (s->rx_hook(s, size))
1795: {
1796: /* We need to be careful since the socket could have been deleted by the hook */
1797: if (current_sock == s)
1798: s->rpos = s->rbuf;
1799: }
1800: }
1801:
1802: #ifdef HAVE_LIBSSH
1803: static int
1804: sk_read_ssh(sock *s)
1805: {
1806: ssh_channel rchans[2] = { s->ssh->channel, NULL };
1807: struct timeval timev = { 1, 0 };
1808:
1809: if (ssh_channel_select(rchans, NULL, NULL, &timev) == SSH_EINTR)
1810: return 1; /* Try again */
1811:
1812: if (ssh_channel_is_eof(s->ssh->channel) != 0)
1813: {
1814: /* The remote side is closing the connection */
1815: s->err_hook(s, 0);
1816: return 0;
1817: }
1818:
1819: if (rchans[0] == NULL)
1820: return 0; /* No data is available on the socket */
1821:
1822: const uint used_bytes = s->rpos - s->rbuf;
1823: const int read_bytes = ssh_channel_read_nonblocking(s->ssh->channel, s->rpos, s->rbsize - used_bytes, 0);
1824: if (read_bytes > 0)
1825: {
1826: /* Received data */
1827: s->rpos += read_bytes;
1828: call_rx_hook(s, used_bytes + read_bytes);
1829: return 1;
1830: }
1831: else if (read_bytes == 0)
1832: {
1833: if (ssh_channel_is_eof(s->ssh->channel) != 0)
1834: {
1835: /* The remote side is closing the connection */
1836: s->err_hook(s, 0);
1837: }
1838: }
1839: else
1840: {
1841: s->err = ssh_get_error(s->ssh->session);
1842: s->err_hook(s, ssh_get_error_code(s->ssh->session));
1843: }
1844:
1845: return 0; /* No data is available on the socket */
1846: }
1847: #endif
1848:
1849: /* sk_read() and sk_write() are called from BFD's event loop */
1850:
1851: int
1852: sk_read(sock *s, int revents)
1853: {
1854: switch (s->type)
1855: {
1856: case SK_TCP_PASSIVE:
1857: return sk_passive_connected(s, SK_TCP);
1858:
1859: case SK_UNIX_PASSIVE:
1860: return sk_passive_connected(s, SK_UNIX);
1861:
1862: case SK_TCP:
1863: case SK_UNIX:
1864: {
1865: int c = read(s->fd, s->rpos, s->rbuf + s->rbsize - s->rpos);
1866:
1867: if (c < 0)
1868: {
1869: if (errno != EINTR && errno != EAGAIN)
1870: s->err_hook(s, errno);
1871: else if (errno == EAGAIN && !(revents & POLLIN))
1872: {
1873: log(L_ERR "Got EAGAIN from read when revents=%x (without POLLIN)", revents);
1874: s->err_hook(s, 0);
1875: }
1876: }
1877: else if (!c)
1878: s->err_hook(s, 0);
1879: else
1880: {
1881: s->rpos += c;
1882: call_rx_hook(s, s->rpos - s->rbuf);
1883: return 1;
1884: }
1885: return 0;
1886: }
1887:
1888: #ifdef HAVE_LIBSSH
1889: case SK_SSH:
1890: return sk_read_ssh(s);
1891: #endif
1892:
1893: case SK_MAGIC:
1894: return s->rx_hook(s, 0);
1895:
1896: default:
1897: {
1898: int e = sk_recvmsg(s);
1899:
1900: if (e < 0)
1901: {
1902: if (errno != EINTR && errno != EAGAIN)
1903: s->err_hook(s, errno);
1904: return 0;
1905: }
1906:
1907: s->rpos = s->rbuf + e;
1908: s->rx_hook(s, e);
1909: return 1;
1910: }
1911: }
1912: }
1913:
1914: int
1915: sk_write(sock *s)
1916: {
1917: switch (s->type)
1918: {
1919: case SK_TCP_ACTIVE:
1920: {
1921: sockaddr sa;
1922: sockaddr_fill(&sa, s->af, s->daddr, s->iface, s->dport);
1923:
1924: if (connect(s->fd, &sa.sa, SA_LEN(sa)) >= 0 || errno == EISCONN)
1925: sk_tcp_connected(s);
1926: else if (errno != EINTR && errno != EAGAIN && errno != EINPROGRESS)
1927: s->err_hook(s, errno);
1928: return 0;
1929: }
1930:
1931: #ifdef HAVE_LIBSSH
1932: case SK_SSH_ACTIVE:
1933: {
1934: switch (sk_ssh_connect(s))
1935: {
1936: case SSH_OK:
1937: sk_ssh_connected(s);
1938: break;
1939:
1940: case SSH_AGAIN:
1941: return 1;
1942:
1943: case SSH_ERROR:
1944: s->err = ssh_get_error(s->ssh->session);
1945: s->err_hook(s, ssh_get_error_code(s->ssh->session));
1946: break;
1947: }
1948: return 0;
1949: }
1950: #endif
1951:
1952: default:
1953: if (s->ttx != s->tpos && sk_maybe_write(s) > 0)
1954: {
1955: if (s->tx_hook)
1956: s->tx_hook(s);
1957: return 1;
1958: }
1959: return 0;
1960: }
1961: }
1962:
1963: int sk_is_ipv4(sock *s)
1964: { return s->af == AF_INET; }
1965:
1966: int sk_is_ipv6(sock *s)
1967: { return s->af == AF_INET6; }
1968:
1969: void
1970: sk_err(sock *s, int revents)
1971: {
1972: int se = 0, sse = sizeof(se);
1973: if ((s->type != SK_MAGIC) && (revents & POLLERR))
1974: if (getsockopt(s->fd, SOL_SOCKET, SO_ERROR, &se, &sse) < 0)
1975: {
1976: log(L_ERR "IO: Socket error: SO_ERROR: %m");
1977: se = 0;
1978: }
1979:
1980: s->err_hook(s, se);
1981: }
1982:
1983: void
1984: sk_dump_all(void)
1985: {
1986: node *n;
1987: sock *s;
1988:
1989: debug("Open sockets:\n");
1990: WALK_LIST(n, sock_list)
1991: {
1992: s = SKIP_BACK(sock, n, n);
1993: debug("%p ", s);
1994: sk_dump(&s->r);
1995: }
1996: debug("\n");
1997: }
1998:
1999:
2000: /*
2001: * Internal event log and watchdog
2002: */
2003:
2004: #define EVENT_LOG_LENGTH 32
2005:
2006: struct event_log_entry
2007: {
2008: void *hook;
2009: void *data;
2010: btime timestamp;
2011: btime duration;
2012: };
2013:
2014: static struct event_log_entry event_log[EVENT_LOG_LENGTH];
2015: static struct event_log_entry *event_open;
2016: static int event_log_pos, event_log_num, watchdog_active;
2017: static btime last_time;
2018: static btime loop_time;
2019:
2020: static void
2021: io_update_time(void)
2022: {
2023: struct timespec ts;
2024: int rv;
2025:
2026: /*
2027: * This is third time-tracking procedure (after update_times() above and
2028: * times_update() in BFD), dedicated to internal event log and latency
2029: * tracking. Hopefully, we consolidate these sometimes.
2030: */
2031:
2032: rv = clock_gettime(CLOCK_MONOTONIC, &ts);
2033: if (rv < 0)
2034: die("clock_gettime: %m");
2035:
2036: last_time = ts.tv_sec S + ts.tv_nsec NS;
2037:
2038: if (event_open)
2039: {
2040: event_open->duration = last_time - event_open->timestamp;
2041:
2042: if (event_open->duration > config->latency_limit)
2043: log(L_WARN "Event 0x%p 0x%p took %d ms",
2044: event_open->hook, event_open->data, (int) (event_open->duration TO_MS));
2045:
2046: event_open = NULL;
2047: }
2048: }
2049:
2050: /**
2051: * io_log_event - mark approaching event into event log
2052: * @hook: event hook address
2053: * @data: event data address
2054: *
2055: * Store info (hook, data, timestamp) about the following internal event into
2056: * a circular event log (@event_log). When latency tracking is enabled, the log
2057: * entry is kept open (in @event_open) so the duration can be filled later.
2058: */
2059: void
2060: io_log_event(void *hook, void *data)
2061: {
2062: if (config->latency_debug)
2063: io_update_time();
2064:
2065: struct event_log_entry *en = event_log + event_log_pos;
2066:
2067: en->hook = hook;
2068: en->data = data;
2069: en->timestamp = last_time;
2070: en->duration = 0;
2071:
2072: event_log_num++;
2073: event_log_pos++;
2074: event_log_pos %= EVENT_LOG_LENGTH;
2075:
2076: event_open = config->latency_debug ? en : NULL;
2077: }
2078:
2079: static inline void
2080: io_close_event(void)
2081: {
2082: if (event_open)
2083: io_update_time();
2084: }
2085:
2086: void
2087: io_log_dump(void)
2088: {
2089: int i;
2090:
2091: log(L_DEBUG "Event log:");
2092: for (i = 0; i < EVENT_LOG_LENGTH; i++)
2093: {
2094: struct event_log_entry *en = event_log + (event_log_pos + i) % EVENT_LOG_LENGTH;
2095: if (en->hook)
2096: log(L_DEBUG " Event 0x%p 0x%p at %8d for %d ms", en->hook, en->data,
2097: (int) ((last_time - en->timestamp) TO_MS), (int) (en->duration TO_MS));
2098: }
2099: }
2100:
2101: void
2102: watchdog_sigalrm(int sig UNUSED)
2103: {
2104: /* Update last_time and duration, but skip latency check */
2105: config->latency_limit = 0xffffffff;
2106: io_update_time();
2107:
2108: /* We want core dump */
2109: abort();
2110: }
2111:
2112: static inline void
2113: watchdog_start1(void)
2114: {
2115: io_update_time();
2116:
2117: loop_time = last_time;
2118: }
2119:
2120: static inline void
2121: watchdog_start(void)
2122: {
2123: io_update_time();
2124:
2125: loop_time = last_time;
2126: event_log_num = 0;
2127:
2128: if (config->watchdog_timeout)
2129: {
2130: alarm(config->watchdog_timeout);
2131: watchdog_active = 1;
2132: }
2133: }
2134:
2135: static inline void
2136: watchdog_stop(void)
2137: {
2138: io_update_time();
2139:
2140: if (watchdog_active)
2141: {
2142: alarm(0);
2143: watchdog_active = 0;
2144: }
2145:
2146: btime duration = last_time - loop_time;
2147: if (duration > config->watchdog_warning)
2148: log(L_WARN "I/O loop cycle took %d ms for %d events",
2149: (int) (duration TO_MS), event_log_num);
2150: }
2151:
2152:
2153: /*
2154: * Main I/O Loop
2155: */
2156:
2157: void
2158: io_init(void)
2159: {
2160: init_list(&sock_list);
2161: init_list(&global_event_list);
2162: krt_io_init();
2163: // XXX init_times();
2164: // XXX update_times();
2165: boot_time = current_time();
2166:
2167: u64 now = (u64) current_real_time();
2168: srandom((uint) (now ^ (now >> 32)));
2169: }
2170:
2171: static int short_loops = 0;
2172: #define SHORT_LOOP_MAX 10
2173:
2174: void
2175: io_loop(void)
2176: {
2177: int poll_tout, timeout;
2178: int nfds, events, pout;
2179: timer *t;
2180: sock *s;
2181: node *n;
2182: int fdmax = 256;
2183: struct pollfd *pfd = xmalloc(fdmax * sizeof(struct pollfd));
2184:
2185: watchdog_start1();
2186: for(;;)
2187: {
2188: times_update(&main_timeloop);
2189: events = ev_run_list(&global_event_list);
2190: timers_fire(&main_timeloop);
2191: io_close_event();
2192:
2193: // FIXME
2194: poll_tout = (events ? 0 : 3000); /* Time in milliseconds */
2195: if (t = timers_first(&main_timeloop))
2196: {
2197: times_update(&main_timeloop);
2198: timeout = (tm_remains(t) TO_MS) + 1;
2199: poll_tout = MIN(poll_tout, timeout);
2200: }
2201:
2202: nfds = 0;
2203: WALK_LIST(n, sock_list)
2204: {
2205: pfd[nfds] = (struct pollfd) { .fd = -1 }; /* everything other set to 0 by this */
2206: s = SKIP_BACK(sock, n, n);
2207: if (s->rx_hook)
2208: {
2209: pfd[nfds].fd = s->fd;
2210: pfd[nfds].events |= POLLIN;
2211: }
2212: if (s->tx_hook && s->ttx != s->tpos)
2213: {
2214: pfd[nfds].fd = s->fd;
2215: pfd[nfds].events |= POLLOUT;
2216: }
2217: if (pfd[nfds].fd != -1)
2218: {
2219: s->index = nfds;
2220: nfds++;
2221: }
2222: else
2223: s->index = -1;
2224:
2225: if (nfds >= fdmax)
2226: {
2227: fdmax *= 2;
2228: pfd = xrealloc(pfd, fdmax * sizeof(struct pollfd));
2229: }
2230: }
2231:
2232: /*
2233: * Yes, this is racy. But even if the signal comes before this test
2234: * and entering poll(), it gets caught on the next timer tick.
2235: */
2236:
2237: if (async_config_flag)
2238: {
2239: io_log_event(async_config, NULL);
2240: async_config();
2241: async_config_flag = 0;
2242: continue;
2243: }
2244: if (async_dump_flag)
2245: {
2246: io_log_event(async_dump, NULL);
2247: async_dump();
2248: async_dump_flag = 0;
2249: continue;
2250: }
2251: if (async_shutdown_flag)
2252: {
2253: io_log_event(async_shutdown, NULL);
2254: async_shutdown();
2255: async_shutdown_flag = 0;
2256: continue;
2257: }
2258:
2259: /* And finally enter poll() to find active sockets */
2260: watchdog_stop();
2261: pout = poll(pfd, nfds, poll_tout);
2262: watchdog_start();
2263:
2264: if (pout < 0)
2265: {
2266: if (errno == EINTR || errno == EAGAIN)
2267: continue;
2268: die("poll: %m");
2269: }
2270: if (pout)
2271: {
2272: times_update(&main_timeloop);
2273:
2274: /* guaranteed to be non-empty */
2275: current_sock = SKIP_BACK(sock, n, HEAD(sock_list));
2276:
2277: while (current_sock)
2278: {
2279: sock *s = current_sock;
2280: if (s->index == -1)
2281: {
2282: current_sock = sk_next(s);
2283: goto next;
2284: }
2285:
2286: int e;
2287: int steps;
2288:
2289: steps = MAX_STEPS;
2290: if (s->fast_rx && (pfd[s->index].revents & POLLIN) && s->rx_hook)
2291: do
2292: {
2293: steps--;
2294: io_log_event(s->rx_hook, s->data);
2295: e = sk_read(s, pfd[s->index].revents);
2296: if (s != current_sock)
2297: goto next;
2298: }
2299: while (e && s->rx_hook && steps);
2300:
2301: steps = MAX_STEPS;
2302: if (pfd[s->index].revents & POLLOUT)
2303: do
2304: {
2305: steps--;
2306: io_log_event(s->tx_hook, s->data);
2307: e = sk_write(s);
2308: if (s != current_sock)
2309: goto next;
2310: }
2311: while (e && steps);
2312:
2313: current_sock = sk_next(s);
2314: next: ;
2315: }
2316:
2317: short_loops++;
2318: if (events && (short_loops < SHORT_LOOP_MAX))
2319: continue;
2320: short_loops = 0;
2321:
2322: int count = 0;
2323: current_sock = stored_sock;
2324: if (current_sock == NULL)
2325: current_sock = SKIP_BACK(sock, n, HEAD(sock_list));
2326:
2327: while (current_sock && count < MAX_RX_STEPS)
2328: {
2329: sock *s = current_sock;
2330: if (s->index == -1)
2331: {
2332: current_sock = sk_next(s);
2333: goto next2;
2334: }
2335:
2336: if (!s->fast_rx && (pfd[s->index].revents & POLLIN) && s->rx_hook)
2337: {
2338: count++;
2339: io_log_event(s->rx_hook, s->data);
2340: sk_read(s, pfd[s->index].revents);
2341: if (s != current_sock)
2342: goto next2;
2343: }
2344:
2345: if (pfd[s->index].revents & (POLLHUP | POLLERR))
2346: {
2347: sk_err(s, pfd[s->index].revents);
2348: if (s != current_sock)
2349: goto next2;
2350: }
2351:
2352: current_sock = sk_next(s);
2353: next2: ;
2354: }
2355:
2356:
2357: stored_sock = current_sock;
2358: }
2359: }
2360: }
2361:
2362: void
2363: test_old_bird(char *path)
2364: {
2365: int fd;
2366: struct sockaddr_un sa;
2367:
2368: fd = socket(AF_UNIX, SOCK_STREAM, 0);
2369: if (fd < 0)
2370: die("Cannot create socket: %m");
2371: if (strlen(path) >= sizeof(sa.sun_path))
2372: die("Socket path too long");
2373: bzero(&sa, sizeof(sa));
2374: sa.sun_family = AF_UNIX;
2375: strcpy(sa.sun_path, path);
2376: if (connect(fd, (struct sockaddr *) &sa, SUN_LEN(&sa)) == 0)
2377: die("I found another BIRD running.");
2378: close(fd);
2379: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to io.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / bird2 / sysdep / unix