fc3188df3b5eec8bde012d39bc2752aedb59ac85
[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.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 }