lib/secure/src/olsrd_plugin.c

   1
   2 /*
   3  * Secure OLSR plugin
   4  * http://www.olsr.org
   5  *
   6  * Copyright (c) 2004, Andreas Tønnesen(andreto@olsr.org)
   7  * All rights reserved.
   8  *
   9  * Redistribution and use in source and binary forms, with or
  10  * without modification, are permitted provided that the following
  11  * conditions are met:
  12  *
  13  * * Redistributions of source code must retain the above copyright
  14  *   notice, this list of conditions and the following disclaimer.
  15  * * Redistributions in binary form must reproduce the above copyright
  16  *   notice, this list of conditions and the following disclaimer in
  17  *   the documentation and/or other materials provided with the
  18  *   distribution.
  19  * * Neither the name of olsrd, olsr.org nor the names of its
  20  *   contributors may be used to endorse or promote products derived
  21  *   from this software without specific prior written permission.
  22  *
  23  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  24  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  25  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  26  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
  27  * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  28  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
  29  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  30  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  31  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  32  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
  33  * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  34  * POSSIBILITY OF SUCH DAMAGE.
  35  *
  36  * $Id: olsrd_plugin.c,v 1.8 2004/11/30 17:04:45 kattemat Exp $
  37  */
  38
  39
  40
  41 #include "olsrd_plugin.h"
  42 #include <stdio.h>
  43 #include <string.h>
  44
  45 /* Data to sent to the plugin with the register_olsr_function call
  46  * THIS STRUCT MUST MATCH ITS SIBLING IN plugin_loader.h IN OLSRD
  47  */
  48 struct olsr_plugin_data
  49 {
  50   int ipversion;
  51   union olsr_ip_addr *main_addr;
  52   int (*olsr_plugin_io)(int, void *, size_t);
  53 };
  54
  55
  56 /* Prototypes */
  57
  58 void __attribute__ ((constructor))
  59 my_init(void);
  60
  61 void __attribute__ ((destructor))
  62 my_fini(void);
  63
  64 int
  65 register_olsr_data(struct olsr_plugin_data *);
  66
  67 int
  68 fetch_olsrd_data(void);
  69
  70 /*
  71  * Defines the version of the plugin interface that is used
  72  * THIS IS NOT THE VERSION OF YOUR PLUGIN!
  73  * Do not alter unless you know what you are doing!
  74  */
  75 int
  76 get_plugin_interface_version()
  77 {
  78   return PLUGIN_INTERFACE_VERSION;
  79 }
  80
  81
  82
  83 /**
  84  *Constructor
  85  */
  86 void
  87 my_init()
  88 {
  89   /* Print plugin info to stdout */
  90   /* We cannot use olsr_printf yet! */
  91   printf("%s\n", MOD_DESC);
  92   printf("[ENC]Accepted parameter pairs: (\"Keyfile\" <FILENAME>)\n");
  93   ifs = NULL;
  94
  95   return;
  96 }
  97
  98 /**
  99  *Destructor
 100  */
 101 void
 102 my_fini()
 103 {
 104
 105   /* Calls the destruction function
 106    * olsr_plugin_exit()
 107    * This function should be present in your
 108    * sourcefile and all data destruction
 109    * should happen there - NOT HERE!
 110    */
 111   olsr_plugin_exit();
 112
 113   return;
 114 }
 115
 116
 117 int
 118 register_olsr_param(char *key, char *value)
 119 {
 120   if(!strcmp(key, "Keyfile"))
 121     {
 122       strncpy(keyfile, value, FILENAME_MAX);
 123     }
 124
 125   return 1;
 126 }
 127
 128
 129 /**
 130  *Register needed functions and pointers
 131  *
 132  *This function should not be changed!
 133  *
 134  */
 135 int
 136 register_olsr_data(struct olsr_plugin_data *data)
 137 {
 138   /* IPversion */
 139   ipversion = data->ipversion;
 140   /* Main address */
 141   main_addr = data->main_addr;
 142
 143   /* Multi-purpose function */
 144   olsr_plugin_io = data->olsr_plugin_io;
 145
 146   /* Set size of IP address */
 147   if(ipversion == AF_INET)
 148     {
 149       ipsize = sizeof(olsr_u32_t);
 150     }
 151   else
 152     {
 153       ipsize = sizeof(struct in6_addr);
 154     }
 155
 156   if(!fetch_olsrd_data())
 157     {
 158       fprintf(stderr, "Could not fetch the neccessary functions from olsrd!\n");
 159       return 0;
 160     }
 161
 162   /* Calls the initialization function
 163    * olsr_plugin_init()
 164    * This function should be present in your
 165    * sourcefile and all data initialization
 166    * should happen there - NOT HERE!
 167    */
 168   if(!olsr_plugin_init())
 169     {
 170       fprintf(stderr, "Could not initialize plugin!\n");
 171       return 0;
 172     }
 173
 174   if(!plugin_ipc_init())
 175     {
 176       fprintf(stderr, "Could not initialize plugin IPC!\n");
 177       return 0;
 178     }
 179   return 1;
 180
 181 }
 182
 183
 184
 185 int
 186 fetch_olsrd_data()
 187 {
 188   int retval = 1;
 189
 190
 191   if(!olsr_plugin_io(GETF__NET_RESERVE_BUFSPACE,
 192                      &net_reserve_bufspace,
 193                      sizeof(net_reserve_bufspace)))
 194   {
 195     net_reserve_bufspace = NULL;
 196     retval = 0;
 197   }
 198
 199   if(!olsr_plugin_io(GETF__NET_OUTBUFFER_PUSH_RESERVED,
 200                      &net_outbuffer_push_reserved,
 201                      sizeof(net_outbuffer_push_reserved)))
 202   {
 203     net_outbuffer_push_reserved = NULL;
 204     retval = 0;
 205   }
 206
 207   if(!olsr_plugin_io(GETF__NET_OUTBUFFER_PUSH,
 208                      &net_outbuffer_push,
 209                      sizeof(net_outbuffer_push)))
 210   {
 211     net_outbuffer_push = NULL;
 212     retval = 0;
 213   }
 214
 215
 216   if(!olsr_plugin_io(GETF__OLSR_PRINTF,
 217                      &olsr_printf,
 218                      sizeof(olsr_printf)))
 219   {
 220     olsr_printf = NULL;
 221     retval = 0;
 222   }
 223
 224   if(!olsr_plugin_io(GETD__NOW,
 225                      &now,
 226                      sizeof(now)))
 227   {
 228     now = NULL;
 229     retval = 0;
 230   }
 231
 232   if(!olsr_plugin_io(GETF__NET_OUTPUT,
 233                      &net_output,
 234                      sizeof(net_output)))
 235   {
 236     net_output = NULL;
 237     retval = 0;
 238   }
 239
 240   /* Olsr malloc wrapper */
 241   if(!olsr_plugin_io(GETF__OLSR_MALLOC,
 242                      &olsr_malloc,
 243                      sizeof(olsr_malloc)))
 244   {
 245     olsr_malloc = NULL;
 246     retval = 0;
 247   }
 248
 249   /* Scheduler event registration */
 250   if(!olsr_plugin_io(GETF__OLSR_REGISTER_SCHEDULER_EVENT,
 251                      &olsr_register_scheduler_event,
 252                      sizeof(olsr_register_scheduler_event)))
 253   {
 254     olsr_register_scheduler_event = NULL;
 255     retval = 0;
 256   }
 257
 258
 259   /* Interface list */
 260   if(!olsr_plugin_io(GETD__IFNET, &ifs, sizeof(ifs)))
 261   {
 262     ifs = NULL;
 263     retval = 0;
 264   }
 265
 266
 267
 268   /* Add socket to OLSR select function */
 269   if(!olsr_plugin_io(GETF__ADD_OLSR_SOCKET, &add_olsr_socket, sizeof(add_olsr_socket)))
 270   {
 271     add_olsr_socket = NULL;
 272     retval = 0;
 273   }
 274
 275   /* Remove socket from OLSR select function */
 276   if(!olsr_plugin_io(GETF__REMOVE_OLSR_SOCKET, &remove_olsr_socket, sizeof(remove_olsr_socket)))
 277   {
 278     remove_olsr_socket = NULL;
 279     retval = 0;
 280   }
 281
 282   /* Add packet transform function */
 283   if(!olsr_plugin_io(GETF__ADD_PTF, &add_ptf, sizeof(add_ptf)))
 284   {
 285     add_ptf = NULL;
 286     retval = 0;
 287   }
 288
 289   /* Remove packet transform function */
 290   if(!olsr_plugin_io(GETF__DEL_PTF, &del_ptf, sizeof(del_ptf)))
 291   {
 292     del_ptf = NULL;
 293     retval = 0;
 294   }
 295
 296   /* Get message seqno function */
 297   if(!olsr_plugin_io(GETF__GET_MSG_SEQNO, &get_msg_seqno, sizeof(get_msg_seqno)))
 298   {
 299     get_msg_seqno = NULL;
 300     retval = 0;
 301   }
 302
 303   /* Socket read function */
 304   if(!olsr_plugin_io(GETF__OLSR_INPUT, &olsr_input, sizeof(olsr_input)))
 305   {
 306     olsr_input = NULL;
 307     retval = 0;
 308   }
 309
 310   /* Default packet parser */
 311   if(!olsr_plugin_io(GETF__PARSE_PACKET, &parse_packet, sizeof(parse_packet)))
 312   {
 313     parse_packet = NULL;
 314     retval = 0;
 315   }
 316
 317   /* Find interface by socket */
 318   if(!olsr_plugin_io(GETF__IF_IFWITHSOCK, &if_ifwithsock, sizeof(if_ifwithsock)))
 319   {
 320     if_ifwithsock = NULL;
 321     retval = 0;
 322   }
 323
 324   /* Find interface by address */
 325   if(!olsr_plugin_io(GETF__IF_IFWITHADDR, &if_ifwithaddr, sizeof(if_ifwithaddr)))
 326   {
 327     if_ifwithaddr = NULL;
 328     retval = 0;
 329   }
 330
 331
 332   /* Add ifchange function */
 333   if(!olsr_plugin_io(GETF__ADD_IFCHGF, &add_ifchgf, sizeof(add_ifchgf)))
 334   {
 335     add_ifchgf = NULL;
 336     retval = 0;
 337   }
 338
 339   /* Remove ifchange function */
 340   if(!olsr_plugin_io(GETF__DEL_IFCHGF, &del_ifchgf, sizeof(del_ifchgf)))
 341   {
 342     del_ifchgf = NULL;
 343     retval = 0;
 344   }
 345
 346
 347   return retval;
 348
 349 }