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 "lq_route.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(NULL);
 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
 217
 218 /**
 219  *Initialize all the tables used(neighbor,
 220  *topology, MID,  HNA, MPR, dup).
 221  *Also initalizes other variables
 222  */
 223 void
 224 olsr_init_tables(void)
 225 {
 226   changes_topology = OLSR_FALSE;
 227   changes_neighborhood = OLSR_FALSE;
 228   changes_hna = OLSR_FALSE;
 229
 230   /* Set avl tree comparator */
 231   if (olsr_cnf->ipsize == 4) {
 232     avl_comp_default = NULL;
 233     avl_comp_prefix_default = avl_comp_ipv4_prefix;
 234   } else {
 235     avl_comp_default = avl_comp_ipv6;
 236     avl_comp_prefix_default = avl_comp_ipv6_prefix;
 237   }
 238
 239   /* Initialize link set */
 240   olsr_init_link_set();
 241
 242   /* Initialize duplicate table */
 243   olsr_init_duplicate_set();
 244
 245   /* Initialize neighbor table */
 246   olsr_init_neighbor_table();
 247
 248   /* Initialize routing table */
 249   olsr_init_routing_table();
 250
 251   /* Initialize two hop table */
 252   olsr_init_two_hop_table();
 253
 254   /* Initialize topology */
 255   olsr_init_tc();
 256
 257   /* Initialize mpr selector table */
 258   olsr_init_mprs_set();
 259
 260   /* Initialize MID set */
 261   olsr_init_mid_set();
 262
 263   /* Initialize HNA set */
 264   olsr_init_hna_set();
 265
 266   /* Start periodic SPF and RIB recalculation */
 267   if (olsr_cnf->lq_dinter > 0.0) {
 268     olsr_start_timer((unsigned int)(olsr_cnf->lq_dinter * MSEC_PER_SEC), 5,
 269                      OLSR_TIMER_PERIODIC, &olsr_calculate_routing_table, NULL, 0);
 270   }
 271 }
 272
 273 /**
 274  *Check if a message is to be forwarded and forward
 275  *it if necessary.
 276  *
 277  *@param m the OLSR message recieved
 278  *@param originator the originator of this message
 279  *@param seqno the seqno of the message
 280  *
 281  *@returns positive if forwarded
 282  */
 283 int
 284 olsr_forward_message(union olsr_message *m,
 285                      union olsr_ip_addr *from_addr)
 286 {
 287   union olsr_ip_addr *src;
 288   struct neighbor_entry *neighbor;
 289   int msgsize;
 290   struct interface *ifn;
 291
 292   /*
 293    * Sven-Ola: We should not flood the mesh with overdue messages. Because
 294    * of a bug in parser.c:parse_packet, we have a lot of messages because
 295    * all older olsrd's have lq_fish enabled.
 296    */
 297   if (AF_INET == olsr_cnf->ip_version)
 298   {
 299     if (2 > m->v4.ttl || 255 < (int)m->v4.hopcnt + (int)m->v4.ttl) return 0;
 300   }
 301   else
 302   {
 303     if (2 > m->v6.ttl || 255 < (int)m->v6.hopcnt + (int)m->v6.ttl) return 0;
 304   }
 305
 306   /* Lookup sender address */
 307   src = mid_lookup_main_addr(from_addr);
 308   if(!src)
 309     src = from_addr;
 310
 311   neighbor=olsr_lookup_neighbor_table(src);
 312   if(!neighbor)
 313     return 0;
 314
 315   if(neighbor->status != SYM)
 316     return 0;
 317
 318   /* Check MPR */
 319   if(olsr_lookup_mprs_set(src) == NULL)
 320     {
 321 #ifdef DEBUG
 322 #ifndef NODEBUG
 323       struct ipaddr_str buf;
 324 #endif
 325       OLSR_PRINTF(5, "Forward - sender %s not MPR selector\n", olsr_ip_to_string(&buf, src));
 326 #endif
 327       return 0;
 328     }
 329
 330   /* Treat TTL hopcnt */
 331   if(olsr_cnf->ip_version == AF_INET)
 332     {
 333       /* IPv4 */
 334       m->v4.hopcnt++;
 335       m->v4.ttl--;
 336     }
 337   else
 338     {
 339       /* IPv6 */
 340       m->v6.hopcnt++;
 341       m->v6.ttl--;
 342     }
 343
 344   /* Update packet data */
 345   msgsize = ntohs(m->v4.olsr_msgsize);
 346
 347   /* looping trough interfaces */
 348   for (ifn = ifnet; ifn ; ifn = ifn->int_next)
 349     {
 350       if(net_output_pending(ifn))
 351         {
 352           /*
 353            * Check if message is to big to be piggybacked
 354            */
 355           if(net_outbuffer_push(ifn, m, msgsize) != msgsize)
 356             {
 357               /* Send */
 358               net_output(ifn);
 359               /* Buffer message */
 360               set_buffer_timer(ifn);
 361
 362               if(net_outbuffer_push(ifn, m, msgsize) != msgsize)
 363                 {
 364                   OLSR_PRINTF(1, "Received message to big to be forwarded in %s(%d bytes)!", ifn->int_name, msgsize);
 365                   olsr_syslog(OLSR_LOG_ERR, "Received message to big to be forwarded on %s(%d bytes)!", ifn->int_name, msgsize);
 366                 }
 367             }
 368         }
 369       else
 370         {
 371           /* No forwarding pending */
 372           set_buffer_timer(ifn);
 373
 374           if(net_outbuffer_push(ifn, m, msgsize) != msgsize)
 375             {
 376               OLSR_PRINTF(1, "Received message to big to be forwarded in %s(%d bytes)!", ifn->int_name, msgsize);
 377               olsr_syslog(OLSR_LOG_ERR, "Received message to big to be forwarded on %s(%d bytes)!", ifn->int_name, msgsize);
 378             }
 379         }
 380     }
 381   return 1;
 382 }
 383
 384
 385 void
 386 set_buffer_timer(struct interface *ifn)
 387 {
 388   /* Set timer */
 389   ifn->fwdtimer = GET_TIMESTAMP(random() * olsr_cnf->max_jitter * 1000 / RAND_MAX);
 390 }
 391
 392 void
 393 olsr_init_willingness(void)
 394 {
 395   if (olsr_cnf->willingness_auto) {
 396
 397     /* Run it first and then periodic. */
 398     olsr_update_willingness(NULL);
 399
 400     olsr_start_timer((unsigned int)olsr_cnf->will_int * MSEC_PER_SEC, 5,
 401                      OLSR_TIMER_PERIODIC, &olsr_update_willingness, NULL, 0);
 402   }
 403 }
 404
 405 void
 406 olsr_update_willingness(void *foo __attribute__((unused)))
 407 {
 408   int tmp_will = olsr_cnf->willingness;
 409
 410   /* Re-calculate willingness */
 411   olsr_cnf->willingness = olsr_calculate_willingness();
 412
 413   if(tmp_will != olsr_cnf->willingness)
 414     {
 415       OLSR_PRINTF(1, "Local willingness updated: old %d new %d\n", tmp_will, olsr_cnf->willingness);
 416     }
 417 }
 418
 419
 420 /**
 421  *Calculate this nodes willingness to act as a MPR
 422  *based on either a fixed value or the power status
 423  *of the node using APM
 424  *
 425  *@return a 8bit value from 0-7 representing the willingness
 426  */
 427
 428 olsr_u8_t
 429 olsr_calculate_willingness(void)
 430 {
 431   struct olsr_apm_info ainfo;
 432
 433   /* If fixed willingness */
 434   if(!olsr_cnf->willingness_auto)
 435     return olsr_cnf->willingness;
 436
 437   if(apm_read(&ainfo) < 1)
 438     return WILL_DEFAULT;
 439
 440   apm_printinfo(&ainfo);
 441
 442   /* If AC powered */
 443   if(ainfo.ac_line_status == OLSR_AC_POWERED)
 444     return 6;
 445
 446   /* If battery powered
 447    *
 448    * juice > 78% will: 3
 449    * 78% > juice > 26% will: 2
 450    * 26% > juice will: 1
 451    */
 452   return (ainfo.battery_percentage / 26);
 453 }
 454
 455 const char *
 456 olsr_msgtype_to_string(olsr_u8_t msgtype)
 457 {
 458   static char type[20];
 459
 460   switch(msgtype)
 461     {
 462     case(HELLO_MESSAGE):
 463       return "HELLO";
 464     case(TC_MESSAGE):
 465       return "TC";
 466     case(MID_MESSAGE):
 467       return "MID";
 468     case(HNA_MESSAGE):
 469       return "HNA";
 470     case(LQ_HELLO_MESSAGE):
 471       return("LQ-HELLO");
 472     case(LQ_TC_MESSAGE):
 473       return("LQ-TC");
 474     default:
 475       break;
 476     }
 477
 478   snprintf(type, sizeof(type), "UNKNOWN(%d)", msgtype);
 479   return type;
 480 }
 481
 482
 483 const char *
 484 olsr_link_to_string(olsr_u8_t linktype)
 485 {
 486   static char type[20];
 487
 488   switch(linktype)
 489     {
 490     case(UNSPEC_LINK):
 491       return "UNSPEC";
 492     case(ASYM_LINK):
 493       return "ASYM";
 494     case(SYM_LINK):
 495       return "SYM";
 496     case(LOST_LINK):
 497       return "LOST";
 498     case(HIDE_LINK):
 499       return "HIDE";
 500     default:
 501       break;
 502     }
 503
 504   snprintf(type, sizeof(type), "UNKNOWN(%d)", linktype);
 505   return type;
 506 }
 507
 508
 509 const char *
 510 olsr_status_to_string(olsr_u8_t status)
 511 {
 512   static char type[20];
 513
 514   switch(status)
 515     {
 516     case(NOT_NEIGH):
 517       return "NOT NEIGH";
 518     case(SYM_NEIGH):
 519       return "NEIGHBOR";
 520     case(MPR_NEIGH):
 521       return "MPR";
 522     default:
 523       break;
 524     }
 525
 526   snprintf(type, sizeof(type), "UNKNOWN(%d)", status);
 527   return type;
 528 }
 529
 530
 531 /**
 532  *Termination function to be called whenever a error occures
 533  *that requires the daemon to terminate
 534  *
 535  *@param msg the message to write to the syslog and possibly stdout
 536  */
 537
 538 void
 539 olsr_exit(const char *msg, int val)
 540 {
 541   OLSR_PRINTF(1, "OLSR EXIT: %s\n", msg);
 542   olsr_syslog(OLSR_LOG_ERR, "olsrd exit: %s\n", msg);
 543   fflush(stdout);
 544   olsr_cnf->exit_value = val;
 545
 546   raise(SIGTERM);
 547 }
 548
 549
 550 /**
 551  * Wrapper for malloc(3) that does error-checking
 552  *
 553  * @param size the number of bytes to allocalte
 554  * @param caller a string identifying the caller for
 555  * use in error messaging
 556  *
 557  * @return a void pointer to the memory allocated
 558  */
 559 void *
 560 olsr_malloc(size_t size, const char *id)
 561 {
 562   void *ptr;
 563
 564   /*
 565    * Not all the callers do a proper cleaning of memory.
 566    * Clean it on behalf of those.
 567    */
 568   ptr = calloc(1, size);
 569
 570   if (!ptr) {
 571       const char * const err_msg = strerror(errno);
 572       OLSR_PRINTF(1, "OUT OF MEMORY: %s\n", err_msg);
 573       olsr_syslog(OLSR_LOG_ERR, "olsrd: out of memory!: %s\n", err_msg);
 574       olsr_exit(id, EXIT_FAILURE);
 575   }
 576
 577   return ptr;
 578 }
 579
 580
 581 /**
 582  *Wrapper for printf that prints to a specific
 583  *debuglevel upper limit
 584  *
 585  */
 586
 587 int
 588 olsr_printf(int loglevel, const char *format, ...)
 589 {
 590   if((loglevel <= olsr_cnf->debug_level) && debug_handle)
 591     {
 592       va_list arglist;
 593       va_start(arglist, format);
 594       vfprintf(debug_handle, format, arglist);
 595       va_end(arglist);
 596     }
 597   return 0;
 598 }
 599
 600 /*
 601  * Local Variables:
 602  * c-basic-offset: 2
 603  * End:
 604  */