Source File modules/df/defs.c

    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  | }