src/olsr.c

   1 /*
   2  * The olsr.org Optimized Link-State Routing daemon(olsrd)
   3  * Copyright (c) 2004, Andreas Tønnesen(andreto@olsr.org)
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  *
  10  * * Redistributions of source code must retain the above copyright
  11  *   notice, this list of conditions and the following disclaimer.
  12  * * Redistributions in binary form must reproduce the above copyright
  13  *   notice, this list of conditions and the following disclaimer in
  14  *   the documentation and/or other materials provided with the
  15  *   distribution.
  16  * * Neither the name of olsr.org, olsrd nor the names of its
  17  *   contributors may be used to endorse or promote products derived
  18  *   from this software without specific prior written permission.
  19  *
  20  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  21  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  22  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  23  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
  24  * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  25  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
  26  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  27  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  28  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
  30  * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  31  * POSSIBILITY OF SUCH DAMAGE.
  32  *
  33  * Visit http://www.olsr.org for more information.
  34  *
  35  * If you find this software useful feel free to make a donation
  36  * to the project. For more information see the website or contact
  37  * the copyright holders.
  38  *
  39  */
  40
  41 /**
  42  * All these functions are global
  43  */
  44
  45 #include "defs.h"
  46 #include "olsr.h"
  47 #include "link_set.h"
  48 #include "two_hop_neighbor_table.h"
  49 #include "tc_set.h"
  50 #include "duplicate_set.h"
  51 #include "mpr_selector_set.h"
  52 #include "mid_set.h"
  53 #include "mpr.h"
  54 #include "lq_mpr.h"
  55 #include "olsr_spf.h"
  56 #include "scheduler.h"
  57 #include "apm.h"
  58 #include "misc.h"
  59 #include "neighbor_table.h"
  60 #include "log.h"
  61 #include "lq_packet.h"
  62 #include "common/avl.h"
  63 #include "net_olsr.h"
  64
  65 #include <stdarg.h>
  66 #include <signal.h>
  67
  68
  69 olsr_bool changes_topology;
  70 olsr_bool changes_neighborhood;
  71 olsr_bool changes_hna;
  72 olsr_bool changes_force;
  73
  74 /**
  75  * Process changes functions
  76  */
  77
  78 struct pcf
  79 {
  80   int (*function)(int, int, int);
  81   struct pcf *next;
  82 };
  83
  84 static struct pcf *pcf_list;
  85
  86 static olsr_u16_t message_seqno;
  87
  88 /**
  89  *Initialize the message sequence number as a random value
  90  */
  91 void
  92 init_msg_seqno(void)
  93 {
  94   message_seqno = random() & 0xFFFF;
  95 }
  96
  97 /**
  98  * Get and increment the message sequence number
  99  *
 100  *@return the seqno
 101  */
 102 olsr_u16_t
 103 get_msg_seqno(void)
 104 {
 105   return message_seqno++;
 106 }
 107
 108
 109 void
 110 register_pcf(int (*f)(int, int, int))
 111 {
 112   struct pcf *new_pcf;
 113
 114   OLSR_PRINTF(1, "Registering pcf function\n");
 115
 116   new_pcf = olsr_malloc(sizeof(struct pcf), "New PCF");
 117
 118   new_pcf->function = f;
 119   new_pcf->next = pcf_list;
 120   pcf_list = new_pcf;
 121
 122 }
 123
 124
 125 /**
 126  *Process changes in neighborhood or/and topology.
 127  *Re-calculates the neighborhooh/topology if there
 128  *are any updates - then calls the right functions to
 129  *update the routing table.
 130  *@return 0
 131  */
 132 void
 133 olsr_process_changes(void)
 134 {
 135   struct pcf *tmp_pc_list;
 136
 137 #ifdef DEBUG
 138   if(changes_neighborhood)
 139     OLSR_PRINTF(3, "CHANGES IN NEIGHBORHOOD\n");
 140   if(changes_topology)
 141     OLSR_PRINTF(3, "CHANGES IN TOPOLOGY\n");
 142   if(changes_hna)
 143     OLSR_PRINTF(3, "CHANGES IN HNA\n");
 144 #endif
 145
 146   if(!changes_force &&
 147      2 <= olsr_cnf->lq_level &&
 148      0 >= olsr_cnf->lq_dlimit)
 149     return;
 150
 151   if(!changes_neighborhood &&
 152      !changes_topology &&
 153      !changes_hna)
 154     return;
 155
 156   if (olsr_cnf->debug_level > 0 && olsr_cnf->clear_screen && isatty(1))
 157   {
 158       clear_console();
 159       printf("       *** %s (%s on %s) ***\n", olsrd_version, build_date, build_host);
 160   }
 161
 162   if (changes_neighborhood) {
 163     if (olsr_cnf->lq_level < 1) {
 164       olsr_calculate_mpr();
 165     } else {
 166       olsr_calculate_lq_mpr();
 167     }
 168   }
 169
 170   /* calculate the routing table */
 171   if (changes_neighborhood || changes_topology || changes_hna) {
 172     olsr_calculate_routing_table();
 173   }
 174
 175   if (olsr_cnf->debug_level > 0)
 176     {
 177       if (olsr_cnf->debug_level > 2)
 178         {
 179           olsr_print_mid_set();
 180
 181           if (olsr_cnf->debug_level > 3)
 182             {
 183              if (olsr_cnf->debug_level > 8)
 184                {
 185                  olsr_print_duplicate_table();
 186                }
 187               olsr_print_hna_set();
 188             }
 189         }
 190
 191 #if 1
 192       olsr_print_link_set();
 193       olsr_print_neighbor_table();
 194       olsr_print_two_hop_neighbor_table();
 195       olsr_print_tc_table();
 196 #endif
 197     }
 198
 199   for(tmp_pc_list = pcf_list;
 200       tmp_pc_list != NULL;
 201       tmp_pc_list = tmp_pc_list->next)
 202     {
 203       tmp_pc_list->function(changes_neighborhood,
 204                             changes_topology,
 205                             changes_hna);
 206     }
 207
 208   changes_neighborhood = OLSR_FALSE;
 209   changes_topology = OLSR_FALSE;
 210   changes_hna = OLSR_FALSE;
 211   changes_force = OLSR_FALSE;
 212 }
 213
 214
 215
 216 void
 217 olsr_trigger_forced_update(void *unused __attribute__((unused))) {
 218         changes_force = OLSR_TRUE;
 219   changes_neighborhood = OLSR_TRUE;
 220   changes_topology = OLSR_TRUE;
 221   changes_hna = OLSR_TRUE;
 222
 223   olsr_process_changes();
 224 }
 225
 226 /**
 227  *Initialize all the tables used(neighbor,
 228  *topology, MID,  HNA, MPR, dup).
 229  *Also initalizes other variables
 230  */
 231 void
 232 olsr_init_tables(void)
 233 {
 234   changes_topology = OLSR_FALSE;
 235   changes_neighborhood = OLSR_FALSE;
 236   changes_hna = OLSR_FALSE;
 237
 238   /* Set avl tree comparator */
 239   if (olsr_cnf->ipsize == 4) {
 240     avl_comp_default = avl_comp_ipv4;
 241     avl_comp_prefix_default = avl_comp_ipv4_prefix;
 242   } else {
 243     avl_comp_default = avl_comp_ipv6;
 244     avl_comp_prefix_default = avl_comp_ipv6_prefix;
 245   }
 246
 247   /* Initialize link set */
 248   olsr_init_link_set();
 249
 250   /* Initialize duplicate table */
 251   olsr_init_duplicate_set();
 252
 253   /* Initialize neighbor table */
 254   olsr_init_neighbor_table();
 255
 256   /* Initialize routing table */
 257   olsr_init_routing_table();
 258
 259   /* Initialize two hop table */
 260   olsr_init_two_hop_table();
 261
 262   /* Initialize topology */
 263   olsr_init_tc();
 264
 265   /* Initialize mpr selector table */
 266   olsr_init_mprs_set();
 267
 268   /* Initialize MID set */
 269   olsr_init_mid_set();
 270
 271   /* Initialize HNA set */
 272   olsr_init_hna_set();
 273
 274   /* Initialize Layer 1/2 database */
 275   // olsr_initialize_layer12();
 276
 277   /* Start periodic SPF and RIB recalculation */
 278   if (olsr_cnf->lq_dinter > 0.0) {
 279     olsr_start_timer((unsigned int)(olsr_cnf->lq_dinter * MSEC_PER_SEC), 5,
 280                      OLSR_TIMER_PERIODIC, &olsr_trigger_forced_update, NULL, 0);
 281   }
 282 }
 283
 284 /**
 285  *Check if a message is to be forwarded and forward
 286  *it if necessary.
 287  *
 288  *@param m the OLSR message recieved
 289  *@param originator the originator of this message
 290  *@param seqno the seqno of the message
 291  *
 292  *@returns positive if forwarded
 293  */
 294 int
 295 olsr_forward_message(union olsr_message *m,
 296                      union olsr_ip_addr *from_addr)
 297 {
 298   union olsr_ip_addr *src;
 299   struct neighbor_entry *neighbor;
 300   int msgsize;
 301   struct interface *ifn;
 302
 303   /*
 304    * Sven-Ola: We should not flood the mesh with overdue messages. Because
 305    * of a bug in parser.c:parse_packet, we have a lot of messages because
 306    * all older olsrd's have lq_fish enabled.
 307    */
 308   if (AF_INET == olsr_cnf->ip_version)
 309   {
 310     if (2 > m->v4.ttl || 255 < (int)m->v4.hopcnt + (int)m->v4.ttl) return 0;
 311   }
 312   else
 313   {
 314     if (2 > m->v6.ttl || 255 < (int)m->v6.hopcnt + (int)m->v6.ttl) return 0;
 315   }
 316
 317   /* Lookup sender address */
 318   src = mid_lookup_main_addr(from_addr);
 319   if(!src)
 320     src = from_addr;
 321
 322   neighbor=olsr_lookup_neighbor_table(src);
 323   if(!neighbor)
 324     return 0;
 325
 326   if(neighbor->status != SYM)
 327     return 0;
 328
 329   /* Check MPR */
 330   if(olsr_lookup_mprs_set(src) == NULL)
 331     {
 332 #ifdef DEBUG
 333 #ifndef NODEBUG
 334       struct ipaddr_str buf;
 335 #endif
 336       OLSR_PRINTF(5, "Forward - sender %s not MPR selector\n", olsr_ip_to_string(&buf, src));
 337 #endif
 338       return 0;
 339     }
 340
 341   /* Treat TTL hopcnt */
 342   if(olsr_cnf->ip_version == AF_INET)
 343     {
 344       /* IPv4 */
 345       m->v4.hopcnt++;
 346       m->v4.ttl--;
 347     }
 348   else
 349     {
 350       /* IPv6 */
 351       m->v6.hopcnt++;
 352       m->v6.ttl--;
 353     }
 354
 355   /* Update packet data */
 356   msgsize = ntohs(m->v4.olsr_msgsize);
 357
 358   /* looping trough interfaces */
 359   for (ifn = ifnet; ifn ; ifn = ifn->int_next)
 360     {
 361       if(net_output_pending(ifn))
 362         {
 363           /*
 364            * Check if message is to big to be piggybacked
 365            */
 366           if(net_outbuffer_push(ifn, m, msgsize) != msgsize)
 367             {
 368               /* Send */
 369               net_output(ifn);
 370               /* Buffer message */
 371               set_buffer_timer(ifn);
 372
 373               if(net_outbuffer_push(ifn, m, msgsize) != msgsize)
 374                 {
 375                   OLSR_PRINTF(1, "Received message to big to be forwarded in %s(%d bytes)!", ifn->int_name, msgsize);
 376                   olsr_syslog(OLSR_LOG_ERR, "Received message to big to be forwarded on %s(%d bytes)!", ifn->int_name, msgsize);
 377                 }
 378             }
 379         }
 380       else
 381         {
 382           /* No forwarding pending */
 383           set_buffer_timer(ifn);
 384
 385           if(net_outbuffer_push(ifn, m, msgsize) != msgsize)
 386             {
 387               OLSR_PRINTF(1, "Received message to big to be forwarded in %s(%d bytes)!", ifn->int_name, msgsize);
 388               olsr_syslog(OLSR_LOG_ERR, "Received message to big to be forwarded on %s(%d bytes)!", ifn->int_name, msgsize);
 389             }
 390         }
 391     }
 392   return 1;
 393 }
 394
 395
 396 void
 397 set_buffer_timer(struct interface *ifn)
 398 {
 399   /* Set timer */
 400   ifn->fwdtimer = GET_TIMESTAMP(random() * olsr_cnf->max_jitter * 1000 / RAND_MAX);
 401 }
 402
 403 void
 404 olsr_init_willingness(void)
 405 {
 406   if (olsr_cnf->willingness_auto) {
 407
 408     /* Run it first and then periodic. */
 409     olsr_update_willingness(NULL);
 410
 411     olsr_start_timer((unsigned int)olsr_cnf->will_int * MSEC_PER_SEC, 5,
 412                      OLSR_TIMER_PERIODIC, &olsr_update_willingness, NULL, 0);
 413   }
 414 }
 415
 416 void
 417 olsr_update_willingness(void *foo __attribute__((unused)))
 418 {
 419   int tmp_will = olsr_cnf->willingness;
 420
 421   /* Re-calculate willingness */
 422   olsr_cnf->willingness = olsr_calculate_willingness();
 423
 424   if(tmp_will != olsr_cnf->willingness)
 425     {
 426       OLSR_PRINTF(1, "Local willingness updated: old %d new %d\n", tmp_will, olsr_cnf->willingness);
 427     }
 428 }
 429
 430
 431 /**
 432  *Calculate this nodes willingness to act as a MPR
 433  *based on either a fixed value or the power status
 434  *of the node using APM
 435  *
 436  *@return a 8bit value from 0-7 representing the willingness
 437  */
 438
 439 olsr_u8_t
 440 olsr_calculate_willingness(void)
 441 {
 442   struct olsr_apm_info ainfo;
 443
 444   /* If fixed willingness */
 445   if(!olsr_cnf->willingness_auto)
 446     return olsr_cnf->willingness;
 447
 448   if(apm_read(&ainfo) < 1)
 449     return WILL_DEFAULT;
 450
 451   apm_printinfo(&ainfo);
 452
 453   /* If AC powered */
 454   if(ainfo.ac_line_status == OLSR_AC_POWERED)
 455     return 6;
 456
 457   /* If battery powered
 458    *
 459    * juice > 78% will: 3
 460    * 78% > juice > 26% will: 2
 461    * 26% > juice will: 1
 462    */
 463   return (ainfo.battery_percentage / 26);
 464 }
 465
 466 const char *
 467 olsr_msgtype_to_string(olsr_u8_t msgtype)
 468 {
 469   static char type[20];
 470
 471   switch(msgtype)
 472     {
 473     case(HELLO_MESSAGE):
 474       return "HELLO";
 475     case(TC_MESSAGE):
 476       return "TC";
 477     case(MID_MESSAGE):
 478       return "MID";
 479     case(HNA_MESSAGE):
 480       return "HNA";
 481     case(LQ_HELLO_MESSAGE):
 482       return("LQ-HELLO");
 483     case(LQ_TC_MESSAGE):
 484       return("LQ-TC");
 485     default:
 486       break;
 487     }
 488
 489   snprintf(type, sizeof(type), "UNKNOWN(%d)", msgtype);
 490   return type;
 491 }
 492
 493
 494 const char *
 495 olsr_link_to_string(olsr_u8_t linktype)
 496 {
 497   static char type[20];
 498
 499   switch(linktype)
 500     {
 501     case(UNSPEC_LINK):
 502       return "UNSPEC";
 503     case(ASYM_LINK):
 504       return "ASYM";
 505     case(SYM_LINK):
 506       return "SYM";
 507     case(LOST_LINK):
 508       return "LOST";
 509     case(HIDE_LINK):
 510       return "HIDE";
 511     default:
 512       break;
 513     }
 514
 515   snprintf(type, sizeof(type), "UNKNOWN(%d)", linktype);
 516   return type;
 517 }
 518
 519
 520 const char *
 521 olsr_status_to_string(olsr_u8_t status)
 522 {
 523   static char type[20];
 524
 525   switch(status)
 526     {
 527     case(NOT_NEIGH):
 528       return "NOT NEIGH";
 529     case(SYM_NEIGH):
 530       return "NEIGHBOR";
 531     case(MPR_NEIGH):
 532       return "MPR";
 533     default:
 534       break;
 535     }
 536
 537   snprintf(type, sizeof(type), "UNKNOWN(%d)", status);
 538   return type;
 539 }
 540
 541
 542 /**
 543  *Termination function to be called whenever a error occures
 544  *that requires the daemon to terminate
 545  *
 546  *@param msg the message to write to the syslog and possibly stdout
 547  */
 548
 549 void
 550 olsr_exit(const char *msg, int val)
 551 {
 552   OLSR_PRINTF(1, "OLSR EXIT: %s\n", msg);
 553   olsr_syslog(OLSR_LOG_ERR, "olsrd exit: %s\n", msg);
 554   fflush(stdout);
 555   olsr_cnf->exit_value = val;
 556
 557   raise(SIGTERM);
 558 }
 559
 560
 561 /**
 562  * Wrapper for malloc(3) that does error-checking
 563  *
 564  * @param size the number of bytes to allocalte
 565  * @param caller a string identifying the caller for
 566  * use in error messaging
 567  *
 568  * @return a void pointer to the memory allocated
 569  */
 570 void *
 571 olsr_malloc(size_t size, const char *id)
 572 {
 573   void *ptr;
 574
 575   /*
 576    * Not all the callers do a proper cleaning of memory.
 577    * Clean it on behalf of those.
 578    */
 579   ptr = calloc(1, size);
 580
 581   if (!ptr) {
 582       const char * const err_msg = strerror(errno);
 583       OLSR_PRINTF(1, "OUT OF MEMORY: %s\n", err_msg);
 584       olsr_syslog(OLSR_LOG_ERR, "olsrd: out of memory!: %s\n", err_msg);
 585       olsr_exit(id, EXIT_FAILURE);
 586   }
 587
 588 #if 0
 589   /* useful for debugging */
 590   olsr_printf(1, "MEMORY: alloc %s %p, %u bytes\n",
 591               id, ptr, size);
 592 #endif
 593
 594   return ptr;
 595 }
 596
 597
 598 /**
 599  *Wrapper for printf that prints to a specific
 600  *debuglevel upper limit
 601  *
 602  */
 603
 604 int
 605 olsr_printf(int loglevel, const char *format, ...)
 606 {
 607   if((loglevel <= olsr_cnf->debug_level) && debug_handle)
 608     {
 609       va_list arglist;
 610       va_start(arglist, format);
 611       vfprintf(debug_handle, format, arglist);
 612       va_end(arglist);
 613     }
 614   return 0;
 615 }
 616
 617 /*
 618  * Local Variables:
 619  * c-basic-offset: 2
 620  * End:
 621  */