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