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_threads
  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_acl
  19. command_set
  20. command_sql
  21. process_input
  22. log_config
  23. authenticate_user
  24. PC_interact

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

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