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