## modules/df/defs.c

/* [<][>][^][v][top][bottom][index][help] */

## FUNCTIONS

This source file includes following functions.

1. DF_get_filter_names
2. DF_get_class_names
3. DF_get_class_aliases
4. DF_get_class_index
5. DF_get_class_name
6. DF_get_class_code
7. DF_get_class_dbase_code
8. DF_get_class_sql_table
9. DF_get_attribute_aliases
10. DF_get_attribute_name
11. DF_get_attribute_code
12. DF_get_attribute_names
13. DF_get_attribute_index
14. DF_get_class_template
15. DF_get_class_template_v
16. DF_get_server_queries
17. DF_get_update_query
18. DF_get_update_query_type
19. DF_get_insert_query
20. DF_get_insert_query_type
21. DF_get_select_query
22. DF_get_select_query_type
23. DF_get_dummy_query
24. DF_get_dummy_query_type
25. DF_get_attribute_desc
26. DF_get_attribute_frmt
27. DF_attributes_to_string
28. DF_attribute_code2type
29. init_name2type_hash
30. DF_attribute_name2type
31. DF_class_code2type
32. DF_class_name2type
33. DF_class_type2name
34. DF_attrcode_has_radix_lookup
35. DF_attrcode_radix_load_v4
36. DF_attrcode_radix_load_v6
37. DF_attrcode_radix_family

       1 /***************************************
       2   $Revision: 1.28 $
       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,2000,2001,2002               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 #define  DEFS_IMPL
      33 #include "rip.h"
      34
      35 #include <stdio.h>
      36 #include <stdlib.h>
      37 #include <stdarg.h>
      38 #include <strings.h>
      39 #include <glib.h>
      40 #include <pthread.h>
      41
      42 #include "DF_class_names.def"
      43 #include "DF_class_codes.def"
      44 #include "DF_class_aliases.def"
      45 #include "DF_class_aliases_map.def"
      46 #include "DF_class_dbase_code_map.def"
      47 #include "DF_class_templates.def"
      48 #include "DF_class_templates_v.def"
      49
      50 #include "DF_attribute_names.def"
      51 #include "DF_attribute_codes.def"
      52 #include "DF_attribute_aliases.def"
      53 #include "DF_attribute_aliases_map.def"
      54
      55 #include "UD_queries.def"
      56
      57
      58
      59 /* getsubopt requires a vector of pointers to a list of possible options
      60    It's used for parsing the source list.
      61    Therefore a quick
      62  XXX  !!!!
      63    hack: hardcode it. Will be initialised from the Sources array
      64    once the config module is defined
      65 */
      66
      67 char * const  Server_queries[] = {
      68   "sources",
      69   "version",
      70   NULL
      71 }; /* Server_queries */
      72
      73 /* Filtered names of classes (only "public" objects, no person or role).
      74
      75    XXX this also should be generated from XML...
      76 */
      77 char * const  Filter_names[] = {
      78   "as-block",
      79   "as-set",
      80   "aut-num",
      81   "domain",
      82   "inet-rtr",
      83   "inet6num",
      84   "inetnum",
      85   "key-cert",
      86   "limerick",
      87   "mntner",
      88   "route",
      89   "origin",
      90   "route-set",
      91   "members",
      92   "filter-set",
      93   "peering-set",
      94   "rtr-set",
      95   "irt",
      96   NULL
      97 }; /* Filter_names */
      98
      99 char * const *DF_get_filter_names(void) {
         /* [<][>][^][v][top][bottom][index][help] */
     100   return Filter_names;
     101 } /* DF_get_filter_names() */
     102
     103 char * const *DF_get_class_names(void) {
         /* [<][>][^][v][top][bottom][index][help] */
     104   return Class_names;
     105 } /* DF_get_class_names() */
     106
     107 char * const *DF_get_class_aliases(void) {
         /* [<][>][^][v][top][bottom][index][help] */
     108   return Class_aliases;
     109 } /* DF_get_class_aliases() */
     110
     111 int DF_get_class_index(int alias_index) {
         /* [<][>][^][v][top][bottom][index][help] */
     112   return Class_aliases_map[alias_index];
     113 } /* DF_get_class_index() */
     114
     115 #if 0
     116 char * const DF_get_class_name(int alias_index) {
         /* [<][>][^][v][top][bottom][index][help] */
     117   return Class_names[Class_aliases_map[alias_index]];
     118 } /* DF_get_class_name() */
     119 #endif
     120
     121 char * const DF_get_class_code(C_Type_t index) {
         /* [<][>][^][v][top][bottom][index][help] */
     122   if( index == C_ANY ) {
     123     return "*";
     124   }
     125   else {
     126     return Class_codes[index];
     127   }
     128 } /* DF_get_class_code() */
     129
     130 int DF_get_class_dbase_code(int class_index) {
         /* [<][>][^][v][top][bottom][index][help] */
     131   return Class_dbase_code_map[class_index];
     132 } /* DF_get_class_dbase_code() */
     133
     134 /* Main tables names for object types */
     135 /*XXX thsi should be modified according to class ordser */
     136 char * const Type2main[] = {
     137 "as_block",
     138 "as_set",
     139 "aut_num",
     140 "domain",
     141 "inet_rtr",
     142 "inet6num",
     143 "inetnum",
     144 "key_cert",
     145 "limerick",
     146 "mntner",
     147 "person_role",
     148 "person_role",
     149 "route",
     150 "route_set",
     151 "filter_set",
     152 "peering_set",
     153 "rtr_set",
     154 "irt",
     155 NULL
     156 };
     157
     158 char * const DF_get_class_sql_table(C_Type_t index) {
         /* [<][>][^][v][top][bottom][index][help] */
     159  return Type2main[index];
     160 } /* DF_get_class_sql_table() */
     161
     162
     163
     164 char * const *DF_get_attribute_aliases(void) {
         /* [<][>][^][v][top][bottom][index][help] */
     165   return Attribute_aliases;
     166 } /* DF_get_attribute_aliases() */
     167
     168 const char *DF_get_attribute_name(A_Type_t index) {
         /* [<][>][^][v][top][bottom][index][help] */
     169   return Attribute_names[index];
     170 } /* DF_get_attribute_name() */
     171
     172 const char *DF_get_attribute_code(A_Type_t index) {
         /* [<][>][^][v][top][bottom][index][help] */
     173   return Attribute_codes[index];
     174 } /* DF_get_attribute_code() */
     175
     176 char * const *DF_get_attribute_names(void) {
         /* [<][>][^][v][top][bottom][index][help] */
     177   return Attribute_names;
     178 } /* DF_get_attribute_names() */
     179
     180 int DF_get_attribute_index(int alias_index) {
         /* [<][>][^][v][top][bottom][index][help] */
     181   return Attribute_aliases_map[alias_index];
     182 } /* DF_get_attribute_index() */
     183
     184 const char *DF_get_class_template(C_Type_t index) {
         /* [<][>][^][v][top][bottom][index][help] */
     185   return Templates[index];
     186 } /* DF_get_class_template() */
     187
     188 const char *DF_get_class_template_v(C_Type_t index) {
         /* [<][>][^][v][top][bottom][index][help] */
     189   return Templates_v[index];
     190 } /* DF_get_class_template_v() */
     191
     192 char * const *DF_get_server_queries(void) {
         /* [<][>][^][v][top][bottom][index][help] */
     193   return Server_queries;
     194 } /* DF_get_server_queries() */
     195
     196 const char *DF_get_update_query(A_Type_t index){
         /* [<][>][^][v][top][bottom][index][help] */
     197   return Update[index].qry;
     198 } /* DF_get_update_query() */
     199
     200 UD_qtype DF_get_update_query_type(A_Type_t index){
         /* [<][>][^][v][top][bottom][index][help] */
     201   return Update[index].qtype;
     202 } /* DF_get_update_query_type() */
     203
     204 const char *DF_get_insert_query(A_Type_t index){
         /* [<][>][^][v][top][bottom][index][help] */
     205   return Insert[index].qry;
     206 } /* DF_get_insert_query() */
     207
     208 UD_qtype DF_get_insert_query_type(A_Type_t index){
         /* [<][>][^][v][top][bottom][index][help] */
     209   return Insert[index].qtype;
     210 } /* DF_get_insert_query_type() */
     211
     212 const char *DF_get_select_query(A_Type_t index){
         /* [<][>][^][v][top][bottom][index][help] */
     213   return Select[index].qry;
     214 } /* DF_get_select_query() */
     215
     216 UD_qtype DF_get_select_query_type(A_Type_t index){
         /* [<][>][^][v][top][bottom][index][help] */
     217   return Select[index].qtype;
     218 } /* DF_get_select_query_type() */
     219
     220 const char *DF_get_dummy_query(A_Type_t index){
         /* [<][>][^][v][top][bottom][index][help] */
     221   return Dummy[index].qry;
     222 } /* DF_get_dummy_query() */
     223
     224 UD_qtype DF_get_dummy_query_type(A_Type_t index){
         /* [<][>][^][v][top][bottom][index][help] */
     225   return Dummy[index].qtype;
     226 } /* DF_get_dummy_query_type() */
     227
     228
     229 #if 0 /* not used anywhere */
     230 const char *DF_get_attribute_desc(A_Type_t index) {
         /* [<][>][^][v][top][bottom][index][help] */
     231 /*
     232   return (char *)Attributes_details[attr_index][0];
     233 */
     234   return NULL;
     235 } /* DF_get_attribute_desc() */
     236
     237 const char *DF_get_attribute_frmt(A_Type_t index) {
         /* [<][>][^][v][top][bottom][index][help] */
     238 /*
     239   return (char *)Attributes_details[attr_index][1];
     240 */
     241   return NULL;
     242 } /* DF_get_attribute_frmt() */
     243
     244 /* DF_attributes_to_string() */
     245 /*++++++++++++++++++++++++++++++++++++++
     246   Returns a string of all the attributes.  Only there for debugging and tracing purposes.
     247
     248   More:
     249   +html+ <PRE>
     250   Authors:
     251         ottrey
     252
     253   +html+ </PRE><DL COMPACT>
     254   +html+ <DT>Online References:
     255   +html+ <DD><UL>
     256   +html+ </UL></DL>
     257
     258   ++++++++++++++++++++++++++++++++++++++*/
     259 char *DF_attributes_to_string(void) {
         /* [<][>][^][v][top][bottom][index][help] */
     260   int i;
     261   char *str;
     262   char str_buffer[4096];
     263   unsigned str_len;
     264
     265   strcpy(str_buffer, "{\"");
     266   for (i=0; Attribute_names[i] != NULL; i++) {
     267     strcat(str_buffer, Attribute_names[i]);
     268     strcat(str_buffer, "\", \"");
     269   }
     270   str_len = strlen(str_buffer);
     271   str_buffer[str_len-3] = '}';
     272   str_buffer[str_len-2] = '\0';
     273   str_len--;
     274
     275   /* str = (char *)calloc(1, str_len); */
     276   /*dieif( wr_malloc((void **)&str, str_len ) != UT_OK);
     277   strcpy(str, str_buffer); */
     278
     279   return UT_strdup(str_buffer);
     280
     281 } /* DF_attributes_to_string() */
     282 #endif /* not used */
     283
     284
     285 /* XXX This could be done MUCH more efficiently (with a hash) */
     286 A_Type_t DF_attribute_code2type(const gchar *token) {
         /* [<][>][^][v][top][bottom][index][help] */
     287   A_Type_t result=-1;
     288
     289   int i;
     290   for (i=0; Attribute_aliases[i] != NULL; i++) {
     291     if (strcmp(Attribute_aliases[i], token) == 0) {
     292       result = Attribute_aliases_map[i];
     293       break;
     294     }
     295   }
     296
     297   return result;
     298 } /* DF_attribute_code2type() */
     299
     300 /*
     301 Description:
     302
     303   Find the type identifier for the given long attribute name.  This can
     304   be used to get the attribute code via the DF_get_attribute_code()
     305   function.
     306
     307 Arguments:
     308
     309   const gchar *token; attribute name, e.g. "person", "aut-num", or "limerick"
     310
     311 Returns:
     312
     313   A_Type_t with the attribute's code, or -1 on error (bad attribute name).
     314
     315 Notes:
     316
     317   Uses a hash table for speedy conversion.  The first time this is called,
     318   the hash table will be built.  Subsequent calls use that table.
     319
     320   It might be better to provide a single function to translate from an
     321   attribute name to the attribute code, but for now, just use
     322   DF_get_attribute_code() with the value returned here.  - SK
     323 */
     324 static GHashTable *name2type_hash = NULL;
     325
     326 static void init_name2type_hash()
         /* [<][>][^][v][top][bottom][index][help] */
     327 {
     328     A_Type_t *val;
     329     int i;
     330
     331     name2type_hash = g_hash_table_new(g_str_hash, g_str_equal);
     332     for (i=0; Attribute_aliases[i] != NULL; i++) {
     333         /*wr_malloc((void *)&val, sizeof(A_Type_t));*/
     334         val = UT_malloc(sizeof(A_Type_t));
     335         *val = Attribute_aliases_map[i];
     336         g_hash_table_insert(name2type_hash, Attribute_aliases[i], val);
     337     }
     338 }
     339
     340 A_Type_t DF_attribute_name2type (const gchar *token)
         /* [<][>][^][v][top][bottom][index][help] */
     341 {
     342     static pthread_once_t once_control = { PTHREAD_ONCE_INIT };
     343     A_Type_t *result;
     344
     345     /* build table on first call */
     346     pthread_once(&once_control, init_name2type_hash);
     347
     348     /* find the type in our has table, returning if found */
     349     result = g_hash_table_lookup(name2type_hash, token);
     350     if (result != NULL) {
     351         return *result;
     352     } else {
     353         return -1;
     354     }
     355 } /* DF_attribute_name2type() */
     356
     357 /* XXX This could be done MUCH more efficiently (with a hash) */
     358 C_Type_t DF_class_code2type(const gchar *token) {
         /* [<][>][^][v][top][bottom][index][help] */
     359   C_Type_t result=-1;
     360
     361   int i;
     362   for (i=0; Class_aliases[i] != NULL; i++) {
     363     if (strcmp(Class_aliases[i], token) == 0) {
     364       result = Class_aliases_map[i];
     365       break;
     366     }
     367   }
     368
     369   return result;
     370 } /* DF_class_code2type() */
     371
     372 /* XXX This could be done MUCH more efficiently (with a hash) */
     373 C_Type_t DF_class_name2type(const gchar *token) {
         /* [<][>][^][v][top][bottom][index][help] */
     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_name2type() */
     386
     387 /* Returns class name for a given type */
     388 const char *DF_class_type2name(C_Type_t class) {
         /* [<][>][^][v][top][bottom][index][help] */
     389         return(Class_names[class]);
     390 }/* DF_class_type2name() */
     391
     392
     393 /* check in the queries if this attribute can trigger a radix lookup */
     394 int DF_attrcode_has_radix_lookup(A_Type_t attr)
         /* [<][>][^][v][top][bottom][index][help] */
     395 {
     396   int i;
     397
     398   for (i=0; Query[i].query != NULL; i++) {
     399     if( Query[i].refer == R_RADIX &&
     400         Query[i].attribute == attr ) {
     401       return 1;
     402     }
     403   }
     404   return 0;
     405 }
     406
     407 /* return the sql query to load the radix ipv4 tree for this attribute
     408    or NULL if no ipv4 radix is used for this attribute */
     409 char * DF_attrcode_radix_load_v4(A_Type_t attr)
         /* [<][>][^][v][top][bottom][index][help] */
     410 {
     411     int i;
     412
     413     for(i=0;
     414         DF_radix_load[i].attr != -1 && DF_radix_load[i].family != -1;
     415         i++) {
     416
     417         if( DF_radix_load[i].attr == attr ) {
     418             return DF_radix_load[i].ipv4_load;
     419         }
     420     }
     421     return NULL;
     422 }
     423
     424 /* return the sql query to load the radix ipv4 tree for this attribute
     425    or NULL if no ipv4 radix is used for this attribute */
     426 char * DF_attrcode_radix_load_v6(A_Type_t attr)
         /* [<][>][^][v][top][bottom][index][help] */
     427 {
     428     int i;
     429
     430     for(i=0;
     431         DF_radix_load[i].attr != -1 && DF_radix_load[i].family != -1;
     432         i++) {
     433
     434         if( DF_radix_load[i].attr == attr ) {
     435             return DF_radix_load[i].ipv6_load;
     436         }
     437     }
     438     return NULL;
     439 }
     440
     441 /* return the family of the radix tree(s) used for this attribute
     442    or -1 if no radix is used for this attribute */
     443 rx_fam_t DF_attrcode_radix_family(A_Type_t attr) {
         /* [<][>][^][v][top][bottom][index][help] */
     444     int i;
     445
     446     for(i=0;
     447         DF_radix_load[i].attr != -1 && DF_radix_load[i].family != -1;
     448         i++) {
     449
     450         if( DF_radix_load[i].attr == attr ) {
     451             return DF_radix_load[i].family;
     452         }
     453     }
     454     return -1;
     455 }

/* [<][>][^][v][top][bottom][index][help] */