/**
* Initialize the value buffers for an OLSRv2 attached network
* @param edge attached network edge
*/
static void
_initialize_attached_network_values(struct olsrv2_tc_attachment *edge) {
netaddr_to_string(&_value_attached_net_dst, &edge->dst->target.prefix.dst);
netaddr_to_string(&_value_attached_net_src, &edge->dst->target.prefix.src);
snprintf(_value_attached_net_ansn, sizeof(_value_attached_net_ansn), "%u", edge->ansn);
}
/*
* Check if entry at index i is stale as described in Section 6.3.
* and clear the struct it fills if it is
*/
static void _reset_entry_if_stale(uint8_t i)
{
vtimer_now(&now);
timex_t lastUsed, expirationTime;
if (timex_cmp(routing_table[i].expirationTime, null_time) == 0) {
return;
}
int state = routing_table[i].state;
lastUsed = routing_table[i].lastUsed;
expirationTime = routing_table[i].expirationTime;
/* an Active route is considered to remain Active as long as it is used at least once
* during every ACTIVE_INTERVAL. When a route is no longer Active, it becomes an Idle route. */
/* if the node is younger than the active interval, don't bother */
if (timex_cmp(now, active_interval) < 0) {
return;
}
if ((state == ROUTE_STATE_ACTIVE) &&
(timex_cmp(timex_sub(now, active_interval), lastUsed) == 1)) {
DEBUG("\t[routing] route towards %s Idle\n",
netaddr_to_string(&nbuf, &routing_table[i].addr));
routing_table[i].state = ROUTE_STATE_IDLE;
routing_table[i].lastUsed = now; /* mark the time entry was set to Idle */
}
/* After an Idle route remains Idle for MAX_IDLETIME, it becomes an Invalid route. */
/* if the node is younger than the expiration time, don't bother */
if (timex_cmp(now, expirationTime) < 0) {
return;
}
/* If Current_Time > Route.ExpirationTime, set Route.State := Invalid. */
if ((state == ROUTE_STATE_IDLE) &&
(timex_cmp(now, expirationTime) > 0)) {
DEBUG("\t[routing] route towards %s became Invalid\n",
netaddr_to_string(&nbuf, &routing_table[i].addr));
routing_table[i].state = ROUTE_STATE_INVALID;
routing_table[i].lastUsed = now; /* mark the time entry was set to Invalid */
}
/* If (Current_Time - Route.LastUsed) > (ACTIVE_INTERVAL + MAX_IDLETIME),
* and if (Route.Timed == FALSE), set Route.State := Invalid. */
if ((timex_cmp(timex_sub(now, lastUsed), timex_add(active_interval, max_idletime)) > 0) &&
(state != ROUTE_STATE_TIMED)) {
routing_table[i].state = ROUTE_STATE_INVALID;
}
/* After that time, old sequence number information is considered no longer
* valid and the Invalid route MUST BE expunged */
if (timex_cmp(timex_sub(now, lastUsed), max_seqnum_lifetime) >= 0) {
DEBUG("\t[routing] Expunged routing table entry for %s at %i\n",
netaddr_to_string(&nbuf, &routing_table[i].addr), i);
memset(&routing_table[i], 0, sizeof(routing_table[i]));
}
}
static void
test_netaddr_is_in_subnet(void) {
struct netaddr_str str1, str2;
size_t a, s;
START_TEST();
for (s = 0; s < sizeof(in_subnet_subnets) / sizeof(*in_subnet_subnets); s++) {
for (a = 0; a < sizeof(in_subnet_addrs) / sizeof(*in_subnet_addrs); a++) {
CHECK_TRUE(
in_subnet_results[a][s] == netaddr_binary_is_in_subnet(&in_subnet_subnets[s], &in_subnet_addrs[a],
netaddr_get_maxprefix(&in_subnet_addrs[a])/8, in_subnet_addrs[a]._type),
"%s should %sbe in %s",
netaddr_to_string(&str1, &in_subnet_addrs[a]),
in_subnet_results[a][s] ? "" : "not ",
netaddr_to_string(&str2, &in_subnet_subnets[s]));
CHECK_TRUE(
in_subnet_results[a][s] == netaddr_is_in_subnet(&in_subnet_subnets[s], &in_subnet_addrs[a]),
"%s should %sbe in %s",
netaddr_to_string(&str1, &in_subnet_addrs[a]),
in_subnet_results[a][s] ? "" : "not ",
netaddr_to_string(&str2, &in_subnet_subnets[s]));
}
}
END_TEST();
}
/**
* Initialize the value buffers for a OLSRv2 route
* @param route OLSRv2 routing entry
*/
static void
_initialize_route_values(struct olsrv2_routing_entry *route) {
netaddr_to_string(&_value_route_dst, &route->route.p.key.dst);
netaddr_to_string(&_value_route_gw, &route->route.p.gw);
netaddr_to_string(&_value_route_src_ip, &route->route.p.src_ip);
netaddr_to_string(&_value_route_src_prefix, &route->route.p.key.src);
snprintf(_value_route_metric, sizeof(_value_route_metric), "%u", route->route.p.metric);
snprintf(_value_route_table, sizeof(_value_route_table), "%u", route->route.p.table);
snprintf(_value_route_proto, sizeof(_value_route_proto), "%u", route->route.p.protocol);
if_indextoname(route->route.p.if_index, _value_route_if);
snprintf(_value_route_ifindex, sizeof(_value_route_ifindex), "%u", route->route.p.if_index);
netaddr_to_string(&_value_route_lasthop, &route->last_originator);
}
/**
* Print start of message
* @param context rfc5444 tlvblock reader context
* @return see rfc5444_result enum
*/
enum rfc5444_result
_cb_print_msg_start(struct rfc5444_reader_tlvblock_context *context)
{
struct rfc5444_print_session *session;
struct netaddr_str buf;
assert(context->type == RFC5444_CONTEXT_MESSAGE);
session = container_of(context->consumer, struct rfc5444_print_session, _msg);
abuf_puts(session->output, "\t| ,-------------------\n");
abuf_puts(session->output, "\t| | MESSAGE\n");
abuf_puts(session->output, "\t| |-------------------\n");
abuf_appendf(session->output, "\t| | * Message type: %u\n", context->msg_type);
abuf_appendf(session->output, "\t| | * Message flags: 0x%02x\n", context->msg_flags);
abuf_appendf(session->output, "\t| | * Address length: %u\n", context->addr_len);
if (context->has_origaddr) {
abuf_appendf(session->output, "\t| | * Originator address: %s\n", netaddr_to_string(&buf, &context->orig_addr));
}
if (context->has_hoplimit) {
abuf_appendf(session->output, "\t| | * Hop limit: %u\n", context->hoplimit);
}
if (context->has_hopcount) {
abuf_appendf(session->output, "\t| | * Hop count: %u\n", context->hopcount);
}
if (context->has_seqno) {
abuf_appendf(session->output, "\t| | * Message seq number: %u\n", context->seqno);
}
return RFC5444_OKAY;
}
void routingtable_break_and_get_all_hopping_over(struct netaddr *hop,
struct unreachable_node unreachable_nodes[],
size_t *len)
{
*len = 0; /* to be sure */
for (unsigned i = 0; i < AODVV2_MAX_ROUTING_ENTRIES; i++) {
_reset_entry_if_stale(i);
if (netaddr_cmp(&routing_table[i].nextHopAddr, hop) == 0) {
if (routing_table[i].state == ROUTE_STATE_ACTIVE &&
*len < AODVV2_MAX_UNREACHABLE_NODES) {
/* when the max number of unreachable nodes is reached we're screwed.
* the above check is just damage control. */
unreachable_nodes[*len].addr = routing_table[i].addr;
unreachable_nodes[*len].seqnum = routing_table[i].seqnum;
(*len)++;
DEBUG("\t[routing] unreachable node found: %s\n", netaddr_to_string(&nbuf, &routing_table[i].nextHopAddr));
}
routing_table[i].state = ROUTE_STATE_INVALID;
DEBUG("\t[routing] number of unreachable nodes: %i\n", *len);
}
}
}
/**
* This block callback is called for every address of a RREQ Message.
*
* @param cont
* @return
*/
static enum rfc5444_result _cb_rreq_blocktlv_addresstlvs_okay(struct rfc5444_reader_tlvblock_context *cont)
{
#if ENABLE_DEBUG
struct netaddr_str nbuf;
#endif
struct rfc5444_reader_tlvblock_entry *tlv;
bool is_origNode_addr = false;
bool is_targNode_addr = false;
VDEBUG("%s()\n", __func__);
DEBUG("\taddr: %s\n", netaddr_to_string(&nbuf, &cont->addr));
/* handle OrigNode SeqNum TLV */
tlv = _rreq_rrep_address_consumer_entries[RFC5444_MSGTLV_ORIGSEQNUM].tlv;
if (tlv) {
DEBUG("\ttlv RFC5444_MSGTLV_ORIGSEQNUM: %d\n", *tlv->single_value);
is_origNode_addr = true;
packet_data.origNode.addr = cont->addr;
packet_data.origNode.seqnum = *tlv->single_value;
}
/* handle TargNode SeqNum TLV */
tlv = _rreq_rrep_address_consumer_entries[RFC5444_MSGTLV_TARGSEQNUM].tlv;
if (tlv) {
DEBUG("\ttlv RFC5444_MSGTLV_TARGSEQNUM: %d\n", *tlv->single_value);
is_targNode_addr = true;
packet_data.targNode.addr = cont->addr;
packet_data.targNode.seqnum = *tlv->single_value;
}
if (!tlv && !is_origNode_addr) {
/* assume that tlv missing => targNode Address */
is_targNode_addr = true;
packet_data.targNode.addr = cont->addr;
}
if (!is_origNode_addr && !is_targNode_addr) {
DEBUG("\tERROR: mandatory RFC5444_MSGTLV_ORIGSEQNUM TLV missing.\n");
return RFC5444_DROP_PACKET;
}
/* handle Metric TLV */
/* cppcheck: suppress false positive on non-trivially initialized arrays.
* this is a known bug: http://trac.cppcheck.net/ticket/5497 */
/* cppcheck-suppress arrayIndexOutOfBounds */
tlv = _rreq_rrep_address_consumer_entries[RFC5444_MSGTLV_METRIC].tlv;
if (!tlv && is_origNode_addr) {
DEBUG("\tERROR: Missing or unknown metric TLV.\n");
return RFC5444_DROP_PACKET;
}
if (tlv) {
if (!is_origNode_addr) {
DEBUG("\tERROR: Metric TLV belongs to wrong address.\n");
return RFC5444_DROP_PACKET;
}
VDEBUG("\ttlv RFC5444_MSGTLV_METRIC val: %d, exttype: %d\n",
*tlv->single_value, tlv->type_ext);
packet_data.metricType = tlv->type_ext;
packet_data.origNode.metric = *tlv->single_value;
}
return RFC5444_OKAY;
}
/**
* Join a socket into a multicast group
* @param sock filedescriptor of socket
* @param multicast multicast ip/port to join
* @param os_if pointer to outgoing interface data for multicast
* @param loop true if multicast loop should be activated, false otherwise
* @param log_src logging source for error messages
* @return -1 if an error happened, 0 otherwise
*/
int
os_fd_generic_join_mcast_send(struct os_fd *sock,
const struct netaddr *multicast,
const struct os_interface *os_if, bool loop,
enum oonf_log_source log_src __attribute__((unused))) {
struct netaddr_str buf1, buf2;
unsigned i;
if (netaddr_get_address_family(multicast) == AF_INET) {
OONF_DEBUG(log_src,
"Socket on interface %s joining sending multicast %s (src %s)\n",
os_if->name,
netaddr_to_string(&buf2, multicast),
netaddr_to_string(&buf1, os_if->if_v4));
if (setsockopt(sock->fd, IPPROTO_IP, IP_MULTICAST_IF, netaddr_get_binptr(os_if->if_v4), 4) < 0) {
OONF_WARN(log_src, "Cannot set multicast %s on interface %s (src %s): %s (%d)\n",
netaddr_to_string(&buf2, multicast),
os_if->name,
netaddr_to_string(&buf1, os_if->if_v4),
strerror(errno), errno);
return -1;
}
i = loop ? 1 : 0;
if(setsockopt(sock->fd, IPPROTO_IP, IP_MULTICAST_LOOP, (char *)&i, sizeof(i)) < 0) {
OONF_WARN(log_src, "Cannot %sactivate local loop of multicast interface: %s (%d)\n",
loop ? "" : "de", strerror(errno), errno);
return -1;
}
}
else {
OONF_DEBUG(log_src,
"Socket on interface %s (%d) joining sending multicast %s (src %s)\n",
os_if->name, os_if->index,
netaddr_to_string(&buf2, multicast),
netaddr_to_string(&buf1, os_if->if_linklocal_v6));
if (setsockopt(sock->fd, IPPROTO_IPV6, IPV6_MULTICAST_IF,
&os_if->index, sizeof(os_if->index)) < 0) {
OONF_WARN(log_src, "Cannot set multicast %s on interface %s (src %s): %s (%d)\n",
netaddr_to_string(&buf2, multicast),
os_if->name,
netaddr_to_string(&buf1, os_if->if_linklocal_v6),
strerror(errno), errno);
return -1;
}
i = loop ? 1 : 0;
if(setsockopt(sock->fd, IPPROTO_IPV6, IPV6_MULTICAST_LOOP, &i, sizeof(i)) < 0) {
OONF_WARN(log_src, "Cannot deactivate local loop of multicast interface: %s (%d)\n",
strerror(errno), errno);
return -1;
}
}
return 0;
}
int aodv_packet_reader_handle_packet(void *buffer, size_t length, struct netaddr *sender)
{
AODV_DEBUG("%s()\n", __func__);
memcpy(&packet_data.sender, sender, sizeof(*sender));
DEBUG("\t sender: %s\n", netaddr_to_string(&nbuf, &packet_data.sender));
return rfc5444_reader_handle_packet(&reader, buffer, length);
}
void print_routingtable_entry(struct aodvv2_routing_entry_t *rt_entry)
{
struct netaddr_str nbuf;
printf(".................................\n");
printf("\t address: %s\n", netaddr_to_string(&nbuf, &(rt_entry->addr)));
printf("\t seqnum: %i\n", rt_entry->seqnum);
printf("\t nextHopAddress: %s\n",
netaddr_to_string(&nbuf, &(rt_entry->nextHopAddr)));
printf("\t lastUsed: %"PRIu32":%"PRIu32"\n",
rt_entry->lastUsed.seconds, rt_entry->lastUsed.microseconds);
printf("\t expirationTime: %"PRIu32":%"PRIu32"\n",
rt_entry->expirationTime.seconds, rt_entry->expirationTime.microseconds);
printf("\t metricType: %i\n", rt_entry->metricType);
printf("\t metric: %d\n", rt_entry->metric);
printf("\t state: %d\n", rt_entry->state);
}
/**
* Process NL80211_CMD_NEW_MPATH message
* @param interf nl80211 listener interface
* @param hdr pointer to netlink message header
*/
void
nl80211_process_get_mpp_result(struct nl80211_if *interf,
struct nlmsghdr *hdr) {
struct oonf_layer2_destination *l2dst;
struct oonf_layer2_neigh *l2neigh;
struct netaddr remote_mac, destination_mac;
#ifdef OONF_LOG_DEBUG_INFO
struct netaddr_str nbuf1, nbuf2;
#endif
struct nlattr *tb[NL80211_ATTR_MAX + 1];
struct genlmsghdr *gnlh;
gnlh = nlmsg_data(hdr);
nla_parse(tb, NL80211_ATTR_MAX, genlmsg_attrdata(gnlh, 0),
genlmsg_attrlen(gnlh, 0), NULL);
if (nl80211_get_if_index(interf) != nla_get_u32(tb[NL80211_ATTR_IFINDEX])) {
/* wrong interface ? */
return;
}
netaddr_from_binary(&remote_mac,
nla_data(tb[NL80211_ATTR_MPATH_NEXT_HOP]), 6, AF_MAC48);
netaddr_from_binary(&destination_mac,
nla_data(tb[NL80211_ATTR_MAC]), 6, AF_MAC48);
l2neigh = oonf_layer2_neigh_get(interf->l2net, &remote_mac);
if (!l2neigh) {
/* don't create a neighbor, just ignore the MPP data */
return;
}
l2dst = nl80211_add_dst(l2neigh, &destination_mac);
if (!l2dst) {
return;
}
OONF_DEBUG(LOG_NL80211, "Neighbor %s was proxied by mesh node %s",
netaddr_to_string(&nbuf1, &destination_mac),
netaddr_to_string(&nbuf2, &remote_mac));
}
/**
* Initialize the value buffers for an OLSRv2 node
* @param node OLSRv2 node
*/
static void
_initialize_node_values(struct olsrv2_tc_node *node) {
netaddr_to_string(&_value_node, &node->target.prefix.dst);
oonf_clock_toIntervalString(&_value_node_vtime, oonf_timer_get_due(&node->_validity_time));
snprintf(_value_node_ansn, sizeof(_value_node_ansn), "%u", node->ansn);
strscpy(_value_node_virtual, json_getbool(!oonf_timer_is_active(&node->_validity_time)), sizeof(_value_node_virtual));
strscpy(_value_node_neighbor, json_getbool(node->direct_neighbor), sizeof(_value_node_neighbor));
}
/**
* Join a socket into a multicast group
* @param sock filedescriptor of socket
* @param multicast multicast-group to join
* @param os_if pointer to outgoing interface data for multicast
* @param log_src logging source for error messages
* @return -1 if an error happened, 0 otherwise
*/
int
os_fd_generic_join_mcast_recv(struct os_fd *sock,
const struct netaddr *multicast,
const struct os_interface *os_if,
enum oonf_log_source log_src __attribute__((unused))) {
struct netaddr_str buf1, buf2;
struct ip_mreq v4_mreq;
struct ipv6_mreq v6_mreq;
const char *ifname = "*";
if (os_if) {
ifname = os_if->name;
}
if (netaddr_get_address_family(multicast) == AF_INET) {
const struct netaddr *src;
src = os_if == NULL ? &NETADDR_IPV4_ANY : os_if->if_v4;
OONF_DEBUG(log_src,
"Socket on interface %s joining receiving multicast %s (src %s)\n",
ifname, netaddr_to_string(&buf2, multicast),
netaddr_to_string(&buf1, src));
netaddr_to_binary(&v4_mreq.imr_multiaddr, multicast, 4);
netaddr_to_binary(&v4_mreq.imr_interface, src, 4);
if (setsockopt(sock->fd, IPPROTO_IP, IP_ADD_MEMBERSHIP,
&v4_mreq, sizeof(v4_mreq)) < 0) {
OONF_WARN(log_src, "Cannot join multicast group %s (src %s) on interface %s: %s (%d)\n",
netaddr_to_string(&buf1, multicast),
netaddr_to_string(&buf2, src),
ifname, strerror(errno), errno);
return -1;
}
}
else {
int if_index;
if_index = os_if == NULL ? 0 : os_if->index;
OONF_DEBUG(log_src,
"Socket on interface %s joining receiving multicast %s (if %d)\n",
ifname, netaddr_to_string(&buf2, multicast), if_index);
netaddr_to_binary(&v6_mreq.ipv6mr_multiaddr, multicast, 16);
v6_mreq.ipv6mr_interface = if_index;
if (setsockopt(sock->fd, IPPROTO_IPV6, IPV6_JOIN_GROUP,
&v6_mreq, sizeof(v6_mreq)) < 0) {
OONF_WARN(log_src, "Cannot join multicast group %s on interface %s: %s (%d)\n",
netaddr_to_string(&buf1, multicast),
ifname,
strerror(errno), errno);
return -1;
}
}
return 0;
}
static enum rfc5444_result _cb_rerr_blocktlv_addresstlvs_okay(struct rfc5444_reader_tlvblock_context *cont)
{
#if ENABLE_DEBUG
/* cppcheck-suppress unusedVariable as nbuf is needed by VDEBUG. */
struct netaddr_str nbuf;
#endif
struct aodvv2_routing_entry_t *unreachable_entry;
struct rfc5444_reader_tlvblock_entry *tlv;
VDEBUG("%s()\n", __func__);
VDEBUG("\tmessage type: %d\n", cont->type);
VDEBUG("\taddr: %s\n", netaddr_to_string(&nbuf, &cont->addr));
/* Out of buffer size for more unreachable nodes. We're screwed, basically. */
if (num_unreachable_nodes == AODVV2_MAX_UNREACHABLE_NODES) {
return RFC5444_OKAY;
}
/* gather packet data */
packet_data.origNode.addr = cont->addr;
/* handle this unreachable node's SeqNum TLV */
/* cppcheck: suppress false positive on non-trivially initialized arrays.
* this is a known bug: http://trac.cppcheck.net/ticket/5497 */
/* cppcheck-suppress arrayIndexOutOfBounds */
tlv = _rerr_address_consumer_entries[RFC5444_MSGTLV_UNREACHABLE_NODE_SEQNUM].tlv;
if (tlv) {
VDEBUG("\ttlv RFC5444_MSGTLV_UNREACHABLE_NODE_SEQNUM: %d\n", *tlv->single_value);
packet_data.origNode.seqnum = *tlv->single_value;
}
/* Check if there is an entry for unreachable node in our routing table */
unreachable_entry = routingtable_get_entry(&packet_data.origNode.addr, packet_data.metricType);
if (unreachable_entry) {
VDEBUG("\t found possibly unreachable entry.\n");
/* check if route to unreachable node has to be marked as broken and RERR has to be forwarded */
if (netaddr_cmp(&unreachable_entry->nextHopAddr, &packet_data.sender) == 0
&& (!tlv || seqnum_cmp(unreachable_entry->seqnum, packet_data.origNode.seqnum) == 0)) {
unreachable_entry->state = ROUTE_STATE_INVALID;
unreachable_nodes[num_unreachable_nodes].addr = packet_data.origNode.addr;
unreachable_nodes[num_unreachable_nodes].seqnum = packet_data.origNode.seqnum;
num_unreachable_nodes++;
}
/* remove entry from FIB */
fib_remove_entry(packet_data.origNode.addr._addr, sizeof(ipv6_addr_t));
}
return RFC5444_OKAY;
}
/**
* Print start of address
* @param context rfc5444 tlvblock reader context
* @return see rfc5444_result enum
*/
enum rfc5444_result
_cb_print_addr_start(struct rfc5444_reader_tlvblock_context *context)
{
struct rfc5444_print_session *session;
struct netaddr_str buf;
assert(context->type == RFC5444_CONTEXT_ADDRESS);
session = container_of(context->consumer, struct rfc5444_print_session, _addr);
abuf_puts(session->output, "\t| | ,-------------------\n");
abuf_appendf(session->output, "\t| | | Address: %s\n", netaddr_to_string(&buf, &context->addr));
return RFC5444_OKAY;
}
static void
test_netaddr_create_host(void) {
struct netaddr netmask, host, result;
struct netaddr_str buf1, buf2, buf3;
char buffer1[17], buffer2[17];
size_t i;
memset(buffer1, 255, sizeof(buffer1));
memset(buffer2, 0, sizeof(buffer2));
START_TEST();
for (i=0; i<ARRAYSIZE(_create_host_test); i++) {
CHECK_TRUE(netaddr_from_string(&netmask, _create_host_test[i].netmask) == 0,
"error in parsing netmask %"PRINTF_SIZE_T_SPECIFIER" %s", i, _create_host_test[i].netmask);
CHECK_TRUE(netaddr_from_string(&result, _create_host_test[i].result) == 0,
"error in parsing result %"PRINTF_SIZE_T_SPECIFIER" %s", i, _create_host_test[i].result);
if (_create_host_test[i].buf_len >= 0) {
CHECK_TRUE(netaddr_create_host_bin(&host, &netmask, buffer1, _create_host_test[i].buf_len) == 0,
"error in creating host %"PRINTF_SIZE_T_SPECIFIER" %s with length %d",
i, netaddr_to_string(&buf1, &netmask), _create_host_test[i].buf_len);
}
else {
CHECK_TRUE(netaddr_create_host_bin(&host, &netmask, buffer2, -_create_host_test[i].buf_len) == 0,
"error in creating host %"PRINTF_SIZE_T_SPECIFIER" %s with length %d",
i, netaddr_to_string(&buf1, &netmask), _create_host_test[i].buf_len);
}
CHECK_TRUE(netaddr_cmp(&host, &result) == 0,
"Error, host %"PRINTF_SIZE_T_SPECIFIER" %s != result %s (netmask %s, len=%d)",
i, netaddr_to_string(&buf1, &host), netaddr_to_string(&buf2, &result),
netaddr_to_string(&buf3, &netmask), _create_host_test[i].buf_len);
}
END_TEST();
}
/*
* Check if entry at index i is stale and clear the struct it fills if it is
*/
static void _reset_entry_if_stale(uint8_t i)
{
vtimer_now(&now);
if (timex_cmp(rreq_table[i].timestamp, null_time) == 0) {
return;
}
timex_t expiration_time = timex_add(rreq_table[i].timestamp, _max_idletime);
if (timex_cmp(expiration_time, now) < 0) {
/* timestamp+expiration time is in the past: this entry is stale */
DEBUG("\treset rreq table entry %s\n",
netaddr_to_string(&nbuf, &rreq_table[i].origNode));
memset(&rreq_table[i], 0, sizeof(rreq_table[i]));
}
}
static void
test_netaddr_is_in_subnet(void) {
struct netaddr_str str1, str2;
size_t a, s;
START_TEST();
for (s = 0; s < sizeof(in_subnet_subnets) / sizeof(*in_subnet_subnets); s++) {
for (a = 0; a < sizeof(in_subnet_addrs) / sizeof(*in_subnet_addrs); a++) {
CHECK_TRUE(
in_subnet_results[a][s] == netaddr_binary_is_in_subnet(&in_subnet_subnets[s], &in_subnet_addrs[a], 4, AF_INET),
"%s is not in %s",
netaddr_to_string(&str1, &in_subnet_addrs[a]),
netaddr_to_string(&str2, &in_subnet_subnets[s]));
CHECK_TRUE(
in_subnet_results[a][s] == netaddr_is_in_subnet(&in_subnet_subnets[s], &in_subnet_addrs[a]),
"%s is not in %s",
netaddr_to_string(&str1, &in_subnet_addrs[a]),
netaddr_to_string(&str2, &in_subnet_subnets[s]));
}
}
END_TEST();
}
struct aodvv2_routing_entry_t *routingtable_get_entry(struct netaddr *addr,
aodvv2_metric_t metricType)
{
for (unsigned i = 0; i < AODVV2_MAX_ROUTING_ENTRIES; i++) {
_reset_entry_if_stale(i);
if (!netaddr_cmp(&routing_table[i].addr, addr)
&& routing_table[i].metricType == metricType) {
DEBUG("[routing] found entry for %s :", netaddr_to_string(&nbuf, addr));
#if ENABLE_DEBUG
print_routingtable_entry(&routing_table[i]);
#endif
return &routing_table[i];
}
}
return NULL;
}
void clienttable_add_client(struct netaddr *addr)
{
if (clienttable_is_client(addr)){
return;
}
/*find free spot in client table and place client address there */
mutex_lock(&clientt_mutex);
for (unsigned i = 0; i < AODVV2_MAX_CLIENTS; i++) {
if ((client_table[i]._type == AF_UNSPEC) &&
(client_table[i]._prefix_len == 0)) {
client_table[i] = *addr;
AODV_DEBUG("clienttable: added client %s\n",
netaddr_to_string(&nbuf, addr));
mutex_unlock(&clientt_mutex);
return;
}
}
AODV_DEBUG("Error: Client could not be added: Client table is full.\n");
mutex_unlock(&clientt_mutex);
}
static void
test_netaddr_to_string(void) {
size_t i;
const char *ptr;
struct netaddr_str strbuf;
START_TEST();
/* test successful netaddr to string conversions first */
for (i=0; i<sizeof(string_tests) / sizeof(*string_tests); i++) {
ptr = netaddr_to_string(&strbuf, &string_tests[i].bin);
CHECK_TRUE(ptr == strbuf.buf, "netaddr_to_string %s return error condition",
string_tests[i].str);
if(ptr != NULL) {
CHECK_TRUE(strcmp(string_tests[i].str, ptr) == 0,
"netaddr_to_string %s != %s return value", string_tests[i].str, ptr);
}
}
END_TEST();
}
/**
* Initialize the value buffer for a LAN entry
* @param lan OLSRv2 LAN entry
*/
static void
_initialize_lan_values(struct olsrv2_lan_entry *lan) {
netaddr_to_string(&_value_lan_dst, &lan->prefix.dst);
netaddr_to_string(&_value_lan_src, &lan->prefix.src);
}
/**
* Apply new configuration to a managed stream socket
* @param managed pointer to managed stream
* @param stream pointer to TCP stream to configure
* @param bindto local address to bind socket to
* set to AF_UNSPEC for simple reinitialization
* @param port local port number
* @param dscp dscp value for outgoing traffic
* @param protocol IP protocol for raw IP socket, 0 otherwise
* @param data interface data to bind socket to, might be NULL
* @return -1 if an error happened, 0 if everything is okay,
* 1 if the socket wasn't touched.
*/
static int
_apply_managed_socket(struct oonf_packet_managed *managed,
struct oonf_packet_socket *packet,
const struct netaddr *bindto, int port, uint8_t dscp,
int protocol, struct os_interface *data) {
union netaddr_socket sock;
struct netaddr_str buf;
/* create binding socket */
if (netaddr_socket_init(&sock, bindto, port,
data == NULL ? 0 : data->index)) {
OONF_WARN(LOG_PACKET, "Cannot create managed socket address: %s/%u",
netaddr_to_string(&buf, bindto), port);
return -1;
}
if (list_is_node_added(&packet->node)) {
if (data == packet->os_if
&& memcmp(&sock, &packet->local_socket, sizeof(sock)) == 0
&& protocol == packet->protocol) {
/* nothing changed */
return 1;
}
}
else {
if (data != NULL && !data->flags.up) {
/* nothing changed */
return 1;
}
}
/* remove old socket */
oonf_packet_remove(packet, true);
if (data != NULL && !data->flags.up) {
OONF_DEBUG(LOG_PACKET, "Interface %s of socket is down",
data->name);
return 0;
}
/* copy configuration */
memcpy(&packet->config, &managed->config, sizeof(packet->config));
if (packet->config.user == NULL) {
packet->config.user = managed;
}
/* create new socket */
if (protocol) {
if (oonf_packet_raw_add(packet, protocol, &sock, data)) {
return -1;
}
}
else {
if (oonf_packet_add(packet, &sock, data)) {
return -1;
}
}
if (os_fd_set_dscp(&packet->scheduler_entry.fd, dscp,
netaddr_get_address_family(bindto) == AF_INET6)) {
OONF_WARN(LOG_PACKET, "Could not set DSCP value for socket: %s (%d)",
strerror(errno), errno);
oonf_packet_remove(packet, true);
return -1;
}
packet->os_if = data;
OONF_DEBUG(LOG_PACKET, "Opened new socket and bound it to %s (if %s)",
netaddr_to_string(&buf, bindto),
data != NULL ? data->name : "any");
return 0;
}
/**
* This callback is called every time the _rreq_consumer finishes reading a
* packet.
* @param cont
* @param dropped indicates wehther the packet has been dropped previously by
* another callback
*/
static enum rfc5444_result _cb_rrep_end_callback(
struct rfc5444_reader_tlvblock_context *cont, bool dropped)
{
(void) cont;
VDEBUG("%s()\n", __func__);
struct aodvv2_routing_entry_t *rt_entry;
#if ENABLE_DEBUG
struct netaddr_str nbuf;
#endif
timex_t now;
/* Check if packet contains the required information */
if (dropped) {
DEBUG("\t Dropping packet.\n");
return RFC5444_DROP_PACKET;
}
if ((packet_data.origNode.addr._type == AF_UNSPEC)
|| !packet_data.origNode.seqnum) {
DEBUG("\tERROR: missing OrigNode Address or SeqNum. Dropping packet.\n");
return RFC5444_DROP_PACKET;
}
if ((packet_data.targNode.addr._type == AF_UNSPEC)
|| !packet_data.targNode.seqnum) {
DEBUG("\tERROR: missing TargNode Address or SeqNum. Dropping packet.\n");
return RFC5444_DROP_PACKET;
}
if ((_get_max_metric(packet_data.metricType) - _get_link_cost(packet_data.metricType))
<= packet_data.targNode.metric) {
DEBUG("\tMetric Limit reached. Dropping packet.\n");
return RFC5444_DROP_PACKET;
}
/* Update the cost of the route, since the packet has successfully traversed
* one more hop. */
packet_data.targNode.metric = _get_route_cost(packet_data.metricType,
packet_data.targNode.metric);
vtimer_now(&now);
packet_data.timestamp = now;
/* for every relevant address (RteMsg.Addr) in the RteMsg, HandlingRtr
searches its route table to see if there is a route table entry with the
same MetricType of the RteMsg, matching RteMsg.Addr. */
rt_entry = routingtable_get_entry(&packet_data.targNode.addr, packet_data.metricType);
if (!rt_entry || (rt_entry->metricType != packet_data.metricType)) {
/* CAUTION SUPER HACKY FIX FIXME ASAP
problem: sometimes we get broadcasted RREQs from 2 hop neighbors and then
AODVv2 gets super confused when they're not in the routing table and starts a
Route discovery to find them and all hell breaks loose. let's see if we can fix
this (horribly).
(another fix would be to stop bouncing the RREP back to the sender and asking
the routing table for the next hop (or just send towards TargNode and let the network stack figure out the rest?))
TODO evaluate that
*/
ipv6_addr_t sender_tmp;
netaddr_to_ipv6_addr_t(&packet_data.sender, &sender_tmp);
ndp_neighbor_cache_t *ndp_nc_entry = ndp_neighbor_cache_search(&sender_tmp);
if (ndp_nc_entry == NULL) {
DEBUG("OH NOES! No bidirectional link to sender. Dropping packet.\n");
return RFC5444_DROP_PACKET;
}
/* HACKY FIX ENDS HERE */
VDEBUG("\tCreating new Routing Table entry...\n");
struct aodvv2_routing_entry_t *tmp_rt_entry = (struct aodvv2_routing_entry_t *)
malloc(sizeof(struct aodvv2_routing_entry_t));
memset(tmp_rt_entry, 0, sizeof(*tmp_rt_entry));
routingtable_fill_routing_entry_t_rrep(&packet_data, tmp_rt_entry);
routingtable_add_entry(tmp_rt_entry);
/* add entry to FIB */
fib_add_entry(aodvv2_if_id, tmp_rt_entry->addr._addr, sizeof(ipv6_addr_t), 0,
tmp_rt_entry->nextHopAddr._addr, sizeof(ipv6_addr_t), 0, aodvv2_validity_t);
free(tmp_rt_entry);
}
else {
if (!routingtable_offers_improvement(rt_entry, &packet_data.targNode)) {
DEBUG("\tPacket offers no improvement over known route. Dropping Packet.\n");
return RFC5444_DROP_PACKET;
}
/* The incoming routing information is better than existing routing
* table information and SHOULD be used to improve the route table. */
VDEBUG("\tUpdating Routing Table entry...\n");
routingtable_fill_routing_entry_t_rrep(&packet_data, rt_entry);
/* update the FIB */
fib_update_entry(rt_entry->addr._addr, sizeof(ipv6_addr_t), rt_entry->nextHopAddr._addr,
sizeof(ipv6_addr_t), 0, aodvv2_validity_t);
}
/* If HandlingRtr is RREQ_Gen then the RREP satisfies RREQ_Gen's
earlier RREQ, and RREP processing is completed. Any packets
buffered for OrigNode should be transmitted. */
if (clienttable_is_client(&packet_data.origNode.addr)) {
#if ENABLE_DEBUG
static struct netaddr_str nbuf2;
#endif
DEBUG("\t{%" PRIu32 ":%" PRIu32 "} %s: This is my RREP (SeqNum: %d). We are done here, thanks %s!\n",
now.seconds, now.microseconds, netaddr_to_string(&nbuf, &packet_data.origNode.addr),
packet_data.origNode.seqnum, netaddr_to_string(&nbuf2, &packet_data.targNode.addr));
}
else {
/* If HandlingRtr is not RREQ_Gen then the outgoing RREP is sent to the
* Route.NextHopAddress for the RREP.AddrBlk[OrigNodeNdx]. */
AODV_DEBUG("Not my RREP, passing it on to the next hop\n");
aodv_send_rrep(&packet_data,
routingtable_get_next_hop(&packet_data.origNode.addr,packet_data.metricType));
}
return RFC5444_OKAY;
}
/**
* Initialize the value buffer for old originator entries
* @param entry originator set entry
*/
static void
_initialize_old_originator_values(struct olsrv2_originator_set_entry *entry) {
netaddr_to_string(&_value_old_originator, &entry->originator);
oonf_clock_toIntervalString(&_value_old_originator_vtime, oonf_timer_get_due(&entry->_vtime));
}
/**
* Initialize the value buffers for an originator entry
* @param af_type address family of originator
*/
static void
_initialize_originator_values(int af_type) {
netaddr_to_string(&_value_originator, olsrv2_originator_get(af_type));
}
/**
* Initialize the value buffers for an OLSRv2 edge
* @param edge OLSRv2 edge
*/
static void
_initialize_edge_values(struct olsrv2_tc_edge *edge) {
netaddr_to_string(&_value_edge, &edge->dst->target.prefix.dst);
snprintf(_value_edge_ansn, sizeof(_value_edge_ansn), "%u", edge->ansn);
}