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  * $Id: olsr.c,v 1.28 2004/11/21 13:45:50 kattemat Exp $
  40  */
  41
  42 /**
  43  * All these functions are global
  44  */
  45
  46 #include "defs.h"
  47 #include "olsr.h"
  48 #include "link_set.h"
  49 #include "two_hop_neighbor_table.h"
  50 #include "tc_set.h"
  51 #include "duplicate_set.h"
  52 #include "mpr_selector_set.h"
  53 #include "mid_set.h"
  54 #include "mpr.h"
  55 #if defined USE_LINK_QUALITY
  56 #include "lq_mpr.h"
  57 #include "lq_route.h"
  58 #endif
  59 #include "scheduler.h"
  60 #include "generate_msg.h"
  61 #include "apm.h"
  62 #include "misc.h"
  63
  64 #include <stdarg.h>
  65 #include <signal.h>
  66
  67
  68 /**
  69  *Checks if a timer has timed out.
  70  */
  71
  72
  73 /**
  74  *Initiates a "timer", wich is a timeval structure,
  75  *with the value given in time_value.
  76  *@param time_value the value to initialize the timer with
  77  *@param hold_timer the timer itself
  78  *@return nada
  79  */
  80 inline void
  81 olsr_init_timer(olsr_u32_t time_value, struct timeval *hold_timer)
  82 {
  83   olsr_u16_t  time_value_sec;
  84   olsr_u16_t  time_value_msec;
  85
  86   time_value_sec = time_value/1000;
  87   time_value_msec = time_value-(time_value_sec*1000);
  88
  89   hold_timer->tv_sec = time_value_sec;
  90   hold_timer->tv_usec = time_value_msec*1000;
  91 }
  92
  93
  94
  95
  96
  97 /**
  98  *Generaties a timestamp a certain number of milliseconds
  99  *into the future.
 100  *
 101  *@param time_value how many milliseconds from now
 102  *@param hold_timer the timer itself
 103  *@return nada
 104  */
 105 inline void
 106 olsr_get_timestamp(olsr_u32_t delay, struct timeval *hold_timer)
 107 {
 108   hold_timer->tv_sec = now.tv_sec + delay / 1000;
 109   hold_timer->tv_usec = now.tv_usec + (delay % 1000) * 1000;
 110
 111   if (hold_timer->tv_usec > 1000000)
 112     {
 113       hold_timer->tv_sec++;
 114       hold_timer->tv_usec -= 1000000;
 115     }
 116 }
 117
 118
 119
 120 /**
 121  *Initialize the message sequence number as a random value
 122  */
 123 void
 124 init_msg_seqno()
 125 {
 126   message_seqno = random() & 0xFFFF;
 127 }
 128
 129 /**
 130  * Get and increment the message sequence number
 131  *
 132  *@return the seqno
 133  */
 134 inline olsr_u16_t
 135 get_msg_seqno()
 136 {
 137   return message_seqno++;
 138 }
 139
 140
 141 void
 142 register_pcf(int (*f)(int, int, int))
 143 {
 144   struct pcf *new_pcf;
 145
 146   olsr_printf(1, "Registering pcf function\n");
 147
 148   new_pcf = olsr_malloc(sizeof(struct pcf), "New PCF");
 149
 150   new_pcf->function = f;
 151   new_pcf->next = pcf_list;
 152   pcf_list = new_pcf;
 153
 154 }
 155
 156
 157 /**
 158  *Process changes in neighborhood or/and topology.
 159  *Re-calculates the neighborhooh/topology if there
 160  *are any updates - then calls the right functions to
 161  *update the routing table.
 162  *@return 0
 163  */
 164 inline void
 165 olsr_process_changes()
 166 {
 167
 168   struct pcf *tmp_pc_list;
 169
 170 #ifdef DEBUG
 171   if(changes_neighborhood)
 172     olsr_printf(3, "CHANGES IN NEIGHBORHOOD\n");
 173   if(changes_topology)
 174     olsr_printf(3, "CHANGES IN TOPOLOGY\n");
 175   if(changes_hna)
 176     olsr_printf(3, "CHANGES IN HNA\n");
 177 #endif
 178
 179   if(!changes_neighborhood &&
 180      !changes_topology &&
 181      !changes_hna)
 182     return;
 183
 184   if (olsr_cnf->debug_level > 0 && olsr_cnf->clear_screen && isatty(1))
 185   {
 186       clear_console();
 187       printf("<<<< %s (%s) >>>>\n", SOFTWARE_VERSION, __DATE__);
 188   }
 189
 190   if (changes_neighborhood)
 191     {
 192       /* Calculate new mprs, HNA and routing table */
 193 #if defined USE_LINK_QUALITY
 194       if (olsr_cnf->lq_level < 1)
 195         {
 196 #endif
 197           olsr_calculate_mpr();
 198 #if defined USE_LINK_QUALITY
 199         }
 200
 201       else
 202         {
 203           olsr_calculate_lq_mpr();
 204         }
 205
 206
 207       if (olsr_cnf->lq_level < 2)
 208         {
 209 #endif
 210           olsr_calculate_routing_table();
 211 #if defined USE_LINK_QUALITY
 212         }
 213
 214       else
 215         {
 216           olsr_calculate_lq_routing_table();
 217         }
 218 #endif
 219
 220       olsr_calculate_hna_routes();
 221     }
 222
 223   else if (changes_topology)
 224     {
 225       /* calculate the routing table and HNA */
 226 #if defined USE_LINK_QUALITY
 227       if (olsr_cnf->lq_level < 2)
 228         {
 229 #endif
 230           olsr_calculate_routing_table();
 231 #if defined USE_LINK_QUALITY
 232         }
 233
 234       else
 235         {
 236           olsr_calculate_lq_routing_table();
 237         }
 238 #endif
 239       olsr_calculate_hna_routes();
 240     }
 241
 242   else if (changes_hna)
 243     {
 244       /* Update HNA routes */
 245       olsr_calculate_hna_routes();
 246     }
 247
 248   if (olsr_cnf->debug_level > 0)
 249     {
 250
 251       if (olsr_cnf->debug_level > 1)
 252         olsr_print_tc_table();
 253
 254       if (olsr_cnf->debug_level > 2)
 255         {
 256           olsr_print_mid_set();
 257
 258           if (olsr_cnf->debug_level > 3)
 259             {
 260               olsr_print_duplicate_table();
 261               olsr_print_hna_set();
 262             }
 263         }
 264
 265       olsr_print_link_set();
 266       olsr_print_neighbor_table();
 267     }
 268
 269   for(tmp_pc_list = pcf_list;
 270       tmp_pc_list != NULL;
 271       tmp_pc_list = tmp_pc_list->next)
 272     {
 273       tmp_pc_list->function(changes_neighborhood,
 274                             changes_topology,
 275                             changes_hna);
 276     }
 277
 278   changes_neighborhood = OLSR_FALSE;
 279   changes_topology = OLSR_FALSE;
 280   changes_hna = OLSR_FALSE;
 281
 282
 283   return;
 284 }
 285
 286
 287
 288
 289
 290 /**
 291  *Initialize all the tables used(neighbor,
 292  *topology, MID,  HNA, MPR, dup).
 293  *Also initalizes other variables
 294  */
 295 void
 296 olsr_init_tables()
 297 {
 298
 299   changes_topology = OLSR_FALSE;
 300   changes_neighborhood = OLSR_FALSE;
 301   changes_hna = OLSR_FALSE;
 302
 303   /* Initialize link set */
 304   olsr_init_link_set();
 305
 306   /* Initialize duplicate table */
 307   olsr_init_duplicate_table();
 308
 309   /* Initialize neighbor table */
 310   olsr_init_neighbor_table();
 311
 312   /* Initialize routing table */
 313   olsr_init_routing_table();
 314
 315   /* Initialize two hop table */
 316   olsr_init_two_hop_table();
 317
 318   /* Initialize old route table */
 319   olsr_init_old_table();
 320
 321   /* Initialize topology */
 322   olsr_init_tc();
 323
 324   /* Initialize mpr selector table */
 325   olsr_init_mprs_set();
 326
 327   /* Initialize MID set */
 328   olsr_init_mid_set();
 329
 330   /* Initialize HNA set */
 331   olsr_init_hna_set();
 332
 333   /* Initialize ProcessChanges list */
 334   ptf_list = NULL;
 335
 336 }
 337
 338
 339
 340
 341
 342
 343 /**
 344  *Check if a message is to be forwarded and forward
 345  *it if necessary.
 346  *
 347  *@param m the OLSR message recieved
 348  *@param originator the originator of this message
 349  *@param seqno the seqno of the message
 350  *
 351  *@returns positive if forwarded
 352  */
 353 int
 354 olsr_forward_message(union olsr_message *m,
 355                      union olsr_ip_addr *originator,
 356                      olsr_u16_t seqno,
 357                      struct interface *in_if,
 358                      union olsr_ip_addr *from_addr)
 359 {
 360   union olsr_ip_addr *src;
 361   struct neighbor_entry *neighbor;
 362   int msgsize;
 363   struct interface *ifn;
 364
 365
 366   if(!olsr_check_dup_table_fwd(originator, seqno, &in_if->ip_addr))
 367     {
 368 #ifdef DEBUG
 369       olsr_printf(3, "Message already forwarded!\n");
 370 #endif
 371       return 0;
 372     }
 373
 374   /* Lookup sender address */
 375   if(!(src = mid_lookup_main_addr(from_addr)))
 376     src = from_addr;
 377
 378
 379   if(NULL == (neighbor=olsr_lookup_neighbor_table(src)))
 380     return 0;
 381
 382   if(neighbor->status != SYM)
 383     return 0;
 384
 385   /* Update duplicate table interface */
 386   olsr_update_dup_entry(originator, seqno, &in_if->ip_addr);
 387
 388
 389   /* Check MPR */
 390   if(olsr_lookup_mprs_set(src) == NULL)
 391     {
 392 #ifdef DEBUG
 393       olsr_printf(5, "Forward - sender %s not MPR selector\n", olsr_ip_to_string(src));
 394 #endif
 395       return 0;
 396     }
 397
 398
 399   /* Treat TTL hopcnt */
 400   if(olsr_cnf->ip_version == AF_INET)
 401     {
 402       /* IPv4 */
 403       m->v4.hopcnt++;
 404       m->v4.ttl--;
 405     }
 406   else
 407     {
 408       /* IPv6 */
 409       m->v6.hopcnt++;
 410       m->v6.ttl--;
 411     }
 412
 413
 414
 415   /* Update dup forwarded */
 416   olsr_set_dup_forward(originator, seqno);
 417
 418   /* Update packet data */
 419
 420
 421   msgsize = ntohs(m->v4.olsr_msgsize);
 422
 423   /* looping trough interfaces */
 424   for (ifn = ifnet; ifn ; ifn = ifn->int_next)
 425     {
 426       if(net_output_pending(ifn))
 427         {
 428           /*
 429            * Check if message is to big to be piggybacked
 430            */
 431           if(net_outbuffer_push(ifn, (olsr_u8_t *)m, msgsize) != msgsize)
 432             {
 433               /* Send */
 434               net_output(ifn);
 435               /* Buffer message */
 436               set_buffer_timer(ifn);
 437
 438               if(net_outbuffer_push(ifn, (olsr_u8_t *)m, msgsize) != msgsize)
 439                 {
 440                   olsr_printf(1, "Received message to big to be forwarded in %s(%d bytes)!", ifn->int_name, msgsize);
 441                   olsr_syslog(OLSR_LOG_ERR, "Received message to big to be forwarded on %s(%d bytes)!", ifn->int_name, msgsize);
 442                 }
 443
 444             }
 445         }
 446
 447       else
 448         {
 449           /* No forwarding pending */
 450           set_buffer_timer(ifn);
 451
 452           if(net_outbuffer_push(ifn, (olsr_u8_t *)m, msgsize) != msgsize)
 453             {
 454               olsr_printf(1, "Received message to big to be forwarded in %s(%d bytes)!", ifn->int_name, msgsize);
 455               olsr_syslog(OLSR_LOG_ERR, "Received message to big to be forwarded on %s(%d bytes)!", ifn->int_name, msgsize);
 456             }
 457         }
 458     }
 459
 460   return 1;
 461
 462 }
 463
 464
 465 void
 466 set_buffer_timer(struct interface *ifn)
 467 {
 468   float jitter;
 469   struct timeval jittertimer;
 470
 471   /* Set timer */
 472   jitter = (float) random()/RAND_MAX;
 473   jitter *= max_jitter;
 474
 475   olsr_init_timer((olsr_u32_t) (jitter*1000), &jittertimer);
 476
 477   timeradd(&now, &jittertimer, &fwdtimer[ifn->if_nr]);
 478
 479 }
 480
 481
 482
 483 void
 484 olsr_init_willingness()
 485 {
 486   if(olsr_cnf->willingness_auto)
 487     olsr_register_scheduler_event(&olsr_update_willingness, NULL, will_int, will_int, NULL);
 488 }
 489
 490 void
 491 olsr_update_willingness(void *foo)
 492 {
 493   int tmp_will;
 494
 495   tmp_will = olsr_cnf->willingness;
 496
 497   /* Re-calculate willingness */
 498   olsr_cnf->willingness = olsr_calculate_willingness();
 499
 500   if(tmp_will != olsr_cnf->willingness)
 501     {
 502       olsr_printf(1, "Local willingness updated: old %d new %d\n", tmp_will, olsr_cnf->willingness);
 503     }
 504 }
 505
 506
 507 /**
 508  *Calculate this nodes willingness to act as a MPR
 509  *based on either a fixed value or the power status
 510  *of the node using APM
 511  *
 512  *@return a 8bit value from 0-7 representing the willingness
 513  */
 514
 515 olsr_u8_t
 516 olsr_calculate_willingness()
 517 {
 518   struct olsr_apm_info ainfo;
 519
 520   /* If fixed willingness */
 521   if(!olsr_cnf->willingness_auto)
 522     return olsr_cnf->willingness;
 523
 524 #warning CHANGES IN THE apm INTERFACE(0.4.8)!
 525
 526   if(apm_read(&ainfo) < 1)
 527     return WILL_DEFAULT;
 528
 529   apm_printinfo(&ainfo);
 530
 531   /* If AC powered */
 532   if(ainfo.ac_line_status == OLSR_AC_POWERED)
 533     return 6;
 534
 535   /* If battery powered
 536    *
 537    * juice > 78% will: 3
 538    * 78% > juice > 26% will: 2
 539    * 26% > juice will: 1
 540    */
 541   return (ainfo.battery_percentage / 26);
 542 }
 543
 544
 545
 546 /**
 547  *Termination function to be called whenever a error occures
 548  *that requires the daemon to terminate
 549  *
 550  *@param msg the message to write to the syslog and possibly stdout
 551  */
 552
 553 void
 554 olsr_exit(const char *msg, int val)
 555 {
 556   olsr_printf(1, "OLSR EXIT: %s\n", msg);
 557   olsr_syslog(OLSR_LOG_ERR, "olsrd exit: %s\n", msg);
 558   fflush(stdout);
 559   exit_value = val;
 560
 561   raise(SIGTERM);
 562 }
 563
 564
 565 /**
 566  *Wrapper for malloc(3) that does error-checking
 567  *
 568  *@param size the number of bytes to allocalte
 569  *@param caller a string identifying the caller for
 570  *use in error messaging
 571  *
 572  *@return a void pointer to the memory allocated
 573  */
 574 void *
 575 olsr_malloc(size_t size, const char *id)
 576 {
 577   void *ptr;
 578
 579   if((ptr = malloc(size)) == 0)
 580     {
 581       olsr_printf(1, "OUT OF MEMORY: %s\n", strerror(errno));
 582       olsr_syslog(OLSR_LOG_ERR, "olsrd: out of memory!: %m\n");
 583       olsr_exit((char *)id, EXIT_FAILURE);
 584     }
 585   return ptr;
 586 }
 587
 588
 589 /**
 590  *Wrapper for printf that prints to a specific
 591  *debuglevel upper limit
 592  *
 593  */
 594
 595 inline int
 596 olsr_printf(int loglevel, char *format, ...)
 597 {
 598   va_list arglist;
 599
 600   if(loglevel <= olsr_cnf->debug_level)
 601     {
 602       va_start(arglist, format);
 603
 604       vprintf(format, arglist);
 605
 606       va_end(arglist);
 607     }
 608
 609
 610   return 0;
 611 }