Source File modules/co/constants.c

    1    | /***************************************
    2    |   $Revision: 1.18 $
    3    |
    4    |   Constants module (co) - this _should_ eventually get merged in with the
    5    |   config module.
    6    |
    7    |   Status: NOT REVUED, NOT TESTED
    8    |
    9    |   +html+ <DL COMPACT>
    10   |   +html+ <DT>Online References:
    11   |   +html+ <DD><UL>
    12   |   +html+ </UL>
    13   |   +html+ </DL>
    14   |   +html+ <PRE>
    15   |   Instructions for use:
    16   |
    17   |     To add a constant:
    18   |       0. Add a default value for the constant. (string)
    19   |       1. Add the constant declaration to the _Constants struct.
    20   |       2. Add a CO_get_function()
    21   |       3. Add initializing code to init_constants()
    22   |
    23   |     To access the constant:
    24   |       use the CO_get<Constant>() function from your other code.
    25   |   +html+ </PRE>
    26   |
    27   |   ******************/ /******************
    28   |   Filename            : constants.c
    29   |   Author              : ottrey@ripe.net
    30   |   OSs Tested          : Solaris
    31   |   Related Modules     : Used in conjunction with the properties module.
    32   |   Problems            :
    33   |   To Do               : Merge into a "config module"
    34   |   Comments            :
    35   |   ******************/ /******************
    36   |   Copyright (c) 1999                              RIPE NCC
    37   |
    38   |   All Rights Reserved
    39   |
    40   |   Permission to use, copy, modify, and distribute this software and its
    41   |   documentation for any purpose and without fee is hereby granted,
    42   |   provided that the above copyright notice appear in all copies and that
    43   |   both that copyright notice and this permission notice appear in
    44   |   supporting documentation, and that the name of the author not be
    45   |   used in advertising or publicity pertaining to distribution of the
    46   |   software without specific, written prior permission.
    47   |
    48   |   THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
    49   |   ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS; IN NO EVENT SHALL
    50   |   AUTHOR BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY
    51   |   DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
    52   |   AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
    53   |   OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
    54   |   ***************************************/
    55   | #include <stdio.h>
    56   | #include <stdlib.h>
    57   | #include <string.h>
    58   |
    59   | #include "memwrap.h"
    60   | #include "properties.h"
    61   |
    62   | #define STR_XL  4095
    63   |
    64   | /*+ Maximum number of constants. +*/
    65   | #define MAX_CONSTS 100
    66   |
    67   | /*+ Default values for constants. +*/
    68   |
    69   | #define DEFLT_AUTHENTICATE    "0"
    70   | #define DEFLT_WHOIS_SUSPENDED "0"
    71   | #define DEFLT_DO_SERVER       "1"
    72   | #define DEFLT_WELCOME         "Welcome to the whois R.I.P. server.\n"
    73   | #define DEFLT_PROMPT          "whois R.I.P. config> "
    74   | #define DEFLT_CLEAR_SCREEN    "0"
    75   | #define DEFLT_ACCOUNTING      "0"
    76   | #define DEFLT_CONFIG_FILE     "rip.config"
    77   |
    78   | /*+ Each constant has a +*/
    79   | struct _constant {
    80   |   const char *token;              /*+ Token to be found in properties file. +*/
    81   |   const char *deflt;                    /*+ Default value for the constant. +*/
    82   |   int (*set_func)(void *, char *);        /*+ Function to set the constant. +*/
    83   |   void *constant_ptr;                     /*+ Pointer to the constant value +*/
    84   |   char *(*show_func)(void *);            /*+ Function to show the constant. +*/
    85   | };
    86   |
    87   |
    88   | /*+ The Constants array has a +*/
    89   | typedef struct _Constants {
    90   |   int   authenticate[1];                         /*+ Authenticate users. +*/
    91   |   int   whois_suspended[1];                /*+ Suspend the whois server. +*/
    92   |   char  welcome[1024];                  /*+ Welcome for config protocol. +*/
    93   |   char  prompt[1024];                    /*+ Prompt for config protocol. +*/
    94   |   int   clear_screen[1];         /*+ Clear screen after config commands. +*/
    95   |   int   accounting[1];          /*+ Conduct accounting on whois queries. +*/
    96   |
    97   |   int   do_server[1]; /*+ turns off execution of the all servers(threads) +*/
    98   |   int   do_update[1]; /*+ switches on and off the updates +*/
    99   |
    100  | } *Constants;
    101  |
    102  | /*
    103  |  * Global Variables
    104  |  */
    105  | /*+ The array of Global Constants. +*/
    106  | static Constants  Global_constants=NULL;
    107  |
    108  | /*
    109  |  * Set Functions
    110  |  */
    111  | static int set_string(void *constant, char *value) {
    112  |
    113  |   strcpy((char *)constant, value);
    114  |
    115  |   return 0;
    116  | } /* set_string() */
    117  |
    118  | static int set_int(void *constant, char *value) {
    119  |   int i;
    120  |
    121  |   i = atol(value);
    122  |   ((int *)constant)[0] = i;
    123  |
    124  |   return 0;
    125  | } /* set_int() */
    126  |
    127  | static int set_boolean(void *constant, char *value) {
    128  |   int result=1;
    129  |   int i;
    130  |
    131  |   i = atol(value);
    132  |
    133  |   /* If a valid boolean */
    134  |   if ( (i == 0) || (i == 1)) {
    135  |     ((int *)constant)[0] = i;
    136  |     result = 0;
    137  |   }
    138  |
    139  |   return result;
    140  | } /* set_boolean() */
    141  |
    142  |
    143  | /*
    144  |  * Show Functions
    145  |  */
    146  | /* AR. changed for unification with oter show funcs */
    147  | static char *show_string(void *constant) {
    148  |   char *tmp;
    149  |
    150  |   /*  tmp = calloc(1, strlen((char *)constant)+1); */
    151  |   dieif( wr_malloc((void **)&tmp, strlen((char *)constant)+1) != UT_OK);
    152  |
    153  |   strcpy(tmp, (char *)constant);
    154  | /*  return((char *)constant); */
    155  |   return tmp;
    156  | } /* show_string() */
    157  |
    158  | static char *show_int(void *constant) {
    159  |   char *tmp;
    160  |
    161  |   /* tmp = calloc(1, 64); */
    162  |   dieif( wr_malloc((void **)&tmp, 64) != UT_OK);
    163  |
    164  |   sprintf(tmp, "%d", ((int *)constant)[0]);
    165  |   return tmp;
    166  | } /* show_int() */
    167  |
    168  | static char *show_boolean(void *constant) {
    169  |   char *tmp;
    170  |
    171  |   /*  tmp = calloc(1, 64); */
    172  |   dieif( wr_malloc((void **)&tmp, 64) != UT_OK);
    173  |
    174  |   sprintf(tmp, "%d", ((int *)constant)[0]);
    175  |   return tmp;
    176  | } /* show_boolean() */
    177  |
    178  |
    179  | /*
    180  |  * Get Functions
    181  |  */
    182  |
    183  | int CO_get_authenticate() {
    184  |   return Global_constants->authenticate[0];
    185  | }
    186  |
    187  | int CO_get_whois_suspended() {
    188  |   return Global_constants->whois_suspended[0];
    189  | }
    190  |
    191  | char *CO_get_welcome() {
    192  |   return Global_constants->welcome;
    193  | }
    194  |
    195  | char *CO_get_prompt() {
    196  |   return Global_constants->prompt;
    197  | }
    198  |
    199  | int CO_get_clear_screen() {
    200  |   return Global_constants->clear_screen[0];
    201  | }
    202  |
    203  | int CO_get_accounting() {
    204  |   return Global_constants->accounting[0];
    205  | }
    206  |
    207  | int CO_get_do_server() {
    208  |   return Global_constants->do_server[0];
    209  | }
    210  |
    211  | int CO_get_do_update() {
    212  |   return Global_constants->do_update[0];
    213  | }
    214  |
    215  | /*+
    216  |  * Contains the constant definitions for the Token, set_function, show_function.
    217  |  * (See: _constant)
    218  | +*/
    219  | static struct _constant constant[MAX_CONSTS];
    220  |
    221  | /* init_constants() */
    222  | /*++++++++++++++++++++++++++++++++++++++
    223  |   Initialize all the constants.
    224  |
    225  |   More:
    226  |   +html+ <PRE>
    227  |   Authors:
    228  |         ottrey
    229  |
    230  |   +html+ </PRE><DL COMPACT>
    231  |   +html+ <DT>Online References:
    232  |   +html+ <DD><UL>
    233  |   +html+ </UL></DL>
    234  |
    235  |   ++++++++++++++++++++++++++++++++++++++*/
    236  | static void init_constants(void) {
    237  |   int n=0;
    238  |
    239  |   constant[n].token="SV.authenticate";
    240  |   constant[n].deflt=DEFLT_AUTHENTICATE;
    241  |   constant[n].set_func=set_boolean;
    242  |   constant[n].constant_ptr=Global_constants->authenticate;
    243  |   constant[n].show_func=show_boolean;
    244  |   n++;
    245  |
    246  |   constant[n].token="SV.whois_suspended";
    247  |   constant[n].deflt=DEFLT_WHOIS_SUSPENDED;
    248  |   constant[n].set_func=set_boolean;
    249  |   constant[n].constant_ptr=Global_constants->whois_suspended;
    250  |   constant[n].show_func=show_boolean;
    251  |   n++;
    252  |
    253  |   constant[n].token="SV.do_server";
    254  |   constant[n].deflt=DEFLT_DO_SERVER;
    255  |   constant[n].set_func=set_boolean;
    256  |   constant[n].constant_ptr=Global_constants->do_server;
    257  |   constant[n].show_func=show_boolean;
    258  |   n++;
    259  |
    260  |   constant[n].token="UD.do_update";
    261  |   constant[n].deflt="1";
    262  |   constant[n].set_func=set_int;
    263  |   constant[n].constant_ptr=Global_constants->do_update;
    264  |   constant[n].show_func=show_int;
    265  |   n++;
    266  |
    267  |   constant[n].token="PC.prompt";
    268  |   constant[n].deflt=DEFLT_PROMPT;
    269  |   constant[n].set_func=set_string;
    270  |   constant[n].constant_ptr=Global_constants->prompt;
    271  |   constant[n].show_func=show_string;
    272  |   n++;
    273  |
    274  |   constant[n].token="PC.clear_screen";
    275  |   constant[n].deflt=DEFLT_CLEAR_SCREEN;
    276  |   constant[n].set_func=set_boolean;
    277  |   constant[n].constant_ptr=Global_constants->clear_screen;
    278  |   constant[n].show_func=show_boolean;
    279  |   n++;
    280  |
    281  |   constant[n].token=NULL;
    282  |
    283  | } /* init_constants() */
    284  |
    285  |
    286  | /* CO_to_string() */
    287  | /*++++++++++++++++++++++++++++++++++++++
    288  |   Returns the constants as a string.
    289  |
    290  |   More:
    291  |   +html+ <PRE>
    292  |   Authors:
    293  |         ottrey
    294  |
    295  |   +html+ </PRE><DL COMPACT>
    296  |   +html+ <DT>Online References:
    297  |   +html+ <DD><UL>
    298  |   +html+ </UL></DL>
    299  |
    300  |   ++++++++++++++++++++++++++++++++++++++*/
    301  | char *CO_to_string(void) {
    302  |   char *consts;
    303  |   const char *token;
    304  |   char *value;
    305  |   char tmp_consts[2048];
    306  |   char tmp_const[1024];
    307  |   int i=0;
    308  |
    309  |   sprintf(tmp_consts, "Constants = { ");
    310  |   while(constant[i].token != NULL) {
    311  |     token = constant[i].token;
    312  |     value = constant[i].show_func(constant[i].constant_ptr);
    313  |     sprintf(tmp_const, "\n[%s]=\"%s\"", token, value);
    314  |     wr_free(value); /* Otherwise we have memory leaks */
    315  |     strcat(tmp_consts, tmp_const);
    316  |     i++;
    317  |   }
    318  |   strcat(tmp_consts, "}");
    319  |
    320  |   /* consts = calloc(1, strlen(tmp_consts)+1); */
    321  |   dieif(  wr_malloc((void **)&consts, strlen(tmp_consts)+1) != UT_OK);
    322  |
    323  |   strcpy(consts, tmp_consts);
    324  |
    325  |   return consts;
    326  | } /* CO_to_string() */
    327  |
    328  |
    329  | char *CO_const_to_string(char *name) {
    330  |   char *result=NULL;
    331  |   int i;
    332  |
    333  |   for (i=0; constant[i].token != NULL; i++) {
    334  |     if (strcmp(constant[i].token, name) == 0) {
    335  |       result = constant[i].show_func(constant[i].constant_ptr);
    336  |       break;
    337  |     }
    338  |   }
    339  |
    340  |   return result;
    341  | } /* CO_const_to_string() */
    342  |
    343  |  /* CO_set_const() */
    344  | /*++++++++++++++++++++++++++++++++++++++
    345  |   Sets the value of one constant.  Returns 0 if no error.
    346  |
    347  |   More:
    348  |   +html+ <PRE>
    349  |   Authors:
    350  |         ottrey
    351  |
    352  |   +html+ </PRE><DL COMPACT>
    353  |   +html+ <DT>Online References:
    354  |   +html+ <DD><UL>
    355  |   +html+ </UL></DL>
    356  |
    357  |   ++++++++++++++++++++++++++++++++++++++*/
    358  | int CO_set_const(char *name, char *value) {
    359  |   int result=1;
    360  |   int i;
    361  |
    362  |   for (i=0; constant[i].token != NULL; i++) {
    363  |     if (strcmp(constant[i].token, name) == 0) {
    364  |       result = constant[i].set_func((void *)constant[i].constant_ptr, value);
    365  |       break;
    366  |     }
    367  |   }
    368  |
    369  |   return result;
    370  | } /* CO_set_const() */
    371  |
    372  |
    373  | /* CO_set() */
    374  | /*++++++++++++++++++++++++++++++++++++++
    375  |   Sets the constants from the properties module.
    376  |   Returns the number of constants set.
    377  |
    378  |   More:
    379  |   +html+ <PRE>
    380  |   Authors:
    381  |         ottrey
    382  |   +html+ </PRE><DL COMPACT>
    383  |   +html+ <DT>Online References:
    384  |   +html+ <DD><UL>
    385  |   +html+   <LI><A HREF="../src/.properties">.properties</A>
    386  |   +html+ </UL></DL>
    387  |
    388  |   ++++++++++++++++++++++++++++++++++++++*/
    389  | char *CO_set(void) {
    390  |   int i;
    391  |   int set_count=0;
    392  |   int set;
    393  |   char result_buff[256];
    394  |   char *result;
    395  |   char *property;
    396  |
    397  |   /* Initialize if necessary */
    398  |   if (Global_constants == NULL) {
    399  |     /*  Global_constants = (Constants)calloc(1, sizeof(struct _Constants)); */
    400  |     dieif( wr_calloc((void **)&Global_constants, 1,
    401  | 		     sizeof(struct _Constants)) != UT_OK);
    402  |
    403  |     init_constants();
    404  |   }
    405  |
    406  |   for (i=0; constant[i].token != NULL; i++) {
    407  |     property = PR_get_property(constant[i].token, constant[i].deflt);
    408  |     set = constant[i].set_func((void *)constant[i].constant_ptr, property);
    409  |     wr_free(property);
    410  |     if (set == 0) {
    411  |       set_count++;
    412  |     }
    413  |   }
    414  |
    415  |   sprintf(result_buff, "%d out of %d constant(s) set.", set_count, i);
    416  |
    417  |   /* result = (char *)calloc(1, strlen(result_buff)+1); */
    418  |   dieif( wr_malloc((void **)&result, strlen(result_buff)+1) != UT_OK);
    419  |   strcpy(result, result_buff);
    420  |
    421  |   return result;
    422  | } /* CO_set() */
    423  |