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" "    \n" "      *** USE  .<H>elp ?    for additional help *** \n",
  64
  65         // <.H>elp ADMIN
  66         "The following commands are available only to Admins.  A subset of these\n"
  67             "commands are available to room aides when they are currently in the room\n"
  68             "they are room aide for.\n"
  69             "\n"
  70             " <.> <A>dmin <K>ill this room   (Delete the current room)\n"
  71             " <.> <A>dmin <E>dit this room   (Edit the current room's parameters)\n"
  72             " <.> <A>dmin <W>ho knows room   (List users with access to this room)\n"
  73             " <.> <A>dmin edit <U>ser        (Change user's access level, password, etc.)\n"
  74             " <.> <A>dmin <V>alidate new users   (Process new user registrations)\n"
  75             " <.> <A>dmin enter <I>nfo file      (Create/change this room's banner)\n"
  76             " <.> <A>dmin <R>oom <I>nvite user   (Grant access to an invitation-only room)\n"
  77             " <.> <A>dmin <R>oom <K>ick out user (Revoke access to an invitation-only room)\n"
  78             " <.> <A>dmin <F>ile <D>elete        (Delete a file from the room's directory)\n"
  79             " <.> <A>dmin <F>ile <S>end over net (Transmit a file to another node)\n"
  80             " <.> <A>dmin <F>ile <M>ove          (Move a file to another room's directory)\n"
  81             " <.> <A>dmin <M>essage edit:        (Edit system banners)\n"
  82             " <.> <A>dmin <P>ost                 (Post a message on behalf of another user)\n"
  83             " <.> <A>dmin <S>ystem configuration <G>eneral   (Edit global site config)\n"
  84             " <.> <A>dmin <S>ystem configuration <I>nternet  (Edit Internet domains)\n"
  85             " <.> <A>dmin <S>ystem configuration check <M>essage base   (Internal checks)\n"
  86             " <.> <A>dmin <S>ystem configuration <N>etwork   (Netting with other Citadels)\n"
  87             " <.> <A>dmin <S>ystem configuration network <F>ilter list\n"
  88             " <.> <A>dmin <T>erminate server <N>ow          (Shut down Citadel server now)\n"
  89             " <.> <A>dmin <T>erminate server <S>cheduled    (Shut down Citadel server later)\n"
  90             " <.> <A>dmin mailing <L>ist recipients         (For mailing list rooms)\n"
  91             " <.> <A>dmin mailing list <D>igest recipients  (For mailing list rooms)\n"
  92             " <.> <A>dmin <N>etwork room sharing     (Replication with other Citadels)\n"
  93             " \n" " In addition, the <M>ove and <D>elete commands are available at the\n" "message prompt.\n",
  94
  95         // <.H>elp FLOORS
  96         " Floors\n"
  97             " ------\n"
  98             "   Floors in Citadel are used to group rooms into related subject areas,\n"
  99             "just as rooms are used to group messages into manageable groups.\n"
 100             " \n"
 101             "   You, as a user, do NOT have to use floors.  If you choose not to, you suffer\n"
 102             "no penalty; you will not lose access to any rooms.  You may use .EC or ;C (the\n"
 103             "latter is easier to use) to decide if you want to use floors.  Feel free to\n"
 104             "experiment.\n"
 105             " \n"
 106             "   Floor options are accessed two ways.  First, if you are in floor mode, the\n"
 107             "<G>oto and <S>kip commands take you to the next room with new messages on the\n"
 108             "current floor; if there are none left, then the system will automatically\n"
 109             "switch floors (and let you know) and put you in the first room with new messages\n"
 110             "on that level.  (Notice that your pattern of basic use of Citadel therefore\n"
 111             "doesn't really change.)\n"
 112             " \n"
 113             "   Direct access to floor options is via the use of a ';' command.\n"
 114             "The following commands are currently available (more can be\n"
 115             "added if needed):\n"
 116             " \n"
 117             " <;C>onfigure\n"
 118             " This command toggles your floor mode.\n"
 119             " \n"
 120             " <;G>oto FLOORNAME\n"
 121             " This command causes the system to take you to the named floor.\n"
 122             " \n"
 123             " <;K>nown rooms on floors\n"
 124             " List all rooms on all floors.  This is a very readable way to get a list of\n"
 125             "all rooms on the system.\n"
 126             " \n"
 127             " <;S>kip FLOORNAME\n"
 128             " This command causes the system to mark all rooms on the current floor as\n"
 129             "Skipped and takes you to the floor that you specify.\n"
 130             " \n"
 131             " <;Z>Forget floor\n"
 132             "   This command causes you to forget all the rooms currently on the current\n"
 133             "floor.  Unfortunately, it doesn't apply to rooms that are subsequently created\n"
 134             "or moved to this floor.  (Sorry.)\n"
 135             " \n"
 136             "   Feel free to experiment, you can't hurt yourself or the system with the\n"
 137             "floor stuff unless you ZForget a floor by accident.\n",
 138
 139         // <.H>elp INTRO
 140         "                  New User's Introduction to the site\n"
 141             "  \n"
 142             " This is an introduction to the Citadel BBS concept.  It is intended\n"
 143             "for new users so that they can more easily become acquainted to using\n"
 144             "Citadel when accessing it in the form of a text-based BBS.  Of\n"
 145             "course, old users might learn something new each time they read\n"
 146             "through it.\n"
 147             " \n"
 148             " Full help for the BBS commands can be obtained by typing <.H>elp SUMMARY\n"
 149             "  \n"
 150             " The CITADEL BBS room concept\n"
 151             " ----------------------------\n"
 152             "   The term BBS stands for 'Bulletin Board System'.  The analogy is\n"
 153             "appropriate: one posts messages so that others may read them.  In\n"
 154             "order to organize the posts, people can post in different areas of the\n"
 155             "BBS, called rooms.\n"
 156             "   In order to post in a certain room, you need to be 'in' that room.\n"
 157             "Your current prompt is usually the room that you are in, followed the\n"
 158             "greater-than-sign, such as:\n"
 159             " \n"
 160             " Lobby>\n"
 161             " \n"
 162             " The easiest way to traverse the room structure is with the 'Goto'\n"
 163             "command, on the 'G' key.  Pressing 'G' will take you to the next room\n"
 164             "in the 'march list' (see below) that has new messages in it.  You can\n"
 165             "read these new messages with the 'N' key.\n"
 166             " Once you've 'Gotoed' every room in the system (or all of the ones\n"
 167             "you choose to read) you return to the 'Lobby,' the first and last room\n"
 168             "in the system.  If new messages get posted to rooms you've already\n"
 169             "read during your session you will be brought BACK to those rooms so\n"
 170             "you can read them.\n"
 171             " \n"
 172             " March List\n"
 173             " ----------\n"
 174             "   All the room names are stored in a march list, which is just a\n"
 175             "list containing all the room names.  When you <G>oto or <S>kip a\n"
 176             "room, you are placed in the next room in your march list THAT HAS NEW\n"
 177             "MESSAGES.  If you have no new messages in any of the rooms on your\n"
 178             "march list, you will keep going to the Lobby>.  You can choose not to\n"
 179             "read certain rooms (that don't interest you) by 'Z'apping them.  When\n"
 180             "you <Z>ap a room, you are merely deleting it from your march list (but\n"
 181             "not from anybody else's).\n"
 182             " \n"
 183             "   You can use the <.G>oto (note the period before the G.  You can also use\n"
 184             "<J>ump on some systems) to go to any room in the\n"
 185             "system.  You don't have to type in the complete name of a room to\n"
 186             "'jump' to it; you merely need to type in enough to distinguish it from\n"
 187             "the other rooms.  Left-aligned matches carry a heavier weight, so if you\n"
 188             "typed (for example) '.Goto TECH', you might be taken to a room called\n"
 189             "'Tech Area>' even if it found a room called 'Biotech/Ethics>' first.\n"
 190             " \n"
 191             "  To return to a room you have previously <Z>apped, use the <.G>oto command\n"
 192             "to enter it, and it will be re-inserted into your march list.  In the case\n"
 193             "of returning to Zapped rooms, you must type the room name in its entirety.\n"
 194             "REMEMBER, rooms with no new messages will not show on your\n"
 195             "march list!  You must <.G>oto to a room with no new messages.\n"
 196             "Incidentally, you cannot change the order of the rooms on your march list.\n"
 197             "It's the same for everybody.\n"
 198             " \n"
 199             " Special rooms\n"
 200             " -------------\n"
 201             "   There are two special rooms on a Citadel that you should know about.\n"
 202             "  \n"
 203             "   The first is the Lobby>.  It's used for system announcements and other\n"
 204             "such administrativia.  You cannot <Z>ap the Lobby>.  Each time you first\n"
 205             "login, you will be placed in the Lobby>.\n"
 206             " \n"
 207             "   The second is Mail>.  In Mail>, when you post a messages, you are\n"
 208             "prompted to enter the screen name of the person who you want to send the\n"
 209             "message to.  Only the person who you send the message to can read the\n"
 210             "message.  NO ONE else can read it, not even the admins.  Mail> is the\n"
 211             "first room on the march list, and is un-<Z>appable, so you can be sure\n"
 212             "that the person will get the message.\n"
 213             "   \n"
 214             " System admins\n"
 215             " -------------\n"
 216             "   These people, along with the room admins, keep the site running smoothly.\n"
 217             "\n"
 218             "   Among the many things that admins do are: create rooms, delete\n"
 219             "rooms, set access levels, invite users, check registration, grant\n"
 220             "room admin status, and countless other things.  They have access to the\n"
 221             "Aide> room, a special room only for admins.\n"
 222             " \n"
 223             "   If you enter a mail message to 'Sysop' it will be placed in the\n"
 224             "Aide> room so that the next admin online will read it and deal with it.\n"
 225             "Admins cannot <Z>ap rooms.  All the rooms are always on each admin's\n"
 226             "march list.  Admins can read *any* and *every* room, but they *CAN* *NOT*\n"
 227             "read other users' Mail!\n"
 228             "  \n"
 229             " Room admins\n"
 230             " -----------\n"
 231             "   Room admins are granted special privileges in specific rooms.\n"
 232             "They are *NOT* true system admins; their power extends only over the\n"
 233             "rooms that they control, and they answer to the system admins.\n"
 234             "  \n"
 235             "   A room admin's job is to keep the topic of the their room on track,\n"
 236             "with nudges in the right direction now and then.  A room admin can also\n"
 237             "move an off topic post to another room, or delete a post, if he/she\n"
 238             "feels it is necessary. \n"
 239             "  \n"
 240             "   Currently, very few rooms have room admins.  Most rooms do not need\n"
 241             "their own specific room admin.  Being a room admin requires a certain\n"
 242             "amount of trust, due to the additional privileges granted.\n"
 243             "  \n"
 244             " Citadel messages\n"
 245             " ----------------\n"
 246             "   Most of the time, the BBS code does not print a lot of messages\n"
 247             "to your screen.  This is a great benefit once you become familiar\n"
 248             "with the system, because you do not have endless menus and screens\n"
 249             "to navigate through.  nevertheless, there are some messages which you\n"
 250             "might see from time to time.\n"
 251             "  \n"
 252             "  'There were messages posted while you were entering.'\n"
 253             "  \n"
 254             "   This is also known as 'simulposting.'  When you start entering a \n"
 255             "message, the system knows where you last left off.  When you save\n"
 256             "your message, the system checks to see if any messages were entered\n"
 257             "while you were typing.  This is so that you know whether you need\n"
 258             "to go back and re-read the last few messages.  This message may appear\n"
 259             "in any room.\n"
 260             "   \n"
 261             " '*** You have new mail'\n"
 262             "  \n"
 263             "   This message is essentially the same as the above message, but can\n"
 264             "appear at any time.  It simply means that new mail has arrived for you while\n"
 265             "you are logged in.  Simply go to the Mail> room to read it.\n"
 266             "  \n"
 267             " Who list\n"
 268             " --------\n"
 269             "   The <W>ho command shows you the names of all users who are currently\n"
 270             "online.  It also shows you the name of the room they are currently in.  If\n"
 271             "they are in any type of private room, however, the room name will simply\n"
 272             "display as '<private room>'.  Along with this information is displayed the\n"
 273             "name of the host computer the user is logged in from.\n",
 274
 275         // <.H>elp MAIL
 276         "To send mail on this system, go to the Mail> room (using the command .G Mail)\n"
 277             "and press E to enter a message.  You will be prompted with:\n"
 278             " \n"
 279             " Enter Recipient:\n"
 280             " \n"
 281             "   At this point you may enter the name of another user on the system.  Private\n"
 282             "mail is only readable by the sender and recipient.  There is no need to delete\n"
 283             "mail after it is read; it will scroll out automatically.\n"
 284             "  \n"
 285             "   To send mail to another user on the Citadel network, simply type the\n"
 286             "user's name, followed by @ and then the system name. For example,\n"
 287             "  \n"
 288             " Enter Recipient: Joe Schmoe @ citadrool\n"
 289             "  \n"
 290             "  If your account is enabled for Internet mail, you can also send email to\n"
 291             "anyone on the Internet here.  Simply enter their address at the prompt:\n"
 292             "  \n" " Enter Recipient: ajc@herring.fishnet.com\n",
 293
 294         // <.H>elp NETWORK
 295         "  Welcome to the network. Messages entered in a network room will appear in\n"
 296             "that room on all other systems carrying it (The name of the room, however,\n" "may be different on other systems).\n",
 297
 298         // <.H>elp SOFTWARE
 299         "   Citadel is the premier 'online community' (i.e. Bulletin Board System)\n"
 300             "software.  It runs on all POSIX-compliant systems, including Linux.  It is an\n"
 301             "advanced client/server application, and is being actively maintained.\n"
 302             " \n" "   For more info, visit UNCENSORED! BBS at uncensored.citadel.org\n",
 303
 304         // <.H>elp SUMMARY
 305         "Extended commands are available using the period ( . ) key. To use\n"
 306             "a dot command, press the . key, and then enter the first letter of\n"
 307             "each word in the command. The words will appear as you enter the keys.\n"
 308             "You can also backspace over partially entered commands. The following\n"
 309             "commands are available:\n"
 310             "\n"
 311             " <.> <H>elp:    Displays help files.  Type .H followed by a help file\n"
 312             "                name.  You are now reading <.H>elp SUMMARY\n"
 313             " \n"
 314             " <.> <G>oto:    Jumps directly to the room you specify.  You can also\n"
 315             "                type a partial room name, just enough to make it unique,\n"
 316             "                and it'll find the room you're looking for.  As with the\n"
 317             "                regular <G>oto command, messages in the current room will\n"
 318             "                be marked as read.\n"
 319             " \n"
 320             " <.> <S>kip, goto:    This is similar to <.G>oto, except it doesn't mark\n"
 321             "                      messages in the current room as read.\n"
 322             " \n"
 323             " <.> list <Z>apped rooms      Shows all rooms you've <Z>apped (forgotten)\n"
 324             "\n"
 325             "  \n"
 326             " Terminate (logoff) commands:\n"
 327             " \n"
 328             " <.> <T>erminate and <Q>uit               Log off and disconnect.\n"
 329             " <.> <T>erminate and <S>tay online        Log in as a different user.\n"
 330             " \n"
 331             " \n"
 332             " Read commands:\n"
 333             "\n"
 334             " <.> <R>ead <N>ew messages                Same as <N>ew\n"
 335             " <.> <R>ead <O>ld msgs reverse            Same as <O>ld\n"
 336             " <.> <R>ead <L>ast five msgs              Same as <L>ast5\n"
 337             " <.> read <L>ast:                         Allows you to specify how many\n"
 338             "                                          messages you wish to read.\n"
 339             "\n"
 340             " <.> <R>ead <U>ser listing:               Lists all users on the system if\n"
 341             "                                          you just hit enter, otherwise\n"
 342             "                                          you can specify a partial match\n"
 343             "\n"
 344             " <.> <R>ead <T>extfile formatted          File 'download' commands.\n"
 345             " <.> <R>ead file using <X>modem   \n"
 346             " <.> <R>ead file using <Y>modem   \n"
 347             " <.> <R>ead file using <Z>modem   \n"
 348             " <.> <R>ead <F>ile unformatted   \n"
 349             " <.> <R>ead <D>irectory   \n"
 350             "\n"
 351             " <.> <R>ead <I>nfo file                   Read the room info file.\n"
 352             " <.> <R>ead <B>io                         Read other users' 'bio' files.\n"
 353             " <.> <R>ead <C>onfiguration               Display your 'preferences'.\n"
 354             " <.> <R>ead <S>ystem info                 Display system statistics.\n"
 355             "\n"
 356             " \n"
 357             " Enter commands:\n"
 358             "\n"
 359             " <.> <E>nter <M>essage                    Post a message in this room.\n"
 360             " <.> <E>nter message with <E>ditor        Post using a full-screen editor.\n"
 361             " <.> <E>nter <A>SCII message              Post 'raw' (use this when 'pasting'\n"
 362             "                                          a message from your clipboard).\n"
 363             "\n"
 364             " <.> <E>nter <P>assword                   Change your password.\n"
 365             " <.> <E>nter <C>onfiguration              Change your 'preferences'.\n"
 366             " <.> <E>nter a new <R>oom                 Create a new room.\n"
 367             " <.> <E>nter re<G>istration               Register (name, address, etc.)\n"
 368             " <.> <E>nter <B>io                        Enter/change your 'bio' file.\n"
 369             "\n"
 370             " <.> <E>nter <T>extfile                   File 'upload' commands.\n"
 371             " <.> <E>nter file using <X>modem   \n"
 372             " <.> <E>nter file using <Y>modem   \n"
 373             " <.> <E>nter file using <Z>modem   \n"
 374             "  \n"
 375             "  \n"
 376             "  Wholist commands:\n"
 377             " \n"
 378             " <.> <W>holist <L>ong             Same as <W>ho is online, but displays\n"
 379             "                                  more detailed information.\n"
 380             " <.> <W>holist <R>oomname         Masquerade your room name (other users\n"
 381             "                                  see the name you enter rather than the\n"
 382             "                                  actual name of the room you're in)\n"
 383             " <.> <W>holist <H>ostname         Masquerade your host name\n"
 384             " <.> <E>nter <U>sername           Masquerade your user name (Admins only)\n"
 385             " <.> <W>holist <S>tealth mode     Enter/exit 'stealth mode' (when in stealth\n"
 386             "                                  mode you are invisible on the wholist)\n"
 387             " \n"
 388             " \n"
 389             " Floor commands (if using floor mode)\n"
 390             " ;<C>onfigure floor mode            - turn floor mode on or off\n"
 391             " ;<G>oto floor:                     - jump to a specific floor\n"
 392             " ;<K>nown rooms                     - list all rooms on all floors\n"
 393             " ;<S>kip to floor:                  - skip current floor, jump to another\n"
 394             " ;<Z>ap floor                       - zap (forget) all rooms on this floor\n"
 395             " \n"
 396             " \n"
 397             " Administrative commands: \n"
 398             " \n"
 399             " <.> <A>dmin <K>ill this room   \n"
 400             " <.> <A>dmin <E>dit this room   \n"
 401             " <.> <A>dmin <W>ho knows room   \n"
 402             " <.> <A>dmin edit <U>ser   \n"
 403             " <.> <A>dmin <V>alidate new users   \n"
 404             " <.> <A>dmin enter <I>nfo file   \n"
 405             " <.> <A>dmin <R>oom <I>nvite user  \n"
 406             " <.> <A>dmin <R>oom <K>ick out user  \n"
 407             " <.> <A>dmin <F>ile <D>elete  \n"
 408             " <.> <A>dmin <F>ile <S>end over net  \n"
 409             " <.> <A>dmin <F>ile <M>ove  \n"
 410             " <.> <A>dmin <M>essage edit:   \n"
 411             " <.> <A>dmin <P>ost   \n"
 412             " <.> <A>dmin <S>ystem configuration   \n"
 413             " <.> <A>dmin <T>erminate server <N>ow\n" " <.> <A>dmin <T>erminate server <S>cheduled\n"
 414 };
 415
 416
 417 struct citcmd {
 418         struct citcmd *next;
 419         int c_cmdnum;
 420         int c_axlevel;
 421         char c_keys[5][64];
 422 };
 423
 424 #define IFNEXPERT if ((userflags&US_EXPERT)==0)
 425
 426
 427 int rc_exp_beep;
 428 char rc_exp_cmd[1024];
 429 int rc_allow_attachments;
 430 int rc_display_message_numbers;
 431 int rc_force_mail_prompts;
 432 int rc_remember_passwords;
 433 int rc_ansi_color;
 434 int rc_color_use_bg;
 435 int rc_prompt_control = 0;
 436 time_t rc_idle_threshold = (time_t) 900;
 437 char rc_url_cmd[SIZ];
 438 char rc_open_cmd[SIZ];
 439 char rc_gotmail_cmd[SIZ];
 440
 441 int next_lazy_cmd = 5;
 442
 443 extern int screenwidth, screenheight;
 444 extern int termn8;
 445 extern CtdlIPC *ipc_for_signal_handlers;        // KLUDGE cover your eyes
 446 struct citcmd *cmdlist = NULL;
 447
 448
 449 // these variables are local to this module
 450 char keepalives_enabled = KA_YES;       // send NOOPs to server when idle
 451 int ok_to_interrupt = 0;        // print instant msgs asynchronously
 452 time_t AnsiDetect;              // when did we send the detect code?
 453 int enable_color = 0;           // nonzero for ANSI color
 454
 455
 456 // If an interesting key has been pressed, return its value, otherwise 0
 457 char was_a_key_pressed(void) {
 458         fd_set rfds;
 459         struct timeval tv;
 460         int the_character;
 461         int retval;
 462
 463         FD_ZERO(&rfds);
 464         FD_SET(0, &rfds);
 465         tv.tv_sec = 0;
 466         tv.tv_usec = 0;
 467         retval = select(1, &rfds, NULL, NULL, &tv);
 468
 469         // Careful!  Disable keepalives during keyboard polling; we're probably
 470         // in the middle of a data transfer from the server, in which case
 471         // sending a NOOP would throw the client protocol out of sync.
 472         if ((retval > 0) && FD_ISSET(0, &rfds)) {
 473                 set_keepalives(KA_NO);
 474                 the_character = inkey();
 475                 set_keepalives(KA_YES);
 476         }
 477         else {
 478                 the_character = 0;
 479         }
 480         return (the_character);
 481 }
 482
 483
 484 // display_instant_messages()  -  print instant messages if there are any
 485 void display_instant_messages(void) {
 486         char buf[1024];
 487         FILE *outpipe;
 488         time_t timestamp;
 489         struct tm stamp;
 490         int flags = 0;
 491         char sender[64];
 492         char node[64];
 493         char *listing = NULL;
 494         int r;                  // IPC result code
 495
 496         if (instant_msgs == 0) {
 497                 return;
 498         }
 499
 500         if (rc_exp_beep) {
 501                 ctdl_beep();
 502         }
 503
 504         if (IsEmptyStr(rc_exp_cmd)) {
 505                 color(BRIGHT_RED);
 506                 scr_printf("\r---");
 507         }
 508
 509         while (instant_msgs != 0) {
 510                 r = CtdlIPCGetInstantMessage(ipc_for_signal_handlers, &listing, buf);
 511                 if (r / 100 != 1) {
 512                         return;
 513                 }
 514
 515                 instant_msgs = extract_int(buf, 0);
 516                 timestamp = extract_long(buf, 1);
 517                 flags = extract_int(buf, 2);
 518                 extract_token(sender, buf, 3, '|', sizeof sender);
 519                 extract_token(node, buf, 4, '|', sizeof node);
 520                 strcpy(last_paged, sender);
 521
 522                 localtime_r(&timestamp, &stamp);
 523
 524                 // If the message contains a Logoff Request, honor it.
 525                 if (flags & 2) {
 526                         termn8 = 1;
 527                         return;
 528                 }
 529
 530                 if (!IsEmptyStr(rc_exp_cmd)) {
 531                         outpipe = popen(rc_exp_cmd, "w");
 532                         if (outpipe != NULL) {
 533                                 // Header derived from flags
 534                                 if (flags & 2)
 535                                         fprintf(outpipe, "Please log off now, as requested ");
 536                                 else if (flags & 1)
 537                                         fprintf(outpipe, "Broadcast message ");
 538                                 else if (flags & 4)
 539                                         fprintf(outpipe, "Chat request ");
 540                                 else
 541                                         fprintf(outpipe, "Message ");
 542                                 // Timestamp.  Can this be improved?
 543                                 if (stamp.tm_hour == 0 || stamp.tm_hour == 12)
 544                                         fprintf(outpipe, "at 12:%02d%cm", stamp.tm_min, stamp.tm_hour ? 'p' : 'a');
 545                                 else if (stamp.tm_hour > 12)    // pm
 546                                         fprintf(outpipe, "at %d:%02dpm", stamp.tm_hour - 12, stamp.tm_min);
 547                                 else    // am
 548                                         fprintf(outpipe, "at %d:%02dam", stamp.tm_hour, stamp.tm_min);
 549                                 fprintf(outpipe, " from %s", sender);
 550                                 if (strncmp(ipc_for_signal_handlers->ServInfo.nodename, node, 32))
 551                                         fprintf(outpipe, " @%s", node);
 552                                 fprintf(outpipe, ":\n%s\n", listing);
 553                                 pclose(outpipe);
 554                                 if (instant_msgs == 0)
 555                                         return;
 556                                 continue;
 557                         }
 558                 }
 559                 // fall back to built-in instant message display
 560                 scr_printf("\n");
 561
 562                 // Header derived from flags
 563                 if (flags & 2)
 564                         scr_printf("Please log off now, as requested ");
 565                 else if (flags & 1)
 566                         scr_printf("Broadcast message ");
 567                 else if (flags & 4)
 568                         scr_printf("Chat request ");
 569                 else
 570                         scr_printf("Message ");
 571
 572                 // Timestamp.  Can this be improved?
 573                 if (stamp.tm_hour == 0 || stamp.tm_hour == 12)  // 12am/12pm
 574                         scr_printf("at 12:%02d%cm", stamp.tm_min, stamp.tm_hour ? 'p' : 'a');
 575                 else if (stamp.tm_hour > 12)    // pm
 576                         scr_printf("at %d:%02dpm", stamp.tm_hour - 12, stamp.tm_min);
 577                 else            // am
 578                         scr_printf("at %d:%02dam", stamp.tm_hour, stamp.tm_min);
 579
 580                 // Sender
 581                 scr_printf(" from %s", sender);
 582
 583                 // Remote node, if any
 584                 if (strncmp(ipc_for_signal_handlers->ServInfo.nodename, node, 32))
 585                         scr_printf(" @%s", node);
 586
 587                 scr_printf(":\n");
 588                 fmout(screenwidth, NULL, listing, NULL, 0);
 589                 free(listing);
 590
 591         }
 592         scr_printf("\n---\n");
 593         color(BRIGHT_WHITE);
 594
 595
 596 }
 597
 598
 599 void set_keepalives(int s) {
 600         keepalives_enabled = (char) s;
 601 }
 602
 603
 604 // This loop handles the "keepalive" messages sent to the server when idling.
 605 static time_t idlet = 0;
 606 static void really_do_keepalive(void) {
 607         time(&idlet);
 608
 609         // This may sometimes get called before we are actually connected
 610         // to the server.  Don't do anything if we aren't connected. -IO
 611         if (!ipc_for_signal_handlers)
 612                 return;
 613
 614         // If full keepalives are enabled, send a NOOP to the server and
 615         // wait for a response.
 616         if (keepalives_enabled == KA_YES) {
 617                 CtdlIPCNoop(ipc_for_signal_handlers);
 618                 if (instant_msgs > 0) {
 619                         if (ok_to_interrupt == 1) {
 620                                 scr_printf("\r%64s\r", "");
 621                                 display_instant_messages();
 622                                 scr_printf("%s%c ", room_name, room_prompt(room_flags));
 623                                 scr_flush();
 624                         }
 625                 }
 626         }
 627
 628         // If half keepalives are enabled, send a QNOP to the server, then do nothing.
 629         if (keepalives_enabled == KA_HALF) {
 630                 CtdlIPC_chat_send(ipc_for_signal_handlers, "QNOP");
 631         }
 632 }
 633
 634
 635 // I changed this from static to not because I need to call it from
 636 // screen.c, either that or make something in screen.c not static.
 637 // Fix it how you like. Why all the staticness? stu
 638 void do_keepalive(void) {
 639         time_t now;
 640
 641         time(&now);
 642         if ((now - idlet) < ((long) S_KEEPALIVE)) {
 643                 return;
 644         }
 645
 646         // Do a space-backspace to keep terminal sessions from idling out
 647         scr_printf(" %c", 8);
 648         scr_flush();
 649
 650         really_do_keepalive();
 651 }
 652
 653
 654 // Get a character from the keyboard, with the watchdog timer in effect if necessary.
 655 int inkey(void) {
 656         int a;
 657         fd_set rfds;
 658         struct timeval tv;
 659         time_t start_time;
 660
 661         scr_flush();
 662         time(&start_time);
 663
 664         do {
 665                 // This loop waits for keyboard input.  If the keepalive
 666                 // timer expires, it sends a keepalive to the server if
 667                 // necessary and then waits again.
 668                 do {
 669                         do_keepalive();
 670
 671                         FD_ZERO(&rfds);
 672                         FD_SET(0, &rfds);
 673                         tv.tv_sec = S_KEEPALIVE;
 674                         tv.tv_usec = 0;
 675
 676                         select(1, &rfds, NULL, NULL, &tv);
 677                 } while (!FD_ISSET(0, &rfds));
 678
 679                 // At this point, there's input, so fetch it.
 680                 // (There's a hole in the bucket...)
 681                 a = scr_getc(SCR_BLOCK);
 682                 if (a == 127) {
 683                         a = 8;
 684                 }
 685                 if (a == 13) {
 686                         a = 10;
 687                 }
 688         } while (a == 0);
 689         return (a);
 690 }
 691
 692
 693 // Returns 1 for yes, 0 for no
 694 int yesno(void) {
 695         int a;
 696         while (1) {
 697                 a = inkey();
 698                 a = tolower(a);
 699                 if (a == 'y') {
 700                         scr_printf("Yes\n");
 701                         return (1);
 702                 }
 703                 if (a == 'n') {
 704                         scr_printf("No\n");
 705                         return (0);
 706                 }
 707         }
 708 }
 709
 710
 711 // Returns 1 for yes, 0 for no, arg is default value
 712 int yesno_d(int d) {
 713         int a;
 714         while (1) {
 715                 a = inkey();
 716                 a = tolower(a);
 717                 if (a == 10)
 718                         a = (d ? 'y' : 'n');
 719                 if (a == 'y') {
 720                         scr_printf("Yes\n");
 721                         return (1);
 722                 }
 723                 if (a == 'n') {
 724                         scr_printf("No\n");
 725                         return (0);
 726                 }
 727         }
 728 }
 729
 730
 731 // Function to read a line of text from the terminal.
 732 //
 733 // string               Pointer to string buffer
 734 // lim                  Maximum length
 735 // noshow               Echo asterisks instead of keystrokes?
 736 // bs                   Allow backspacing out of the prompt? (returns -1 if this happens)
 737 //
 738 // returns: string length
 739 int ctdl_getline(char *string, int lim, int noshow, int bs) {
 740         int pos = strlen(string);
 741         int ch;
 742
 743         if (noshow && !IsEmptyStr(string)) {
 744                 int num_stars = strlen(string);
 745                 while (num_stars--) {
 746                         scr_putc('*');
 747                 }
 748         }
 749         else {
 750                 scr_printf("%s", string);
 751         }
 752
 753         while (1) {
 754                 ch = inkey();
 755
 756                 if ((ch == 8) && (pos > 0)) {   // backspace
 757                         --pos;
 758                         scr_putc(8);
 759                         scr_putc(32);
 760                         scr_putc(8);
 761                 }
 762
 763                 else if ((ch == 8) && (pos == 0) && (bs)) {     // backspace out of the prompt
 764                         return (-1);
 765                 }
 766
 767                 else if ((ch == 23) && (pos > 0)) {     // Ctrl-W deletes a word
 768                         while ((pos > 0) && !isspace(string[pos])) {
 769                                 --pos;
 770                                 scr_putc(8);
 771                                 scr_putc(32);
 772                                 scr_putc(8);
 773                         }
 774                         while ((pos > 0) && !isspace(string[pos - 1])) {
 775                                 --pos;
 776                                 scr_putc(8);
 777                                 scr_putc(32);
 778                                 scr_putc(8);
 779                         }
 780                 }
 781
 782                 else if (ch == 10) {    // return
 783                         string[pos] = 0;
 784                         scr_printf("\n");
 785                         return (pos);
 786                 }
 787
 788                 else if (isprint(ch)) { // payload characters
 789                         scr_putc((noshow ? '*' : ch));
 790                         string[pos] = ch;
 791                         ++pos;
 792                 }
 793         }
 794 }
 795
 796
 797 // prompt for a string, print the existing value, and allow the user to press return to keep it...
 798 // If len is negative, pass the "noshow" flag to ctdl_getline()
 799 void strprompt(char *prompt, char *str, int len) {
 800         display_instant_messages();
 801         color(DIM_WHITE);
 802         scr_printf("%s", prompt);
 803         color(DIM_WHITE);
 804         scr_printf(": ");
 805         color(BRIGHT_CYAN);
 806         ctdl_getline(str, abs(len), (len < 0), 0);
 807         color(DIM_WHITE);
 808 }
 809
 810
 811 // prompt for a yes/no, print the existing value and allow the user to press return to keep it...
 812 int boolprompt(char *prompt, int prev_val) {
 813         int r;
 814
 815         color(DIM_WHITE);
 816         scr_printf("%s ", prompt);
 817         color(DIM_MAGENTA);
 818         scr_printf("[");
 819         color(BRIGHT_MAGENTA);
 820         scr_printf("%s", (prev_val ? "Yes" : "No"));
 821         color(DIM_MAGENTA);
 822         scr_printf("]: ");
 823         color(BRIGHT_CYAN);
 824         r = (yesno_d(prev_val));
 825         color(DIM_WHITE);
 826         return r;
 827 }
 828
 829
 830 // like strprompt(), except for an integer (note that it RETURNS the new value!)
 831 int intprompt(char *prompt, int ival, int imin, int imax) {
 832         char buf[16];
 833         int i;
 834         int p;
 835
 836         do {
 837                 i = ival;
 838                 snprintf(buf, sizeof buf, "%d", i);
 839                 strprompt(prompt, buf, 15);
 840                 i = atoi(buf);
 841                 for (p = 0; !IsEmptyStr(&buf[p]); ++p) {
 842                         if ((!isdigit(buf[p]))
 843                             && ((buf[p] != '-') || (p != 0)))
 844                                 i = imin - 1;
 845                 }
 846                 if (i < imin)
 847                         scr_printf("*** Must be no less than %d.\n", imin);
 848                 if (i > imax)
 849                         scr_printf("*** Must be no more than %d.\n", imax);
 850         } while ((i < imin) || (i > imax));
 851         return (i);
 852 }
 853
 854
 855 // prompt for a string with no existing value (clears out string buffer first)
 856 // If len is negative, pass the "noshow" flag to ctdl_getline()
 857 void newprompt(char *prompt, char *str, int len) {
 858         str[0] = 0;
 859         color(BRIGHT_MAGENTA);
 860         scr_printf("%s", prompt);
 861         color(DIM_MAGENTA);
 862         ctdl_getline(str, abs(len), (len < 0), 0);
 863         color(DIM_WHITE);
 864 }
 865
 866
 867 // returns a lower case value
 868 int lkey(void) {
 869         int a;
 870         a = inkey();
 871         if (isupper(a))
 872                 a = tolower(a);
 873         return (a);
 874 }
 875
 876
 877 // parse the citadel.rc file
 878 void load_command_set(void) {
 879         FILE *ccfile;
 880         char buf[1024];
 881         struct citcmd *cptr;
 882         struct citcmd *lastcmd = NULL;
 883         int a, d;
 884         int b = 0;
 885
 886         // first, set up some defaults for non-required variables
 887         strcpy(editor_path, "");
 888         strcpy(printcmd, "");
 889         strcpy(imagecmd, "");
 890         strcpy(rc_username, "");
 891         strcpy(rc_password, "");
 892         rc_floor_mode = 0;
 893         rc_exp_beep = 1;
 894         rc_allow_attachments = 0;
 895         rc_remember_passwords = 0;
 896         strcpy(rc_exp_cmd, "");
 897         rc_display_message_numbers = 0;
 898         rc_force_mail_prompts = 0;
 899         rc_ansi_color = 0;
 900         rc_color_use_bg = 0;
 901         strcpy(rc_url_cmd, "");
 902         strcpy(rc_open_cmd, "");
 903         strcpy(rc_gotmail_cmd, "");
 904 #ifdef HAVE_OPENSSL
 905         rc_encrypt = RC_DEFAULT;
 906 #endif
 907
 908         // now try to open the citadel.rc file
 909         ccfile = NULL;
 910         if (getenv("HOME") != NULL) {
 911                 snprintf(buf, sizeof buf, "%s/.citadelrc", getenv("HOME"));
 912                 ccfile = fopen(buf, "r");
 913         }
 914         if (getenv("APPDIR") != NULL) {
 915                 snprintf(buf, sizeof buf, "%s/citadel.rc", getenv("APPDIR"));
 916                 ccfile = fopen(buf, "r");
 917         }
 918         if (ccfile == NULL) {
 919                 ccfile = fopen(file_citadel_rc, "r");
 920         }
 921         if (ccfile == NULL) {
 922                 ccfile = fopen("/usr/local/etc/citadel.rc", "r");
 923         }
 924         if (ccfile == NULL) {
 925                 ccfile = fopen("/etc/citadel.rc", "r");
 926         }
 927         if (ccfile == NULL) {
 928                 ccfile = fopen("./citadel.rc", "r");
 929         }
 930         if (ccfile == NULL) {
 931                 perror("commands: cannot open citadel.rc");
 932                 logoff(NULL, 3);
 933         }
 934         while (fgets(buf, sizeof buf, ccfile) != NULL) {
 935                 while ((!IsEmptyStr(buf)) ? (isspace(buf[strlen(buf) - 1])) : 0)
 936                         buf[strlen(buf) - 1] = 0;
 937
 938                 if (!strncasecmp(buf, "encrypt=", 8)) {
 939                         if (!strcasecmp(&buf[8], "yes")) {
 940 #ifdef HAVE_OPENSSL
 941                                 rc_encrypt = RC_YES;
 942 #else
 943                                 fprintf(stderr, "citadel.rc requires encryption support but citadel is not compiled with OpenSSL");
 944                                 logoff(NULL, 3);
 945 #endif
 946                         }
 947 #ifdef HAVE_OPENSSL
 948                         else if (!strcasecmp(&buf[8], "no")) {
 949                                 rc_encrypt = RC_NO;
 950                         }
 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
1350                 // Character-by-character input instead of line mode
1351                 live.c_iflag = ISTRIP | IXON | IXANY;
1352                 live.c_oflag = OPOST | ONLCR;
1353                 live.c_lflag = ISIG | NOFLSH;
1354
1355                 // Key bindings
1356                 live.c_cc[VINTR] = 0;
1357                 live.c_cc[VQUIT] = 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
1367         if (cmd == 2) {
1368                 tcgetattr(0, &saved_settings);
1369         }
1370
1371         if (cmd == 3) {
1372                 tcsetattr(0, TCSADRAIN, &saved_settings);
1373         }
1374
1375 }
1376
1377
1378 // display_help()  -  help text viewer
1379 void display_help(CtdlIPC * ipc, char *name) {
1380         int i;
1381         int num_helps = sizeof(helpnames) / sizeof(char *);
1382
1383         for (i = 0; i < num_helps; ++i) {
1384                 if (!strcasecmp(name, helpnames[i])) {
1385                         fmout(screenwidth, NULL, helptexts[i], NULL, 0);
1386                         return;
1387                 }
1388         }
1389
1390         scr_printf("'%s' not found.  Enter one of:\n", name);
1391         for (i = 0; i < num_helps; ++i) {
1392                 scr_printf("  %s\n", helpnames[i]);
1393         }
1394 }
1395
1396
1397 // fmout() - Citadel text formatter and paginator
1398 int fmout(int width,            // screen width to use
1399           FILE * fpin,          // file to read from, or NULL to format given text
1400           char *text,           // text to be formatted (when fpin is NULL
1401           FILE * fpout,         // file to write to, or NULL to write to screen
1402           int subst) {          // nonzero if we should use hypertext mode
1403         char *buffer = NULL;    // The current message
1404         char *word = NULL;      // What we are about to actually print
1405         char *e;                // Pointer to position in text
1406         char old = 0;           // The previous character
1407         int column = 0;         // Current column
1408         size_t i;               // Generic counter
1409
1410         // Space for a single word, which can be at most screenwidth
1411         word = (char *) calloc(1, width);
1412         if (!word) {
1413                 scr_printf("Can't alloc memory to print message: %s!\n", strerror(errno));
1414                 logoff(NULL, 3);
1415         }
1416
1417         // Read the entire message body into memory
1418         if (fpin) {
1419                 buffer = load_message_from_file(fpin);
1420                 if (!buffer) {
1421                         scr_printf("Can't print message: %s!\n", strerror(errno));
1422                         logoff(NULL, 3);
1423                 }
1424         }
1425         else {
1426                 buffer = text;
1427         }
1428         e = buffer;
1429
1430         // Run the message body
1431         while (*e) {
1432                 // Catch characters that shouldn't be there at all
1433                 if (*e == '\r') {
1434                         e++;
1435                         continue;
1436                 }
1437                 if (*e == '\n') {       // newline?
1438                         e++;
1439                         if (*e == ' ') {        // paragraph?
1440                                 if (fpout) {
1441                                         fprintf(fpout, "\n");
1442                                 }
1443                                 else {
1444                                         scr_printf("\n");
1445                                 }
1446                                 column = 0;
1447                         }
1448                         else if (old != ' ') {  // Don't print two spaces
1449                                 if (fpout) {
1450                                         fprintf(fpout, " ");
1451                                 }
1452                                 else {
1453                                         scr_printf(" ");
1454                                 }
1455                                 column++;
1456                         }
1457                         old = '\n';
1458                         continue;
1459                 }
1460
1461                 // Or are we looking at a space?
1462                 if (*e == ' ') {
1463                         e++;
1464                         if (column >= width - 1) {
1465                                 // Are we in the rightmost column?
1466                                 if (fpout) {
1467                                         fprintf(fpout, "\n");
1468                                 }
1469                                 else {
1470                                         scr_printf("\n");
1471                                 }
1472                                 column = 0;
1473                         }
1474                         else if (!(column == 0 && old == ' ')) {
1475                                 // Eat only the first space on a line
1476                                 if (fpout) {
1477                                         fprintf(fpout, " ");
1478                                 }
1479                                 else {
1480                                         scr_printf(" ");
1481                                 }
1482                                 column++;
1483                         }
1484                         // ONLY eat the FIRST space on a line
1485                         old = ' ';
1486                         continue;
1487                 }
1488                 old = *e;
1489
1490                 // Read a word, slightly messy
1491                 i = 0;
1492                 while (e[i]) {
1493                         if (!isprint(e[i]) && !isspace(e[i]))
1494                                 e[i] = ' ';
1495                         if (isspace(e[i]))
1496                                 break;
1497                         i++;
1498                 }
1499
1500                 // We should never see these, but... slightly messy
1501                 if (e[i] == '\t' || e[i] == '\f' || e[i] == '\v')
1502                         e[i] = ' ';
1503
1504                 // Break up really long words
1505                 if (i >= width) {
1506                         i = width - 1;
1507                 }
1508                 strncpy(word, e, i);
1509                 word[i] = 0;
1510
1511                 // Decide where to print the word
1512                 if (column + i >= width) {
1513                         // Wrap to the next line
1514                         if (fpout) {
1515                                 fprintf(fpout, "\n");
1516                         }
1517                         else {
1518                                 scr_printf("\n");
1519                         }
1520                         column = 0;
1521                 }
1522
1523                 // Print the word
1524                 if (fpout) {
1525                         fprintf(fpout, "%s", word);
1526                 }
1527                 else {
1528                         scr_printf("%s", word);
1529                 }
1530                 column += i;
1531                 e += i;         // Start over with the whitepsace!
1532         }
1533
1534         free(word);
1535         if (fpin)               /* We allocated this, remember? */
1536                 free(buffer);
1537
1538         // Is this necessary?  It makes the output kind of spacey.
1539         if (fpout) {
1540                 fprintf(fpout, "\n");
1541         }
1542         else {
1543                 scr_printf("\n");
1544         }
1545
1546         return sigcaught;
1547 }
1548
1549
1550 // support ANSI color if defined
1551 void color(int colornum) {
1552         static int hold_color;
1553         static int current_color;
1554
1555         if (colornum == COLOR_PUSH) {
1556                 hold_color = current_color;
1557                 return;
1558         }
1559
1560         if (colornum == COLOR_POP) {
1561                 color(hold_color);
1562                 return;
1563         }
1564
1565         current_color = colornum;
1566         if (enable_color) {
1567                 // When switching to dim white, actually output an 'original
1568                 // pair' sequence -- this looks better on black-on-white
1569                 // terminals. - Changed to ORIGINAL_PAIR as this actually
1570                 // wound up looking horrible on black-on-white terminals, not
1571                 // to mention transparent terminals.
1572                 if (colornum == ORIGINAL_PAIR)
1573                         printf("\033[0;39;49m");
1574                 else
1575                         printf("\033[%d;3%d;4%dm", (colornum & 8) ? 1 : 0, (colornum & 7), rc_color_use_bg);
1576
1577         }
1578 }
1579
1580
1581 // Clear the screen
1582 void cls(int colornum) {
1583         if (enable_color) {
1584                 printf("\033[4%dm\033[2J\033[H\033[0m", colornum ? colornum : rc_color_use_bg);
1585         }
1586 }
1587
1588
1589 // Detect whether ANSI color is available (answerback)
1590 void send_ansi_detect(void) {
1591         if (rc_ansi_color == 2) {
1592                 printf("\033[c");
1593                 scr_flush();
1594                 time(&AnsiDetect);
1595         }
1596 }
1597
1598
1599 void look_for_ansi(void) {
1600         fd_set rfds;
1601         struct timeval tv;
1602         char abuf[512];
1603         time_t now;
1604         int a, rv;
1605
1606         if (rc_ansi_color == 0) {
1607                 enable_color = 0;
1608         }
1609         else if (rc_ansi_color == 1) {
1610                 enable_color = 1;
1611         }
1612         else if (rc_ansi_color == 2) {
1613
1614                 /* otherwise, do the auto-detect */
1615
1616                 strcpy(abuf, "");
1617
1618                 time(&now);
1619                 if ((now - AnsiDetect) < 2)
1620                         sleep(1);
1621
1622                 do {
1623                         FD_ZERO(&rfds);
1624                         FD_SET(0, &rfds);
1625                         tv.tv_sec = 0;
1626                         tv.tv_usec = 1;
1627
1628                         select(1, &rfds, NULL, NULL, &tv);
1629                         if (FD_ISSET(0, &rfds)) {
1630                                 abuf[strlen(abuf) + 1] = 0;
1631                                 rv = read(0, &abuf[strlen(abuf)], 1);
1632                                 if (rv < 0) {
1633                                         scr_printf("failed to read after select: %s", strerror(errno));
1634                                         break;
1635                                 }
1636                         }
1637                 } while (FD_ISSET(0, &rfds));
1638
1639                 for (a = 0; !IsEmptyStr(&abuf[a]); ++a) {
1640                         if ((abuf[a] == 27) && (abuf[a + 1] == '[')
1641                             && (abuf[a + 2] == '?')) {
1642                                 enable_color = 1;
1643                         }
1644                 }
1645         }
1646 }
1647
1648
1649 // Display key options (highlight hotkeys inside angle brackets)
1650 void keyopt(char *buf) {
1651         int i;
1652
1653         color(DIM_WHITE);
1654         for (i = 0; !IsEmptyStr(&buf[i]); ++i) {
1655                 if (buf[i] == '<') {
1656                         scr_printf("%c", buf[i]);
1657                         color(BRIGHT_MAGENTA);
1658                 }
1659                 else {
1660                         if (buf[i] == '>' && buf[i + 1] != '>') {
1661                                 color(DIM_WHITE);
1662                         }
1663                         scr_printf("%c", buf[i]);
1664                 }
1665         }
1666         color(DIM_WHITE);
1667 }
1668
1669
1670 // Present a key-menu line choice type of thing
1671 char keymenu(char *menuprompt, char *menustring) {
1672         int i, c, a;
1673         int choices;
1674         int do_prompt = 0;
1675         char buf[1024];
1676         int ch;
1677         int display_prompt = 1;
1678
1679         choices = num_tokens(menustring, '|');
1680
1681         if (menuprompt != NULL)
1682                 do_prompt = 1;
1683         if ((menuprompt != NULL) && (IsEmptyStr(menuprompt)))
1684                 do_prompt = 0;
1685
1686         while (1) {
1687                 if (display_prompt) {
1688                         if (do_prompt) {
1689                                 scr_printf("%s ", menuprompt);
1690                         }
1691                         else {
1692                                 for (i = 0; i < choices; ++i) {
1693                                         extract_token(buf, menustring, i, '|', sizeof buf);
1694                                         keyopt(buf);
1695                                         scr_printf(" ");
1696                                 }
1697                         }
1698                         scr_printf("-> ");
1699                         display_prompt = 0;
1700                 }
1701                 ch = lkey();
1702
1703                 if ((do_prompt) && (ch == '?')) {
1704                         scr_printf("\rOne of...                               ");
1705                         scr_printf("                                      \n");
1706                         for (i = 0; i < choices; ++i) {
1707                                 extract_token(buf, menustring, i, '|', sizeof buf);
1708                                 scr_printf("   ");
1709                                 keyopt(buf);
1710                                 scr_printf("\n");
1711                         }
1712                         scr_printf("\n");
1713                         display_prompt = 1;
1714                 }
1715
1716                 for (i = 0; i < choices; ++i) {
1717                         extract_token(buf, menustring, i, '|', sizeof buf);
1718                         for (c = 1; !IsEmptyStr(&buf[c]); ++c) {
1719                                 if ((ch == tolower(buf[c]))
1720                                     && (buf[c - 1] == '<')
1721                                     && (buf[c + 1] == '>')) {
1722                                         for (a = 0; !IsEmptyStr(&buf[a]); ++a) {
1723                                                 if ((a != (c - 1)) && (a != (c + 1))) {
1724                                                         scr_putc(buf[a]);
1725                                                 }
1726                                         }
1727                                         scr_printf("\n");
1728                                         return ch;
1729                                 }
1730                         }
1731                 }
1732         }
1733 }