int kernel_callback(int (*fn)(int, void*), void *closure) { int rc; int changed = 0; kdebugf("\nReceived changes in kernel tables.\n"); if(nl_listen.sock < 0) { rc = kernel_setup_socket(1); if(rc < 0) { perror("kernel_callback: kernel_setup_socket(1)"); return -1; } } rc = netlink_read(&nl_listen, &nl_command, 0, filter_netlink, &changed); if(rc < 0 && nl_listen.sock < 0) kernel_setup_socket(1); /* if netlink return 0 (found something interesting) */ /* or -1 (i.e. IO error), we call... back ! */ if(rc) return fn(changed, closure); return 0; }
int kernel_callback(int (*fn)(int, void*), void *closure) { int rc; if(kernel_socket < 0) kernel_setup_socket(1); kdebugf("Reading kernel table modification."); rc = socket_read(kernel_socket); if(rc) return fn(~0, closure); return 0; }
int main(int argc, char **argv) { struct sockaddr_in6 sin6; int rc, fd, i, opt; time_t expiry_time, source_expiry_time, kernel_dump_time; const char **config_files = NULL; int num_config_files = 0; void *vrc; unsigned int seed; struct interface *ifp; gettime(&now); rc = read_random_bytes(&seed, sizeof(seed)); if(rc < 0) { perror("read(random)"); seed = 42; } seed ^= (now.tv_sec ^ now.tv_usec); srandom(seed); parse_address("ff02:0:0:0:0:0:1:6", protocol_group, NULL); protocol_port = 6696; change_smoothing_half_life(4); has_ipv6_subtrees = kernel_has_ipv6_subtrees(); while(1) { opt = getopt(argc, argv, "m:p:h:H:i:k:A:sruS:d:g:G:lwz:M:t:T:c:C:DL:I:V"); if(opt < 0) break; switch(opt) { case 'm': rc = parse_address(optarg, protocol_group, NULL); if(rc < 0) goto usage; if(protocol_group[0] != 0xff) { fprintf(stderr, "%s is not a multicast address\n", optarg); goto usage; } if(protocol_group[1] != 2) { fprintf(stderr, "Warning: %s is not a link-local multicast address\n", optarg); } break; case 'p': protocol_port = parse_nat(optarg); if(protocol_port <= 0 || protocol_port > 0xFFFF) goto usage; break; case 'h': default_wireless_hello_interval = parse_thousands(optarg); if(default_wireless_hello_interval <= 0 || default_wireless_hello_interval > 0xFFFF * 10) goto usage; break; case 'H': default_wired_hello_interval = parse_thousands(optarg); if(default_wired_hello_interval <= 0 || default_wired_hello_interval > 0xFFFF * 10) goto usage; break; case 'k': kernel_metric = parse_nat(optarg); if(kernel_metric < 0 || kernel_metric > 0xFFFF) goto usage; break; case 'A': allow_duplicates = parse_nat(optarg); if(allow_duplicates < 0 || allow_duplicates > 0xFFFF) goto usage; break; case 's': split_horizon = 0; break; case 'r': random_id = 1; break; case 'u': keep_unfeasible = 1; break; case 'S': state_file = optarg; break; case 'd': debug = parse_nat(optarg); if(debug < 0) goto usage; break; case 'g': case 'G': if(opt == 'g') local_server_write = 0; else local_server_write = 1; if(optarg[0] == '/') { local_server_port = -1; free(local_server_path); local_server_path = strdup(optarg); } else { local_server_port = parse_nat(optarg); free(local_server_path); local_server_path = NULL; if(local_server_port <= 0 || local_server_port > 0xFFFF) goto usage; } break; case 'l': link_detect = 1; break; case 'w': all_wireless = 1; break; case 'z': { char *comma; diversity_kind = (int)strtol(optarg, &comma, 0); if(*comma == '\0') diversity_factor = 128; else if(*comma == ',') diversity_factor = parse_nat(comma + 1); else goto usage; if(diversity_factor <= 0 || diversity_factor > 256) goto usage; } break; case 'M': { int l = parse_nat(optarg); if(l < 0 || l > 3600) goto usage; change_smoothing_half_life(l); break; } case 't': export_table = parse_nat(optarg); if(export_table < 0 || export_table > 0xFFFF) goto usage; break; case 'T': if(add_import_table(parse_nat(optarg))) goto usage; break; case 'c': config_files = realloc(config_files, (num_config_files + 1) * sizeof(char*)); if(config_files == NULL) { fprintf(stderr, "Couldn't allocate config file.\n"); exit(1); } config_files[num_config_files++] = optarg; break; case 'C': rc = parse_config_from_string(optarg, strlen(optarg), NULL); if(rc != CONFIG_ACTION_DONE) { fprintf(stderr, "Couldn't parse configuration from command line.\n"); exit(1); } break; case 'D': do_daemonise = 1; break; case 'L': logfile = optarg; break; case 'I': pidfile = optarg; break; case 'V': fprintf(stderr, "%s\n", BABELD_VERSION); exit(0); break; default: goto usage; } } if(num_config_files == 0) { if(access("/etc/babeld.conf", F_OK) >= 0) { config_files = malloc(sizeof(char*)); if(config_files == NULL) { fprintf(stderr, "Couldn't allocate config file.\n"); exit(1); } config_files[num_config_files++] = "/etc/babeld.conf"; } } for(i = 0; i < num_config_files; i++) { int line; rc = parse_config_from_file(config_files[i], &line); if(rc < 0) { fprintf(stderr, "Couldn't parse configuration from file %s " "(error at line %d).\n", config_files[i], line); exit(1); } } free(config_files); if(default_wireless_hello_interval <= 0) default_wireless_hello_interval = 4000; default_wireless_hello_interval = MAX(default_wireless_hello_interval, 5); if(default_wired_hello_interval <= 0) default_wired_hello_interval = 4000; default_wired_hello_interval = MAX(default_wired_hello_interval, 5); resend_delay = 2000; resend_delay = MIN(resend_delay, default_wireless_hello_interval / 2); resend_delay = MIN(resend_delay, default_wired_hello_interval / 2); resend_delay = MAX(resend_delay, 20); if(do_daemonise) { if(logfile == NULL) logfile = "/var/log/babeld.log"; } rc = reopen_logfile(); if(rc < 0) { perror("reopen_logfile()"); exit(1); } fd = open("/dev/null", O_RDONLY); if(fd < 0) { perror("open(null)"); exit(1); } rc = dup2(fd, 0); if(rc < 0) { perror("dup2(null, 0)"); exit(1); } close(fd); if(do_daemonise) { rc = daemonise(); if(rc < 0) { perror("daemonise"); exit(1); } } if(pidfile && pidfile[0] != '\0') { int pfd, len; char buf[100]; len = snprintf(buf, 100, "%lu", (unsigned long)getpid()); if(len < 0 || len >= 100) { perror("snprintf(getpid)"); exit(1); } pfd = open(pidfile, O_WRONLY | O_CREAT | O_EXCL, 0644); if(pfd < 0) { char buf[40]; snprintf(buf, 40, "creat(%s)", pidfile); buf[39] = '\0'; perror(buf); exit(1); } rc = write(pfd, buf, len); if(rc < len) { perror("write(pidfile)"); goto fail_pid; } close(pfd); } rc = kernel_setup(1); if(rc < 0) { fprintf(stderr, "kernel_setup failed.\n"); goto fail_pid; } rc = kernel_setup_socket(1); if(rc < 0) { fprintf(stderr, "kernel_setup_socket failed.\n"); kernel_setup(0); goto fail_pid; } rc = finalise_config(); if(rc < 0) { fprintf(stderr, "Couldn't finalise configuration.\n"); goto fail; } for(i = optind; i < argc; i++) { vrc = add_interface(argv[i], NULL); if(vrc == NULL) goto fail; } if(interfaces == NULL) { fprintf(stderr, "Eek... asked to run on no interfaces!\n"); goto fail; } if(!have_id && !random_id) { /* We use all available interfaces here, since this increases the chances of getting a stable router-id in case the set of Babel interfaces changes. */ for(i = 1; i < 256; i++) { char buf[IF_NAMESIZE], *ifname; unsigned char eui[8]; ifname = if_indextoname(i, buf); if(ifname == NULL) continue; rc = if_eui64(ifname, i, eui); if(rc < 0) continue; memcpy(myid, eui, 8); have_id = 1; break; } } if(!have_id) { if(!random_id) fprintf(stderr, "Warning: couldn't find router id -- " "using random value.\n"); rc = read_random_bytes(myid, 8); if(rc < 0) { perror("read(random)"); goto fail; } /* Clear group and global bits */ myid[0] &= ~3; } myseqno = (random() & 0xFFFF); fd = open(state_file, O_RDONLY); if(fd < 0 && errno != ENOENT) perror("open(babel-state)"); rc = unlink(state_file); if(fd >= 0 && rc < 0) { perror("unlink(babel-state)"); /* If we couldn't unlink it, it's probably stale. */ close(fd); fd = -1; } if(fd >= 0) { char buf[100]; int s; rc = read(fd, buf, 99); if(rc < 0) { perror("read(babel-state)"); } else { buf[rc] = '\0'; rc = sscanf(buf, "%d\n", &s); if(rc == 1 && s >= 0 && s <= 0xFFFF) { myseqno = seqno_plus(s, 1); } else { fprintf(stderr, "Couldn't parse babel-state.\n"); } } close(fd); fd = -1; } protocol_socket = babel_socket(protocol_port); if(protocol_socket < 0) { perror("Couldn't create link local socket"); goto fail; } if(local_server_port >= 0) { local_server_socket = tcp_server_socket(local_server_port, 1); if(local_server_socket < 0) { perror("local_server_socket"); goto fail; } } else if(local_server_path) { local_server_socket = unix_server_socket(local_server_path); if(local_server_socket < 0) { perror("local_server_socket"); goto fail; } } init_signals(); rc = resize_receive_buffer(1500); if(rc < 0) goto fail; if(receive_buffer == NULL) goto fail; check_interfaces(); rc = check_xroutes(0); if(rc < 0) fprintf(stderr, "Warning: couldn't check exported routes.\n"); rc = check_rules(); if(rc < 0) fprintf(stderr, "Warning: couldn't check rules.\n"); kernel_routes_changed = 0; kernel_rules_changed = 0; kernel_link_changed = 0; kernel_addr_changed = 0; kernel_dump_time = now.tv_sec + roughly(30); schedule_neighbours_check(5000, 1); schedule_interfaces_check(30000, 1); expiry_time = now.tv_sec + roughly(30); source_expiry_time = now.tv_sec + roughly(300); /* Make some noise so that others notice us, and send retractions in case we were restarted recently */ FOR_ALL_INTERFACES(ifp) { if(!if_up(ifp)) continue; /* Apply jitter before we send the first message. */ usleep(roughly(10000)); gettime(&now); send_hello(ifp); send_wildcard_retraction(ifp); } FOR_ALL_INTERFACES(ifp) { if(!if_up(ifp)) continue; usleep(roughly(10000)); gettime(&now); send_hello(ifp); send_wildcard_retraction(ifp); send_self_update(ifp); send_request(ifp, NULL, 0, NULL, 0); flushupdates(ifp); flushbuf(ifp); } debugf("Entering main loop.\n"); while(1) { struct timeval tv; fd_set readfds; gettime(&now); tv = check_neighbours_timeout; timeval_min(&tv, &check_interfaces_timeout); timeval_min_sec(&tv, expiry_time); timeval_min_sec(&tv, source_expiry_time); timeval_min_sec(&tv, kernel_dump_time); timeval_min(&tv, &resend_time); FOR_ALL_INTERFACES(ifp) { if(!if_up(ifp)) continue; timeval_min(&tv, &ifp->flush_timeout); timeval_min(&tv, &ifp->hello_timeout); timeval_min(&tv, &ifp->update_timeout); timeval_min(&tv, &ifp->update_flush_timeout); } timeval_min(&tv, &unicast_flush_timeout); FD_ZERO(&readfds); if(timeval_compare(&tv, &now) > 0) { int maxfd = 0; timeval_minus(&tv, &tv, &now); FD_SET(protocol_socket, &readfds); maxfd = MAX(maxfd, protocol_socket); if(kernel_socket < 0) kernel_setup_socket(1); if(kernel_socket >= 0) { FD_SET(kernel_socket, &readfds); maxfd = MAX(maxfd, kernel_socket); } if(local_server_socket >= 0 && num_local_sockets < MAX_LOCAL_SOCKETS) { FD_SET(local_server_socket, &readfds); maxfd = MAX(maxfd, local_server_socket); } for(i = 0; i < num_local_sockets; i++) { FD_SET(local_sockets[i].fd, &readfds); maxfd = MAX(maxfd, local_sockets[i].fd); } rc = select(maxfd + 1, &readfds, NULL, NULL, &tv); if(rc < 0) { if(errno != EINTR) { perror("select"); sleep(1); } rc = 0; FD_ZERO(&readfds); } } gettime(&now); if(exiting) break; if(kernel_socket >= 0 && FD_ISSET(kernel_socket, &readfds)) { struct kernel_filter filter = {0}; filter.route = kernel_route_notify; filter.addr = kernel_addr_notify; filter.link = kernel_link_notify; filter.rule = kernel_rule_notify; kernel_callback(&filter); } if(FD_ISSET(protocol_socket, &readfds)) { rc = babel_recv(protocol_socket, receive_buffer, receive_buffer_size, (struct sockaddr*)&sin6, sizeof(sin6)); if(rc < 0) { if(errno != EAGAIN && errno != EINTR) { perror("recv"); sleep(1); } } else { FOR_ALL_INTERFACES(ifp) { if(!if_up(ifp)) continue; if(ifp->ifindex == sin6.sin6_scope_id) { parse_packet((unsigned char*)&sin6.sin6_addr, ifp, receive_buffer, rc); VALGRIND_MAKE_MEM_UNDEFINED(receive_buffer, receive_buffer_size); break; } } } } if(local_server_socket >= 0 && FD_ISSET(local_server_socket, &readfds)) accept_local_connections(); i = 0; while(i < num_local_sockets) { if(FD_ISSET(local_sockets[i].fd, &readfds)) { rc = local_read(&local_sockets[i]); if(rc <= 0) { if(rc < 0) { if(errno == EINTR || errno == EAGAIN) continue; perror("read(local_socket)"); } local_socket_destroy(i); } } i++; } if(reopening) { kernel_dump_time = now.tv_sec; check_neighbours_timeout = now; expiry_time = now.tv_sec; rc = reopen_logfile(); if(rc < 0) { perror("reopen_logfile"); break; } reopening = 0; } if(kernel_link_changed || kernel_addr_changed) { check_interfaces(); kernel_link_changed = 0; } if(kernel_routes_changed || kernel_addr_changed || kernel_rules_changed || now.tv_sec >= kernel_dump_time) { rc = check_xroutes(1); if(rc < 0) fprintf(stderr, "Warning: couldn't check exported routes.\n"); rc = check_rules(); if(rc < 0) fprintf(stderr, "Warning: couldn't check rules.\n"); kernel_routes_changed = kernel_rules_changed = kernel_addr_changed = 0; if(kernel_socket >= 0) kernel_dump_time = now.tv_sec + roughly(300); else kernel_dump_time = now.tv_sec + roughly(30); } if(timeval_compare(&check_neighbours_timeout, &now) < 0) { int msecs; msecs = check_neighbours(); /* Multiply by 3/2 to allow neighbours to expire. */ msecs = MAX(3 * msecs / 2, 10); schedule_neighbours_check(msecs, 1); } if(timeval_compare(&check_interfaces_timeout, &now) < 0) { check_interfaces(); schedule_interfaces_check(30000, 1); } if(now.tv_sec >= expiry_time) { expire_routes(); expire_resend(); expiry_time = now.tv_sec + roughly(30); } if(now.tv_sec >= source_expiry_time) { expire_sources(); source_expiry_time = now.tv_sec + roughly(300); } FOR_ALL_INTERFACES(ifp) { if(!if_up(ifp)) continue; if(timeval_compare(&now, &ifp->hello_timeout) >= 0) send_hello(ifp); if(timeval_compare(&now, &ifp->update_timeout) >= 0) send_update(ifp, 0, NULL, 0, NULL, 0); if(timeval_compare(&now, &ifp->update_flush_timeout) >= 0) flushupdates(ifp); } if(resend_time.tv_sec != 0) { if(timeval_compare(&now, &resend_time) >= 0) do_resend(); } if(unicast_flush_timeout.tv_sec != 0) { if(timeval_compare(&now, &unicast_flush_timeout) >= 0) flush_unicast(1); } FOR_ALL_INTERFACES(ifp) { if(!if_up(ifp)) continue; if(ifp->flush_timeout.tv_sec != 0) { if(timeval_compare(&now, &ifp->flush_timeout) >= 0) flushbuf(ifp); } } if(UNLIKELY(debug || dumping)) { dump_tables(stdout); dumping = 0; } }
int kernel_route(int operation, const unsigned char *dest, unsigned short plen, const unsigned char *gate, int ifindex, unsigned int metric, const unsigned char *newgate, int newifindex, unsigned int newmetric) { struct { struct rt_msghdr m_rtm; char m_space[512]; } msg; char *data = msg.m_space; int rc, ipv4; char local6[1][1][16] = IN6ADDR_LOOPBACK_INIT; char local4[1][1][16] = {{{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7f, 0x00, 0x00, 0x01 }}}; /* Check that the protocol family is consistent. */ if(plen >= 96 && v4mapped(dest)) { if(!v4mapped(gate)) { errno = EINVAL; return -1; } ipv4 = 1; } else { if(v4mapped(gate)) { errno = EINVAL; return -1; } ipv4 = 0; } if(operation == ROUTE_MODIFY && newmetric == metric && memcmp(newgate, gate, 16) == 0 && newifindex == ifindex) return 0; if(operation == ROUTE_MODIFY) { /* Avoid atomic route changes that is buggy on OS X. */ kernel_route(ROUTE_FLUSH, dest, plen, gate, ifindex, metric, NULL, 0, 0); return kernel_route(ROUTE_ADD, dest, plen, newgate, newifindex, newmetric, NULL, 0, 0); } kdebugf("kernel_route: %s %s/%d metric %d dev %d nexthop %s\n", operation == ROUTE_ADD ? "add" : operation == ROUTE_FLUSH ? "flush" : "change", format_address(dest), plen, metric, ifindex, format_address(gate)); if(kernel_socket < 0) kernel_setup_socket(1); memset(&msg, 0, sizeof(msg)); msg.m_rtm.rtm_version = RTM_VERSION; switch(operation) { case ROUTE_FLUSH: msg.m_rtm.rtm_type = RTM_DELETE; break; case ROUTE_ADD: msg.m_rtm.rtm_type = RTM_ADD; break; case ROUTE_MODIFY: msg.m_rtm.rtm_type = RTM_CHANGE; break; default: return -1; }; msg.m_rtm.rtm_index = ifindex; msg.m_rtm.rtm_flags = RTF_UP | RTF_PROTO2; if(plen == 128) msg.m_rtm.rtm_flags |= RTF_HOST; if(metric == KERNEL_INFINITY) { msg.m_rtm.rtm_flags |= RTF_BLACKHOLE; if(ifindex_lo < 0) { ifindex_lo = if_nametoindex("lo0"); if(ifindex_lo <= 0) return -1; } msg.m_rtm.rtm_index = ifindex_lo; } msg.m_rtm.rtm_seq = ++seq; msg.m_rtm.rtm_addrs = RTA_DST | RTA_GATEWAY; if(plen != 128) msg.m_rtm.rtm_addrs |= RTA_NETMASK; #define PUSHEUI(ifindex) \ do { char ifname[IFNAMSIZ]; \ struct sockaddr_dl *sdl = (struct sockaddr_dl*) data; \ if(!if_indextoname((ifindex), ifname)) \ return -1; \ if(get_sdl(sdl, ifname) < 0) \ return -1; \ data = data + ROUNDUP(sdl->sdl_len); \ } while (0) #define PUSHADDR(src) \ do { struct sockaddr_in *sin = (struct sockaddr_in*) data; \ sin->sin_len = sizeof(struct sockaddr_in); \ sin->sin_family = AF_INET; \ memcpy(&sin->sin_addr, (src) + 12, 4); \ data = data + ROUNDUP(sin->sin_len); \ } while (0) #define PUSHADDR6(src) \ do { struct sockaddr_in6 *sin6 = (struct sockaddr_in6*) data; \ sin6->sin6_len = sizeof(struct sockaddr_in6); \ sin6->sin6_family = AF_INET6; \ memcpy(&sin6->sin6_addr, (src), 16); \ if(IN6_IS_ADDR_LINKLOCAL (&sin6->sin6_addr)) \ SET_IN6_LINKLOCAL_IFINDEX (sin6->sin6_addr, ifindex); \ data = data + ROUNDUP(sin6->sin6_len); \ } while (0) /* KAME ipv6 stack does not support IPv4 mapped IPv6, so we have to * duplicate the codepath */ if(ipv4) { PUSHADDR(dest); if (metric == KERNEL_INFINITY) { PUSHADDR(**local4); } else if(plen == 128 && memcmp(dest+12, gate+12, 4) == 0) { #if defined(RTF_CLONING) msg.m_rtm.rtm_flags |= RTF_CLONING; #endif PUSHEUI(ifindex); } else { msg.m_rtm.rtm_flags |= RTF_GATEWAY; PUSHADDR(gate); } if((msg.m_rtm.rtm_addrs & RTA_NETMASK) != 0) { struct in6_addr tmp_sin6_addr; plen2mask(plen, &tmp_sin6_addr); PUSHADDR((char *)&tmp_sin6_addr); } } else { PUSHADDR6(dest); if (metric == KERNEL_INFINITY) { PUSHADDR6(**local6); } else { msg.m_rtm.rtm_flags |= RTF_GATEWAY; PUSHADDR6(gate); } if((msg.m_rtm.rtm_addrs & RTA_NETMASK) != 0) { struct in6_addr tmp_sin6_addr; plen2mask(plen, &tmp_sin6_addr); PUSHADDR6((char*)&tmp_sin6_addr); } } #undef PUSHEUI #undef PUSHADDR #undef PUSHADDR6 msg.m_rtm.rtm_msglen = data - (char *)&msg; rc = write(kernel_socket, (char*)&msg, msg.m_rtm.rtm_msglen); if (rc < msg.m_rtm.rtm_msglen) return -1; return 1; }
int kernel_route(int operation, const unsigned char *dest, unsigned short plen, const unsigned char *gate, int ifindex, unsigned int metric, const unsigned char *newgate, int newifindex, unsigned int newmetric) { unsigned char msg[512]; struct rt_msghdr *rtm; struct sockaddr_in6 *sin6; struct sockaddr_in *sin; int rc, len, ipv4; char local6[1][1][16] = IN6ADDR_LOOPBACK_INIT; char local4[1][1][16] = {{{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7f, 0x00, 0x00, 0x01 }}}; /* Check that the protocol family is consistent. */ if(plen >= 96 && v4mapped(dest)) { if(!v4mapped(gate)) { errno = EINVAL; return -1; } ipv4 = 1; } else { if(v4mapped(gate)) { errno = EINVAL; return -1; } ipv4 = 0; } if(operation == ROUTE_MODIFY && newmetric == metric && memcmp(newgate, gate, 16) == 0 && newifindex == ifindex) return 0; if(operation == ROUTE_MODIFY) { metric = newmetric; gate = newgate; ifindex = newifindex; } kdebugf("kernel_route: %s %s/%d metric %d dev %d nexthop %s\n", operation == ROUTE_ADD ? "add" : operation == ROUTE_FLUSH ? "flush" : "change", format_address(dest), plen, metric, ifindex, format_address(gate)); if(kernel_socket < 0) kernel_setup_socket(1); memset(&msg, 0, sizeof(msg)); rtm = (struct rt_msghdr *)msg; rtm->rtm_version = RTM_VERSION; switch(operation) { case ROUTE_FLUSH: rtm->rtm_type = RTM_DELETE; break; case ROUTE_ADD: rtm->rtm_type = RTM_ADD; break; case ROUTE_MODIFY: rtm->rtm_type = RTM_CHANGE; break; default: return -1; }; rtm->rtm_index = ifindex; rtm->rtm_flags = RTF_UP | RTF_PROTO2; if(plen == 128) rtm->rtm_flags |= RTF_HOST; /* if(memcmp(nexthop->id, dest, 16) == 0) { */ /* rtm -> rtm_flags |= RTF_LLINFO; */ /* rtm -> rtm_flags |= RTF_CLONING; */ /* } else { */ rtm->rtm_flags |= RTF_GATEWAY; /* } */ if(metric == KERNEL_INFINITY) { rtm->rtm_flags |= RTF_BLACKHOLE; if(ifindex_lo < 0) { ifindex_lo = if_nametoindex("lo0"); if(ifindex_lo <= 0) return -1; } rtm->rtm_index = ifindex_lo; } rtm->rtm_seq = ++seq; rtm->rtm_addrs = RTA_DST | RTA_GATEWAY; if(!(operation == ROUTE_MODIFY && plen == 128)) { rtm->rtm_addrs |= RTA_NETMASK; } #define push_sockaddr_in(ptr, offset) \ do { (ptr) = (struct sockaddr_in *)((char *)(ptr) + (offset)); \ (ptr)->sin_len = sizeof(struct sockaddr_in); \ (ptr)->sin_family = AF_INET; } while (0) #define get_sin_addr(dst,src) \ do { memcpy((dst), (src) + 12, 4); } while (0) #define push_sockaddr_in6(ptr, offset) \ do { (ptr) = (struct sockaddr_in6 *)((char *)(ptr) + (offset)); \ (ptr)->sin6_len = sizeof(struct sockaddr_in6); \ (ptr)->sin6_family = AF_INET6; } while (0) #define get_sin6_addr(dst,src) \ do { memcpy((dst), (src), 16); } while (0) /* KAME ipv6 stack does not support IPv4 mapped IPv6, so we have to * duplicate the codepath */ if(ipv4) { sin = (struct sockaddr_in *)msg; /* destination */ push_sockaddr_in(sin, sizeof(*rtm)); get_sin_addr(&(sin->sin_addr), dest); /* gateway */ push_sockaddr_in(sin, ROUNDUP(sin->sin_len)); if (metric == KERNEL_INFINITY) get_sin_addr(&(sin->sin_addr),**local4); else get_sin_addr(&(sin->sin_addr),gate); /* netmask */ if((rtm->rtm_addrs | RTA_NETMASK) != 0) { struct in6_addr tmp_sin6_addr; push_sockaddr_in(sin, ROUNDUP(sin->sin_len)); plen2mask(plen, &tmp_sin6_addr); get_sin_addr(&(sin->sin_addr), (char *)&tmp_sin6_addr); } len = (char *)sin + ROUNDUP(sin->sin_len) - (char *)msg; } else { sin6 = (struct sockaddr_in6 *)msg; /* destination */ push_sockaddr_in6(sin6, sizeof(*rtm)); get_sin6_addr(&(sin6->sin6_addr), dest); /* gateway */ push_sockaddr_in6(sin6, ROUNDUP(sin6->sin6_len)); if (metric == KERNEL_INFINITY) get_sin6_addr(&(sin6->sin6_addr),**local6); else get_sin6_addr(&(sin6->sin6_addr),gate); if(IN6_IS_ADDR_LINKLOCAL (&sin6->sin6_addr)) SET_IN6_LINKLOCAL_IFINDEX (sin6->sin6_addr, ifindex); /* netmask */ if((rtm->rtm_addrs | RTA_NETMASK) != 0) { push_sockaddr_in6(sin6, ROUNDUP(sin6->sin6_len)); plen2mask(plen, &sin6->sin6_addr); } len = (char *)sin6 + ROUNDUP(sin6->sin6_len) - (char *)msg; } rtm->rtm_msglen = len; rc = write(kernel_socket, msg, rtm->rtm_msglen); if (rc < rtm->rtm_msglen) return -1; return 1; }