citadel/commands.c

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