citadel/commands.c

   1 /*
   2  * $Id$
   3  *
   4  * This file contains functions which implement parts of the
   5  * text-mode user interface.
   6  *
   7  */
   8
   9 #include "sysdep.h"
  10 #include <stdlib.h>
  11 #include <unistd.h>
  12 #include <stdio.h>
  13 #include <fcntl.h>
  14 #include <ctype.h>
  15 #include <string.h>
  16 #include <sys/types.h>
  17
  18 #if TIME_WITH_SYS_TIME
  19 # include <sys/time.h>
  20 # include <time.h>
  21 #else
  22 # if HAVE_SYS_TIME_H
  23 #  include <sys/time.h>
  24 # else
  25 #  include <time.h>
  26 # endif
  27 #endif
  28
  29 #ifdef HAVE_TERMIOS_H
  30 #include <termios.h>
  31 #else
  32 #include <sgtty.h>
  33 #endif
  34
  35 #ifdef HAVE_SYS_SELECT_H
  36 #include <sys/select.h>
  37 #endif
  38
  39 #ifdef THREADED_CLIENT
  40 #include <pthread.h>
  41 #endif
  42
  43 #include <signal.h>
  44 #include <errno.h>
  45 #include <stdarg.h>
  46 #include "citadel.h"
  47 #include "citadel_ipc.h"
  48 #include "commands.h"
  49 #include "messages.h"
  50 #include "citadel_decls.h"
  51 #include "routines.h"
  52 #include "routines2.h"
  53 #include "tools.h"
  54 #include "rooms.h"
  55 #include "client_chat.h"
  56 #ifndef HAVE_SNPRINTF
  57 #include "snprintf.h"
  58 #endif
  59 #include "screen.h"
  60
  61 struct citcmd {
  62         struct citcmd *next;
  63         int c_cmdnum;
  64         int c_axlevel;
  65         char c_keys[5][64];
  66 };
  67
  68 #define IFNEXPERT if ((userflags&US_EXPERT)==0)
  69
  70
  71 int rc_exp_beep;
  72 char rc_exp_cmd[1024];
  73 int rc_allow_attachments;
  74 int rc_display_message_numbers;
  75 int rc_force_mail_prompts;
  76 int rc_remember_passwords;
  77 int rc_ansi_color;
  78 int rc_color_use_bg;
  79 int num_urls = 0;
  80 int rc_prompt_control = 0;
  81 time_t rc_idle_threshold = (time_t)900;
  82 char urls[MAXURLS][SIZ];
  83 char rc_url_cmd[SIZ];
  84 char rc_gotmail_cmd[SIZ];
  85
  86 char *gl_string;
  87 int next_lazy_cmd = 5;
  88
  89 int lines_printed = 0;          /* line count for paginator */
  90 extern int screenwidth, screenheight;
  91 extern int termn8;
  92 extern CtdlIPC *ipc_for_signal_handlers;        /* KLUDGE cover your eyes */
  93
  94 struct citcmd *cmdlist = NULL;
  95
  96
  97 /* these variables are local to this module */
  98 char keepalives_enabled = KA_YES;       /* send NOOPs to server when idle */
  99 int ok_to_interrupt = 0;                /* print express msgs asynchronously */
 100 time_t AnsiDetect;                      /* when did we send the detect code? */
 101 int enable_color = 0;                   /* nonzero for ANSI color */
 102
 103
 104
 105
 106 /*
 107  * If an interesting key has been pressed, return its value, otherwise 0
 108  */
 109 char was_a_key_pressed(void) {
 110         fd_set rfds;
 111         struct timeval tv;
 112         int the_character;
 113         int retval;
 114
 115         FD_ZERO(&rfds);
 116         FD_SET(0, &rfds);
 117         tv.tv_sec = 0;
 118         tv.tv_usec = 0;
 119         retval = select(1, &rfds, NULL, NULL, &tv);
 120
 121         /* Careful!  Disable keepalives during keyboard polling; we're probably
 122          * in the middle of a data transfer from the server, in which case
 123          * sending a NOOP would throw the client protocol out of sync.
 124          */
 125         if (FD_ISSET(0, &rfds)) {
 126                 set_keepalives(KA_NO);
 127                 the_character = inkey();
 128                 set_keepalives(KA_YES);
 129         }
 130         else {
 131                 the_character = 0;
 132         }
 133         return(the_character);
 134 }
 135
 136
 137
 138
 139
 140 /*
 141  * Check to see if we need to pause at the end of a screen.
 142  * If we do, we have to switch to half keepalives during the pause because
 143  * we are probably in the middle of a server operation and the NOOP command
 144  * would confuse everything.
 145  */
 146 int checkpagin(int lp, unsigned int pagin, unsigned int height)
 147 {
 148         int thekey;
 149
 150         if (sigcaught) return(lp);
 151         thekey = was_a_key_pressed();
 152         if (thekey == 'q' || thekey == 'Q' || thekey == 's' || thekey == 'S')
 153                 thekey = STOP_KEY;
 154         if (thekey == 'n' || thekey == 'N')
 155                 thekey = NEXT_KEY;
 156         if ( (thekey == NEXT_KEY) || (thekey == STOP_KEY)) sigcaught = thekey;
 157         if (sigcaught) return(lp);
 158
 159         if (!pagin) return(0);
 160         if (lp>=(height-1)) {
 161                 set_keepalives(KA_HALF);
 162                 hit_any_key();
 163                 set_keepalives(KA_YES);
 164                 return(0);
 165         }
 166         return(lp);
 167 }
 168
 169
 170
 171
 172 /*
 173  * pprintf()  ...   paginated version of printf()
 174  */
 175 void pprintf(const char *format, ...) {
 176         va_list arg_ptr;
 177         static char buf[4096];  /* static for performance, change if needed */
 178         int i;
 179
 180         /* If sigcaught is nonzero, a keypress has interrupted this and we
 181          * should just drain output.
 182          */
 183         if (sigcaught) return;
 184
 185         /* Otherwise, start spewing... */
 186         va_start(arg_ptr, format);
 187         vsnprintf(buf, sizeof(buf), format, arg_ptr);
 188         va_end(arg_ptr);
 189
 190         for (i=0; i<strlen(buf); ++i) {
 191                 scr_putc(buf[i]);
 192                 if (buf[i]==10) {
 193                         ++lines_printed;
 194                         lines_printed = checkpagin(lines_printed,
 195                                 (userflags & US_PAGINATOR),
 196                                 screenheight);
 197                 }
 198         }
 199 }
 200
 201
 202
 203 /*
 204  * print_express()  -  print express messages if there are any
 205  */
 206 void print_express(void)
 207 {
 208         char buf[1024];
 209         FILE *outpipe;
 210         time_t timestamp;
 211         struct tm *stamp;
 212         int flags = 0;
 213         char sender[64];
 214         char node[64];
 215         char *listing = NULL;
 216         int r;                  /* IPC result code */
 217
 218         if (express_msgs == 0)
 219                 return;
 220
 221         if (rc_exp_beep) {
 222                 ctdl_beep();
 223         }
 224         if (strlen(rc_exp_cmd) == 0) {
 225                 color(BRIGHT_RED);
 226                 scr_printf("\r---");
 227         }
 228
 229         while (express_msgs != 0) {
 230                 r = CtdlIPCGetInstantMessage(ipc_for_signal_handlers, &listing, buf);
 231                 if (r / 100 != 1)
 232                         return;
 233
 234                 express_msgs = extract_int(buf, 0);
 235                 timestamp = extract_long(buf, 1);
 236                 flags = extract_int(buf, 2);
 237                 extract(sender, buf, 3);
 238                 extract(node, buf, 4);
 239                 strcpy(last_paged, sender);
 240
 241                 stamp = localtime(&timestamp);
 242
 243                 /* If the page is a Logoff Request, honor it. */
 244                 if (flags & 2) {
 245                         termn8 = 1;
 246                         return;
 247                 }
 248
 249                 if (strlen(rc_exp_cmd) > 0) {
 250                         outpipe = popen(rc_exp_cmd, "w");
 251                         if (outpipe != NULL) {
 252                                 /* Header derived from flags */
 253                                 if (flags & 2)
 254                                         fprintf(outpipe,
 255                                                "Please log off now, as requested ");
 256                                 else if (flags & 1)
 257                                         fprintf(outpipe, "Broadcast message ");
 258                                 else if (flags & 4)
 259                                         fprintf(outpipe, "Chat request ");
 260                                 else
 261                                         fprintf(outpipe, "Message ");
 262                                 /* Timestamp.  Can this be improved? */
 263                                 if (stamp->tm_hour == 0 || stamp->tm_hour == 12)
 264                                         fprintf(outpipe, "at 12:%02d%cm",
 265                                                 stamp->tm_min,
 266                                                 stamp->tm_hour ? 'p' : 'a');
 267                                 else if (stamp->tm_hour > 12)           /* pm */
 268                                         fprintf(outpipe, "at %d:%02dpm",
 269                                                 stamp->tm_hour - 12,
 270                                                 stamp->tm_min);
 271                                 else                                    /* am */
 272                                         fprintf(outpipe, "at %d:%02dam",
 273                                                 stamp->tm_hour, stamp->tm_min);
 274                                 fprintf(outpipe, " from %s", sender);
 275                                 if (strncmp(serv_info.serv_nodename, node, 32))
 276                                         fprintf(outpipe, " @%s", node);
 277                                 fprintf(outpipe, ":\n%s\n", listing);
 278                                 pclose(outpipe);
 279                                 if (express_msgs == 0)
 280                                         return;
 281                                 continue;
 282                         }
 283                 }
 284                 /* fall back to built-in express message display */
 285                 scr_printf("\n");
 286                 lines_printed++;
 287
 288                 /* Header derived from flags */
 289                 if (flags & 2)
 290                         scr_printf("Please log off now, as requested ");
 291                 else if (flags & 1)
 292                         scr_printf("Broadcast message ");
 293                 else if (flags & 4)
 294                         scr_printf("Chat request ");
 295                 else
 296                         scr_printf("Message ");
 297
 298                 /* Timestamp.  Can this be improved? */
 299                 if (stamp->tm_hour == 0 || stamp->tm_hour == 12)/* 12am/12pm */
 300                         scr_printf("at 12:%02d%cm", stamp->tm_min,
 301                                 stamp->tm_hour ? 'p' : 'a');
 302                 else if (stamp->tm_hour > 12)                   /* pm */
 303                         scr_printf("at %d:%02dpm",
 304                                 stamp->tm_hour - 12, stamp->tm_min);
 305                 else                                            /* am */
 306                         scr_printf("at %d:%02dam", stamp->tm_hour, stamp->tm_min);
 307
 308                 /* Sender */
 309                 scr_printf(" from %s", sender);
 310
 311                 /* Remote node, if any */
 312                 if (strncmp(serv_info.serv_nodename, node, 32))
 313                         scr_printf(" @%s", node);
 314
 315                 scr_printf(":\n");
 316                 lines_printed++;
 317                 fmout(screenwidth, NULL, listing, NULL, 1, screenheight, -1, 0);
 318                 free(listing);
 319
 320                 /* when running in curses mode, the scroll bar in most
 321                    xterm-style programs becomes useless, so it makes sense to
 322                    pause after a screenful of pages if the user has been idle
 323                    for a while. However, this is annoying to some of the users
 324                    who aren't in curses mode and tend to leave their clients
 325                    idle. keepalives become disabled, resulting in getting booted
 326                    when coming back to the idle session. but they probably have
 327                    a working scrollback in their terminal, so disable it in this
 328                    case:
 329                  */
 330                 if (!is_curses_enabled())
 331                         lines_printed = 0;
 332         }
 333         scr_printf("\n---\n");
 334         color(BRIGHT_WHITE);
 335
 336
 337 }
 338
 339
 340 void set_keepalives(int s)
 341 {
 342         keepalives_enabled = (char) s;
 343 }
 344
 345 /*
 346  * This loop handles the "keepalive" messages sent to the server when idling.
 347  */
 348
 349 static time_t idlet = 0;
 350 static void really_do_keepalive(void) {
 351         int r;                          /* IPC response code */
 352
 353         time(&idlet);
 354
 355         /* If full keepalives are enabled, send a NOOP to the server and
 356          * wait for a response.
 357          */
 358         if (keepalives_enabled == KA_YES) {
 359                 r = CtdlIPCNoop(ipc_for_signal_handlers);
 360                 if (express_msgs > 0) {
 361                         if (ok_to_interrupt == 1) {
 362                                 scr_printf("\r%64s\r", "");
 363                                 print_express();
 364                                 scr_printf("%s%c ", room_name,
 365                                        room_prompt(room_flags));
 366                                 scr_flush();
 367                         }
 368                 }
 369         }
 370
 371         /* If half keepalives are enabled, send a QNOP to the server (if the
 372          * server supports it) and then do nothing.
 373          */
 374         if ( (keepalives_enabled == KA_HALF)
 375            && (serv_info.serv_supports_qnop > 0) ) {
 376                 CtdlIPC_putline(ipc_for_signal_handlers, "QNOP");
 377         }
 378 }
 379
 380 /* threaded nonblocking keepalive stuff starts here. I'm going for a simple
 381    encapsulated interface; in theory there should be no need to touch these
 382    globals outside of the async_ka_* functions. */
 383
 384 #ifdef THREADED_CLIENT
 385 static pthread_t ka_thr_handle;
 386 static int ka_thr_active = 0;
 387 static int async_ka_enabled = 0;
 388
 389 static void *ka_thread(void *arg)
 390 {
 391         really_do_keepalive();
 392         pthread_detach(ka_thr_handle);
 393         ka_thr_active = 0;
 394         return NULL;
 395 }
 396
 397 /* start up a thread to handle a keepalive in the background */
 398 static void async_ka_exec(void)
 399 {
 400         if (!ka_thr_active) {
 401                 ka_thr_active = 1;
 402                 if (pthread_create(&ka_thr_handle, NULL, ka_thread, NULL)) {
 403                         perror("pthread_create");
 404                         exit(1);
 405                 }
 406         }
 407 }
 408 #endif /* THREADED_CLIENT */
 409
 410 /* I changed this from static to not because I need to call it from
 411    screen.c, either that or make something in screen.c not static.
 412    Fix it how you like. Why all the staticness? stu */
 413
 414 void do_keepalive(void)
 415 {
 416         time_t now;
 417
 418         time(&now);
 419         if ((now - idlet) < ((long) S_KEEPALIVE))
 420                 return;
 421
 422         /* Do a space-backspace to keep telnet sessions from idling out */
 423         scr_printf(" %c", 8);
 424         scr_flush();
 425
 426 #ifdef THREADED_CLIENT
 427         if (async_ka_enabled)
 428                 async_ka_exec();
 429         else
 430 #endif
 431                 really_do_keepalive();
 432 }
 433
 434
 435 /* Now the actual async-keepalve API that we expose to higher levels:
 436    async_ka_start() and async_ka_end(). These do nothing when we don't have
 437    threading enabled, so we avoid sprinkling ifdef's throughout the code. */
 438
 439 /* wait for a background keepalive to complete. this must be done before
 440    attempting any further server requests! */
 441 void async_ka_end(void)
 442 {
 443 #ifdef THREADED_CLIENT
 444         if (ka_thr_active)
 445                 pthread_join(ka_thr_handle, NULL);
 446
 447         async_ka_enabled--;
 448 #endif
 449 }
 450
 451 /* tell do_keepalive() that keepalives are asynchronous. */
 452 void async_ka_start(void)
 453 {
 454 #ifdef THREADED_CLIENT
 455         async_ka_enabled++;
 456 #endif
 457 }
 458
 459
 460 int inkey(void)
 461 {                               /* get a character from the keyboard, with   */
 462         int a;                  /* the watchdog timer in effect if necessary */
 463         fd_set rfds;
 464         struct timeval tv;
 465         time_t start_time;
 466
 467         scr_flush();
 468         lines_printed = 0;
 469         time(&start_time);
 470
 471         do {
 472                 /* This loop waits for keyboard input.  If the keepalive
 473                  * timer expires, it sends a keepalive to the server if
 474                  * necessary and then waits again.
 475                  */
 476                 do {
 477                         scr_set_windowsize();
 478                         do_keepalive();
 479                         scr_set_windowsize();
 480
 481                         FD_ZERO(&rfds);
 482                         FD_SET(0, &rfds);
 483                         tv.tv_sec = S_KEEPALIVE;
 484                         tv.tv_usec = 0;
 485
 486                         select(1, &rfds, NULL, NULL, &tv);
 487                 } while (!FD_ISSET(0, &rfds));
 488
 489                 /* At this point, there's input, so fetch it.
 490                  * (There's a hole in the bucket...)
 491                  */
 492                 a = scr_getc(SCR_NOBLOCK);
 493                 if (a == 127)
 494                         a = 8;
 495                 if (a > 126)
 496                         a = 0;
 497                 if (a == 13)
 498                         a = 10;
 499                 if (((a != 23) && (a != 4) && (a != 10) && (a != 8) && (a != NEXT_KEY) && (a != STOP_KEY))
 500                     && ((a < 32) || (a > 126)))
 501                         a = 0;
 502
 503 #ifndef DISABLE_CURSES
 504 #if defined(HAVE_CURSES_H) || defined(HAVE_NCURSES_H)
 505                 if (a == ERR)
 506                         a = 0;
 507 #endif
 508 #endif
 509
 510         } while (a == 0);
 511         return (a);
 512 }
 513
 514
 515 int yesno(void)
 516 {                               /* Returns 1 for yes, 0 for no */
 517         int a;
 518         while (1) {
 519                 a = inkey();
 520                 a = tolower(a);
 521                 if (a == 'y') {
 522                         scr_printf("Yes\n");
 523                         return (1);
 524                 }
 525                 if (a == 'n') {
 526                         scr_printf("No\n");
 527                         return (0);
 528                 }
 529         }
 530 }
 531
 532 /* Returns 1 for yes, 0 for no, arg is default value */
 533 int yesno_d(int d)
 534 {
 535         int a;
 536         while (1) {
 537                 a = inkey();
 538                 a = tolower(a);
 539                 if (a == 10)
 540                         a = (d ? 'y' : 'n');
 541                 if (a == 'y') {
 542                         scr_printf("Yes\n");
 543                         return (1);
 544                 }
 545                 if (a == 'n') {
 546                         scr_printf("No\n");
 547                         return (0);
 548                 }
 549         }
 550 }
 551
 552
 553
 554
 555 /* Gets a line from the terminal */
 556 /* string == Pointer to string buffer */
 557 /* lim == Maximum length - if negative, no-show */
 558 void getline(char *string, int lim)
 559 {
 560         int a, b;
 561         char flag = 0;
 562
 563         if (lim < 0) {
 564                 lim = (0 - lim);
 565                 flag = 1;
 566         }
 567         strcpy(string, "");
 568         gl_string = string;
 569         async_ka_start();
 570       GLA:a = inkey();
 571         a = (a & 127);
 572         if ((a == 8 || a == 23) && (strlen(string) == 0))
 573                 goto GLA;
 574         if ((a != 10) && (a != 8) && (strlen(string) == lim))
 575                 goto GLA;
 576         if ((a == 8) && (string[0] != 0)) {
 577                 string[strlen(string) - 1] = 0;
 578                 scr_putc(8); scr_putc(32); scr_putc(8);
 579                 goto GLA;
 580         }
 581         if ((a == 23) && (string[0] != 0)) {
 582                 do {
 583                         string[strlen(string) - 1] = 0;
 584                         scr_putc(8); scr_putc(32); scr_putc(8);
 585                 } while (strlen(string) && string[strlen(string) - 1] != ' ');
 586                 goto GLA;
 587         }
 588         if ((a == 10)) {
 589                 scr_putc(10);
 590                 async_ka_end();
 591                 return;
 592         }
 593         if (a < 32)
 594                 a = '.';
 595         b = strlen(string);
 596         string[b] = a;
 597         string[b + 1] = 0;
 598         if (flag == 0)
 599                 scr_putc(a);
 600         if (flag == 1)
 601                 scr_putc('*');
 602         goto GLA;
 603 }
 604
 605
 606 /*
 607  * strprompt()  -  prompt for a string, print the existing value and
 608  *                 allow the user to press return to keep it...
 609  */
 610 void strprompt(char *prompt, char *str, int len)
 611 {
 612         int i;
 613         char buf[128];
 614
 615         print_express();
 616         color(DIM_WHITE);
 617         scr_printf("%s ", prompt);
 618         color(DIM_MAGENTA);
 619         scr_printf("[");
 620         color(BRIGHT_MAGENTA);
 621
 622         if (len >= 0) {
 623                 scr_printf("%s", str);
 624         }
 625         else {
 626                 for (i=0; i<strlen(str); ++i) {
 627                         scr_printf("*");
 628                 }
 629         }
 630
 631         color(DIM_MAGENTA);
 632         scr_printf("]");
 633         color(DIM_WHITE);
 634         scr_printf(": ");
 635         color(BRIGHT_CYAN);
 636         getline(buf, len);
 637         if (buf[0] != 0)
 638                 strcpy(str, buf);
 639         color(DIM_WHITE);
 640 }
 641
 642 /*
 643  * boolprompt()  -  prompt for a yes/no, print the existing value and
 644  *                  allow the user to press return to keep it...
 645  */
 646 int boolprompt(char *prompt, int prev_val)
 647 {
 648         int r;
 649
 650         color(DIM_WHITE);
 651         scr_printf("%s ", prompt);
 652         color(DIM_MAGENTA);
 653         scr_printf("[");
 654         color(BRIGHT_MAGENTA);
 655         scr_printf("%s", (prev_val ? "Yes" : "No"));
 656         color(DIM_MAGENTA);
 657         scr_printf("]: ");
 658         color(BRIGHT_CYAN);
 659         r = (yesno_d(prev_val));
 660         color(DIM_WHITE);
 661         return r;
 662 }
 663
 664 /*
 665  * intprompt()  -  like strprompt(), except for an integer
 666  *                 (note that it RETURNS the new value!)
 667  */
 668 int intprompt(char *prompt, int ival, int imin, int imax)
 669 {
 670         char buf[16];
 671         int i;
 672         int p;
 673
 674         do {
 675                 i = ival;
 676                 snprintf(buf, sizeof buf, "%d", i);
 677                 strprompt(prompt, buf, 15);
 678                 i = atoi(buf);
 679                 for (p=0; p<strlen(buf); ++p) {
 680                         if ( (!isdigit(buf[p]))
 681                            && ( (buf[p]!='-') || (p!=0) )  )
 682                                 i = imin - 1;
 683                 }
 684                 if (i < imin)
 685                         scr_printf("*** Must be no less than %d.\n", imin);
 686                 if (i > imax)
 687                         scr_printf("*** Must be no more than %d.\n", imax);
 688         } while ((i < imin) || (i > imax));
 689         return (i);
 690 }
 691
 692 /*
 693  * newprompt()  -  prompt for a string with no existing value
 694  *                 (clears out string buffer first)
 695  */
 696 void newprompt(char *prompt, char *str, int len)
 697 {
 698         color(BRIGHT_MAGENTA);
 699         scr_printf("%s", prompt);
 700         color(DIM_MAGENTA);
 701         getline(str, len);
 702         color(DIM_WHITE);
 703 }
 704
 705
 706 int lkey(void)
 707 {                               /* returns a lower case value */
 708         int a;
 709         a = inkey();
 710         if (isupper(a))
 711                 a = tolower(a);
 712         return (a);
 713 }
 714
 715 /*
 716  * parse the citadel.rc file
 717  */
 718 void load_command_set(void)
 719 {
 720         FILE *ccfile;
 721         char buf[1024];
 722         struct citcmd *cptr;
 723         struct citcmd *lastcmd = NULL;
 724         int a, d;
 725         int b = 0;
 726
 727
 728         /* first, set up some defaults for non-required variables */
 729
 730         strcpy(editor_path, "");
 731         strcpy(printcmd, "");
 732         strcpy(rc_username, "");
 733         strcpy(rc_password, "");
 734         rc_floor_mode = 0;
 735         rc_exp_beep = 1;
 736         rc_allow_attachments = 0;
 737         rc_remember_passwords = 0;
 738         strcpy(rc_exp_cmd, "");
 739         rc_display_message_numbers = 0;
 740         rc_force_mail_prompts = 0;
 741         rc_ansi_color = 0;
 742         rc_color_use_bg = 0;
 743         strcpy(rc_url_cmd, "");
 744         strcpy(rc_gotmail_cmd, "");
 745 #ifdef HAVE_OPENSSL
 746         rc_encrypt = RC_DEFAULT;
 747 #endif
 748 #if defined(HAVE_CURSES_H) && !defined(DISABLE_CURSES)
 749         rc_screen = RC_DEFAULT;
 750 #endif
 751         rc_alt_semantics = 0;
 752
 753         /* now try to open the citadel.rc file */
 754
 755         ccfile = NULL;
 756         if (getenv("HOME") != NULL) {
 757                 snprintf(buf, sizeof buf, "%s/.citadelrc", getenv("HOME"));
 758                 ccfile = fopen(buf, "r");
 759         }
 760         if (ccfile == NULL) {
 761                 snprintf(buf, sizeof buf, "%s/citadel.rc", BBSDIR);
 762                 ccfile = fopen(buf, "r");
 763         }
 764         if (ccfile == NULL) {
 765                 ccfile = fopen("/etc/citadel.rc", "r");
 766         }
 767         if (ccfile == NULL) {
 768                 ccfile = fopen("./citadel.rc", "r");
 769         }
 770         if (ccfile == NULL) {
 771                 perror("commands: cannot open citadel.rc");
 772                 logoff(NULL, 3);
 773         }
 774         while (fgets(buf, sizeof buf, ccfile) != NULL) {
 775                 while ((strlen(buf) > 0) ? (isspace(buf[strlen(buf) - 1])) : 0)
 776                         buf[strlen(buf) - 1] = 0;
 777
 778                 if (!strncasecmp(buf, "encrypt=", 8)) {
 779                         if (!strcasecmp(&buf[8], "yes")) {
 780 #ifdef HAVE_OPENSSL
 781                                 rc_encrypt = RC_YES;
 782 #else
 783                                 fprintf(stderr, "citadel.rc requires encryption support but citadel is not compiled with OpenSSL");
 784                                 logoff(NULL, 3);
 785 #endif
 786                         }
 787 #ifdef HAVE_OPENSSL
 788                         else if (!strcasecmp(&buf[8], "no")) {
 789                                 rc_encrypt = RC_NO;
 790                         }
 791                         else if (!strcasecmp(&buf[8], "default")) {
 792                                 rc_encrypt = RC_DEFAULT;
 793                         }
 794 #endif
 795                 }
 796
 797 #if defined(HAVE_CURSES_H) && !defined(DISABLE_CURSES)
 798                 if (!strncasecmp(buf, "fullscreen=", 11)) {
 799                         if (!strcasecmp(&buf[11], "yes"))
 800                                 rc_screen = RC_YES;
 801                         else if (!strcasecmp(&buf[11], "no"))
 802                                 rc_screen = RC_NO;
 803                 }
 804 #endif
 805
 806                 if (!strncasecmp(buf, "editor=", 7))
 807                         strcpy(editor_path, &buf[7]);
 808
 809                 if (!strncasecmp(buf, "printcmd=", 9))
 810                         strcpy(printcmd, &buf[9]);
 811
 812                 if (!strncasecmp(buf, "expcmd=", 7))
 813                         strcpy(rc_exp_cmd, &buf[7]);
 814
 815                 if (!strncasecmp(buf, "local_screen_dimensions=", 24))
 816                         have_xterm = (char) atoi(&buf[24]);
 817
 818                 if (!strncasecmp(buf, "use_floors=", 11)) {
 819                         if (!strcasecmp(&buf[11], "yes"))
 820                                 rc_floor_mode = RC_YES;
 821                         if (!strcasecmp(&buf[11], "no"))
 822                                 rc_floor_mode = RC_NO;
 823                         if (!strcasecmp(&buf[11], "default"))
 824                                 rc_floor_mode = RC_DEFAULT;
 825                 }
 826                 if (!strncasecmp(buf, "beep=", 5)) {
 827                         rc_exp_beep = atoi(&buf[5]);
 828                 }
 829                 if (!strncasecmp(buf, "allow_attachments=", 18)) {
 830                         rc_allow_attachments = atoi(&buf[18]);
 831                 }
 832                 if (!strncasecmp(buf, "idle_threshold=", 15)) {
 833                         rc_idle_threshold = atoi(&buf[15]);
 834                 }
 835                 if (!strncasecmp(buf, "remember_passwords=", 19)) {
 836                         rc_remember_passwords = atoi(&buf[19]);
 837                 }
 838                 if (!strncasecmp(buf, "display_message_numbers=", 24)) {
 839                         rc_display_message_numbers = atoi(&buf[24]);
 840                 }
 841                 if (!strncasecmp(buf, "force_mail_prompts=", 19)) {
 842                         rc_force_mail_prompts = atoi(&buf[19]);
 843                 }
 844                 if (!strncasecmp(buf, "ansi_color=", 11)) {
 845                         if (!strncasecmp(&buf[11], "on", 2))
 846                                 rc_ansi_color = 1;
 847                         if (!strncasecmp(&buf[11], "auto", 4))
 848                                 rc_ansi_color = 2;      /* autodetect */
 849                         if (!strncasecmp(&buf[11], "user", 4))
 850                                 rc_ansi_color = 3;      /* user config */
 851                 }
 852                 if (!strncasecmp(buf, "use_background=", 15)) {
 853                         if (!strncasecmp(&buf[15], "on", 2))
 854                                 rc_color_use_bg = 9;
 855                 }
 856                 if (!strncasecmp(buf, "prompt_control=", 15)) {
 857                         if (!strncasecmp(&buf[15], "on", 2))
 858                                 rc_prompt_control = 1;
 859                         if (!strncasecmp(&buf[15], "user", 4))
 860                                 rc_prompt_control = 3;  /* user config */
 861                 }
 862                 if (!strncasecmp(buf, "username=", 9))
 863                         strcpy(rc_username, &buf[9]);
 864
 865                 if (!strncasecmp(buf, "password=", 9))
 866                         strcpy(rc_password, &buf[9]);
 867
 868                 if (!strncasecmp(buf, "urlcmd=", 7))
 869                         strcpy(rc_url_cmd, &buf[7]);
 870
 871                 if (!strncasecmp(buf, "gotmailcmd=", 11))
 872                         strcpy(rc_gotmail_cmd, &buf[11]);
 873
 874                 if (!strncasecmp(buf, "alternate_semantics=", 20)) {
 875                         if (!strncasecmp(&buf[11], "yes", 3))
 876                                 rc_alt_semantics = 1;
 877                         if (!strncasecmp(&buf[11], "no", 2))
 878                                 rc_alt_semantics = 0;
 879                 }
 880                 if (!strncasecmp(buf, "cmd=", 4)) {
 881                         strcpy(buf, &buf[4]);
 882
 883                         cptr = (struct citcmd *) malloc(sizeof(struct citcmd));
 884
 885                         cptr->c_cmdnum = atoi(buf);
 886                         for (d = strlen(buf); d >= 0; --d)
 887                                 if (buf[d] == ',')
 888                                         b = d;
 889                         strcpy(buf, &buf[b + 1]);
 890
 891                         cptr->c_axlevel = atoi(buf);
 892                         for (d = strlen(buf); d >= 0; --d)
 893                                 if (buf[d] == ',')
 894                                         b = d;
 895                         strcpy(buf, &buf[b + 1]);
 896
 897                         for (a = 0; a < 5; ++a)
 898                                 cptr->c_keys[a][0] = 0;
 899
 900                         a = 0;
 901                         b = 0;
 902                         buf[strlen(buf) + 1] = 0;
 903                         while (strlen(buf) > 0) {
 904                                 b = strlen(buf);
 905                                 for (d = strlen(buf); d >= 0; --d)
 906                                         if (buf[d] == ',')
 907                                                 b = d;
 908                                 strncpy(cptr->c_keys[a], buf, b);
 909                                 cptr->c_keys[a][b] = 0;
 910                                 if (buf[b] == ',')
 911                                         strcpy(buf, &buf[b + 1]);
 912                                 else
 913                                         strcpy(buf, "");
 914                                 ++a;
 915                         }
 916
 917                         cptr->next = NULL;
 918                         if (cmdlist == NULL)
 919                                 cmdlist = cptr;
 920                         else
 921                                 lastcmd->next = cptr;
 922                         lastcmd = cptr;
 923                 }
 924         }
 925         fclose(ccfile);
 926 }
 927
 928
 929
 930 /*
 931  * return the key associated with a command
 932  */
 933 char keycmd(char *cmdstr)
 934 {
 935         int a;
 936
 937         for (a = 0; a < strlen(cmdstr); ++a)
 938                 if (cmdstr[a] == '&')
 939                         return (tolower(cmdstr[a + 1]));
 940         return (0);
 941 }
 942
 943
 944 /*
 945  * Output the string from a key command without the ampersand
 946  * "mode" should be set to 0 for normal or 1 for <C>ommand key highlighting
 947  */
 948 char *cmd_expand(char *strbuf, int mode)
 949 {
 950         int a;
 951         static char exp[64];
 952         char buf[1024];
 953
 954         strcpy(exp, strbuf);
 955
 956         for (a = 0; a < strlen(exp); ++a) {
 957                 if (strbuf[a] == '&') {
 958
 959                         if (mode == 0) {
 960                                 strcpy(&exp[a], &exp[a + 1]);
 961                         }
 962                         if (mode == 1) {
 963                                 exp[a] = '<';
 964                                 strcpy(buf, &exp[a + 2]);
 965                                 exp[a + 2] = '>';
 966                                 exp[a + 3] = 0;
 967                                 strcat(exp, buf);
 968                         }
 969                 }
 970                 if (!strncmp(&exp[a], "^r", 2)) {
 971                         strcpy(buf, exp);
 972                         strcpy(&exp[a], room_name);
 973                         strcat(exp, &buf[a + 2]);
 974                 }
 975                 if (!strncmp(&exp[a], "^c", 2)) {
 976                         exp[a] = ',';
 977                         strcpy(&exp[a + 1], &exp[a + 2]);
 978                 }
 979         }
 980
 981         return (exp);
 982 }
 983
 984
 985
 986 /*
 987  * Comparison function to determine if entered commands match a
 988  * command loaded from the config file.
 989  */
 990 int cmdmatch(char *cmdbuf, struct citcmd *cptr, int ncomp)
 991 {
 992         int a;
 993         int cmdax;
 994
 995         cmdax = 0;
 996         if (is_room_aide)
 997                 cmdax = 1;
 998         if (axlevel >= 6)
 999                 cmdax = 2;
1000
1001         for (a = 0; a < ncomp; ++a) {
1002                 if ((tolower(cmdbuf[a]) != keycmd(cptr->c_keys[a]))
1003                     || (cptr->c_axlevel > cmdax))
1004                         return (0);
1005         }
1006         return (1);
1007 }
1008
1009
1010 /*
1011  * This function returns 1 if a given command requires a string input
1012  */
1013 int requires_string(struct citcmd *cptr, int ncomp)
1014 {
1015         int a;
1016         char buf[64];
1017
1018         strcpy(buf, cptr->c_keys[ncomp - 1]);
1019         for (a = 0; a < strlen(buf); ++a) {
1020                 if (buf[a] == ':')
1021                         return (1);
1022         }
1023         return (0);
1024 }
1025
1026
1027 /*
1028  * Input a command at the main prompt.
1029  * This function returns an integer command number.  If the command prompts
1030  * for a string then it is placed in the supplied buffer.
1031  */
1032 int getcmd(CtdlIPC *ipc, char *argbuf)
1033 {
1034         char cmdbuf[5];
1035         int cmdspaces[5];
1036         int cmdpos;
1037         int ch;
1038         int a;
1039         int got;
1040         int this_lazy_cmd;
1041         struct citcmd *cptr;
1042
1043         /*
1044          * Starting a new command now, so set sigcaught to 0.  This variable
1045          * is set to nonzero (usually NEXT_KEY or STOP_KEY) if a command has
1046          * been interrupted by a keypress.
1047          */
1048         sigcaught = 0;
1049
1050         /* Switch color support on or off if we're in user mode */
1051         if (rc_ansi_color == 3) {
1052                 if (userflags & US_COLOR)
1053                         enable_color = 1;
1054                 else
1055                         enable_color = 0;
1056         }
1057         /* if we're running in idiot mode, display a cute little menu */
1058         IFNEXPERT formout(ipc, "mainmenu");
1059
1060         print_express();
1061         strcpy(argbuf, "");
1062         cmdpos = 0;
1063         for (a = 0; a < 5; ++a)
1064                 cmdbuf[a] = 0;
1065         /* now the room prompt... */
1066         ok_to_interrupt = 1;
1067         color(BRIGHT_WHITE);
1068         scr_printf("\n%s", room_name);
1069         color(DIM_WHITE);
1070         scr_printf("%c ", room_prompt(room_flags));
1071         scr_flush();
1072
1073         while (1) {
1074                 ch = inkey();
1075                 ok_to_interrupt = 0;
1076
1077                 /* Handle the backspace key, but only if there's something
1078                  * to backspace over...
1079                  */
1080                 if ((ch == 8) && (cmdpos > 0)) {
1081                         back(cmdspaces[cmdpos - 1] + 1);
1082                         cmdbuf[cmdpos] = 0;
1083                         --cmdpos;
1084                 }
1085                 /* Spacebar invokes "lazy traversal" commands */
1086                 if ((ch == 32) && (cmdpos == 0)) {
1087                         this_lazy_cmd = next_lazy_cmd;
1088                         if (this_lazy_cmd == 13)
1089                                 next_lazy_cmd = 5;
1090                         if (this_lazy_cmd == 5)
1091                                 next_lazy_cmd = 13;
1092                         for (cptr = cmdlist; cptr != NULL; cptr = cptr->next) {
1093                                 if (cptr->c_cmdnum == this_lazy_cmd) {
1094                                         for (a = 0; a < 5; ++a)
1095                                                 if (cptr->c_keys[a][0] != 0)
1096                                                         scr_printf("%s ", cmd_expand(
1097                                                                                         cptr->c_keys[a], 0));
1098                                         scr_printf("\n");
1099                                         return (this_lazy_cmd);
1100                                 }
1101                         }
1102                         scr_printf("\n");
1103                         return (this_lazy_cmd);
1104                 }
1105                 /* Otherwise, process the command */
1106                 cmdbuf[cmdpos] = tolower(ch);
1107
1108                 for (cptr = cmdlist; cptr != NULL; cptr = cptr->next) {
1109                         if (cmdmatch(cmdbuf, cptr, cmdpos + 1)) {
1110
1111                                 scr_printf("%s", cmd_expand(cptr->c_keys[cmdpos], 0));
1112                                 cmdspaces[cmdpos] = strlen(
1113                                     cmd_expand(cptr->c_keys[cmdpos], 0));
1114                                 if (cmdpos < 4)
1115                                         if ((cptr->c_keys[cmdpos + 1]) != 0)
1116                                                 scr_putc(' ');
1117                                 ++cmdpos;
1118                         }
1119                 }
1120
1121                 for (cptr = cmdlist; cptr != NULL; cptr = cptr->next) {
1122                         if (cmdmatch(cmdbuf, cptr, 5)) {
1123                                 /* We've found our command. */
1124                                 if (requires_string(cptr, cmdpos)) {
1125                                         getline(argbuf, 32);
1126                                 } else {
1127                                         scr_printf("\n");
1128                                 }
1129
1130                                 /* If this command is one that changes rooms,
1131                                  * then the next lazy-command (space bar)
1132                                  * should be "read new" instead of "goto"
1133                                  */
1134                                 if ((cptr->c_cmdnum == 5)
1135                                     || (cptr->c_cmdnum == 6)
1136                                     || (cptr->c_cmdnum == 47)
1137                                     || (cptr->c_cmdnum == 52)
1138                                     || (cptr->c_cmdnum == 16)
1139                                     || (cptr->c_cmdnum == 20))
1140                                         next_lazy_cmd = 13;
1141
1142                                 return (cptr->c_cmdnum);
1143
1144                         }
1145                 }
1146
1147                 if (ch == '?') {
1148                         pprintf("\rOne of ...                         \n");
1149                         for (cptr = cmdlist; cptr != NULL; cptr = cptr->next) {
1150                                 if (cmdmatch(cmdbuf, cptr, cmdpos)) {
1151                                         for (a = 0; a < 5; ++a) {
1152                                                 pprintf("%s ", cmd_expand(cptr->c_keys[a], 1));
1153                                         }
1154                                         pprintf("\n");
1155                                 }
1156                         }
1157
1158                         pprintf("\n%s%c ", room_name, room_prompt(room_flags));
1159                         got = 0;
1160                         for (cptr = cmdlist; cptr != NULL; cptr = cptr->next) {
1161                                 if ((got == 0) && (cmdmatch(cmdbuf, cptr, cmdpos))) {
1162                                         for (a = 0; a < cmdpos; ++a) {
1163                                                 pprintf("%s ",
1164                                                        cmd_expand(cptr->c_keys[a], 0));
1165                                         }
1166                                         got = 1;
1167                                 }
1168                         }
1169                 }
1170         }
1171
1172 }
1173
1174
1175
1176
1177
1178 /*
1179  * set tty modes.  commands are:
1180  *
1181  * 01- set to bbs mode
1182  * 2 - save current settings for later restoral
1183  * 3 - restore saved settings
1184  */
1185 #ifdef HAVE_TERMIOS_H
1186 void sttybbs(int cmd)
1187 {                               /* SysV version of sttybbs() */
1188         struct termios live;
1189         static struct termios saved_settings;
1190         static int last_cmd = 0;
1191
1192         if (cmd == SB_LAST)
1193                 cmd = last_cmd;
1194         else
1195                 last_cmd = cmd;
1196
1197         if ((cmd == 0) || (cmd == 1)) {
1198                 tcgetattr(0, &live);
1199                 live.c_iflag = ISTRIP | IXON | IXANY;
1200                 live.c_oflag = OPOST | ONLCR;
1201                 live.c_lflag = ISIG | NOFLSH;
1202
1203                 live.c_cc[VINTR] = 0;
1204                 live.c_cc[VQUIT] = 0;
1205
1206 #ifdef hpux
1207                 live.c_cc[VMIN] = 0;
1208                 live.c_cc[VTIME] = 0;
1209 #endif
1210
1211                 /* do we even need this stuff anymore? */
1212                 /* live.c_line=0; */
1213                 live.c_cc[VERASE] = 8;
1214                 live.c_cc[VKILL] = 24;
1215                 live.c_cc[VEOF] = 1;
1216                 live.c_cc[VEOL] = 255;
1217                 live.c_cc[VEOL2] = 0;
1218                 live.c_cc[VSTART] = 0;
1219                 tcsetattr(0, TCSADRAIN, &live);
1220         }
1221         if (cmd == 2) {
1222                 tcgetattr(0, &saved_settings);
1223         }
1224         if (cmd == 3) {
1225                 tcsetattr(0, TCSADRAIN, &saved_settings);
1226         }
1227
1228 }
1229 #else
1230 void sttybbs(int cmd)
1231 {                               /* BSD version of sttybbs() */
1232         struct sgttyb live;
1233         static struct sgttyb saved_settings;
1234         static int last_cmd = 0;
1235
1236         if (cmd == SB_LAST)
1237                 cmd = last_cmd;
1238         else
1239                 last_cmd = cmd;
1240
1241         if ((cmd == 0) || (cmd == 1)) {
1242                 gtty(0, &live);
1243                 live.sg_flags |= CBREAK;
1244                 live.sg_flags |= CRMOD;
1245                 live.sg_flags |= NL1;
1246                 live.sg_flags &= ~ECHO;
1247                 if (cmd == 1)
1248                         live.sg_flags |= NOFLSH;
1249                 stty(0, &live);
1250         }
1251         if (cmd == 2) {
1252                 gtty(0, &saved_settings);
1253         }
1254         if (cmd == 3) {
1255                 stty(0, &saved_settings);
1256         }
1257 }
1258 #endif
1259
1260
1261 /*
1262  * display_help()  -  help file viewer
1263  */
1264 void display_help(CtdlIPC *ipc, char *name)
1265 {
1266         formout(ipc, name);
1267 }
1268
1269
1270 /*
1271  * fmout() - Citadel text formatter and paginator
1272  */
1273 int fmout(
1274         int width,      /* screen width to use */
1275         FILE *fpin,     /* file to read from, or NULL to format given text */
1276         char *text,     /* text to be formatted (when fpin is NULL */
1277         FILE *fpout,    /* file to write to, or NULL to write to screen */
1278         char pagin,     /* nonzero if we should use the paginator */
1279         int height,     /* screen height to use */
1280         int starting_lp,/* starting value for lines_printed, -1 for global */
1281         int subst)      /* nonzero if we should use hypertext mode */
1282 {
1283         char *buffer = NULL;    /* The current message */
1284         char *word = NULL;      /* What we are about to actually print */
1285         char *e;                /* Pointer to position in text */
1286         char old = 0;           /* The previous character */
1287         int column = 0;         /* Current column */
1288         size_t i;               /* Generic counter */
1289
1290         num_urls = 0;   /* Start with a clean slate of embedded URL's */
1291
1292         /* Space for a single word, which can be at most screenwidth */
1293         word = (char *)calloc(1, width);
1294         if (!word) {
1295                 err_printf("Can't alloc memory to print message: %s!\n",
1296                                 strerror(errno));
1297                 logoff(NULL, 3);
1298         }
1299
1300         /* Read the entire message body into memory */
1301         if (fpin) {
1302                 buffer = load_message_from_file(fpin);
1303                 if (!buffer) {
1304                         err_printf("Can't print message: %s!\n",
1305                                         strerror(errno));
1306                         logoff(NULL, 3);
1307                 }
1308         } else {
1309                 buffer = text;
1310         }
1311         e = buffer;
1312
1313         if (starting_lp >= 0)
1314                 lines_printed = starting_lp;
1315
1316         /* Run the message body */
1317         while (*e) {
1318                 /* Catch characters that shouldn't be there at all */
1319                 if (*e == '\r') {
1320                         e++;
1321                         continue;
1322                 }
1323                 /* First, are we looking at a newline? */
1324                 if (*e == '\n') {
1325                         e++;
1326                         if (*e == ' ') {        /* Paragraph */
1327                                 if (fpout) {
1328                                         fprintf(fpout, "\n");
1329                                 } else {
1330                                         scr_printf("\n");
1331                                         ++lines_printed;
1332                                         lines_printed = checkpagin(lines_printed, pagin, height);
1333                                 }
1334                                 column = 0;
1335                         } else if (old != ' ') {/* Don't print two spaces */
1336                                 if (fpout) {
1337                                         fprintf(fpout, " ");
1338                                 } else {
1339                                         scr_printf(" ");
1340                                 }
1341                                 column++;
1342                         }
1343                         old = '\n';
1344                         continue;
1345                 }
1346                 /* Or are we looking at a space? */
1347                 if (*e == ' ') {
1348                         e++;
1349                         if (column >= width - 1) {
1350                                 /* Are we in the rightmost column? */
1351                                 if (fpout) {
1352                                         fprintf(fpout, "\n");
1353                                 } else {
1354                                         scr_printf("\n");
1355                                         ++lines_printed;
1356                                         lines_printed = checkpagin(lines_printed, pagin, height);
1357                                 }
1358                                 column = 0;
1359                         } else if (!(column == 0 && old == ' ')) {
1360                                 /* Eat only the first space on a line */
1361                                 if (fpout) {
1362                                         fprintf(fpout, " ");
1363                                 } else {
1364                                         scr_printf(" ");
1365                                 }
1366                                 column++;
1367                         }
1368                         /* ONLY eat the FIRST space on a line */
1369                         old = ' ';
1370                         continue;
1371                 }
1372                 old = *e;
1373
1374                 /* Read a word, slightly messy */
1375                 i = 0;
1376                 while (e[i]) {
1377                         if (!isprint(e[i]) && !isspace(e[i]))
1378                                 e[i] = ' ';
1379                         if (isspace(e[i]))
1380                                 break;
1381                         i++;
1382                 }
1383
1384                 /* We should never see these, but... slightly messy */
1385                 if (e[i] == '\t' || e[i] == '\f' || e[i] == '\v')
1386                         e[i] = ' ';
1387
1388                 /*
1389                  * Check for and copy URLs
1390                  * We will get the entire URL even if it's longer than the
1391                  * screen width, as long as the server didn't break it up
1392                  */
1393                 if (!strncasecmp(e, "http://", 7) ||
1394                     !strncasecmp(e, "ftp://", 6)) {
1395                         int j;
1396
1397                         strncpy(urls[num_urls], e, i);
1398                         urls[num_urls][i] = 0;
1399                         for (j = 0; j < strlen(e); j++) {
1400                                 char c;
1401
1402                                 c = urls[num_urls][j];
1403                                 if (c == '>' || c == '\"' || c == ')' ||
1404                                     c == ' ' || c == '\n') {
1405                                         urls[num_urls][j] = 0;
1406                                         break;
1407                                 }
1408                         }
1409                         num_urls++;
1410                 }
1411
1412                 /* Break up really long words */
1413                 /* TODO: auto-hyphenation someday? */
1414                 if (i >= width)
1415                         i = width - 1;
1416                 strncpy(word, e, i);
1417                 word[i] = 0;
1418
1419                 /* Decide where to print the word */
1420                 if (column + i >= width) {
1421                         /* Wrap to the next line */
1422                         if (fpout) {
1423                                 fprintf(fpout, "\n");
1424                         } else {
1425                                 scr_printf("\n");
1426                                 ++lines_printed;
1427                                 lines_printed = checkpagin(lines_printed, pagin, height);
1428                         }
1429                         column = 0;
1430                 }
1431
1432                 /* Print the word */
1433                 if (fpout) {
1434                         fprintf(fpout, "%s", word);
1435                 } else {
1436                         scr_printf("%s", word);
1437                 }
1438                 column += i;
1439                 e += i;         /* Start over with the whitepsace! */
1440         }
1441
1442         free(word);
1443         if (fpin)               /* We allocated this, remember? */
1444                 free(buffer);
1445
1446         /* Is this necessary?  It makes the output kind of spacey. */
1447         if (fpout) {
1448                 fprintf(fpout, "\n");
1449         } else {
1450                 scr_printf("\n");
1451                 ++lines_printed;
1452                 lines_printed = checkpagin(lines_printed, pagin, height);
1453         }
1454
1455         return sigcaught;
1456 }
1457
1458
1459 /*
1460  * support ANSI color if defined
1461  */
1462 void color(int colornum)
1463 {
1464         static int hold_color;
1465         static int current_color;
1466
1467         if (colornum == COLOR_PUSH) {
1468                 hold_color = current_color;
1469                 return;
1470         }
1471
1472         if (colornum == COLOR_POP) {
1473                 color(hold_color);
1474                 return;
1475         }
1476
1477         current_color = colornum;
1478         if (enable_color) {
1479 #if defined(HAVE_CURSES_H) && !defined(DISABLE_CURSES)
1480                 if (scr_color(colornum))
1481                         return;
1482 #endif
1483                 /* When switching to dim white, actually output an 'original
1484                  * pair' sequence -- this looks better on black-on-white
1485                  * terminals. - Changed to ORIGINAL_PAIR as this actually
1486                  * wound up looking horrible on black-on-white terminals, not
1487                  * to mention transparent terminals.
1488                  */
1489                 if (colornum == ORIGINAL_PAIR)
1490                         printf("\033[0;39;49m");
1491                 else
1492                         printf("\033[%d;3%d;4%dm",
1493                                         (colornum & 8) ? 1 : 0,
1494                                         (colornum & 7),
1495                                         rc_color_use_bg);
1496
1497                 scr_flush();
1498         }
1499 }
1500
1501 void cls(int colornum)
1502 {
1503         if (enable_color) {
1504                 printf("\033[4%dm\033[2J\033[H\033[0m",
1505                                 colornum ? colornum : rc_color_use_bg);
1506                 scr_flush();
1507         }
1508 }
1509
1510
1511 /*
1512  * Detect whether ANSI color is available (answerback)
1513  */
1514 void send_ansi_detect(void)
1515 {
1516         if (rc_ansi_color == 2) {
1517                 printf("\033[c");
1518                 scr_flush();
1519                 time(&AnsiDetect);
1520         }
1521 }
1522
1523 void look_for_ansi(void)
1524 {
1525         fd_set rfds;
1526         struct timeval tv;
1527         char abuf[512];
1528         time_t now;
1529         int a;
1530
1531         if (rc_ansi_color == 0) {
1532                 enable_color = 0;
1533         } else if (rc_ansi_color == 1) {
1534                 enable_color = 1;
1535         } else if (rc_ansi_color == 2) {
1536
1537                 /* otherwise, do the auto-detect */
1538
1539                 strcpy(abuf, "");
1540
1541                 time(&now);
1542                 if ((now - AnsiDetect) < 2)
1543                         sleep(1);
1544
1545                 do {
1546                         FD_ZERO(&rfds);
1547                         FD_SET(0, &rfds);
1548                         tv.tv_sec = 0;
1549                         tv.tv_usec = 1;
1550
1551                         select(1, &rfds, NULL, NULL, &tv);
1552                         if (FD_ISSET(0, &rfds)) {
1553                                 abuf[strlen(abuf) + 1] = 0;
1554                                 read(0, &abuf[strlen(abuf)], 1);
1555                         }
1556                 } while (FD_ISSET(0, &rfds));
1557
1558                 for (a = 0; a < strlen(abuf); ++a) {
1559                         if ((abuf[a] == 27) && (abuf[a + 1] == '[')
1560                             && (abuf[a + 2] == '?')) {
1561                                 enable_color = 1;
1562                         }
1563                 }
1564         }
1565 }
1566
1567
1568 /*
1569  * Display key options (highlight hotkeys inside angle brackets)
1570  */
1571 void keyopt(char *buf) {
1572         int i;
1573
1574         color(DIM_WHITE);
1575         for (i=0; i<strlen(buf); ++i) {
1576                 if (buf[i]=='<') {
1577                         scr_putc(buf[i]);
1578                         color(BRIGHT_MAGENTA);
1579                 } else {
1580                         if (buf[i]=='>') {
1581                                 color(DIM_WHITE);
1582                         }
1583                         scr_putc(buf[i]);
1584                 }
1585         }
1586         color(DIM_WHITE);
1587 }
1588
1589
1590
1591 /*
1592  * Present a key-menu line choice type of thing
1593  */
1594 char keymenu(char *menuprompt, char *menustring) {
1595         int i, c, a;
1596         int choices;
1597         int do_prompt = 0;
1598         char buf[1024];
1599         int ch;
1600         int display_prompt = 1;
1601
1602         choices = num_tokens(menustring, '|');
1603
1604         if (menuprompt != NULL) do_prompt = 1;
1605         if (menuprompt != NULL) if (strlen(menuprompt)==0) do_prompt = 0;
1606
1607         while (1) {
1608                 if (display_prompt) {
1609                         if (do_prompt) {
1610                                 scr_printf("%s ", menuprompt);
1611                         }
1612                         else {
1613                                 for (i=0; i<choices; ++i) {
1614                                         extract(buf, menustring, i);
1615                                         keyopt(buf);
1616                                         scr_printf(" ");
1617                                 }
1618                         }
1619                         scr_printf(" -> ");
1620                         display_prompt = 0;
1621                 }
1622                 ch = lkey();
1623
1624                 if ( (do_prompt) && (ch=='?') ) {
1625                         scr_printf("\rOne of...                               ");
1626                         scr_printf("                                      \n");
1627                         for (i=0; i<choices; ++i) {
1628                                 extract(buf, menustring, i);
1629                                 scr_printf("   ");
1630                                 keyopt(buf);
1631                                 scr_printf("\n");
1632                         }
1633                         scr_printf("\n");
1634                         display_prompt = 1;
1635                 }
1636
1637                 for (i=0; i<choices; ++i) {
1638                         extract(buf, menustring, i);
1639                         for (c=1; c<strlen(buf); ++c) {
1640                                 if ( (ch == tolower(buf[c]))
1641                                    && (buf[c-1]=='<')
1642                                    && (buf[c+1]=='>') ) {
1643                                         for (a=0; a<strlen(buf); ++a) {
1644                                                 if ( (a!=(c-1)) && (a!=(c+1))) {
1645                                                         scr_putc(buf[a]);
1646                                                 }
1647                                         }
1648                                         scr_printf("\n\n");
1649                                         return ch;
1650                                 }
1651                         }
1652                 }
1653         }
1654 }