textclient/commands.c

   1 // This file contains functions which implement parts of the
   2 // text-mode user interface.
   3 //
   4 // Copyright (c) 1987-2022 by the citadel.org team
   5 //
   6 // This program is open source software.  Use, duplication, and/or
   7 // disclosure are subject to the GNU General Purpose License version 3.
   8 //
   9 // This program is distributed in the hope that it will be useful,
  10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 // GNU General Public License for more details.
  13
  14 #include "textclient.h"
  15
  16
  17 // The help "files" are now just an embedded set of Very Long Strings.  helpnames[] is
  18 // an array of "file names" and helptexts[] is the "content".
  19
  20 char *helpnames[] = {
  21         "help",
  22         "admin",
  23         "floors",
  24         "intro",
  25         "mail",
  26         "network",
  27         "software",
  28         "summary"
  29 };
  30
  31 char *helptexts[] = {
  32
  33         // <.H>elp HELP
  34         "                          Citadel Help Menu\n"
  35             "  \n"
  36             " ?         Help. (Typing a '?' will give you a menu almost anywhere)\n"
  37             " A         Abandon this room where you stopped reading, goto next room.\n"
  38             " C         Chat (multiuser chat, where available)\n"
  39             " D         Prints directory, if there is one in the current room.\n"
  40             " E         Enter a message.\n"
  41             " F         Read all messages in the room, forward.\n"
  42             " G         Goto next room which has UNREAD messages.\n"
  43             " H         Help. Same as '?'\n"
  44             " I         Reads the Information file for this room.\n"
  45             " K         List of Known rooms.\n"
  46             " L         Reads the last five messages in the room.\n"
  47             " N         Reads all new messages in the room.\n"
  48             " O         Reads all old messages, backwards.\n"
  49             " P         Page another user (send an instant message)\n"
  50             " R         Reads all messages in the room, in reverse order.\n"
  51             " S         Skips current room without making its messages old.\n"
  52             " T         Terminate (logout)\n"
  53             " U         Ungoto (returns to the last room you were in)\n"
  54             " W         Displays who is currently logged in.\n"
  55             " X         Toggle eXpert mode (menus and help blurbs on/off)\n"
  56             " Z         Zap (forget) room. (Removes the room from your list)\n"
  57             " + -       Goto next, previous room on current floor.\n"
  58             " > <       Goto next, previous floor.\n"
  59             "   \n"
  60             " In addition, there are dot commands. You hit the . (dot), then press the\n"
  61             "first letter of each word of the command. As you hit the letters, the words\n"
  62             "pop onto your screen. Exceptions: after you hit .Help or .Goto, the remainder\n"
  63             "of the command is a help file name or room name.\n"
  64             "    \n"
  65             "      *** USE  .<H>elp ?    for additional help *** \n",
  66
  67         // <.H>elp ADMIN
  68         "The following commands are available only to Admins.  A subset of these\n"
  69             "commands are available to room aides when they are currently in the room\n"
  70             "they are room aide for.\n"
  71             "\n"
  72             " <.> <A>dmin <K>ill this room   (Delete the current room)\n"
  73             " <.> <A>dmin <E>dit this room   (Edit the current room's parameters)\n"
  74             " <.> <A>dmin <W>ho knows room   (List users with access to this room)\n"
  75             " <.> <A>dmin edit <U>ser        (Change user's access level, password, etc.)\n"
  76             " <.> <A>dmin <V>alidate new users   (Process new user registrations)\n"
  77             " <.> <A>dmin enter <I>nfo file      (Create/change this room's banner)\n"
  78             " <.> <A>dmin <R>oom <I>nvite user   (Grant access to an invitation-only room)\n"
  79             " <.> <A>dmin <R>oom <K>ick out user (Revoke access to an invitation-only room)\n"
  80             " <.> <A>dmin <F>ile <D>elete        (Delete a file from the room's directory)\n"
  81             " <.> <A>dmin <F>ile <S>end over net (Transmit a file to another node)\n"
  82             " <.> <A>dmin <F>ile <M>ove          (Move a file to another room's directory)\n"
  83             " <.> <A>dmin <M>essage edit:        (Edit system banners)\n"
  84             " <.> <A>dmin <P>ost                 (Post a message on behalf of another user)\n"
  85             " <.> <A>dmin <S>ystem configuration <G>eneral   (Edit global site config)\n"
  86             " <.> <A>dmin <S>ystem configuration <I>nternet  (Edit Internet domains)\n"
  87             " <.> <A>dmin <S>ystem configuration check <M>essage base   (Internal checks)\n"
  88             " <.> <A>dmin <S>ystem configuration <N>etwork   (Netting with other Citadels)\n"
  89             " <.> <A>dmin <S>ystem configuration network <F>ilter list\n"
  90             " <.> <A>dmin <T>erminate server <N>ow          (Shut down Citadel server now)\n"
  91             " <.> <A>dmin <T>erminate server <S>cheduled    (Shut down Citadel server later)\n"
  92             " <.> <A>dmin mailing <L>ist recipients         (For mailing list rooms)\n"
  93             " <.> <A>dmin mailing list <D>igest recipients  (For mailing list rooms)\n"
  94             " <.> <A>dmin <N>etwork room sharing     (Replication with other Citadels)\n"
  95             " \n" " In addition, the <M>ove and <D>elete commands are available at the\n" "message prompt.\n",
  96
  97         // <.H>elp FLOORS
  98         " Floors\n"
  99             " ------\n"
 100             "   Floors in Citadel are used to group rooms into related subject areas,\n"
 101             "just as rooms are used to group messages into manageable groups.\n"
 102             " \n"
 103             "   You, as a user, do NOT have to use floors.  If you choose not to, you suffer\n"
 104             "no penalty; you will not lose access to any rooms.  You may use .EC or ;C (the\n"
 105             "latter is easier to use) to decide if you want to use floors.  Feel free to\n"
 106             "experiment.\n"
 107             " \n"
 108             "   Floor options are accessed two ways.  First, if you are in floor mode, the\n"
 109             "<G>oto and <S>kip commands take you to the next room with new messages on the\n"
 110             "current floor; if there are none left, then the system will automatically\n"
 111             "switch floors (and let you know) and put you in the first room with new messages\n"
 112             "on that level.  (Notice that your pattern of basic use of Citadel therefore\n"
 113             "doesn't really change.)\n"
 114             " \n"
 115             "   Direct access to floor options is via the use of a ';' command.\n"
 116             "The following commands are currently available (more can be\n"
 117             "added if needed):\n"
 118             " \n"
 119             " <;C>onfigure\n"
 120             " This command toggles your floor mode.\n"
 121             " \n"
 122             " <;G>oto FLOORNAME\n"
 123             " This command causes the system to take you to the named floor.\n"
 124             " \n"
 125             " <;K>nown rooms on floors\n"
 126             " List all rooms on all floors.  This is a very readable way to get a list of\n"
 127             "all rooms on the system.\n"
 128             " \n"
 129             " <;S>kip FLOORNAME\n"
 130             " This command causes the system to mark all rooms on the current floor as\n"
 131             "Skipped and takes you to the floor that you specify.\n"
 132             " \n"
 133             " <;Z>Forget floor\n"
 134             "   This command causes you to forget all the rooms currently on the current\n"
 135             "floor.  Unfortunately, it doesn't apply to rooms that are subsequently created\n"
 136             "or moved to this floor.  (Sorry.)\n"
 137             " \n"
 138             "   Feel free to experiment, you can't hurt yourself or the system with the\n"
 139             "floor stuff unless you ZForget a floor by accident.\n",
 140
 141         // <.H>elp INTRO
 142         "                  New User's Introduction to the site\n"
 143             "  \n"
 144             " This is an introduction to the Citadel BBS concept.  It is intended\n"
 145             "for new users so that they can more easily become acquainted to using\n"
 146             "Citadel when accessing it in the form of a text-based BBS.  Of\n"
 147             "course, old users might learn something new each time they read\n"
 148             "through it.\n"
 149             " \n"
 150             " Full help for the BBS commands can be obtained by typing <.H>elp SUMMARY\n"
 151             "  \n"
 152             " The CITADEL BBS room concept\n"
 153             " ----------------------------\n"
 154             "   The term BBS stands for 'Bulletin Board System'.  The analogy is\n"
 155             "appropriate: one posts messages so that others may read them.  In\n"
 156             "order to organize the posts, people can post in different areas of the\n"
 157             "BBS, called rooms.\n"
 158             "   In order to post in a certain room, you need to be 'in' that room.\n"
 159             "Your current prompt is usually the room that you are in, followed the\n"
 160             "greater-than-sign, such as:\n"
 161             " \n"
 162             " Lobby>\n"
 163             " \n"
 164             " The easiest way to traverse the room structure is with the 'Goto'\n"
 165             "command, on the 'G' key.  Pressing 'G' will take you to the next room\n"
 166             "in the 'march list' (see below) that has new messages in it.  You can\n"
 167             "read these new messages with the 'N' key.\n"
 168             " Once you've 'Gotoed' every room in the system (or all of the ones\n"
 169             "you choose to read) you return to the 'Lobby,' the first and last room\n"
 170             "in the system.  If new messages get posted to rooms you've already\n"
 171             "read during your session you will be brought BACK to those rooms so\n"
 172             "you can read them.\n"
 173             " \n"
 174             " March List\n"
 175             " ----------\n"
 176             "   All the room names are stored in a march list, which is just a\n"
 177             "list containing all the room names.  When you <G>oto or <S>kip a\n"
 178             "room, you are placed in the next room in your march list THAT HAS NEW\n"
 179             "MESSAGES.  If you have no new messages in any of the rooms on your\n"
 180             "march list, you will keep going to the Lobby>.  You can choose not to\n"
 181             "read certain rooms (that don't interest you) by 'Z'apping them.  When\n"
 182             "you <Z>ap a room, you are merely deleting it from your march list (but\n"
 183             "not from anybody else's).\n"
 184             " \n"
 185             "   You can use the <.G>oto (note the period before the G.  You can also use\n"
 186             "<J>ump on some systems) to go to any room in the\n"
 187             "system.  You don't have to type in the complete name of a room to\n"
 188             "'jump' to it; you merely need to type in enough to distinguish it from\n"
 189             "the other rooms.  Left-aligned matches carry a heavier weight, so if you\n"
 190             "typed (for example) '.Goto TECH', you might be taken to a room called\n"
 191             "'Tech Area>' even if it found a room called 'Biotech/Ethics>' first.\n"
 192             " \n"
 193             "  To return to a room you have previously <Z>apped, use the <.G>oto command\n"
 194             "to enter it, and it will be re-inserted into your march list.  In the case\n"
 195             "of returning to Zapped rooms, you must type the room name in its entirety.\n"
 196             "REMEMBER, rooms with no new messages will not show on your\n"
 197             "march list!  You must <.G>oto to a room with no new messages.\n"
 198             "Incidentally, you cannot change the order of the rooms on your march list.\n"
 199             "It's the same for everybody.\n"
 200             " \n"
 201             " Special rooms\n"
 202             " -------------\n"
 203             "   There are two special rooms on a Citadel that you should know about.\n"
 204             "  \n"
 205             "   The first is the Lobby>.  It's used for system announcements and other\n"
 206             "such administrativia.  You cannot <Z>ap the Lobby>.  Each time you first\n"
 207             "login, you will be placed in the Lobby>.\n"
 208             " \n"
 209             "   The second is Mail>.  In Mail>, when you post a messages, you are\n"
 210             "prompted to enter the screen name of the person who you want to send the\n"
 211             "message to.  Only the person who you send the message to can read the\n"
 212             "message.  NO ONE else can read it, not even the admins.  Mail> is the\n"
 213             "first room on the march list, and is un-<Z>appable, so you can be sure\n"
 214             "that the person will get the message.\n"
 215             "   \n"
 216             " System admins\n"
 217             " -------------\n"
 218             "   These people, along with the room admins, keep the site running smoothly.\n"
 219             "\n"
 220             "   Among the many things that admins do are: create rooms, delete\n"
 221             "rooms, set access levels, invite users, check registration, grant\n"
 222             "room admin status, and countless other things.  They have access to the\n"
 223             "Aide> room, a special room only for admins.\n"
 224             " \n"
 225             "   If you enter a mail message to 'Sysop' it will be placed in the\n"
 226             "Aide> room so that the next admin online will read it and deal with it.\n"
 227             "Admins cannot <Z>ap rooms.  All the rooms are always on each admin's\n"
 228             "march list.  Admins can read *any* and *every* room, but they *CAN* *NOT*\n"
 229             "read other users' Mail!\n"
 230             "  \n"
 231             " Room admins\n"
 232             " -----------\n"
 233             "   Room admins are granted special privileges in specific rooms.\n"
 234             "They are *NOT* true system admins; their power extends only over the\n"
 235             "rooms that they control, and they answer to the system admins.\n"
 236             "  \n"
 237             "   A room admin's job is to keep the topic of the their room on track,\n"
 238             "with nudges in the right direction now and then.  A room admin can also\n"
 239             "move an off topic post to another room, or delete a post, if he/she\n"
 240             "feels it is necessary. \n"
 241             "  \n"
 242             "   Currently, very few rooms have room admins.  Most rooms do not need\n"
 243             "their own specific room admin.  Being a room admin requires a certain\n"
 244             "amount of trust, due to the additional privileges granted.\n"
 245             "  \n"
 246             " Citadel messages\n"
 247             " ----------------\n"
 248             "   Most of the time, the BBS code does not print a lot of messages\n"
 249             "to your screen.  This is a great benefit once you become familiar\n"
 250             "with the system, because you do not have endless menus and screens\n"
 251             "to navigate through.  nevertheless, there are some messages which you\n"
 252             "might see from time to time.\n"
 253             "  \n"
 254             "  'There were messages posted while you were entering.'\n"
 255             "  \n"
 256             "   This is also known as 'simulposting.'  When you start entering a \n"
 257             "message, the system knows where you last left off.  When you save\n"
 258             "your message, the system checks to see if any messages were entered\n"
 259             "while you were typing.  This is so that you know whether you need\n"
 260             "to go back and re-read the last few messages.  This message may appear\n"
 261             "in any room.\n"
 262             "   \n"
 263             " '*** You have new mail'\n"
 264             "  \n"
 265             "   This message is essentially the same as the above message, but can\n"
 266             "appear at any time.  It simply means that new mail has arrived for you while\n"
 267             "you are logged in.  Simply go to the Mail> room to read it.\n"
 268             "  \n"
 269             " Who list\n"
 270             " --------\n"
 271             "   The <W>ho command shows you the names of all users who are currently\n"
 272             "online.  It also shows you the name of the room they are currently in.  If\n"
 273             "they are in any type of private room, however, the room name will simply\n"
 274             "display as '<private room>'.  Along with this information is displayed the\n"
 275             "name of the host computer the user is logged in from.\n",
 276
 277         // <.H>elp MAIL
 278         "To send mail on this system, go to the Mail> room (using the command .G Mail)\n"
 279             "and press E to enter a message.  You will be prompted with:\n"
 280             " \n"
 281             " Enter Recipient:\n"
 282             " \n"
 283             "   At this point you may enter the name of another user on the system.  Private\n"
 284             "mail is only readable by the sender and recipient.  There is no need to delete\n"
 285             "mail after it is read; it will scroll out automatically.\n"
 286             "  \n"
 287             "   To send mail to another user on the Citadel network, simply type the\n"
 288             "user's name, followed by @ and then the system name. For example,\n"
 289             "  \n"
 290             " Enter Recipient: Joe Schmoe @ citadrool\n"
 291             "  \n"
 292             "  If your account is enabled for Internet mail, you can also send email to\n"
 293             "anyone on the Internet here.  Simply enter their address at the prompt:\n"
 294             "  \n" " Enter Recipient: ajc@herring.fishnet.com\n",
 295
 296         // <.H>elp NETWORK
 297         "  Welcome to the network. Messages entered in a network room will appear in\n"
 298             "that room on all other systems carrying it (The name of the room, however,\n" "may be different on other systems).\n",
 299
 300         // <.H>elp SOFTWARE
 301         "   Citadel is the premier 'online community' (i.e. Bulletin Board System)\n"
 302             "software.  It runs on all POSIX-compliant systems, including Linux.  It is an\n"
 303             "advanced client/server application, and is being actively maintained.\n"
 304             " \n" "   For more info, visit UNCENSORED! BBS at uncensored.citadel.org\n",
 305
 306         // <.H>elp SUMMARY
 307         "Extended commands are available using the period ( . ) key. To use\n"
 308             "a dot command, press the . key, and then enter the first letter of\n"
 309             "each word in the command. The words will appear as you enter the keys.\n"
 310             "You can also backspace over partially entered commands. The following\n"
 311             "commands are available:\n"
 312             "\n"
 313             " <.> <H>elp:    Displays help files.  Type .H followed by a help file\n"
 314             "                name.  You are now reading <.H>elp SUMMARY\n"
 315             " \n"
 316             " <.> <G>oto:    Jumps directly to the room you specify.  You can also\n"
 317             "                type a partial room name, just enough to make it unique,\n"
 318             "                and it'll find the room you're looking for.  As with the\n"
 319             "                regular <G>oto command, messages in the current room will\n"
 320             "                be marked as read.\n"
 321             " \n"
 322             " <.> <S>kip, goto:    This is similar to <.G>oto, except it doesn't mark\n"
 323             "                      messages in the current room as read.\n"
 324             " \n"
 325             " <.> list <Z>apped rooms      Shows all rooms you've <Z>apped (forgotten)\n"
 326             "\n"
 327             "  \n"
 328             " Terminate (logoff) commands:\n"
 329             " \n"
 330             " <.> <T>erminate and <Q>uit               Log off and disconnect.\n"
 331             " <.> <T>erminate and <S>tay online        Log in as a different user.\n"
 332             " \n"
 333             " \n"
 334             " Read commands:\n"
 335             "\n"
 336             " <.> <R>ead <N>ew messages                Same as <N>ew\n"
 337             " <.> <R>ead <O>ld msgs reverse            Same as <O>ld\n"
 338             " <.> <R>ead <L>ast five msgs              Same as <L>ast5\n"
 339             " <.> read <L>ast:                         Allows you to specify how many\n"
 340             "                                          messages you wish to read.\n"
 341             "\n"
 342             " <.> <R>ead <U>ser listing:               Lists all users on the system if\n"
 343             "                                          you just hit enter, otherwise\n"
 344             "                                          you can specify a partial match\n"
 345             "\n"
 346             " <.> <R>ead <T>extfile formatted          File 'download' commands.\n"
 347             " <.> <R>ead file using <X>modem   \n"
 348             " <.> <R>ead file using <Y>modem   \n"
 349             " <.> <R>ead file using <Z>modem   \n"
 350             " <.> <R>ead <F>ile unformatted   \n"
 351             " <.> <R>ead <D>irectory   \n"
 352             "\n"
 353             " <.> <R>ead <I>nfo file                   Read the room info file.\n"
 354             " <.> <R>ead <B>io                         Read other users' 'bio' files.\n"
 355             " <.> <R>ead <C>onfiguration               Display your 'preferences'.\n"
 356             " <.> <R>ead <S>ystem info                 Display system statistics.\n"
 357             "\n"
 358             " \n"
 359             " Enter commands:\n"
 360             "\n"
 361             " <.> <E>nter <M>essage                    Post a message in this room.\n"
 362             " <.> <E>nter message with <E>ditor        Post using a full-screen editor.\n"
 363             " <.> <E>nter <A>SCII message              Post 'raw' (use this when 'pasting'\n"
 364             "                                          a message from your clipboard).\n"
 365             "\n"
 366             " <.> <E>nter <P>assword                   Change your password.\n"
 367             " <.> <E>nter <C>onfiguration              Change your 'preferences'.\n"
 368             " <.> <E>nter a new <R>oom                 Create a new room.\n"
 369             " <.> <E>nter re<G>istration               Register (name, address, etc.)\n"
 370             " <.> <E>nter <B>io                        Enter/change your 'bio' file.\n"
 371             "\n"
 372             " <.> <E>nter <T>extfile                   File 'upload' commands.\n"
 373             " <.> <E>nter file using <X>modem   \n"
 374             " <.> <E>nter file using <Y>modem   \n"
 375             " <.> <E>nter file using <Z>modem   \n"
 376             "  \n"
 377             "  \n"
 378             "  Wholist commands:\n"
 379             " \n"
 380             " <.> <W>holist <L>ong             Same as <W>ho is online, but displays\n"
 381             "                                  more detailed information.\n"
 382             " <.> <W>holist <R>oomname         Masquerade your room name (other users\n"
 383             "                                  see the name you enter rather than the\n"
 384             "                                  actual name of the room you're in)\n"
 385             " <.> <W>holist <H>ostname         Masquerade your host name\n"
 386             " <.> <E>nter <U>sername           Masquerade your user name (Admins only)\n"
 387             " <.> <W>holist <S>tealth mode     Enter/exit 'stealth mode' (when in stealth\n"
 388             "                                  mode you are invisible on the wholist)\n"
 389             " \n"
 390             " \n"
 391             " Floor commands (if using floor mode)\n"
 392             " ;<C>onfigure floor mode            - turn floor mode on or off\n"
 393             " ;<G>oto floor:                     - jump to a specific floor\n"
 394             " ;<K>nown rooms                     - list all rooms on all floors\n"
 395             " ;<S>kip to floor:                  - skip current floor, jump to another\n"
 396             " ;<Z>ap floor                       - zap (forget) all rooms on this floor\n"
 397             " \n"
 398             " \n"
 399             " Administrative commands: \n"
 400             " \n"
 401             " <.> <A>dmin <K>ill this room   \n"
 402             " <.> <A>dmin <E>dit this room   \n"
 403             " <.> <A>dmin <W>ho knows room   \n"
 404             " <.> <A>dmin edit <U>ser   \n"
 405             " <.> <A>dmin <V>alidate new users   \n"
 406             " <.> <A>dmin enter <I>nfo file   \n"
 407             " <.> <A>dmin <R>oom <I>nvite user  \n"
 408             " <.> <A>dmin <R>oom <K>ick out user  \n"
 409             " <.> <A>dmin <F>ile <D>elete  \n"
 410             " <.> <A>dmin <F>ile <S>end over net  \n"
 411             " <.> <A>dmin <F>ile <M>ove  \n"
 412             " <.> <A>dmin <M>essage edit:   \n"
 413             " <.> <A>dmin <P>ost   \n"
 414             " <.> <A>dmin <S>ystem configuration   \n"
 415             " <.> <A>dmin <T>erminate server <N>ow\n" " <.> <A>dmin <T>erminate server <S>cheduled\n"
 416 };
 417
 418
 419 struct citcmd {
 420         struct citcmd *next;
 421         int c_cmdnum;
 422         int c_axlevel;
 423         char c_keys[5][64];
 424 };
 425
 426 #define IFNEXPERT if ((userflags&US_EXPERT)==0)
 427
 428
 429 int rc_exp_beep;
 430 char rc_exp_cmd[1024];
 431 int rc_allow_attachments;
 432 int rc_display_message_numbers;
 433 int rc_force_mail_prompts;
 434 int rc_remember_passwords;
 435 int rc_ansi_color;
 436 int rc_color_use_bg;
 437 int rc_prompt_control = 0;
 438 time_t rc_idle_threshold = (time_t) 900;
 439 char rc_url_cmd[SIZ];
 440 char rc_open_cmd[SIZ];
 441 char rc_gotmail_cmd[SIZ];
 442
 443 int next_lazy_cmd = 5;
 444
 445 extern int screenwidth, screenheight;
 446 extern int termn8;
 447 extern CtdlIPC *ipc_for_signal_handlers;        // KLUDGE cover your eyes
 448 struct citcmd *cmdlist = NULL;
 449
 450
 451 // these variables are local to this module
 452 char keepalives_enabled = KA_YES;               // send NOOPs to server when idle
 453 int ok_to_interrupt = 0;                        // print instant msgs asynchronously
 454 time_t AnsiDetect;                              // when did we send the detect code?
 455 int enable_color = 0;                           // nonzero for ANSI color
 456
 457
 458 // If an interesting key has been pressed, return its value, otherwise 0
 459 char was_a_key_pressed(void) {
 460         fd_set rfds;
 461         struct timeval tv;
 462         int the_character;
 463         int retval;
 464
 465         FD_ZERO(&rfds);
 466         FD_SET(0, &rfds);
 467         tv.tv_sec = 0;
 468         tv.tv_usec = 0;
 469         retval = select(1, &rfds, NULL, NULL, &tv);
 470
 471         // Careful!  Disable keepalives during keyboard polling; we're probably
 472         // in the middle of a data transfer from the server, in which case
 473         // sending a NOOP would throw the client protocol out of sync.
 474         if ((retval > 0) && FD_ISSET(0, &rfds)) {
 475                 set_keepalives(KA_NO);
 476                 the_character = inkey();
 477                 set_keepalives(KA_YES);
 478         }
 479         else {
 480                 the_character = 0;
 481         }
 482         return (the_character);
 483 }
 484
 485
 486 // display_instant_messages()  -  print instant messages if there are any
 487 void display_instant_messages(void) {
 488         char buf[1024];
 489         FILE *outpipe;
 490         time_t timestamp;
 491         struct tm stamp;
 492         int flags = 0;
 493         char sender[64];
 494         char node[64];
 495         char *listing = NULL;
 496         int r;                  // IPC result code
 497
 498         if (instant_msgs == 0) {
 499                 return;
 500         }
 501
 502         if (rc_exp_beep) {
 503                 ctdl_beep();
 504         }
 505
 506         if (IsEmptyStr(rc_exp_cmd)) {
 507                 color(BRIGHT_RED);
 508                 scr_printf("\r---");
 509         }
 510
 511         while (instant_msgs != 0) {
 512                 r = CtdlIPCGetInstantMessage(ipc_for_signal_handlers, &listing, buf);
 513                 if (r / 100 != 1) {
 514                         return;
 515                 }
 516
 517                 instant_msgs = extract_int(buf, 0);
 518                 timestamp = extract_long(buf, 1);
 519                 flags = extract_int(buf, 2);
 520                 extract_token(sender, buf, 3, '|', sizeof sender);
 521                 extract_token(node, buf, 4, '|', sizeof node);
 522                 strcpy(last_paged, sender);
 523
 524                 localtime_r(&timestamp, &stamp);
 525
 526                 // If the message contains a Logoff Request, honor it.
 527                 if (flags & 2) {
 528                         termn8 = 1;
 529                         return;
 530                 }
 531
 532                 if (!IsEmptyStr(rc_exp_cmd)) {
 533                         outpipe = popen(rc_exp_cmd, "w");
 534                         if (outpipe != NULL) {
 535                                 // Header derived from flags
 536                                 if (flags & 2)
 537                                         fprintf(outpipe, "Please log off now, as requested ");
 538                                 else if (flags & 1)
 539                                         fprintf(outpipe, "Broadcast message ");
 540                                 else if (flags & 4)
 541                                         fprintf(outpipe, "Chat request ");
 542                                 else
 543                                         fprintf(outpipe, "Message ");
 544                                 // Timestamp.  Can this be improved?
 545                                 if (stamp.tm_hour == 0 || stamp.tm_hour == 12)
 546                                         fprintf(outpipe, "at 12:%02d%cm", stamp.tm_min, stamp.tm_hour ? 'p' : 'a');
 547                                 else if (stamp.tm_hour > 12)    // pm
 548                                         fprintf(outpipe, "at %d:%02dpm", stamp.tm_hour - 12, stamp.tm_min);
 549                                 else    // am
 550                                         fprintf(outpipe, "at %d:%02dam", stamp.tm_hour, stamp.tm_min);
 551                                 fprintf(outpipe, " from %s", sender);
 552                                 if (strncmp(ipc_for_signal_handlers->ServInfo.nodename, node, 32))
 553                                         fprintf(outpipe, " @%s", node);
 554                                 fprintf(outpipe, ":\n%s\n", listing);
 555                                 pclose(outpipe);
 556                                 if (instant_msgs == 0)
 557                                         return;
 558                                 continue;
 559                         }
 560                 }
 561                 // fall back to built-in instant message display
 562                 scr_printf("\n");
 563
 564                 // Header derived from flags
 565                 if (flags & 2)
 566                         scr_printf("Please log off now, as requested ");
 567                 else if (flags & 1)
 568                         scr_printf("Broadcast message ");
 569                 else if (flags & 4)
 570                         scr_printf("Chat request ");
 571                 else
 572                         scr_printf("Message ");
 573
 574                 // Timestamp.  Can this be improved?
 575                 if (stamp.tm_hour == 0 || stamp.tm_hour == 12)  // 12am/12pm
 576                         scr_printf("at 12:%02d%cm", stamp.tm_min, stamp.tm_hour ? 'p' : 'a');
 577                 else if (stamp.tm_hour > 12)    // pm
 578                         scr_printf("at %d:%02dpm", stamp.tm_hour - 12, stamp.tm_min);
 579                 else            // am
 580                         scr_printf("at %d:%02dam", stamp.tm_hour, stamp.tm_min);
 581
 582                 // Sender
 583                 scr_printf(" from %s", sender);
 584
 585                 // Remote node, if any
 586                 if (strncmp(ipc_for_signal_handlers->ServInfo.nodename, node, 32))
 587                         scr_printf(" @%s", node);
 588
 589                 scr_printf(":\n");
 590                 fmout(screenwidth, NULL, listing, NULL, 0);
 591                 free(listing);
 592
 593         }
 594         scr_printf("\n---\n");
 595         color(BRIGHT_WHITE);
 596
 597
 598 }
 599
 600
 601 void set_keepalives(int s) {
 602         keepalives_enabled = (char) s;
 603 }
 604
 605
 606 // This loop handles the "keepalive" messages sent to the server when idling.
 607 static time_t idlet = 0;
 608 static void really_do_keepalive(void) {
 609         time(&idlet);
 610
 611         // This may sometimes get called before we are actually connected
 612         // to the server.  Don't do anything if we aren't connected. -IO
 613         if (!ipc_for_signal_handlers)
 614                 return;
 615
 616         // If full keepalives are enabled, send a NOOP to the server and
 617         // wait for a response.
 618         if (keepalives_enabled == KA_YES) {
 619                 CtdlIPCNoop(ipc_for_signal_handlers);
 620                 if (instant_msgs > 0) {
 621                         if (ok_to_interrupt == 1) {
 622                                 scr_printf("\r%64s\r", "");
 623                                 display_instant_messages();
 624                                 scr_printf("%s%c ", room_name, room_prompt(room_flags));
 625                                 scr_flush();
 626                         }
 627                 }
 628         }
 629
 630         // If half keepalives are enabled, send a QNOP to the server, then do nothing.
 631         if (keepalives_enabled == KA_HALF) {
 632                 CtdlIPC_chat_send(ipc_for_signal_handlers, "QNOP");
 633         }
 634 }
 635
 636
 637 // I changed this from static to not because I need to call it from
 638 // screen.c, either that or make something in screen.c not static.
 639 // Fix it how you like. Why all the staticness? stu
 640 void do_keepalive(void) {
 641         time_t now;
 642
 643         time(&now);
 644         if ((now - idlet) < ((long) S_KEEPALIVE)) {
 645                 return;
 646         }
 647
 648         // Do a space-backspace to keep terminal sessions from idling out
 649         scr_printf(" %c", 8);
 650         scr_flush();
 651
 652         really_do_keepalive();
 653 }
 654
 655
 656 // Get a character from the keyboard, with the watchdog timer in effect if necessary.
 657 int inkey(void) {
 658         int a;
 659         fd_set rfds;
 660         struct timeval tv;
 661         time_t start_time;
 662
 663         scr_flush();
 664         time(&start_time);
 665
 666         do {
 667                 // This loop waits for keyboard input.  If the keepalive
 668                 // timer expires, it sends a keepalive to the server if
 669                 // necessary and then waits again.
 670                 do {
 671                         do_keepalive();
 672
 673                         FD_ZERO(&rfds);
 674                         FD_SET(0, &rfds);
 675                         tv.tv_sec = S_KEEPALIVE;
 676                         tv.tv_usec = 0;
 677
 678                         select(1, &rfds, NULL, NULL, &tv);
 679                 } while (!FD_ISSET(0, &rfds));
 680
 681                 // At this point, there's input, so fetch it.
 682                 // (There's a hole in the bucket...)
 683                 a = scr_getc(SCR_BLOCK);
 684                 if (a == 127) {
 685                         a = 8;
 686                 }
 687                 if (a == 13) {
 688                         a = 10;
 689                 }
 690         } while (a == 0);
 691         return (a);
 692 }
 693
 694
 695 // Returns 1 for yes, 0 for no
 696 int yesno(void) {
 697         int a;
 698         while (1) {
 699                 a = inkey();
 700                 a = tolower(a);
 701                 if (a == 'y') {
 702                         scr_printf("Yes\n");
 703                         return (1);
 704                 }
 705                 if (a == 'n') {
 706                         scr_printf("No\n");
 707                         return (0);
 708                 }
 709         }
 710 }
 711
 712
 713 // Returns 1 for yes, 0 for no, arg is default value
 714 int yesno_d(int d) {
 715         int a;
 716         while (1) {
 717                 a = inkey();
 718                 a = tolower(a);
 719                 if (a == 10)
 720                         a = (d ? 'y' : 'n');
 721                 if (a == 'y') {
 722                         scr_printf("Yes\n");
 723                         return (1);
 724                 }
 725                 if (a == 'n') {
 726                         scr_printf("No\n");
 727                         return (0);
 728                 }
 729         }
 730 }
 731
 732
 733 // Function to read a line of text from the terminal.
 734 //
 735 // string               Pointer to string buffer
 736 // lim                  Maximum length
 737 // noshow               Echo asterisks instead of keystrokes?
 738 // bs                   Allow backspacing out of the prompt? (returns -1 if this happens)
 739 //
 740 // returns: string length
 741 int ctdl_getline(char *string, int lim, int noshow, int bs) {
 742         int pos = strlen(string);
 743         int ch;
 744
 745         if (noshow && !IsEmptyStr(string)) {
 746                 int num_stars = strlen(string);
 747                 while (num_stars--) {
 748                         scr_putc('*');
 749                 }
 750         } else {
 751                 scr_printf("%s", string);
 752         }
 753
 754         while (1) {
 755                 ch = inkey();
 756
 757                 if ((ch == 8) && (pos > 0)) {                   // backspace
 758                         --pos;
 759                         scr_putc(8);
 760                         scr_putc(32);
 761                         scr_putc(8);
 762                 }
 763
 764                 else if ((ch == 8) && (pos == 0) && (bs)) {     // backspace out of the prompt
 765                         return (-1);
 766                 }
 767
 768                 else if ((ch == 23) && (pos > 0)) {             // Ctrl-W deletes a word
 769                         while ((pos > 0) && !isspace(string[pos])) {
 770                                 --pos;
 771                                 scr_putc(8);
 772                                 scr_putc(32);
 773                                 scr_putc(8);
 774                         }
 775                         while ((pos > 0) && !isspace(string[pos - 1])) {
 776                                 --pos;
 777                                 scr_putc(8);
 778                                 scr_putc(32);
 779                                 scr_putc(8);
 780                         }
 781                 }
 782
 783                 else if (ch == 10) {                            // return
 784                         string[pos] = 0;
 785                         scr_printf("\n");
 786                         return (pos);
 787                 }
 788
 789                 else if (isprint(ch)) {                         // payload characters
 790                         scr_putc((noshow ? '*' : ch));
 791                         string[pos] = ch;
 792                         ++pos;
 793                 }
 794         }
 795 }
 796
 797
 798 // prompt for a string, print the existing value, and allow the user to press return to keep it...
 799 // If len is negative, pass the "noshow" flag to ctdl_getline()
 800 void strprompt(char *prompt, char *str, int len) {
 801         display_instant_messages();
 802         color(DIM_WHITE);
 803         scr_printf("%s", prompt);
 804         color(DIM_WHITE);
 805         scr_printf(": ");
 806         color(BRIGHT_CYAN);
 807         ctdl_getline(str, abs(len), (len < 0), 0);
 808         color(DIM_WHITE);
 809 }
 810
 811
 812 // prompt for a yes/no, print the existing value and allow the user to press return to keep it...
 813 int boolprompt(char *prompt, int prev_val) {
 814         int r;
 815
 816         color(DIM_WHITE);
 817         scr_printf("%s ", prompt);
 818         color(DIM_MAGENTA);
 819         scr_printf("[");
 820         color(BRIGHT_MAGENTA);
 821         scr_printf("%s", (prev_val ? "Yes" : "No"));
 822         color(DIM_MAGENTA);
 823         scr_printf("]: ");
 824         color(BRIGHT_CYAN);
 825         r = (yesno_d(prev_val));
 826         color(DIM_WHITE);
 827         return r;
 828 }
 829
 830
 831 // like strprompt(), except for an integer (note that it RETURNS the new value!)
 832 int intprompt(char *prompt, int ival, int imin, int imax) {
 833         char buf[16];
 834         int i;
 835         int p;
 836
 837         do {
 838                 i = ival;
 839                 snprintf(buf, sizeof buf, "%d", i);
 840                 strprompt(prompt, buf, 15);
 841                 i = atoi(buf);
 842                 for (p = 0; !IsEmptyStr(&buf[p]); ++p) {
 843                         if ((!isdigit(buf[p]))
 844                             && ((buf[p] != '-') || (p != 0)))
 845                                 i = imin - 1;
 846                 }
 847                 if (i < imin)
 848                         scr_printf("*** Must be no less than %d.\n", imin);
 849                 if (i > imax)
 850                         scr_printf("*** Must be no more than %d.\n", imax);
 851         } while ((i < imin) || (i > imax));
 852         return (i);
 853 }
 854
 855
 856 // prompt for a string with no existing value (clears out string buffer first)
 857 // If len is negative, pass the "noshow" flag to ctdl_getline()
 858 void newprompt(char *prompt, char *str, int len) {
 859         str[0] = 0;
 860         color(BRIGHT_MAGENTA);
 861         scr_printf("%s", prompt);
 862         color(DIM_MAGENTA);
 863         ctdl_getline(str, abs(len), (len < 0), 0);
 864         color(DIM_WHITE);
 865 }
 866
 867
 868 // returns a lower case value
 869 int lkey(void) {
 870         int a;
 871         a = inkey();
 872         if (isupper(a))
 873                 a = tolower(a);
 874         return (a);
 875 }
 876
 877
 878 // parse the citadel.rc file
 879 void load_command_set(void) {
 880         FILE *ccfile;
 881         char buf[1024];
 882         struct citcmd *cptr;
 883         struct citcmd *lastcmd = NULL;
 884         int a, d;
 885         int b = 0;
 886
 887         // first, set up some defaults for non-required variables
 888         strcpy(editor_path, "");
 889         strcpy(printcmd, "");
 890         strcpy(imagecmd, "");
 891         strcpy(rc_username, "");
 892         strcpy(rc_password, "");
 893         rc_floor_mode = 0;
 894         rc_exp_beep = 1;
 895         rc_allow_attachments = 0;
 896         rc_remember_passwords = 0;
 897         strcpy(rc_exp_cmd, "");
 898         rc_display_message_numbers = 0;
 899         rc_force_mail_prompts = 0;
 900         rc_ansi_color = 0;
 901         rc_color_use_bg = 0;
 902         strcpy(rc_url_cmd, "");
 903         strcpy(rc_open_cmd, "");
 904         strcpy(rc_gotmail_cmd, "");
 905 #ifdef HAVE_OPENSSL
 906         rc_encrypt = RC_DEFAULT;
 907 #endif
 908
 909         // now try to open the citadel.rc file
 910         ccfile = NULL;
 911         if (getenv("HOME") != NULL) {
 912                 snprintf(buf, sizeof buf, "%s/.citadelrc", getenv("HOME"));
 913                 ccfile = fopen(buf, "r");
 914         }
 915         if (getenv("APPDIR") != NULL) {
 916                 snprintf(buf, sizeof buf, "%s/citadel.rc", getenv("APPDIR"));
 917                 ccfile = fopen(buf, "r");
 918         }
 919         if (ccfile == NULL) {
 920                 ccfile = fopen(file_citadel_rc, "r");
 921         }
 922         if (ccfile == NULL) {
 923                 ccfile = fopen("/usr/local/etc/citadel.rc", "r");
 924         }
 925         if (ccfile == NULL) {
 926                 ccfile = fopen("/etc/citadel.rc", "r");
 927         }
 928         if (ccfile == NULL) {
 929                 ccfile = fopen("./citadel.rc", "r");
 930         }
 931         if (ccfile == NULL) {
 932                 perror("commands: cannot open citadel.rc");
 933                 logoff(NULL, 3);
 934         }
 935         while (fgets(buf, sizeof buf, ccfile) != NULL) {
 936                 while ((!IsEmptyStr(buf)) ? (isspace(buf[strlen(buf) - 1])) : 0)
 937                         buf[strlen(buf) - 1] = 0;
 938
 939                 if (!strncasecmp(buf, "encrypt=", 8)) {
 940                         if (!strcasecmp(&buf[8], "yes")) {
 941 #ifdef HAVE_OPENSSL
 942                                 rc_encrypt = RC_YES;
 943 #else
 944                                 fprintf(stderr, "citadel.rc requires encryption support but citadel is not compiled with OpenSSL");
 945                                 logoff(NULL, 3);
 946 #endif
 947                         }
 948 #ifdef HAVE_OPENSSL
 949                         else if (!strcasecmp(&buf[8], "no")) {
 950                                 rc_encrypt = RC_NO;
 951                         } else if (!strcasecmp(&buf[8], "default")) {
 952                                 rc_encrypt = RC_DEFAULT;
 953                         }
 954 #endif
 955                 }
 956
 957                 if (!strncasecmp(buf, "editor=", 7)) {
 958                         strcpy(editor_path, &buf[7]);
 959                 }
 960
 961                 if (!strncasecmp(buf, "printcmd=", 9))
 962                         strcpy(printcmd, &buf[9]);
 963
 964                 if (!strncasecmp(buf, "imagecmd=", 9))
 965                         strcpy(imagecmd, &buf[9]);
 966
 967                 if (!strncasecmp(buf, "expcmd=", 7))
 968                         strcpy(rc_exp_cmd, &buf[7]);
 969
 970                 if (!strncasecmp(buf, "use_floors=", 11)) {
 971                         if (!strcasecmp(&buf[11], "yes"))
 972                                 rc_floor_mode = RC_YES;
 973                         if (!strcasecmp(&buf[11], "no"))
 974                                 rc_floor_mode = RC_NO;
 975                         if (!strcasecmp(&buf[11], "default"))
 976                                 rc_floor_mode = RC_DEFAULT;
 977                 }
 978                 if (!strncasecmp(buf, "beep=", 5)) {
 979                         rc_exp_beep = atoi(&buf[5]);
 980                 }
 981                 if (!strncasecmp(buf, "allow_attachments=", 18)) {
 982                         rc_allow_attachments = atoi(&buf[18]);
 983                 }
 984                 if (!strncasecmp(buf, "idle_threshold=", 15)) {
 985                         rc_idle_threshold = atol(&buf[15]);
 986                 }
 987                 if (!strncasecmp(buf, "remember_passwords=", 19)) {
 988                         rc_remember_passwords = atoi(&buf[19]);
 989                 }
 990                 if (!strncasecmp(buf, "display_message_numbers=", 24)) {
 991                         rc_display_message_numbers = atoi(&buf[24]);
 992                 }
 993                 if (!strncasecmp(buf, "force_mail_prompts=", 19)) {
 994                         rc_force_mail_prompts = atoi(&buf[19]);
 995                 }
 996                 if (!strncasecmp(buf, "ansi_color=", 11)) {
 997                         if (!strncasecmp(&buf[11], "on", 2))
 998                                 rc_ansi_color = 1;
 999                         if (!strncasecmp(&buf[11], "auto", 4))
1000                                 rc_ansi_color = 2;              // autodetect
1001                         if (!strncasecmp(&buf[11], "user", 4))
1002                                 rc_ansi_color = 3;              // user config
1003                 }
1004                 if (!strncasecmp(buf, "status_line=", 12)) {
1005                         if (!strncasecmp(&buf[12], "on", 2))
1006                                 enable_status_line = 1;
1007                 }
1008                 if (!strncasecmp(buf, "use_background=", 15)) {
1009                         if (!strncasecmp(&buf[15], "on", 2))
1010                                 rc_color_use_bg = 9;
1011                 }
1012                 if (!strncasecmp(buf, "prompt_control=", 15)) {
1013                         if (!strncasecmp(&buf[15], "on", 2))
1014                                 rc_prompt_control = 1;
1015                         if (!strncasecmp(&buf[15], "user", 4))
1016                                 rc_prompt_control = 3;          // user config
1017                 }
1018                 if (!strncasecmp(buf, "username=", 9))
1019                         strcpy(rc_username, &buf[9]);
1020
1021                 if (!strncasecmp(buf, "password=", 9))
1022                         strcpy(rc_password, &buf[9]);
1023
1024                 if (!strncasecmp(buf, "urlcmd=", 7))
1025                         strcpy(rc_url_cmd, &buf[7]);
1026
1027                 if (!strncasecmp(buf, "opencmd=", 7))
1028                         strcpy(rc_open_cmd, &buf[8]);
1029
1030                 if (!strncasecmp(buf, "gotmailcmd=", 11))
1031                         strcpy(rc_gotmail_cmd, &buf[11]);
1032
1033                 if (!strncasecmp(buf, "cmd=", 4)) {
1034                         strcpy(buf, &buf[4]);
1035
1036                         cptr = (struct citcmd *) malloc(sizeof(struct citcmd));
1037
1038                         cptr->c_cmdnum = atoi(buf);
1039                         for (d = strlen(buf); d >= 0; --d)
1040                                 if (buf[d] == ',')
1041                                         b = d;
1042                         strcpy(buf, &buf[b + 1]);
1043
1044                         cptr->c_axlevel = atoi(buf);
1045                         for (d = strlen(buf); d >= 0; --d)
1046                                 if (buf[d] == ',')
1047                                         b = d;
1048                         strcpy(buf, &buf[b + 1]);
1049
1050                         for (a = 0; a < 5; ++a)
1051                                 cptr->c_keys[a][0] = 0;
1052
1053                         a = 0;
1054                         b = 0;
1055                         buf[strlen(buf) + 1] = 0;
1056                         while (!IsEmptyStr(buf)) {
1057                                 b = strlen(buf);
1058                                 for (d = strlen(buf); d >= 0; --d)
1059                                         if (buf[d] == ',')
1060                                                 b = d;
1061                                 strncpy(cptr->c_keys[a], buf, b);
1062                                 cptr->c_keys[a][b] = 0;
1063                                 if (buf[b] == ',')
1064                                         strcpy(buf, &buf[b + 1]);
1065                                 else
1066                                         strcpy(buf, "");
1067                                 ++a;
1068                         }
1069
1070                         cptr->next = NULL;
1071                         if (cmdlist == NULL)
1072                                 cmdlist = cptr;
1073                         else
1074                                 lastcmd->next = cptr;
1075                         lastcmd = cptr;
1076                 }
1077         }
1078         fclose(ccfile);
1079 }
1080
1081
1082 // return the key associated with a command
1083 char keycmd(char *cmdstr) {
1084         int a;
1085
1086         for (a = 0; !IsEmptyStr(&cmdstr[a]); ++a)
1087                 if (cmdstr[a] == '&')
1088                         return (tolower(cmdstr[a + 1]));
1089         return (0);
1090 }
1091
1092
1093 // Output the string from a key command without the ampersand
1094 // "mode" should be set to 0 for normal or 1 for <C>ommand key highlighting
1095 char *cmd_expand(char *strbuf, int mode) {
1096         int a;
1097         static char exp[64];
1098         char buf[1024];
1099
1100         strcpy(exp, strbuf);
1101
1102         for (a = 0; exp[a]; ++a) {
1103                 if (strbuf[a] == '&') {
1104
1105                         // don't echo these non-mnemonic command keys
1106                         int noecho = strbuf[a + 1] == '<' || strbuf[a + 1] == '>' || strbuf[a + 1] == '+' || strbuf[a + 1] == '-';
1107
1108                         if (mode == 0) {
1109                                 strcpy(&exp[a], &exp[a + 1 + noecho]);
1110                         }
1111                         if (mode == 1) {
1112                                 exp[a] = '<';
1113                                 strcpy(buf, &exp[a + 2]);
1114                                 exp[a + 2] = '>';
1115                                 exp[a + 3] = 0;
1116                                 strcat(exp, buf);
1117                         }
1118                 }
1119                 if (!strncmp(&exp[a], "^r", 2)) {
1120                         strcpy(buf, exp);
1121                         strcpy(&exp[a], room_name);
1122                         strcat(exp, &buf[a + 2]);
1123                 }
1124                 if (!strncmp(&exp[a], "^c", 2)) {
1125                         exp[a] = ',';
1126                         strcpy(&exp[a + 1], &exp[a + 2]);
1127                 }
1128         }
1129
1130         return (exp);
1131 }
1132
1133
1134 // Comparison function to determine if entered commands match a command loaded from the config file.
1135 int cmdmatch(char *cmdbuf, struct citcmd *cptr, int ncomp) {
1136         int a;
1137         int cmdax;
1138
1139         cmdax = 0;
1140         if (is_room_aide)
1141                 cmdax = 1;
1142         if (axlevel >= 6)
1143                 cmdax = 2;
1144
1145         for (a = 0; a < ncomp; ++a) {
1146                 if ((tolower(cmdbuf[a]) != keycmd(cptr->c_keys[a]))
1147                     || (cptr->c_axlevel > cmdax))
1148                         return (0);
1149         }
1150         return (1);
1151 }
1152
1153
1154 // This function returns 1 if a given command requires a string input
1155 int requires_string(struct citcmd *cptr, int ncomp) {
1156         int a;
1157         char buf[64];
1158
1159         strcpy(buf, cptr->c_keys[ncomp - 1]);
1160         for (a = 0; !IsEmptyStr(&buf[a]); ++a) {
1161                 if (buf[a] == ':')
1162                         return (1);
1163         }
1164         return (0);
1165 }
1166
1167
1168 // Input a command at the main prompt.
1169 // This function returns an integer command number.  If the command prompts
1170 // for a string then it is placed in the supplied buffer.
1171 int getcmd(CtdlIPC * ipc, char *argbuf) {
1172         char cmdbuf[5];
1173         int cmdspaces[5];
1174         int cmdpos;
1175         int ch;
1176         int a;
1177         int got;
1178         int this_lazy_cmd;
1179         struct citcmd *cptr;
1180
1181         // Starting a new command now, so set sigcaught to 0.  This variable
1182         // is set to nonzero (usually NEXT_KEY or STOP_KEY) if a command has
1183         // been interrupted by a keypress.
1184         sigcaught = 0;
1185
1186         // Switch color support on or off if we're in user mode
1187         if (rc_ansi_color == 3) {
1188                 if (userflags & US_COLOR)
1189                         enable_color = 1;
1190                 else
1191                         enable_color = 0;
1192         }
1193
1194         // if we're running in idiot mode, display a cute little menu
1195         IFNEXPERT {
1196                 scr_printf("-----------------------------------------------------------------------\n");
1197                 scr_printf("Room cmds:    <K>nown rooms, <G>oto next room, <.G>oto a specific room,\n");
1198                 scr_printf("              <S>kip this room, <A>bandon this room, <Z>ap this room,\n");
1199                 scr_printf("              <U>ngoto (move back)\n");
1200                 scr_printf("Message cmds: <N>ew msgs, <F>orward read, <R>everse read, <O>ld msgs,\n");
1201                 scr_printf("              <L>ast five msgs, <E>nter a message\n");
1202                 scr_printf("General cmds: <?> help, <T>erminate, <C>hat, <W>ho is online\n");
1203                 scr_printf("Misc:         <X> toggle eXpert mode, <D>irectory\n");
1204                 scr_printf("\n");
1205                 scr_printf(" (Type .Help SUMMARY for extended commands, <X> to hide this menu)\n");
1206                 scr_printf("-----------------------------------------------------------------------\n");
1207         }
1208
1209         display_instant_messages();
1210         strcpy(argbuf, "");
1211         cmdpos = 0;
1212         for (a = 0; a < 5; ++a) {
1213                 cmdbuf[a] = 0;
1214         }
1215
1216         // now the room prompt...
1217         ok_to_interrupt = 1;
1218         color(BRIGHT_WHITE);
1219         scr_printf("\n%s", room_name);
1220         color(DIM_WHITE);
1221         scr_printf("%c ", room_prompt(room_flags));
1222
1223         while (1) {
1224                 ch = inkey();
1225                 ok_to_interrupt = 0;
1226
1227                 // Handle the backspace key, but only if there's something to backspace over...
1228                 if ((ch == 8) && (cmdpos > 0)) {
1229                         back(cmdspaces[cmdpos - 1] + 1);
1230                         cmdbuf[cmdpos] = 0;
1231                         --cmdpos;
1232                 }
1233
1234                 // Spacebar invokes "lazy traversal" commands
1235                 if ((ch == 32) && (cmdpos == 0)) {
1236                         this_lazy_cmd = next_lazy_cmd;
1237                         if (this_lazy_cmd == 13)
1238                                 next_lazy_cmd = 5;
1239                         if (this_lazy_cmd == 5)
1240                                 next_lazy_cmd = 13;
1241                         for (cptr = cmdlist; cptr != NULL; cptr = cptr->next) {
1242                                 if (cptr->c_cmdnum == this_lazy_cmd) {
1243                                         for (a = 0; a < 5; ++a)
1244                                                 if (cptr->c_keys[a][0] != 0)
1245                                                         scr_printf("%s ", cmd_expand(cptr->c_keys[a], 0));
1246                                         scr_printf("\n");
1247                                         return (this_lazy_cmd);
1248                                 }
1249                         }
1250                         scr_printf("\n");
1251                         return (this_lazy_cmd);
1252                 }
1253
1254                 // Otherwise, process the command
1255                 cmdbuf[cmdpos] = tolower(ch);
1256
1257                 for (cptr = cmdlist; cptr != NULL; cptr = cptr->next) {
1258                         if (cmdmatch(cmdbuf, cptr, cmdpos + 1)) {
1259
1260                                 scr_printf("%s", cmd_expand(cptr->c_keys[cmdpos], 0));
1261                                 cmdspaces[cmdpos] = strlen(cmd_expand(cptr->c_keys[cmdpos], 0));
1262                                 if (cmdpos < 4)
1263                                         if ((cptr->c_keys[cmdpos + 1]) != 0)
1264                                                 scr_putc(' ');
1265                                 ++cmdpos;
1266                         }
1267                 }
1268
1269                 for (cptr = cmdlist; cptr != NULL; cptr = cptr->next) {
1270                         if (cmdmatch(cmdbuf, cptr, 5)) {
1271                                 if (requires_string(cptr, cmdpos)) {    // We found our command.
1272                                         argbuf[0] = 0;
1273                                         ctdl_getline(argbuf, 64, 0, 0);
1274                                 }
1275                                 else {
1276                                         scr_printf("\n");
1277                                 }
1278
1279                                 // If this command is one that changes rooms, then the next lazy-command
1280                                 // (space bar) should be "read new" instead of "goto"
1281                                 if (    (cptr->c_cmdnum == 5)
1282                                         || (cptr->c_cmdnum == 6)
1283                                         || (cptr->c_cmdnum == 47)
1284                                         || (cptr->c_cmdnum == 52)
1285                                         || (cptr->c_cmdnum == 16)
1286                                         || (cptr->c_cmdnum == 20)
1287                                 ) {
1288                                         next_lazy_cmd = 13;
1289                                 }
1290
1291                                 // If this command is "read new" then the next lazy-command (space bar) should be "goto"
1292                                 if (cptr->c_cmdnum == 13) {
1293                                         next_lazy_cmd = 5;
1294                                 }
1295
1296                                 return (cptr->c_cmdnum);
1297
1298                         }
1299                 }
1300
1301                 if (ch == '?') {
1302                         scr_printf("\rOne of ...                         \n");
1303                         for (cptr = cmdlist; cptr != NULL; cptr = cptr->next) {
1304                                 if (cmdmatch(cmdbuf, cptr, cmdpos)) {
1305                                         for (a = 0; a < 5; ++a) {
1306                                                 keyopt(cmd_expand(cptr->c_keys[a], 1));
1307                                                 scr_printf(" ");
1308                                         }
1309                                         scr_printf("\n");
1310                                 }
1311                         }
1312                         sigcaught = 0;
1313
1314                         scr_printf("\n%s%c ", room_name, room_prompt(room_flags));
1315                         got = 0;
1316                         for (cptr = cmdlist; cptr != NULL; cptr = cptr->next) {
1317                                 if ((got == 0) && (cmdmatch(cmdbuf, cptr, cmdpos))) {
1318                                         for (a = 0; a < cmdpos; ++a) {
1319                                                 scr_printf("%s ", cmd_expand(cptr->c_keys[a], 0));
1320                                         }
1321                                         got = 1;
1322                                 }
1323                         }
1324                 }
1325         }
1326
1327 }
1328
1329
1330 // set tty modes.  commands are:
1331 //
1332 // 01- set to Citadel mode
1333 // 2 - save current settings for later restoral
1334 // 3 - restore saved settings
1335 void stty_ctdl(int cmd) {
1336         struct termios live;
1337         static struct termios saved_settings;
1338         static int last_cmd = 0;
1339
1340         if (cmd == SB_LAST) {
1341                 cmd = last_cmd;
1342         }
1343         else {
1344                 last_cmd = cmd;
1345         }
1346
1347         if ((cmd == 0) || (cmd == 1)) {
1348                 tcgetattr(0, &live);
1349                 live.c_iflag = ISTRIP | IXON | IXANY;
1350                 live.c_oflag = OPOST | ONLCR;
1351                 live.c_lflag = ISIG | NOFLSH;
1352
1353                 live.c_cc[VINTR] = 0;
1354                 live.c_cc[VQUIT] = 0;
1355
1356                 // do we even need this stuff anymore?
1357                 // live.c_line=0;
1358                 live.c_cc[VERASE] = 8;
1359                 live.c_cc[VKILL] = 24;
1360                 live.c_cc[VEOF] = 1;
1361                 live.c_cc[VEOL] = 255;
1362                 live.c_cc[VEOL2] = 0;
1363                 live.c_cc[VSTART] = 0;
1364                 tcsetattr(0, TCSADRAIN, &live);
1365         }
1366         if (cmd == 2) {
1367                 tcgetattr(0, &saved_settings);
1368         }
1369         if (cmd == 3) {
1370                 tcsetattr(0, TCSADRAIN, &saved_settings);
1371         }
1372
1373 }
1374
1375
1376 // display_help()  -  help text viewer
1377 void display_help(CtdlIPC * ipc, char *name) {
1378         int i;
1379         int num_helps = sizeof(helpnames) / sizeof(char *);
1380
1381         for (i = 0; i < num_helps; ++i) {
1382                 if (!strcasecmp(name, helpnames[i])) {
1383                         fmout(screenwidth, NULL, helptexts[i], NULL, 0);
1384                         return;
1385                 }
1386         }
1387
1388         scr_printf("'%s' not found.  Enter one of:\n", name);
1389         for (i = 0; i < num_helps; ++i) {
1390                 scr_printf("  %s\n", helpnames[i]);
1391         }
1392 }
1393
1394
1395 // fmout() - Citadel text formatter and paginator
1396 int fmout(int width,            // screen width to use
1397         FILE * fpin,            // file to read from, or NULL to format given text
1398         char *text,             // text to be formatted (when fpin is NULL
1399         FILE * fpout,           // file to write to, or NULL to write to screen
1400         int subst) {            // nonzero if we should use hypertext mode
1401         char *buffer = NULL;    // The current message
1402         char *word = NULL;      // What we are about to actually print
1403         char *e;                // Pointer to position in text
1404         char old = 0;           // The previous character
1405         int column = 0;         // Current column
1406         size_t i;               // Generic counter
1407
1408         // Space for a single word, which can be at most screenwidth
1409         word = (char *) calloc(1, width);
1410         if (!word) {
1411                 scr_printf("Can't alloc memory to print message: %s!\n", strerror(errno));
1412                 logoff(NULL, 3);
1413         }
1414
1415         // Read the entire message body into memory
1416         if (fpin) {
1417                 buffer = load_message_from_file(fpin);
1418                 if (!buffer) {
1419                         scr_printf("Can't print message: %s!\n", strerror(errno));
1420                         logoff(NULL, 3);
1421                 }
1422         }
1423         else {
1424                 buffer = text;
1425         }
1426         e = buffer;
1427
1428         // Run the message body
1429         while (*e) {
1430                 // Catch characters that shouldn't be there at all
1431                 if (*e == '\r') {
1432                         e++;
1433                         continue;
1434                 }
1435                 if (*e == '\n') {                       // newline?
1436                         e++;
1437                         if (*e == ' ') {                // paragraph?
1438                                 if (fpout) {
1439                                         fprintf(fpout, "\n");
1440                                 } else {
1441                                         scr_printf("\n");
1442                                 }
1443                                 column = 0;
1444                         }
1445                         else if (old != ' ') {          // Don't print two spaces
1446                                 if (fpout) {
1447                                         fprintf(fpout, " ");
1448                                 }
1449                                 else {
1450                                         scr_printf(" ");
1451                                 }
1452                                 column++;
1453                         }
1454                         old = '\n';
1455                         continue;
1456                 }
1457
1458                 // Or are we looking at a space?
1459                 if (*e == ' ') {
1460                         e++;
1461                         if (column >= width - 1) {
1462                                 // Are we in the rightmost column?
1463                                 if (fpout) {
1464                                         fprintf(fpout, "\n");
1465                                 }
1466                                 else {
1467                                         scr_printf("\n");
1468                                 }
1469                                 column = 0;
1470                         }
1471                         else if (!(column == 0 && old == ' ')) {
1472                                 // Eat only the first space on a line
1473                                 if (fpout) {
1474                                         fprintf(fpout, " ");
1475                                 }
1476                                 else {
1477                                         scr_printf(" ");
1478                                 }
1479                                 column++;
1480                         }
1481                         // ONLY eat the FIRST space on a line
1482                         old = ' ';
1483                         continue;
1484                 }
1485                 old = *e;
1486
1487                 // Read a word, slightly messy
1488                 i = 0;
1489                 while (e[i]) {
1490                         if (!isprint(e[i]) && !isspace(e[i]))
1491                                 e[i] = ' ';
1492                         if (isspace(e[i]))
1493                                 break;
1494                         i++;
1495                 }
1496
1497                 // We should never see these, but... slightly messy
1498                 if (e[i] == '\t' || e[i] == '\f' || e[i] == '\v')
1499                         e[i] = ' ';
1500
1501                 // Break up really long words
1502                 if (i >= width) {
1503                         i = width - 1;
1504                 }
1505                 strncpy(word, e, i);
1506                 word[i] = 0;
1507
1508                 // Decide where to print the word
1509                 if (column + i >= width) {
1510                         // Wrap to the next line
1511                         if (fpout) {
1512                                 fprintf(fpout, "\n");
1513                         }
1514                         else {
1515                                 scr_printf("\n");
1516                         }
1517                         column = 0;
1518                 }
1519
1520                 // Print the word
1521                 if (fpout) {
1522                         fprintf(fpout, "%s", word);
1523                 }
1524                 else {
1525                         scr_printf("%s", word);
1526                 }
1527                 column += i;
1528                 e += i;         // Start over with the whitepsace!
1529         }
1530
1531         free(word);
1532         if (fpin)               /* We allocated this, remember? */
1533                 free(buffer);
1534
1535         // Is this necessary?  It makes the output kind of spacey.
1536         if (fpout) {
1537                 fprintf(fpout, "\n");
1538         }
1539         else {
1540                 scr_printf("\n");
1541         }
1542
1543         return sigcaught;
1544 }
1545
1546
1547 // support ANSI color if defined
1548 void color(int colornum) {
1549         static int hold_color;
1550         static int current_color;
1551
1552         if (colornum == COLOR_PUSH) {
1553                 hold_color = current_color;
1554                 return;
1555         }
1556
1557         if (colornum == COLOR_POP) {
1558                 color(hold_color);
1559                 return;
1560         }
1561
1562         current_color = colornum;
1563         if (enable_color) {
1564                 // When switching to dim white, actually output an 'original
1565                 // pair' sequence -- this looks better on black-on-white
1566                 // terminals. - Changed to ORIGINAL_PAIR as this actually
1567                 // wound up looking horrible on black-on-white terminals, not
1568                 // to mention transparent terminals.
1569                 if (colornum == ORIGINAL_PAIR)
1570                         printf("\033[0;39;49m");
1571                 else
1572                         printf("\033[%d;3%d;4%dm", (colornum & 8) ? 1 : 0, (colornum & 7), rc_color_use_bg);
1573
1574         }
1575 }
1576
1577
1578 // Clear the screen
1579 void cls(int colornum) {
1580         if (enable_color) {
1581                 printf("\033[4%dm\033[2J\033[H\033[0m", colornum ? colornum : rc_color_use_bg);
1582         }
1583 }
1584
1585
1586 // Detect whether ANSI color is available (answerback)
1587 void send_ansi_detect(void) {
1588         if (rc_ansi_color == 2) {
1589                 printf("\033[c");
1590                 scr_flush();
1591                 time(&AnsiDetect);
1592         }
1593 }
1594
1595
1596 void look_for_ansi(void) {
1597         fd_set rfds;
1598         struct timeval tv;
1599         char abuf[512];
1600         time_t now;
1601         int a, rv;
1602
1603         if (rc_ansi_color == 0) {
1604                 enable_color = 0;
1605         }
1606         else if (rc_ansi_color == 1) {
1607                 enable_color = 1;
1608         }
1609         else if (rc_ansi_color == 2) {
1610
1611                 /* otherwise, do the auto-detect */
1612
1613                 strcpy(abuf, "");
1614
1615                 time(&now);
1616                 if ((now - AnsiDetect) < 2)
1617                         sleep(1);
1618
1619                 do {
1620                         FD_ZERO(&rfds);
1621                         FD_SET(0, &rfds);
1622                         tv.tv_sec = 0;
1623                         tv.tv_usec = 1;
1624
1625                         select(1, &rfds, NULL, NULL, &tv);
1626                         if (FD_ISSET(0, &rfds)) {
1627                                 abuf[strlen(abuf) + 1] = 0;
1628                                 rv = read(0, &abuf[strlen(abuf)], 1);
1629                                 if (rv < 0) {
1630                                         scr_printf("failed to read after select: %s", strerror(errno));
1631                                         break;
1632                                 }
1633                         }
1634                 } while (FD_ISSET(0, &rfds));
1635
1636                 for (a = 0; !IsEmptyStr(&abuf[a]); ++a) {
1637                         if ((abuf[a] == 27) && (abuf[a + 1] == '[')
1638                             && (abuf[a + 2] == '?')) {
1639                                 enable_color = 1;
1640                         }
1641                 }
1642         }
1643 }
1644
1645
1646 // Display key options (highlight hotkeys inside angle brackets)
1647 void keyopt(char *buf) {
1648         int i;
1649
1650         color(DIM_WHITE);
1651         for (i = 0; !IsEmptyStr(&buf[i]); ++i) {
1652                 if (buf[i] == '<') {
1653                         scr_printf("%c", buf[i]);
1654                         color(BRIGHT_MAGENTA);
1655                 } else {
1656                         if (buf[i] == '>' && buf[i + 1] != '>') {
1657                                 color(DIM_WHITE);
1658                         }
1659                         scr_printf("%c", buf[i]);
1660                 }
1661         }
1662         color(DIM_WHITE);
1663 }
1664
1665
1666 // Present a key-menu line choice type of thing
1667 char keymenu(char *menuprompt, char *menustring) {
1668         int i, c, a;
1669         int choices;
1670         int do_prompt = 0;
1671         char buf[1024];
1672         int ch;
1673         int display_prompt = 1;
1674
1675         choices = num_tokens(menustring, '|');
1676
1677         if (menuprompt != NULL)
1678                 do_prompt = 1;
1679         if ((menuprompt != NULL) && (IsEmptyStr(menuprompt)))
1680                 do_prompt = 0;
1681
1682         while (1) {
1683                 if (display_prompt) {
1684                         if (do_prompt) {
1685                                 scr_printf("%s ", menuprompt);
1686                         }
1687                         else {
1688                                 for (i = 0; i < choices; ++i) {
1689                                         extract_token(buf, menustring, i, '|', sizeof buf);
1690                                         keyopt(buf);
1691                                         scr_printf(" ");
1692                                 }
1693                         }
1694                         scr_printf("-> ");
1695                         display_prompt = 0;
1696                 }
1697                 ch = lkey();
1698
1699                 if ((do_prompt) && (ch == '?')) {
1700                         scr_printf("\rOne of...                               ");
1701                         scr_printf("                                      \n");
1702                         for (i = 0; i < choices; ++i) {
1703                                 extract_token(buf, menustring, i, '|', sizeof buf);
1704                                 scr_printf("   ");
1705                                 keyopt(buf);
1706                                 scr_printf("\n");
1707                         }
1708                         scr_printf("\n");
1709                         display_prompt = 1;
1710                 }
1711
1712                 for (i = 0; i < choices; ++i) {
1713                         extract_token(buf, menustring, i, '|', sizeof buf);
1714                         for (c = 1; !IsEmptyStr(&buf[c]); ++c) {
1715                                 if ((ch == tolower(buf[c]))
1716                                     && (buf[c - 1] == '<')
1717                                     && (buf[c + 1] == '>')) {
1718                                         for (a = 0; !IsEmptyStr(&buf[a]); ++a) {
1719                                                 if ((a != (c - 1)) && (a != (c + 1))) {
1720                                                         scr_putc(buf[a]);
1721                                                 }
1722                                         }
1723                                         scr_printf("\n");
1724                                         return ch;
1725                                 }
1726                         }
1727                 }
1728         }
1729 }