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_attrcode_has_radix_lookup
  34. DF_attrcode_radix_load_v4
  35. DF_attrcode_radix_load_v6
  36. DF_attrcode_radix_family

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

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