lib/nameservice/src/olsrd_plugin.c

   1 /*
   2  * Copyright (c) 2005, Bruno Randolf <bruno.randolf@4g-systems.biz>
   3  * Copyright (c) 2004, Andreas Tønnesen(andreto-at-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 notice,
  11  *   this list of conditions and the following disclaimer.
  12  * * Redistributions in binary form must reproduce the above copyright notice,
  13  *   this list of conditions and the following disclaimer in the documentation
  14  *   and/or other materials provided with the distribution.
  15  * * Neither the name of the UniK olsr daemon nor the names of its contributors
  16  *   may be used to endorse or promote products derived from this software
  17  *   without specific prior written permission.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  20  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  21  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  22  * IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
  23  * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
  24  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  25  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  26  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
  27  * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
  28  * OF THE POSSIBILITY OF SUCH DAMAGE.
  29  *
  30  */
  31
  32 /* $Id: olsrd_plugin.c,v 1.2 2005/01/30 16:20:36 kattemat Exp $ */
  33
  34
  35 /*
  36  * Dynamic linked library example for UniK OLSRd
  37  */
  38
  39 #include <stdio.h>
  40 #include <string.h>
  41
  42 #include "olsrd_plugin.h"
  43 #include "nameservice.h"
  44
  45 #ifdef __FreeBSD__
  46
  47 #include <stdlib.h>
  48
  49 /* strndup() is a GNU extention */
  50 char *
  51 strndup(const char *ptr, size_t size)
  52 {
  53   int len = strlen(ptr);
  54   char *ret = NULL;
  55
  56   if(!len)
  57     return NULL;
  58
  59   if(len > size)
  60     len = size;
  61
  62   ret = malloc(len + 1);
  63
  64   if(!ret)
  65     return NULL;
  66
  67   strncpy(ret, ptr, len);
  68   ret[len] = '\0';
  69
  70   return ret;
  71 }
  72
  73 #endif
  74
  75 /* Data to sent to the plugin with the register_olsr_function call
  76  * THIS STRUCT MUST MATCH ITS SIBLING IN plugin_loader.h IN OLSRD
  77  */
  78 struct olsr_plugin_data
  79 {
  80   int ipversion;
  81   union olsr_ip_addr *main_addr;
  82   int (*olsr_plugin_io)(int, void *, size_t);
  83 };
  84
  85
  86 /**
  87  * "Private" declarations
  88  */
  89
  90 void __attribute__ ((constructor))
  91 my_init(void);
  92
  93 void __attribute__ ((destructor))
  94 my_fini(void);
  95
  96 int
  97 register_olsr_data(struct olsr_plugin_data *);
  98
  99 int
 100 fetch_olsrd_data(void);
 101
 102 /*
 103  * Returns the version of the plugin interface that is used
 104  * THIS IS NOT THE VERSION OF YOUR PLUGIN!
 105  */
 106 int
 107 get_plugin_interface_version()
 108 {
 109   return PLUGIN_INTERFACE_VERSION;
 110 }
 111
 112 /**
 113  *Constructor
 114  */
 115 void
 116 my_init()
 117 {
 118   /* Print plugin info to stdout */
 119   printf("%s\n", MOD_DESC);
 120
 121   ifs = NULL;
 122
 123   return;
 124 }
 125
 126 /**
 127  *Destructor
 128  */
 129 void
 130 my_fini()
 131 {
 132
 133   /* Calls the destruction function
 134    * olsr_plugin_exit()
 135    * This function should be present in your
 136    * sourcefile and all data destruction
 137    * should happen there - NOT HERE!
 138    */
 139   olsr_plugin_exit();
 140
 141   return;
 142 }
 143
 144 /* Mulitpurpose funtion */
 145 int
 146 plugin_io(int cmd, void *data, size_t size)
 147 {
 148
 149   switch(cmd)
 150     {
 151     default:
 152       return 0;
 153     }
 154
 155   return 1;
 156 }
 157
 158 int
 159 register_olsr_param(char *key, char *value)
 160 {
 161         if(!strcmp(key, "name")) {
 162                 my_name = strndup( value, MAX_NAME );
 163                 my_name_len = strlen( my_name );
 164                 printf("(NAME) name: %s\n", my_name);
 165         }
 166
 167         if(!strcmp(key, "filename")) {
 168                 my_filename = strndup( value, MAX_FILE );
 169                 printf("(NAME) filename: %s\n", my_filename);
 170         }
 171
 172         return 1;
 173 }
 174
 175
 176 /**
 177  *Register needed functions and pointers
 178  *
 179  *This function should not be changed!
 180  *
 181  */
 182 int
 183 register_olsr_data(struct olsr_plugin_data *data)
 184 {
 185   /* IPversion */
 186   ipversion = data->ipversion;
 187   /* Main address */
 188   main_addr = data->main_addr;
 189
 190   /* Multi-purpose function */
 191   olsr_plugin_io = data->olsr_plugin_io;
 192
 193   /* Set size of IP address */
 194   if(ipversion == AF_INET)
 195     {
 196       ipsize = sizeof(olsr_u32_t);
 197     }
 198   else
 199     {
 200       ipsize = sizeof(struct in6_addr);
 201     }
 202
 203   if(!fetch_olsrd_data())
 204     {
 205       fprintf(stderr, "Could not fetch the neccessary functions from olsrd!\n");
 206       return 0;
 207     }
 208
 209   /* Calls the initialization function
 210    * olsr_plugin_init()
 211    * This function should be present in your
 212    * sourcefile and all data initialization
 213    * should happen there - NOT HERE!
 214    */
 215   if(!olsr_plugin_init())
 216     {
 217       fprintf(stderr, "Could not initialize plugin!\n");
 218       return 0;
 219     }
 220
 221   return 1;
 222 }
 223
 224
 225
 226 int
 227 fetch_olsrd_data()
 228 {
 229   int retval = 1;
 230
 231
 232   /* Packet buffer */
 233   if(!olsr_plugin_io(GETF__NET_OUTBUFFER_PUSH, &net_outbuffer_push, sizeof(net_outbuffer_push)))
 234   {
 235     net_outbuffer_push = NULL;
 236     retval = 0;
 237   }
 238
 239   /* Olsr debug output function */
 240   if(!olsr_plugin_io(GETF__OLSR_PRINTF,
 241                      &olsr_printf,
 242                      sizeof(olsr_printf)))
 243   {
 244     olsr_printf = NULL;
 245     retval = 0;
 246   }
 247
 248
 249   /* Olsr malloc wrapper */
 250   if(!olsr_plugin_io(GETF__OLSR_MALLOC,
 251                      &olsr_malloc,
 252                      sizeof(olsr_malloc)))
 253   {
 254     olsr_malloc = NULL;
 255     retval = 0;
 256   }
 257
 258   /* Parser registration */
 259   if(!olsr_plugin_io(GETF__OLSR_PARSER_ADD_FUNCTION,
 260                      &olsr_parser_add_function,
 261                      sizeof(olsr_parser_add_function)))
 262   {
 263     olsr_parser_add_function = NULL;
 264     retval = 0;
 265   }
 266
 267   /* Scheduler timeout registration */
 268   if(!olsr_plugin_io(GETF__OLSR_REGISTER_TIMEOUT_FUNCTION,
 269                      &olsr_register_timeout_function,
 270                      sizeof(olsr_register_timeout_function)))
 271   {
 272     olsr_register_timeout_function = NULL;
 273     retval = 0;
 274   }
 275
 276   /* Scheduler event registration */
 277   if(!olsr_plugin_io(GETF__OLSR_REGISTER_SCHEDULER_EVENT,
 278                      &olsr_register_scheduler_event,
 279                      sizeof(olsr_register_scheduler_event)))
 280   {
 281     olsr_register_scheduler_event = NULL;
 282     retval = 0;
 283   }
 284
 285   /* Double to mantissa/exponent */
 286   if(!olsr_plugin_io(GETF__DOUBLE_TO_ME,
 287                      &double_to_me,
 288                      sizeof(double_to_me)))
 289   {
 290     double_to_me = NULL;
 291     retval = 0;
 292   }
 293
 294
 295
 296   /* Mantissa/exponent to double conversion */
 297   if(!olsr_plugin_io(GETF__ME_TO_DOUBLE,
 298                      &me_to_double,
 299                      sizeof(me_to_double)))
 300   {
 301     me_to_double = NULL;
 302     retval = 0;
 303   }
 304
 305
 306   /* Interface list */
 307   if(!olsr_plugin_io(GETD__IFNET, &ifs, sizeof(ifs)))
 308   {
 309     ifs = NULL;
 310     retval = 0;
 311   }
 312
 313   /* Messageseqno fetch function */
 314   if(!olsr_plugin_io(GETF__GET_MSG_SEQNO, &get_msg_seqno, sizeof(get_msg_seqno)))
 315   {
 316     get_msg_seqno = NULL;
 317     retval = 0;
 318   }
 319
 320   /* Scheduler maintained timestamp */
 321   if(!olsr_plugin_io(GETD__NOW, &now, sizeof(now)))
 322   {
 323     now = NULL;
 324     retval = 0;
 325   }
 326
 327   /* Output function */
 328   if(!olsr_plugin_io(GETF__NET_OUTPUT, &net_output, sizeof(net_output)))
 329   {
 330     net_output = NULL;
 331     retval = 0;
 332   }
 333
 334   /* Duplicate check (for processing) */
 335   if(!olsr_plugin_io(GETF__OLSR_CHECK_DUP_TABLE_PROC, &check_dup_proc, sizeof(check_dup_proc)))
 336   {
 337     check_dup_proc = NULL;
 338     retval = 0;
 339   }
 340
 341   /* Default forward function */
 342   if(!olsr_plugin_io(GETF__OLSR_FORWARD_MESSAGE, &default_fwd, sizeof(default_fwd)))
 343   {
 344     default_fwd = NULL;
 345     retval = 0;
 346   }
 347
 348
 349   /* Add socket to OLSR select function */
 350   if(!olsr_plugin_io(GETF__ADD_OLSR_SOCKET, &add_olsr_socket, sizeof(add_olsr_socket)))
 351   {
 352     add_olsr_socket = NULL;
 353     retval = 0;
 354   }
 355
 356   /* Neighbor link status lookup */
 357   if(!olsr_plugin_io(GETF__CHECK_NEIGHBOR_LINK, &check_neighbor_link, sizeof(check_neighbor_link)))
 358   {
 359     check_neighbor_link = NULL;
 360     retval = 0;
 361   }
 362
 363   return retval;
 364 }