citadel/modules/ctdlproto/serv_rooms.c

   1 /*
   2  * Server functions which perform operations on room objects.
   3  *
   4  * Copyright (c) 1987-2015 by the citadel.org team
   5  *
   6  * This program is open source software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public 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
  15 #include <stdio.h>
  16 #include <dirent.h>     /* for cmd_rdir to read contents of the directory */
  17 #include <libcitadel.h>
  18
  19 #include "citserver.h"
  20 #include "ctdl_module.h"
  21 #include "room_ops.h"
  22 #include "config.h"
  23
  24 /*
  25  * Back-back-end for all room listing commands
  26  */
  27 void list_roomname(struct ctdlroom *qrbuf, int ra, int current_view, int default_view)
  28 {
  29         char truncated_roomname[ROOMNAMELEN];
  30
  31         /* For my own mailbox rooms, chop off the owner prefix */
  32         if ( (qrbuf->QRflags & QR_MAILBOX)
  33              && (atol(qrbuf->QRname) == CC->user.usernum) ) {
  34                 safestrncpy(truncated_roomname, qrbuf->QRname, sizeof truncated_roomname);
  35                 safestrncpy(truncated_roomname, &truncated_roomname[11], sizeof truncated_roomname);
  36                 cprintf("%s", truncated_roomname);
  37         }
  38         /* For all other rooms, just display the name in its entirety */
  39         else {
  40                 cprintf("%s", qrbuf->QRname);
  41         }
  42
  43         /* ...and now the other parameters */
  44         cprintf("|%u|%d|%d|%d|%d|%d|%d|%ld|\n",
  45                 qrbuf->QRflags,
  46                 (int) qrbuf->QRfloor,
  47                 (int) qrbuf->QRorder,
  48                 (int) qrbuf->QRflags2,
  49                 ra,
  50                 current_view,
  51                 default_view,
  52                 qrbuf->QRmtime
  53         );
  54 }
  55
  56
  57 /*
  58  * cmd_lrms()   -  List all accessible rooms, known or forgotten
  59  */
  60 void cmd_lrms_backend(struct ctdlroom *qrbuf, void *data)
  61 {
  62         int FloorBeingSearched = (-1);
  63         int ra;
  64         int view;
  65
  66         FloorBeingSearched = *(int *)data;
  67         CtdlRoomAccess(qrbuf, &CC->user, &ra, &view);
  68
  69         if ((( ra & (UA_KNOWN | UA_ZAPPED)))
  70             && ((qrbuf->QRfloor == (FloorBeingSearched))
  71                 || ((FloorBeingSearched) < 0)))
  72                 list_roomname(qrbuf, ra, view, qrbuf->QRdefaultview);
  73 }
  74
  75 void cmd_lrms(char *argbuf)
  76 {
  77         int FloorBeingSearched = (-1);
  78         if (!IsEmptyStr(argbuf))
  79                 FloorBeingSearched = extract_int(argbuf, 0);
  80
  81         if (CtdlAccessCheck(ac_logged_in_or_guest)) return;
  82
  83         CtdlGetUser(&CC->user, CC->curr_user);
  84         cprintf("%d Accessible rooms:\n", LISTING_FOLLOWS);
  85
  86         CtdlForEachRoom(cmd_lrms_backend, &FloorBeingSearched);
  87         cprintf("000\n");
  88 }
  89
  90
  91
  92 /*
  93  * cmd_lkra()   -  List all known rooms
  94  */
  95 void cmd_lkra_backend(struct ctdlroom *qrbuf, void *data)
  96 {
  97         int FloorBeingSearched = (-1);
  98         int ra;
  99         int view;
 100
 101         FloorBeingSearched = *(int *)data;
 102         CtdlRoomAccess(qrbuf, &CC->user, &ra, &view);
 103
 104         if ((( ra & (UA_KNOWN)))
 105             && ((qrbuf->QRfloor == (FloorBeingSearched))
 106                 || ((FloorBeingSearched) < 0)))
 107                 list_roomname(qrbuf, ra, view, qrbuf->QRdefaultview);
 108 }
 109
 110 void cmd_lkra(char *argbuf)
 111 {
 112         int FloorBeingSearched = (-1);
 113         if (!IsEmptyStr(argbuf))
 114                 FloorBeingSearched = extract_int(argbuf, 0);
 115
 116         if (CtdlAccessCheck(ac_logged_in_or_guest)) return;
 117
 118         CtdlGetUser(&CC->user, CC->curr_user);
 119         cprintf("%d Known rooms:\n", LISTING_FOLLOWS);
 120
 121         CtdlForEachRoom(cmd_lkra_backend, &FloorBeingSearched);
 122         cprintf("000\n");
 123 }
 124
 125
 126
 127 void cmd_lprm_backend(struct ctdlroom *qrbuf, void *data)
 128 {
 129         int FloorBeingSearched = (-1);
 130         int ra;
 131         int view;
 132
 133         FloorBeingSearched = *(int *)data;
 134         CtdlRoomAccess(qrbuf, &CC->user, &ra, &view);
 135
 136         if (   ((qrbuf->QRflags & QR_PRIVATE) == 0)
 137                 && ((qrbuf->QRflags & QR_MAILBOX) == 0)
 138             && ((qrbuf->QRfloor == (FloorBeingSearched))
 139                 || ((FloorBeingSearched) < 0)))
 140                 list_roomname(qrbuf, ra, view, qrbuf->QRdefaultview);
 141 }
 142
 143 void cmd_lprm(char *argbuf)
 144 {
 145         int FloorBeingSearched = (-1);
 146         if (!IsEmptyStr(argbuf))
 147                 FloorBeingSearched = extract_int(argbuf, 0);
 148
 149         cprintf("%d Public rooms:\n", LISTING_FOLLOWS);
 150
 151         CtdlForEachRoom(cmd_lprm_backend, &FloorBeingSearched);
 152         cprintf("000\n");
 153 }
 154
 155
 156
 157 /*
 158  * cmd_lkrn()   -  List all known rooms with new messages
 159  */
 160 void cmd_lkrn_backend(struct ctdlroom *qrbuf, void *data)
 161 {
 162         int FloorBeingSearched = (-1);
 163         int ra;
 164         int view;
 165
 166         FloorBeingSearched = *(int *)data;
 167         CtdlRoomAccess(qrbuf, &CC->user, &ra, &view);
 168
 169         if ((ra & UA_KNOWN)
 170             && (ra & UA_HASNEWMSGS)
 171             && ((qrbuf->QRfloor == (FloorBeingSearched))
 172                 || ((FloorBeingSearched) < 0)))
 173                 list_roomname(qrbuf, ra, view, qrbuf->QRdefaultview);
 174 }
 175
 176 void cmd_lkrn(char *argbuf)
 177 {
 178         int FloorBeingSearched = (-1);
 179         if (!IsEmptyStr(argbuf))
 180                 FloorBeingSearched = extract_int(argbuf, 0);
 181
 182         if (CtdlAccessCheck(ac_logged_in_or_guest)) return;
 183
 184         CtdlGetUser(&CC->user, CC->curr_user);
 185         cprintf("%d Rooms w/ new msgs:\n", LISTING_FOLLOWS);
 186
 187         CtdlForEachRoom(cmd_lkrn_backend, &FloorBeingSearched);
 188         cprintf("000\n");
 189 }
 190
 191
 192
 193 /*
 194  * cmd_lkro()   -  List all known rooms
 195  */
 196 void cmd_lkro_backend(struct ctdlroom *qrbuf, void *data)
 197 {
 198         int FloorBeingSearched = (-1);
 199         int ra;
 200         int view;
 201
 202         FloorBeingSearched = *(int *)data;
 203         CtdlRoomAccess(qrbuf, &CC->user, &ra, &view);
 204
 205         if ((ra & UA_KNOWN)
 206             && ((ra & UA_HASNEWMSGS) == 0)
 207             && ((qrbuf->QRfloor == (FloorBeingSearched))
 208                 || ((FloorBeingSearched) < 0)))
 209                 list_roomname(qrbuf, ra, view, qrbuf->QRdefaultview);
 210 }
 211
 212 void cmd_lkro(char *argbuf)
 213 {
 214         int FloorBeingSearched = (-1);
 215         if (!IsEmptyStr(argbuf))
 216                 FloorBeingSearched = extract_int(argbuf, 0);
 217
 218         if (CtdlAccessCheck(ac_logged_in_or_guest)) return;
 219
 220         CtdlGetUser(&CC->user, CC->curr_user);
 221         cprintf("%d Rooms w/o new msgs:\n", LISTING_FOLLOWS);
 222
 223         CtdlForEachRoom(cmd_lkro_backend, &FloorBeingSearched);
 224         cprintf("000\n");
 225 }
 226
 227
 228
 229 /*
 230  * cmd_lzrm()   -  List all forgotten rooms
 231  */
 232 void cmd_lzrm_backend(struct ctdlroom *qrbuf, void *data)
 233 {
 234         int FloorBeingSearched = (-1);
 235         int ra;
 236         int view;
 237
 238         FloorBeingSearched = *(int *)data;
 239         CtdlRoomAccess(qrbuf, &CC->user, &ra, &view);
 240
 241         if ((ra & UA_GOTOALLOWED)
 242             && (ra & UA_ZAPPED)
 243             && ((qrbuf->QRfloor == (FloorBeingSearched))
 244                 || ((FloorBeingSearched) < 0)))
 245                 list_roomname(qrbuf, ra, view, qrbuf->QRdefaultview);
 246 }
 247
 248 void cmd_lzrm(char *argbuf)
 249 {
 250         int FloorBeingSearched = (-1);
 251         if (!IsEmptyStr(argbuf))
 252                 FloorBeingSearched = extract_int(argbuf, 0);
 253
 254         if (CtdlAccessCheck(ac_logged_in_or_guest)) return;
 255
 256         CtdlGetUser(&CC->user, CC->curr_user);
 257         cprintf("%d Zapped rooms:\n", LISTING_FOLLOWS);
 258
 259         CtdlForEachRoom(cmd_lzrm_backend, &FloorBeingSearched);
 260         cprintf("000\n");
 261 }
 262
 263
 264 /*
 265  * cmd_goto()  -  goto a new room
 266  */
 267 void cmd_goto(char *gargs)
 268 {
 269         struct CitContext *CCC = CC;
 270         struct ctdlroom QRscratch;
 271         int c;
 272         int ok = 0;
 273         int ra;
 274         char augmented_roomname[ROOMNAMELEN];
 275         char towhere[ROOMNAMELEN];
 276         char password[32];
 277         int transiently = 0;
 278
 279         if (CtdlAccessCheck(ac_logged_in_or_guest)) return;
 280
 281         extract_token(towhere, gargs, 0, '|', sizeof towhere);
 282         extract_token(password, gargs, 1, '|', sizeof password);
 283         transiently = extract_int(gargs, 2);
 284
 285         CtdlGetUser(&CCC->user, CCC->curr_user);
 286
 287         /*
 288          * Handle some of the macro named rooms
 289          */
 290         convert_room_name_macros(towhere, sizeof towhere);
 291
 292         /* First try a regular match */
 293         c = CtdlGetRoom(&QRscratch, towhere);
 294
 295         /* Then try a mailbox name match */
 296         if (c != 0) {
 297                 CtdlMailboxName(augmented_roomname, sizeof augmented_roomname,
 298                             &CCC->user, towhere);
 299                 c = CtdlGetRoom(&QRscratch, augmented_roomname);
 300                 if (c == 0)
 301                         safestrncpy(towhere, augmented_roomname, sizeof towhere);
 302         }
 303
 304         /* And if the room was found... */
 305         if (c == 0) {
 306
 307                 /* Let internal programs go directly to any room. */
 308                 if (CCC->internal_pgm) {
 309                         memcpy(&CCC->room, &QRscratch,
 310                                 sizeof(struct ctdlroom));
 311                         CtdlUserGoto(NULL, 1, transiently, NULL, NULL, NULL, NULL);
 312                         return;
 313                 }
 314
 315                 /* See if there is an existing user/room relationship */
 316                 CtdlRoomAccess(&QRscratch, &CCC->user, &ra, NULL);
 317
 318                 /* normal clients have to pass through security */
 319                 if (ra & UA_GOTOALLOWED) {
 320                         ok = 1;
 321                 }
 322
 323                 if (ok == 1) {
 324                         if ((QRscratch.QRflags & QR_MAILBOX) &&
 325                             ((ra & UA_GOTOALLOWED))) {
 326                                 memcpy(&CCC->room, &QRscratch,
 327                                         sizeof(struct ctdlroom));
 328                                 CtdlUserGoto(NULL, 1, transiently, NULL, NULL, NULL, NULL);
 329                                 return;
 330                         } else if ((QRscratch.QRflags & QR_PASSWORDED) &&
 331                             ((ra & UA_KNOWN) == 0) &&
 332                             (strcasecmp(QRscratch.QRpasswd, password)) &&
 333                             (CCC->user.axlevel < AxAideU)
 334                             ) {
 335                                 cprintf("%d wrong or missing passwd\n",
 336                                         ERROR + PASSWORD_REQUIRED);
 337                                 return;
 338                         } else if ((QRscratch.QRflags & QR_PRIVATE) &&
 339                                    ((QRscratch.QRflags & QR_PASSWORDED) == 0) &&
 340                                    ((QRscratch.QRflags & QR_GUESSNAME) == 0) &&
 341                                    ((ra & UA_KNOWN) == 0) &&
 342                                    (CCC->user.axlevel < AxAideU)
 343                                   ) {
 344                                 CTDLM_syslog(LOG_DEBUG, "Failed to acquire private room");
 345                         } else {
 346                                 memcpy(&CCC->room, &QRscratch,
 347                                         sizeof(struct ctdlroom));
 348                                 CtdlUserGoto(NULL, 1, transiently, NULL, NULL, NULL, NULL);
 349                                 return;
 350                         }
 351                 }
 352         }
 353
 354         cprintf("%d room '%s' not found\n", ERROR + ROOM_NOT_FOUND, towhere);
 355 }
 356
 357
 358 void cmd_whok(char *cmdbuf)
 359 {
 360         struct ctdluser temp;
 361         struct cdbdata *cdbus;
 362         int ra;
 363
 364         cprintf("%d Who knows room:\n", LISTING_FOLLOWS);
 365         cdb_rewind(CDB_USERS);
 366         while (cdbus = cdb_next_item(CDB_USERS), cdbus != NULL) {
 367                 memset(&temp, 0, sizeof temp);
 368                 memcpy(&temp, cdbus->ptr, sizeof temp);
 369                 cdb_free(cdbus);
 370
 371                 CtdlRoomAccess(&CC->room, &temp, &ra, NULL);
 372                 if ((!IsEmptyStr(temp.fullname)) &&
 373                     (CC->room.QRflags & QR_INUSE) &&
 374                     (ra & UA_KNOWN)
 375                         )
 376                         cprintf("%s\n", temp.fullname);
 377         }
 378         cprintf("000\n");
 379 }
 380
 381
 382 /*
 383  * RDIR command for room directory
 384  */
 385 void cmd_rdir(char *cmdbuf)
 386 {
 387         char buf[256];
 388         char comment[256];
 389         FILE *fd;
 390         struct stat statbuf;
 391         DIR *filedir = NULL;
 392         struct dirent *filedir_entry;
 393         int d_namelen;
 394         char buf2[SIZ];
 395         char mimebuf[64];
 396         long len;
 397
 398         if (CtdlAccessCheck(ac_logged_in)) return;
 399
 400         CtdlGetRoom(&CC->room, CC->room.QRname);
 401         CtdlGetUser(&CC->user, CC->curr_user);
 402
 403         if ((CC->room.QRflags & QR_DIRECTORY) == 0) {
 404                 cprintf("%d not here.\n", ERROR + NOT_HERE);
 405                 return;
 406         }
 407         if (((CC->room.QRflags & QR_VISDIR) == 0)
 408             && (CC->user.axlevel < AxAideU)
 409             && (CC->user.usernum != CC->room.QRroomaide)) {
 410                 cprintf("%d not here.\n", ERROR + HIGHER_ACCESS_REQUIRED);
 411                 return;
 412         }
 413
 414         snprintf(buf, sizeof buf, "%s/%s", ctdl_file_dir, CC->room.QRdirname);
 415         filedir = opendir (buf);
 416
 417         if (filedir == NULL) {
 418                 cprintf("%d not here.\n", ERROR + HIGHER_ACCESS_REQUIRED);
 419                 return;
 420         }
 421         cprintf("%d %s|%s/%s\n", LISTING_FOLLOWS, CtdlGetConfigStr("c_fqdn"), ctdl_file_dir, CC->room.QRdirname);
 422
 423         snprintf(buf, sizeof buf, "%s/%s/filedir", ctdl_file_dir, CC->room.QRdirname);
 424         fd = fopen(buf, "r");
 425         if (fd == NULL)
 426                 fd = fopen("/dev/null", "r");
 427         while ((filedir_entry = readdir(filedir)))
 428         {
 429                 if (strcasecmp(filedir_entry->d_name, "filedir") && filedir_entry->d_name[0] != '.')
 430                 {
 431 #ifdef _DIRENT_HAVE_D_NAMELEN
 432                         d_namelen = filedir_entry->d_namlen;
 433 #else
 434                         d_namelen = strlen(filedir_entry->d_name);
 435 #endif
 436                         snprintf(buf, sizeof buf, "%s/%s/%s", ctdl_file_dir, CC->room.QRdirname, filedir_entry->d_name);
 437                         stat(buf, &statbuf);    /* stat the file */
 438                         if (!(statbuf.st_mode & S_IFREG))
 439                         {
 440                                 snprintf(buf2, sizeof buf2,
 441                                         "\"%s\" appears in the file directory for room \"%s\" but is not a regular file.  Directories, named pipes, sockets, etc. are not usable in Citadel room directories.\n",
 442                                         buf, CC->room.QRname
 443                                 );
 444                                 CtdlAideMessage(buf2, "Unusable data found in room directory");
 445                                 continue;       /* not a useable file type so don't show it */
 446                         }
 447                         safestrncpy(comment, "", sizeof comment);
 448                         fseek(fd, 0L, 0);       /* rewind descriptions file */
 449                         /* Get the description from the descriptions file */
 450                         while ((fgets(buf, sizeof buf, fd) != NULL) && (IsEmptyStr(comment)))
 451                         {
 452                                 buf[strlen(buf) - 1] = 0;
 453                                 if ((!strncasecmp(buf, filedir_entry->d_name, d_namelen)) && (buf[d_namelen] == ' '))
 454                                         safestrncpy(comment, &buf[d_namelen + 1], sizeof comment);
 455                         }
 456                         len = extract_token (mimebuf, comment, 0,' ', 64);
 457                         if ((len <0) || strchr(mimebuf, '/') == NULL)
 458                         {
 459                                 snprintf (mimebuf, 64, "application/octetstream");
 460                                 len = 0;
 461                         }
 462                         cprintf("%s|%ld|%s|%s\n",
 463                                 filedir_entry->d_name,
 464                                 (long)statbuf.st_size,
 465                                 mimebuf,
 466                                 &comment[len]);
 467                 }
 468         }
 469         fclose(fd);
 470         closedir(filedir);
 471
 472         cprintf("000\n");
 473 }
 474
 475 /*
 476  * get room parameters (admin or room admin command)
 477  */
 478 void cmd_getr(char *cmdbuf)
 479 {
 480         if (CtdlAccessCheck(ac_room_aide)) return;
 481
 482         CtdlGetRoom(&CC->room, CC->room.QRname);
 483         cprintf("%d%c%s|%s|%s|%d|%d|%d|%d|%d|\n",
 484                 CIT_OK,
 485                 CtdlCheckExpress(),
 486
 487                 ((CC->room.QRflags & QR_MAILBOX) ?
 488                         &CC->room.QRname[11] : CC->room.QRname),
 489
 490                 ((CC->room.QRflags & QR_PASSWORDED) ?
 491                         CC->room.QRpasswd : ""),
 492
 493                 ((CC->room.QRflags & QR_DIRECTORY) ?
 494                         CC->room.QRdirname : ""),
 495
 496                 CC->room.QRflags,
 497                 (int) CC->room.QRfloor,
 498                 (int) CC->room.QRorder,
 499
 500                 CC->room.QRdefaultview,
 501                 CC->room.QRflags2
 502                 );
 503 }
 504
 505 /*
 506  * set room parameters (admin or room admin command)
 507  */
 508 void cmd_setr(char *args)
 509 {
 510         char buf[256];
 511         int new_order = 0;
 512         int r;
 513         int new_floor;
 514         char new_name[ROOMNAMELEN];
 515
 516         if (CtdlAccessCheck(ac_logged_in)) return;
 517
 518         if (num_parms(args) >= 6) {
 519                 new_floor = extract_int(args, 5);
 520         } else {
 521                 new_floor = (-1);       /* don't change the floor */
 522         }
 523
 524         /* When is a new name more than just a new name?  When the old name
 525          * has a namespace prefix.
 526          */
 527         if (CC->room.QRflags & QR_MAILBOX) {
 528                 sprintf(new_name, "%010ld.", atol(CC->room.QRname) );
 529         } else {
 530                 safestrncpy(new_name, "", sizeof new_name);
 531         }
 532         extract_token(&new_name[strlen(new_name)], args, 0, '|', (sizeof new_name - strlen(new_name)));
 533
 534         r = CtdlRenameRoom(CC->room.QRname, new_name, new_floor);
 535
 536         if (r == crr_room_not_found) {
 537                 cprintf("%d Internal error - room not found?\n", ERROR + INTERNAL_ERROR);
 538         } else if (r == crr_already_exists) {
 539                 cprintf("%d '%s' already exists.\n",
 540                         ERROR + ALREADY_EXISTS, new_name);
 541         } else if (r == crr_noneditable) {
 542                 cprintf("%d Cannot edit this room.\n", ERROR + NOT_HERE);
 543         } else if (r == crr_invalid_floor) {
 544                 cprintf("%d Target floor does not exist.\n",
 545                         ERROR + INVALID_FLOOR_OPERATION);
 546         } else if (r == crr_access_denied) {
 547                 cprintf("%d You do not have permission to edit '%s'\n",
 548                         ERROR + HIGHER_ACCESS_REQUIRED,
 549                         CC->room.QRname);
 550         } else if (r != crr_ok) {
 551                 cprintf("%d Error: CtdlRenameRoom() returned %d\n",
 552                         ERROR + INTERNAL_ERROR, r);
 553         }
 554
 555         if (r != crr_ok) {
 556                 return;
 557         }
 558
 559         CtdlGetRoom(&CC->room, new_name);
 560
 561         /* Now we have to do a bunch of other stuff */
 562
 563         if (num_parms(args) >= 7) {
 564                 new_order = extract_int(args, 6);
 565                 if (new_order < 1)
 566                         new_order = 1;
 567                 if (new_order > 127)
 568                         new_order = 127;
 569         }
 570
 571         CtdlGetRoomLock(&CC->room, CC->room.QRname);
 572
 573         /* Directory room */
 574         extract_token(buf, args, 2, '|', sizeof buf);
 575         buf[15] = 0;
 576         safestrncpy(CC->room.QRdirname, buf,
 577                 sizeof CC->room.QRdirname);
 578
 579         /* Default view */
 580         if (num_parms(args) >= 8) {
 581                 CC->room.QRdefaultview = extract_int(args, 7);
 582         }
 583
 584         /* Second set of flags */
 585         if (num_parms(args) >= 9) {
 586                 CC->room.QRflags2 = extract_int(args, 8);
 587         }
 588
 589         /* Misc. flags */
 590         CC->room.QRflags = (extract_int(args, 3) | QR_INUSE);
 591         /* Clean up a client boo-boo: if the client set the room to
 592          * guess-name or passworded, ensure that the private flag is
 593          * also set.
 594          */
 595         if ((CC->room.QRflags & QR_GUESSNAME)
 596             || (CC->room.QRflags & QR_PASSWORDED))
 597                 CC->room.QRflags |= QR_PRIVATE;
 598
 599         /* Some changes can't apply to BASEROOM */
 600         if (!strncasecmp(CC->room.QRname, CtdlGetConfigStr("c_baseroom"), ROOMNAMELEN)) {
 601                 CC->room.QRorder = 0;
 602                 CC->room.QRpasswd[0] = '\0';
 603                 CC->room.QRflags &= ~(QR_PRIVATE & QR_PASSWORDED &
 604                         QR_GUESSNAME & QR_PREFONLY & QR_MAILBOX);
 605                 CC->room.QRflags |= QR_PERMANENT;
 606         } else {
 607                 /* March order (doesn't apply to AIDEROOM) */
 608                 if (num_parms(args) >= 7)
 609                         CC->room.QRorder = (char) new_order;
 610                 /* Room password */
 611                 extract_token(buf, args, 1, '|', sizeof buf);
 612                 buf[10] = 0;
 613                 safestrncpy(CC->room.QRpasswd, buf,
 614                             sizeof CC->room.QRpasswd);
 615                 /* Kick everyone out if the client requested it
 616                  * (by changing the room's generation number)
 617                  */
 618                 if (extract_int(args, 4)) {
 619                         time(&CC->room.QRgen);
 620                 }
 621         }
 622         /* Some changes can't apply to AIDEROOM */
 623         if (!strncasecmp(CC->room.QRname, CtdlGetConfigStr("c_baseroom"), ROOMNAMELEN)) {
 624                 CC->room.QRorder = 0;
 625                 CC->room.QRflags &= ~QR_MAILBOX;
 626                 CC->room.QRflags |= QR_PERMANENT;
 627         }
 628
 629         /* Write the room record back to disk */
 630         CtdlPutRoomLock(&CC->room);
 631
 632         /* Create a room directory if necessary */
 633         if (CC->room.QRflags & QR_DIRECTORY) {
 634                 snprintf(buf, sizeof buf,"%s/%s",
 635                                  ctdl_file_dir,
 636                                  CC->room.QRdirname);
 637                 mkdir(buf, 0755);
 638         }
 639         snprintf(buf, sizeof buf, "The room \"%s\" has been edited by %s.\n",
 640                 CC->room.QRname,
 641                 (CC->logged_in ? CC->curr_user : "an administrator")
 642         );
 643         CtdlAideMessage(buf, "Room modification Message");
 644         cprintf("%d Ok\n", CIT_OK);
 645 }
 646
 647
 648
 649 /*
 650  * get the name of the room admin for this room
 651  */
 652 void cmd_geta(char *cmdbuf)
 653 {
 654         struct ctdluser usbuf;
 655
 656         if (CtdlAccessCheck(ac_logged_in)) return;
 657
 658         if (CtdlGetUserByNumber(&usbuf, CC->room.QRroomaide) == 0) {
 659                 cprintf("%d %s\n", CIT_OK, usbuf.fullname);
 660         } else {
 661                 cprintf("%d \n", CIT_OK);
 662         }
 663 }
 664
 665
 666 /*
 667  * set the room admin for this room
 668  */
 669 void cmd_seta(char *new_ra)
 670 {
 671         struct ctdluser usbuf;
 672         long newu;
 673         char buf[SIZ];
 674         int post_notice;
 675
 676         if (CtdlAccessCheck(ac_room_aide)) return;
 677
 678         if (CtdlGetUser(&usbuf, new_ra) != 0) {
 679                 newu = (-1L);
 680         } else {
 681                 newu = usbuf.usernum;
 682         }
 683
 684         CtdlGetRoomLock(&CC->room, CC->room.QRname);
 685         post_notice = 0;
 686         if (CC->room.QRroomaide != newu) {
 687                 post_notice = 1;
 688         }
 689         CC->room.QRroomaide = newu;
 690         CtdlPutRoomLock(&CC->room);
 691
 692         /*
 693          * We have to post the change notice _after_ writing changes to
 694          * the room table, otherwise it would deadlock!
 695          */
 696         if (post_notice == 1) {
 697                 if (!IsEmptyStr(usbuf.fullname))
 698                         snprintf(buf, sizeof buf,
 699                                 "%s is now the room admin for \"%s\".\n",
 700                                 usbuf.fullname, CC->room.QRname);
 701                 else
 702                         snprintf(buf, sizeof buf,
 703                                 "There is now no room admin for \"%s\".\n",
 704                                 CC->room.QRname);
 705                 CtdlAideMessage(buf, "Admin Room Modification");
 706         }
 707         cprintf("%d Ok\n", CIT_OK);
 708 }
 709
 710 /*
 711  * retrieve info file for this room
 712  */
 713 void cmd_rinf(char *gargs)
 714 {
 715         char filename[PATH_MAX];
 716         char buf[SIZ];
 717         FILE *info_fp;
 718
 719         assoc_file_name(filename, sizeof filename, &CC->room, ctdl_info_dir);
 720         info_fp = fopen(filename, "r");
 721
 722         if (info_fp == NULL) {
 723                 cprintf("%d No info file.\n", ERROR + FILE_NOT_FOUND);
 724                 return;
 725         }
 726         cprintf("%d Info:\n", LISTING_FOLLOWS);
 727         while (fgets(buf, sizeof buf, info_fp) != NULL) {
 728                 if (!IsEmptyStr(buf))
 729                         buf[strlen(buf) - 1] = 0;
 730                 cprintf("%s\n", buf);
 731         }
 732         cprintf("000\n");
 733         fclose(info_fp);
 734 }
 735
 736
 737 /*
 738  * admin command: kill the current room
 739  */
 740 void cmd_kill(char *argbuf)
 741 {
 742         char deleted_room_name[ROOMNAMELEN];
 743         char msg[SIZ];
 744         int kill_ok;
 745
 746         kill_ok = extract_int(argbuf, 0);
 747
 748         if (CtdlDoIHavePermissionToDeleteThisRoom(&CC->room) == 0) {
 749                 cprintf("%d Can't delete this room.\n", ERROR + NOT_HERE);
 750                 return;
 751         }
 752         if (kill_ok) {
 753                 if (CC->room.QRflags & QR_MAILBOX) {
 754                         safestrncpy(deleted_room_name, &CC->room.QRname[11], sizeof deleted_room_name);
 755                 }
 756                 else {
 757                         safestrncpy(deleted_room_name, CC->room.QRname, sizeof deleted_room_name);
 758                 }
 759
 760                 /* Do the dirty work */
 761                 CtdlScheduleRoomForDeletion(&CC->room);
 762
 763                 /* Return to the Lobby */
 764                 CtdlUserGoto(CtdlGetConfigStr("c_baseroom"), 0, 0, NULL, NULL, NULL, NULL);
 765
 766                 /* tell the world what we did */
 767                 snprintf(msg, sizeof msg, "The room \"%s\" has been deleted by %s.\n",
 768                          deleted_room_name,
 769                         (CC->logged_in ? CC->curr_user : "an administrator")
 770                 );
 771                 CtdlAideMessage(msg, "Room Purger Message");
 772                 cprintf("%d '%s' deleted.\n", CIT_OK, deleted_room_name);
 773         } else {
 774                 cprintf("%d ok to delete.\n", CIT_OK);
 775         }
 776 }
 777
 778
 779 /*
 780  * create a new room
 781  */
 782 void cmd_cre8(char *args)
 783 {
 784         int cre8_ok;
 785         char new_room_name[ROOMNAMELEN];
 786         int new_room_type;
 787         char new_room_pass[32];
 788         int new_room_floor;
 789         int new_room_view;
 790         char *notification_message = NULL;
 791         unsigned newflags;
 792         struct floor *fl;
 793         int avoid_access = 0;
 794
 795         cre8_ok = extract_int(args, 0);
 796         extract_token(new_room_name, args, 1, '|', sizeof new_room_name);
 797         new_room_name[ROOMNAMELEN - 1] = 0;
 798         new_room_type = extract_int(args, 2);
 799         extract_token(new_room_pass, args, 3, '|', sizeof new_room_pass);
 800         avoid_access = extract_int(args, 5);
 801         new_room_view = extract_int(args, 6);
 802         new_room_pass[9] = 0;
 803         new_room_floor = 0;
 804
 805         if ((IsEmptyStr(new_room_name)) && (cre8_ok == 1)) {
 806                 cprintf("%d Invalid room name.\n", ERROR + ILLEGAL_VALUE);
 807                 return;
 808         }
 809
 810         if (!strcasecmp(new_room_name, MAILROOM)) {
 811                 cprintf("%d '%s' already exists.\n",
 812                         ERROR + ALREADY_EXISTS, new_room_name);
 813                 return;
 814         }
 815
 816         if (num_parms(args) >= 5) {
 817                 fl = CtdlGetCachedFloor(extract_int(args, 4));
 818                 if (fl == NULL) {
 819                         cprintf("%d Invalid floor number.\n",
 820                                 ERROR + INVALID_FLOOR_OPERATION);
 821                         return;
 822                 }
 823                 else if ((fl->f_flags & F_INUSE) == 0) {
 824                         cprintf("%d Invalid floor number.\n",
 825                                 ERROR + INVALID_FLOOR_OPERATION);
 826                         return;
 827                 } else {
 828                         new_room_floor = extract_int(args, 4);
 829                 }
 830         }
 831
 832         if (CtdlAccessCheck(ac_logged_in)) return;
 833
 834         if (CC->user.axlevel < CtdlGetConfigInt("c_createax") && !CC->internal_pgm) {
 835                 cprintf("%d You need higher access to create rooms.\n",
 836                         ERROR + HIGHER_ACCESS_REQUIRED);
 837                 return;
 838         }
 839
 840         if ((IsEmptyStr(new_room_name)) && (cre8_ok == 0)) {
 841                 cprintf("%d Ok to create rooms.\n", CIT_OK);
 842                 return;
 843         }
 844
 845         if ((new_room_type < 0) || (new_room_type > 5)) {
 846                 cprintf("%d Invalid room type.\n", ERROR + ILLEGAL_VALUE);
 847                 return;
 848         }
 849
 850         if (new_room_type == 5) {
 851                 if (CC->user.axlevel < AxAideU) {
 852                         cprintf("%d Higher access required\n",
 853                                 ERROR + HIGHER_ACCESS_REQUIRED);
 854                         return;
 855                 }
 856         }
 857
 858         /* Check to make sure the requested room name doesn't already exist */
 859         newflags = CtdlCreateRoom(new_room_name,
 860                                 new_room_type, new_room_pass, new_room_floor,
 861                                 0, avoid_access, new_room_view);
 862         if (newflags == 0) {
 863                 cprintf("%d '%s' already exists.\n",
 864                         ERROR + ALREADY_EXISTS, new_room_name);
 865                 return;
 866         }
 867
 868         if (cre8_ok == 0) {
 869                 cprintf("%d OK to create '%s'\n", CIT_OK, new_room_name);
 870                 return;
 871         }
 872
 873         /* If we reach this point, the room needs to be created. */
 874
 875         newflags = CtdlCreateRoom(new_room_name,
 876                            new_room_type, new_room_pass, new_room_floor, 1, 0,
 877                            new_room_view);
 878
 879         /* post a message in Aide> describing the new room */
 880         notification_message = malloc(1024);
 881         snprintf(notification_message, 1024,
 882                 "A new room called \"%s\" has been created by %s%s%s%s%s%s\n",
 883                 new_room_name,
 884                 (CC->logged_in ? CC->curr_user : "an administrator"),
 885                 ((newflags & QR_MAILBOX) ? " [personal]" : ""),
 886                 ((newflags & QR_PRIVATE) ? " [private]" : ""),
 887                 ((newflags & QR_GUESSNAME) ? " [hidden]" : ""),
 888                 ((newflags & QR_PASSWORDED) ? " Password: " : ""),
 889                 ((newflags & QR_PASSWORDED) ? new_room_pass : "")
 890         );
 891         CtdlAideMessage(notification_message, "Room Creation Message");
 892         free(notification_message);
 893
 894         cprintf("%d '%s' has been created.\n", CIT_OK, new_room_name);
 895 }
 896
 897
 898
 899 void cmd_einf(char *ok)
 900 {                               /* enter info file for current room */
 901         struct CitContext *CCC = CC;
 902         FILE *fp;
 903         char infofilename[SIZ];
 904         char buf[SIZ];
 905
 906         unbuffer_output();
 907
 908         if (CtdlAccessCheck(ac_room_aide)) return;
 909
 910         if (atoi(ok) == 0) {
 911                 cprintf("%d Ok.\n", CIT_OK);
 912                 return;
 913         }
 914         assoc_file_name(infofilename, sizeof infofilename, &CCC->room, ctdl_info_dir);
 915         CTDL_syslog(LOG_DEBUG, "opening %s", infofilename);
 916         fp = fopen(infofilename, "w");
 917         CTDLM_syslog(LOG_DEBUG, "checking");
 918         if (fp == NULL) {
 919                 cprintf("%d Cannot open %s: %s\n",
 920                   ERROR + INTERNAL_ERROR, infofilename, strerror(errno));
 921                 return;
 922         }
 923         cprintf("%d Send info...\n", SEND_LISTING);
 924
 925         do {
 926                 client_getln(buf, sizeof buf);
 927                 if (strcmp(buf, "000"))
 928                         fprintf(fp, "%s\n", buf);
 929         } while (strcmp(buf, "000"));
 930         fclose(fp);
 931
 932         /* now update the room index so people will see our new info */
 933         CtdlGetRoomLock(&CCC->room, CCC->room.QRname);          /* lock so no one steps on us */
 934         CtdlPutRoomLock(&CCC->room);
 935 }
 936
 937
 938 /*
 939  * cmd_lflr()   -  List all known floors
 940  */
 941 void cmd_lflr(char *gargs)
 942 {
 943         int a;
 944         struct floor flbuf;
 945
 946         if (CtdlAccessCheck(ac_logged_in_or_guest)) return;
 947
 948         cprintf("%d Known floors:\n", LISTING_FOLLOWS);
 949
 950         for (a = 0; a < MAXFLOORS; ++a) {
 951                 CtdlGetFloor(&flbuf, a);
 952                 if (flbuf.f_flags & F_INUSE) {
 953                         cprintf("%d|%s|%d\n",
 954                                 a,
 955                                 flbuf.f_name,
 956                                 flbuf.f_ref_count);
 957                 }
 958         }
 959         cprintf("000\n");
 960 }
 961
 962
 963
 964 /*
 965  * create a new floor
 966  */
 967 void cmd_cflr(char *argbuf)
 968 {
 969         char new_floor_name[256];
 970         struct floor flbuf;
 971         int cflr_ok;
 972         int free_slot = (-1);
 973         int a;
 974
 975         extract_token(new_floor_name, argbuf, 0, '|', sizeof new_floor_name);
 976         cflr_ok = extract_int(argbuf, 1);
 977
 978         if (CtdlAccessCheck(ac_aide)) return;
 979
 980         if (IsEmptyStr(new_floor_name)) {
 981                 cprintf("%d Blank floor name not allowed.\n",
 982                         ERROR + ILLEGAL_VALUE);
 983                 return;
 984         }
 985
 986         for (a = 0; a < MAXFLOORS; ++a) {
 987                 CtdlGetFloor(&flbuf, a);
 988
 989                 /* note any free slots while we're scanning... */
 990                 if (((flbuf.f_flags & F_INUSE) == 0)
 991                     && (free_slot < 0))
 992                         free_slot = a;
 993
 994                 /* check to see if it already exists */
 995                 if ((!strcasecmp(flbuf.f_name, new_floor_name))
 996                     && (flbuf.f_flags & F_INUSE)) {
 997                         cprintf("%d Floor '%s' already exists.\n",
 998                                 ERROR + ALREADY_EXISTS,
 999                                 flbuf.f_name);
1000                         return;
1001                 }
1002         }
1003
1004         if (free_slot < 0) {
1005                 cprintf("%d There is no space available for a new floor.\n",
1006                         ERROR + INVALID_FLOOR_OPERATION);
1007                 return;
1008         }
1009         if (cflr_ok == 0) {
1010                 cprintf("%d ok to create...\n", CIT_OK);
1011                 return;
1012         }
1013         lgetfloor(&flbuf, free_slot);
1014         flbuf.f_flags = F_INUSE;
1015         flbuf.f_ref_count = 0;
1016         safestrncpy(flbuf.f_name, new_floor_name, sizeof flbuf.f_name);
1017         lputfloor(&flbuf, free_slot);
1018         cprintf("%d %d\n", CIT_OK, free_slot);
1019 }
1020
1021
1022
1023 /*
1024  * delete a floor
1025  */
1026 void cmd_kflr(char *argbuf)
1027 {
1028         struct floor flbuf;
1029         int floor_to_delete;
1030         int kflr_ok;
1031         int delete_ok;
1032
1033         floor_to_delete = extract_int(argbuf, 0);
1034         kflr_ok = extract_int(argbuf, 1);
1035
1036         if (CtdlAccessCheck(ac_aide)) return;
1037
1038         lgetfloor(&flbuf, floor_to_delete);
1039
1040         delete_ok = 1;
1041         if ((flbuf.f_flags & F_INUSE) == 0) {
1042                 cprintf("%d Floor %d not in use.\n",
1043                         ERROR + INVALID_FLOOR_OPERATION, floor_to_delete);
1044                 delete_ok = 0;
1045         } else {
1046                 if (flbuf.f_ref_count != 0) {
1047                         cprintf("%d Cannot delete; floor contains %d rooms.\n",
1048                                 ERROR + INVALID_FLOOR_OPERATION,
1049                                 flbuf.f_ref_count);
1050                         delete_ok = 0;
1051                 } else {
1052                         if (kflr_ok == 1) {
1053                                 cprintf("%d Ok\n", CIT_OK);
1054                         } else {
1055                                 cprintf("%d Ok to delete...\n", CIT_OK);
1056                         }
1057
1058                 }
1059
1060         }
1061
1062         if ((delete_ok == 1) && (kflr_ok == 1))
1063                 flbuf.f_flags = 0;
1064         lputfloor(&flbuf, floor_to_delete);
1065 }
1066
1067 /*
1068  * edit a floor
1069  */
1070 void cmd_eflr(char *argbuf)
1071 {
1072         struct floor flbuf;
1073         int floor_num;
1074         int np;
1075
1076         np = num_parms(argbuf);
1077         if (np < 1) {
1078                 cprintf("%d Usage error.\n", ERROR + ILLEGAL_VALUE);
1079                 return;
1080         }
1081
1082         if (CtdlAccessCheck(ac_aide)) return;
1083
1084         floor_num = extract_int(argbuf, 0);
1085         lgetfloor(&flbuf, floor_num);
1086         if ((flbuf.f_flags & F_INUSE) == 0) {
1087                 lputfloor(&flbuf, floor_num);
1088                 cprintf("%d Floor %d is not in use.\n",
1089                         ERROR + INVALID_FLOOR_OPERATION, floor_num);
1090                 return;
1091         }
1092         if (np >= 2)
1093                 extract_token(flbuf.f_name, argbuf, 1, '|', sizeof flbuf.f_name);
1094         lputfloor(&flbuf, floor_num);
1095
1096         cprintf("%d Ok\n", CIT_OK);
1097 }
1098
1099
1100
1101 /*
1102  * cmd_stat()  -  return the modification time of the current room (maybe other things in the future)
1103  */
1104 void cmd_stat(char *gargs)
1105 {
1106         if (CtdlAccessCheck(ac_logged_in_or_guest)) return;
1107         CtdlGetRoom(&CC->room, CC->room.QRname);
1108         cprintf("%d %s|%ld|\n", CIT_OK, CC->room.QRname, CC->room.QRmtime);
1109 }
1110
1111
1112
1113
1114 /*****************************************************************************/
1115 /*                      MODULE INITIALIZATION STUFF                          */
1116 /*****************************************************************************/
1117
1118 CTDL_MODULE_INIT(rooms)
1119 {
1120         if (!threading) {
1121                 CtdlRegisterProtoHook(cmd_lrms, "LRMS", "List rooms");
1122                 CtdlRegisterProtoHook(cmd_lkra, "LKRA", "List all known rooms");
1123                 CtdlRegisterProtoHook(cmd_lkrn, "LKRN", "List known rooms with new messages");
1124                 CtdlRegisterProtoHook(cmd_lkro, "LKRO", "List known rooms without new messages");
1125                 CtdlRegisterProtoHook(cmd_lzrm, "LZRM", "List zapped rooms");
1126                 CtdlRegisterProtoHook(cmd_lprm, "LPRM", "List public rooms");
1127                 CtdlRegisterProtoHook(cmd_goto, "GOTO", "Goto a named room");
1128                 CtdlRegisterProtoHook(cmd_stat, "STAT", "Get mtime of the current room");
1129                 CtdlRegisterProtoHook(cmd_whok, "WHOK", "List users who know this room");
1130                 CtdlRegisterProtoHook(cmd_rdir, "RDIR", "List files in room directory");
1131                 CtdlRegisterProtoHook(cmd_getr, "GETR", "Get room parameters");
1132                 CtdlRegisterProtoHook(cmd_setr, "SETR", "Set room parameters");
1133                 CtdlRegisterProtoHook(cmd_geta, "GETA", "Get the room admin name");
1134                 CtdlRegisterProtoHook(cmd_seta, "SETA", "Set the room admin for this room");
1135                 CtdlRegisterProtoHook(cmd_rinf, "RINF", "Fetch room info file");
1136                 CtdlRegisterProtoHook(cmd_kill, "KILL", "Kill (delete) the current room");
1137                 CtdlRegisterProtoHook(cmd_cre8, "CRE8", "Create a new room");
1138                 CtdlRegisterProtoHook(cmd_einf, "EINF", "Enter info file for the current room");
1139                 CtdlRegisterProtoHook(cmd_lflr, "LFLR", "List all known floors");
1140                 CtdlRegisterProtoHook(cmd_cflr, "CFLR", "Create a new floor");
1141                 CtdlRegisterProtoHook(cmd_kflr, "KFLR", "Kill a floor");
1142                 CtdlRegisterProtoHook(cmd_eflr, "EFLR", "Edit a floor");
1143         }
1144         /* return our Subversion id for the Log */
1145         return "rooms";
1146 }