1    | /***************************************
2    |   $Revision: 1.2 $
3    | 
4    |   Definitions module (df)
5    | 
6    |   Status: NOT REVUED, NOT TESTED
7    | 
8    |   ******************/ /******************
9    |   Filename            : defs.c
10   |   Author              : ottrey@ripe.net
11   |   OSs Tested          : Solaris
12   |   Related Modules     : 
13   |   Problems            : 
14   |   To Do               : 
15   |   Comments            :
16   |   ******************/ /******************
17   |   Copyright (c) 1999                              RIPE NCC
18   |  
19   |   All Rights Reserved
20   |   
21   |   Permission to use, copy, modify, and distribute this software and its
22   |   documentation for any purpose and without fee is hereby granted,
23   |   provided that the above copyright notice appear in all copies and that
24   |   both that copyright notice and this permission notice appear in
25   |   supporting documentation, and that the name of the author not be
26   |   used in advertising or publicity pertaining to distribution of the
27   |   software without specific, written prior permission.
28   |   
29   |   THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
30   |   ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS; IN NO EVENT SHALL
31   |   AUTHOR BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY
32   |   DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
33   |   AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
34   |   OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
35   |   ***************************************/
36   | #include <stdio.h>
37   | #include <stdlib.h>
38   | #include <stdarg.h>
39   | #include <strings.h>
40   | #include <glib.h>
41   | 
42   | /*+ String sizes +*/
43   | #define STR_S   63
44   | #define STR_M   255
45   | #define STR_L   1023
46   | #define STR_XL  4095
47   | #define STR_XXL 16383
48   | 
49   | #include "defs.h"
50   | 
51   | #include "DF_class_names.def"
52   | #include "DF_class_codes.def"
53   | #include "DF_class_aliases.def"
54   | #include "DF_class_aliases_map.def"
55   | #include "DF_class_dbase_code_map.def"
56   | #include "DF_class_templates.def"
57   | #include "DF_class_templates_v.def"
58   | 
59   | #include "DF_attribute_names.def"
60   | #include "DF_attribute_codes.def"
61   | #include "DF_attribute_aliases.def"
62   | #include "DF_attribute_aliases_map.def"
63   | 
64   | /*+ Source database mirrors +*/
65   | char * const  Sources[] = {
66   |   "RIPE3",
67   |   "RIPE",
68   |   "ARIN",
69   |   "APNIC",
70   |   NULL
71   | }; /* Sources */
72   | 
73   | char * const  Server_queries[] = {
74   |   "help",
75   |   "sources",
76   |   "version",
77   |   "version",
78   |   NULL
79   | }; /* Server_queries */
80   | 
81   | char * const  Server_query[] = {
82   |   "You need help ...\n",
83   |   "The sources are ...\n",
84   |   "The version is ...\n",
85   |   NULL
86   | }; /* Server_query */
87   | 
88   | char * const  Filter_names[] = {
89   |   "aut-num",
90   |   "domain",
91   |   "inet6num",
92   |   "inetnum",
93   |   "inet-rtr",
94   |   "key-cert",
95   |   "limerick",
96   |   "mntner",
97   |   "route",
98   |   "origin",
99   |   "as-set",
100  |   "route-set",   
101  |   "members",
102  |   NULL
103  | }; /* Filter_names */
104  | 
105  | char * const *DF_get_filter_names(void) {
106  |   return Filter_names;
107  | } /* DF_get_filter_names() */
108  | 
109  | char * const *DF_get_class_names(void) {
110  |   return Class_names;
111  | } /* DF_get_class_names() */
112  | 
113  | char * const *DF_get_class_aliases(void) {
114  |   return Class_aliases;
115  | } /* DF_get_class_aliases() */
116  | 
117  | int DF_get_class_index(int alias_index) {
118  |   return Class_aliases_map[alias_index];
119  | } /* DF_get_class_index() */
120  | 
121  | char * const DF_get_class_name(int alias_index) {
122  |   return Class_names[Class_aliases_map[alias_index]];
123  | } /* DF_get_class_name() */
124  | 
125  | char * const DF_get_class_code(C_Type_t index) {
126  |   return Class_codes[index];
127  | } /* DF_get_class_code() */
128  | 
129  | int DF_get_class_dbase_code(int class_index) {
130  |   return Class_dbase_code_map[class_index];
131  | } /* DF_get_class_dbase_code() */
132  | 
133  | char * const *DF_get_sources(void) {
134  |   return Sources;
135  | } /* DF_get_sources() */
136  | 
137  | const char *DF_get_source(int index) {
138  |   return Sources[index];
139  | } /* DF_get_source() */
140  | 
141  | char * const *DF_get_attribute_aliases(void) {
142  |   return Attribute_aliases;
143  | } /* DF_get_attribute_aliases() */
144  | 
145  | const char *DF_get_attribute_name(A_Type_t index) {
146  |   return Attribute_names[index];
147  | } /* DF_get_attribute_name() */
148  | 
149  | const char *DF_get_attribute_code(A_Type_t index) {
150  |   return Attribute_codes[index];
151  | } /* DF_get_attribute_code() */
152  | 
153  | char * const *DF_get_attribute_names(void) {
154  |   return Attribute_names;
155  | } /* DF_get_attribute_names() */
156  | 
157  | int DF_get_attribute_index(int alias_index) {
158  |   return Attribute_aliases_map[alias_index];
159  | } /* DF_get_attribute_index() */
160  | 
161  | const char *DF_get_class_template(C_Type_t index) {
162  |   return Templates[index];
163  | } /* DF_get_class_template() */
164  | 
165  | const char *DF_get_class_template_v(C_Type_t index) {
166  |   return Templates_v[index];
167  | } /* DF_get_class_template_v() */
168  | 
169  | const char *DF_get_server_query(int index) {
170  |   return Server_query[index];
171  | } /* DF_get_server_query() */
172  | 
173  | char * const *DF_get_server_queries(void) {
174  |   return Server_queries;
175  | } /* DF_get_server_queries() */
176  | 
177  | const char *DF_get_attribute_desc(A_Type_t index) {
178  | /*
179  |   return (char *)Attributes_details[attr_index][0];
180  | */
181  |   return NULL;
182  | } /* DF_get_attribute_desc() */
183  | 
184  | const char *DF_get_attribute_frmt(A_Type_t index) {
185  | /*
186  |   return (char *)Attributes_details[attr_index][1];
187  | */
188  |   return NULL;
189  | } /* DF_get_attribute_frmt() */
190  | 
191  | /* source_foreach() */
192  | /*++++++++++++++++++++++++++++++++++++++
193  |   Function to adds the source string to the created string from the Glist of sources.
194  |   It is called via g_list_foreach().
195  | 
196  |   void *element_data The source name.
197  | 
198  |   void *result_buf_ptr The string to be populated.
199  | 
200  |   More:
201  |   +html+ <PRE>
202  |   Authors:
203  |         ottrey
204  | 
205  |   +html+ </PRE><DL COMPACT>
206  |   +html+ <DT>Online References:
207  |   +html+ <DD><UL>
208  |   +html+ </UL></DL>
209  | 
210  |   ++++++++++++++++++++++++++++++++++++++*/
211  | static void source_foreach(void *element_data, void *result_buf_ptr) {
212  |   char *source = element_data;
213  |   char *result_buf = (char *)result_buf_ptr;
214  | 
215  |   strcat(result_buf, element_data);
216  |   strcat(result_buf, ",");
217  | 
218  | } /* source_foreach() */
219  | 
220  | /* DF_sources_to_string() */
221  | /*++++++++++++++++++++++++++++++++++++++
222  |   Creates a string from Sources.
223  | 
224  |   char * DF_sources_to_string Returns a string of the Sources.
225  | 
226  |   More:
227  |   +html+ <PRE>
228  |   Authors:
229  |         ottrey
230  | 
231  |   +html+ </PRE><DL COMPACT>
232  |   +html+ <DT>Online References:
233  |   +html+ <DD><UL>
234  |   +html+ </UL></DL>
235  | 
236  |   ++++++++++++++++++++++++++++++++++++++*/
237  | char * DF_sources_to_string(void) {
238  |   char *result=NULL;
239  |   char result_buf[STR_XL];
240  |   int result_len;
241  |   int i;
242  | 
243  |   strcpy(result_buf, "{");
244  |   for (i=0; Sources[i] != NULL; i++) {
245  |     strcat(result_buf, Sources[i]);
246  |     strcat(result_buf, ",");
247  |   }
248  |   result_len = strlen(result_buf);
249  |   result_buf[result_len-1] = '}';
250  |   result_buf[result_len] = '\0';
251  | 
252  |   result = (char *)calloc(1, result_len+1);
253  |   strcpy(result, result_buf);
254  | 
255  |   return result;
256  | 
257  | } /* DF_sources_to_string() */
258  | 
259  | /* DF_sources_list_to_string() */
260  | /*++++++++++++++++++++++++++++++++++++++
261  |   Creates a string from the sources in the GList.
262  | 
263  |   GList *sources_list  The GList of sources.
264  | 
265  |   More:
266  |   +html+ <PRE>
267  |   Authors:
268  |         ottrey
269  | 
270  |   +html+ </PRE><DL COMPACT>
271  |   +html+ <DT>Online References:
272  |   +html+ <DD><UL>
273  |   +html+ </UL></DL>
274  | 
275  |   ++++++++++++++++++++++++++++++++++++++*/
276  | char *DF_sources_list_to_string(GList *sources_list) {
277  |   char *result=NULL;
278  |   char result_buf[STR_XL];
279  |   int result_len;
280  | 
281  |   strcpy(result_buf, "{");
282  |   g_list_foreach(sources_list, source_foreach, &result_buf);
283  |   result_len = strlen(result_buf);
284  |   if (result_len == 1) {
285  |     /* If an empty set */
286  |     result_buf[1] = '}';
287  |     result_buf[2] = '\0';
288  |   }
289  |   else {
290  |     result_buf[result_len-1] = '}';
291  |     result_buf[result_len] = '\0';
292  |   }
293  | 
294  |   result = (char *)calloc(1, result_len+1);
295  |   strcpy(result, result_buf);
296  | 
297  |   return result;
298  | 
299  | } /* DF_sources_list_to_string() */
300  | 
301  | 
302  | /* DF_attributes_to_string() */
303  | /*++++++++++++++++++++++++++++++++++++++
304  |   Returns a string of all the attributes.  Only there for debugging and tracing purposes.
305  | 
306  |   int offset The offset (Ie short or long name).
307  | 
308  |   More:
309  |   +html+ <PRE>
310  |   Authors:
311  |         ottrey
312  | 
313  |   +html+ </PRE><DL COMPACT>
314  |   +html+ <DT>Online References:
315  |   +html+ <DD><UL>
316  |   +html+ </UL></DL>
317  | 
318  |   ++++++++++++++++++++++++++++++++++++++*/
319  | char *DF_attributes_to_string(void) {
320  |   int i;
321  |   char *str;
322  |   char str_buffer[4096];
323  |   int str_len;
324  | 
325  |   strcpy(str_buffer, "{\"");
326  |   for (i=0; Attribute_names[i] != NULL; i++) {
327  |     strcat(str_buffer, Attribute_names[i]);
328  |     strcat(str_buffer, "\", \"");
329  |   }
330  |   str_len = strlen(str_buffer);
331  |   str_buffer[str_len-3] = '}';
332  |   str_buffer[str_len-2] = '\0';
333  |   str_len--;
334  | 
335  |   str = (char *)calloc(1, str_len);
336  |   strcpy(str, str_buffer);
337  | 
338  |   return str;
339  | 
340  | } /* DF_attributes_to_string() */
341  | 
342  | /* XXX This could be done MUCH more efficiently (with a hash) */
343  | A_Type_t DF_attribute_code2type(const gchar *token) {
344  |   A_Type_t result=-1;
345  | 
346  |   int i;
347  |   for (i=0; Attribute_aliases[i] != NULL; i++) {
348  |     if (strcmp(Attribute_aliases[i], token) == 0) {
349  |       result = Attribute_aliases_map[i];
350  |       break;
351  |     }
352  |   }
353  | 
354  |   return result;
355  | } /* DF_attribute_code2type() */
356  | 
357  | /* XXX This could be done MUCH more efficiently (with a hash) */
358  | A_Type_t DF_attribute_name2type(const gchar *token) {
359  |   A_Type_t result=-1;
360  | 
361  |   int i;
362  |   for (i=0; Attribute_aliases[i] != NULL; i++) {
363  |     if (strcmp(Attribute_aliases[i], token) == 0) {
364  |       result = Attribute_aliases_map[i];
365  |       break;
366  |     }
367  |   }
368  | 
369  |   return result;
370  | } /* DF_attribute_name2type() */
371  | 
372  | /* XXX This could be done MUCH more efficiently (with a hash) */
373  | C_Type_t DF_class_code2type(const gchar *token) {
374  |   C_Type_t result=-1;
375  | 
376  |   int i;
377  |   for (i=0; Class_aliases[i] != NULL; i++) {
378  |     if (strcmp(Class_aliases[i], token) == 0) {
379  |       result = Class_aliases_map[i];
380  |       break;
381  |     }
382  |   }
383  | 
384  |   return result;
385  | } /* DF_class_code2type() */
386  | 
387  | /* XXX This could be done MUCH more efficiently (with a hash) */
388  | C_Type_t DF_class_name2type(const gchar *token) {
389  |   C_Type_t result=-1;
390  | 
391  |   int i;
392  |   for (i=0; Class_aliases[i] != NULL; i++) {
393  |     if (strcmp(Class_aliases[i], token) == 0) {
394  |       result = Class_aliases_map[i];
395  |       break;
396  |     }
397  |   }
398  | 
399  |   return result;
400  | } /* DF_class_name2type() */
401  |