11df672a2851351f206d5cb1131be449a1704e03
[olsrd.git] / 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.3 2005/01/30 16:33:53 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 WIN32
46
47 static char *inet_ntop4(const unsigned char *src, char *dst, int size)
48 {
49   static const char fmt[] = "%u.%u.%u.%u";
50   char tmp[sizeof "255.255.255.255"];
51
52   if (sprintf(tmp, fmt, src[0], src[1], src[2], src[3]) > size)
53     return (NULL);
54
55   return strcpy(dst, tmp);
56 }
57
58 char *inet_ntop(int af, void *src, char *dst, int size)
59 {
60   switch (af)
61   {
62   case AF_INET:
63     return (inet_ntop4(src, dst, size));
64
65   default:
66     return (NULL);
67   }
68 }
69
70 #endif
71
72 #ifndef linux
73
74 #include <stdlib.h>
75
76 /* strndup() is a GNU extention */
77 char *
78 strndup(const char *ptr, size_t size)
79 {
80   int len = strlen(ptr);
81   char *ret = NULL;
82
83   if(!len)
84     return NULL;
85
86   if(len > size)
87     len = size;
88
89   ret = malloc(len + 1);
90   
91   if(!ret)
92     return NULL;
93
94   strncpy(ret, ptr, len);
95   ret[len] = '\0';
96
97   return ret;
98 }
99
100 #endif
101
102 /* Data to sent to the plugin with the register_olsr_function call 
103  * THIS STRUCT MUST MATCH ITS SIBLING IN plugin_loader.h IN OLSRD
104  */
105 struct olsr_plugin_data
106 {
107   int ipversion;
108   union olsr_ip_addr *main_addr;
109   int (*olsr_plugin_io)(int, void *, size_t);
110 };
111
112
113 /**
114  * "Private" declarations
115  */
116
117 void __attribute__ ((constructor)) 
118 my_init(void);
119
120 void __attribute__ ((destructor)) 
121 my_fini(void);
122
123 int
124 register_olsr_data(struct olsr_plugin_data *);
125
126 int
127 fetch_olsrd_data(void);
128
129 /*
130  * Returns the version of the plugin interface that is used
131  * THIS IS NOT THE VERSION OF YOUR PLUGIN!
132  */
133 int 
134 get_plugin_interface_version()
135 {
136   return PLUGIN_INTERFACE_VERSION;
137 }
138
139 /**
140  *Constructor
141  */
142 void
143 my_init()
144 {
145   /* Print plugin info to stdout */
146   printf("%s\n", MOD_DESC);
147
148   ifs = NULL;
149
150   return;
151 }
152
153 /**
154  *Destructor
155  */
156 void
157 my_fini()
158 {
159
160   /* Calls the destruction function
161    * olsr_plugin_exit()
162    * This function should be present in your
163    * sourcefile and all data destruction
164    * should happen there - NOT HERE!
165    */
166   olsr_plugin_exit();
167
168   return;
169 }
170
171 /* Mulitpurpose funtion */
172 int
173 plugin_io(int cmd, void *data, size_t size)
174 {
175
176   switch(cmd)
177     {
178     default:
179       return 0;
180     }
181   
182   return 1;
183 }
184
185 int
186 register_olsr_param(char *key, char *value)
187 {
188         if(!strcmp(key, "name")) {
189                 my_name = strndup( value, MAX_NAME );
190                 my_name_len = strlen( my_name );
191                 printf("(NAME) name: %s\n", my_name);
192         }       
193         
194         if(!strcmp(key, "filename")) {
195                 my_filename = strndup( value, MAX_FILE );
196                 printf("(NAME) filename: %s\n", my_filename);
197         }
198         
199         return 1;
200 }
201
202
203 /**
204  *Register needed functions and pointers
205  *
206  *This function should not be changed!
207  *
208  */
209 int
210 register_olsr_data(struct olsr_plugin_data *data)
211 {
212   /* IPversion */
213   ipversion = data->ipversion;
214   /* Main address */
215   main_addr = data->main_addr;
216
217   /* Multi-purpose function */
218   olsr_plugin_io = data->olsr_plugin_io;
219
220   /* Set size of IP address */
221   if(ipversion == AF_INET)
222     {
223       ipsize = sizeof(olsr_u32_t);
224     }
225   else
226     {
227       ipsize = sizeof(struct in6_addr);
228     }
229
230   if(!fetch_olsrd_data())
231     {
232       fprintf(stderr, "Could not fetch the neccessary functions from olsrd!\n");
233       return 0;
234     }
235
236   /* Calls the initialization function
237    * olsr_plugin_init()
238    * This function should be present in your
239    * sourcefile and all data initialization
240    * should happen there - NOT HERE!
241    */
242   if(!olsr_plugin_init())
243     {
244       fprintf(stderr, "Could not initialize plugin!\n");
245       return 0;
246     }
247
248   return 1;
249 }
250
251
252
253 int
254 fetch_olsrd_data()
255 {
256   int retval = 1;
257
258
259   /* Packet buffer */
260   if(!olsr_plugin_io(GETF__NET_OUTBUFFER_PUSH, &net_outbuffer_push, sizeof(net_outbuffer_push)))
261   {
262     net_outbuffer_push = NULL;
263     retval = 0;
264   }
265
266   /* Olsr debug output function */
267   if(!olsr_plugin_io(GETF__OLSR_PRINTF, 
268                      &olsr_printf, 
269                      sizeof(olsr_printf)))
270   {
271     olsr_printf = NULL;
272     retval = 0;
273   }
274
275
276   /* Olsr malloc wrapper */
277   if(!olsr_plugin_io(GETF__OLSR_MALLOC, 
278                      &olsr_malloc, 
279                      sizeof(olsr_malloc)))
280   {
281     olsr_malloc = NULL;
282     retval = 0;
283   }
284
285   /* Parser registration */
286   if(!olsr_plugin_io(GETF__OLSR_PARSER_ADD_FUNCTION, 
287                      &olsr_parser_add_function, 
288                      sizeof(olsr_parser_add_function)))
289   {
290     olsr_parser_add_function = NULL;
291     retval = 0;
292   }
293
294   /* Scheduler timeout registration */
295   if(!olsr_plugin_io(GETF__OLSR_REGISTER_TIMEOUT_FUNCTION, 
296                      &olsr_register_timeout_function, 
297                      sizeof(olsr_register_timeout_function)))
298   {
299     olsr_register_timeout_function = NULL;
300     retval = 0;
301   }
302
303   /* Scheduler event registration */
304   if(!olsr_plugin_io(GETF__OLSR_REGISTER_SCHEDULER_EVENT, 
305                      &olsr_register_scheduler_event, 
306                      sizeof(olsr_register_scheduler_event)))
307   {
308     olsr_register_scheduler_event = NULL;
309     retval = 0;
310   }
311
312   /* Double to mantissa/exponent */
313   if(!olsr_plugin_io(GETF__DOUBLE_TO_ME, 
314                      &double_to_me, 
315                      sizeof(double_to_me)))
316   {
317     double_to_me = NULL;
318     retval = 0;
319   }
320
321
322
323   /* Mantissa/exponent to double conversion */
324   if(!olsr_plugin_io(GETF__ME_TO_DOUBLE, 
325                      &me_to_double, 
326                      sizeof(me_to_double)))
327   {
328     me_to_double = NULL;
329     retval = 0;
330   }
331
332
333   /* Interface list */
334   if(!olsr_plugin_io(GETD__IFNET, &ifs, sizeof(ifs)))
335   {
336     ifs = NULL;
337     retval = 0;
338   }
339
340   /* Messageseqno fetch function */
341   if(!olsr_plugin_io(GETF__GET_MSG_SEQNO, &get_msg_seqno, sizeof(get_msg_seqno)))
342   {
343     get_msg_seqno = NULL;
344     retval = 0;
345   }
346
347   /* Scheduler maintained timestamp */
348   if(!olsr_plugin_io(GETD__NOW, &now, sizeof(now)))
349   {
350     now = NULL;
351     retval = 0;
352   }
353
354   /* Output function */
355   if(!olsr_plugin_io(GETF__NET_OUTPUT, &net_output, sizeof(net_output)))
356   {
357     net_output = NULL;
358     retval = 0;
359   }
360
361   /* Duplicate check (for processing) */
362   if(!olsr_plugin_io(GETF__OLSR_CHECK_DUP_TABLE_PROC, &check_dup_proc, sizeof(check_dup_proc)))
363   {
364     check_dup_proc = NULL;
365     retval = 0;
366   }
367
368   /* Default forward function */
369   if(!olsr_plugin_io(GETF__OLSR_FORWARD_MESSAGE, &default_fwd, sizeof(default_fwd)))
370   {
371     default_fwd = NULL;
372     retval = 0;
373   }
374
375
376   /* Add socket to OLSR select function */
377   if(!olsr_plugin_io(GETF__ADD_OLSR_SOCKET, &add_olsr_socket, sizeof(add_olsr_socket)))
378   {
379     add_olsr_socket = NULL;
380     retval = 0;
381   }
382
383   /* Neighbor link status lookup */
384   if(!olsr_plugin_io(GETF__CHECK_NEIGHBOR_LINK, &check_neighbor_link, sizeof(check_neighbor_link)))
385   {
386     check_neighbor_link = NULL;
387     retval = 0;
388   }
389
390   return retval;
391 }