## 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_help
4. command_quit
5. show_const
6. show_consts
7. show_props
8. show_thread
9. show_whois
10. show_access
11. show_acl
12. command_execute
13. command_show
14. command_repeat
15. set_const
16. set_consts
17. set_props
18. set_ban
19. command_set
20. command_sql
21. process_input
22. log_config
23. authenticate_user
24. PC_interact

       1 /***************************************
       2   $Revision: 1.19 $
       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
      57 /*+ Each command has a +*/
      58 typedef struct _command {
      59   const char *name;                          /*+ Name to be invoked. +*/
      60   char *(*function)(char *, sk_conn_st *);   /*+ Function to be invoked. +*/
      61   const char *help;                                /*+ Command help. +*/
      62 } Command;
      63
      64 /*
      65  * Forward declarations
      66  */
      67 static char *command_help(char *input, sk_conn_st *condat);
      68 static char *command_quit(char *input, sk_conn_st *condat);
      69 static char *command_show(char *input, sk_conn_st *condat);
      70 static char *command_repeat(char *input, sk_conn_st *condat);
      71 static char *show_const(char *input, sk_conn_st *condat);
      72 static char *show_consts(char *input, sk_conn_st *condat);
      73 static char *show_props(char *input, sk_conn_st *condat);
      74 static char *show_thread(char *input, sk_conn_st *condat);
      75 static char *show_whois(char *input, sk_conn_st *condat);
      76 static char *show_access(char *input, sk_conn_st *condat);
      77 static char *show_acl(char *input, sk_conn_st *condat);
      78 static char *command_set(char *input, sk_conn_st *condat);
      79 static char *set_const(char *input, sk_conn_st *condat);
      80 static char *set_consts(char *input, sk_conn_st *condat);
      81 static char *set_props(char *input, sk_conn_st *condat);
      82 static char *command_sql(char *input, sk_conn_st *condat);
      83 static char *set_ban(char *input, sk_conn_st *condat);
      84
      85 /*+
      86  * Contains the command definitions
      87 +*/
      88 static struct _command command[] = {
      89   {"help"   , command_help   , HELP_HELP   },
      90   {"quit"   , command_quit   , HELP_QUIT   },
      91   {"show"   , command_show   , HELP_SHOW   },
      92   {"repeat" , command_repeat , HELP_REPEAT },
      93   {"set"    , command_set    , HELP_SET    },
      94   {"sql"    , command_sql    , HELP_SQL    },
      95   {NULL     , NULL           , NULL        }
      96 };
      97
      98 /*+
      99  * Contains the show commands
     100 +*/
     101 static struct _command show[] = {
     102   {"const"   , show_const   , HELP_SHOW_CONST   },
     103   {"consts"  , show_consts  , HELP_SHOW_CONSTS  },
     104   {"props"   , show_props   , HELP_SHOW_PROPS   },
     105   {"thread"  , show_thread  , HELP_SHOW_THREAD  },
     106   {"whois"   , show_whois   , HELP_SHOW_WHOIS   },
     107   {"access"  , show_access  , HELP_SHOW_ACCESS  },
     108   {"acl"     , show_acl     , HELP_SHOW_ACL     },
     109   {NULL      , NULL         , NULL              }
     110 };
     111
     112 /*+
     113  * Contains the set commands
     114 +*/
     115 static struct _command set[] = {
     116   {"const"  , set_const  , HELP_SET_CONST  },
     117   {"consts" , set_consts , HELP_SET_CONSTS },
     118   {"props"  , set_props  , HELP_SET_PROPS  },
     119   {"ban"    , set_ban    , HELP_SET_BAN    },
     120   {NULL     , NULL       , NULL            }
     121 };
     122
     123 static int find_command(char *comm_name, Command *comm) {
         /* [<][>][^][v][top][bottom][index][help] */
     124   int i, index;
     125   char comm_buffer[STR_L];
     126
     127   if (comm_name != NULL) {
     128     strcpy(comm_buffer, comm_name);
     129     strtok(comm_buffer, " \t");
     130     for (i=0, index=-1; comm[i].name != NULL; i++) {
     131       if ( strcmp(comm_buffer, comm[i].name) == 0) {
     132         index = i;
     133         break;
     134       }
     135     }
     136   }
     137   else {
     138     index = -2;
     139   }
     140
     141   return index;
     142 } /* find_command() */
     143
     144 static char *show_commands(Command *comm) {
         /* [<][>][^][v][top][bottom][index][help] */
     145   char *str;
     146   char help_buffer[STR_XL];
     147   char help_comm[STR_M];
     148   int i;
     149
     150   sprintf(help_buffer, " commands are:\n\n");
     151   i = 0;
     152   while (comm[i].name != NULL) {
     153     sprintf(help_comm, "%s\t%s\n", comm[i].name, comm[i].help);
     154     strcat(help_buffer, help_comm);
     155     i++;
     156   }
     157
     158   /* str = (char *)calloc(1, strlen(help_buffer)+1); */
     159   dieif( wr_malloc((void **)&str, strlen(help_buffer)+1) != UT_OK);
     160   strcpy(str, help_buffer);
     161
     162   return str;
     163 } /* show_commands() */
     164
     165
     166 /*
     167  * Command functions
     168  */
     169 static char *command_help(char *input, sk_conn_st *condat) {
         /* [<][>][^][v][top][bottom][index][help] */
     170   char *str;
     171   char *str1;
     172   char output_buffer[STR_XXL];
     173   char *command_name;
     174   int index;
     175
     176   strcpy(output_buffer, "");
     177
     178   strtok(input, " \t");
     179   command_name = (char *)strtok(NULL, " \t");
     180
     181   index = find_command(command_name, command);
     182
     183   switch (index) {
     184     case -2:
     185       strcat(output_buffer, "Main");
     186       str1 = show_commands(command);
     187       strcat(output_buffer, str1);
     188       wr_free(str1);
     189       break;
     190
     191     case -1:
     192       strcat(output_buffer, HELP_ERROR);
     193       strcat(output_buffer, command_name);
     194       break;
     195
     196     default:
     197       strcat(output_buffer, command[index].help);
     198   }
     199
     200   /*
     201   str = (char *)CopyString(output_buffer);
     202   */
     203   /*  str = (char *)calloc(1, strlen(output_buffer)+1); */
     204   dieif( wr_malloc((void **)&str, strlen(output_buffer)+1) != UT_OK);
     205   strcpy(str, output_buffer);
     206
     207   return str;
     208 } /* command_help() */
     209
     210 static char *command_quit(char *input, sk_conn_st *condat) {
         /* [<][>][^][v][top][bottom][index][help] */
     211     /* Administrator wishes to quit. */
     212   return NULL;
     213 } /* command_quit() */
     214
     215 static char *show_const(char *input, sk_conn_st *condat) {
         /* [<][>][^][v][top][bottom][index][help] */
     216   /* Administrator wishes to show constants. */
     217   char *result;
     218   char *name;
     219   char *tmp_input;
     220
     221   /* tmp_input = (char *)calloc(1, strlen(input)+1); */
     222   dieif( wr_malloc((void **)&tmp_input, strlen(input)+1) != UT_OK);
     223   strcpy(tmp_input, input);
     224
     225   /* The name will be the third token in stuff */
     226   strtok(tmp_input, " ");
     227   strtok(NULL, " ");
     228   name = (char *)strtok(NULL, " ");
     229
     230   result = CO_const_to_string(name);
     231
     232   wr_free(tmp_input);
     233   return result;
     234
     235 } /* show_const() */
     236
     237 static char *show_consts(char *input, sk_conn_st *condat) {
         /* [<][>][^][v][top][bottom][index][help] */
     238   /* Administrator wishes to show constants. */
     239   return CO_to_string();
     240
     241 } /* show_consts() */
     242
     243 static char *show_props(char *input, sk_conn_st *condat) {
         /* [<][>][^][v][top][bottom][index][help] */
     244   /* Administrator wishes to show properties. */
     245   return PR_to_string();
     246
     247 } /* show_props() */
     248
     249 static char *show_thread(char *input, sk_conn_st *condat) {
         /* [<][>][^][v][top][bottom][index][help] */
     250   /* Administrator wishes to show thread information. */
     251   return TH_to_string();
     252
     253 } /* show_thread() */
     254
     255 static char *show_whois(char *input, sk_conn_st *condat) {
         /* [<][>][^][v][top][bottom][index][help] */
     256   /* Administrator wishes to show whois query information. */
     257   return wr_string("WQ_to_string();");
     258
     259 } /* show_whois() */
     260
     261 static char *show_access(char *input, sk_conn_st *condat) {
         /* [<][>][^][v][top][bottom][index][help] */
     262   /* Administrator wishes to show whois query information. */
     263
     264   char line[128];
     265   int cnt;
     266   er_ret_t err;
     267
     268   if( act_runtime->top_ptr != NULL ) {
     269     char *header = AC_to_string_header();
     270
     271     /* print header */
     272     SK_cd_puts(condat,header);
     273     wr_free(header);
     274
     275     cnt = rx_walk_tree(act_runtime->top_ptr, AC_rxwalkhook_print,
     276                        RX_WALK_SKPGLU,  /* print no glue nodes */
     277                        255, 0, 0, condat, &err);
     278     sprintf(line,"Found %d nodes\n", cnt);
     279     SK_cd_puts(condat,line);
     280   }
     281
     282   return wr_string("");
     283
     284 } /* show_access() */
     285
     286 static char *show_acl(char *input, sk_conn_st *condat) {
         /* [<][>][^][v][top][bottom][index][help] */
     287   /* Administrator wishes to show access control list. */
     288
     289   char line[128];
     290   int cnt;
     291   er_ret_t err;
     292
     293   if( act_acl->top_ptr != NULL ) {
     294     char *header = AC_acl_to_string_header();
     295
     296     /* print header */
     297     SK_cd_puts(condat,header);
     298     wr_free(header);
     299
     300     cnt = rx_walk_tree(act_acl->top_ptr, AC_rxwalkhook_print_acl,
     301                        RX_WALK_SKPGLU,  /* print no glue nodes */
     302                        255, 0, 0, condat, &err);
     303     sprintf(line,"Found %d nodes\n", cnt);
     304     SK_cd_puts(condat,line);
     305   }
     306
     307   return wr_string("");
     308
     309 } /* show_acl() */
     310
     311 static char *command_execute(char *input, char *comm_name,
         /* [<][>][^][v][top][bottom][index][help] */
     312                              Command *comm, sk_conn_st *condat) {
     313   char *str;
     314   char *str1;
     315   char output_buffer[STR_XXL];
     316   char *name;
     317   int index;
     318   char *tmp_input;
     319
     320   /* Make a copy of the input */
     321   /* tmp_input = (char *)calloc(1, strlen(input)+1); */
     322   dieif( wr_malloc((void **)&tmp_input, strlen(input)+1) != UT_OK);
     323   strcpy(tmp_input, input);
     324
     325   strtok(tmp_input, " \t");
     326   name = (char *)strtok(NULL, " \t");
     327
     328   index = find_command(name, comm);
     329
     330   switch (index) {
     331     case -2:
     332       str1 = show_commands(comm);
     333       sprintf(output_buffer, "%s%s", comm_name, str1);
     334       wr_free(str1);
     335       break;
     336
     337     case -1:
     338       sprintf(output_buffer, "%s invalid command: %s", comm_name, name);
     339       break;
     340
     341     default:
     342       sprintf(output_buffer, "%s", comm[index].function(input, condat));
     343   }
     344
     345   /*
     346   str = (char *)CopyString(output_buffer);
     347   */
     348   /* str = (char *)calloc(1, strlen(output_buffer)+1); */
     349   dieif( wr_malloc((void **)&str, strlen(output_buffer)+1) != UT_OK);
     350   strcpy(str, output_buffer);
     351
     352   wr_free(tmp_input);
     353
     354   return str;
     355 } /* command_execute() */
     356
     357 static char *command_show(char *input, sk_conn_st *condat) {
         /* [<][>][^][v][top][bottom][index][help] */
     358   return command_execute(input, "Show", show, condat);
     359 } /* command_show() */
     360
     361 static char *command_repeat(char *input, sk_conn_st *condat) {
         /* [<][>][^][v][top][bottom][index][help] */
     362   char *command_ptr;
     363
     364   /* Goto the bit after "repeat n " */
     365   for (command_ptr=input+7; command_ptr[0] != ' ' || (command_ptr[0] >= '0' && command_ptr[0] <= '9'); command_ptr++);
     366
     367   return command_ptr+1;
     368
     369 } /* command_show() */
     370
     371 static char *set_const(char *input, sk_conn_st *condat) {
         /* [<][>][^][v][top][bottom][index][help] */
     372   /* Administrator wishes to set a constant. */
     373   char *result;
     374   char result_buf[STR_M];
     375   char *tmp_input;
     376   char *name;
     377   char *value;
     378   int value_len;
     379   char *stuff;
     380   char *str;
     381
     382   /* tmp_input = (char *)calloc(1, strlen(input)+1); */
     383   dieif( wr_malloc((void **)&tmp_input, strlen(input)+1) != UT_OK);
     384   strcpy(tmp_input, input);
     385
     386   stuff = (char *)strtok(tmp_input, "=");
     387
     388   /* The value will be after the '=' */
     389   value = (char *)strtok(NULL, "=");
     390
     391   /* The name will be the third token in stuff */
     392   strtok(stuff, " ");
     393   strtok(NULL, " ");
     394   name = (char *)strtok(NULL, " ");
     395
     396   /* Remove any quotes */
     397   if (value[0] == '"') {
     398     value++;
     399   }
     400   value_len=strlen(value);
     401   if (value[value_len-1] == '"') {
     402     value[value_len-1]='\0';
     403   }
     404
     405   printf("set_const name=(%s), value=(%s)\n", name, value);
     406   if (CO_set_const(name, value) == 0) {
     407     strcpy(result_buf, "Constant successfully set\n");
     408   }
     409   else {
     410     str = CO_const_to_string(name);
     411     sprintf(result_buf, "Constant not successfully set\nReverting to:   %s=%s\n", name, str);
     412     wr_free(str);
     413   }
     414
     415   /* result = (char *)calloc(1, strlen(result_buf)+1); */
     416   dieif( wr_malloc((void **)&result, strlen(result_buf)+1) != UT_OK);
     417   strcpy(result, result_buf);
     418
     419   wr_free(tmp_input);
     420   return result;
     421 } /* set_const() */
     422
     423 static char *set_consts(char *input, sk_conn_st *condat) {
         /* [<][>][^][v][top][bottom][index][help] */
     424   /* Administrator wishes to set constants. */
     425   return CO_set();
     426 } /* set_consts() */
     427
     428 static char *set_props(char *input, sk_conn_st *condat) {
         /* [<][>][^][v][top][bottom][index][help] */
     429   /* Administrator wishes to set properties. */
     430   return PR_set();
     431 } /* set_props() */
     432
     433 static char *set_ban(char *input, sk_conn_st *condat) {
         /* [<][>][^][v][top][bottom][index][help] */
     434   int flag;
     435   char addrstr[128];
     436
     437   if( sscanf(input,"set ban %d %127s", &flag, addrstr) < 2) {
     438     return wr_string("Invalid arguments");
     439   }
     440   else {
     441     if( ! NOERR( AC_asc_ban_set( addrstr, "Manual", (flag!=0) ))) {
     442       return wr_string("Error\n");
     443     }
     444     else {
     445       return wr_string("OK");
     446     }
     447   }
     448 }
     449
     450 static char *command_set(char *input, sk_conn_st *condat) {
         /* [<][>][^][v][top][bottom][index][help] */
     451   return command_execute(input, "Set", set, condat);
     452 } /* command_set() */
     453
     454 static char *command_sql(char *input, sk_conn_st *condat) {
         /* [<][>][^][v][top][bottom][index][help] */
     455   char *str;
     456   char output_buffer[STR_XXL];
     457   char *sql_str;
     458
     459   char *res=NULL;
     460
     461   SQ_result_set_t *sql_result=NULL;
     462   SQ_connection_t *sql_connection;
     463
     464   sql_connection = SQ_get_connection(CO_get_host(), CO_get_database_port(), CO_get_database(), CO_get_user(), CO_get_password() );
     465
     466   if (sql_connection == NULL) {
     467     printf("/* Check for errors */\n");
     468   }
     469
     470   /* skip over the "sql" */
     471   sql_str = input+3;
     472   /* skip over white space */
     473   while (sql_str[0] == ' ') {
     474     sql_str++;
     475   }
     476
     477   strcpy(output_buffer, "");
     478
     479   if (sql_connection != NULL) {
     480     if (strcmp(sql_str, "status") == 0) {
     481       /* Get the status of the database */
     482       res = SQ_info_to_string(sql_connection);
     483     }
     484     else {
     485       if (strcmp(sql_str, "") == 0) {
     486         /* Execute the default query (from the properties file) */
     487           SQ_execute_query(sql_connection, CO_get_query(), &sql_result);
     488       }
     489       else {
     490         /* Execute an sql query */
     491           SQ_execute_query(sql_connection, sql_str, &sql_result);
     492       }
     493       if (sql_result != NULL) {
     494         res = SQ_result_to_string(sql_result);
     495       }
     496       else {
     497         printf("no results\n");
     498       }
     499     }
     500     if (res != NULL) {
     501       sprintf(output_buffer, "%s", res);
     502     }
     503     else {
     504       printf("empty results\n");
     505     }
     506   }
     507   else {
     508     printf("Failed to make connection\n");
     509   }
     510
     511   /*
     512   strcat(output_buffer, mysql_info(sql_connection));
     513   */
     514
     515   strcat(output_buffer, "XXX Results from mysql_info(sql_connection) is meant to go here.  But it's not working!");
     516
     517   /*
     518   str = (char *)CopyString(output_buffer);
     519   */
     520   /* str = (char *)calloc(1, strlen(output_buffer)+1); */
     521   dieif( wr_malloc((void **)&str, strlen(output_buffer)+1) != UT_OK);
     522   strcpy(str, output_buffer);
     523
     524   wr_free(res);
     525   SQ_free_result(sql_result);
     526
     527   SQ_close_connection(sql_connection);
     528
     529   return str;
     530
     531 } /* command_sql() */
     532
     533
     534 /* process_input() */
     535 /*++++++++++++++++++++++++++++++++++++++
     536
     537   Process the input.
     538
     539   sk_conn_st *condat         connection data
     540
     541   More:
     542   +html+ <PRE>
     543   Author:
     544         ottrey
     545   +html+ </PRE>
     546   ++++++++++++++++++++++++++++++++++++++*/
     547 static int process_input(char *input, sk_conn_st *condat) {
         /* [<][>][^][v][top][bottom][index][help] */
     548   int connected = 1;
     549   char *input_ptr;
     550   char *output;
     551   int  index;
     552   int repeat=0;
     553
     554   input_ptr = input;
     555
     556   if (strncmp(input, "repeat", 6) == 0) {
     557     /* XXX This is a really dodgy call, that hopefully converts
     558     the string to the value of the first found integer. */
     559     repeat = atoi(input+7);
     560     input_ptr= command_repeat(input, condat);
     561   }
     562
     563   index = find_command(input_ptr, command);
     564
     565   do {
     566     switch (index) {
     567       case -1:
     568         /* Command not found */
     569         output = command_help(NULL, condat);
     570         break;
     571
     572       default:
     573         output = command[index].function(input_ptr, condat);
     574     }
     575
     576     if(output == NULL) {
     577       connected = 0;
     578     } else {
     579       /*
     580       printf("thread output=\n%s\n", output);
     581       */
     582       if ( CO_get_clear_screen() == 1 ) {
     583         SK_cd_puts(condat, CLEAR_SCREEN);
     584       }
     585       SK_cd_puts(condat,  output);
     586       SK_cd_puts(condat, "\n");
     587       SK_cd_puts(condat, CO_get_prompt());
     588
     589       wr_free(output);
     590     }
     591
     592     if (repeat > 0) {
     593       repeat--;
     594       sleep(CO_get_sleep_time());
     595     }
     596
     597   } while (repeat > 0);
     598
     599   return connected;
     600
     601 } /* process_input() */
     602
     603 static void log_config(const char *user, const char *status) {
         /* [<][>][^][v][top][bottom][index][help] */
     604   FILE *logf;
     605   time_t now;
     606   char timebuf[26];
     607
     608   time(&now);
     609
     610   if (CO_get_config_logging() == 1) {
     611
     612     if (strcmp(CO_get_config_logfile(), "stdout") == 0) {
     613       printf(LOG_CONFIG, TH_get_id(), user, status, ctime_r(&now, timebuf));
     614     }
     615     else {
     616       logf = fopen(CO_get_config_logfile(), "a");
     617       fprintf(logf, LOG_CONFIG, TH_get_id(), user, status, ctime_r(&now, timebuf));
     618       fclose(logf);
     619     }
     620   }
     621
     622 } /* log_config() */
     623
     624 /* XXX Doh! These only change the server's terminal.  We need some
     625    tricky escape sequence to send over the socket.
     626 static void echo_off(int sock) {
     627   struct termio state;
     628
     629   ioctl(0, TIOCGETP, &state);
     630   state.c_lflag &= ~ECHO;
     631   ioctl(0, TIOCSETP, &state);
     632 } echo_off() */
     633
     634 /* XXX Doh! These only change the server's terminal.  We need some
     635    tricky escape sequence to send over the socket.
     636 static void echo_on(int sock) {
     637   struct termio state;
     638
     639   ioctl(0, TIOCGETP, &state);
     640   state.c_lflag |= ECHO;
     641   ioctl(0, TIOCSETP, &state);
     642 } echo_on() */
     643
     644 static char *authenticate_user(sk_conn_st *condat) {
         /* [<][>][^][v][top][bottom][index][help] */
     645   char *user = NULL;
     646   const char Salt[2] = "DB";
     647   char input[MAX_INPUT_SIZE];
     648   int read_result;
     649   char *password=NULL;
     650   char *user_password=NULL;
     651   char user_buf[10];
     652
     653   SK_cd_puts(condat, LOGIN_PROMPT);
     654   read_result = SK_cd_gets(condat, input, MAX_INPUT_SIZE);
     655
     656   strncpy(user_buf, input, 10);
     657
     658   SK_cd_puts(condat, PASSWD_PROMPT);
     659   /* XXX These aren't working.
     660   SK_puts(sock, ECHO_ON);
     661   echo_off(sock);
     662   */
     663   read_result = SK_cd_gets(condat, input, MAX_INPUT_SIZE);
     664   /* XXX These aren't working.
     665   echo_on(sock);
     666   SK_puts(sock, ECHO_OFF);
     667   */
     668
     669   password = crypt(input, Salt);
     670
     671   user_password = PR_get_property(user_buf, DEFAULT_USER_NAME);
     672
     673   if (user_password != NULL) {
     674     if (strcmp(password, user_password) == 0) {
     675       /*user = (char *)calloc(1, strlen(user_buf)+1);*/
     676       dieif( wr_malloc((void **)&user, strlen(user_buf)+1) != UT_OK);
     677       strcpy(user, user_buf);
     678     }
     679   }
     680
     681   if (user == NULL) {
     682     log_config(user_buf, "unsuccesful login attempt");
     683   }
     684
     685   return user;
     686
     687 } /* authenticate_user() */
     688
     689 void PC_interact(int sock) {
         /* [<][>][^][v][top][bottom][index][help] */
     690   char input[MAX_INPUT_SIZE];
     691   int connected = 1;
     692   char *user=NULL;
     693   sk_conn_st condat;
     694
     695   memset( &condat, 0, sizeof(condat));
     696   condat.sock = sock;
     697   SK_getpeerip(sock, &(condat.rIP));
     698   condat.ip = SK_getpeername(sock); /* XXX *alloc involved */
     699
     700   /* Welcome the client */
     701   SK_cd_puts(&condat, CO_get_welcome());
     702
     703   /* Authenticate the user */
     704   if (CO_get_authenticate() == 1) {
     705     user = authenticate_user(&condat);
     706   }
     707   else {
     708     user="nobody";
     709   }
     710
     711   if (user != NULL) {
     712
     713
     714     /* Log admin logging on */
     715     log_config(user, "logged on");
     716
     717
     718     {
     719       char timestring[26];
     720       extern time_t SV_starttime;
     721
     722       ctime_r(&SV_starttime, timestring);
     723       SK_cd_printf(&condat,
     724                    "System running since %sUptime in seconds: %ld \n\n",
     725                    timestring,
     726                    time(NULL) - SV_starttime);
     727     }
     728
     729     SK_cd_puts(&condat, CO_get_prompt());
     730
     731     while (condat.rtc==0 && connected) {
     732       /* Read input */
     733       SK_cd_gets(&condat, input, MAX_INPUT_SIZE);
     734       connected = process_input(input, &condat);
     735     }
     736
     737     /* Log admin logging off */
     738     log_config(user, "logged off");
     739   }
     740
     741   /* Close the socket */
     742   SK_close(sock);
     743
     744   wr_free(condat.ip);
     745 } /* PC_interact() */
     746

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