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         char editor_key[100];
 723         struct citcmd *cptr;
 724         struct citcmd *lastcmd = NULL;
 725         int a, d;
 726         int b = 0;
 727         int i;
 728
 729
 730         /* first, set up some defaults for non-required variables */
 731
 732         for (i = 0; i < MAX_EDITORS; i++)
 733                 strcpy(editor_paths[i], "");
 734         strcpy(printcmd, "");
 735         strcpy(rc_username, "");
 736         strcpy(rc_password, "");
 737         rc_floor_mode = 0;
 738         rc_exp_beep = 1;
 739         rc_allow_attachments = 0;
 740         rc_remember_passwords = 0;
 741         strcpy(rc_exp_cmd, "");
 742         rc_display_message_numbers = 0;
 743         rc_force_mail_prompts = 0;
 744         rc_ansi_color = 0;
 745         rc_color_use_bg = 0;
 746         strcpy(rc_url_cmd, "");
 747         strcpy(rc_gotmail_cmd, "");
 748 #ifdef HAVE_OPENSSL
 749         rc_encrypt = RC_DEFAULT;
 750 #endif
 751 #if defined(HAVE_CURSES_H) && !defined(DISABLE_CURSES)
 752         rc_screen = RC_DEFAULT;
 753 #endif
 754         rc_alt_semantics = 0;
 755
 756         /* now try to open the citadel.rc file */
 757
 758         ccfile = NULL;
 759         if (getenv("HOME") != NULL) {
 760                 snprintf(buf, sizeof buf, "%s/.citadelrc", getenv("HOME"));
 761                 ccfile = fopen(buf, "r");
 762         }
 763         if (ccfile == NULL) {
 764                 snprintf(buf, sizeof buf, "%s/citadel.rc", BBSDIR);
 765                 ccfile = fopen(buf, "r");
 766         }
 767         if (ccfile == NULL) {
 768                 ccfile = fopen("/etc/citadel.rc", "r");
 769         }
 770         if (ccfile == NULL) {
 771                 ccfile = fopen("./citadel.rc", "r");
 772         }
 773         if (ccfile == NULL) {
 774                 perror("commands: cannot open citadel.rc");
 775                 logoff(NULL, 3);
 776         }
 777         while (fgets(buf, sizeof buf, ccfile) != NULL) {
 778                 while ((strlen(buf) > 0) ? (isspace(buf[strlen(buf) - 1])) : 0)
 779                         buf[strlen(buf) - 1] = 0;
 780
 781                 if (!strncasecmp(buf, "encrypt=", 8)) {
 782                         if (!strcasecmp(&buf[8], "yes")) {
 783 #ifdef HAVE_OPENSSL
 784                                 rc_encrypt = RC_YES;
 785 #else
 786                                 fprintf(stderr, "citadel.rc requires encryption support but citadel is not compiled with OpenSSL");
 787                                 logoff(NULL, 3);
 788 #endif
 789                         }
 790 #ifdef HAVE_OPENSSL
 791                         else if (!strcasecmp(&buf[8], "no")) {
 792                                 rc_encrypt = RC_NO;
 793                         }
 794                         else if (!strcasecmp(&buf[8], "default")) {
 795                                 rc_encrypt = RC_DEFAULT;
 796                         }
 797 #endif
 798                 }
 799
 800 #if defined(HAVE_CURSES_H) && !defined(DISABLE_CURSES)
 801                 if (!strncasecmp(buf, "fullscreen=", 11)) {
 802                         if (!strcasecmp(&buf[11], "yes"))
 803                                 rc_screen = RC_YES;
 804                         else if (!strcasecmp(&buf[11], "no"))
 805                                 rc_screen = RC_NO;
 806                 }
 807 #endif
 808
 809                 if (!strncasecmp(buf, "editor=", 7))
 810                         strcpy(editor_paths[0], &buf[7]);
 811
 812                 for (i = 0; i < MAX_EDITORS; i++)
 813                 {
 814                         sprintf(editor_key, "editor%d=", i);
 815                         if (!strncasecmp(buf, editor_key, strlen(editor_key)))
 816                                 strcpy(editor_paths[i], &buf[strlen(editor_key)]);
 817                 }
 818
 819                 if (!strncasecmp(buf, "printcmd=", 9))
 820                         strcpy(printcmd, &buf[9]);
 821
 822                 if (!strncasecmp(buf, "expcmd=", 7))
 823                         strcpy(rc_exp_cmd, &buf[7]);
 824
 825                 if (!strncasecmp(buf, "local_screen_dimensions=", 24))
 826                         have_xterm = (char) atoi(&buf[24]);
 827
 828                 if (!strncasecmp(buf, "use_floors=", 11)) {
 829                         if (!strcasecmp(&buf[11], "yes"))
 830                                 rc_floor_mode = RC_YES;
 831                         if (!strcasecmp(&buf[11], "no"))
 832                                 rc_floor_mode = RC_NO;
 833                         if (!strcasecmp(&buf[11], "default"))
 834                                 rc_floor_mode = RC_DEFAULT;
 835                 }
 836                 if (!strncasecmp(buf, "beep=", 5)) {
 837                         rc_exp_beep = atoi(&buf[5]);
 838                 }
 839                 if (!strncasecmp(buf, "allow_attachments=", 18)) {
 840                         rc_allow_attachments = atoi(&buf[18]);
 841                 }
 842                 if (!strncasecmp(buf, "idle_threshold=", 15)) {
 843                         rc_idle_threshold = atoi(&buf[15]);
 844                 }
 845                 if (!strncasecmp(buf, "remember_passwords=", 19)) {
 846                         rc_remember_passwords = atoi(&buf[19]);
 847                 }
 848                 if (!strncasecmp(buf, "display_message_numbers=", 24)) {
 849                         rc_display_message_numbers = atoi(&buf[24]);
 850                 }
 851                 if (!strncasecmp(buf, "force_mail_prompts=", 19)) {
 852                         rc_force_mail_prompts = atoi(&buf[19]);
 853                 }
 854                 if (!strncasecmp(buf, "ansi_color=", 11)) {
 855                         if (!strncasecmp(&buf[11], "on", 2))
 856                                 rc_ansi_color = 1;
 857                         if (!strncasecmp(&buf[11], "auto", 4))
 858                                 rc_ansi_color = 2;      /* autodetect */
 859                         if (!strncasecmp(&buf[11], "user", 4))
 860                                 rc_ansi_color = 3;      /* user config */
 861                 }
 862                 if (!strncasecmp(buf, "use_background=", 15)) {
 863                         if (!strncasecmp(&buf[15], "on", 2))
 864                                 rc_color_use_bg = 9;
 865                 }
 866                 if (!strncasecmp(buf, "prompt_control=", 15)) {
 867                         if (!strncasecmp(&buf[15], "on", 2))
 868                                 rc_prompt_control = 1;
 869                         if (!strncasecmp(&buf[15], "user", 4))
 870                                 rc_prompt_control = 3;  /* user config */
 871                 }
 872                 if (!strncasecmp(buf, "username=", 9))
 873                         strcpy(rc_username, &buf[9]);
 874
 875                 if (!strncasecmp(buf, "password=", 9))
 876                         strcpy(rc_password, &buf[9]);
 877
 878                 if (!strncasecmp(buf, "urlcmd=", 7))
 879                         strcpy(rc_url_cmd, &buf[7]);
 880
 881                 if (!strncasecmp(buf, "gotmailcmd=", 11))
 882                         strcpy(rc_gotmail_cmd, &buf[11]);
 883
 884                 if (!strncasecmp(buf, "alternate_semantics=", 20)) {
 885                         if (!strncasecmp(&buf[11], "yes", 3))
 886                                 rc_alt_semantics = 1;
 887                         if (!strncasecmp(&buf[11], "no", 2))
 888                                 rc_alt_semantics = 0;
 889                 }
 890                 if (!strncasecmp(buf, "cmd=", 4)) {
 891                         strcpy(buf, &buf[4]);
 892
 893                         cptr = (struct citcmd *) malloc(sizeof(struct citcmd));
 894
 895                         cptr->c_cmdnum = atoi(buf);
 896                         for (d = strlen(buf); d >= 0; --d)
 897                                 if (buf[d] == ',')
 898                                         b = d;
 899                         strcpy(buf, &buf[b + 1]);
 900
 901                         cptr->c_axlevel = atoi(buf);
 902                         for (d = strlen(buf); d >= 0; --d)
 903                                 if (buf[d] == ',')
 904                                         b = d;
 905                         strcpy(buf, &buf[b + 1]);
 906
 907                         for (a = 0; a < 5; ++a)
 908                                 cptr->c_keys[a][0] = 0;
 909
 910                         a = 0;
 911                         b = 0;
 912                         buf[strlen(buf) + 1] = 0;
 913                         while (strlen(buf) > 0) {
 914                                 b = strlen(buf);
 915                                 for (d = strlen(buf); d >= 0; --d)
 916                                         if (buf[d] == ',')
 917                                                 b = d;
 918                                 strncpy(cptr->c_keys[a], buf, b);
 919                                 cptr->c_keys[a][b] = 0;
 920                                 if (buf[b] == ',')
 921                                         strcpy(buf, &buf[b + 1]);
 922                                 else
 923                                         strcpy(buf, "");
 924                                 ++a;
 925                         }
 926
 927                         cptr->next = NULL;
 928                         if (cmdlist == NULL)
 929                                 cmdlist = cptr;
 930                         else
 931                                 lastcmd->next = cptr;
 932                         lastcmd = cptr;
 933                 }
 934         }
 935         fclose(ccfile);
 936 }
 937
 938
 939
 940 /*
 941  * return the key associated with a command
 942  */
 943 char keycmd(char *cmdstr)
 944 {
 945         int a;
 946
 947         for (a = 0; a < strlen(cmdstr); ++a)
 948                 if (cmdstr[a] == '&')
 949                         return (tolower(cmdstr[a + 1]));
 950         return (0);
 951 }
 952
 953
 954 /*
 955  * Output the string from a key command without the ampersand
 956  * "mode" should be set to 0 for normal or 1 for <C>ommand key highlighting
 957  */
 958 char *cmd_expand(char *strbuf, int mode)
 959 {
 960         int a;
 961         static char exp[64];
 962         char buf[1024];
 963
 964         strcpy(exp, strbuf);
 965
 966         for (a = 0; a < strlen(exp); ++a) {
 967                 if (strbuf[a] == '&') {
 968
 969                         if (mode == 0) {
 970                                 strcpy(&exp[a], &exp[a + 1]);
 971                         }
 972                         if (mode == 1) {
 973                                 exp[a] = '<';
 974                                 strcpy(buf, &exp[a + 2]);
 975                                 exp[a + 2] = '>';
 976                                 exp[a + 3] = 0;
 977                                 strcat(exp, buf);
 978                         }
 979                 }
 980                 if (!strncmp(&exp[a], "^r", 2)) {
 981                         strcpy(buf, exp);
 982                         strcpy(&exp[a], room_name);
 983                         strcat(exp, &buf[a + 2]);
 984                 }
 985                 if (!strncmp(&exp[a], "^c", 2)) {
 986                         exp[a] = ',';
 987                         strcpy(&exp[a + 1], &exp[a + 2]);
 988                 }
 989         }
 990
 991         return (exp);
 992 }
 993
 994
 995
 996 /*
 997  * Comparison function to determine if entered commands match a
 998  * command loaded from the config file.
 999  */
1000 int cmdmatch(char *cmdbuf, struct citcmd *cptr, int ncomp)
1001 {
1002         int a;
1003         int cmdax;
1004
1005         cmdax = 0;
1006         if (is_room_aide)
1007                 cmdax = 1;
1008         if (axlevel >= 6)
1009                 cmdax = 2;
1010
1011         for (a = 0; a < ncomp; ++a) {
1012                 if ((tolower(cmdbuf[a]) != keycmd(cptr->c_keys[a]))
1013                     || (cptr->c_axlevel > cmdax))
1014                         return (0);
1015         }
1016         return (1);
1017 }
1018
1019
1020 /*
1021  * This function returns 1 if a given command requires a string input
1022  */
1023 int requires_string(struct citcmd *cptr, int ncomp)
1024 {
1025         int a;
1026         char buf[64];
1027
1028         strcpy(buf, cptr->c_keys[ncomp - 1]);
1029         for (a = 0; a < strlen(buf); ++a) {
1030                 if (buf[a] == ':')
1031                         return (1);
1032         }
1033         return (0);
1034 }
1035
1036
1037 /*
1038  * Input a command at the main prompt.
1039  * This function returns an integer command number.  If the command prompts
1040  * for a string then it is placed in the supplied buffer.
1041  */
1042 int getcmd(CtdlIPC *ipc, char *argbuf)
1043 {
1044         char cmdbuf[5];
1045         int cmdspaces[5];
1046         int cmdpos;
1047         int ch;
1048         int a;
1049         int got;
1050         int this_lazy_cmd;
1051         struct citcmd *cptr;
1052
1053         /*
1054          * Starting a new command now, so set sigcaught to 0.  This variable
1055          * is set to nonzero (usually NEXT_KEY or STOP_KEY) if a command has
1056          * been interrupted by a keypress.
1057          */
1058         sigcaught = 0;
1059
1060         /* Switch color support on or off if we're in user mode */
1061         if (rc_ansi_color == 3) {
1062                 if (userflags & US_COLOR)
1063                         enable_color = 1;
1064                 else
1065                         enable_color = 0;
1066         }
1067         /* if we're running in idiot mode, display a cute little menu */
1068         IFNEXPERT formout(ipc, "mainmenu");
1069
1070         print_express();
1071         strcpy(argbuf, "");
1072         cmdpos = 0;
1073         for (a = 0; a < 5; ++a)
1074                 cmdbuf[a] = 0;
1075         /* now the room prompt... */
1076         ok_to_interrupt = 1;
1077         color(BRIGHT_WHITE);
1078         scr_printf("\n%s", room_name);
1079         color(DIM_WHITE);
1080         scr_printf("%c ", room_prompt(room_flags));
1081         scr_flush();
1082
1083         while (1) {
1084                 ch = inkey();
1085                 ok_to_interrupt = 0;
1086
1087                 /* Handle the backspace key, but only if there's something
1088                  * to backspace over...
1089                  */
1090                 if ((ch == 8) && (cmdpos > 0)) {
1091                         back(cmdspaces[cmdpos - 1] + 1);
1092                         cmdbuf[cmdpos] = 0;
1093                         --cmdpos;
1094                 }
1095                 /* Spacebar invokes "lazy traversal" commands */
1096                 if ((ch == 32) && (cmdpos == 0)) {
1097                         this_lazy_cmd = next_lazy_cmd;
1098                         if (this_lazy_cmd == 13)
1099                                 next_lazy_cmd = 5;
1100                         if (this_lazy_cmd == 5)
1101                                 next_lazy_cmd = 13;
1102                         for (cptr = cmdlist; cptr != NULL; cptr = cptr->next) {
1103                                 if (cptr->c_cmdnum == this_lazy_cmd) {
1104                                         for (a = 0; a < 5; ++a)
1105                                                 if (cptr->c_keys[a][0] != 0)
1106                                                         scr_printf("%s ", cmd_expand(
1107                                                                                         cptr->c_keys[a], 0));
1108                                         scr_printf("\n");
1109                                         return (this_lazy_cmd);
1110                                 }
1111                         }
1112                         scr_printf("\n");
1113                         return (this_lazy_cmd);
1114                 }
1115                 /* Otherwise, process the command */
1116                 cmdbuf[cmdpos] = tolower(ch);
1117
1118                 for (cptr = cmdlist; cptr != NULL; cptr = cptr->next) {
1119                         if (cmdmatch(cmdbuf, cptr, cmdpos + 1)) {
1120
1121                                 scr_printf("%s", cmd_expand(cptr->c_keys[cmdpos], 0));
1122                                 cmdspaces[cmdpos] = strlen(
1123                                     cmd_expand(cptr->c_keys[cmdpos], 0));
1124                                 if (cmdpos < 4)
1125                                         if ((cptr->c_keys[cmdpos + 1]) != 0)
1126                                                 scr_putc(' ');
1127                                 ++cmdpos;
1128                         }
1129                 }
1130
1131                 for (cptr = cmdlist; cptr != NULL; cptr = cptr->next) {
1132                         if (cmdmatch(cmdbuf, cptr, 5)) {
1133                                 /* We've found our command. */
1134                                 if (requires_string(cptr, cmdpos)) {
1135                                         getline(argbuf, 32);
1136                                 } else {
1137                                         scr_printf("\n");
1138                                 }
1139
1140                                 /* If this command is one that changes rooms,
1141                                  * then the next lazy-command (space bar)
1142                                  * should be "read new" instead of "goto"
1143                                  */
1144                                 if ((cptr->c_cmdnum == 5)
1145                                     || (cptr->c_cmdnum == 6)
1146                                     || (cptr->c_cmdnum == 47)
1147                                     || (cptr->c_cmdnum == 52)
1148                                     || (cptr->c_cmdnum == 16)
1149                                     || (cptr->c_cmdnum == 20))
1150                                         next_lazy_cmd = 13;
1151
1152                                 return (cptr->c_cmdnum);
1153
1154                         }
1155                 }
1156
1157                 if (ch == '?') {
1158                         pprintf("\rOne of ...                         \n");
1159                         for (cptr = cmdlist; cptr != NULL; cptr = cptr->next) {
1160                                 if (cmdmatch(cmdbuf, cptr, cmdpos)) {
1161                                         for (a = 0; a < 5; ++a) {
1162                                                 pprintf("%s ", cmd_expand(cptr->c_keys[a], 1));
1163                                         }
1164                                         pprintf("\n");
1165                                 }
1166                         }
1167
1168                         pprintf("\n%s%c ", room_name, room_prompt(room_flags));
1169                         got = 0;
1170                         for (cptr = cmdlist; cptr != NULL; cptr = cptr->next) {
1171                                 if ((got == 0) && (cmdmatch(cmdbuf, cptr, cmdpos))) {
1172                                         for (a = 0; a < cmdpos; ++a) {
1173                                                 pprintf("%s ",
1174                                                        cmd_expand(cptr->c_keys[a], 0));
1175                                         }
1176                                         got = 1;
1177                                 }
1178                         }
1179                 }
1180         }
1181
1182 }
1183
1184
1185
1186
1187
1188 /*
1189  * set tty modes.  commands are:
1190  *
1191  * 01- set to bbs mode
1192  * 2 - save current settings for later restoral
1193  * 3 - restore saved settings
1194  */
1195 #ifdef HAVE_TERMIOS_H
1196 void sttybbs(int cmd)
1197 {                               /* SysV version of sttybbs() */
1198         struct termios live;
1199         static struct termios saved_settings;
1200         static int last_cmd = 0;
1201
1202         if (cmd == SB_LAST)
1203                 cmd = last_cmd;
1204         else
1205                 last_cmd = cmd;
1206
1207         if ((cmd == 0) || (cmd == 1)) {
1208                 tcgetattr(0, &live);
1209                 live.c_iflag = ISTRIP | IXON | IXANY;
1210                 live.c_oflag = OPOST | ONLCR;
1211                 live.c_lflag = ISIG | NOFLSH;
1212
1213                 live.c_cc[VINTR] = 0;
1214                 live.c_cc[VQUIT] = 0;
1215
1216 #ifdef hpux
1217                 live.c_cc[VMIN] = 0;
1218                 live.c_cc[VTIME] = 0;
1219 #endif
1220
1221                 /* do we even need this stuff anymore? */
1222                 /* live.c_line=0; */
1223                 live.c_cc[VERASE] = 8;
1224                 live.c_cc[VKILL] = 24;
1225                 live.c_cc[VEOF] = 1;
1226                 live.c_cc[VEOL] = 255;
1227                 live.c_cc[VEOL2] = 0;
1228                 live.c_cc[VSTART] = 0;
1229                 tcsetattr(0, TCSADRAIN, &live);
1230         }
1231         if (cmd == 2) {
1232                 tcgetattr(0, &saved_settings);
1233         }
1234         if (cmd == 3) {
1235                 tcsetattr(0, TCSADRAIN, &saved_settings);
1236         }
1237
1238 }
1239 #else
1240 void sttybbs(int cmd)
1241 {                               /* BSD version of sttybbs() */
1242         struct sgttyb live;
1243         static struct sgttyb saved_settings;
1244         static int last_cmd = 0;
1245
1246         if (cmd == SB_LAST)
1247                 cmd = last_cmd;
1248         else
1249                 last_cmd = cmd;
1250
1251         if ((cmd == 0) || (cmd == 1)) {
1252                 gtty(0, &live);
1253                 live.sg_flags |= CBREAK;
1254                 live.sg_flags |= CRMOD;
1255                 live.sg_flags |= NL1;
1256                 live.sg_flags &= ~ECHO;
1257                 if (cmd == 1)
1258                         live.sg_flags |= NOFLSH;
1259                 stty(0, &live);
1260         }
1261         if (cmd == 2) {
1262                 gtty(0, &saved_settings);
1263         }
1264         if (cmd == 3) {
1265                 stty(0, &saved_settings);
1266         }
1267 }
1268 #endif
1269
1270
1271 /*
1272  * display_help()  -  help file viewer
1273  */
1274 void display_help(CtdlIPC *ipc, char *name)
1275 {
1276         formout(ipc, name);
1277 }
1278
1279
1280 /*
1281  * fmout() - Citadel text formatter and paginator
1282  */
1283 int fmout(
1284         int width,      /* screen width to use */
1285         FILE *fpin,     /* file to read from, or NULL to format given text */
1286         char *text,     /* text to be formatted (when fpin is NULL */
1287         FILE *fpout,    /* file to write to, or NULL to write to screen */
1288         char pagin,     /* nonzero if we should use the paginator */
1289         int height,     /* screen height to use */
1290         int starting_lp,/* starting value for lines_printed, -1 for global */
1291         int subst)      /* nonzero if we should use hypertext mode */
1292 {
1293         char *buffer = NULL;    /* The current message */
1294         char *word = NULL;      /* What we are about to actually print */
1295         char *e;                /* Pointer to position in text */
1296         char old = 0;           /* The previous character */
1297         int column = 0;         /* Current column */
1298         size_t i;               /* Generic counter */
1299
1300         num_urls = 0;   /* Start with a clean slate of embedded URL's */
1301
1302         /* Space for a single word, which can be at most screenwidth */
1303         word = (char *)calloc(1, width);
1304         if (!word) {
1305                 err_printf("Can't alloc memory to print message: %s!\n",
1306                                 strerror(errno));
1307                 logoff(NULL, 3);
1308         }
1309
1310         /* Read the entire message body into memory */
1311         if (fpin) {
1312                 buffer = load_message_from_file(fpin);
1313                 if (!buffer) {
1314                         err_printf("Can't print message: %s!\n",
1315                                         strerror(errno));
1316                         logoff(NULL, 3);
1317                 }
1318         } else {
1319                 buffer = text;
1320         }
1321         e = buffer;
1322
1323         if (starting_lp >= 0)
1324                 lines_printed = starting_lp;
1325
1326         /* Run the message body */
1327         while (*e) {
1328                 /* Catch characters that shouldn't be there at all */
1329                 if (*e == '\r') {
1330                         e++;
1331                         continue;
1332                 }
1333                 /* First, are we looking at a newline? */
1334                 if (*e == '\n') {
1335                         e++;
1336                         if (*e == ' ') {        /* Paragraph */
1337                                 if (fpout) {
1338                                         fprintf(fpout, "\n");
1339                                 } else {
1340                                         scr_printf("\n");
1341                                         ++lines_printed;
1342                                         lines_printed = checkpagin(lines_printed, pagin, height);
1343                                 }
1344                                 column = 0;
1345                         } else if (old != ' ') {/* Don't print two spaces */
1346                                 if (fpout) {
1347                                         fprintf(fpout, " ");
1348                                 } else {
1349                                         scr_printf(" ");
1350                                 }
1351                                 column++;
1352                         }
1353                         old = '\n';
1354                         continue;
1355                 }
1356                 /* Or are we looking at a space? */
1357                 if (*e == ' ') {
1358                         e++;
1359                         if (column >= width - 1) {
1360                                 /* Are we in the rightmost column? */
1361                                 if (fpout) {
1362                                         fprintf(fpout, "\n");
1363                                 } else {
1364                                         scr_printf("\n");
1365                                         ++lines_printed;
1366                                         lines_printed = checkpagin(lines_printed, pagin, height);
1367                                 }
1368                                 column = 0;
1369                         } else if (!(column == 0 && old == ' ')) {
1370                                 /* Eat only the first space on a line */
1371                                 if (fpout) {
1372                                         fprintf(fpout, " ");
1373                                 } else {
1374                                         scr_printf(" ");
1375                                 }
1376                                 column++;
1377                         }
1378                         /* ONLY eat the FIRST space on a line */
1379                         old = ' ';
1380                         continue;
1381                 }
1382                 old = *e;
1383
1384                 /* Read a word, slightly messy */
1385                 i = 0;
1386                 while (e[i]) {
1387                         if (!isprint(e[i]) && !isspace(e[i]))
1388                                 e[i] = ' ';
1389                         if (isspace(e[i]))
1390                                 break;
1391                         i++;
1392                 }
1393
1394                 /* We should never see these, but... slightly messy */
1395                 if (e[i] == '\t' || e[i] == '\f' || e[i] == '\v')
1396                         e[i] = ' ';
1397
1398                 /*
1399                  * Check for and copy URLs
1400                  * We will get the entire URL even if it's longer than the
1401                  * screen width, as long as the server didn't break it up
1402                  */
1403                 if (!strncasecmp(e, "http://", 7) ||
1404                     !strncasecmp(e, "ftp://", 6)) {
1405                         int j;
1406
1407                         strncpy(urls[num_urls], e, i);
1408                         urls[num_urls][i] = 0;
1409                         for (j = 0; j < strlen(e); j++) {
1410                                 char c;
1411
1412                                 c = urls[num_urls][j];
1413                                 if (c == '>' || c == '\"' || c == ')' ||
1414                                     c == ' ' || c == '\n') {
1415                                         urls[num_urls][j] = 0;
1416                                         break;
1417                                 }
1418                         }
1419                         num_urls++;
1420                 }
1421
1422                 /* Break up really long words */
1423                 /* TODO: auto-hyphenation someday? */
1424                 if (i >= width)
1425                         i = width - 1;
1426                 strncpy(word, e, i);
1427                 word[i] = 0;
1428
1429                 /* Decide where to print the word */
1430                 if (column + i >= width) {
1431                         /* Wrap to the next line */
1432                         if (fpout) {
1433                                 fprintf(fpout, "\n");
1434                         } else {
1435                                 scr_printf("\n");
1436                                 ++lines_printed;
1437                                 lines_printed = checkpagin(lines_printed, pagin, height);
1438                         }
1439                         column = 0;
1440                 }
1441
1442                 /* Print the word */
1443                 if (fpout) {
1444                         fprintf(fpout, "%s", word);
1445                 } else {
1446                         scr_printf("%s", word);
1447                 }
1448                 column += i;
1449                 e += i;         /* Start over with the whitepsace! */
1450         }
1451
1452         free(word);
1453         if (fpin)               /* We allocated this, remember? */
1454                 free(buffer);
1455
1456         /* Is this necessary?  It makes the output kind of spacey. */
1457         if (fpout) {
1458                 fprintf(fpout, "\n");
1459         } else {
1460                 scr_printf("\n");
1461                 ++lines_printed;
1462                 lines_printed = checkpagin(lines_printed, pagin, height);
1463         }
1464
1465         return sigcaught;
1466 }
1467
1468
1469 /*
1470  * support ANSI color if defined
1471  */
1472 void color(int colornum)
1473 {
1474         static int hold_color;
1475         static int current_color;
1476
1477         if (colornum == COLOR_PUSH) {
1478                 hold_color = current_color;
1479                 return;
1480         }
1481
1482         if (colornum == COLOR_POP) {
1483                 color(hold_color);
1484                 return;
1485         }
1486
1487         current_color = colornum;
1488         if (enable_color) {
1489 #if defined(HAVE_CURSES_H) && !defined(DISABLE_CURSES)
1490                 if (scr_color(colornum))
1491                         return;
1492 #endif
1493                 /* When switching to dim white, actually output an 'original
1494                  * pair' sequence -- this looks better on black-on-white
1495                  * terminals. - Changed to ORIGINAL_PAIR as this actually
1496                  * wound up looking horrible on black-on-white terminals, not
1497                  * to mention transparent terminals.
1498                  */
1499                 if (colornum == ORIGINAL_PAIR)
1500                         printf("\033[0;39;49m");
1501                 else
1502                         printf("\033[%d;3%d;4%dm",
1503                                         (colornum & 8) ? 1 : 0,
1504                                         (colornum & 7),
1505                                         rc_color_use_bg);
1506
1507                 scr_flush();
1508         }
1509 }
1510
1511 void cls(int colornum)
1512 {
1513         if (enable_color) {
1514                 printf("\033[4%dm\033[2J\033[H\033[0m",
1515                                 colornum ? colornum : rc_color_use_bg);
1516                 scr_flush();
1517         }
1518 }
1519
1520
1521 /*
1522  * Detect whether ANSI color is available (answerback)
1523  */
1524 void send_ansi_detect(void)
1525 {
1526         if (rc_ansi_color == 2) {
1527                 printf("\033[c");
1528                 scr_flush();
1529                 time(&AnsiDetect);
1530         }
1531 }
1532
1533 void look_for_ansi(void)
1534 {
1535         fd_set rfds;
1536         struct timeval tv;
1537         char abuf[512];
1538         time_t now;
1539         int a;
1540
1541         if (rc_ansi_color == 0) {
1542                 enable_color = 0;
1543         } else if (rc_ansi_color == 1) {
1544                 enable_color = 1;
1545         } else if (rc_ansi_color == 2) {
1546
1547                 /* otherwise, do the auto-detect */
1548
1549                 strcpy(abuf, "");
1550
1551                 time(&now);
1552                 if ((now - AnsiDetect) < 2)
1553                         sleep(1);
1554
1555                 do {
1556                         FD_ZERO(&rfds);
1557                         FD_SET(0, &rfds);
1558                         tv.tv_sec = 0;
1559                         tv.tv_usec = 1;
1560
1561                         select(1, &rfds, NULL, NULL, &tv);
1562                         if (FD_ISSET(0, &rfds)) {
1563                                 abuf[strlen(abuf) + 1] = 0;
1564                                 read(0, &abuf[strlen(abuf)], 1);
1565                         }
1566                 } while (FD_ISSET(0, &rfds));
1567
1568                 for (a = 0; a < strlen(abuf); ++a) {
1569                         if ((abuf[a] == 27) && (abuf[a + 1] == '[')
1570                             && (abuf[a + 2] == '?')) {
1571                                 enable_color = 1;
1572                         }
1573                 }
1574         }
1575 }
1576
1577
1578 /*
1579  * Display key options (highlight hotkeys inside angle brackets)
1580  */
1581 void keyopt(char *buf) {
1582         int i;
1583
1584         color(DIM_WHITE);
1585         for (i=0; i<strlen(buf); ++i) {
1586                 if (buf[i]=='<') {
1587                         scr_putc(buf[i]);
1588                         color(BRIGHT_MAGENTA);
1589                 } else {
1590                         if (buf[i]=='>') {
1591                                 color(DIM_WHITE);
1592                         }
1593                         scr_putc(buf[i]);
1594                 }
1595         }
1596         color(DIM_WHITE);
1597 }
1598
1599
1600
1601 /*
1602  * Present a key-menu line choice type of thing
1603  */
1604 char keymenu(char *menuprompt, char *menustring) {
1605         int i, c, a;
1606         int choices;
1607         int do_prompt = 0;
1608         char buf[1024];
1609         int ch;
1610         int display_prompt = 1;
1611
1612         choices = num_tokens(menustring, '|');
1613
1614         if (menuprompt != NULL) do_prompt = 1;
1615         if (menuprompt != NULL) if (strlen(menuprompt)==0) do_prompt = 0;
1616
1617         while (1) {
1618                 if (display_prompt) {
1619                         if (do_prompt) {
1620                                 scr_printf("%s ", menuprompt);
1621                         }
1622                         else {
1623                                 for (i=0; i<choices; ++i) {
1624                                         extract(buf, menustring, i);
1625                                         keyopt(buf);
1626                                         scr_printf(" ");
1627                                 }
1628                         }
1629                         scr_printf(" -> ");
1630                         display_prompt = 0;
1631                 }
1632                 ch = lkey();
1633
1634                 if ( (do_prompt) && (ch=='?') ) {
1635                         scr_printf("\rOne of...                               ");
1636                         scr_printf("                                      \n");
1637                         for (i=0; i<choices; ++i) {
1638                                 extract(buf, menustring, i);
1639                                 scr_printf("   ");
1640                                 keyopt(buf);
1641                                 scr_printf("\n");
1642                         }
1643                         scr_printf("\n");
1644                         display_prompt = 1;
1645                 }
1646
1647                 for (i=0; i<choices; ++i) {
1648                         extract(buf, menustring, i);
1649                         for (c=1; c<strlen(buf); ++c) {
1650                                 if ( (ch == tolower(buf[c]))
1651                                    && (buf[c-1]=='<')
1652                                    && (buf[c+1]=='>') ) {
1653                                         for (a=0; a<strlen(buf); ++a) {
1654                                                 if ( (a!=(c-1)) && (a!=(c+1))) {
1655                                                         scr_putc(buf[a]);
1656                                                 }
1657                                         }
1658                                         scr_printf("\n\n");
1659                                         return ch;
1660                                 }
1661                         }
1662                 }
1663         }
1664 }