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