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. DF_attribute_name2type
  30. DF_class_code2type
  31. DF_class_name2type
  32. DF_attrcode_has_radix_lookup

   1 /***************************************
   2   $Revision: 1.16 $
   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 char * const  Server_queries[] = {
  75   "sources",
  76   "version",
  77   NULL
  78 }; /* Server_queries */
  79 
  80 /* XXX this also should be generated from XML... */
  81 char * const  Filter_names[] = {
  82   "aut-num",
  83   "domain",
  84   "inet6num",
  85   "inetnum",
  86   "inet-rtr",
  87   "key-cert",
  88   "limerick",
  89   "mntner",
  90   "route",
  91   "origin",
  92   "as-set",
  93   "route-set",   
  94   "members",
  95   "peering-set",
  96   "filter-set",
  97   "rtr-set",
  98   NULL
  99 }; /* Filter_names */
 100 
 101 char * const *DF_get_filter_names(void) {
     /* [<][>][^][v][top][bottom][index][help] */
 102   return Filter_names;
 103 } /* DF_get_filter_names() */
 104 
 105 char * const *DF_get_class_names(void) {
     /* [<][>][^][v][top][bottom][index][help] */
 106   return Class_names;
 107 } /* DF_get_class_names() */
 108 
 109 char * const *DF_get_class_aliases(void) {
     /* [<][>][^][v][top][bottom][index][help] */
 110   return Class_aliases;
 111 } /* DF_get_class_aliases() */
 112 
 113 int DF_get_class_index(int alias_index) {
     /* [<][>][^][v][top][bottom][index][help] */
 114   return Class_aliases_map[alias_index];
 115 } /* DF_get_class_index() */
 116 
 117 char * const DF_get_class_name(int alias_index) {
     /* [<][>][^][v][top][bottom][index][help] */
 118   return Class_names[Class_aliases_map[alias_index]];
 119 } /* DF_get_class_name() */
 120 
 121 char * const DF_get_class_code(C_Type_t index) {
     /* [<][>][^][v][top][bottom][index][help] */
 122   if( index == -1 ) {
 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 char * const Type2main[] = {
 136 "as_block",
 137 "as_set",
 138 "aut_num",
 139 "domain",
 140 "inet_rtr",
 141 "inet6num",
 142 "inetnum",
 143 "key_cert",
 144 "limerick",
 145 "mntner",
 146 "person_role", /*pn*/
 147 "person_role", /*ro*/
 148 "route",
 149 "route_set",
 150 "filter_set",
 151 "peering_set",
 152 "rtr_set",
 153 NULL
 154 };
 155 
 156 char * const DF_get_class_sql_table(C_Type_t index) {
     /* [<][>][^][v][top][bottom][index][help] */
 157  return Type2main[index];
 158 } /* DF_get_class_sql_table() */ 
 159 
 160 
 161 
 162 char * const *DF_get_attribute_aliases(void) {
     /* [<][>][^][v][top][bottom][index][help] */
 163   return Attribute_aliases;
 164 } /* DF_get_attribute_aliases() */
 165 
 166 const char *DF_get_attribute_name(A_Type_t index) {
     /* [<][>][^][v][top][bottom][index][help] */
 167   return Attribute_names[index];
 168 } /* DF_get_attribute_name() */
 169 
 170 const char *DF_get_attribute_code(A_Type_t index) {
     /* [<][>][^][v][top][bottom][index][help] */
 171   return Attribute_codes[index];
 172 } /* DF_get_attribute_code() */
 173 
 174 char * const *DF_get_attribute_names(void) {
     /* [<][>][^][v][top][bottom][index][help] */
 175   return Attribute_names;
 176 } /* DF_get_attribute_names() */
 177 
 178 int DF_get_attribute_index(int alias_index) {
     /* [<][>][^][v][top][bottom][index][help] */
 179   return Attribute_aliases_map[alias_index];
 180 } /* DF_get_attribute_index() */
 181 
 182 const char *DF_get_class_template(C_Type_t index) {
     /* [<][>][^][v][top][bottom][index][help] */
 183   return Templates[index];
 184 } /* DF_get_class_template() */
 185 
 186 const char *DF_get_class_template_v(C_Type_t index) {
     /* [<][>][^][v][top][bottom][index][help] */
 187   return Templates_v[index];
 188 } /* DF_get_class_template_v() */
 189 
 190 char * const *DF_get_server_queries(void) {
     /* [<][>][^][v][top][bottom][index][help] */
 191   return Server_queries;
 192 } /* DF_get_server_queries() */
 193 
 194 const char *DF_get_update_query(A_Type_t index){
     /* [<][>][^][v][top][bottom][index][help] */
 195   return Update[index].qry;
 196 } /* DF_get_update_query() */
 197 
 198 UD_qtype DF_get_update_query_type(A_Type_t index){
     /* [<][>][^][v][top][bottom][index][help] */
 199   return Update[index].qtype;
 200 } /* DF_get_update_query_type() */
 201 
 202 const char *DF_get_insert_query(A_Type_t index){
     /* [<][>][^][v][top][bottom][index][help] */
 203   return Insert[index].qry;
 204 } /* DF_get_insert_query() */
 205   
 206 UD_qtype DF_get_insert_query_type(A_Type_t index){
     /* [<][>][^][v][top][bottom][index][help] */
 207   return Insert[index].qtype;
 208 } /* DF_get_insert_query_type() */
 209     
 210 const char *DF_get_select_query(A_Type_t index){
     /* [<][>][^][v][top][bottom][index][help] */
 211   return Select[index].qry;
 212 } /* DF_get_select_query() */
 213   
 214 UD_qtype DF_get_select_query_type(A_Type_t index){
     /* [<][>][^][v][top][bottom][index][help] */
 215   return Select[index].qtype;
 216 } /* DF_get_select_query_type() */
 217         
 218 const char *DF_get_dummy_query(A_Type_t index){
     /* [<][>][^][v][top][bottom][index][help] */
 219   return Dummy[index].qry;
 220 } /* DF_get_dummy_query() */
 221   
 222 UD_qtype DF_get_dummy_query_type(A_Type_t index){
     /* [<][>][^][v][top][bottom][index][help] */
 223   return Dummy[index].qtype;
 224 } /* DF_get_dummy_query_type() */
 225 
 226 
 227 
 228 const char *DF_get_attribute_desc(A_Type_t index) {
     /* [<][>][^][v][top][bottom][index][help] */
 229 /*
 230   return (char *)Attributes_details[attr_index][0];
 231 */
 232   return NULL;
 233 } /* DF_get_attribute_desc() */
 234 
 235 const char *DF_get_attribute_frmt(A_Type_t index) {
     /* [<][>][^][v][top][bottom][index][help] */
 236 /*
 237   return (char *)Attributes_details[attr_index][1];
 238 */
 239   return NULL;
 240 } /* DF_get_attribute_frmt() */
 241 
 242 /* DF_attributes_to_string() */
 243 /*++++++++++++++++++++++++++++++++++++++
 244   Returns a string of all the attributes.  Only there for debugging and tracing purposes.
 245 
 246   int offset The offset (Ie short or long name).
 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   int 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 str;
 280 
 281 } /* DF_attributes_to_string() */
 282 
 283 /* XXX This could be done MUCH more efficiently (with a hash) */
 284 A_Type_t DF_attribute_code2type(const gchar *token) {
     /* [<][>][^][v][top][bottom][index][help] */
 285   A_Type_t result=-1;
 286 
 287   int i;
 288   for (i=0; Attribute_aliases[i] != NULL; i++) {
 289     if (strcmp(Attribute_aliases[i], token) == 0) {
 290       result = Attribute_aliases_map[i];
 291       break;
 292     }
 293   }
 294 
 295   return result;
 296 } /* DF_attribute_code2type() */
 297 
 298 /* XXX This could be done MUCH more efficiently (with a hash) */
 299 A_Type_t DF_attribute_name2type(const gchar *token) {
     /* [<][>][^][v][top][bottom][index][help] */
 300   A_Type_t result=-1;
 301 
 302   int i;
 303   for (i=0; Attribute_aliases[i] != NULL; i++) {
 304     if (strcmp(Attribute_aliases[i], token) == 0) {
 305       result = Attribute_aliases_map[i];
 306       break;
 307     }
 308   }
 309 
 310   return result;
 311 } /* DF_attribute_name2type() */
 312 
 313 /* XXX This could be done MUCH more efficiently (with a hash) */
 314 C_Type_t DF_class_code2type(const gchar *token) {
     /* [<][>][^][v][top][bottom][index][help] */
 315   C_Type_t result=-1;
 316 
 317   int i;
 318   for (i=0; Class_aliases[i] != NULL; i++) {
 319     if (strcmp(Class_aliases[i], token) == 0) {
 320       result = Class_aliases_map[i];
 321       break;
 322     }
 323   }
 324 
 325   return result;
 326 } /* DF_class_code2type() */
 327 
 328 /* XXX This could be done MUCH more efficiently (with a hash) */
 329 C_Type_t DF_class_name2type(const gchar *token) {
     /* [<][>][^][v][top][bottom][index][help] */
 330   C_Type_t result=-1;
 331 
 332   int i;
 333   for (i=0; Class_aliases[i] != NULL; i++) {
 334     if (strcmp(Class_aliases[i], token) == 0) {
 335       result = Class_aliases_map[i];
 336       break;
 337     }
 338   }
 339 
 340   return result;
 341 } /* DF_class_name2type() */
 342 
 343 
 344 /* check in the queries if this attribute can trigger a radix lookup */
 345 int DF_attrcode_has_radix_lookup(A_Type_t attr) 
     /* [<][>][^][v][top][bottom][index][help] */
 346 {
 347   int i;
 348   
 349   for (i=0; Query[i].query != NULL; i++) {
 350     if( Query[i].refer == R_RADIX &&
 351         Query[i].attribute == attr ) {
 352       return 1;
 353     }
 354   }
 355   return 0;
 356 }

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