Source File modules/df/defs.c

    1    | /***************************************
    2    |   $Revision: 1.2 $
    3    |
    4    |   Definitions module (df)
    5    |
    6    |   Status: NOT REVUED, NOT TESTED
    7    |
    8    |   ******************/ /******************
    9    |   Filename            : defs.c
    10   |   Author              : ottrey@ripe.net
    11   |   OSs Tested          : Solaris
    12   |   Related Modules     :
    13   |   Problems            :
    14   |   To Do               :
    15   |   Comments            :
    16   |   ******************/ /******************
    17   |   Copyright (c) 1999                              RIPE NCC
    18   |
    19   |   All Rights Reserved
    20   |
    21   |   Permission to use, copy, modify, and distribute this software and its
    22   |   documentation for any purpose and without fee is hereby granted,
    23   |   provided that the above copyright notice appear in all copies and that
    24   |   both that copyright notice and this permission notice appear in
    25   |   supporting documentation, and that the name of the author not be
    26   |   used in advertising or publicity pertaining to distribution of the
    27   |   software without specific, written prior permission.
    28   |
    29   |   THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
    30   |   ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS; IN NO EVENT SHALL
    31   |   AUTHOR BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY
    32   |   DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
    33   |   AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
    34   |   OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
    35   |   ***************************************/
    36   | #include <stdio.h>
    37   | #include <stdlib.h>
    38   | #include <stdarg.h>
    39   | #include <strings.h>
    40   | #include <glib.h>
    41   |
    42   | /*+ String sizes +*/
    43   | #define STR_S   63
    44   | #define STR_M   255
    45   | #define STR_L   1023
    46   | #define STR_XL  4095
    47   | #define STR_XXL 16383
    48   |
    49   | #include "defs.h"
    50   |
    51   | #include "DF_class_names.def"
    52   | #include "DF_class_codes.def"
    53   | #include "DF_class_aliases.def"
    54   | #include "DF_class_aliases_map.def"
    55   | #include "DF_class_dbase_code_map.def"
    56   | #include "DF_class_templates.def"
    57   | #include "DF_class_templates_v.def"
    58   |
    59   | #include "DF_attribute_names.def"
    60   | #include "DF_attribute_codes.def"
    61   | #include "DF_attribute_aliases.def"
    62   | #include "DF_attribute_aliases_map.def"
    63   |
    64   | /*+ Source database mirrors +*/
    65   | char * const  Sources[] = {
    66   |   "RIPE3",
    67   |   "RIPE",
    68   |   "ARIN",
    69   |   "APNIC",
    70   |   NULL
    71   | }; /* Sources */
    72   |
    73   | char * const  Server_queries[] = {
    74   |   "help",
    75   |   "sources",
    76   |   "version",
    77   |   "version",
    78   |   NULL
    79   | }; /* Server_queries */
    80   |
    81   | char * const  Server_query[] = {
    82   |   "You need help ...\n",
    83   |   "The sources are ...\n",
    84   |   "The version is ...\n",
    85   |   NULL
    86   | }; /* Server_query */
    87   |
    88   | char * const  Filter_names[] = {
    89   |   "aut-num",
    90   |   "domain",
    91   |   "inet6num",
    92   |   "inetnum",
    93   |   "inet-rtr",
    94   |   "key-cert",
    95   |   "limerick",
    96   |   "mntner",
    97   |   "route",
    98   |   "origin",
    99   |   "as-set",
    100  |   "route-set",
    101  |   "members",
    102  |   NULL
    103  | }; /* Filter_names */
    104  |
    105  | char * const *DF_get_filter_names(void) {
    106  |   return Filter_names;
    107  | } /* DF_get_filter_names() */
    108  |
    109  | char * const *DF_get_class_names(void) {
    110  |   return Class_names;
    111  | } /* DF_get_class_names() */
    112  |
    113  | char * const *DF_get_class_aliases(void) {
    114  |   return Class_aliases;
    115  | } /* DF_get_class_aliases() */
    116  |
    117  | int DF_get_class_index(int alias_index) {
    118  |   return Class_aliases_map[alias_index];
    119  | } /* DF_get_class_index() */
    120  |
    121  | char * const DF_get_class_name(int alias_index) {
    122  |   return Class_names[Class_aliases_map[alias_index]];
    123  | } /* DF_get_class_name() */
    124  |
    125  | char * const DF_get_class_code(C_Type_t index) {
    126  |   return Class_codes[index];
    127  | } /* DF_get_class_code() */
    128  |
    129  | int DF_get_class_dbase_code(int class_index) {
    130  |   return Class_dbase_code_map[class_index];
    131  | } /* DF_get_class_dbase_code() */
    132  |
    133  | char * const *DF_get_sources(void) {
    134  |   return Sources;
    135  | } /* DF_get_sources() */
    136  |
    137  | const char *DF_get_source(int index) {
    138  |   return Sources[index];
    139  | } /* DF_get_source() */
    140  |
    141  | char * const *DF_get_attribute_aliases(void) {
    142  |   return Attribute_aliases;
    143  | } /* DF_get_attribute_aliases() */
    144  |
    145  | const char *DF_get_attribute_name(A_Type_t index) {
    146  |   return Attribute_names[index];
    147  | } /* DF_get_attribute_name() */
    148  |
    149  | const char *DF_get_attribute_code(A_Type_t index) {
    150  |   return Attribute_codes[index];
    151  | } /* DF_get_attribute_code() */
    152  |
    153  | char * const *DF_get_attribute_names(void) {
    154  |   return Attribute_names;
    155  | } /* DF_get_attribute_names() */
    156  |
    157  | int DF_get_attribute_index(int alias_index) {
    158  |   return Attribute_aliases_map[alias_index];
    159  | } /* DF_get_attribute_index() */
    160  |
    161  | const char *DF_get_class_template(C_Type_t index) {
    162  |   return Templates[index];
    163  | } /* DF_get_class_template() */
    164  |
    165  | const char *DF_get_class_template_v(C_Type_t index) {
    166  |   return Templates_v[index];
    167  | } /* DF_get_class_template_v() */
    168  |
    169  | const char *DF_get_server_query(int index) {
    170  |   return Server_query[index];
    171  | } /* DF_get_server_query() */
    172  |
    173  | char * const *DF_get_server_queries(void) {
    174  |   return Server_queries;
    175  | } /* DF_get_server_queries() */
    176  |
    177  | const char *DF_get_attribute_desc(A_Type_t index) {
    178  | /*
    179  |   return (char *)Attributes_details[attr_index][0];
    180  | */
    181  |   return NULL;
    182  | } /* DF_get_attribute_desc() */
    183  |
    184  | const char *DF_get_attribute_frmt(A_Type_t index) {
    185  | /*
    186  |   return (char *)Attributes_details[attr_index][1];
    187  | */
    188  |   return NULL;
    189  | } /* DF_get_attribute_frmt() */
    190  |
    191  | /* source_foreach() */
    192  | /*++++++++++++++++++++++++++++++++++++++
    193  |   Function to adds the source string to the created string from the Glist of sources.
    194  |   It is called via g_list_foreach().
    195  |
    196  |   void *element_data The source name.
    197  |
    198  |   void *result_buf_ptr The string to be populated.
    199  |
    200  |   More:
    201  |   +html+ <PRE>
    202  |   Authors:
    203  |         ottrey
    204  |
    205  |   +html+ </PRE><DL COMPACT>
    206  |   +html+ <DT>Online References:
    207  |   +html+ <DD><UL>
    208  |   +html+ </UL></DL>
    209  |
    210  |   ++++++++++++++++++++++++++++++++++++++*/
    211  | static void source_foreach(void *element_data, void *result_buf_ptr) {
    212  |   char *source = element_data;
    213  |   char *result_buf = (char *)result_buf_ptr;
    214  |
    215  |   strcat(result_buf, element_data);
    216  |   strcat(result_buf, ",");
    217  |
    218  | } /* source_foreach() */
    219  |
    220  | /* DF_sources_to_string() */
    221  | /*++++++++++++++++++++++++++++++++++++++
    222  |   Creates a string from Sources.
    223  |
    224  |   char * DF_sources_to_string Returns a string of the Sources.
    225  |
    226  |   More:
    227  |   +html+ <PRE>
    228  |   Authors:
    229  |         ottrey
    230  |
    231  |   +html+ </PRE><DL COMPACT>
    232  |   +html+ <DT>Online References:
    233  |   +html+ <DD><UL>
    234  |   +html+ </UL></DL>
    235  |
    236  |   ++++++++++++++++++++++++++++++++++++++*/
    237  | char * DF_sources_to_string(void) {
    238  |   char *result=NULL;
    239  |   char result_buf[STR_XL];
    240  |   int result_len;
    241  |   int i;
    242  |
    243  |   strcpy(result_buf, "{");
    244  |   for (i=0; Sources[i] != NULL; i++) {
    245  |     strcat(result_buf, Sources[i]);
    246  |     strcat(result_buf, ",");
    247  |   }
    248  |   result_len = strlen(result_buf);
    249  |   result_buf[result_len-1] = '}';
    250  |   result_buf[result_len] = '\0';
    251  |
    252  |   result = (char *)calloc(1, result_len+1);
    253  |   strcpy(result, result_buf);
    254  |
    255  |   return result;
    256  |
    257  | } /* DF_sources_to_string() */
    258  |
    259  | /* DF_sources_list_to_string() */
    260  | /*++++++++++++++++++++++++++++++++++++++
    261  |   Creates a string from the sources in the GList.
    262  |
    263  |   GList *sources_list  The GList of sources.
    264  |
    265  |   More:
    266  |   +html+ <PRE>
    267  |   Authors:
    268  |         ottrey
    269  |
    270  |   +html+ </PRE><DL COMPACT>
    271  |   +html+ <DT>Online References:
    272  |   +html+ <DD><UL>
    273  |   +html+ </UL></DL>
    274  |
    275  |   ++++++++++++++++++++++++++++++++++++++*/
    276  | char *DF_sources_list_to_string(GList *sources_list) {
    277  |   char *result=NULL;
    278  |   char result_buf[STR_XL];
    279  |   int result_len;
    280  |
    281  |   strcpy(result_buf, "{");
    282  |   g_list_foreach(sources_list, source_foreach, &result_buf);
    283  |   result_len = strlen(result_buf);
    284  |   if (result_len == 1) {
    285  |     /* If an empty set */
    286  |     result_buf[1] = '}';
    287  |     result_buf[2] = '\0';
    288  |   }
    289  |   else {
    290  |     result_buf[result_len-1] = '}';
    291  |     result_buf[result_len] = '\0';
    292  |   }
    293  |
    294  |   result = (char *)calloc(1, result_len+1);
    295  |   strcpy(result, result_buf);
    296  |
    297  |   return result;
    298  |
    299  | } /* DF_sources_list_to_string() */
    300  |
    301  |
    302  | /* DF_attributes_to_string() */
    303  | /*++++++++++++++++++++++++++++++++++++++
    304  |   Returns a string of all the attributes.  Only there for debugging and tracing purposes.
    305  |
    306  |   int offset The offset (Ie short or long name).
    307  |
    308  |   More:
    309  |   +html+ <PRE>
    310  |   Authors:
    311  |         ottrey
    312  |
    313  |   +html+ </PRE><DL COMPACT>
    314  |   +html+ <DT>Online References:
    315  |   +html+ <DD><UL>
    316  |   +html+ </UL></DL>
    317  |
    318  |   ++++++++++++++++++++++++++++++++++++++*/
    319  | char *DF_attributes_to_string(void) {
    320  |   int i;
    321  |   char *str;
    322  |   char str_buffer[4096];
    323  |   int str_len;
    324  |
    325  |   strcpy(str_buffer, "{\"");
    326  |   for (i=0; Attribute_names[i] != NULL; i++) {
    327  |     strcat(str_buffer, Attribute_names[i]);
    328  |     strcat(str_buffer, "\", \"");
    329  |   }
    330  |   str_len = strlen(str_buffer);
    331  |   str_buffer[str_len-3] = '}';
    332  |   str_buffer[str_len-2] = '\0';
    333  |   str_len--;
    334  |
    335  |   str = (char *)calloc(1, str_len);
    336  |   strcpy(str, str_buffer);
    337  |
    338  |   return str;
    339  |
    340  | } /* DF_attributes_to_string() */
    341  |
    342  | /* XXX This could be done MUCH more efficiently (with a hash) */
    343  | A_Type_t DF_attribute_code2type(const gchar *token) {
    344  |   A_Type_t result=-1;
    345  |
    346  |   int i;
    347  |   for (i=0; Attribute_aliases[i] != NULL; i++) {
    348  |     if (strcmp(Attribute_aliases[i], token) == 0) {
    349  |       result = Attribute_aliases_map[i];
    350  |       break;
    351  |     }
    352  |   }
    353  |
    354  |   return result;
    355  | } /* DF_attribute_code2type() */
    356  |
    357  | /* XXX This could be done MUCH more efficiently (with a hash) */
    358  | A_Type_t DF_attribute_name2type(const gchar *token) {
    359  |   A_Type_t result=-1;
    360  |
    361  |   int i;
    362  |   for (i=0; Attribute_aliases[i] != NULL; i++) {
    363  |     if (strcmp(Attribute_aliases[i], token) == 0) {
    364  |       result = Attribute_aliases_map[i];
    365  |       break;
    366  |     }
    367  |   }
    368  |
    369  |   return result;
    370  | } /* DF_attribute_name2type() */
    371  |
    372  | /* XXX This could be done MUCH more efficiently (with a hash) */
    373  | C_Type_t DF_class_code2type(const gchar *token) {
    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_code2type() */
    386  |
    387  | /* XXX This could be done MUCH more efficiently (with a hash) */
    388  | C_Type_t DF_class_name2type(const gchar *token) {
    389  |   C_Type_t result=-1;
    390  |
    391  |   int i;
    392  |   for (i=0; Class_aliases[i] != NULL; i++) {
    393  |     if (strcmp(Class_aliases[i], token) == 0) {
    394  |       result = Class_aliases_map[i];
    395  |       break;
    396  |     }
    397  |   }
    398  |
    399  |   return result;
    400  | } /* DF_class_name2type() */
    401  |