citadel/textclient/rooms.c

   1 /*
   2  * $Id$
   3  *
   4  *
   5  * Client-side functions which perform room operations
   6  *
   7  */
   8
   9 #include "sysdep.h"
  10 #include <stdlib.h>
  11 #include <unistd.h>
  12 #include <fcntl.h>
  13 #include <stdio.h>
  14 #include <ctype.h>
  15 #include <string.h>
  16 #include <signal.h>
  17 #include <sys/types.h>
  18 #include <sys/stat.h>
  19 #include <sys/wait.h>
  20 #include <errno.h>
  21 #include <stdarg.h>
  22 #include <libcitadel.h>
  23 #include "citadel.h"
  24 #include "citadel_ipc.h"
  25 #include "citadel_decls.h"
  26 #include "rooms.h"
  27 #include "commands.h"
  28 #include "messages.h"
  29 #ifndef HAVE_SNPRINTF
  30 #include "snprintf.h"
  31 #endif
  32 #include "screen.h"
  33 #include "citadel_dirs.h"
  34
  35 #define IFNEXPERT if ((userflags&US_EXPERT)==0)
  36
  37
  38 void stty_ctdl(int cmd);
  39 void dotgoto(CtdlIPC *ipc, char *towhere, int display_name, int fromungoto);
  40 void progress(CtdlIPC* ipc, unsigned long curr, unsigned long cmax);
  41 int pattern(char *search, char *patn);
  42 int file_checksum(char *filename);
  43 int nukedir(char *dirname);
  44
  45 extern unsigned room_flags;
  46 extern char room_name[];
  47 extern char temp[];
  48 extern char tempdir[];
  49 extern int editor_pid;
  50 extern int screenwidth;
  51 extern int screenheight;
  52 extern char fullname[];
  53 extern char sigcaught;
  54 extern char floor_mode;
  55 extern char curr_floor;
  56
  57
  58 extern int ugnum;
  59 extern long uglsn;
  60 extern char *uglist[];
  61 extern long uglistlsn[];
  62 extern int uglistsize;
  63
  64 extern char floorlist[128][SIZ];
  65
  66
  67 void load_floorlist(CtdlIPC *ipc)
  68 {
  69         int a;
  70         char buf[SIZ];
  71         char *listing = NULL;
  72         int r;                  /* IPC response code */
  73
  74         for (a = 0; a < 128; ++a)
  75                 floorlist[a][0] = 0;
  76
  77         r = CtdlIPCFloorListing(ipc, &listing, buf);
  78         if (r / 100 != 1) {
  79                 strcpy(floorlist[0], "Main Floor");
  80                 return;
  81         }
  82         while (*listing && !IsEmptyStr(listing)) {
  83                 extract_token(buf, listing, 0, '\n', sizeof buf);
  84                 remove_token(listing, 0, '\n');
  85                 extract_token(floorlist[extract_int(buf, 0)], buf, 1, '|', SIZ);
  86         }
  87         free(listing);
  88 }
  89
  90
  91 void room_tree_list(struct ctdlroomlisting *rp)
  92 {
  93         static int c = 0;
  94         char rmname[ROOMNAMELEN];
  95         int f;
  96
  97         if (rp == NULL) {
  98                 c = 1;
  99                 return;
 100         }
 101
 102         if (rp->lnext != NULL) {
 103                 room_tree_list(rp->lnext);
 104         }
 105
 106         if (sigcaught == 0) {
 107                 strcpy(rmname, rp->rlname);
 108                 f = rp->rlflags;
 109                 if ((c + strlen(rmname) + 4) > screenwidth) {
 110
 111                         /* line break, check the paginator */
 112                         pprintf("\n");
 113                         c = 1;
 114                 }
 115                 if (f & QR_MAILBOX) {
 116                         color(BRIGHT_YELLOW);
 117                 } else if (f & QR_PRIVATE) {
 118                         color(BRIGHT_RED);
 119                 } else {
 120                         color(DIM_WHITE);
 121                 }
 122                 pprintf("%s", rmname);
 123                 if ((f & QR_DIRECTORY) && (f & QR_NETWORK))
 124                         pprintf("}  ");
 125                 else if (f & QR_DIRECTORY)
 126                         pprintf("]  ");
 127                 else if (f & QR_NETWORK)
 128                         pprintf(")  ");
 129                 else
 130                         pprintf(">  ");
 131                 c = c + strlen(rmname) + 3;
 132         }
 133
 134         if (rp->rnext != NULL) {
 135                 room_tree_list(rp->rnext);
 136         }
 137
 138         free(rp);
 139 }
 140
 141
 142 /*
 143  * Room ordering stuff (compare first by floor, then by order)
 144  */
 145 int rordercmp(struct ctdlroomlisting *r1, struct ctdlroomlisting *r2)
 146 {
 147         if ((r1 == NULL) && (r2 == NULL))
 148                 return (0);
 149         if (r1 == NULL)
 150                 return (-1);
 151         if (r2 == NULL)
 152                 return (1);
 153         if (r1->rlfloor < r2->rlfloor)
 154                 return (-1);
 155         if (r1->rlfloor > r2->rlfloor)
 156                 return (1);
 157         if (r1->rlorder < r2->rlorder)
 158                 return (-1);
 159         if (r1->rlorder > r2->rlorder)
 160                 return (1);
 161         return (0);
 162 }
 163
 164
 165 /*
 166  * Common code for all room listings
 167  */
 168 static void listrms(struct march *listing, int new_only, int floor_only, unsigned int flags, char *match)
 169 {
 170         struct march *mptr;
 171         struct ctdlroomlisting *rl = NULL;
 172         struct ctdlroomlisting *rp;
 173         struct ctdlroomlisting *rs;
 174         int list_it;
 175
 176         for (mptr = listing; mptr != NULL; mptr = mptr->next) {
 177                 list_it = 1;
 178
 179                 if ( (new_only == LISTRMS_NEW_ONLY)
 180                    && ((mptr->march_access & UA_HASNEWMSGS) == 0))
 181                         list_it = 0;
 182
 183                 if ( (new_only == LISTRMS_OLD_ONLY)
 184                    && ((mptr->march_access & UA_HASNEWMSGS) != 0))
 185                         list_it = 0;
 186
 187                 if ( (floor_only >= 0)
 188                    && (mptr->march_floor != floor_only))
 189                         list_it = 0;
 190
 191                 if (flags && (mptr->march_flags & flags) == 0)
 192                     list_it = 0;
 193
 194             if (match && (pattern(mptr->march_name, match) == -1))
 195                         list_it = 0;
 196
 197                 if (list_it) {
 198                         rp = malloc(sizeof(struct ctdlroomlisting));
 199                         strncpy(rp->rlname, mptr->march_name, ROOMNAMELEN);
 200                         rp->rlflags = mptr->march_flags;
 201                         rp->rlfloor = mptr->march_floor;
 202                         rp->rlorder = mptr->march_order;
 203                         rp->lnext = NULL;
 204                         rp->rnext = NULL;
 205
 206                         rs = rl;
 207                         if (rl == NULL) {
 208                                 rl = rp;
 209                         } else {
 210                                 while (rp != NULL) {
 211                                         if (rordercmp(rp, rs) < 0) {
 212                                                 if (rs->lnext == NULL) {
 213                                                         rs->lnext = rp;
 214                                                         rp = NULL;
 215                                                 } else {
 216                                                         rs = rs->lnext;
 217                                                 }
 218                                         } else {
 219                                                 if (rs->rnext == NULL) {
 220                                                         rs->rnext = rp;
 221                                                         rp = NULL;
 222                                                 } else {
 223                                                         rs = rs->rnext;
 224                                                 }
 225                                         }
 226                                 }
 227                         }
 228                 }
 229         }
 230
 231         room_tree_list(NULL);
 232         room_tree_list(rl);
 233         color(DIM_WHITE);
 234 }
 235
 236
 237 void list_other_floors(void)
 238 {
 239         int a, c;
 240
 241         c = 1;
 242         for (a = 0; a < 128; ++a) {
 243                 if ((strlen(floorlist[a]) > 0) && (a != curr_floor)) {
 244                         if ((c + strlen(floorlist[a]) + 4) > screenwidth) {
 245                                 pprintf("\n");
 246                                 c = 1;
 247                         }
 248                         pprintf("%s:  ", floorlist[a]);
 249                         c = c + strlen(floorlist[a]) + 3;
 250                 }
 251         }
 252 }
 253
 254
 255 /*
 256  * List known rooms.  kn_floor_mode should be set to 0 for a 'flat' listing,
 257  * 1 to list rooms on the current floor, or 2 to list rooms on all floors.
 258  */
 259 void knrooms(CtdlIPC *ipc, int kn_floor_mode)
 260 {
 261         int a;
 262         struct march *listing = NULL;
 263         struct march *mptr;
 264         int r;          /* IPC response code */
 265         char buf[SIZ];
 266
 267
 268         /* Ask the server for a room list */
 269         r = CtdlIPCKnownRooms(ipc, SubscribedRooms, (-1), &listing, buf);
 270         if (r / 100 != 1) {
 271                 listing = NULL;
 272         }
 273
 274         load_floorlist(ipc);
 275
 276
 277         if (kn_floor_mode == 0) {
 278                 color(BRIGHT_CYAN);
 279                 pprintf("\n   Rooms with unread messages:\n");
 280                 listrms(listing, LISTRMS_NEW_ONLY, -1, 0, NULL);
 281                 color(BRIGHT_CYAN);
 282                 pprintf("\n\n   No unseen messages in:\n");
 283                 listrms(listing, LISTRMS_OLD_ONLY, -1, 0, NULL);
 284                 pprintf("\n");
 285         }
 286
 287         if (kn_floor_mode == 1) {
 288                 color(BRIGHT_CYAN);
 289                 pprintf("\n   Rooms with unread messages on %s:\n",
 290                         floorlist[(int) curr_floor]);
 291                 listrms(listing, LISTRMS_NEW_ONLY, curr_floor, 0, NULL);
 292                 color(BRIGHT_CYAN);
 293                 pprintf("\n\n   Rooms with no new messages on %s:\n",
 294                         floorlist[(int) curr_floor]);
 295                 listrms(listing, LISTRMS_OLD_ONLY, curr_floor, 0, NULL);
 296                 color(BRIGHT_CYAN);
 297                 pprintf("\n\n   Other floors:\n");
 298                 list_other_floors();
 299                 pprintf("\n");
 300         }
 301
 302         if (kn_floor_mode == 2) {
 303                 for (a = 0; a < 128; ++a) {
 304                         if (floorlist[a][0] != 0) {
 305                                 color(BRIGHT_CYAN);
 306                                 pprintf("\n   Rooms on %s:\n",
 307                                         floorlist[a]);
 308                                 listrms(listing, LISTRMS_ALL, a, 0, NULL);
 309                                 pprintf("\n");
 310                         }
 311                 }
 312         }
 313
 314         /* Free the room list */
 315         while (listing) {
 316                 mptr = listing->next;
 317                 free(listing);
 318                 listing = mptr;
 319         };
 320
 321         color(DIM_WHITE);
 322         IFNEXPERT hit_any_key(ipc);
 323 }
 324
 325
 326 void listzrooms(CtdlIPC *ipc)
 327 {                               /* list public forgotten rooms */
 328         struct march *listing = NULL;
 329         struct march *mptr;
 330         int r;          /* IPC response code */
 331         char buf[SIZ];
 332
 333
 334         /* Ask the server for a room list */
 335         r = CtdlIPCKnownRooms(ipc, UnsubscribedRooms, (-1), &listing, buf);
 336         if (r / 100 != 1) {
 337                 listing = NULL;
 338         }
 339
 340         color(BRIGHT_CYAN);
 341         pprintf("\n   Forgotten public rooms:\n");
 342         listrms(listing, LISTRMS_ALL, -1, 0, NULL);
 343         pprintf("\n");
 344
 345         /* Free the room list */
 346         while (listing) {
 347                 mptr = listing->next;
 348                 free(listing);
 349                 listing = mptr;
 350         };
 351
 352         color(DIM_WHITE);
 353         IFNEXPERT hit_any_key(ipc);
 354 }
 355
 356 void dotknown(CtdlIPC *ipc, int what, char *match)
 357 {                               /* list rooms according to attribute */
 358         struct march *listing = NULL;
 359         struct march *mptr;
 360         int r;          /* IPC response code */
 361         char buf[SIZ];
 362
 363         /* Ask the server for a room list */
 364         r = CtdlIPCKnownRooms(ipc, AllAccessibleRooms, (-1), &listing, buf);
 365         if (r / 100 != 1) {
 366                 listing = NULL;
 367         }
 368
 369         color(BRIGHT_CYAN);
 370
 371         switch (what) {
 372     case 0:
 373         pprintf("\n   Anonymous rooms:\n");
 374             listrms(listing, LISTRMS_ALL, -1, QR_ANONONLY|QR_ANONOPT, NULL);
 375         pprintf("\n");
 376                 break;
 377     case 1:
 378         pprintf("\n   Directory rooms:\n");
 379             listrms(listing, LISTRMS_ALL, -1, QR_DIRECTORY, NULL);
 380         pprintf("\n");
 381                 break;
 382     case 2:
 383         pprintf("\n   Matching \"%s\" rooms:\n", match);
 384             listrms(listing, LISTRMS_ALL, -1, 0, match);
 385         pprintf("\n");
 386                 break;
 387     case 3:
 388         pprintf("\n   Preferred only rooms:\n");
 389             listrms(listing, LISTRMS_ALL, -1, QR_PREFONLY, NULL);
 390         pprintf("\n");
 391                 break;
 392     case 4:
 393         pprintf("\n   Private rooms:\n");
 394             listrms(listing, LISTRMS_ALL, -1, QR_PRIVATE, NULL);
 395         pprintf("\n");
 396                 break;
 397     case 5:
 398         pprintf("\n   Read only rooms:\n");
 399             listrms(listing, LISTRMS_ALL, -1, QR_READONLY, NULL);
 400         pprintf("\n");
 401                 break;
 402     case 6:
 403         pprintf("\n   Shared rooms:\n");
 404             listrms(listing, LISTRMS_ALL, -1, QR_NETWORK, NULL);
 405         pprintf("\n");
 406                 break;
 407         }
 408
 409         /* Free the room list */
 410         while (listing) {
 411                 mptr = listing->next;
 412                 free(listing);
 413                 listing = mptr;
 414         };
 415
 416         color(DIM_WHITE);
 417         IFNEXPERT hit_any_key(ipc);
 418 }
 419
 420
 421 int set_room_attr(CtdlIPC *ipc, unsigned int ibuf, char *prompt, unsigned int sbit)
 422 {
 423         int a;
 424
 425         a = boolprompt(prompt, (ibuf & sbit));
 426         ibuf = (ibuf | sbit);
 427         if (!a) {
 428                 ibuf = (ibuf ^ sbit);
 429         }
 430         return (ibuf);
 431 }
 432
 433
 434
 435 /*
 436  * Select a floor (used in several commands)
 437  * The supplied argument is the 'default' floor number.
 438  * This function returns the selected floor number.
 439  */
 440 int select_floor(CtdlIPC *ipc, int rfloor)
 441 {
 442         int a, newfloor;
 443         char floorstr[SIZ];
 444
 445         if (floor_mode == 1) {
 446                 if (floorlist[(int) curr_floor][0] == 0) {
 447                         load_floorlist(ipc);
 448                 }
 449
 450                 do {
 451                         newfloor = (-1);
 452                         safestrncpy(floorstr, floorlist[rfloor],
 453                                     sizeof floorstr);
 454                         strprompt("Which floor", floorstr, 255);
 455                         for (a = 0; a < 128; ++a) {
 456                                 if (!strcasecmp
 457                                     (floorstr, &floorlist[a][0]))
 458                                         newfloor = a;
 459                                 if ((newfloor < 0)
 460                                     &&
 461                                     (!strncasecmp
 462                                      (floorstr, &floorlist[a][0],
 463                                       strlen(floorstr))))
 464                                         newfloor = a;
 465                                 if ((newfloor < 0)
 466                                     && (pattern(&floorlist[a][0], floorstr)
 467                                         >= 0))
 468                                         newfloor = a;
 469                         }
 470                         if (newfloor < 0) {
 471                                 scr_printf("\n One of:\n");
 472                                 for (a = 0; a < 128; ++a) {
 473                                         if (floorlist[a][0] != 0) {
 474                                                 scr_printf("%s\n",
 475                                                        &floorlist[a][0]);
 476                                         }
 477                                 }
 478                         }
 479                 } while (newfloor < 0);
 480                 return (newfloor);
 481         }
 482
 483         else {
 484                 scr_printf("Floor selection bypassed because you have "
 485                         "floor mode disabled.\n");
 486         }
 487
 488         return (rfloor);
 489 }
 490
 491
 492
 493
 494 /*
 495  * .<A>ide <E>dit room
 496  */
 497 void editthisroom(CtdlIPC *ipc)
 498 {
 499         int rbump = 0;
 500         char raide[USERNAME_SIZE];
 501         char buf[SIZ];
 502         struct ctdlroom *attr = NULL;
 503         struct ExpirePolicy *eptr = NULL;
 504         int r;                          /* IPC response code */
 505
 506         /* Fetch the existing room config */
 507         r = CtdlIPCGetRoomAttributes(ipc, &attr, buf);
 508         if (r / 100 != 2) {
 509                 scr_printf("%s\n", buf);
 510                 return;
 511         }
 512         eptr = &(attr->QRep);
 513
 514         /* Fetch the name of the current room aide */
 515         r = CtdlIPCGetRoomAide(ipc, buf);
 516         if (r / 100 == 2) {
 517                 safestrncpy(raide, buf, sizeof raide);
 518         } else {
 519                 strcpy(raide, "");
 520         }
 521         if (IsEmptyStr(raide)) {
 522                 strcpy(raide, "none");
 523         }
 524
 525         /* Fetch the expire policy (this will silently fail on old servers,
 526          * resulting in "default" policy)
 527          */
 528         r = CtdlIPCGetMessageExpirationPolicy(ipc, 0, &eptr, buf);
 529
 530         /* Now interact with the user. */
 531
 532         strprompt("Room name", attr->QRname, ROOMNAMELEN-1);
 533         attr->QRfloor = select_floor(ipc, attr->QRfloor);
 534         attr->QRflags = set_room_attr(ipc, attr->QRflags, "Private room", QR_PRIVATE);
 535         if (attr->QRflags & QR_PRIVATE) {
 536                 attr->QRflags = set_room_attr(ipc, attr->QRflags,
 537                                        "Hidden room (accessible to anyone who knows the room name)",
 538                                        QR_GUESSNAME);
 539         }
 540
 541         /* if it's public, clear the privacy classes */
 542         if ((attr->QRflags & QR_PRIVATE) == 0) {
 543                 if (attr->QRflags & QR_GUESSNAME) {
 544                         attr->QRflags = attr->QRflags - QR_GUESSNAME;
 545                 }
 546                 if (attr->QRflags & QR_PASSWORDED) {
 547                         attr->QRflags = attr->QRflags - QR_PASSWORDED;
 548                 }
 549         }
 550
 551         /* if it's private, choose the privacy classes */
 552         if ((attr->QRflags & QR_PRIVATE)
 553             && ((attr->QRflags & QR_GUESSNAME) == 0)) {
 554                 attr->QRflags = set_room_attr(ipc, attr->QRflags,
 555                                        "Accessible by entering a password",
 556                                        QR_PASSWORDED);
 557         }
 558         if ((attr->QRflags & QR_PRIVATE)
 559             && ((attr->QRflags & QR_PASSWORDED) == QR_PASSWORDED)) {
 560                 strprompt("Room password", attr->QRpasswd, 9);
 561         }
 562
 563         if ((attr->QRflags & QR_PRIVATE) == QR_PRIVATE) {
 564                 rbump = boolprompt("Cause current users to forget room", 0);
 565         }
 566
 567         attr->QRflags = set_room_attr(ipc, attr->QRflags,
 568                                         "Preferred users only", QR_PREFONLY);
 569         attr->QRflags = set_room_attr(ipc, attr->QRflags,
 570                                         "Read-only room", QR_READONLY);
 571         attr->QRflags2 = set_room_attr(ipc, attr->QRflags2,
 572                                 "Allow message deletion by anyone who can post",
 573                                 QR2_COLLABDEL);
 574         attr->QRflags = set_room_attr(ipc, attr->QRflags,
 575                                         "Permanent room", QR_PERMANENT);
 576         attr->QRflags2 = set_room_attr(ipc, attr->QRflags2,
 577                                                                    "Subject Required (Force "
 578                                                                    "users to specify a message "
 579                                    "subject)", QR2_SUBJECTREQ);
 580         attr->QRflags = set_room_attr(ipc, attr->QRflags,
 581                                         "Directory room", QR_DIRECTORY);
 582         if (attr->QRflags & QR_DIRECTORY) {
 583                 strprompt("Directory name", attr->QRdirname, 14);
 584                 attr->QRflags =
 585                     set_room_attr(ipc, attr->QRflags,
 586                                                 "Uploading allowed", QR_UPLOAD);
 587                 attr->QRflags =
 588                     set_room_attr(ipc, attr->QRflags, "Downloading allowed",
 589                                   QR_DOWNLOAD);
 590                 attr->QRflags =
 591                     set_room_attr(ipc, attr->QRflags,
 592                                                 "Visible directory", QR_VISDIR);
 593         }
 594         attr->QRflags = set_room_attr(ipc, attr->QRflags,
 595                                         "Network shared room", QR_NETWORK);
 596         attr->QRflags2 = set_room_attr(ipc, attr->QRflags2,
 597                                 "Self-service list subscribe/unsubscribe",
 598                                 QR2_SELFLIST);
 599         attr->QRflags2 = set_room_attr(ipc, attr->QRflags2,
 600                                 "public posting to this room via room_roomname@yourcitadel.org",
 601                                 QR2_SMTP_PUBLIC);
 602         attr->QRflags2 = set_room_attr(ipc, attr->QRflags2,
 603                                 "moderated mailinglist",
 604                                 QR2_MODERATED);
 605         attr->QRflags = set_room_attr(ipc, attr->QRflags,
 606                                "Automatically make all messages anonymous",
 607                                QR_ANONONLY);
 608         if ((attr->QRflags & QR_ANONONLY) == 0) {
 609                 attr->QRflags = set_room_attr(ipc, attr->QRflags,
 610                                        "Ask users whether to make messages anonymous",
 611                                        QR_ANONOPT);
 612         }
 613         attr->QRorder = intprompt("Listing order", attr->QRorder, 0, 127);
 614
 615         /* Ask about the room aide */
 616         do {
 617                 strprompt("Room aide (or 'none')", raide, 29);
 618                 if (!strcasecmp(raide, "none")) {
 619                         strcpy(raide, "");
 620                         break;
 621                 } else {
 622                         r = CtdlIPCQueryUsername(ipc, raide, buf);
 623                         if (r / 100 != 2)
 624                                 scr_printf("%s\n", buf);
 625                 }
 626         } while (r / 100 != 2);
 627
 628         /* Angels and demons dancing in my head... */
 629         do {
 630                 snprintf(buf, sizeof buf, "%d", attr->QRep.expire_mode);
 631                 strprompt("Message expire policy (? for list)", buf, 1);
 632                 if (buf[0] == '?') {
 633                         scr_printf("\n"
 634                                 "0. Use the default for this floor\n"
 635                                 "1. Never automatically expire messages\n"
 636                                 "2. Expire by message count\n"
 637                                 "3. Expire by message age\n");
 638                 }
 639         } while ((buf[0] < 48) || (buf[0] > 51));
 640         attr->QRep.expire_mode = buf[0] - 48;
 641
 642         /* ...lunatics and monsters underneath my bed */
 643         if (attr->QRep.expire_mode == 2) {
 644                 snprintf(buf, sizeof buf, "%d", attr->QRep.expire_value);
 645                 strprompt("Keep how many messages online?", buf, 10);
 646                 attr->QRep.expire_value = atol(buf);
 647         }
 648
 649         if (attr->QRep.expire_mode == 3) {
 650                 snprintf(buf, sizeof buf, "%d", attr->QRep.expire_value);
 651                 strprompt("Keep messages for how many days?", buf, 10);
 652                 attr->QRep.expire_value = atol(buf);
 653         }
 654
 655         /* Give 'em a chance to change their minds */
 656         scr_printf("Save changes (y/n)? ");
 657
 658         if (yesno() == 1) {
 659                 r = CtdlIPCSetRoomAide(ipc, raide, buf);
 660                 if (r / 100 != 2) {
 661                         scr_printf("%s\n", buf);
 662                 }
 663
 664                 r = CtdlIPCSetMessageExpirationPolicy(ipc, 0, eptr, buf);
 665                 if (r / 100 != 2) {
 666                         scr_printf("%s\n", buf);
 667                 }
 668
 669                 r = CtdlIPCSetRoomAttributes(ipc, rbump, attr, buf);
 670                 scr_printf("%s\n", buf);
 671                 strncpy(buf, attr->QRname, ROOMNAMELEN);
 672                 free(attr);
 673                 if (r / 100 == 2)
 674                         dotgoto(ipc, buf, 2, 0);
 675         }
 676         else free(attr);
 677 }
 678
 679
 680 /*
 681  * un-goto the previous room, or a specified room
 682  */
 683 void dotungoto(CtdlIPC *ipc, char *towhere)
 684   {
 685     /* Find this 'towhere' room in the list ungoto from this room to
 686        that at the messagepointer position in that room in our ungoto list.
 687        I suppose I could be a real dick and just ungoto that many places
 688        in our list. */
 689     int found = -1;
 690     int lp;
 691         char buf[SIZ];
 692         struct ctdlipcroom *rret = NULL;        /* ignored */
 693         int r;
 694
 695         if (uglistsize == 0)
 696       {
 697                 scr_printf("No rooms to ungoto.\n");
 698                 return;
 699       }
 700         if (towhere == NULL)
 701       {
 702                 scr_printf("Must specify a room to ungoto.\n");
 703                 return;
 704       }
 705         if (IsEmptyStr(towhere))
 706       {
 707                 scr_printf("Must specify a room to ungoto.\n");
 708                 return;
 709       }
 710     for (lp = uglistsize-1; lp >= 0; lp--)
 711       {
 712         if (strcasecmp(towhere, uglist[lp]) == 0)
 713           {
 714             found = lp;
 715             break;
 716           }
 717       }
 718     if (found == -1)
 719       {
 720                 scr_printf("Room: %s not in ungoto list.\n", towhere);
 721         return;
 722       }
 723
 724         r = CtdlIPCGotoRoom(ipc, uglist[found], "", &rret, buf);
 725         if (rret) free(rret);   /* ignored */
 726         if (r / 100 != 2) {
 727                 scr_printf("%s\n", buf);
 728                 return;
 729         }
 730         r = CtdlIPCSetLastRead(ipc, uglistlsn[found] ? uglistlsn[found] : 1, buf);
 731         if (r / 100 != 2) {
 732                 scr_printf("%s\n", buf);
 733         }
 734         safestrncpy(buf, uglist[found], sizeof(buf));
 735     /* we queue ungoto information here, because we're not really
 736        ungotoing, we're really going to a random spot in some arbitrary
 737        room list. */
 738         dotgoto(ipc, buf, 0, 0);
 739   }
 740
 741 void ungoto(CtdlIPC *ipc)
 742 {
 743         char buf[SIZ];
 744         struct ctdlipcroom *rret = NULL;        /* ignored */
 745         int r;
 746
 747         if (uglistsize == 0)
 748                 return;
 749
 750         r = CtdlIPCGotoRoom(ipc, uglist[uglistsize-1], "", &rret, buf);
 751         if (rret) free(rret);   /* ignored */
 752         if (r / 100 != 2) {
 753                 scr_printf("%s\n", buf);
 754                 return;
 755         }
 756         r = CtdlIPCSetLastRead(ipc, uglistlsn[uglistsize-1] ? uglistlsn[uglistsize-1] : 1, buf);
 757         if (r / 100 != 2) {
 758                 scr_printf("%s\n", buf);
 759         }
 760         safestrncpy(buf, uglist[uglistsize-1], sizeof(buf));
 761         uglistsize--;
 762         free(uglist[uglistsize]);
 763         /* Don't queue ungoto info or we end up in a loop */
 764         dotgoto(ipc, buf, 0, 1);
 765 }
 766
 767
 768 /*
 769  * saves filelen bytes from file at pathname
 770  */
 771 int save_buffer(void *file, size_t filelen, const char *pathname)
 772 {
 773         size_t block = 0;
 774         size_t bytes_written = 0;
 775         FILE *fp;
 776
 777         fp = fopen(pathname, "w");
 778         if (!fp) {
 779                 err_printf("Cannot open '%s': %s\n", pathname, strerror(errno));
 780                 return 0;
 781         }
 782         do {
 783                 block = fwrite((char *)file + bytes_written, 1,
 784                                 filelen - bytes_written, fp);
 785                 bytes_written += block;
 786         } while (errno == EINTR && bytes_written < filelen);
 787         fclose(fp);
 788
 789         if (bytes_written < filelen) {
 790                 err_printf("Trouble saving '%s': %s\n", pathname,
 791                                 strerror(errno));
 792                 return 0;
 793         }
 794         return 1;
 795 }
 796
 797
 798 /*
 799  * Save supplied_filename in dest directory; gets the name only
 800  */
 801 void destination_directory(char *dest, const char *supplied_filename)
 802 {
 803         static char save_dir[SIZ] = { 0 };
 804
 805         if (IsEmptyStr(save_dir)) {
 806                 if (getenv("HOME") == NULL) {
 807                         strcpy(save_dir, ".");
 808                 }
 809                 else {
 810                         sprintf(save_dir, "%s/Desktop", getenv("HOME"));
 811                         if (access(save_dir, W_OK) != 0) {
 812                                 sprintf(save_dir, "%s", getenv("HOME"));
 813                                 if (access(save_dir, W_OK) != 0) {
 814                                         sprintf(save_dir, ".");
 815                                 }
 816                         }
 817                 }
 818         }
 819
 820         sprintf(dest, "%s/%s", save_dir, supplied_filename);
 821         strprompt("Save as", dest, PATH_MAX);
 822
 823         /* Remember the directory for next time */
 824         strcpy(save_dir, dest);
 825         if (strrchr(save_dir, '/') != NULL) {
 826                 strcpy(strrchr(save_dir, '/'), "");
 827         }
 828         else {
 829                 strcpy(save_dir, ".");
 830         }
 831 }
 832
 833
 834 /*
 835  * download()  -  download a file or files.  The argument passed to this
 836  *                function determines which protocol to use.
 837  *  proto - 0 = paginate, 1 = xmodem, 2 = raw, 3 = ymodem, 4 = zmodem, 5 = save
 838  */
 839 void download(CtdlIPC *ipc, int proto)
 840 {
 841         char buf[SIZ];
 842         char filename[PATH_MAX];
 843         char tempname[PATH_MAX];
 844         char transmit_cmd[SIZ];
 845         FILE *tpipe = NULL;
 846         int broken = 0;
 847         int r;
 848         int rv = 0;
 849         void *file = NULL;      /* The downloaded file */
 850         size_t filelen = 0L;    /* The downloaded file length */
 851
 852         if ((room_flags & QR_DOWNLOAD) == 0) {
 853                 scr_printf("*** You cannot download from this room.\n");
 854                 return;
 855         }
 856
 857         newprompt("Enter filename: ", filename, PATH_MAX);
 858
 859         /* Save to local disk, for folks with their own copy of the client */
 860         if (proto == 5) {
 861                 destination_directory(tempname, filename);
 862                 r = CtdlIPCFileDownload(ipc, filename, &file, 0, progress, buf);
 863                 if (r / 100 != 2) {
 864                         scr_printf("%s\n", buf);
 865                         return;
 866                 }
 867                 save_buffer(file, (size_t)extract_long(buf, 0), tempname);
 868                 free(file);
 869                 return;
 870         }
 871
 872         r = CtdlIPCFileDownload(ipc, filename, &file, 0, progress, buf);
 873         if (r / 100 != 2) {
 874                 scr_printf("%s\n", buf);
 875                 return;
 876         }
 877         filelen = extract_unsigned_long(buf, 0);
 878
 879         /* Meta-download for public clients */
 880         /* scr_printf("Fetching file from Citadel server...\n"); */
 881         mkdir(tempdir, 0700);
 882         snprintf(tempname, sizeof tempname, "%s/%s", tempdir, filename);
 883         tpipe = fopen(tempname, "wb");
 884         if (fwrite(file, filelen, 1, tpipe) < filelen) {
 885                 /* FIXME: restart syscall on EINTR */
 886                 broken = 1;
 887         }
 888         fclose(tpipe);
 889         if (file) free(file);
 890
 891         if (proto == 0) {
 892                 /* FIXME: display internally instead */
 893                 snprintf(transmit_cmd, sizeof transmit_cmd,
 894                         "SHELL=/dev/null; export SHELL; TERM=dumb; export TERM; exec more -d <%s",
 895                         tempname);
 896         }
 897         else if (proto == 1)
 898                 snprintf(transmit_cmd, sizeof transmit_cmd, "exec sx %s", tempname);
 899         else if (proto == 3)
 900                 snprintf(transmit_cmd, sizeof transmit_cmd, "exec sb %s", tempname);
 901         else if (proto == 4)
 902                 snprintf(transmit_cmd, sizeof transmit_cmd, "exec sz %s", tempname);
 903         else
 904                 /* FIXME: display internally instead */
 905                 snprintf(transmit_cmd, sizeof transmit_cmd, "exec cat %s", tempname);
 906
 907         screen_reset();
 908         stty_ctdl(SB_RESTORE);
 909         rv = system(transmit_cmd);
 910         stty_ctdl(SB_NO_INTR);
 911         screen_set();
 912
 913         /* clean up the temporary directory */
 914         nukedir(tempdir);
 915         ctdl_beep();    /* Beep beep! */
 916 }
 917
 918
 919 /*
 920  * read directory of this room
 921  */
 922 void roomdir(CtdlIPC *ipc)
 923 {
 924         char flnm[256];
 925         char flsz[32];
 926         char comment[256];
 927         char mimetype[256];
 928         char buf[256];
 929         char *listing = NULL;   /* Returned directory listing */
 930         int r;
 931
 932         r = CtdlIPCReadDirectory(ipc, &listing, buf);
 933         if (r / 100 != 1) {
 934                 pprintf("%s\n", buf);
 935                 return;
 936         }
 937
 938         extract_token(comment, buf, 0, '|', sizeof comment);
 939         extract_token(flnm, buf, 1, '|', sizeof flnm);
 940         pprintf("\nDirectory of %s on %s\n", flnm, comment);
 941         pprintf("-----------------------\n");
 942         while (listing && *listing && !IsEmptyStr(listing)) {
 943                 extract_token(buf, listing, 0, '\n', sizeof buf);
 944                 remove_token(listing, 0, '\n');
 945
 946                 extract_token(flnm, buf, 0, '|', sizeof flnm);
 947                 extract_token(flsz, buf, 1, '|', sizeof flsz);
 948                 extract_token(mimetype, buf, 2, '|', sizeof mimetype);
 949                 extract_token(comment, buf, 3, '|', sizeof comment);
 950                 if (strlen(flnm) <= 14)
 951                         pprintf("%-14s %8s %s [%s]\n", flnm, flsz, comment, mimetype);
 952                 else
 953                         pprintf("%s\n%14s %8s %s [%s]\n", flnm, "", flsz,
 954                                 comment, mimetype);
 955         }
 956         if (listing) free(listing);
 957 }
 958
 959
 960 /*
 961  * add a user to a private room
 962  */
 963 void invite(CtdlIPC *ipc)
 964 {
 965         char username[USERNAME_SIZE];
 966         char buf[SIZ];
 967         int r;                          /* IPC response code */
 968
 969         newprompt("Name of user? ", username, USERNAME_SIZE);
 970         if (username[0] == 0)
 971                 return;
 972
 973         r = CtdlIPCInviteUserToRoom(ipc, username, buf);
 974         scr_printf("%s\n", buf);
 975 }
 976
 977
 978 /*
 979  * kick a user out of a room
 980  */
 981 void kickout(CtdlIPC *ipc)
 982 {
 983         char username[USERNAME_SIZE];
 984         char buf[SIZ];
 985         int r;                          /* IPC response code */
 986
 987         newprompt("Name of user? ", username, USERNAME_SIZE);
 988         if (username[0] == 0)
 989                 return;
 990
 991         r = CtdlIPCKickoutUserFromRoom(ipc, username, buf);
 992         scr_printf("%s\n", buf);
 993 }
 994
 995
 996 /*
 997  * aide command: kill the current room
 998  */
 999 void killroom(CtdlIPC *ipc)
1000 {
1001         char aaa[100];
1002         int r;
1003
1004         r = CtdlIPCDeleteRoom(ipc, 0, aaa);
1005         if (r / 100 != 2) {
1006                 scr_printf("%s\n", aaa);
1007                 return;
1008         }
1009
1010         scr_printf("Are you sure you want to kill this room? ");
1011         if (yesno() == 0)
1012                 return;
1013
1014         r = CtdlIPCDeleteRoom(ipc, 1, aaa);
1015         scr_printf("%s\n", aaa);
1016         if (r / 100 != 2)
1017                 return;
1018         dotgoto(ipc, "_BASEROOM_", 0, 0);
1019 }
1020
1021 void forget(CtdlIPC *ipc)
1022 {                               /* forget the current room */
1023         char buf[SIZ];
1024
1025         scr_printf("Are you sure you want to forget this room? ");
1026         if (yesno() == 0)
1027                 return;
1028
1029         remove_march(room_name, 0);
1030         if (CtdlIPCForgetRoom(ipc, buf) / 100 != 2) {
1031                 scr_printf("%s\n", buf);
1032                 return;
1033         }
1034
1035         /* now return to the lobby */
1036         dotgoto(ipc, "_BASEROOM_", 0, 0);
1037 }
1038
1039
1040 /*
1041  * create a new room
1042  */
1043 void entroom(CtdlIPC *ipc)
1044 {
1045         char buf[SIZ];
1046         char new_room_name[ROOMNAMELEN];
1047         int new_room_type;
1048         char new_room_pass[10];
1049         int new_room_floor;
1050         int a, b;
1051         int r;                          /* IPC response code */
1052
1053         /* Check permission to create room */
1054         r = CtdlIPCCreateRoom(ipc, 0, "", 1, "", 0, buf);
1055         if (r / 100 != 2) {
1056                 scr_printf("%s\n", buf);
1057                 return;
1058         }
1059
1060         newprompt("Name for new room? ", new_room_name, ROOMNAMELEN - 1);
1061         if (IsEmptyStr(new_room_name)) {
1062                 return;
1063         }
1064         for (a = 0; !IsEmptyStr(&new_room_name[a]); ++a) {
1065                 if (new_room_name[a] == '|') {
1066                         new_room_name[a] = '_';
1067                 }
1068         }
1069
1070         new_room_floor = select_floor(ipc, (int) curr_floor);
1071
1072         IFNEXPERT formout(ipc, "roomaccess");
1073         do {
1074                 scr_printf("<?>Help\n"
1075                         "<1>Public room (shown to all users by default)\n"
1076                         "<2>Hidden room (accessible to anyone who knows the room name)\n"
1077                         "<3>Passworded room (hidden, plus requires a password to enter)\n"
1078                         "<4>Invitation-only room (requires access to be granted by an Aide)\n"
1079                         "<5>Personal room (accessible to you only)\n"
1080                         "Enter room type: "
1081                 );
1082                 do {
1083                         b = inkey();
1084                 } while (((b < '1') || (b > '5')) && (b != '?'));
1085                 if (b == '?') {
1086                         scr_printf("?\n");
1087                         formout(ipc, "roomaccess");
1088                 }
1089         } while ((b < '1') || (b > '5'));
1090         b -= '0';                       /* Portable */
1091         scr_printf("%d\n", b);
1092         new_room_type = b - 1;
1093         if (new_room_type == 2) {
1094                 newprompt("Enter a room password: ", new_room_pass, 9);
1095                 for (a = 0; !IsEmptyStr(&new_room_pass[a]); ++a)
1096                         if (new_room_pass[a] == '|')
1097                                 new_room_pass[a] = '_';
1098         } else {
1099                 strcpy(new_room_pass, "");
1100         }
1101
1102         scr_printf("\042%s\042, a", new_room_name);
1103         if (b == 1)
1104                 scr_printf(" public room.");
1105         if (b == 2)
1106                 scr_printf(" hidden room.");
1107         if (b == 3)
1108                 scr_printf(" passworded room, password: %s", new_room_pass);
1109         if (b == 4)
1110                 scr_printf("n invitation-only room.");
1111         if (b == 5)
1112                 scr_printf(" personal room.");
1113         scr_printf("\nInstall it? (y/n) : ");
1114         if (yesno() == 0) {
1115                 return;
1116         }
1117
1118         r = CtdlIPCCreateRoom(ipc, 1, new_room_name, new_room_type,
1119                               new_room_pass, new_room_floor, buf);
1120         if (r / 100 != 2) {
1121                 scr_printf("%s\n", buf);
1122                 return;
1123         }
1124
1125         /* command succeeded... now GO to the new room! */
1126         dotgoto(ipc, new_room_name, 0, 0);
1127 }
1128
1129
1130
1131 void readinfo(CtdlIPC *ipc)
1132 {                               /* read info file for current room */
1133         char buf[SIZ];
1134         char raide[64];
1135         int r;                  /* IPC response code */
1136         char *text = NULL;
1137
1138         /* Name of currernt room aide */
1139         r = CtdlIPCGetRoomAide(ipc, buf);
1140         if (r / 100 == 2)
1141                 safestrncpy(raide, buf, sizeof raide);
1142         else
1143                 strcpy(raide, "");
1144
1145         if (!IsEmptyStr(raide))
1146                 scr_printf("Room aide is %s.\n\n", raide);
1147
1148         r = CtdlIPCRoomInfo(ipc, &text, buf);
1149         if (r / 100 != 1)
1150                 return;
1151
1152         if (text) {
1153                 fmout(screenwidth, NULL, text, NULL,
1154                       ((userflags & US_PAGINATOR) ? 1 : 0), screenheight,
1155                       (*raide) ? 2 : 0, 1);
1156                 free(text);
1157         }
1158 }
1159
1160
1161 /*
1162  * <W>ho knows room...
1163  */
1164 void whoknows(CtdlIPC *ipc)
1165 {
1166         char buf[256];
1167         char *listing = NULL;
1168         int r;
1169
1170         r = CtdlIPCWhoKnowsRoom(ipc, &listing, buf);
1171         if (r / 100 != 1) {
1172                 pprintf("%s\n", buf);
1173                 return;
1174         }
1175         while (!IsEmptyStr(listing)) {
1176                 extract_token(buf, listing, 0, '\n', sizeof buf);
1177                 remove_token(listing, 0, '\n');
1178                 if (sigcaught == 0)
1179                         pprintf("%s\n", buf);
1180         }
1181         free(listing);
1182 }
1183
1184
1185 void do_edit(CtdlIPC *ipc,
1186                 char *desc, char *read_cmd, char *check_cmd, char *write_cmd)
1187 {
1188         FILE *fp;
1189         char cmd[SIZ];
1190         int b, cksum, editor_exit;
1191
1192         if (IsEmptyStr(editor_paths[0])) {
1193                 scr_printf("Do you wish to re-enter %s? ", desc);
1194                 if (yesno() == 0)
1195                         return;
1196         }
1197
1198         fp = fopen(temp, "w");
1199         fclose(fp);
1200
1201         CtdlIPC_chat_send(ipc, check_cmd);
1202         CtdlIPC_chat_recv(ipc, cmd);
1203         if (cmd[0] != '2') {
1204                 scr_printf("%s\n", &cmd[4]);
1205                 return;
1206         }
1207
1208         if (!IsEmptyStr(editor_paths[0])) {
1209                 CtdlIPC_chat_send(ipc, read_cmd);
1210                 CtdlIPC_chat_recv(ipc, cmd);
1211                 if (cmd[0] == '1') {
1212                         fp = fopen(temp, "w");
1213                         while (CtdlIPC_chat_recv(ipc, cmd), strcmp(cmd, "000")) {
1214                                 fprintf(fp, "%s\n", cmd);
1215                         }
1216                         fclose(fp);
1217                 }
1218         }
1219
1220         cksum = file_checksum(temp);
1221
1222         if (!IsEmptyStr(editor_paths[0])) {
1223                 char tmp[SIZ];
1224
1225                 snprintf(tmp, sizeof tmp, "WINDOW_TITLE=%s", desc);
1226                 putenv(tmp);
1227                 screen_reset();
1228                 stty_ctdl(SB_RESTORE);
1229                 editor_pid = fork();
1230                 if (editor_pid == 0) {
1231                         chmod(temp, 0600);
1232                         execlp(editor_paths[0], editor_paths[0], temp, NULL);
1233                         exit(1);
1234                 }
1235                 if (editor_pid > 0)
1236                         do {
1237                                 editor_exit = 0;
1238                                 b = ka_wait(&editor_exit);
1239                         } while ((b != editor_pid) && (b >= 0));
1240                 editor_pid = (-1);
1241                 scr_printf("Executed %s\n", editor_paths[0]);
1242                 stty_ctdl(0);
1243                 screen_set();
1244         } else {
1245                 scr_printf("Entering %s.  "
1246                         "Press return twice when finished.\n", desc);
1247                 fp = fopen(temp, "r+");
1248                 citedit(ipc, fp);
1249                 fclose(fp);
1250         }
1251
1252         if (file_checksum(temp) == cksum) {
1253                 scr_printf("*** Aborted.\n");
1254         }
1255
1256         else {
1257                 CtdlIPC_chat_send(ipc, write_cmd);
1258                 CtdlIPC_chat_recv(ipc, cmd);
1259                 if (cmd[0] != '4') {
1260                         scr_printf("%s\n", &cmd[4]);
1261                         return;
1262                 }
1263
1264                 fp = fopen(temp, "r");
1265                 while (fgets(cmd, SIZ - 1, fp) != NULL) {
1266                         cmd[strlen(cmd) - 1] = 0;
1267                         CtdlIPC_chat_send(ipc, cmd);
1268                 }
1269                 fclose(fp);
1270                 CtdlIPC_chat_send(ipc, "000");
1271         }
1272
1273         unlink(temp);
1274 }
1275
1276
1277 void enterinfo(CtdlIPC *ipc)
1278 {                               /* edit info file for current room */
1279         do_edit(ipc, "the Info file for this room", "RINF", "EINF 0", "EINF 1");
1280 }
1281
1282 void enter_bio(CtdlIPC *ipc)
1283 {
1284         char cmd[SIZ];
1285         snprintf(cmd, sizeof cmd, "RBIO %s", fullname);
1286         do_edit(ipc, "your Bio", cmd, "NOOP", "EBIO");
1287 }
1288
1289 /*
1290  * create a new floor
1291  */
1292 void create_floor(CtdlIPC *ipc)
1293 {
1294         char buf[SIZ];
1295         char newfloorname[SIZ];
1296         int r;                  /* IPC response code */
1297
1298         load_floorlist(ipc);
1299
1300         r = CtdlIPCCreateFloor(ipc, 0, "", buf);
1301         if ( (r / 100 != 2) && (r != ERROR + ILLEGAL_VALUE) ) {
1302                 scr_printf("%s\n", buf);
1303                 return;
1304         }
1305
1306         newprompt("Name for new floor: ", newfloorname, 255);
1307         if (!*newfloorname) return;
1308         r = CtdlIPCCreateFloor(ipc, 1, newfloorname, buf);
1309         if (r / 100 == 2) {
1310                 scr_printf("Floor has been created.\n");
1311         } else {
1312                 scr_printf("%s\n", buf);
1313         }
1314
1315         load_floorlist(ipc);
1316 }
1317
1318 /*
1319  * edit the current floor
1320  */
1321 void edit_floor(CtdlIPC *ipc)
1322 {
1323         char buf[SIZ];
1324         struct ExpirePolicy *ep = NULL;
1325         int r;                          /* IPC response code */
1326
1327         load_floorlist(ipc);
1328
1329         /* Fetch the expire policy (this will silently fail on old servers,
1330          * resulting in "default" policy)
1331          */
1332         r = CtdlIPCGetMessageExpirationPolicy(ipc, 1, &ep, buf);
1333
1334         /* Interact with the user */
1335         scr_printf("You are editing the floor called \"%s\"\n",
1336                 &floorlist[(int) curr_floor][0] );
1337         strprompt("Floor name", &floorlist[(int) curr_floor][0], 255);
1338
1339         /* Angels and demons dancing in my head... */
1340         do {
1341                 snprintf(buf, sizeof buf, "%d", ep->expire_mode);
1342                 strprompt
1343                     ("Floor default message expire policy (? for list)",
1344                      buf, 1);
1345                 if (buf[0] == '?') {
1346                         scr_printf("\n"
1347                                 "0. Use the system default\n"
1348                                 "1. Never automatically expire messages\n"
1349                                 "2. Expire by message count\n"
1350                                 "3. Expire by message age\n");
1351                 }
1352         } while ((buf[0] < '0') || (buf[0] > '3'));
1353         ep->expire_mode = buf[0] - '0';
1354
1355         /* ...lunatics and monsters underneath my bed */
1356         if (ep->expire_mode == 2) {
1357                 snprintf(buf, sizeof buf, "%d", ep->expire_value);
1358                 strprompt("Keep how many messages online?", buf, 10);
1359                 ep->expire_value = atol(buf);
1360         }
1361
1362         if (ep->expire_mode == 3) {
1363                 snprintf(buf, sizeof buf, "%d", ep->expire_value);
1364                 strprompt("Keep messages for how many days?", buf, 10);
1365                 ep->expire_value = atol(buf);
1366         }
1367
1368         /* Save it */
1369         r = CtdlIPCSetMessageExpirationPolicy(ipc, 1, ep, buf);
1370         r = CtdlIPCEditFloor(ipc, curr_floor, &floorlist[(int)curr_floor][0], buf);
1371         scr_printf("%s\n", buf);
1372         load_floorlist(ipc);
1373 }
1374
1375
1376
1377
1378 /*
1379  * kill the current floor
1380  */
1381 void kill_floor(CtdlIPC *ipc)
1382 {
1383         int floornum_to_delete, a;
1384         char buf[SIZ];
1385
1386         load_floorlist(ipc);
1387         do {
1388                 floornum_to_delete = (-1);
1389                 scr_printf("(Press return to abort)\n");
1390                 newprompt("Delete which floor? ", buf, 255);
1391                 if (IsEmptyStr(buf))
1392                         return;
1393                 for (a = 0; a < 128; ++a)
1394                         if (!strcasecmp(&floorlist[a][0], buf))
1395                                 floornum_to_delete = a;
1396                 if (floornum_to_delete < 0) {
1397                         scr_printf("No such floor.  Select one of:\n");
1398                         for (a = 0; a < 128; ++a)
1399                                 if (floorlist[a][0] != 0)
1400                                         scr_printf("%s\n", &floorlist[a][0]);
1401                 }
1402         } while (floornum_to_delete < 0);
1403         CtdlIPCDeleteFloor(ipc, 1, floornum_to_delete, buf);
1404         scr_printf("%s\n", buf);
1405         load_floorlist(ipc);
1406 }