src/olsr.c

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