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