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