1    | /***************************************
2    |   $Revision: 1.6 $
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   | #include "memwrap.h"
51   | 
52   | #include "DF_class_names.def"
53   | #include "DF_class_codes.def"
54   | #include "DF_class_aliases.def"
55   | #include "DF_class_aliases_map.def"
56   | #include "DF_class_dbase_code_map.def"
57   | #include "DF_class_templates.def"
58   | #include "DF_class_templates_v.def"
59   | 
60   | #include "DF_attribute_names.def"
61   | #include "DF_attribute_codes.def"
62   | #include "DF_attribute_aliases.def"
63   | #include "DF_attribute_aliases_map.def"
64   | 
65   | /*+ Source database mirrors +*/
66   | typedef struct {
67   |   char src[32];
68   |   char db[32];
69   | } source_info_t;
70   | 
71   | source_info_t const Sources[] = {
72   |   {"RIPE","RIPE6"},
73   |   
74   |   /*  "ARIN",
75   |       "APNIC",
76   |   */
77   |   
78   |   {"",""}
79   | }; /* Sources */
80   | 
81   | /* getsubopt requires a vector of pointers to a list of possible options
82   |    It's used for parsing the source list.
83   |    Therefore a quick 
84   |  XXX  !!!!
85   |    hack: hardcode it. Will be initialised from the Sources array 
86   |    once the config module is defined
87   | */
88   | 
89   | char * const Sources_vector[] = {
90   |   "RIPE",
91   |   NULL
92   | };
93   | 
94   | char * const  Server_queries[] = {
95   |   "help",
96   |   "sources",
97   |   "version",
98   |   "version",
99   |   NULL
100  | }; /* Server_queries */
101  | 
102  | char * const  Server_query[] = {
103  |   "You need help ...\n",
104  |   "The sources are ...\n",
105  |   "The version is ...\n",
106  |   NULL
107  | }; /* Server_query */
108  | 
109  | char * const  Filter_names[] = {
110  |   "aut-num",
111  |   "domain",
112  |   "inet6num",
113  |   "inetnum",
114  |   "inet-rtr",
115  |   "key-cert",
116  |   "limerick",
117  |   "mntner",
118  |   "route",
119  |   "origin",
120  |   "as-set",
121  |   "route-set",   
122  |   "members",
123  |   NULL
124  | }; /* Filter_names */
125  | 
126  | char * const *DF_get_filter_names(void) {
127  |   return Filter_names;
128  | } /* DF_get_filter_names() */
129  | 
130  | char * const *DF_get_class_names(void) {
131  |   return Class_names;
132  | } /* DF_get_class_names() */
133  | 
134  | char * const *DF_get_class_aliases(void) {
135  |   return Class_aliases;
136  | } /* DF_get_class_aliases() */
137  | 
138  | int DF_get_class_index(int alias_index) {
139  |   return Class_aliases_map[alias_index];
140  | } /* DF_get_class_index() */
141  | 
142  | char * const DF_get_class_name(int alias_index) {
143  |   return Class_names[Class_aliases_map[alias_index]];
144  | } /* DF_get_class_name() */
145  | 
146  | char * const DF_get_class_code(C_Type_t index) {
147  |   if( index == -1 ) {
148  |     return "*";
149  |   }
150  |   else {
151  |     return Class_codes[index];
152  |   }
153  | } /* DF_get_class_code() */
154  | 
155  | int DF_get_class_dbase_code(int class_index) {
156  |   return Class_dbase_code_map[class_index];
157  | } /* DF_get_class_dbase_code() */
158  | 
159  | char * const *DF_get_sources(void) {
160  |   return Sources_vector;
161  | } /* DF_get_sources() */
162  | 
163  | const char *DF_get_source(int index) {
164  | const char *s = Sources[index].src;
165  | 
166  |  return (*s == 0) 
167  |    ? NULL 
168  |    : s; 
169  |  
170  | } /* DF_get_source() */
171  | 
172  | const char *DF_get_database(int index) {
173  | const char *s = Sources[index].db;
174  | 
175  |  return (*s == 0) 
176  |    ? NULL 
177  |    : s; 
178  |  
179  | } /* DF_get_database() */
180  | 
181  | 
182  | char * const *DF_get_attribute_aliases(void) {
183  |   return Attribute_aliases;
184  | } /* DF_get_attribute_aliases() */
185  | 
186  | const char *DF_get_attribute_name(A_Type_t index) {
187  |   return Attribute_names[index];
188  | } /* DF_get_attribute_name() */
189  | 
190  | const char *DF_get_attribute_code(A_Type_t index) {
191  |   return Attribute_codes[index];
192  | } /* DF_get_attribute_code() */
193  | 
194  | char * const *DF_get_attribute_names(void) {
195  |   return Attribute_names;
196  | } /* DF_get_attribute_names() */
197  | 
198  | int DF_get_attribute_index(int alias_index) {
199  |   return Attribute_aliases_map[alias_index];
200  | } /* DF_get_attribute_index() */
201  | 
202  | const char *DF_get_class_template(C_Type_t index) {
203  |   return Templates[index];
204  | } /* DF_get_class_template() */
205  | 
206  | const char *DF_get_class_template_v(C_Type_t index) {
207  |   return Templates_v[index];
208  | } /* DF_get_class_template_v() */
209  | 
210  | const char *DF_get_server_query(int index) {
211  |   return Server_query[index];
212  | } /* DF_get_server_query() */
213  | 
214  | char * const *DF_get_server_queries(void) {
215  |   return Server_queries;
216  | } /* DF_get_server_queries() */
217  | 
218  | const char *DF_get_attribute_desc(A_Type_t index) {
219  | /*
220  |   return (char *)Attributes_details[attr_index][0];
221  | */
222  |   return NULL;
223  | } /* DF_get_attribute_desc() */
224  | 
225  | const char *DF_get_attribute_frmt(A_Type_t index) {
226  | /*
227  |   return (char *)Attributes_details[attr_index][1];
228  | */
229  |   return NULL;
230  | } /* DF_get_attribute_frmt() */
231  | 
232  | /* source_foreach() */
233  | /*++++++++++++++++++++++++++++++++++++++
234  |   Function to adds the source string to the created string from the Glist of sources.
235  |   It is called via g_list_foreach().
236  | 
237  |   void *element_data The source name.
238  | 
239  |   void *result_buf_ptr The string to be populated.
240  | 
241  |   More:
242  |   +html+ <PRE>
243  |   Authors:
244  |         ottrey
245  | 
246  |   +html+ </PRE><DL COMPACT>
247  |   +html+ <DT>Online References:
248  |   +html+ <DD><UL>
249  |   +html+ </UL></DL>
250  | 
251  |   ++++++++++++++++++++++++++++++++++++++*/
252  | static void source_foreach(void *element_data, void *result_buf_ptr) {
253  |   char *source = element_data;
254  |   char *result_buf = (char *)result_buf_ptr;
255  | 
256  |   strcat(result_buf, source);
257  |   strcat(result_buf, ",");
258  | 
259  | } /* source_foreach() */
260  | 
261  | /* DF_sources_to_string() */
262  | /*++++++++++++++++++++++++++++++++++++++
263  |   Creates a string from Sources.
264  | 
265  |   char * DF_sources_to_string Returns a string of the Sources.
266  | 
267  |   More:
268  |   +html+ <PRE>
269  |   Authors:
270  |         ottrey
271  | 
272  |   +html+ </PRE><DL COMPACT>
273  |   +html+ <DT>Online References:
274  |   +html+ <DD><UL>
275  |   +html+ </UL></DL>
276  | 
277  |   ++++++++++++++++++++++++++++++++++++++*/
278  | char * DF_sources_to_string(void) {
279  |   char *result=NULL;
280  |   char result_buf[STR_XL];
281  |   int result_len;
282  |   int i;
283  | 
284  |   strcpy(result_buf, "{");
285  |   for (i=0; Sources[i].src[0] != 0 ; i++) {
286  |     strcat(result_buf, Sources[i].src);
287  |     strcat(result_buf, ",");
288  |   }
289  |   result_len = strlen(result_buf);
290  |   result_buf[result_len-1] = '}';
291  |   result_buf[result_len] = '\0';
292  |   
293  |   //  result = (char *)calloc(1, result_len+1);
294  |   dieif( wr_malloc((void **)&result, result_len+1) != UT_OK);  
295  |   strcpy(result, result_buf);
296  | 
297  |   return result;
298  | 
299  | } /* DF_sources_to_string() */
300  | 
301  | /* DF_sources_list_to_string() */
302  | /*++++++++++++++++++++++++++++++++++++++
303  |   Creates a string from the sources in the GList.
304  | 
305  |   GList *sources_list  The GList of sources.
306  | 
307  |   More:
308  |   +html+ <PRE>
309  |   Authors:
310  |         ottrey
311  | 
312  |   +html+ </PRE><DL COMPACT>
313  |   +html+ <DT>Online References:
314  |   +html+ <DD><UL>
315  |   +html+ </UL></DL>
316  | 
317  |   ++++++++++++++++++++++++++++++++++++++*/
318  | char *DF_sources_list_to_string(GList *sources_list) {
319  |   char *result=NULL;
320  |   char result_buf[STR_XL];
321  |   int result_len;
322  | 
323  |   strcpy(result_buf, "{");
324  |   g_list_foreach(sources_list, source_foreach, &result_buf);
325  |   result_len = strlen(result_buf);
326  |   if (result_len == 1) {
327  |     /* If an empty set */
328  |     result_buf[1] = '}';
329  |     result_buf[2] = '\0';
330  |   }
331  |   else {
332  |     result_buf[result_len-1] = '}';
333  |     result_buf[result_len] = '\0';
334  |   }
335  | 
336  |   //result = (char *)calloc(1, result_len+1);
337  |   dieif( wr_malloc((void **)&result, result_len+1) != UT_OK);  
338  |   strcpy(result, result_buf);
339  | 
340  |   return result;
341  | 
342  | } /* DF_sources_list_to_string() */
343  | 
344  | 
345  | /* DF_attributes_to_string() */
346  | /*++++++++++++++++++++++++++++++++++++++
347  |   Returns a string of all the attributes.  Only there for debugging and tracing purposes.
348  | 
349  |   int offset The offset (Ie short or long name).
350  | 
351  |   More:
352  |   +html+ <PRE>
353  |   Authors:
354  |         ottrey
355  | 
356  |   +html+ </PRE><DL COMPACT>
357  |   +html+ <DT>Online References:
358  |   +html+ <DD><UL>
359  |   +html+ </UL></DL>
360  | 
361  |   ++++++++++++++++++++++++++++++++++++++*/
362  | char *DF_attributes_to_string(void) {
363  |   int i;
364  |   char *str;
365  |   char str_buffer[4096];
366  |   int str_len;
367  | 
368  |   strcpy(str_buffer, "{\"");
369  |   for (i=0; Attribute_names[i] != NULL; i++) {
370  |     strcat(str_buffer, Attribute_names[i]);
371  |     strcat(str_buffer, "\", \"");
372  |   }
373  |   str_len = strlen(str_buffer);
374  |   str_buffer[str_len-3] = '}';
375  |   str_buffer[str_len-2] = '\0';
376  |   str_len--;
377  | 
378  |   //  str = (char *)calloc(1, str_len);
379  |   dieif( wr_malloc((void **)&str, str_len ) != UT_OK);  
380  |   strcpy(str, str_buffer);
381  | 
382  |   return str;
383  | 
384  | } /* DF_attributes_to_string() */
385  | 
386  | /* XXX This could be done MUCH more efficiently (with a hash) */
387  | A_Type_t DF_attribute_code2type(const gchar *token) {
388  |   A_Type_t result=-1;
389  | 
390  |   int i;
391  |   for (i=0; Attribute_aliases[i] != NULL; i++) {
392  |     if (strcmp(Attribute_aliases[i], token) == 0) {
393  |       result = Attribute_aliases_map[i];
394  |       break;
395  |     }
396  |   }
397  | 
398  |   return result;
399  | } /* DF_attribute_code2type() */
400  | 
401  | /* XXX This could be done MUCH more efficiently (with a hash) */
402  | A_Type_t DF_attribute_name2type(const gchar *token) {
403  |   A_Type_t result=-1;
404  | 
405  |   int i;
406  |   for (i=0; Attribute_aliases[i] != NULL; i++) {
407  |     if (strcmp(Attribute_aliases[i], token) == 0) {
408  |       result = Attribute_aliases_map[i];
409  |       break;
410  |     }
411  |   }
412  | 
413  |   return result;
414  | } /* DF_attribute_name2type() */
415  | 
416  | /* XXX This could be done MUCH more efficiently (with a hash) */
417  | C_Type_t DF_class_code2type(const gchar *token) {
418  |   C_Type_t result=-1;
419  | 
420  |   int i;
421  |   for (i=0; Class_aliases[i] != NULL; i++) {
422  |     if (strcmp(Class_aliases[i], token) == 0) {
423  |       result = Class_aliases_map[i];
424  |       break;
425  |     }
426  |   }
427  | 
428  |   return result;
429  | } /* DF_class_code2type() */
430  | 
431  | /* XXX This could be done MUCH more efficiently (with a hash) */
432  | C_Type_t DF_class_name2type(const gchar *token) {
433  |   C_Type_t result=-1;
434  | 
435  |   int i;
436  |   for (i=0; Class_aliases[i] != NULL; i++) {
437  |     if (strcmp(Class_aliases[i], token) == 0) {
438  |       result = Class_aliases_map[i];
439  |       break;
440  |     }
441  |   }
442  | 
443  |   return result;
444  | } /* DF_class_name2type() */
445  |