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