## modules/pc/protocol_config.c

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

## FUNCTIONS

This source file includes following functions.

1. find_command
2. show_commands
3. command_purify
4. command_help
5. command_quit
6. show_const
7. show_consts
8. show_props
9. show_threads
10. show_whois
11. show_access
12. show_acl
13. command_execute
14. command_show
15. command_repeat
16. set_const
17. set_consts
18. set_props
19. set_acl
20. command_set
21. command_sql
22. process_input
23. log_config
24. authenticate_user
25. PC_interact

       1 /***************************************
       2   $Revision: 1.24 $
       3
       4   Protocol config module (pc).  This is the protocol that the admin uses to
       5   talk to the server.
       6
       7   Status: NOT REVUED, NOT TESTED
       8
       9   ******************/ /******************
      10   Filename            : protocol_config.c
      11   Authors             : ottrey@ripe.net
      12                         marek@ripe.net
      13   To Do               : Add a facility to take callbacks instead of
      14                         hard-coding menu options.
      15                         Add in all the menu support provided by the GLib
      16                         libraries.
      17                         (Remove strtok if multiple threads are to be used.)
      18                         use gnu readline with expansion and history
      19   ******************/ /******************
      20   Copyright (c) 1999                              RIPE NCC
      21
      22   All Rights Reserved
      23
      24   Permission to use, copy, modify, and distribute this software and its
      25   documentation for any purpose and without fee is hereby granted,
      26   provided that the above copyright notice appear in all copies and that
      27   both that copyright notice and this permission notice appear in
      28   supporting documentation, and that the name of the author not be
      29   used in advertising or publicity pertaining to distribution of the
      30   software without specific, written prior permission.
      31
      32   THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
      33   ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS; IN NO EVENT SHALL
      34   AUTHOR BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY
      35   DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
      36   AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
      37   OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
      38   ***************************************/
      39 #include <stdio.h>
      40 #include <stdlib.h>
      41 /*** solaris' header file doesn't contain the crypt definition...
      42      #include <unistd.h> */
      43
      44 extern char* crypt(const char *, const char *);   /* crypt stuff */
      45 #include <time.h>       /* Time stuff */
      46 #include <sys/ioctl.h>  /* Terminal control stuff */
      47 #include <termio.h>     /* Terminal control stuff */
      48
      49 #include "mysql_driver.h"
      50 #include "constants.h"
      51 #include "properties.h"
      52 #include "thread.h"
      53 #include "protocol_config.h"
      54 #include "access_control.h"
      55 #include "socket.h"
      56 #include "ta.h"
      57
      58 /*+ Each command has a +*/
      59 typedef struct _command {
      60   const char *name;                          /*+ Name to be invoked. +*/
      61   char *(*function)(char *, sk_conn_st *);   /*+ Function to be invoked. +*/
      62   const char *help;                                /*+ Command help. +*/
      63 } Command;
      64
      65 /*
      66  * Forward declarations
      67  */
      68 static char *command_help(char *input, sk_conn_st *condat);
      69 static char *command_quit(char *input, sk_conn_st *condat);
      70 static char *command_show(char *input, sk_conn_st *condat);
      71 static char *command_repeat(char *input, sk_conn_st *condat);
      72 static char *show_const(char *input, sk_conn_st *condat);
      73 static char *show_consts(char *input, sk_conn_st *condat);
      74 static char *show_props(char *input, sk_conn_st *condat);
      75 static char *show_threads(char *input, sk_conn_st *condat);
      76 static char *show_whois(char *input, sk_conn_st *condat);
      77 static char *show_access(char *input, sk_conn_st *condat);
      78 static char *show_acl(char *input, sk_conn_st *condat);
      79 static char *command_set(char *input, sk_conn_st *condat);
      80 static char *set_const(char *input, sk_conn_st *condat);
      81 static char *set_consts(char *input, sk_conn_st *condat);
      82 static char *set_props(char *input, sk_conn_st *condat);
      83 static char *command_sql(char *input, sk_conn_st *condat);
      84 static char *command_purify(char *input, sk_conn_st *condat);
      85 static char *set_acl(char *input, sk_conn_st *condat);
      86
      87 /*+
      88  * Contains the command definitions
      89 +*/
      90
      91 extern void purify_new_inuse(void);
      92
      93 static struct _command command[] = {
      94   {"help"   , command_help   , HELP_HELP   },
      95   {"quit"   , command_quit   , HELP_QUIT   },
      96   {"show"   , command_show   , HELP_SHOW   },
      97   {"repeat" , command_repeat , HELP_REPEAT },
      98   {"set"    , command_set    , HELP_SET    },
      99   {"sql"    , command_sql    , HELP_SQL    },
     100   {"purify" , command_purify , "trigger a new memory-in-use report" },
     101   {NULL     , NULL           , NULL        }
     102 };
     103
     104 /*+
     105  * Contains the show commands
     106 +*/
     107 static struct _command show[] = {
     108   {"const"   , show_const   , HELP_SHOW_CONST   },
     109   {"consts"  , show_consts  , HELP_SHOW_CONSTS  },
     110   {"props"   , show_props   , HELP_SHOW_PROPS   },
     111   {"threads"  , show_threads  , HELP_SHOW_THREAD  },
     112   {"whois"   , show_whois   , HELP_SHOW_WHOIS   },
     113   {"access"  , show_access  , HELP_SHOW_ACCESS  },
     114   {"acl"     , show_acl     , HELP_SHOW_ACL     },
     115   {NULL      , NULL         , NULL              }
     116 };
     117
     118 /*+
     119  * Contains the set commands
     120 +*/
     121 static struct _command set[] = {
     122   {"const"  , set_const  , HELP_SET_CONST  },
     123   {"consts" , set_consts , HELP_SET_CONSTS },
     124   {"props"  , set_props  , HELP_SET_PROPS  },
     125   {"acl"    , set_acl    , HELP_SET_ACL    },
     126   {NULL     , NULL       , NULL            }
     127 };
     128
     129 static int find_command(char *comm_name, Command *comm) {
         /* [<][>][^][v][top][bottom][index][help] */
     130   int i, index;
     131   char comm_buffer[STR_L];
     132
     133   if (comm_name != NULL) {
     134     strcpy(comm_buffer, comm_name);
     135     strtok(comm_buffer, " \t");
     136     for (i=0, index=-1; comm[i].name != NULL; i++) {
     137       if ( strcmp(comm_buffer, comm[i].name) == 0) {
     138         index = i;
     139         break;
     140       }
     141     }
     142   }
     143   else {
     144     index = -2;
     145   }
     146
     147   return index;
     148 } /* find_command() */
     149
     150 static char *show_commands(Command *comm) {
         /* [<][>][^][v][top][bottom][index][help] */
     151   char *str;
     152   char help_buffer[STR_XL];
     153   char help_comm[STR_M];
     154   int i;
     155
     156   sprintf(help_buffer, " commands are:\n\n");
     157   i = 0;
     158   while (comm[i].name != NULL) {
     159     sprintf(help_comm, "%s\t%s\n", comm[i].name, comm[i].help);
     160     strcat(help_buffer, help_comm);
     161     i++;
     162   }
     163
     164   /* str = (char *)calloc(1, strlen(help_buffer)+1); */
     165   dieif( wr_malloc((void **)&str, strlen(help_buffer)+1) != UT_OK);
     166   strcpy(str, help_buffer);
     167
     168   return str;
     169 } /* show_commands() */
     170
     171
     172 /*
     173  * Command functions
     174  */
     175
     176 static char *command_purify(char *input, sk_conn_st *condat)
         /* [<][>][^][v][top][bottom][index][help] */
     177 {
     178   char *str;
     179   dieif( wr_malloc((void **)&str, 4) != UT_OK);
     180 #if 0
     181   purify_new_inuse();
     182   strcpy(str, "OK");
     183 #else
     184   strcpy(str, "NOP");
     185 #endif
     186
     187   return str;
     188 }
     189
     190 static char *command_help(char *input, sk_conn_st *condat) {
         /* [<][>][^][v][top][bottom][index][help] */
     191   char *str;
     192   char *str1;
     193   char output_buffer[STR_XXL];
     194   char *command_name;
     195   int index;
     196
     197   strcpy(output_buffer, "");
     198
     199   strtok(input, " \t");
     200   command_name = (char *)strtok(NULL, " \t");
     201
     202   index = find_command(command_name, command);
     203
     204   switch (index) {
     205     case -2:
     206       strcat(output_buffer, "Main");
     207       str1 = show_commands(command);
     208       strcat(output_buffer, str1);
     209       wr_free(str1);
     210       break;
     211
     212     case -1:
     213       strcat(output_buffer, HELP_ERROR);
     214       strcat(output_buffer, command_name);
     215       break;
     216
     217     default:
     218       strcat(output_buffer, command[index].help);
     219   }
     220
     221   /*
     222   str = (char *)CopyString(output_buffer);
     223   */
     224   /*  str = (char *)calloc(1, strlen(output_buffer)+1); */
     225   dieif( wr_malloc((void **)&str, strlen(output_buffer)+1) != UT_OK);
     226   strcpy(str, output_buffer);
     227
     228   return str;
     229 } /* command_help() */
     230
     231 static char *command_quit(char *input, sk_conn_st *condat) {
         /* [<][>][^][v][top][bottom][index][help] */
     232     /* Administrator wishes to quit. */
     233   return NULL;
     234 } /* command_quit() */
     235
     236 static char *show_const(char *input, sk_conn_st *condat) {
         /* [<][>][^][v][top][bottom][index][help] */
     237   /* Administrator wishes to show constants. */
     238   char *result;
     239   char *name;
     240   char *tmp_input;
     241
     242   /* tmp_input = (char *)calloc(1, strlen(input)+1); */
     243   dieif( wr_malloc((void **)&tmp_input, strlen(input)+1) != UT_OK);
     244   strcpy(tmp_input, input);
     245
     246   /* The name will be the third token in stuff */
     247   strtok(tmp_input, " ");
     248   strtok(NULL, " ");
     249   name = (char *)strtok(NULL, " ");
     250
     251   result = CO_const_to_string(name);
     252
     253   wr_free(tmp_input);
     254   return result;
     255
     256 } /* show_const() */
     257
     258 static char *show_consts(char *input, sk_conn_st *condat) {
         /* [<][>][^][v][top][bottom][index][help] */
     259   /* Administrator wishes to show constants. */
     260   return CO_to_string();
     261
     262 } /* show_consts() */
     263
     264 static char *show_props(char *input, sk_conn_st *condat) {
         /* [<][>][^][v][top][bottom][index][help] */
     265   /* Administrator wishes to show properties. */
     266   return PR_to_string();
     267
     268 } /* show_props() */
     269
     270 static char *show_threads(char *input, sk_conn_st *condat) {
         /* [<][>][^][v][top][bottom][index][help] */
     271   /* Administrator wishes to show thread information. */
     272   return TA_tostring();
     273
     274 } /* show_thread() */
     275
     276 static char *show_whois(char *input, sk_conn_st *condat) {
         /* [<][>][^][v][top][bottom][index][help] */
     277   /* Administrator wishes to show whois query information. */
     278   return wr_string("WQ_to_string();");
     279
     280 } /* show_whois() */
     281
     282 static char *show_access(char *input, sk_conn_st *condat) {
         /* [<][>][^][v][top][bottom][index][help] */
     283   /* Administrator wishes to show whois query information. */
     284
     285   char line[128];
     286   int cnt;
     287   er_ret_t err;
     288
     289   if( act_runtime->top_ptr != NULL ) {
     290     char *header = AC_to_string_header();
     291
     292     /* print header */
     293     SK_cd_puts(condat,header);
     294     wr_free(header);
     295
     296     cnt = rx_walk_tree(act_runtime->top_ptr, AC_rxwalkhook_print,
     297                        RX_WALK_SKPGLU,  /* print no glue nodes */
     298                        255, 0, 0, condat, &err);
     299     sprintf(line,"Found %d nodes\n", cnt);
     300     SK_cd_puts(condat,line);
     301   }
     302
     303   return wr_string("");
     304
     305 } /* show_access() */
     306
     307 static char *show_acl(char *input, sk_conn_st *condat) {
         /* [<][>][^][v][top][bottom][index][help] */
     308   /* Administrator wishes to show access control list. */
     309
     310   char line[128];
     311   int cnt;
     312   er_ret_t err;
     313
     314   if( act_acl->top_ptr != NULL ) {
     315     char *header = AC_acl_to_string_header();
     316
     317     /* print header */
     318     SK_cd_puts(condat,header);
     319     wr_free(header);
     320
     321     cnt = rx_walk_tree(act_acl->top_ptr, AC_rxwalkhook_print_acl,
     322                        RX_WALK_SKPGLU,  /* print no glue nodes */
     323                        255, 0, 0, condat, &err);
     324     sprintf(line,"Found %d nodes\n", cnt);
     325     SK_cd_puts(condat,line);
     326   }
     327
     328   return wr_string("");
     329
     330 } /* show_acl() */
     331
     332 static char *command_execute(char *input, char *comm_name,
         /* [<][>][^][v][top][bottom][index][help] */
     333                              Command *comm, sk_conn_st *condat) {
     334   char *str;
     335   char *str1;
     336   char output_buffer[STR_XXL];
     337   char *name;
     338   int index;
     339   char *tmp_input;
     340
     341   /* Make a copy of the input */
     342   /* tmp_input = (char *)calloc(1, strlen(input)+1); */
     343   dieif( wr_malloc((void **)&tmp_input, strlen(input)+1) != UT_OK);
     344   strcpy(tmp_input, input);
     345
     346   strtok(tmp_input, " \t");
     347   name = (char *)strtok(NULL, " \t");
     348
     349   index = find_command(name, comm);
     350
     351   switch (index) {
     352     case -2:
     353       str1 = show_commands(comm);
     354       sprintf(output_buffer, "%s%s", comm_name, str1);
     355       wr_free(str1);
     356       break;
     357
     358     case -1:
     359       sprintf(output_buffer, "%s invalid command: %s", comm_name, name);
     360       break;
     361
     362     default:
     363       sprintf(output_buffer, "%s", comm[index].function(input, condat));
     364   }
     365
     366   /*
     367   str = (char *)CopyString(output_buffer);
     368   */
     369   /* str = (char *)calloc(1, strlen(output_buffer)+1); */
     370   dieif( wr_malloc((void **)&str, strlen(output_buffer)+1) != UT_OK);
     371   strcpy(str, output_buffer);
     372
     373   wr_free(tmp_input);
     374
     375   return str;
     376 } /* command_execute() */
     377
     378 static char *command_show(char *input, sk_conn_st *condat) {
         /* [<][>][^][v][top][bottom][index][help] */
     379   return command_execute(input, "Show", show, condat);
     380 } /* command_show() */
     381
     382 static char *command_repeat(char *input, sk_conn_st *condat) {
         /* [<][>][^][v][top][bottom][index][help] */
     383   char *command_ptr;
     384
     385   /* Goto the bit after "repeat n " */
     386   for (command_ptr=input+7; command_ptr[0] != ' ' || (command_ptr[0] >= '0' && command_ptr[0] <= '9'); command_ptr++);
     387
     388   return command_ptr+1;
     389
     390 } /* command_show() */
     391
     392 static char *set_const(char *input, sk_conn_st *condat) {
         /* [<][>][^][v][top][bottom][index][help] */
     393   /* Administrator wishes to set a constant. */
     394   char *result;
     395   char result_buf[STR_M];
     396   char *tmp_input;
     397   char *name;
     398   char *value;
     399   int value_len;
     400   char *stuff;
     401   char *str;
     402
     403   /* tmp_input = (char *)calloc(1, strlen(input)+1); */
     404   dieif( wr_malloc((void **)&tmp_input, strlen(input)+1) != UT_OK);
     405   strcpy(tmp_input, input);
     406
     407   stuff = (char *)strtok(tmp_input, "=");
     408
     409   /* The value will be after the '=' */
     410   value = (char *)strtok(NULL, "=");
     411
     412   /* The name will be the third token in stuff */
     413   strtok(stuff, " ");
     414   strtok(NULL, " ");
     415   name = (char *)strtok(NULL, " ");
     416
     417   /* Remove any quotes */
     418   if (value[0] == '"') {
     419     value++;
     420   }
     421   value_len=strlen(value);
     422   if (value[value_len-1] == '"') {
     423     value[value_len-1]='\0';
     424   }
     425
     426   printf("set_const name=(%s), value=(%s)\n", name, value);
     427   if (CO_set_const(name, value) == 0) {
     428     strcpy(result_buf, "Constant successfully set\n");
     429   }
     430   else {
     431     str = CO_const_to_string(name);
     432     sprintf(result_buf, "Constant not successfully set\nReverting to:   %s=%s\n", name, str);
     433     wr_free(str);
     434   }
     435
     436   /* result = (char *)calloc(1, strlen(result_buf)+1); */
     437   dieif( wr_malloc((void **)&result, strlen(result_buf)+1) != UT_OK);
     438   strcpy(result, result_buf);
     439
     440   wr_free(tmp_input);
     441   return result;
     442 } /* set_const() */
     443
     444 static char *set_consts(char *input, sk_conn_st *condat) {
         /* [<][>][^][v][top][bottom][index][help] */
     445   /* Administrator wishes to set constants. */
     446   return CO_set();
     447 } /* set_consts() */
     448
     449 static char *set_props(char *input, sk_conn_st *condat) {
         /* [<][>][^][v][top][bottom][index][help] */
     450   /* Administrator wishes to set properties. */
     451   return PR_set();
     452 } /* set_props() */
     453
     454 static char *set_acl(char *input, sk_conn_st *condat) {
         /* [<][>][^][v][top][bottom][index][help] */
     455
     456   /* first 8 characters are "set acl " so skip them */
     457
     458   if( ! NOERR( AC_asc_acl_command_set( input+8, "Manual"))) {
     459     return wr_string("Error\n");
     460   }
     461   else {
     462     return wr_string("OK");
     463   }
     464 }
     465
     466 static char *command_set(char *input, sk_conn_st *condat) {
         /* [<][>][^][v][top][bottom][index][help] */
     467   return command_execute(input, "Set", set, condat);
     468 } /* command_set() */
     469
     470 static char *command_sql(char *input, sk_conn_st *condat) {
         /* [<][>][^][v][top][bottom][index][help] */
     471   char *str;
     472   char output_buffer[STR_XXL];
     473   char *sql_str;
     474
     475   char *res=NULL;
     476
     477   SQ_result_set_t *sql_result=NULL;
     478   SQ_connection_t *sql_connection;
     479
     480   sql_connection = SQ_get_connection("",0,"","","");
     481
     482   if (sql_connection == NULL) {
     483     printf("/* Check for errors */\n");
     484   }
     485
     486   /* skip over the "sql" */
     487   sql_str = input+3;
     488   /* skip over white space */
     489   while (sql_str[0] == ' ') {
     490     sql_str++;
     491   }
     492
     493   strcpy(output_buffer, "");
     494
     495   if (sql_connection != NULL) {
     496     if (strcmp(sql_str, "status") == 0) {
     497       /* Get the status of the database */
     498       res = SQ_info_to_string(sql_connection);
     499     }
     500     else {
     501       if (strcmp(sql_str, "") == 0) {
     502         /* Execute the default query (from the properties file) */
     503           SQ_execute_query(sql_connection, "", &sql_result);
     504       }
     505       else {
     506         /* Execute an sql query */
     507           SQ_execute_query(sql_connection, sql_str, &sql_result);
     508       }
     509       if (sql_result != NULL) {
     510         res = SQ_result_to_string(sql_result);
     511       }
     512       else {
     513         printf("no results\n");
     514       }
     515     }
     516     if (res != NULL) {
     517       sprintf(output_buffer, "%s", res);
     518     }
     519     else {
     520       printf("empty results\n");
     521     }
     522   }
     523   else {
     524     printf("Failed to make connection\n");
     525   }
     526
     527   /*
     528   strcat(output_buffer, mysql_info(sql_connection));
     529   */
     530
     531   strcat(output_buffer, "XXX Results from mysql_info(sql_connection) is meant to go here.  But it's not working!");
     532
     533   /*
     534   str = (char *)CopyString(output_buffer);
     535   */
     536   /* str = (char *)calloc(1, strlen(output_buffer)+1); */
     537   dieif( wr_malloc((void **)&str, strlen(output_buffer)+1) != UT_OK);
     538   strcpy(str, output_buffer);
     539
     540   wr_free(res);
     541   SQ_free_result(sql_result);
     542
     543   SQ_close_connection(sql_connection);
     544
     545   return str;
     546
     547 } /* command_sql() */
     548
     549
     550 /* process_input() */
     551 /*++++++++++++++++++++++++++++++++++++++
     552
     553   Process the input.
     554
     555   sk_conn_st *condat         connection data
     556
     557   More:
     558   +html+ <PRE>
     559   Author:
     560         ottrey
     561   +html+ </PRE>
     562   ++++++++++++++++++++++++++++++++++++++*/
     563 static int process_input(char *input, sk_conn_st *condat) {
         /* [<][>][^][v][top][bottom][index][help] */
     564   int connected = 1;
     565   char *input_ptr;
     566   char *output;
     567   int  index;
     568   int repeat=0;
     569
     570   input_ptr = input;
     571
     572   if (strncmp(input, "repeat", 6) == 0) {
     573     /* XXX This is a really dodgy call, that hopefully converts
     574     the string to the value of the first found integer. */
     575     repeat = atoi(input+7);
     576     input_ptr= command_repeat(input, condat);
     577   }
     578
     579   index = find_command(input_ptr, command);
     580
     581   do {
     582     switch (index) {
     583       case -1:
     584         /* Command not found */
     585         output = command_help(NULL, condat);
     586         break;
     587
     588       default:
     589         output = command[index].function(input_ptr, condat);
     590     }
     591
     592     if(output == NULL) {
     593       connected = 0;
     594     } else {
     595       /*
     596       printf("thread output=\n%s\n", output);
     597       */
     598       if ( CO_get_clear_screen() == 1 ) {
     599         SK_cd_puts(condat, CLEAR_SCREEN);
     600       }
     601       SK_cd_puts(condat,  output);
     602       SK_cd_puts(condat, "\n");
     603       SK_cd_puts(condat, CO_get_prompt());
     604
     605       wr_free(output);
     606     }
     607
     608     if (repeat > 0) {
     609       repeat--;
     610     }
     611
     612   } while (repeat > 0);
     613
     614   return connected;
     615
     616 } /* process_input() */
     617
     618 static void log_config(const char *user, const char *status) {
         /* [<][>][^][v][top][bottom][index][help] */
     619   FILE *logf;
     620   time_t now;
     621   char timebuf[26];
     622
     623   time(&now);
     624
     625   printf(LOG_CONFIG, TH_get_id(), user, status, ctime_r(&now, timebuf));
     626
     627 } /* log_config() */
     628
     629 /* XXX Doh! These only change the server's terminal.  We need some
     630    tricky escape sequence to send over the socket.
     631 static void echo_off(int sock) {
     632   struct termio state;
     633
     634   ioctl(0, TIOCGETP, &state);
     635   state.c_lflag &= ~ECHO;
     636   ioctl(0, TIOCSETP, &state);
     637 } echo_off() */
     638
     639 /* XXX Doh! These only change the server's terminal.  We need some
     640    tricky escape sequence to send over the socket.
     641 static void echo_on(int sock) {
     642   struct termio state;
     643
     644   ioctl(0, TIOCGETP, &state);
     645   state.c_lflag |= ECHO;
     646   ioctl(0, TIOCSETP, &state);
     647 } echo_on() */
     648
     649 static char *authenticate_user(sk_conn_st *condat) {
         /* [<][>][^][v][top][bottom][index][help] */
     650   char *user = NULL;
     651   const char Salt[2] = "DB";
     652   char input[MAX_INPUT_SIZE];
     653   int read_result;
     654   char *password=NULL;
     655   char *user_password=NULL;
     656   char user_buf[10];
     657
     658   SK_cd_puts(condat, LOGIN_PROMPT);
     659   read_result = SK_cd_gets(condat, input, MAX_INPUT_SIZE);
     660
     661   strncpy(user_buf, input, 10);
     662
     663   SK_cd_puts(condat, PASSWD_PROMPT);
     664   /* XXX These aren't working.
     665   SK_puts(sock, ECHO_ON);
     666   echo_off(sock);
     667   */
     668   read_result = SK_cd_gets(condat, input, MAX_INPUT_SIZE);
     669   /* XXX These aren't working.
     670   echo_on(sock);
     671   SK_puts(sock, ECHO_OFF);
     672   */
     673
     674   password = crypt(input, Salt);
     675
     676   user_password = PR_get_property(user_buf, DEFAULT_USER_NAME);
     677
     678   if (user_password != NULL) {
     679     if (strcmp(password, user_password) == 0) {
     680       /*user = (char *)calloc(1, strlen(user_buf)+1);*/
     681       dieif( wr_malloc((void **)&user, strlen(user_buf)+1) != UT_OK);
     682       strcpy(user, user_buf);
     683     }
     684   }
     685
     686   if (user == NULL) {
     687     log_config(user_buf, "unsuccesful login attempt");
     688   }
     689
     690   return user;
     691
     692 } /* authenticate_user() */
     693
     694 void PC_interact(int sock) {
         /* [<][>][^][v][top][bottom][index][help] */
     695   char input[MAX_INPUT_SIZE];
     696   int connected = 1;
     697   char *user=NULL;
     698   sk_conn_st condat;
     699
     700   memset( &condat, 0, sizeof(condat));
     701   condat.sock = sock;
     702   SK_getpeerip(sock, &(condat.rIP));
     703   condat.ip = SK_getpeername(sock); /* XXX *alloc involved */
     704
     705   /* Welcome the client */
     706   SK_cd_puts(&condat, CO_get_welcome());
     707
     708   /* Authenticate the user */
     709   if (CO_get_authenticate() == 1) {
     710     user = authenticate_user(&condat);
     711   }
     712   else {
     713     user="nobody";
     714   }
     715
     716   if (user != NULL) {
     717
     718
     719     /* Log admin logging on */
     720     log_config(user, "logged on");
     721
     722
     723     {
     724       char timestring[26];
     725       extern time_t SV_starttime;
     726
     727       ctime_r(&SV_starttime, timestring);
     728       SK_cd_printf(&condat,
     729                    "System running since %sUptime in seconds: %ld \n\n",
     730                    timestring,
     731                    time(NULL) - SV_starttime);
     732     }
     733
     734     SK_cd_puts(&condat, CO_get_prompt());
     735
     736     while (condat.rtc==0 && connected) {
     737       char *ichr;
     738       char *icopy;
     739       char *chr;
     740       /* Read input */
     741       SK_cd_gets(&condat, input, MAX_INPUT_SIZE);
     742
     743       /* filter junk out: leading/trailing whitespaces */
     744
     745       /* 1. advance to non-whitespace */
     746       for(ichr=input; *ichr != 0 && isspace(*ichr); ichr++) {
     747         /* EMPTY */
     748       }
     749       /* 2. copy the rest (even if empty) */
     750       dieif( (icopy = strdup(ichr)) == NULL);
     751
     752       /* 3. chop trailing spaces */
     753       for( chr = icopy + strlen(icopy)-1 ;
     754            chr != icopy && isspace(*chr);
     755            chr--) {
     756         *chr = 0;
     757       }
     758
     759       /* set thread accounting */
     760       TA_setactivity(icopy);
     761       TA_increment();
     762
     763       connected = process_input(icopy, &condat);
     764
     765       TA_setactivity("");
     766
     767       free(icopy);
     768     }
     769
     770     /* Log admin logging off */
     771     log_config(user, "logged off");
     772   }
     773
     774   /* Close the socket */
     775   SK_close(sock);
     776
     777   wr_free(condat.ip);
     778 } /* PC_interact() */
     779

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