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