1 | /***************************************
2 | $Revision: 1.15 $
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 | "The sources are ...\n",
78 | "The version is ...\n",
79 | NULL
80 | }; /* Server_query */
81 |
82 | char * const Server_queries[] = {
83 | "sources",
84 | "version",
85 | NULL
86 | }; /* Server_queries */
87 |
88 | /* XXX this also should be generated from XML... */
89 | char * const Filter_names[] = {
90 | "aut-num",
91 | "domain",
92 | "inet6num",
93 | "inetnum",
94 | "inet-rtr",
95 | "key-cert",
96 | "limerick",
97 | "mntner",
98 | "route",
99 | "origin",
100 | "as-set",
101 | "route-set",
102 | "members",
103 | "peering-set",
104 | "filter-set",
105 | "rtr-set",
106 | NULL
107 | }; /* Filter_names */
108 |
109 | char * const *DF_get_filter_names(void) {
110 | return Filter_names;
111 | } /* DF_get_filter_names() */
112 |
113 | char * const *DF_get_class_names(void) {
114 | return Class_names;
115 | } /* DF_get_class_names() */
116 |
117 | char * const *DF_get_class_aliases(void) {
118 | return Class_aliases;
119 | } /* DF_get_class_aliases() */
120 |
121 | int DF_get_class_index(int alias_index) {
122 | return Class_aliases_map[alias_index];
123 | } /* DF_get_class_index() */
124 |
125 | char * const DF_get_class_name(int alias_index) {
126 | return Class_names[Class_aliases_map[alias_index]];
127 | } /* DF_get_class_name() */
128 |
129 | char * const DF_get_class_code(C_Type_t index) {
130 | if( index == -1 ) {
131 | return "*";
132 | }
133 | else {
134 | return Class_codes[index];
135 | }
136 | } /* DF_get_class_code() */
137 |
138 | int DF_get_class_dbase_code(int class_index) {
139 | return Class_dbase_code_map[class_index];
140 | } /* DF_get_class_dbase_code() */
141 |
142 | /* Main tables names for object types */
143 | char * const Type2main[] = {
144 | "as_block",
145 | "as_set",
146 | "aut_num",
147 | "domain",
148 | "inet_rtr",
149 | "inet6num",
150 | "inetnum",
151 | "key_cert",
152 | "limerick",
153 | "mntner",
154 | "person_role", /*pn*/
155 | "person_role", /*ro*/
156 | "route",
157 | "route_set",
158 | "filter_set",
159 | "peering_set",
160 | "rtr_set",
161 | NULL
162 | };
163 |
164 | char * const DF_get_class_sql_table(C_Type_t index) {
165 | return Type2main[index];
166 | } /* DF_get_class_sql_table() */
167 |
168 |
169 |
170 | char * const *DF_get_attribute_aliases(void) {
171 | return Attribute_aliases;
172 | } /* DF_get_attribute_aliases() */
173 |
174 | const char *DF_get_attribute_name(A_Type_t index) {
175 | return Attribute_names[index];
176 | } /* DF_get_attribute_name() */
177 |
178 | const char *DF_get_attribute_code(A_Type_t index) {
179 | return Attribute_codes[index];
180 | } /* DF_get_attribute_code() */
181 |
182 | char * const *DF_get_attribute_names(void) {
183 | return Attribute_names;
184 | } /* DF_get_attribute_names() */
185 |
186 | int DF_get_attribute_index(int alias_index) {
187 | return Attribute_aliases_map[alias_index];
188 | } /* DF_get_attribute_index() */
189 |
190 | const char *DF_get_class_template(C_Type_t index) {
191 | return Templates[index];
192 | } /* DF_get_class_template() */
193 |
194 | const char *DF_get_class_template_v(C_Type_t index) {
195 | return Templates_v[index];
196 | } /* DF_get_class_template_v() */
197 |
198 | const char *DF_get_server_query(int index) {
199 | return Server_query[index];
200 | } /* DF_get_server_query() */
201 |
202 | char * const *DF_get_server_queries(void) {
203 | return Server_queries;
204 | } /* DF_get_server_queries() */
205 |
206 | const char *DF_get_update_query(A_Type_t index){
207 | return Update[index].qry;
208 | } /* DF_get_update_query() */
209 |
210 | UD_qtype DF_get_update_query_type(A_Type_t index){
211 | return Update[index].qtype;
212 | } /* DF_get_update_query_type() */
213 |
214 | const char *DF_get_insert_query(A_Type_t index){
215 | return Insert[index].qry;
216 | } /* DF_get_insert_query() */
217 |
218 | UD_qtype DF_get_insert_query_type(A_Type_t index){
219 | return Insert[index].qtype;
220 | } /* DF_get_insert_query_type() */
221 |
222 | const char *DF_get_select_query(A_Type_t index){
223 | return Select[index].qry;
224 | } /* DF_get_select_query() */
225 |
226 | UD_qtype DF_get_select_query_type(A_Type_t index){
227 | return Select[index].qtype;
228 | } /* DF_get_select_query_type() */
229 |
230 | const char *DF_get_dummy_query(A_Type_t index){
231 | return Dummy[index].qry;
232 | } /* DF_get_dummy_query() */
233 |
234 | UD_qtype DF_get_dummy_query_type(A_Type_t index){
235 | return Dummy[index].qtype;
236 | } /* DF_get_dummy_query_type() */
237 |
238 |
239 |
240 | const char *DF_get_attribute_desc(A_Type_t index) {
241 | /*
242 | return (char *)Attributes_details[attr_index][0];
243 | */
244 | return NULL;
245 | } /* DF_get_attribute_desc() */
246 |
247 | const char *DF_get_attribute_frmt(A_Type_t index) {
248 | /*
249 | return (char *)Attributes_details[attr_index][1];
250 | */
251 | return NULL;
252 | } /* DF_get_attribute_frmt() */
253 |
254 | /* DF_attributes_to_string() */
255 | /*++++++++++++++++++++++++++++++++++++++
256 | Returns a string of all the attributes. Only there for debugging and tracing purposes.
257 |
258 | int offset The offset (Ie short or long name).
259 |
260 | More:
261 | +html+ <PRE>
262 | Authors:
263 | ottrey
264 |
265 | +html+ </PRE><DL COMPACT>
266 | +html+ <DT>Online References:
267 | +html+ <DD><UL>
268 | +html+ </UL></DL>
269 |
270 | ++++++++++++++++++++++++++++++++++++++*/
271 | char *DF_attributes_to_string(void) {
272 | int i;
273 | char *str;
274 | char str_buffer[4096];
275 | int str_len;
276 |
277 | strcpy(str_buffer, "{\"");
278 | for (i=0; Attribute_names[i] != NULL; i++) {
279 | strcat(str_buffer, Attribute_names[i]);
280 | strcat(str_buffer, "\", \"");
281 | }
282 | str_len = strlen(str_buffer);
283 | str_buffer[str_len-3] = '}';
284 | str_buffer[str_len-2] = '\0';
285 | str_len--;
286 |
287 | /* str = (char *)calloc(1, str_len); */
288 | dieif( wr_malloc((void **)&str, str_len ) != UT_OK);
289 | strcpy(str, str_buffer);
290 |
291 | return str;
292 |
293 | } /* DF_attributes_to_string() */
294 |
295 | /* XXX This could be done MUCH more efficiently (with a hash) */
296 | A_Type_t DF_attribute_code2type(const gchar *token) {
297 | A_Type_t result=-1;
298 |
299 | int i;
300 | for (i=0; Attribute_aliases[i] != NULL; i++) {
301 | if (strcmp(Attribute_aliases[i], token) == 0) {
302 | result = Attribute_aliases_map[i];
303 | break;
304 | }
305 | }
306 |
307 | return result;
308 | } /* DF_attribute_code2type() */
309 |
310 | /* XXX This could be done MUCH more efficiently (with a hash) */
311 | A_Type_t DF_attribute_name2type(const gchar *token) {
312 | A_Type_t result=-1;
313 |
314 | int i;
315 | for (i=0; Attribute_aliases[i] != NULL; i++) {
316 | if (strcmp(Attribute_aliases[i], token) == 0) {
317 | result = Attribute_aliases_map[i];
318 | break;
319 | }
320 | }
321 |
322 | return result;
323 | } /* DF_attribute_name2type() */
324 |
325 | /* XXX This could be done MUCH more efficiently (with a hash) */
326 | C_Type_t DF_class_code2type(const gchar *token) {
327 | C_Type_t result=-1;
328 |
329 | int i;
330 | for (i=0; Class_aliases[i] != NULL; i++) {
331 | if (strcmp(Class_aliases[i], token) == 0) {
332 | result = Class_aliases_map[i];
333 | break;
334 | }
335 | }
336 |
337 | return result;
338 | } /* DF_class_code2type() */
339 |
340 | /* XXX This could be done MUCH more efficiently (with a hash) */
341 | C_Type_t DF_class_name2type(const gchar *token) {
342 | C_Type_t result=-1;
343 |
344 | int i;
345 | for (i=0; Class_aliases[i] != NULL; i++) {
346 | if (strcmp(Class_aliases[i], token) == 0) {
347 | result = Class_aliases_map[i];
348 | break;
349 | }
350 | }
351 |
352 | return result;
353 | } /* DF_class_name2type() */
354 |
355 |
356 | /* check in the queries if this attribute can trigger a radix lookup */
357 | int DF_attrcode_has_radix_lookup(A_Type_t attr)
358 | {
359 | int i;
360 |
361 | for (i=0; Query[i].query != NULL; i++) {
362 | if( Query[i].refer == R_RADIX &&
363 | Query[i].attribute == attr ) {
364 | return 1;
365 | }
366 | }
367 | return 0;
368 | }