static void ipc_print_neigh_link(struct autobuf *abuf, const struct neighbor_entry *neighbor) { static const char DASHED[] = "dashed"; static const char SOLID[] = "solid"; struct ipaddr_str mainaddrstrbuf, strbuf; olsr_linkcost etx = 0.0; const char *style; const char *adr = olsr_ip_to_string(&mainaddrstrbuf, &olsr_cnf->main_addr); struct link_entry *the_link; struct lqtextbuffer lqbuffer; if (neighbor->status == 0) { /* non SYM */ style = DASHED; } else { the_link = get_best_link_to_neighbor(&neighbor->neighbor_main_addr); if (the_link) { etx = the_link->linkcost; } style = SOLID; } abuf_appendf(abuf, "\"%s\" -> \"%s\"[label=\"%s\", style=%s];\n", adr, olsr_ip_to_string(&strbuf, &neighbor->neighbor_main_addr), get_linkcost_text(etx, false, &lqbuffer), style); if (neighbor->is_mpr) { abuf_appendf(abuf, "\"%s\"[shape=box];\n", adr); } }
olsr_u8_t netmask_to_prefix(const olsr_u8_t *adr, int len) { struct ipaddr_str buf; const olsr_u8_t * const a_end = adr+len; olsr_u16_t prefix = 0; const olsr_u8_t *a; for (a = adr; a < a_end && *a == 0xff; a++) { prefix += 8; } if (a < a_end) { /* handle the last byte */ switch (*a) { case 0: prefix += 0; break; case 128: prefix += 1; break; case 192: prefix += 2; break; case 224: prefix += 3; break; case 240: prefix += 4; break; case 248: prefix += 5; break; case 252: prefix += 6; break; case 254: prefix += 7; break; case 255: prefix += 8; break; /* Shouldn't happen */ default: OLSR_PRINTF(0, "%s: Got bogus netmask %s\n", __func__, olsr_ip_to_string(&buf, (const union olsr_ip_addr *)adr)); prefix = UCHAR_MAX; *(int *)0 = 0; break; } } #ifdef DEBUG OLSR_PRINTF(3, "Netmask: %s = Prefix %d\n", olsr_ip_to_string(&buf, (const union olsr_ip_addr *)adr), prefix); #endif return prefix; }
/** * Print the routingtree to STDOUT * */ void olsr_print_routing_table(struct avl_tree *tree) { #ifndef NODEBUG /* The whole function makes no sense without it. */ struct avl_node *rt_tree_node; struct lqtextbuffer lqbuffer; OLSR_PRINTF(6, "ROUTING TABLE\n"); for (rt_tree_node = avl_walk_first(tree); rt_tree_node != NULL; rt_tree_node = avl_walk_next(rt_tree_node)) { struct avl_node *rtp_tree_node; struct ipaddr_str prefixstr, origstr, gwstr; struct rt_entry *rt = rt_tree2rt(rt_tree_node); /* first the route entry */ OLSR_PRINTF(6, "%s/%u, via %s, best-originator %s\n", olsr_ip_to_string(&prefixstr, &rt->rt_dst.prefix), rt->rt_dst.prefix_len, olsr_ip_to_string(&origstr, &rt->rt_nexthop.gateway), olsr_ip_to_string(&gwstr, &rt->rt_best->rtp_originator)); /* walk the per-originator path tree of routes */ for (rtp_tree_node = avl_walk_first(&rt->rt_path_tree); rtp_tree_node != NULL; rtp_tree_node = avl_walk_next(rtp_tree_node)) { struct rt_path *rtp = rtp_tree2rtp(rtp_tree_node); OLSR_PRINTF(6, "\tfrom %s, cost %s, metric %u, via %s, %s, v %u\n", olsr_ip_to_string(&origstr, &rtp->rtp_originator), get_linkcost_text(rtp->rtp_metric.cost, true, &lqbuffer), rtp->rtp_metric.hops, olsr_ip_to_string(&gwstr, &rtp-> rtp_nexthop. gateway), if_ifwithindex_name(rt->rt_nexthop.iif_index), rtp->rtp_version); } } #endif /* NODEBUG */ tree = NULL; /* squelch compiler warnings */ }
/** * Insert a prefix into the prefix tree hanging off a lsdb (tc) entry. * * Check if the candidate route (we call this a rt_path) is known, * if not create it. * Upon post-SPF processing (if the node is reachable) the prefix * will be finally inserted into the global RIB. * *@param dst the destination *@param plen the prefix length *@param originator the originating router * *@return the new rt_path struct */ struct rt_path * olsr_insert_routing_table(union olsr_ip_addr *dst, int plen, union olsr_ip_addr *originator, int origin) { #ifdef DEBUG struct ipaddr_str dstbuf, origbuf; #endif struct tc_entry *tc; struct rt_path *rtp; struct avl_node *node; struct olsr_ip_prefix prefix; /* * No bogus prefix lengths. */ if (plen > olsr_cnf->maxplen) { return NULL; } /* * For all routes we use the tc_entry as an hookup point. * If the tc_entry is disconnected, i.e. has no edges it will not * be explored during SPF run. */ tc = olsr_locate_tc_entry(originator); /* * first check if there is a rt_path for the prefix. */ prefix.prefix = *dst; prefix.prefix_len = plen; node = avl_find(&tc->prefix_tree, &prefix); if (!node) { /* no rt_path for this prefix yet */ rtp = olsr_alloc_rt_path(tc, &prefix, origin); if (!rtp) { return NULL; } #ifdef DEBUG OLSR_PRINTF(1, "RIB: add prefix %s/%u from %s\n", olsr_ip_to_string(&dstbuf, dst), plen, olsr_ip_to_string(&origbuf, originator)); #endif /* overload the hna change bit for flagging a prefix change */ changes_hna = OLSR_TRUE; } else { rtp = rtp_prefix_tree2rtp(node); } return rtp; }
int olsr_process_hysteresis(struct link_entry *entry) { //printf("PROCESSING QUALITY: %f\n", entry->L_link_quality); if (entry->L_link_quality > hhigh) { if (entry->L_link_pending == 1) { struct ipaddr_str buf; OLSR_PRINTF(1, "HYST[%s] link set to NOT pending!\n", olsr_ip_to_string(&buf, &entry->neighbor_iface_addr)); changes_neighborhood = true; } /* Pending = false */ entry->L_link_pending = 0; if (!TIMED_OUT(entry->L_LOST_LINK_time)) changes_neighborhood = true; /* time = now -1 */ entry->L_LOST_LINK_time = now_times - 1; return 1; } if (entry->L_link_quality < hlow) { if (entry->L_link_pending == 0) { struct ipaddr_str buf; OLSR_PRINTF(1, "HYST[%s] link set to pending!\n", olsr_ip_to_string(&buf, &entry->neighbor_iface_addr)); changes_neighborhood = true; } /* Pending = true */ entry->L_link_pending = 1; if (TIMED_OUT(entry->L_LOST_LINK_time)) changes_neighborhood = true; /* Timer = min (L_time, current time + NEIGHB_HOLD_TIME) */ entry->L_LOST_LINK_time = MIN(GET_TIMESTAMP(NEIGHB_HOLD_TIME * MSEC_PER_SEC), entry->link_timer->timer_clock); /* (the link is then considered as lost according to section 8.5 and this may produce a neighbor loss). WTF? */ return -1; } /* *If we get here then: *(HYST_THRESHOLD_LOW <= entry->L_link_quality <= HYST_THRESHOLD_HIGH) */ /* L_link_pending and L_LOST_LINK_time remain unchanged. */ return 0; }
/** * format a route entry into a buffer */ char * olsr_rt_to_string(const struct rt_entry *rt) { static char buff[128]; struct ipaddr_str prefixstr, gwstr; snprintf(buff, sizeof(buff), "%s/%u via %s", olsr_ip_to_string(&prefixstr, &rt->rt_dst.prefix), rt->rt_dst.prefix_len, olsr_ip_to_string(&gwstr, &rt->rt_nexthop.gateway)); return buff; }
int check_gw(union olsr_ip_addr *net, union olsr_ip_addr *mask) { char buff[1024], iface[17]; uint32_t gate_addr, dest_addr, netmask; unsigned int iflags; int num, metric, refcnt, use; int retval = 0; FILE *fp = fopen(PROCENTRY_ROUTE, "r"); if (!fp) { OLSR_WARN(LOG_PLUGINS, "Cannot read proc file %s: %s\n", PROCENTRY_ROUTE, strerror(errno)); return -1; } rewind(fp); /* OLSR_PRINTF(DEBUGLEV, "Genmask Destination Gateway " "Flags Metric Ref Use Iface\n"); */ while (fgets(buff, 1023, fp)) { #if !defined REMOVE_LOG_DEBUG struct ipaddr_str buf; #endif num = sscanf(buff, "%16s %128X %128X %X %d %d %d %128X \n", iface, &dest_addr, &gate_addr, &iflags, &refcnt, &use, &metric, &netmask); if (num < 8) { continue; } OLSR_DEBUG(LOG_PLUGINS, "%-15s %-15s %-15s %-6d %-2d %7d %s\n", olsr_ip_to_string(&buf, (union olsr_ip_addr *)&netmask), olsr_ip_to_string(&buf, (union olsr_ip_addr *)&dest_addr), olsr_ip_to_string(&buf, (union olsr_ip_addr *)&gate_addr), metric, refcnt, use, iface); if ( /* (iflags & RTF_GATEWAY) && */ (iflags & RTF_UP) && (metric == 0) && (netmask == mask->v4.s_addr) && (dest_addr == net->v4.s_addr)) { OLSR_DEBUG(LOG_PLUGINS, "INTERNET GATEWAY VIA %s detected in routing table.\n", iface); retval = 1; } } fclose(fp); if (retval == 0) { OLSR_DEBUG(LOG_PLUGINS, "No Internet GWs detected...\n"); } return retval; }
/** *Find the neighbor that covers the most 2 hop neighbors *with a given willingness * *@param willingness the willingness of the neighbor * *@return a pointer to the neighbor_entry struct */ static struct neighbor_entry * olsr_find_maximum_covered(int willingness) { uint16_t maximum; struct neighbor_entry *a_neighbor; struct neighbor_entry *mpr_candidate = NULL; maximum = 0; OLSR_FOR_ALL_NBR_ENTRIES(a_neighbor) { #if 0 printf("[%s] nocov: %d mpr: %d will: %d max: %d\n\n", olsr_ip_to_string(&buf, &a_neighbor->neighbor_main_addr), a_neighbor->neighbor_2_nocov, a_neighbor->is_mpr, a_neighbor->willingness, maximum); #endif if ((!a_neighbor->is_mpr) && (a_neighbor->willingness == willingness) && (maximum < a_neighbor->neighbor_2_nocov)) { maximum = a_neighbor->neighbor_2_nocov; mpr_candidate = a_neighbor; } } OLSR_FOR_ALL_NBR_ENTRIES_END(a_neighbor); return mpr_candidate; }
/** * Adds all nodes with willingness set to WILL_ALWAYS */ static uint16_t add_will_always_nodes(void) { struct neighbor_entry *a_neighbor; uint16_t count = 0; #if 0 printf("\nAdding WILL ALWAYS nodes....\n"); #endif OLSR_FOR_ALL_NBR_ENTRIES(a_neighbor) { struct ipaddr_str buf; if ((a_neighbor->status == NOT_SYM) || (a_neighbor->willingness != WILL_ALWAYS)) { continue; } olsr_chosen_mpr(a_neighbor, &count); OLSR_PRINTF(3, "Adding WILL_ALWAYS: %s\n", olsr_ip_to_string(&buf, &a_neighbor->neighbor_main_addr)); } OLSR_FOR_ALL_NBR_ENTRIES_END(a_neighbor); #if 0 OLSR_PRINTF(1, "Count: %d\n", count); #endif return count; }
/** * format a route path into a buffer */ char * olsr_rtp_to_string(const struct rt_path *rtp) { static char buff[128]; struct ipaddr_str prefixstr, origstr, gwstr; struct rt_entry *rt = rtp->rtp_rt; struct lqtextbuffer lqbuffer; snprintf(buff, sizeof(buff), "%s/%u from %s via %s, " "cost %s, metric %u, v %u", olsr_ip_to_string(&prefixstr, &rt->rt_dst.prefix), rt->rt_dst.prefix_len, olsr_ip_to_string(&origstr, &rtp->rtp_originator), olsr_ip_to_string(&gwstr, &rtp->rtp_nexthop.gateway), get_linkcost_text(rtp->rtp_metric.cost, true, &lqbuffer), rtp->rtp_metric.hops, rtp->rtp_version); return buff; }
/** *Prints the registered neighbors and two hop neighbors *to STDOUT. * *@return nada */ void olsr_print_neighbor_table(void) { #ifdef NODEBUG /* The whole function doesn't do anything else. */ #ifndef NODEBUG const int iplen = olsr_cnf->ip_version == AF_INET ? 15 : 39; #endif int idx; OLSR_PRINTF(1, "\n--- %02d:%02d:%02d.%02d ------------------------------------------------ NEIGHBORS\n\n" "%*s LQ NLQ SYM MPR MPRS will\n", nowtm->tm_hour, nowtm->tm_min, nowtm->tm_sec, (int)now.tv_usec / 10000, iplen, "IP address"); for (idx = 0; idx < HASHSIZE; idx++) { struct neighbor_entry *neigh; for (neigh = neighbortable[idx].next; neigh != &neighbortable[idx]; neigh = neigh->next) { struct link_entry *lnk = get_best_link_to_neighbor(&neigh->neighbor_main_addr); if (lnk) { struct ipaddr_str buf; OLSR_PRINTF(1, "%-*s %5.3f %5.3f %s %s %s %d\n", iplen, olsr_ip_to_string(&buf, &neigh->neighbor_main_addr), lnk->loss_link_quality, lnk->neigh_link_quality, neigh->status == SYM ? "YES " : "NO ", neigh->is_mpr ? "YES " : "NO ", olsr_lookup_mprs_set(&neigh->neighbor_main_addr) == NULL ? "NO " : "YES ", neigh->willingness); } } } #endif }
void olsr_print_neighbor_table(void) { /* The whole function doesn't do anything else. */ const int iplen = olsr_cnf->ip_version == AF_INET ? (INET_ADDRSTRLEN - 1) : (INET6_ADDRSTRLEN - 1); int idx; OLSR_PRINTF(1, "\n--- %s ------------------------------------------------ NEIGHBORS\n\n" "%*s\tHyst\tLQ\tETX\tSYM MPR MPRS will\n", olsr_wallclock_string(), iplen, "IP address"); for (idx = 0; idx < HASHSIZE; idx++) { struct neighbor_entry *neigh; for (neigh = neighbortable[idx].next; neigh != &neighbortable[idx]; neigh = neigh->next) { struct link_entry *lnk = get_best_link_to_neighbor(&neigh->neighbor_main_addr); if (lnk) { struct ipaddr_str buf; struct lqtextbuffer lqbuffer1, lqbuffer2; OLSR_PRINTF(1, "%-*s\t%5.3f\t%s\t%s\t%s %s %s %d\n", iplen, olsr_ip_to_string(&buf, &neigh->neighbor_main_addr), (double)lnk->L_link_quality, get_link_entry_text(lnk, '/', &lqbuffer1), get_linkcost_text(lnk->linkcost,false, &lqbuffer2), neigh->status == SYM ? "YES " : "NO ", neigh->is_mpr ? "YES " : "NO ", olsr_lookup_mprs_set(&neigh->neighbor_main_addr) == NULL ? "NO " : "YES ", neigh->willingness); } } } }
/** * Delete a prefix from the prefix tree hanging off a lsdb (tc) entry. */ void olsr_delete_routing_table(union olsr_ip_addr *dst, int plen, union olsr_ip_addr *originator) { #ifdef DEBUG struct ipaddr_str dstbuf, origbuf; #endif struct tc_entry *tc; struct rt_path *rtp; struct avl_node *node; struct olsr_ip_prefix prefix; /* * No bogus prefix lengths. */ if (plen > olsr_cnf->maxplen) { return; } tc = olsr_lookup_tc_entry(originator); if (!tc) { return; } /* * Grab the rt_path for the prefix. */ prefix.prefix = *dst; prefix.prefix_len = plen; node = avl_find(&tc->prefix_tree, &prefix); if (node) { rtp = rtp_prefix_tree2rtp(node); olsr_delete_rt_path(rtp); #ifdef DEBUG OLSR_PRINTF(1, "RIB: del prefix %s/%u from %s\n", olsr_ip_to_string(&dstbuf, dst), plen, olsr_ip_to_string(&origbuf, originator)); #endif /* overload the hna change bit for flagging a prefix change */ changes_hna = OLSR_TRUE; } }
/* * olsr_spf_add_path_list * * Insert an SPF result at the end of the path list. */ static void olsr_spf_add_path_list(struct list_node *head, int *path_count, struct tc_entry *tc) { #if !defined(NODEBUG) && defined(DEBUG) struct ipaddr_str pathbuf, nbuf; struct lqtextbuffer lqbuffer; #endif /* !defined(NODEBUG) && defined(DEBUG) */ #ifdef DEBUG OLSR_PRINTF(2, "SPF: append path %s, cost %s, via %s\n", olsr_ip_to_string(&pathbuf, &tc->addr), get_linkcost_text(tc->path_cost, false, &lqbuffer), tc->next_hop ? olsr_ip_to_string(&nbuf, &tc->next_hop-> neighbor_iface_addr) : "-"); #endif /* DEBUG */ list_add_before(head, &tc->path_list_node); *path_count = *path_count + 1; }
/** *This function processes the chosen MPRs and updates the counters *used in calculations */ static int olsr_chosen_mpr(struct neighbor_entry *one_hop_neighbor, uint16_t * two_hop_covered_count) { struct neighbor_list_entry *the_one_hop_list; struct neighbor_2_list_entry *second_hop_entries; struct neighbor_entry *dup_neighbor; uint16_t count; struct ipaddr_str buf; count = *two_hop_covered_count; OLSR_PRINTF(1, "Setting %s as MPR\n", olsr_ip_to_string(&buf, &one_hop_neighbor->neighbor_main_addr)); //printf("PRE COUNT: %d\n\n", count); one_hop_neighbor->is_mpr = true; //NBS_MPR; for (second_hop_entries = one_hop_neighbor->neighbor_2_list.next; second_hop_entries != &one_hop_neighbor->neighbor_2_list; second_hop_entries = second_hop_entries->next) { dup_neighbor = olsr_lookup_neighbor_table(&second_hop_entries->neighbor_2->neighbor_2_addr); if ((dup_neighbor != NULL) && (dup_neighbor->status == SYM)) { //OLSR_PRINTF(7, "(2)Skipping 2h neighbor %s - already 1hop\n", olsr_ip_to_string(&buf, &second_hop_entries->neighbor_2->neighbor_2_addr)); continue; } // if(!second_hop_entries->neighbor_2->neighbor_2_state) //if(second_hop_entries->neighbor_2->mpr_covered_count < olsr_cnf->mpr_coverage) //{ /* Now the neighbor is covered by this mpr */ second_hop_entries->neighbor_2->mpr_covered_count++; the_one_hop_list = second_hop_entries->neighbor_2->neighbor_2_nblist.next; //OLSR_PRINTF(1, "[%s](%x) has coverage %d\n", olsr_ip_to_string(&buf, &second_hop_entries->neighbor_2->neighbor_2_addr), second_hop_entries->neighbor_2, second_hop_entries->neighbor_2->mpr_covered_count); if (second_hop_entries->neighbor_2->mpr_covered_count >= olsr_cnf->mpr_coverage) count++; while (the_one_hop_list != &second_hop_entries->neighbor_2->neighbor_2_nblist) { if ((the_one_hop_list->neighbor->status == SYM)) { if (second_hop_entries->neighbor_2->mpr_covered_count >= olsr_cnf->mpr_coverage) { the_one_hop_list->neighbor->neighbor_2_nocov--; } } the_one_hop_list = the_one_hop_list->next; } //} } //printf("POST COUNT %d\n\n", count); *two_hop_covered_count = count; return count; }
static int olsrd_sanity_check_interface_cnf(struct if_config_options * io, struct olsrd_config * cnf, char* name) { struct olsr_lq_mult *mult; /* HELLO interval */ if (io->hello_params.validity_time < 0.0) { if (cnf->lq_level == 0) io->hello_params.validity_time = NEIGHB_HOLD_TIME; else io->hello_params.validity_time = (int)(REFRESH_INTERVAL / cnf->lq_aging); } if (io->hello_params.emission_interval < cnf->pollrate || io->hello_params.emission_interval > io->hello_params.validity_time) { fprintf(stderr, "Bad HELLO parameters! (em: %0.2f, vt: %0.2f) for dev %s\n", io->hello_params.emission_interval, io->hello_params.validity_time, name); return -1; } /* TC interval */ if (io->tc_params.emission_interval < cnf->pollrate || io->tc_params.emission_interval > io->tc_params.validity_time) { fprintf(stderr, "Bad TC parameters! (em: %0.2f, vt: %0.2f) for dev %s\n", io->tc_params.emission_interval, io->tc_params.validity_time, name); return -1; } if (cnf->min_tc_vtime > 0.0 && (io->tc_params.validity_time / io->tc_params.emission_interval) < 128) { fprintf(stderr, "Please use a tc vtime at least 128 times the emission interval while using the min_tc_vtime hack.\n"); return -1; } /* MID interval */ if (io->mid_params.emission_interval < cnf->pollrate || io->mid_params.emission_interval > io->mid_params.validity_time) { fprintf(stderr, "Bad MID parameters! (em: %0.2f, vt: %0.2f) for dev %s\n", io->mid_params.emission_interval, io->mid_params.validity_time, name); return -1; } /* HNA interval */ if (io->hna_params.emission_interval < cnf->pollrate || io->hna_params.emission_interval > io->hna_params.validity_time) { fprintf(stderr, "Bad HNA parameters! (em: %0.2f, vt: %0.2f) for dev %s\n", io->hna_params.emission_interval, io->hna_params.validity_time, name); return -1; } for (mult = io->lq_mult; mult; mult=mult->next) { if (mult->value > LINK_LOSS_MULTIPLIER) { struct ipaddr_str buf; fprintf(stderr, "Bad Linkquality multiplier ('%s' on IP %s: %0.2f)\n", name, olsr_ip_to_string(&buf, &mult->addr), (float)mult->value / (float)LINK_LOSS_MULTIPLIER); return -1; } } return 0; }
/** *Print the current MPR selector set to STDOUT */ void olsr_print_mprs_set(void) { struct mpr_selector *mprs; OLSR_PRINTF(1, "MPR SELECTORS: "); for (mprs = mprs_list.next; mprs != &mprs_list; mprs = mprs->next) { struct ipaddr_str buf; OLSR_PRINTF(1, "%s ", olsr_ip_to_string(&buf, &mprs->MS_main_addr)); } OLSR_PRINTF(1, "\n"); }
/** *Update the hello timeout of a hysteresis link *entry * *@param entry the link entry to update *@param htime the hello interval to use * *@return nada */ void olsr_update_hysteresis_hello(struct link_entry *entry, olsr_reltime htime) { struct ipaddr_str buf; OLSR_PRINTF(3, "HYST[%s]: HELLO update vtime %u ms\n", olsr_ip_to_string(&buf, &entry->neighbor_iface_addr), htime + htime / 2); olsr_set_timer(&entry->link_hello_timer, htime + htime / 2, OLSR_LINK_HELLO_JITTER, OLSR_TIMER_PERIODIC, &olsr_expire_link_hello_timer, entry, 0); return; }
/* * Adds the given IP-address to the invalid list. */ void olsr_add_invalid_address(const union olsr_ip_addr *adr) { struct ipaddr_str buf; struct deny_address_entry *new_entry = olsr_malloc(sizeof(struct deny_address_entry), "Add deny address"); new_entry->addr = *adr; new_entry->next = deny_entries; deny_entries = new_entry; OLSR_PRINTF(1, "Added %s to IP deny set\n", olsr_ip_to_string(&buf, &new_entry->addr)); }
/** * Print all HNA entries. * *@return nada */ void olsr_print_hna_set(void) { #ifdef NODEBUG /* The whole function doesn't do anything else. */ int idx; OLSR_PRINTF(1, "\n--- %02d:%02d:%02d.%02d ------------------------------------------------- HNA SET\n\n", nowtm->tm_hour, nowtm->tm_min, nowtm->tm_sec, (int)now.tv_usec / 10000); if (olsr_cnf->ip_version == AF_INET) OLSR_PRINTF(1, "IP net netmask GW IP\n"); else OLSR_PRINTF(1, "IP net/prefixlen GW IP\n"); for (idx = 0; idx < HASHSIZE; idx++) { struct hna_entry *tmp_hna = hna_set[idx].next; /* Check all entrys */ while (tmp_hna != &hna_set[idx]) { /* Check all networks */ struct hna_net *tmp_net = tmp_hna->networks.next; while (tmp_net != &tmp_hna->networks) { if (olsr_cnf->ip_version == AF_INET) { struct ipaddr_str buf; OLSR_PRINTF(1, "%-15s ", olsr_ip_to_string(&buf, &tmp_net->A_network_addr)); OLSR_PRINTF(1, "%-15d ", tmp_net->prefix_len); OLSR_PRINTF(1, "%-15s\n", olsr_ip_to_string(&buf, &tmp_hna->A_gateway_addr)); } else { struct ipaddr_str buf; OLSR_PRINTF(1, "%-27s/%d", olsr_ip_to_string(&buf, &tmp_net->A_network_addr), tmp_net->A_netmask.v6); OLSR_PRINTF(1, "%s\n", olsr_ip_to_string(&buf, &tmp_hna->A_gateway_addr)); } tmp_net = tmp_net->next; } tmp_hna = tmp_hna->next; } } #endif /* NODEBUG */ }
void update_hysteresis_incoming(union olsr_ip_addr *remote, struct interface *local, uint16_t seqno) { struct link_entry *lnk = lookup_link_entry(remote, NULL, local); /* Calculate new quality */ if (lnk != NULL) { #ifdef DEBUG struct ipaddr_str buf; #endif lnk->L_link_quality = olsr_hyst_calc_stability(lnk->L_link_quality); #ifdef DEBUG OLSR_PRINTF(3, "HYST[%s]: %f\n", olsr_ip_to_string(&buf, remote), lnk->L_link_quality); #endif /* * see how many packets we have missed and update the link quality * for each missed packet; HELLOs have already been accounted for by * the timeout function and the number of missed HELLOs has already * been added to olsr_seqno there */ if (lnk->olsr_seqno_valid && (unsigned short)(seqno - lnk->olsr_seqno) < 100) while (lnk->olsr_seqno != seqno) { lnk->L_link_quality = olsr_hyst_calc_instability(lnk->L_link_quality); #ifdef DEBUG OLSR_PRINTF(5, "HYST[%s] PACKET LOSS! %f\n", olsr_ip_to_string(&buf, remote), lnk->L_link_quality); #endif if (lnk->L_link_quality < olsr_cnf->hysteresis_param.thr_low) break; lnk->olsr_seqno++; } lnk->olsr_seqno = seqno + 1; lnk->olsr_seqno_valid = true; //printf("Updating seqno to: %d\n", lnk->olsr_seqno); } return; }
void BMF_handle_encapsulatingFd(int skfd, void *data, unsigned int flags __attribute__ ((unused))) { unsigned char rxBuffer[BMF_BUFFER_SIZE]; struct TBmfInterface* walker = data; struct sockaddr_in from; socklen_t fromLen = sizeof(from); int nBytes; int minimumLength; union olsr_ip_addr forwardedBy; /* An encapsulated packet was received */ nBytes = recvfrom( skfd, rxBuffer, BMF_BUFFER_SIZE, 0, (struct sockaddr*)&from, &fromLen); if (nBytes < 0) { BmfPError("recvfrom() error on \"%s\"", walker->ifName); return; } /* if (nBytes < 0) */ forwardedBy.v4 = from.sin_addr; /* Check if the number of received bytes is large enough for a minimal BMF * encapsulation packet, at least: * - the encapsulation header * - a minimum IP header inside the encapsulated packet */ minimumLength = ENCAP_HDR_LEN + sizeof(struct ip); if (nBytes < minimumLength) { struct ipaddr_str buf; olsr_printf( 1, "%s: received a too short encapsulation packet (%d bytes) from %s on \"%s\"\n", PLUGIN_NAME, nBytes, olsr_ip_to_string(&buf, &forwardedBy), walker->ifName); return; } /* Unfortunately, the recvfrom call does not return the destination * of the encapsulation packet (the destination may be either the * my unicast or my local broadcast address). Therefore we fill in 'NULL' * for the 'forwardedTo' parameter. */ BmfEncapsulationPacketReceived(walker, &forwardedBy, NULL, rxBuffer); }
/** * Add a new tc_entry to the tc tree * * @param (last)adr address of the entry * @return a pointer to the created entry */ static struct tc_entry * olsr_add_tc_entry(const union olsr_ip_addr *adr) { #if !defined REMOVE_LOG_DEBUG struct ipaddr_str buf; #endif struct tc_entry *tc; /* * Safety net against loss of the last main IP address. */ if (olsr_ipcmp(&olsr_cnf->router_id, &all_zero) == 0) { return NULL; } OLSR_DEBUG(LOG_TC, "TC: add entry %s\n", olsr_ip_to_string(&buf, adr)); tc = olsr_memcookie_malloc(tc_mem_cookie); if (!tc) { return NULL; } /* Fill entry */ tc->addr = *adr; tc->vertex_node.key = &tc->addr; tc->mid_seq = -1; tc->hna_seq = -1; tc->tc_seq = -1; /* * Insert into the global tc tree. */ avl_insert(&tc_tree, &tc->vertex_node); /* * Initialize subtrees for edges, prefixes, HNAs and MIDs. */ avl_init(&tc->edge_tree, avl_comp_default, true, NULL); avl_init(&tc->prefix_tree, avl_comp_prefix_origin_default, false, NULL); avl_init(&tc->mid_tree, avl_comp_default, false, NULL); avl_init(&tc->hna_tree, avl_comp_prefix_default, false, NULL); /* * Add a rt_path for ourselves. */ olsr_insert_routing_table(adr, 8 * olsr_cnf->ipsize, adr, OLSR_RT_ORIGIN_TC); return tc; }
/** * Attempts to delete a tc entry. This will work unless there are virtual edges left * that cannot be removed * * @param entry the TC entry to delete * */ void olsr_delete_tc_entry(struct tc_entry *tc) { struct tc_edge_entry *tc_edge, *edge_iterator; struct rt_path *rtp, *rtp_iterator; #if !defined REMOVE_LOG_DEBUG struct ipaddr_str buf; #endif OLSR_DEBUG(LOG_TC, "TC: del entry %s\n", olsr_ip_to_string(&buf, &tc->addr)); /* The delete all non-virtual edges */ OLSR_FOR_ALL_TC_EDGE_ENTRIES(tc, tc_edge, edge_iterator) { olsr_delete_tc_edge_entry(tc_edge); }
/* * olsr_spf_del_cand_tree * * Unkey an existing vertex from a candidate tree. */ static void olsr_spf_del_cand_tree(struct avl_tree *tree, struct tc_entry *tc) { #ifdef DEBUG #ifndef NODEBUG struct ipaddr_str buf; struct lqtextbuffer lqbuffer; #endif /* NODEBUG */ OLSR_PRINTF(2, "SPF: delete candidate %s, cost %s\n", olsr_ip_to_string(&buf, &tc->addr), get_linkcost_text(tc->path_cost, false, &lqbuffer)); #endif /* DEBUG */ avl_delete(tree, &tc->cand_tree_node); }
bool olsr_validate_address(const union olsr_ip_addr *adr) { const struct deny_address_entry *deny_entry; for (deny_entry = deny_entries; deny_entry != NULL; deny_entry = deny_entry->next) { if (ipequal(adr, &deny_entry->addr)) { struct ipaddr_str buf; OLSR_PRINTF(1, "Validation of address %s failed!\n", olsr_ip_to_string(&buf, adr)); return false; } if (&deny_entry->addr == &olsr_cnf->main_addr) break; } return true; }
/** *Update a MPR selector entry or create an new *one if it does not exist * *@param addr the address of the MPR selector *@param vtime tha validity time of the entry * *@return 1 if a new entry was added 0 if not */ int olsr_update_mprs_set(const union olsr_ip_addr *addr, olsr_reltime vtime) { struct ipaddr_str buf; struct mpr_selector *mprs = olsr_lookup_mprs_set(addr); OLSR_PRINTF(5, "MPRS: Update %s\n", olsr_ip_to_string(&buf, addr)); if (mprs == NULL) { olsr_add_mpr_selector(addr, vtime); signal_link_changes(true); return 1; } olsr_set_mpr_sel_timer(mprs, vtime); return 0; }
/* * olsr_spf_add_cand_tree * * Key an existing vertex to a candidate tree. */ static void olsr_spf_add_cand_tree(struct avl_tree *tree, struct tc_entry *tc) { #if !defined(NODEBUG) && defined(DEBUG) struct ipaddr_str buf; struct lqtextbuffer lqbuffer; #endif /* !defined(NODEBUG) && defined(DEBUG) */ tc->cand_tree_node.key = &tc->path_cost; #ifdef DEBUG OLSR_PRINTF(2, "SPF: insert candidate %s, cost %s\n", olsr_ip_to_string(&buf, &tc->addr), get_linkcost_text(tc->path_cost, false, &lqbuffer)); #endif /* DEBUG */ avl_insert(tree, &tc->cand_tree_node, AVL_DUP); }
/** * Add a new tc_entry to the tc tree * * @param adr (last)adr address of the entry * @return a pointer to the created entry */ static struct tc_entry * olsr_add_tc_entry(union olsr_ip_addr *adr) { #ifdef DEBUG struct ipaddr_str buf; #endif /* DEBUG */ struct tc_entry *tc; /* * Safety net against loss of the last main IP address. */ if (ipequal(&olsr_cnf->main_addr, &all_zero)) { return NULL; } #ifdef DEBUG OLSR_PRINTF(1, "TC: add entry %s\n", olsr_ip_to_string(&buf, adr)); #endif /* DEBUG */ tc = olsr_cookie_malloc(tc_mem_cookie); if (!tc) { return NULL; } /* Fill entry */ tc->addr = *adr; tc->vertex_node.key = &tc->addr; /* * Insert into the global tc tree. */ avl_insert(&tc_tree, &tc->vertex_node, AVL_DUP_NO); olsr_lock_tc_entry(tc); /* * Initialize subtrees for edges and prefixes. */ avl_init(&tc->edge_tree, avl_comp_default); avl_init(&tc->prefix_tree, avl_comp_prefix_default); /* * Add a rt_path for ourselves. */ olsr_insert_routing_table(adr, olsr_cnf->maxplen, adr, OLSR_RT_ORIGIN_INT); return tc; }
/** *Optimize MPR set by removing all entries *where all 2 hop neighbors actually is *covered by enough MPRs already *Described in RFC3626 section 8.3.1 *point 5 * *@return nada */ static void olsr_optimize_mpr_set(void) { struct neighbor_entry *a_neighbor, *dup_neighbor; struct neighbor_2_list_entry *two_hop_list; int i, removeit; #if 0 printf("\n**MPR OPTIMIZING**\n\n"); #endif for (i = WILL_NEVER + 1; i < WILL_ALWAYS; i++) { OLSR_FOR_ALL_NBR_ENTRIES(a_neighbor) { if (a_neighbor->willingness != i) { continue; } if (a_neighbor->is_mpr) { removeit = 1; for (two_hop_list = a_neighbor->neighbor_2_list.next; two_hop_list != &a_neighbor->neighbor_2_list; two_hop_list = two_hop_list->next) { dup_neighbor = olsr_lookup_neighbor_table(&two_hop_list->neighbor_2->neighbor_2_addr); if ((dup_neighbor != NULL) && (dup_neighbor->status != NOT_SYM)) { continue; } //printf("\t[%s] coverage %d\n", olsr_ip_to_string(&buf, &two_hop_list->neighbor_2->neighbor_2_addr), two_hop_list->neighbor_2->mpr_covered_count); /* Do not remove if we find a entry which need this MPR */ if (two_hop_list->neighbor_2->mpr_covered_count <= olsr_cnf->mpr_coverage) { removeit = 0; } } if (removeit) { struct ipaddr_str buf; OLSR_PRINTF(3, "MPR OPTIMIZE: removiong mpr %s\n\n", olsr_ip_to_string(&buf, &a_neighbor->neighbor_main_addr)); a_neighbor->is_mpr = false; } } } OLSR_FOR_ALL_NBR_ENTRIES_END(a_neighbor); } }