Skip to content

B
babeld
Commit 1c3b2bb8 authored by Matthieu Boutier's avatar Matthieu Boutier Committed by Juliusz Chroboczek
Browse files
Options

Rename struct network to interface and associated changes.

parent 5f40b621
Show whitespace changes
Inline Side-by-side
Showing with 700 additions and 701 deletions
babeld.c
View file @ 1c3b2bb8
......@@ -108,7 +108,7 @@ main(int argc, char **argv)
char *config_file = NULL;
void *vrc;
unsigned int seed;
struct network *net;
struct interface *ifp;
gettime(&now);
......@@ -362,22 +362,22 @@ main(int argc, char **argv)
}
for(i = optind; i < argc; i++) {
vrc = add_network(argv[i], NULL);
vrc = add_interface(argv[i], NULL);
if(vrc == NULL)
goto fail;
}
if(networks == NULL) {
if(interfaces == NULL) {
fprintf(stderr, "Eek... asked to run on no interfaces!\n");
goto fail;
}
FOR_ALL_NETS(net) {
/* net->ifindex is not necessarily valid at this point */
int ifindex = if_nametoindex(net->ifname);
FOR_ALL_INTERFACES(ifp) {
/* ifp->ifindex is not necessarily valid at this point */
int ifindex = if_nametoindex(ifp->name);
if(ifindex > 0) {
unsigned char eui[8];
rc = if_eui64(net->ifname, ifindex, eui);
rc = if_eui64(ifp->name, ifindex, eui);
if(rc < 0)
continue;
memcpy(myid, eui, 8);
......@@ -482,7 +482,7 @@ main(int argc, char **argv)
rc = resize_receive_buffer(1500);
if(rc < 0)
goto fail;
check_networks();
check_interfaces();
if(receive_buffer == NULL)
goto fail;
......@@ -499,27 +499,27 @@ main(int argc, char **argv)
/* Make some noise so that others notice us, and send retractions in
case we were restarted recently */
FOR_ALL_NETS(net) {
if(!net_up(net))
FOR_ALL_INTERFACES(ifp) {
if(!if_up(ifp))
continue;
/* Apply jitter before we send the first message. */
usleep(roughly(10000));
gettime(&now);
send_hello(net);
send_wildcard_retraction(net);
send_hello(ifp);
send_wildcard_retraction(ifp);
}
FOR_ALL_NETS(net) {
if(!net_up(net))
FOR_ALL_INTERFACES(ifp) {
if(!if_up(ifp))
continue;
usleep(roughly(10000));
gettime(&now);
send_hello(net);
send_wildcard_retraction(net);
send_self_update(net);
send_request(net, NULL, 0);
flushupdates(net);
flushbuf(net);
send_hello(ifp);
send_wildcard_retraction(ifp);
send_self_update(ifp);
send_request(ifp, NULL, 0);
flushupdates(ifp);
flushbuf(ifp);
}
debugf("Entering main loop.\n");
......@@ -535,13 +535,13 @@ main(int argc, char **argv)
timeval_min_sec(&tv, source_expiry_time);
timeval_min_sec(&tv, kernel_dump_time);
timeval_min(&tv, &resend_time);
FOR_ALL_NETS(net) {
if(!net_up(net))
FOR_ALL_INTERFACES(ifp) {
if(!if_up(ifp))
continue;
timeval_min(&tv, &net->flush_timeout);
timeval_min(&tv, &net->hello_timeout);
timeval_min(&tv, &net->update_timeout);
timeval_min(&tv, &net->update_flush_timeout);
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);
......@@ -593,11 +593,11 @@ main(int argc, char **argv)
sleep(1);
}
} else {
FOR_ALL_NETS(net) {
if(!net_up(net))
FOR_ALL_INTERFACES(ifp) {
if(!if_up(ifp))
continue;
if(net->ifindex == sin6.sin6_scope_id) {
parse_packet((unsigned char*)&sin6.sin6_addr, net,
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);
......@@ -647,7 +647,7 @@ main(int argc, char **argv)
}
if(kernel_link_changed || kernel_addr_changed) {
check_networks();
check_interfaces();
kernel_link_changed = 0;
}
......@@ -671,7 +671,7 @@ main(int argc, char **argv)
}
if(now.tv_sec >= expiry_time) {
check_networks();
check_interfaces();
expire_routes();
expire_resend();
expiry_time = now.tv_sec + roughly(30);
......@@ -682,15 +682,15 @@ main(int argc, char **argv)
source_expiry_time = now.tv_sec + roughly(300);
}
FOR_ALL_NETS(net) {
if(!net_up(net))
FOR_ALL_INTERFACES(ifp) {
if(!if_up(ifp))
continue;
if(timeval_compare(&now, &net->hello_timeout) >= 0)
send_hello(net);
if(timeval_compare(&now, &net->update_timeout) >= 0)
send_update(net, 0, NULL, 0);
if(timeval_compare(&now, &net->update_flush_timeout) >= 0)
flushupdates(net);
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);
if(timeval_compare(&now, &ifp->update_flush_timeout) >= 0)
flushupdates(ifp);
}
if(resend_time.tv_sec != 0) {
......@@ -703,12 +703,12 @@ main(int argc, char **argv)
flush_unicast(1);
}
FOR_ALL_NETS(net) {
if(!net_up(net))
FOR_ALL_INTERFACES(ifp) {
if(!if_up(ifp))
continue;
if(net->flush_timeout.tv_sec != 0) {
if(timeval_compare(&now, &net->flush_timeout) >= 0)
flushbuf(net);
if(ifp->flush_timeout.tv_sec != 0) {
if(timeval_compare(&now, &ifp->flush_timeout) >= 0)
flushbuf(ifp);
}
}
......@@ -726,31 +726,31 @@ main(int argc, char **argv)
while(numroutes > 0) {
if(routes[0].installed)
uninstall_route(&routes[0]);
/* We need to flush the route so network_up won't reinstall it */
/* We need to flush the route so interface_up won't reinstall it */
flush_route(&routes[0]);
}
FOR_ALL_NETS(net) {
if(!net_up(net))
FOR_ALL_INTERFACES(ifp) {
if(!if_up(ifp))
continue;
send_wildcard_retraction(net);
send_wildcard_retraction(ifp);
/* Make sure that we expire quickly from our neighbours'
association caches. */
send_hello_noupdate(net, 10);
flushbuf(net);
send_hello_noupdate(ifp, 10);
flushbuf(ifp);
usleep(roughly(1000));
gettime(&now);
}
FOR_ALL_NETS(net) {
if(!net_up(net))
FOR_ALL_INTERFACES(ifp) {
if(!if_up(ifp))
continue;
/* Make sure they got it. */
send_wildcard_retraction(net);
send_hello_noupdate(net, 1);
flushbuf(net);
send_wildcard_retraction(ifp);
send_hello_noupdate(ifp, 1);
flushbuf(ifp);
usleep(roughly(10000));
gettime(&now);
network_up(net, 0);
interface_up(ifp, 0);
}
kernel_setup_socket(0);
kernel_setup(0);
......@@ -802,10 +802,10 @@ main(int argc, char **argv)
exit(1);
fail:
FOR_ALL_NETS(net) {
if(!net_up(net))
FOR_ALL_INTERFACES(ifp) {
if(!if_up(ifp))
continue;
network_up(net, 0);
interface_up(ifp, 0);
}
kernel_setup_socket(0);
kernel_setup(0);
......@@ -936,12 +936,12 @@ dump_tables(FILE *out)
FOR_ALL_NEIGHBOURS(neigh) {
fprintf(out, "Neighbour %s dev %s reach %04x rxcost %d txcost %d chan %d%s.\n",
format_address(neigh->address),
neigh->network->ifname,
neigh->ifp->name,
neigh->reach,
neighbour_rxcost(neigh),
neigh->txcost,
neigh->network->channel,
net_up(neigh->network) ? "" : " (down)");
neigh->ifp->channel,
if_up(neigh->ifp) ? "" : " (down)");
}
for(i = 0; i < numxroutes; i++) {
fprintf(out, "%s metric %d (exported)\n",
......@@ -980,7 +980,7 @@ dump_tables(FILE *out)
(int)routes[i].seqno,
channels,
(int)(now.tv_sec - routes[i].time),
routes[i].neigh->network->ifname,
routes[i].neigh->ifp->name,
format_address(routes[i].neigh->address),
nexthop ? " nexthop " : "",
nexthop ? format_address(nexthop) : "",
......
configuration.c
View file @ 1c3b2bb8
......@@ -40,7 +40,7 @@ THE SOFTWARE.
struct filter *input_filters = NULL;
struct filter *output_filters = NULL;
struct filter *redistribute_filters = NULL;
struct network_conf *network_confs = NULL;
struct interface_conf *interface_confs = NULL;
/* get_next_char callback */
typedef int (*gnc_t)(void*);
......@@ -370,15 +370,15 @@ parse_filter(gnc_t gnc, void *closure)
return NULL;
}
static struct network_conf *
parse_nconf(gnc_t gnc, void *closure)
static struct interface_conf *
parse_ifconf(gnc_t gnc, void *closure)
{
int c;
char *token;
struct network_conf *nconf;
struct interface_conf *if_conf;
nconf = calloc(1, sizeof(struct network_conf));
if(nconf == NULL)
if_conf = calloc(1, sizeof(struct interface_conf));
if(if_conf == NULL)
goto error;
c = gnc(closure);
......@@ -393,7 +393,7 @@ parse_nconf(gnc_t gnc, void *closure)
if(c < -1 || token == NULL)
goto error;
nconf->ifname = token;
if_conf->ifname = token;
while(c >= 0 && c != '\n') {
c = skip_whitespace(c, gnc, closure);
......@@ -410,43 +410,43 @@ parse_nconf(gnc_t gnc, void *closure)
c = getint(c, &cost, gnc, closure);
if(c < -1 || cost <= 0 || cost > 0xFFFF)
goto error;
nconf->cost = cost;
if_conf->cost = cost;
} else if(strcmp(token, "hello-interval") == 0) {
int interval;
c = getmsec(c, &interval, gnc, closure);
if(c < -1 || interval <= 0 || interval > 10 * 0xFFFF)
goto error;
nconf->hello_interval = interval;
if_conf->hello_interval = interval;
} else if(strcmp(token, "update-interval") == 0) {
int interval;
c = getmsec(c, &interval, gnc, closure);
if(c < -1 || interval <= 0 || interval > 10 * 0xFFFF)
goto error;
nconf->update_interval = interval;
if_conf->update_interval = interval;
} else if(strcmp(token, "wired") == 0) {
int v;
c = getbool(c, &v, gnc, closure);
if(c < -1)
goto error;
nconf->wired = v;
if_conf->wired = v;
} else if(strcmp(token, "faraway") == 0) {
int v;
c = getbool(c, &v, gnc, closure);
if(c < -1)
goto error;
nconf->faraway = v;
if_conf->faraway = v;
} else if(strcmp(token, "link-quality") == 0) {
int v;
c = getbool(c, &v, gnc, closure);
if(c < -1)
goto error;
nconf->lq = v;
if_conf->lq = v;
} else if(strcmp(token, "split-horizon") == 0) {
int v;
c = getbool(c, &v, gnc, closure);
if(c < -1)
goto error;
nconf->split_horizon = v;
if_conf->split_horizon = v;
} else if(strcmp(token, "channel") == 0) {
char *t, *end;
......@@ -455,19 +455,19 @@ parse_nconf(gnc_t gnc, void *closure)
goto error;
if(strcmp(t, "noninterfering") == 0)
nconf->channel = NET_CHANNEL_NONINTERFERING;
if_conf->channel = IF_CHANNEL_NONINTERFERING;
else if(strcmp(t, "interfering") == 0)
nconf->channel = NET_CHANNEL_INTERFERING;
if_conf->channel = IF_CHANNEL_INTERFERING;
else {
nconf->channel = strtol(t, &end, 0);
if_conf->channel = strtol(t, &end, 0);
if(*end != '\0')
goto error;
}
free(t);
if((nconf->channel < 1 || nconf->channel > 254) &&
nconf->channel != NET_CHANNEL_NONINTERFERING)
if((if_conf->channel < 1 || if_conf->channel > 254) &&
if_conf->channel != IF_CHANNEL_NONINTERFERING)
goto error;
} else {
goto error;
......@@ -475,10 +475,10 @@ parse_nconf(gnc_t gnc, void *closure)
free(token);
}
return nconf;
return if_conf;
error:
free(nconf);
free(if_conf);
return NULL;
}
......@@ -499,7 +499,7 @@ add_filter(struct filter *filter, struct filter **filters)
}
static void
merge_nconf(struct network_conf *dest, struct network_conf *src)
merge_ifconf(struct interface_conf *dest, struct interface_conf *src)
{
assert(strcmp(dest->ifname, src->ifname) == 0);
......@@ -520,24 +520,24 @@ merge_nconf(struct network_conf *dest, struct network_conf *src)
}
static void
add_nconf(struct network_conf *nconf, struct network_conf **nconfs)
add_ifconf(struct interface_conf *if_conf, struct interface_conf **if_confs)
{
if(*nconfs == NULL) {
nconf->next = NULL;
*nconfs = nconf;
if(*if_confs == NULL) {
if_conf->next = NULL;
*if_confs = if_conf;
} else {
struct network_conf *n;
n = *nconfs;
while(n->next) {
if(strcmp(n->ifname, nconf->ifname) == 0) {
merge_nconf(n, nconf);
free(nconf);
struct interface_conf *if_c;
if_c = *if_confs;
while(if_c->next) {
if(strcmp(if_c->ifname, if_conf->ifname) == 0) {
merge_ifconf(if_c, if_conf);
free(if_conf);
return;
}
n = n->next;
if_c = if_c->next;
}
nconf->next = NULL;
n->next = nconf;
if_conf->next = NULL;
if_c->next = if_conf;
}
}
......@@ -582,11 +582,11 @@ parse_config(gnc_t gnc, void *closure)
return -1;
add_filter(filter, &redistribute_filters);
} else if(strcmp(token, "interface") == 0) {
struct network_conf *nconf;
nconf = parse_nconf(gnc, closure);
if(nconf == NULL)
struct interface_conf *if_conf;
if_conf = parse_ifconf(gnc, closure);
if(if_conf == NULL)
return -1;
add_nconf(nconf, &network_confs);
add_ifconf(if_conf, &interface_confs);
} else {
return -1;
}
......@@ -759,15 +759,15 @@ finalise_config()
filter->plen_le = 128;
add_filter(filter, &redistribute_filters);
while(network_confs) {
struct network_conf *n;
while(interface_confs) {
struct interface_conf *if_conf;
void *vrc;
n = network_confs;
network_confs = network_confs->next;
n->next = NULL;
vrc = add_network(n->ifname, n);
if_conf = interface_confs;
interface_confs = interface_confs->next;
if_conf->next = NULL;
vrc = add_interface(if_conf->ifname, if_conf);
if(vrc == NULL) {
fprintf(stderr, "Couldn't add interface %s.\n", n->ifname);
fprintf(stderr, "Couldn't add interface %s.\n", if_conf->ifname);
return -1;
}
}
......
kernel_netlink.c
View file @ 1c3b2bb8
......@@ -1239,7 +1239,7 @@ filter_link(struct nlmsghdr *nh, void *data)
int ifindex;
char *ifname;
unsigned int ifflags;
struct network *net;
struct interface *ifp;
len = nh->nlmsg_len;
......@@ -1257,8 +1257,8 @@ filter_link(struct nlmsghdr *nh, void *data)
return 0;
kdebugf("filter_interfaces: link change on if %s(%d): 0x%x\n",
ifname, ifindex, (unsigned)ifflags);
FOR_ALL_NETS(net) {
if (strcmp(net->ifname, ifname) == 0)
FOR_ALL_INTERFACES(ifp) {
if (strcmp(ifp->name, ifname) == 0)
return 1;
}
return 0;
......
local.c
View file @ 1c3b2bb8
......@@ -140,7 +140,7 @@ local_notify_neighbour(struct neighbour *neigh, int kind)
address as a unique identifier. */
(unsigned long int)neigh,
format_address(neigh->address),
neigh->network->ifname,
neigh->ifp->name,
neigh->reach,
neighbour_rxcost(neigh),
neighbour_txcost(neigh),
......@@ -207,7 +207,7 @@ local_notify_route(struct route *route, int kind)
format_eui64(route->src->id),
route_metric(route), route->refmetric,
format_address(route->neigh->address),
route->neigh->network->ifname);
route->neigh->ifp->name);
if(rc < 0 || rc >= 512)
goto fail;
......
message.c
View file @ 1c3b2bb8
......@@ -182,7 +182,7 @@ channels_len(unsigned char *channels)
}
void
parse_packet(const unsigned char *from, struct network *net,
parse_packet(const unsigned char *from, struct interface *ifp,
const unsigned char *packet, int packetlen)
{
int i;
......@@ -203,18 +203,18 @@ parse_packet(const unsigned char *from, struct network *net,
if(packet[0] != 42) {
fprintf(stderr, "Received malformed packet on %s from %s.\n",
net->ifname, format_address(from));
ifp->name, format_address(from));
return;
}
if(packet[1] != 2) {
fprintf(stderr,
"Received packet with unknown version %d on %s from %s.\n",
packet[1], net->ifname, format_address(from));
packet[1], ifp->name, format_address(from));
return;
}
neigh = find_neighbour(from, net);
neigh = find_neighbour(from, ifp);
if(neigh == NULL) {
fprintf(stderr, "Couldn't allocate neighbour.\n");
return;
......@@ -234,7 +234,7 @@ parse_packet(const unsigned char *from, struct network *net,
type = message[0];
if(type == MESSAGE_PAD1) {
debugf("Received pad1 from %s on %s.\n",
format_address(from), net->ifname);
format_address(from), ifp->name);
i++;
continue;
}
......@@ -250,18 +250,18 @@ parse_packet(const unsigned char *from, struct network *net,
if(type == MESSAGE_PADN) {
debugf("Received pad%d from %s on %s.\n",
len, format_address(from), net->ifname);
len, format_address(from), ifp->name);
} else if(type == MESSAGE_ACK_REQ) {
unsigned short nonce, interval;
if(len < 6) goto fail;
DO_NTOHS(nonce, message + 4);
DO_NTOHS(interval, message + 6);
debugf("Received ack-req (%04X %d) from %s on %s.\n",
nonce, interval, format_address(from), net->ifname);
nonce, interval, format_address(from), ifp->name);
send_ack(neigh, nonce, interval);
} else if(type == MESSAGE_ACK) {
debugf("Received ack from %s on %s.\n",
format_address(from), net->ifname);
format_address(from), ifp->name);
/* Nothing right now */
} else if(type == MESSAGE_HELLO) {
unsigned short seqno, interval;
......@@ -271,9 +271,9 @@ parse_packet(const unsigned char *from, struct network *net,
DO_NTOHS(interval, message + 6);
debugf("Received hello %d (%d) from %s on %s.\n",
seqno, interval,
format_address(from), net->ifname);
net->activity_time = now.tv_sec;
update_hello_interval(net);
format_address(from), ifp->name);
ifp->activity_time = now.tv_sec;
update_hello_interval(ifp);
changed = update_neighbour(neigh, seqno, interval);
update_neighbour_metric(neigh, changed);
if(interval > 0)
......@@ -289,9 +289,9 @@ parse_packet(const unsigned char *from, struct network *net,
if(rc < 0) goto fail;
debugf("Received ihu %d (%d) from %s on %s for %s.\n",
txcost, interval,
format_address(from), net->ifname,
format_address(from), ifp->name,
format_address(address));
if(message[2] == 0 || network_ll_address(net, address)) {
if(message[2] == 0 || interface_ll_address(ifp, address)) {
int changed = txcost != neigh->txcost;
neigh->txcost = txcost;
neigh->ihu_time = now;
......@@ -308,7 +308,7 @@ parse_packet(const unsigned char *from, struct network *net,
memcpy(router_id, message + 4, 8);
have_router_id = 1;
debugf("Received router-id %s from %s on %s.\n",
format_eui64(router_id), format_address(from), net->ifname);
format_eui64(router_id), format_address(from), ifp->name);
} else if(type == MESSAGE_NH) {
unsigned char nh[16];
int rc;
......@@ -326,7 +326,7 @@ parse_packet(const unsigned char *from, struct network *net,
}
debugf("Received nh %s (%d) from %s on %s.\n",
format_address(nh), message[2],
format_address(from), net->ifname);
format_address(from), ifp->name);
if(message[2] == 1) {
memcpy(v4_nh, nh, 16);
have_v4_nh = 1;
......@@ -391,7 +391,7 @@ parse_packet(const unsigned char *from, struct network *net,
(message[3] & 0x80) ? "/prefix" : "",
(message[3] & 0x40) ? "/id" : "",
format_prefix(prefix, plen),
format_address(from), net->ifname);
format_address(from), ifp->name);
if(message[2] == 0) {
if(metric < 0xFFFF) {
......@@ -412,11 +412,11 @@ parse_packet(const unsigned char *from, struct network *net,
}
if(message[2] == 1) {
if(!net->ipv4)
if(!ifp->ipv4)
goto done;
}
if((net->flags & NET_FARAWAY)) {
if((ifp->flags & IF_FARAWAY)) {
channels[0] = 0;
} else {
/* This will be overwritten by parse_route_attributes below. */
......@@ -425,7 +425,7 @@ parse_packet(const unsigned char *from, struct network *net,
channels[0] = 0;
} else {
/* Assume interfering. */
channels[0] = NET_CHANNEL_INTERFERING;
channels[0] = IF_CHANNEL_INTERFERING;
channels[1] = 0;
}
......@@ -447,14 +447,14 @@ parse_packet(const unsigned char *from, struct network *net,
plen = message[3] + (message[2] == 1 ? 96 : 0);
debugf("Received request for %s from %s on %s.\n",
message[2] == 0 ? "any" : format_prefix(prefix, plen),
format_address(from), net->ifname);
format_address(from), ifp->name);
if(message[2] == 0) {
/* If a neighbour is requesting a full route dump from us,
we might as well send it an IHU. */
send_ihu(neigh, NULL);
send_update(neigh->network, 0, NULL, 0);
send_update(neigh->ifp, 0, NULL, 0);
} else {
send_update(neigh->network, 0, prefix, plen);
send_update(neigh->ifp, 0, prefix, plen);
}
} else if(type == MESSAGE_MH_REQUEST) {
unsigned char prefix[16], plen;
......@@ -469,13 +469,13 @@ parse_packet(const unsigned char *from, struct network *net,
debugf("Received request (%d) for %s from %s on %s (%s, %d).\n",
message[6],
format_prefix(prefix, plen),
format_address(from), net->ifname,
format_address(from), ifp->name,
format_eui64(message + 8), seqno);
handle_request(neigh, prefix, plen, message[6],
seqno, message + 8);
} else {
debugf("Received unknown packet type %d from %s on %s.\n",
type, format_address(from), net->ifname);
type, format_address(from), ifp->name);
}
done:
i += len + 2;
......@@ -483,7 +483,7 @@ parse_packet(const unsigned char *from, struct network *net,
fail:
fprintf(stderr, "Couldn't parse packet (%d, %d) from %s on %s.\n",
message[0], message[1], format_address(from), net->ifname);
message[0], message[1], format_address(from), ifp->name);
goto done;
}
return;
......@@ -494,20 +494,20 @@ parse_packet(const unsigned char *from, struct network *net,
should never trigger. But I'm superstitious. */
static int
check_bucket(struct network *net)
check_bucket(struct interface *ifp)
{
if(net->bucket <= 0) {
int seconds = now.tv_sec - net->bucket_time;
if(ifp->bucket <= 0) {
int seconds = now.tv_sec - ifp->bucket_time;
if(seconds > 0) {
net->bucket = MIN(BUCKET_TOKENS_MAX,
ifp->bucket = MIN(BUCKET_TOKENS_MAX,
seconds * BUCKET_TOKENS_PER_SEC);
}
/* Reset bucket time unconditionally, in case clock is stepped. */
net->bucket_time = now.tv_sec;
ifp->bucket_time = now.tv_sec;
}
if(net->bucket > 0) {
net->bucket--;
if(ifp->bucket > 0) {
ifp->bucket--;
return 1;
} else {
return 0;
......@@ -515,65 +515,65 @@ check_bucket(struct network *net)
}
void
flushbuf(struct network *net)
flushbuf(struct interface *ifp)
{
int rc;
struct sockaddr_in6 sin6;
assert(net->buffered <= net->bufsize);
assert(ifp->buffered <= ifp->bufsize);
flushupdates(net);
flushupdates(ifp);
if(net->buffered > 0) {
if(ifp->buffered > 0) {
debugf(" (flushing %d buffered bytes on %s)\n",
net->buffered, net->ifname);
if(check_bucket(net)) {
ifp->buffered, ifp->name);
if(check_bucket(ifp)) {
memset(&sin6, 0, sizeof(sin6));
sin6.sin6_family = AF_INET6;
memcpy(&sin6.sin6_addr, protocol_group, 16);
sin6.sin6_port = htons(protocol_port);
sin6.sin6_scope_id = net->ifindex;
DO_HTONS(packet_header + 2, net->buffered);
sin6.sin6_scope_id = ifp->ifindex;
DO_HTONS(packet_header + 2, ifp->buffered);
rc = babel_send(protocol_socket,
packet_header, sizeof(packet_header),
net->sendbuf, net->buffered,
ifp->sendbuf, ifp->buffered,
(struct sockaddr*)&sin6, sizeof(sin6));
if(rc < 0)
perror("send");
} else {
fprintf(stderr, "Warning: bucket full, dropping packet to %s.\n",
net->ifname);
ifp->name);
}
}
VALGRIND_MAKE_MEM_UNDEFINED(net->sendbuf, net->bufsize);
net->buffered = 0;
net->have_buffered_hello = 0;
net->have_buffered_id = 0;
net->have_buffered_nh = 0;
net->have_buffered_prefix = 0;
net->flush_timeout.tv_sec = 0;
net->flush_timeout.tv_usec = 0;
VALGRIND_MAKE_MEM_UNDEFINED(ifp->sendbuf, ifp->bufsize);
ifp->buffered = 0;
ifp->have_buffered_hello = 0;
ifp->have_buffered_id = 0;
ifp->have_buffered_nh = 0;
ifp->have_buffered_prefix = 0;
ifp->flush_timeout.tv_sec = 0;
ifp->flush_timeout.tv_usec = 0;
}
static void
schedule_flush(struct network *net)
schedule_flush(struct interface *ifp)
{
unsigned msecs = jitter(net, 0);
if(net->flush_timeout.tv_sec != 0 &&
timeval_minus_msec(&net->flush_timeout, &now) < msecs)
unsigned msecs = jitter(ifp, 0);
if(ifp->flush_timeout.tv_sec != 0 &&
timeval_minus_msec(&ifp->flush_timeout, &now) < msecs)
return;
set_timeout(&net->flush_timeout, msecs);
set_timeout(&ifp->flush_timeout, msecs);
}
static void
schedule_flush_now(struct network *net)
schedule_flush_now(struct interface *ifp)
{
/* Almost now */
unsigned msecs = roughly(10);
if(net->flush_timeout.tv_sec != 0 &&
timeval_minus_msec(&net->flush_timeout, &now) < msecs)
if(ifp->flush_timeout.tv_sec != 0 &&
timeval_minus_msec(&ifp->flush_timeout, &now) < msecs)
return;
set_timeout(&net->flush_timeout, msecs);
set_timeout(&ifp->flush_timeout, msecs);
}
static void
......@@ -590,49 +590,49 @@ schedule_unicast_flush(unsigned msecs)
}
static void
ensure_space(struct network *net, int space)
ensure_space(struct interface *ifp, int space)
{
if(net->bufsize - net->buffered < space)
flushbuf(net);
if(ifp->bufsize - ifp->buffered < space)
flushbuf(ifp);
}
static void
start_message(struct network *net, int type, int len)
start_message(struct interface *ifp, int type, int len)
{
if(net->bufsize - net->buffered < len + 2)
flushbuf(net);
net->sendbuf[net->buffered++] = type;
net->sendbuf[net->buffered++] = len;
if(ifp->bufsize - ifp->buffered < len + 2)
flushbuf(ifp);
ifp->sendbuf[ifp->buffered++] = type;
ifp->sendbuf[ifp->buffered++] = len;
}
static void
end_message(struct network *net, int type, int bytes)
end_message(struct interface *ifp, int type, int bytes)
{
assert(net->buffered >= bytes + 2 &&
net->sendbuf[net->buffered - bytes - 2] == type &&
net->sendbuf[net->buffered - bytes - 1] == bytes);
schedule_flush(net);
assert(ifp->buffered >= bytes + 2 &&
ifp->sendbuf[ifp->buffered - bytes - 2] == type &&
ifp->sendbuf[ifp->buffered - bytes - 1] == bytes);
schedule_flush(ifp);
}
static void
accumulate_byte(struct network *net, unsigned char value)
accumulate_byte(struct interface *ifp, unsigned char value)
{
net->sendbuf[net->buffered++] = value;
ifp->sendbuf[ifp->buffered++] = value;
}
static void
accumulate_short(struct network *net, unsigned short value)
accumulate_short(struct interface *ifp, unsigned short value)
{
DO_HTONS(net->sendbuf + net->buffered, value);
net->buffered += 2;
DO_HTONS(ifp->sendbuf + ifp->buffered, value);
ifp->buffered += 2;
}
static void
accumulate_bytes(struct network *net,
accumulate_bytes(struct interface *ifp,
const unsigned char *value, unsigned len)
{
memcpy(net->sendbuf + net->buffered, value, len);
net->buffered += len;
memcpy(ifp->sendbuf + ifp->buffered, value, len);
ifp->buffered += len;
}
static int
......@@ -641,7 +641,7 @@ start_unicast_message(struct neighbour *neigh, int type, int len)
if(unicast_neighbour) {
if(neigh != unicast_neighbour ||
unicast_buffered + len + 2 >=
MIN(UNICAST_BUFSIZE, neigh->network->bufsize))
MIN(UNICAST_BUFSIZE, neigh->ifp->bufsize))
flush_unicast(0);
}
if(!unicast_buffer)
......@@ -664,7 +664,7 @@ end_unicast_message(struct neighbour *neigh, int type, int bytes)
assert(unicast_neighbour == neigh && unicast_buffered >= bytes + 2 &&
unicast_buffer[unicast_buffered - bytes - 2] == type &&
unicast_buffer[unicast_buffered - bytes - 1] == bytes);
schedule_unicast_flush(jitter(neigh->network, 0));
schedule_unicast_flush(jitter(neigh->ifp, 0));
}
static void
......@@ -693,7 +693,7 @@ send_ack(struct neighbour *neigh, unsigned short nonce, unsigned short interval)
{
int rc;
debugf("Sending ack (%04x) to %s on %s.\n",
nonce, format_address(neigh->address), neigh->network->ifname);
nonce, format_address(neigh->address), neigh->ifp->name);
rc = start_unicast_message(neigh, MESSAGE_ACK, 2); if(rc < 0) return;
accumulate_unicast_short(neigh, nonce);
end_unicast_message(neigh, MESSAGE_ACK, 2);
......@@ -702,41 +702,41 @@ send_ack(struct neighbour *neigh, unsigned short nonce, unsigned short interval)
}
void
send_hello_noupdate(struct network *net, unsigned interval)
send_hello_noupdate(struct interface *ifp, unsigned interval)
{
/* This avoids sending multiple hellos in a single packet, which breaks
link quality estimation. */
if(net->have_buffered_hello)
flushbuf(net);
if(ifp->have_buffered_hello)
flushbuf(ifp);
net->hello_seqno = seqno_plus(net->hello_seqno, 1);
set_timeout(&net->hello_timeout, net->hello_interval);
ifp->hello_seqno = seqno_plus(ifp->hello_seqno, 1);
set_timeout(&ifp->hello_timeout, ifp->hello_interval);
if(!net_up(net))
if(!if_up(ifp))
return;
debugf("Sending hello %d (%d) to %s.\n",
net->hello_seqno, interval, net->ifname);
start_message(net, MESSAGE_HELLO, 6);
accumulate_short(net, 0);
accumulate_short(net, net->hello_seqno);
accumulate_short(net, interval > 0xFFFF ? 0xFFFF : interval);
end_message(net, MESSAGE_HELLO, 6);
net->have_buffered_hello = 1;
ifp->hello_seqno, interval, ifp->name);
start_message(ifp, MESSAGE_HELLO, 6);
accumulate_short(ifp, 0);
accumulate_short(ifp, ifp->hello_seqno);
accumulate_short(ifp, interval > 0xFFFF ? 0xFFFF : interval);
end_message(ifp, MESSAGE_HELLO, 6);
ifp->have_buffered_hello = 1;
}
void
send_hello(struct network *net)
send_hello(struct interface *ifp)
{
int changed;
changed = update_hello_interval(net);
send_hello_noupdate(net, (net->hello_interval + 9) / 10);
changed = update_hello_interval(ifp);
send_hello_noupdate(ifp, (ifp->hello_interval + 9) / 10);
/* Send full IHU every 3 hellos, and marginal IHU each time */
if(changed || net->hello_seqno % 3 == 0)
send_ihu(NULL, net);
if(changed || ifp->hello_seqno % 3 == 0)
send_ihu(NULL, ifp);
else
send_marginal_ihu(net);
send_marginal_ihu(ifp);
}
void
......@@ -748,18 +748,18 @@ flush_unicast(int dofree)
if(unicast_buffered == 0)
goto done;
if(!net_up(unicast_neighbour->network))
if(!if_up(unicast_neighbour->ifp))
goto done;
/* Preserve ordering of messages */
flushbuf(unicast_neighbour->network);
flushbuf(unicast_neighbour->ifp);
if(check_bucket(unicast_neighbour->network)) {
if(check_bucket(unicast_neighbour->ifp)) {
memset(&sin6, 0, sizeof(sin6));
sin6.sin6_family = AF_INET6;
memcpy(&sin6.sin6_addr, unicast_neighbour->address, 16);
sin6.sin6_port = htons(protocol_port);
sin6.sin6_scope_id = unicast_neighbour->network->ifindex;
sin6.sin6_scope_id = unicast_neighbour->ifp->ifindex;
DO_HTONS(packet_header + 2, unicast_buffered);
rc = babel_send(protocol_socket,
packet_header, sizeof(packet_header),
......@@ -772,7 +772,7 @@ flush_unicast(int dofree)
"Warning: bucket full, dropping unicast packet"
"to %s if %s.\n",
format_address(unicast_neighbour->address),
unicast_neighbour->network->ifname);
unicast_neighbour->ifp->name);
}
done:
......@@ -788,7 +788,7 @@ flush_unicast(int dofree)
}
static void
really_send_update(struct network *net,
really_send_update(struct interface *ifp,
const unsigned char *id,
const unsigned char *prefix, unsigned char plen,
unsigned short seqno, unsigned short metric,
......@@ -804,82 +804,82 @@ really_send_update(struct network *net,
channels_size = channels_len >= 0 ? channels_len + 2 : 0;
if(!net_up(net))
if(!if_up(ifp))
return;
add_metric = output_filter(id, prefix, plen, net->ifindex);
add_metric = output_filter(id, prefix, plen, ifp->ifindex);
if(add_metric >= INFINITY)
return;
metric = MIN(metric + add_metric, INFINITY);
/* Worst case */
ensure_space(net, 20 + 12 + 28);
ensure_space(ifp, 20 + 12 + 28);
v4 = plen >= 96 && v4mapped(prefix);
if(v4) {
if(!net->ipv4)
if(!ifp->ipv4)
return;
if(!net->have_buffered_nh ||
memcmp(net->buffered_nh, net->ipv4, 4) != 0) {
start_message(net, MESSAGE_NH, 6);
accumulate_byte(net, 1);
accumulate_byte(net, 0);
accumulate_bytes(net, net->ipv4, 4);
end_message(net, MESSAGE_NH, 6);
memcpy(net->buffered_nh, net->ipv4, 4);
net->have_buffered_nh = 1;
if(!ifp->have_buffered_nh ||
memcmp(ifp->buffered_nh, ifp->ipv4, 4) != 0) {
start_message(ifp, MESSAGE_NH, 6);
accumulate_byte(ifp, 1);
accumulate_byte(ifp, 0);
accumulate_bytes(ifp, ifp->ipv4, 4);
end_message(ifp, MESSAGE_NH, 6);
memcpy(ifp->buffered_nh, ifp->ipv4, 4);
ifp->have_buffered_nh = 1;
}
real_prefix = prefix + 12;
real_plen = plen - 96;
} else {
if(net->have_buffered_prefix) {
if(ifp->have_buffered_prefix) {
while(omit < plen / 8 &&
net->buffered_prefix[omit] == prefix[omit])
ifp->buffered_prefix[omit] == prefix[omit])
omit++;
}
if(!net->have_buffered_prefix || plen >= 48)
if(!ifp->have_buffered_prefix || plen >= 48)
flags |= 0x80;
real_prefix = prefix;
real_plen = plen;
}
if(!net->have_buffered_id || memcmp(id, net->buffered_id, 8) != 0) {
if(!ifp->have_buffered_id || memcmp(id, ifp->buffered_id, 8) != 0) {
if(real_plen == 128 && memcmp(real_prefix + 8, id, 8) == 0) {
flags |= 0x40;
} else {
start_message(net, MESSAGE_ROUTER_ID, 10);
accumulate_short(net, 0);
accumulate_bytes(net, id, 8);
end_message(net, MESSAGE_ROUTER_ID, 10);
start_message(ifp, MESSAGE_ROUTER_ID, 10);
accumulate_short(ifp, 0);
accumulate_bytes(ifp, id, 8);
end_message(ifp, MESSAGE_ROUTER_ID, 10);
}
memcpy(net->buffered_id, id, 16);
net->have_buffered_id = 1;
memcpy(ifp->buffered_id, id, 16);
ifp->have_buffered_id = 1;
}
start_message(net, MESSAGE_UPDATE, 10 + (real_plen + 7) / 8 - omit +
start_message(ifp, MESSAGE_UPDATE, 10 + (real_plen + 7) / 8 - omit +
channels_size);
accumulate_byte(net, v4 ? 1 : 2);
accumulate_byte(net, flags);
accumulate_byte(net, real_plen);
accumulate_byte(net, omit);
accumulate_short(net, (net->update_interval + 5) / 10);
accumulate_short(net, seqno);
accumulate_short(net, metric);
accumulate_bytes(net, real_prefix + omit, (real_plen + 7) / 8 - omit);
accumulate_byte(ifp, v4 ? 1 : 2);
accumulate_byte(ifp, flags);
accumulate_byte(ifp, real_plen);
accumulate_byte(ifp, omit);
accumulate_short(ifp, (ifp->update_interval + 5) / 10);
accumulate_short(ifp, seqno);
accumulate_short(ifp, metric);
accumulate_bytes(ifp, real_prefix + omit, (real_plen + 7) / 8 - omit);
/* Note that an empty channels TLV is different from no such TLV. */
if(channels_len >= 0) {
accumulate_byte(net, 2);
accumulate_byte(net, channels_len);
accumulate_bytes(net, channels, channels_len);
accumulate_byte(ifp, 2);
accumulate_byte(ifp, channels_len);
accumulate_bytes(ifp, channels, channels_len);
}
end_message(net, MESSAGE_UPDATE, 10 + (real_plen + 7) / 8 - omit +
end_message(ifp, MESSAGE_UPDATE, 10 + (real_plen + 7) / 8 - omit +
channels_size);
if(flags & 0x80) {
memcpy(net->buffered_prefix, prefix, 16);
net->have_buffered_prefix = 1;
memcpy(ifp->buffered_prefix, prefix, 16);
ifp->have_buffered_prefix = 1;
}
}
......@@ -918,7 +918,7 @@ compare_buffered_updates(const void *av, const void *bv)
}
void
flushupdates(struct network *net)
flushupdates(struct interface *ifp)
{
struct xroute *xroute;
struct route *route;
......@@ -926,26 +926,26 @@ flushupdates(struct network *net)
unsigned char last_plen = 0xFF;
int i;
if(net == NULL) {
struct network *n;
FOR_ALL_NETS(n)
flushupdates(n);
if(ifp == NULL) {
struct interface *ifp_aux;
FOR_ALL_INTERFACES(ifp_aux)
flushupdates(ifp_aux);
return;
}
if(net->num_buffered_updates > 0) {
struct buffered_update *b = net->buffered_updates;
int n = net->num_buffered_updates;
if(ifp->num_buffered_updates > 0) {
struct buffered_update *b = ifp->buffered_updates;
int n = ifp->num_buffered_updates;
net->buffered_updates = NULL;
net->update_bufsize = 0;
net->num_buffered_updates = 0;
ifp->buffered_updates = NULL;
ifp->update_bufsize = 0;
ifp->num_buffered_updates = 0;
if(!net_up(net))
if(!if_up(ifp))
goto done;
debugf(" (flushing %d buffered updates on %s (%d))\n",
n, net->ifname, net->ifindex);
n, ifp->name, ifp->ifindex);
/* In order to send fewer update messages, we want to send updates
with the same router-id together, with IPv6 going out before IPv4. */
......@@ -975,7 +975,7 @@ flushupdates(struct network *net)
route = find_installed_route(b[i].prefix, b[i].plen);
if(xroute && (!route || xroute->metric <= kernel_metric)) {
really_send_update(net, myid,
really_send_update(ifp, myid,
xroute->prefix, xroute->plen,
myseqno, xroute->metric,
NULL, 0);
......@@ -984,39 +984,39 @@ flushupdates(struct network *net)
} else if(route) {
unsigned char channels[DIVERSITY_HOPS];
int chlen;
struct network *route_net = route->neigh->network;
struct interface *route_ifp = route->neigh->ifp;
unsigned short metric;
unsigned short seqno;
seqno = route->seqno;
metric =
route_interferes(route, net) ?
route_interferes(route, ifp) ?
route_metric(route) :
route_metric_noninterfering(route);
if(metric < INFINITY)
satisfy_request(route->src->prefix, route->src->plen,
seqno, route->src->id, net);
seqno, route->src->id, ifp);
if((net->flags & NET_SPLIT_HORIZON) &&
route->neigh->network == net)
if((ifp->flags & IF_SPLIT_HORIZON) &&
route->neigh->ifp == ifp)
continue;
if(route_net->channel == NET_CHANNEL_NONINTERFERING) {
if(route_ifp->channel == IF_CHANNEL_NONINTERFERING) {
memcpy(channels, route->channels, DIVERSITY_HOPS);
} else {
if(route_net->channel == NET_CHANNEL_UNKNOWN)
channels[0] = NET_CHANNEL_INTERFERING;
if(route_ifp->channel == IF_CHANNEL_UNKNOWN)
channels[0] = IF_CHANNEL_INTERFERING;
else {
assert(route_net->channel > 0 &&
route_net->channel <= 254);
channels[0] = route_net->channel;
assert(route_ifp->channel > 0 &&
route_ifp->channel <= 254);
channels[0] = route_ifp->channel;
}
memcpy(channels + 1, route->channels, DIVERSITY_HOPS - 1);
}
chlen = channels_len(channels);
really_send_update(net, route->src->id,
really_send_update(ifp, route->src->id,
route->src->prefix,
route->src->plen,
seqno, metric,
......@@ -1027,44 +1027,44 @@ flushupdates(struct network *net)
} else {
/* There's no route for this prefix. This can happen shortly
after an xroute has been retracted, so send a retraction. */
really_send_update(net, myid, b[i].prefix, b[i].plen,
really_send_update(ifp, myid, b[i].prefix, b[i].plen,
myseqno, INFINITY, NULL, -1);
}
}
schedule_flush_now(net);
schedule_flush_now(ifp);
done:
free(b);
}
net->update_flush_timeout.tv_sec = 0;
net->update_flush_timeout.tv_usec = 0;
ifp->update_flush_timeout.tv_sec = 0;
ifp->update_flush_timeout.tv_usec = 0;
}
static void
schedule_update_flush(struct network *net, int urgent)
schedule_update_flush(struct interface *ifp, int urgent)
{
unsigned msecs;
msecs = update_jitter(net, urgent);
if(net->update_flush_timeout.tv_sec != 0 &&
timeval_minus_msec(&net->update_flush_timeout, &now) < msecs)
msecs = update_jitter(ifp, urgent);
if(ifp->update_flush_timeout.tv_sec != 0 &&
timeval_minus_msec(&ifp->update_flush_timeout, &now) < msecs)
return;
set_timeout(&net->update_flush_timeout, msecs);
set_timeout(&ifp->update_flush_timeout, msecs);
}
static void
buffer_update(struct network *net,
buffer_update(struct interface *ifp,
const unsigned char *prefix, unsigned char plen)
{
if(net->num_buffered_updates > 0 &&
net->num_buffered_updates >= net->update_bufsize)
flushupdates(net);
if(ifp->num_buffered_updates > 0 &&
ifp->num_buffered_updates >= ifp->update_bufsize)
flushupdates(ifp);
if(net->update_bufsize == 0) {
if(ifp->update_bufsize == 0) {
int n;
assert(net->buffered_updates == NULL);
n = MAX(net->bufsize / 16, 4);
assert(ifp->buffered_updates == NULL);
n = MAX(ifp->bufsize / 16, 4);
again:
net->buffered_updates = malloc(n * sizeof(struct buffered_update));
if(net->buffered_updates == NULL) {
ifp->buffered_updates = malloc(n * sizeof(struct buffered_update));
if(ifp->buffered_updates == NULL) {
perror("malloc(buffered_updates)");
if(n > 4) {
n = 4;
......@@ -1072,27 +1072,27 @@ buffer_update(struct network *net,
}
return;
}
net->update_bufsize = n;
net->num_buffered_updates = 0;
ifp->update_bufsize = n;
ifp->num_buffered_updates = 0;
}
memcpy(net->buffered_updates[net->num_buffered_updates].prefix,
memcpy(ifp->buffered_updates[ifp->num_buffered_updates].prefix,
prefix, 16);
net->buffered_updates[net->num_buffered_updates].plen = plen;
net->num_buffered_updates++;
ifp->buffered_updates[ifp->num_buffered_updates].plen = plen;
ifp->num_buffered_updates++;
}
void
send_update(struct network *net, int urgent,
send_update(struct interface *ifp, int urgent,
const unsigned char *prefix, unsigned char plen)
{
int i;
if(net == NULL) {
struct network *n;
if(ifp == NULL) {
struct interface *ifp_aux;
struct route *route;
FOR_ALL_NETS(n)
send_update(n, urgent, prefix, plen);
FOR_ALL_INTERFACES(ifp_aux)
send_update(ifp_aux, urgent, prefix, plen);
if(prefix) {
/* Since flushupdates only deals with non-wildcard interfaces, we
need to do this now. */
......@@ -1104,41 +1104,41 @@ send_update(struct network *net, int urgent,
return;
}
if(!net_up(net))
if(!if_up(ifp))
return;
if(prefix) {
if(!parasitic || find_xroute(prefix, plen)) {
debugf("Sending update to %s for %s.\n",
net->ifname, format_prefix(prefix, plen));
buffer_update(net, prefix, plen);
ifp->name, format_prefix(prefix, plen));
buffer_update(ifp, prefix, plen);
}
} else {
if(!network_idle(net)) {
send_self_update(net);
if(!interface_idle(ifp)) {
send_self_update(ifp);
if(!parasitic) {
debugf("Sending update to %s for any.\n", net->ifname);
debugf("Sending update to %s for any.\n", ifp->name);
for(i = 0; i < numroutes; i++)
if(routes[i].installed)
buffer_update(net,
buffer_update(ifp,
routes[i].src->prefix,
routes[i].src->plen);
}
}
set_timeout(&net->update_timeout, net->update_interval);
set_timeout(&ifp->update_timeout, ifp->update_interval);
}
schedule_update_flush(net, urgent);
schedule_update_flush(ifp, urgent);
}
void
send_update_resend(struct network *net,
send_update_resend(struct interface *ifp,
const unsigned char *prefix, unsigned char plen)
{
int delay;
assert(prefix != NULL);
send_update(net, 1, prefix, plen);
send_update(ifp, 1, prefix, plen);
delay = 2000;
delay = MIN(delay, wireless_hello_interval / 2);
......@@ -1148,29 +1148,29 @@ send_update_resend(struct network *net,
}
void
send_wildcard_retraction(struct network *net)
send_wildcard_retraction(struct interface *ifp)
{
if(net == NULL) {
struct network *n;
FOR_ALL_NETS(n)
send_wildcard_retraction(n);
if(ifp == NULL) {
struct interface *ifp_aux;
FOR_ALL_INTERFACES(ifp_aux)
send_wildcard_retraction(ifp_aux);
return;
}
if(!net_up(net))
if(!if_up(ifp))
return;
start_message(net, MESSAGE_UPDATE, 10);
accumulate_byte(net, 0);
accumulate_byte(net, 0x40);
accumulate_byte(net, 0);
accumulate_byte(net, 0);
accumulate_short(net, 0xFFFF);
accumulate_short(net, myseqno);
accumulate_short(net, 0xFFFF);
end_message(net, MESSAGE_UPDATE, 10);
net->have_buffered_id = 0;
start_message(ifp, MESSAGE_UPDATE, 10);
accumulate_byte(ifp, 0);
accumulate_byte(ifp, 0x40);
accumulate_byte(ifp, 0);
accumulate_byte(ifp, 0);
accumulate_short(ifp, 0xFFFF);
accumulate_short(ifp, myseqno);
accumulate_short(ifp, 0xFFFF);
end_message(ifp, MESSAGE_UPDATE, 10);
ifp->have_buffered_id = 0;
}
void
......@@ -1181,39 +1181,39 @@ update_myseqno()
}
void
send_self_update(struct network *net)
send_self_update(struct interface *ifp)
{
int i;
if(net == NULL) {
struct network *n;
FOR_ALL_NETS(n) {
if(!net_up(n))
if(ifp == NULL) {
struct interface *ifp_aux;
FOR_ALL_INTERFACES(ifp_aux) {
if(!if_up(ifp_aux))
continue;
send_self_update(n);
send_self_update(ifp_aux);
}
return;
}
if(!network_idle(net)) {
debugf("Sending self update to %s.\n", net->ifname);
if(!interface_idle(ifp)) {
debugf("Sending self update to %s.\n", ifp->name);
for(i = 0; i < numxroutes; i++)
send_update(net, 0, xroutes[i].prefix, xroutes[i].plen);
send_update(ifp, 0, xroutes[i].prefix, xroutes[i].plen);
}
}
void
send_ihu(struct neighbour *neigh, struct network *net)
send_ihu(struct neighbour *neigh, struct interface *ifp)
{
int rxcost, interval;
int ll;
if(neigh == NULL && net == NULL) {
struct network *n;
FOR_ALL_NETS(n) {
if(net_up(n))
if(neigh == NULL && ifp == NULL) {
struct interface *ifp_aux;
FOR_ALL_INTERFACES(ifp_aux) {
if(if_up(ifp_aux))
continue;
send_ihu(NULL, n);
send_ihu(NULL, ifp_aux);
}
return;
}
......@@ -1221,22 +1221,22 @@ send_ihu(struct neighbour *neigh, struct network *net)
if(neigh == NULL) {
struct neighbour *ngh;
FOR_ALL_NEIGHBOURS(ngh) {
if(ngh->network == net)
send_ihu(ngh, net);
if(ngh->ifp == ifp)
send_ihu(ngh, ifp);
}
return;
}
if(net && neigh->network != net)
if(ifp && neigh->ifp != ifp)
return;
net = neigh->network;
if(!net_up(net))
ifp = neigh->ifp;
if(!if_up(ifp))
return;
rxcost = neighbour_rxcost(neigh);
interval = (net->hello_interval * 3 + 9) / 10;
interval = (ifp->hello_interval * 3 + 9) / 10;
/* Conceptually, an IHU is a unicast message. We usually send them as
multicast, since this allows aggregation into a single packet and
......@@ -1245,22 +1245,22 @@ send_ihu(struct neighbour *neigh, struct network *net)
debugf("Sending %sihu %d on %s to %s.\n",
unicast_neighbour == neigh ? "unicast " : "",
rxcost,
neigh->network->ifname,
neigh->ifp->name,
format_address(neigh->address));
ll = linklocal(neigh->address);
if(unicast_neighbour != neigh) {
start_message(net, MESSAGE_IHU, ll ? 14 : 22);
accumulate_byte(net, ll ? 3 : 2);
accumulate_byte(net, 0);
accumulate_short(net, rxcost);
accumulate_short(net, interval);
start_message(ifp, MESSAGE_IHU, ll ? 14 : 22);
accumulate_byte(ifp, ll ? 3 : 2);
accumulate_byte(ifp, 0);
accumulate_short(ifp, rxcost);
accumulate_short(ifp, interval);
if(ll)
accumulate_bytes(net, neigh->address + 8, 8);
accumulate_bytes(ifp, neigh->address + 8, 8);
else
accumulate_bytes(net, neigh->address, 16);
end_message(net, MESSAGE_IHU, ll ? 14 : 22);
accumulate_bytes(ifp, neigh->address, 16);
end_message(ifp, MESSAGE_IHU, ll ? 14 : 22);
} else {
int rc;
rc = start_unicast_message(neigh, MESSAGE_IHU, ll ? 14 : 22);
......@@ -1279,54 +1279,54 @@ send_ihu(struct neighbour *neigh, struct network *net)
/* Send IHUs to all marginal neighbours */
void
send_marginal_ihu(struct network *net)
send_marginal_ihu(struct interface *ifp)
{
struct neighbour *neigh;
FOR_ALL_NEIGHBOURS(neigh) {
if(net && neigh->network != net)
if(ifp && neigh->ifp != ifp)
continue;
if(neigh->txcost >= 384 || (neigh->reach & 0xF000) != 0xF000)
send_ihu(neigh, net);
send_ihu(neigh, ifp);
}
}
void
send_request(struct network *net,
send_request(struct interface *ifp,
const unsigned char *prefix, unsigned char plen)
{
int v4, len;
if(net == NULL) {
struct network *n;
FOR_ALL_NETS(n) {
if(net_up(n))
if(ifp == NULL) {
struct interface *ifp_auxn;
FOR_ALL_INTERFACES(ifp_auxn) {
if(if_up(ifp_auxn))
continue;
send_request(n, prefix, plen);
send_request(ifp_auxn, prefix, plen);
}
return;
}
/* make sure any buffered updates go out before this request. */
flushupdates(net);
flushupdates(ifp);
if(!net_up(net))
if(!if_up(ifp))
return;
debugf("sending request to %s for %s.\n",
net->ifname, prefix ? format_prefix(prefix, plen) : "any");
ifp->name, prefix ? format_prefix(prefix, plen) : "any");
v4 = plen >= 96 && v4mapped(prefix);
len = !prefix ? 2 : v4 ? 6 : 18;
start_message(net, MESSAGE_REQUEST, len);
accumulate_byte(net, !prefix ? 0 : v4 ? 1 : 2);
accumulate_byte(net, !prefix ? 0 : v4 ? plen - 96 : plen);
start_message(ifp, MESSAGE_REQUEST, len);
accumulate_byte(ifp, !prefix ? 0 : v4 ? 1 : 2);
accumulate_byte(ifp, !prefix ? 0 : v4 ? plen - 96 : plen);
if(prefix) {
if(v4)
accumulate_bytes(net, prefix + 12, 4);
accumulate_bytes(ifp, prefix + 12, 4);
else
accumulate_bytes(net, prefix, 16);
accumulate_bytes(ifp, prefix, 16);
}
end_message(net, MESSAGE_REQUEST, len);
end_message(ifp, MESSAGE_REQUEST, len);
}
void
......@@ -1336,7 +1336,7 @@ send_unicast_request(struct neighbour *neigh,
int rc, v4, len;
/* make sure any buffered updates go out before this request. */
flushupdates(neigh->network);
flushupdates(neigh->ifp);
debugf("sending unicast request to %s for %s.\n",
format_address(neigh->address),
......@@ -1358,7 +1358,7 @@ send_unicast_request(struct neighbour *neigh,
}
void
send_multihop_request(struct network *net,
send_multihop_request(struct interface *ifp,
const unsigned char *prefix, unsigned char plen,
unsigned short seqno, const unsigned char *id,
unsigned short hop_count)
......@@ -1366,41 +1366,41 @@ send_multihop_request(struct network *net,
int v4, pb, len;
/* Make sure any buffered updates go out before this request. */
flushupdates(net);
flushupdates(ifp);
if(net == NULL) {
struct network *n;
FOR_ALL_NETS(n) {
if(!net_up(n))
if(ifp == NULL) {
struct interface *ifp_aux;
FOR_ALL_INTERFACES(ifp_aux) {
if(!if_up(ifp_aux))
continue;
send_multihop_request(n, prefix, plen, seqno, id, hop_count);
send_multihop_request(ifp_aux, prefix, plen, seqno, id, hop_count);
}
return;
}
if(!net_up(net))
if(!if_up(ifp))
return;
debugf("Sending request (%d) on %s for %s.\n",
hop_count, net->ifname, format_prefix(prefix, plen));
hop_count, ifp->name, format_prefix(prefix, plen));
v4 = plen >= 96 && v4mapped(prefix);
pb = v4 ? ((plen - 96) + 7) / 8 : (plen + 7) / 8;
len = 6 + 8 + pb;
start_message(net, MESSAGE_MH_REQUEST, len);
accumulate_byte(net, v4 ? 1 : 2);
accumulate_byte(net, v4 ? plen - 96 : plen);
accumulate_short(net, seqno);
accumulate_byte(net, hop_count);
accumulate_byte(net, 0);
accumulate_bytes(net, id, 8);
start_message(ifp, MESSAGE_MH_REQUEST, len);
accumulate_byte(ifp, v4 ? 1 : 2);
accumulate_byte(ifp, v4 ? plen - 96 : plen);
accumulate_short(ifp, seqno);
accumulate_byte(ifp, hop_count);
accumulate_byte(ifp, 0);
accumulate_bytes(ifp, id, 8);
if(prefix) {
if(v4)
accumulate_bytes(net, prefix + 12, pb);
accumulate_bytes(ifp, prefix + 12, pb);
else
accumulate_bytes(net, prefix, pb);
accumulate_bytes(ifp, prefix, pb);
}
end_message(net, MESSAGE_MH_REQUEST, len);
end_message(ifp, MESSAGE_MH_REQUEST, len);
}
void
......@@ -1412,7 +1412,7 @@ send_unicast_multihop_request(struct neighbour *neigh,
int rc, v4, pb, len;
/* Make sure any buffered updates go out before this request. */
flushupdates(neigh->network);
flushupdates(neigh->ifp);
debugf("Sending multi-hop request to %s for %s (%d hops).\n",
format_address(neigh->address),
......@@ -1455,7 +1455,7 @@ send_request_resend(struct neighbour *neigh,
delay = MIN(delay, wired_hello_interval / 2);
delay = MAX(delay, 10);
record_resend(RESEND_REQUEST, prefix, plen, seqno, id,
neigh ? neigh->network : NULL, delay);
neigh ? neigh->ifp : NULL, delay);
}
void
......@@ -1480,14 +1480,14 @@ handle_request(struct neighbour *neigh, const unsigned char *prefix,
update_myseqno();
}
}
send_update(neigh->network, 1, prefix, plen);
send_update(neigh->ifp, 1, prefix, plen);
return;
}
if(route &&
(memcmp(id, route->src->id, 8) != 0 ||
seqno_compare(seqno, route->seqno) <= 0)) {
send_update(neigh->network, 1, prefix, plen);
send_update(neigh->ifp, 1, prefix, plen);
return;
}
......@@ -1500,7 +1500,7 @@ handle_request(struct neighbour *neigh, const unsigned char *prefix,
return;
}
if(request_redundant(neigh->network, prefix, plen, seqno, id))
if(request_redundant(neigh->ifp, prefix, plen, seqno, id))
return;
/* Let's try to forward this request. */
......@@ -1524,5 +1524,5 @@ handle_request(struct neighbour *neigh, const unsigned char *prefix,
send_unicast_multihop_request(successor, prefix, plen, seqno, id,
hop_count - 1);
record_resend(RESEND_REQUEST, prefix, plen, seqno, id,
neigh->network, 0);
neigh->ifp, 0);
}
message.h
View file @ 1c3b2bb8
......@@ -50,29 +50,29 @@ extern unsigned char packet_header[4];
extern struct neighbour *unicast_neighbour;
extern struct timeval unicast_flush_timeout;
void parse_packet(const unsigned char *from, struct network *net,
void parse_packet(const unsigned char *from, struct interface *ifp,
const unsigned char *packet, int packetlen);
void flushbuf(struct network *net);
void flushupdates(struct network *net);
void flushbuf(struct interface *ifp);
void flushupdates(struct interface *ifp);
void send_ack(struct neighbour *neigh, unsigned short nonce,
unsigned short interval);
void send_hello_noupdate(struct network *net, unsigned interval);
void send_hello(struct network *net);
void send_hello_noupdate(struct interface *ifp, unsigned interval);
void send_hello(struct interface *ifp);
void flush_unicast(int dofree);
void send_update(struct network *net, int urgent,
void send_update(struct interface *ifp, int urgent,
const unsigned char *prefix, unsigned char plen);
void send_update_resend(struct network *net,
void send_update_resend(struct interface *ifp,
const unsigned char *prefix, unsigned char plen);
void send_wildcard_retraction(struct network *net);
void send_wildcard_retraction(struct interface *ifp);
void update_myseqno(void);
void send_self_update(struct network *net);
void send_ihu(struct neighbour *neigh, struct network *net);
void send_marginal_ihu(struct network *net);
void send_request(struct network *net,
void send_self_update(struct interface *ifp);
void send_ihu(struct neighbour *neigh, struct interface *ifp);
void send_marginal_ihu(struct interface *ifp);
void send_request(struct interface *ifp,
const unsigned char *prefix, unsigned char plen);
void send_unicast_request(struct neighbour *neigh,
const unsigned char *prefix, unsigned char plen);
void send_multihop_request(struct network *net,
void send_multihop_request(struct interface *ifp,
const unsigned char *prefix, unsigned char plen,
unsigned short seqno, const unsigned char *id,
unsigned short hop_count);
......
neighbour.c
View file @ 1c3b2bb8
......@@ -39,12 +39,12 @@ THE SOFTWARE.
struct neighbour *neighs = NULL;
static struct neighbour *
find_neighbour_nocreate(const unsigned char *address, struct network *net)
find_neighbour_nocreate(const unsigned char *address, struct interface *ifp)
{
struct neighbour *neigh;
FOR_ALL_NEIGHBOURS(neigh) {
if(memcmp(address, neigh->address, 16) == 0 &&
neigh->network == net)
neigh->ifp == ifp)
return neigh;
}
return NULL;
......@@ -71,17 +71,17 @@ flush_neighbour(struct neighbour *neigh)
}
struct neighbour *
find_neighbour(const unsigned char *address, struct network *net)
find_neighbour(const unsigned char *address, struct interface *ifp)
{
struct neighbour *neigh;
const struct timeval zero = {0, 0};
neigh = find_neighbour_nocreate(address, net);
neigh = find_neighbour_nocreate(address, ifp);
if(neigh)
return neigh;
debugf("Creating neighbour %s on %s.\n",
format_address(address), net->ifname);
format_address(address), ifp->name);
neigh = malloc(sizeof(struct neighbour));
if(neigh == NULL) {
......@@ -97,11 +97,11 @@ find_neighbour(const unsigned char *address, struct network *net)
neigh->hello_time = zero;
neigh->hello_interval = 0;
neigh->ihu_interval = 0;
neigh->network = net;
neigh->ifp = ifp;
neigh->next = neighs;
neighs = neigh;
local_notify_neighbour(neigh, LOCAL_ADD);
send_hello(net);
send_hello(ifp);
return neigh;
}
......@@ -174,14 +174,14 @@ update_neighbour(struct neighbour *neigh, int hello, int hello_interval)
/* Make sure to give neighbours some feedback early after association */
if((neigh->reach & 0xBF00) == 0x8000) {
/* A new neighbour */
send_hello(neigh->network);
send_hello(neigh->ifp);
} else {
/* Don't send hellos, in order to avoid a positive feedback loop. */
int a = (neigh->reach & 0xC000);
int b = (neigh->reach & 0x3000);
if((a == 0xC000 && b == 0) || (a == 0 && b == 0x3000)) {
/* Reachability is either 1100 or 0011 */
send_self_update(neigh->network);
send_self_update(neigh->ifp);
}
}
......@@ -269,25 +269,25 @@ neighbour_rxcost(struct neighbour *neigh)
if((reach & 0xFFF0) == 0 || delay >= 180000) {
return INFINITY;
} else if((neigh->network->flags & NET_LQ)) {
} else if((neigh->ifp->flags & IF_LQ)) {
int sreach =
((reach & 0x8000) >> 2) +
((reach & 0x4000) >> 1) +
(reach & 0x3FFF);
/* 0 <= sreach <= 0x7FFF */
int cost = (0x8000 * neigh->network->cost) / (sreach + 1);
/* cost >= network->cost */
int cost = (0x8000 * neigh->ifp->cost) / (sreach + 1);
/* cost >= interface->cost */
if(delay >= 40000)
cost = (cost * (delay - 20000) + 10000) / 20000;
return MIN(cost, INFINITY);
} else {
/* To lose one hello is a misfortune, to lose two is carelessness. */
if((reach & 0xC000) == 0xC000)
return neigh->network->cost;
return neigh->ifp->cost;
else if((reach & 0xC000) == 0)
return INFINITY;
else if((reach & 0x2000))
return neigh->network->cost;
return neigh->ifp->cost;
else
return INFINITY;
}
......@@ -298,7 +298,7 @@ neighbour_cost(struct neighbour *neigh)
{
unsigned a, b;
if(!net_up(neigh->network))
if(!if_up(neigh->ifp))
return INFINITY;
a = neighbour_txcost(neigh);
......@@ -310,7 +310,7 @@ neighbour_cost(struct neighbour *neigh)
if(b >= INFINITY)
return INFINITY;
if(!(neigh->network->flags & NET_LQ) || (a <= 256 && b <= 256)) {
if(!(neigh->ifp->flags & IF_LQ) || (a <= 256 && b <= 256)) {
return a;
} else {
/* a = 256/alpha, b = 256/beta, where alpha and beta are the expected
......
neighbour.h
View file @ 1c3b2bb8
......@@ -31,7 +31,7 @@ struct neighbour {
struct timeval ihu_time;
unsigned short hello_interval; /* in centiseconds */
unsigned short ihu_interval; /* in centiseconds */
struct network *network;
struct interface *ifp;
};
extern struct neighbour *neighs;
......@@ -42,7 +42,7 @@ extern struct neighbour *neighs;
int neighbour_valid(struct neighbour *neigh);
void flush_neighbour(struct neighbour *neigh);
struct neighbour *find_neighbour(const unsigned char *address,
struct network *net);
struct interface *ifp);
int update_neighbour(struct neighbour *neigh, int hello, int hello_interval);
unsigned check_neighbours(void);
unsigned neighbour_txcost(struct neighbour *neigh);
......
network.c
View file @ 1c3b2bb8
......@@ -41,80 +41,80 @@ THE SOFTWARE.
#include "route.h"
#include "configuration.h"
struct network *networks = NULL;
struct interface *interfaces = NULL;
static struct network *
last_network(void)
static struct interface *
last_interface(void)
{
struct network *net = networks;
struct interface *ifp = interfaces;
if(!net)
if(!ifp)
return NULL;
while(net->next)
net = net->next;
while(ifp->next)
ifp = ifp->next;
return net;
return ifp;
}
struct network *
add_network(char *ifname, struct network_conf *conf)
struct interface *
add_interface(char *ifname, struct interface_conf *if_conf)
{
struct network *net;
struct interface *ifp;
assert(!conf || strcmp(ifname, conf->ifname) == 0);
assert(!if_conf || strcmp(ifname, if_conf->ifname) == 0);
FOR_ALL_NETS(net) {
if(strcmp(net->ifname, ifname) == 0) {
assert(conf == NULL);
return net;
FOR_ALL_INTERFACES(ifp) {
if(strcmp(ifp->name, ifname) == 0) {
assert(if_conf == NULL);
return ifp;
}
}
net = malloc(sizeof(struct network));
if(net == NULL)
ifp = malloc(sizeof(struct interface));
if(ifp == NULL)
return NULL;
memset(net, 0, sizeof(struct network));
strncpy(net->ifname, ifname, IF_NAMESIZE);
net->conf = conf;
net->activity_time = now.tv_sec;
net->bucket_time = now.tv_sec;
net->bucket = BUCKET_TOKENS_MAX;
net->hello_seqno = (random() & 0xFFFF);
memset(ifp, 0, sizeof(struct interface));
strncpy(ifp->name, ifname, IF_NAMESIZE);
ifp->conf = if_conf;
ifp->activity_time = now.tv_sec;
ifp->bucket_time = now.tv_sec;
ifp->bucket = BUCKET_TOKENS_MAX;
ifp->hello_seqno = (random() & 0xFFFF);
if(networks == NULL)
networks = net;
if(interfaces == NULL)
interfaces = ifp;
else
last_network()->next = net;
last_interface()->next = ifp;
return net;
return ifp;
}
int
network_idle(struct network *net)
interface_idle(struct interface *ifp)
{
return (idle_hello_interval > 0 &&
net->activity_time < now.tv_sec - idle_time);
ifp->activity_time < now.tv_sec - idle_time);
}
int
update_hello_interval(struct network *net)
update_hello_interval(struct interface *ifp)
{
int rc = 0;
unsigned short interval;
if(network_idle(net))
if(interface_idle(ifp))
interval = idle_hello_interval;
else if(NET_CONF(net, hello_interval) > 0)
interval = NET_CONF(net, hello_interval);
else if((net->flags & NET_WIRED))
else if(IF_CONF(ifp, hello_interval) > 0)
interval = IF_CONF(ifp, hello_interval);
else if((ifp->flags & IF_WIRED))
interval = wired_hello_interval;
else
interval = wireless_hello_interval;
if(net->hello_interval != interval) {
net->hello_interval = interval;
if(ifp->hello_interval != interval) {
ifp->hello_interval = interval;
rc = 1;
}
......@@ -124,9 +124,9 @@ update_hello_interval(struct network *net)
/* This should be no more than half the hello interval, so that hellos
aren't sent late. The result is in milliseconds. */
unsigned
jitter(struct network *net, int urgent)
jitter(struct interface *ifp, int urgent)
{
unsigned interval = net->hello_interval;
unsigned interval = ifp->hello_interval;
if(urgent)
interval = MIN(interval, 100);
else
......@@ -135,9 +135,9 @@ jitter(struct network *net, int urgent)
}
unsigned
update_jitter(struct network *net, int urgent)
update_jitter(struct interface *ifp, int urgent)
{
unsigned interval = net->hello_interval;
unsigned interval = ifp->hello_interval;
if(urgent)
interval = MIN(interval, 100);
else
......@@ -152,32 +152,32 @@ set_timeout(struct timeval *timeout, int msecs)
}
static int
check_network_ipv4(struct network *net)
check_interface_ipv4(struct interface *ifp)
{
unsigned char ipv4[4];
int rc;
if(net->ifindex > 0)
rc = kernel_interface_ipv4(net->ifname, net->ifindex, ipv4);
if(ifp->ifindex > 0)
rc = kernel_interface_ipv4(ifp->name, ifp->ifindex, ipv4);
else
rc = 0;
if(rc > 0) {
if(!net->ipv4 || memcmp(ipv4, net->ipv4, 4) != 0) {
debugf("Noticed IPv4 change for %s.\n", net->ifname);
flush_network_routes(net, 0);
if(!net->ipv4)
net->ipv4 = malloc(4);
if(net->ipv4)
memcpy(net->ipv4, ipv4, 4);
if(!ifp->ipv4 || memcmp(ipv4, ifp->ipv4, 4) != 0) {
debugf("Noticed IPv4 change for %s.\n", ifp->name);
flush_interface_routes(ifp, 0);
if(!ifp->ipv4)
ifp->ipv4 = malloc(4);
if(ifp->ipv4)
memcpy(ifp->ipv4, ipv4, 4);
return 1;
}
} else {
if(net->ipv4) {
debugf("Noticed IPv4 change for %s.\n", net->ifname);
flush_network_routes(net, 0);
free(net->ipv4);
net->ipv4 = NULL;
if(ifp->ipv4) {
debugf("Noticed IPv4 change for %s.\n", ifp->name);
flush_interface_routes(ifp, 0);
free(ifp->ipv4);
ifp->ipv4 = NULL;
return 1;
}
}
......@@ -185,64 +185,64 @@ check_network_ipv4(struct network *net)
}
int
check_network_channel(struct network *net)
check_interface_channel(struct interface *ifp)
{
int channel = NET_CONF(net, channel);
int channel = IF_CONF(ifp, channel);
if(channel == NET_CHANNEL_UNKNOWN) {
if((net->flags & NET_WIRED)) {
channel = NET_CHANNEL_NONINTERFERING;
if(channel == IF_CHANNEL_UNKNOWN) {
if((ifp->flags & IF_WIRED)) {
channel = IF_CHANNEL_NONINTERFERING;
} else {
channel = kernel_interface_channel(net->ifname, net->ifindex);
channel = kernel_interface_channel(ifp->name, ifp->ifindex);
if(channel < 0)
fprintf(stderr,
"Couldn't determine channel of interface %s: %s.\n",
net->ifname, strerror(errno));
ifp->name, strerror(errno));
if(channel <= 0)
channel = NET_CHANNEL_INTERFERING;
channel = IF_CHANNEL_INTERFERING;
}
}
if(net->channel != channel) {
net->channel = channel;
if(ifp->channel != channel) {
ifp->channel = channel;
return 1;
}
return 0;
}
int
network_up(struct network *net, int up)
interface_up(struct interface *ifp, int up)
{
int mtu, rc, wired;
struct ipv6_mreq mreq;
if((!!up) == net_up(net))
if((!!up) == if_up(ifp))
return 0;
if(up)
net->flags |= NET_UP;
ifp->flags |= IF_UP;
else
net->flags &= ~NET_UP;
ifp->flags &= ~IF_UP;
if(up) {
struct kernel_route ll[32];
if(net->ifindex <= 0) {
if(ifp->ifindex <= 0) {
fprintf(stderr,
"Upping unknown interface %s.\n", net->ifname);
return network_up(net, 0);
"Upping unknown interface %s.\n", ifp->name);
return interface_up(ifp, 0);
}
rc = kernel_setup_interface(1, net->ifname, net->ifindex);
rc = kernel_setup_interface(1, ifp->name, ifp->ifindex);
if(rc < 0) {
fprintf(stderr, "kernel_setup_interface(%s, %d) failed.\n",
net->ifname, net->ifindex);
return network_up(net, 0);
ifp->name, ifp->ifindex);
return interface_up(ifp, 0);
}
mtu = kernel_interface_mtu(net->ifname, net->ifindex);
mtu = kernel_interface_mtu(ifp->name, ifp->ifindex);
if(mtu < 0) {
fprintf(stderr, "Warning: couldn't get MTU of interface %s (%d).\n",
net->ifname, net->ifindex);
ifp->name, ifp->ifindex);
mtu = 1280;
}
......@@ -252,37 +252,37 @@ network_up(struct network *net, int up)
to reassemble up to 1500 bytes, but I'd rather not rely on this. */
if(mtu < 128) {
fprintf(stderr, "Suspiciously low MTU %d on interface %s (%d).\n",
mtu, net->ifname, net->ifindex);
mtu, ifp->name, ifp->ifindex);
mtu = 128;
}
if(net->sendbuf)
free(net->sendbuf);
if(ifp->sendbuf)
free(ifp->sendbuf);
/* 40 for IPv6 header, 8 for UDP header, 12 for good luck. */
net->bufsize = mtu - sizeof(packet_header) - 60;
net->sendbuf = malloc(net->bufsize);
if(net->sendbuf == NULL) {
ifp->bufsize = mtu - sizeof(packet_header) - 60;
ifp->sendbuf = malloc(ifp->bufsize);
if(ifp->sendbuf == NULL) {
fprintf(stderr, "Couldn't allocate sendbuf.\n");
net->bufsize = 0;
return network_up(net, 0);
ifp->bufsize = 0;
return interface_up(ifp, 0);
}
resize_receive_buffer(mtu);
if(NET_CONF(net, wired) == CONFIG_NO) {
if(IF_CONF(ifp, wired) == CONFIG_NO) {
wired = 0;
} else if(NET_CONF(net, wired) == CONFIG_YES) {
} else if(IF_CONF(ifp, wired) == CONFIG_YES) {
wired = 1;
} else if(all_wireless) {
wired = 0;
} else {
rc = kernel_interface_wireless(net->ifname, net->ifindex);
rc = kernel_interface_wireless(ifp->name, ifp->ifindex);
if(rc < 0) {
fprintf(stderr,
"Warning: couldn't determine whether %s (%d) "
"is a wireless interface.\n",
net->ifname, net->ifindex);
ifp->name, ifp->ifindex);
wired = 0;
} else {
wired = !rc;
......@@ -290,172 +290,172 @@ network_up(struct network *net, int up)
}
if(wired) {
net->flags |= NET_WIRED;
net->cost = NET_CONF(net, cost);
if(net->cost <= 0) net->cost = 96;
if(NET_CONF(net, split_horizon) == CONFIG_NO)
net->flags &= ~NET_SPLIT_HORIZON;
else if(NET_CONF(net, split_horizon) == CONFIG_YES)
net->flags |= NET_SPLIT_HORIZON;
ifp->flags |= IF_WIRED;
ifp->cost = IF_CONF(ifp, cost);
if(ifp->cost <= 0) ifp->cost = 96;
if(IF_CONF(ifp, split_horizon) == CONFIG_NO)
ifp->flags &= ~IF_SPLIT_HORIZON;
else if(IF_CONF(ifp, split_horizon) == CONFIG_YES)
ifp->flags |= IF_SPLIT_HORIZON;
else if(split_horizon)
net->flags |= NET_SPLIT_HORIZON;
ifp->flags |= IF_SPLIT_HORIZON;
else
net->flags &= ~NET_SPLIT_HORIZON;
if(NET_CONF(net, lq) == CONFIG_YES)
net->flags |= NET_LQ;
ifp->flags &= ~IF_SPLIT_HORIZON;
if(IF_CONF(ifp, lq) == CONFIG_YES)
ifp->flags |= IF_LQ;
else
net->flags &= ~NET_LQ;
ifp->flags &= ~IF_LQ;
} else {
net->flags &= ~NET_WIRED;
net->cost = NET_CONF(net, cost);
if(net->cost <= 0) net->cost = 256;
if(NET_CONF(net, split_horizon) == CONFIG_YES)
net->flags |= NET_SPLIT_HORIZON;
ifp->flags &= ~IF_WIRED;
ifp->cost = IF_CONF(ifp, cost);
if(ifp->cost <= 0) ifp->cost = 256;
if(IF_CONF(ifp, split_horizon) == CONFIG_YES)
ifp->flags |= IF_SPLIT_HORIZON;
else
net->flags &= ~NET_SPLIT_HORIZON;
if(NET_CONF(net, lq) == CONFIG_NO)
net->flags &= ~NET_LQ;
ifp->flags &= ~IF_SPLIT_HORIZON;
if(IF_CONF(ifp, lq) == CONFIG_NO)
ifp->flags &= ~IF_LQ;
else
net->flags |= NET_LQ;
ifp->flags |= IF_LQ;
}
if(NET_CONF(net, faraway) == CONFIG_YES)
net->flags |= NET_FARAWAY;
if(IF_CONF(ifp, faraway) == CONFIG_YES)
ifp->flags |= IF_FARAWAY;
net->activity_time = now.tv_sec;
update_hello_interval(net);
ifp->activity_time = now.tv_sec;
update_hello_interval(ifp);
/* Since the interface was marked as active above, the
idle_hello_interval cannot be the one being used here. */
net->update_interval =
NET_CONF(net, update_interval) > 0 ?
NET_CONF(net, update_interval) :
net->hello_interval * 4;
ifp->update_interval =
IF_CONF(ifp, update_interval) > 0 ?
IF_CONF(ifp, update_interval) :
ifp->hello_interval * 4;
memset(&mreq, 0, sizeof(mreq));
memcpy(&mreq.ipv6mr_multiaddr, protocol_group, 16);
mreq.ipv6mr_interface = net->ifindex;
mreq.ipv6mr_interface = ifp->ifindex;
rc = setsockopt(protocol_socket, IPPROTO_IPV6, IPV6_JOIN_GROUP,
(char*)&mreq, sizeof(mreq));
if(rc < 0) {
perror("setsockopt(IPV6_JOIN_GROUP)");
/* This is probably due to a missing link-local address,
so down this network, and wait until the main loop
so down this interface, and wait until the main loop
tries to up it again. */
return network_up(net, 0);
return interface_up(ifp, 0);
}
if(net->ll)
free(net->ll);
net->numll = 0;
net->ll = NULL;
rc = kernel_addresses(net->ifname, net->ifindex, 1, ll, 32);
if(ifp->ll)
free(ifp->ll);
ifp->numll = 0;
ifp->ll = NULL;
rc = kernel_addresses(ifp->name, ifp->ifindex, 1, ll, 32);
if(rc < 0) {
perror("kernel_ll_addresses");
} else if(rc > 0) {
net->ll = malloc(16 * rc);
if(net->ll == NULL) {
ifp->ll = malloc(16 * rc);
if(ifp->ll == NULL) {
perror("malloc(ll)");
} else {
int i;
for(i = 0; i < rc; i++)
memcpy(net->ll[i], ll[i].prefix, 16);
net->numll = rc;
memcpy(ifp->ll[i], ll[i].prefix, 16);
ifp->numll = rc;
}
}
set_timeout(&net->hello_timeout, net->hello_interval);
set_timeout(&net->update_timeout, net->update_interval);
send_hello(net);
send_request(net, NULL, 0);
set_timeout(&ifp->hello_timeout, ifp->hello_interval);
set_timeout(&ifp->update_timeout, ifp->update_interval);
send_hello(ifp);
send_request(ifp, NULL, 0);
} else {
flush_network_routes(net, 0);
net->buffered = 0;
net->bufsize = 0;
free(net->sendbuf);
net->num_buffered_updates = 0;
net->update_bufsize = 0;
if(net->buffered_updates)
free(net->buffered_updates);
net->buffered_updates = NULL;
net->sendbuf = NULL;
if(net->ifindex > 0) {
flush_interface_routes(ifp, 0);
ifp->buffered = 0;
ifp->bufsize = 0;
free(ifp->sendbuf);
ifp->num_buffered_updates = 0;
ifp->update_bufsize = 0;
if(ifp->buffered_updates)
free(ifp->buffered_updates);
ifp->buffered_updates = NULL;
ifp->sendbuf = NULL;
if(ifp->ifindex > 0) {
memset(&mreq, 0, sizeof(mreq));
memcpy(&mreq.ipv6mr_multiaddr, protocol_group, 16);
mreq.ipv6mr_interface = net->ifindex;
mreq.ipv6mr_interface = ifp->ifindex;
rc = setsockopt(protocol_socket, IPPROTO_IPV6, IPV6_LEAVE_GROUP,
(char*)&mreq, sizeof(mreq));
if(rc < 0)
perror("setsockopt(IPV6_LEAVE_GROUP)");
kernel_setup_interface(0, net->ifname, net->ifindex);
kernel_setup_interface(0, ifp->name, ifp->ifindex);
}
if(net->ll)
free(net->ll);
net->ll = NULL;
net->numll = 0;
if(ifp->ll)
free(ifp->ll);
ifp->ll = NULL;
ifp->numll = 0;
}
check_network_channel(net);
update_network_metric(net);
rc = check_network_ipv4(net);
check_interface_channel(ifp);
update_interface_metric(ifp);
rc = check_interface_ipv4(ifp);
debugf("Upped network %s (%s, cost=%d, channel=%d%s).\n",
net->ifname,
(net->flags & NET_WIRED) ? "wired" : "wireless",
net->cost,
net->channel,
net->ipv4 ? ", IPv4" : "");
debugf("Upped interface %s (%s, cost=%d, channel=%d%s).\n",
ifp->name,
(ifp->flags & IF_WIRED) ? "wired" : "wireless",
ifp->cost,
ifp->channel,
ifp->ipv4 ? ", IPv4" : "");
if(up && rc > 0)
send_update(net, 0, NULL, 0);
send_update(ifp, 0, NULL, 0);
return 1;
}
int
network_ll_address(struct network *net, const unsigned char *address)
interface_ll_address(struct interface *ifp, const unsigned char *address)
{
int i;
if(!net_up(net))
if(!if_up(ifp))
return 0;
for(i = 0; i < net->numll; i++)
if(memcmp(net->ll[i], address, 16) == 0)
for(i = 0; i < ifp->numll; i++)
if(memcmp(ifp->ll[i], address, 16) == 0)
return 1;
return 0;
}
void
check_networks(void)
check_interfaces(void)
{
struct network *net;
struct interface *ifp;
int rc, ifindex, ifindex_changed = 0;
FOR_ALL_NETS(net) {
ifindex = if_nametoindex(net->ifname);
if(ifindex != net->ifindex) {
debugf("Noticed ifindex change for %s.\n", net->ifname);
net->ifindex = 0;
network_up(net, 0);
net->ifindex = ifindex;
FOR_ALL_INTERFACES(ifp) {
ifindex = if_nametoindex(ifp->name);
if(ifindex != ifp->ifindex) {
debugf("Noticed ifindex change for %s.\n", ifp->name);
ifp->ifindex = 0;
interface_up(ifp, 0);
ifp->ifindex = ifindex;
ifindex_changed = 1;
}
if(net->ifindex > 0)
rc = kernel_interface_operational(net->ifname, net->ifindex);
if(ifp->ifindex > 0)
rc = kernel_interface_operational(ifp->name, ifp->ifindex);
else
rc = 0;
if((rc > 0) != net_up(net)) {
debugf("Noticed status change for %s.\n", net->ifname);
network_up(net, rc > 0);
if((rc > 0) != if_up(ifp)) {
debugf("Noticed status change for %s.\n", ifp->name);
interface_up(ifp, rc > 0);
}
check_network_channel(net);
rc = check_network_ipv4(net);
check_interface_channel(ifp);
rc = check_interface_ipv4(ifp);
if(rc > 0) {
send_request(net, NULL, 0);
send_update(net, 0, NULL, 0);
send_request(ifp, NULL, 0);
send_update(ifp, 0, NULL, 0);
}
}
......
network.h
View file @ 1c3b2bb8
......@@ -27,7 +27,7 @@ struct buffered_update {
unsigned char pad[3];
};
struct network_conf {
struct interface_conf {
char *ifname;
unsigned hello_interval;
unsigned update_interval;
......@@ -37,27 +37,27 @@ struct network_conf {
char lq;
char faraway;
int channel;
struct network_conf *next;
struct interface_conf *next;
};
#define CONFIG_DEFAULT 0
#define CONFIG_NO 1
#define CONFIG_YES 2
#define NET_UP (1 << 0)
#define NET_WIRED (1<<1)
#define NET_SPLIT_HORIZON (1 << 2)
#define NET_LQ (1 << 3)
#define NET_FARAWAY (1 << 4)
#define IF_UP (1 << 0)
#define IF_WIRED (1<<1)
#define IF_SPLIT_HORIZON (1 << 2)
#define IF_LQ (1 << 3)
#define IF_FARAWAY (1 << 4)
/* Only INTERFERING can appear on the wire. */
#define NET_CHANNEL_UNKNOWN 0
#define NET_CHANNEL_INTERFERING 255
#define NET_CHANNEL_NONINTERFERING -2
#define IF_CHANNEL_UNKNOWN 0
#define IF_CHANNEL_INTERFERING 255
#define IF_CHANNEL_NONINTERFERING -2
struct network {
struct network *next;
struct network_conf *conf;
struct interface {
struct interface *next;
struct interface_conf *conf;
unsigned int ifindex;
unsigned short flags;
unsigned short cost;
......@@ -66,7 +66,7 @@ struct network {
struct timeval update_timeout;
struct timeval flush_timeout;
struct timeval update_flush_timeout;
char ifname[IF_NAMESIZE];
char name[IF_NAMESIZE];
unsigned char *ipv4;
int numll;
unsigned char (*ll)[16];
......@@ -91,26 +91,25 @@ struct network {
unsigned update_interval;
};
#define NET_CONF(_net, _field) \
((_net)->conf ? (_net)->conf->_field : 0)
#define IF_CONF(_ifp, _field) \
((_ifp)->conf ? (_ifp)->conf->_field : 0)
extern struct network *networks;
extern int numnets;
extern struct interface *interfaces;
#define FOR_ALL_NETS(_net) for(_net = networks; _net; _net = _net->next)
#define FOR_ALL_INTERFACES(_ifp) for(_ifp = interfaces; _ifp; _ifp = _ifp->next)
static inline int
net_up(struct network *net)
if_up(struct interface *ifp)
{
return !!(net->flags & NET_UP);
return !!(ifp->flags & IF_UP);
}
struct network *add_network(char *ifname, struct network_conf *conf);
int network_idle(struct network *net);
int update_hello_interval(struct network *net);
unsigned jitter(struct network *net, int urgent);
unsigned update_jitter(struct network *net, int urgent);
struct interface *add_interface(char *ifname, struct interface_conf *if_conf);
int interface_idle(struct interface *ifp);
int update_hello_interval(struct interface *ifp);
unsigned jitter(struct interface *ifp, int urgent);
unsigned update_jitter(struct interface *ifp, int urgent);
void set_timeout(struct timeval *timeout, int msecs);
int network_up(struct network *net, int up);
int network_ll_address(struct network *net, const unsigned char *address);
void check_networks(void);
int interface_up(struct interface *ifp, int up);
int interface_ll_address(struct interface *ifp, const unsigned char *address);
void check_interfaces(void);
resend.c
View file @ 1c3b2bb8
......@@ -83,10 +83,10 @@ find_request(const unsigned char *prefix, unsigned char plen,
int
record_resend(int kind, const unsigned char *prefix, unsigned char plen,
unsigned short seqno, const unsigned char *id,
struct network *network, int delay)
struct interface *ifp, int delay)
{
struct resend *resend;
unsigned int ifindex = network ? network->ifindex : 0;
unsigned int ifindex = ifp ? ifp->ifindex : 0;
if((kind == RESEND_REQUEST &&
input_filter(NULL, prefix, plen, NULL, ifindex) >= INFINITY) ||
......@@ -114,8 +114,8 @@ record_resend(int kind, const unsigned char *prefix, unsigned char plen,
else
memset(resend->id, 0, 8);
resend->seqno = seqno;
if(resend->network != network)
resend->network = NULL;
if(resend->ifp != ifp)
resend->ifp = NULL;
} else {
resend = malloc(sizeof(struct resend));
if(resend == NULL)
......@@ -130,7 +130,7 @@ record_resend(int kind, const unsigned char *prefix, unsigned char plen,
memcpy(resend->id, id, 8);
else
memset(resend->id, 0, 8);
resend->network = network;
resend->ifp = ifp;
resend->time = now;
resend->next = to_resend;
to_resend = resend;
......@@ -174,7 +174,7 @@ unsatisfied_request(const unsigned char *prefix, unsigned char plen,
/* Determine whether a given request should be forwarded. */
int
request_redundant(struct network *net,
request_redundant(struct interface *ifp,
const unsigned char *prefix, unsigned char plen,
unsigned short seqno, const unsigned char *id)
{
......@@ -188,7 +188,7 @@ request_redundant(struct network *net,
seqno_compare(request->seqno, seqno) > 0)
return 0;
if(request->network != NULL && request->network != net)
if(request->ifp != NULL && request->ifp != ifp)
return 0;
if(request->max > 0)
......@@ -196,7 +196,7 @@ request_redundant(struct network *net,
return 1;
if(timeval_minus_msec(&now, &request->time) <
(net ? MIN(net->hello_interval, 1000) : 1000))
(ifp ? MIN(ifp->hello_interval, 1000) : 1000))
/* Fairly recent. */
return 1;
......@@ -206,7 +206,7 @@ request_redundant(struct network *net,
int
satisfy_request(const unsigned char *prefix, unsigned char plen,
unsigned short seqno, const unsigned char *id,
struct network *network)
struct interface *ifp)
{
struct resend *request, *previous;
......@@ -214,7 +214,7 @@ satisfy_request(const unsigned char *prefix, unsigned char plen,
if(request == NULL)
return 0;
if(network != NULL && request->network != network)
if(ifp != NULL && request->ifp != ifp)
return 0;
if(memcmp(request->id, id, 8) != 0 ||
......@@ -291,12 +291,12 @@ do_resend()
if(timeval_compare(&now, &timeout) >= 0) {
switch(resend->kind) {
case RESEND_REQUEST:
send_multihop_request(resend->network,
send_multihop_request(resend->ifp,
resend->prefix, resend->plen,
resend->seqno, resend->id, 127);
break;
case RESEND_UPDATE:
send_update(resend->network, 1,
send_update(resend->ifp, 1,
resend->prefix, resend->plen);
break;
default: abort();
......
resend.h
View file @ 1c3b2bb8
......@@ -35,7 +35,7 @@ struct resend {
unsigned char plen;
unsigned short seqno;
unsigned char id[8];
struct network *network;
struct interface *ifp;
struct resend *next;
};
......@@ -46,15 +46,15 @@ struct resend *find_request(const unsigned char *prefix, unsigned char plen,
void flush_resends(struct neighbour *neigh);
int record_resend(int kind, const unsigned char *prefix, unsigned char plen,
unsigned short seqno, const unsigned char *id,
struct network *net, int delay);
struct interface *ifp, int delay);
int unsatisfied_request(const unsigned char *prefix, unsigned char plen,
unsigned short seqno, const unsigned char *id);
int request_redundant(struct network *net,
int request_redundant(struct interface *ifp,
const unsigned char *prefix, unsigned char plen,
unsigned short seqno, const unsigned char *id);
int satisfy_request(const unsigned char *prefix, unsigned char plen,
unsigned short seqno, const unsigned char *id,
struct network *net);
struct interface *ifp);
void expire_resend(void);
void recompute_resend_time(void);
......
route.c
View file @ 1c3b2bb8
......@@ -134,13 +134,13 @@ flush_neighbour_routes(struct neighbour *neigh)
}
void
flush_network_routes(struct network *net, int v4only)
flush_interface_routes(struct interface *ifp, int v4only)
{
int i;
i = 0;
while(i < numroutes) {
if(routes[i].neigh->network == net &&
if(routes[i].neigh->ifp == ifp &&
(!v4only || v4mapped(routes[i].nexthop))) {
flush_route(&routes[i]);
continue;
......@@ -169,7 +169,7 @@ install_route(struct route *route)
rc = kernel_route(ROUTE_ADD, route->src->prefix, route->src->plen,
route->nexthop,
route->neigh->network->ifindex,
route->neigh->ifp->ifindex,
metric_to_kernel(route_metric(route)), NULL, 0, 0);
if(rc < 0) {
int save = errno;
......@@ -191,7 +191,7 @@ uninstall_route(struct route *route)
rc = kernel_route(ROUTE_FLUSH, route->src->prefix, route->src->plen,
route->nexthop,
route->neigh->network->ifindex,
route->neigh->ifp->ifindex,
metric_to_kernel(route_metric(route)), NULL, 0, 0);
if(rc < 0)
perror("kernel_route(FLUSH)");
......@@ -222,9 +222,9 @@ switch_routes(struct route *old, struct route *new)
"(this shouldn't happen).");
rc = kernel_route(ROUTE_MODIFY, old->src->prefix, old->src->plen,
old->nexthop, old->neigh->network->ifindex,
old->nexthop, old->neigh->ifp->ifindex,
metric_to_kernel(route_metric(old)),
new->nexthop, new->neigh->network->ifindex,
new->nexthop, new->neigh->ifp->ifindex,
metric_to_kernel(route_metric(new)));
if(rc < 0) {
perror("kernel_route(MODIFY)");
......@@ -251,9 +251,9 @@ change_route_metric(struct route *route,
if(route->installed && old != new) {
int rc;
rc = kernel_route(ROUTE_MODIFY, route->src->prefix, route->src->plen,
route->nexthop, route->neigh->network->ifindex,
route->nexthop, route->neigh->ifp->ifindex,
old,
route->nexthop, route->neigh->network->ifindex,
route->nexthop, route->neigh->ifp->ifindex,
new);
if(rc < 0) {
perror("kernel_route(MODIFY metric)");
......@@ -294,33 +294,33 @@ route_expired(struct route *route)
static int
channels_interfere(int ch1, int ch2)
{
if(ch1 == NET_CHANNEL_NONINTERFERING || ch2 == NET_CHANNEL_NONINTERFERING)
if(ch1 == IF_CHANNEL_NONINTERFERING || ch2 == IF_CHANNEL_NONINTERFERING)
return 0;
if(ch1 == NET_CHANNEL_INTERFERING || ch2 == NET_CHANNEL_INTERFERING)
if(ch1 == IF_CHANNEL_INTERFERING || ch2 == IF_CHANNEL_INTERFERING)
return 1;
return ch1 == ch2;
}
int
route_interferes(struct route *route, struct network *net)
route_interferes(struct route *route, struct interface *ifp)
{
switch(diversity_kind) {
case DIVERSITY_NONE:
return 1;
case DIVERSITY_INTERFACE_1:
return route->neigh->network == net;
return route->neigh->ifp == ifp;
case DIVERSITY_CHANNEL_1:
case DIVERSITY_CHANNEL:
if(route->neigh->network == net)
if(route->neigh->ifp == ifp)
return 1;
if(channels_interfere(net->channel, route->neigh->network->channel))
if(channels_interfere(ifp->channel, route->neigh->ifp->channel))
return 1;
if(diversity_kind == DIVERSITY_CHANNEL) {
int i;
for(i = 0; i < DIVERSITY_HOPS; i++) {
if(route->channels[i] == 0)
break;
if(channels_interfere(net->channel, route->channels[i]))
if(channels_interfere(ifp->channel, route->channels[i]))
return 1;
}
}
......@@ -391,7 +391,7 @@ update_route_metric(struct route *route)
int add_metric = input_filter(route->src->id,
route->src->prefix, route->src->plen,
neigh->address,
neigh->network->ifindex);
neigh->ifp->ifindex);
change_route_metric(route, route->refmetric,
neighbour_cost(route->neigh), add_metric);
if(route_metric(route) != oldmetric)
......@@ -420,13 +420,13 @@ update_neighbour_metric(struct neighbour *neigh, int changed)
}
void
update_network_metric(struct network *net)
update_interface_metric(struct interface *ifp)
{
int i;
i = 0;
while(i < numroutes) {
if(routes[i].neigh->network == net)
if(routes[i].neigh->ifp == ifp)
update_route_metric(&routes[i]);
i++;
}
......@@ -456,7 +456,7 @@ update_route(const unsigned char *a, const unsigned char *p, unsigned char plen,
}
add_metric = input_filter(a, p, plen,
neigh->address, neigh->network->ifindex);
neigh->address, neigh->ifp->ifindex);
if(add_metric >= INFINITY)
return NULL;
......
route.h
View file @ 1c3b2bb8
......@@ -71,14 +71,14 @@ struct route *find_installed_route(const unsigned char *prefix,
unsigned char plen);
void flush_route(struct route *route);
void flush_neighbour_routes(struct neighbour *neigh);
void flush_network_routes(struct network *net, int v4only);
void flush_interface_routes(struct interface *ifp, int v4only);
void install_route(struct route *route);
void uninstall_route(struct route *route);
void switch_route(struct route *old, struct route *new);
int route_feasible(struct route *route);
int route_old(struct route *route);
int route_expired(struct route *route);
int route_interferes(struct route *route, struct network *net);
int route_interferes(struct route *route, struct interface *ifp);
int update_feasible(struct source *src,
unsigned short seqno, unsigned short refmetric);
struct route *find_best_route(const unsigned char *prefix, unsigned char plen,
......@@ -86,7 +86,7 @@ struct route *find_best_route(const unsigned char *prefix, unsigned char plen,
struct route *install_best_route(const unsigned char prefix[16],
unsigned char plen);
void update_neighbour_metric(struct neighbour *neigh, int changed);
void update_network_metric(struct network *net);
void update_interface_metric(struct interface *ifp);
void update_route_metric(struct route *route);
struct route *update_route(const unsigned char *a,
const unsigned char *p, unsigned char plen,
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7