citadel/citserver.c

   1 /*
   2  * $Id$
   3  *
   4  * Main source module for the Citadel server
   5  *
   6  */
   7
   8 #include "sysdep.h"
   9 #include <stdlib.h>
  10 #include <unistd.h>
  11 #include <stdio.h>
  12 #include <fcntl.h>
  13 #include <signal.h>
  14 #include <sys/types.h>
  15 #include <sys/stat.h>
  16
  17
  18 #if TIME_WITH_SYS_TIME
  19 # include <sys/time.h>
  20 # include <time.h>
  21 #else
  22 # if HAVE_SYS_TIME_H
  23 #  include <sys/time.h>
  24 # else
  25 #  include <time.h>
  26 # endif
  27 #endif
  28
  29 #if HAVE_BACKTRACE
  30 #include <execinfo.h>
  31 #endif
  32
  33 #include <ctype.h>
  34 #include <string.h>
  35 #include <dirent.h>
  36 #include <errno.h>
  37 #include <limits.h>
  38 #include <netdb.h>
  39 #include <sys/types.h>
  40 #include <sys/socket.h>
  41 #include <netinet/in.h>
  42 #include <arpa/inet.h>
  43 #include <libcitadel.h>
  44 #include "citadel.h"
  45 #include "server.h"
  46 #include "sysdep_decls.h"
  47 #include "threads.h"
  48 #include "citserver.h"
  49 #include "config.h"
  50 #include "database.h"
  51 #include "housekeeping.h"
  52 #include "user_ops.h"
  53 #include "msgbase.h"
  54 #include "support.h"
  55 #include "locate_host.h"
  56 #include "room_ops.h"
  57 #include "file_ops.h"
  58 #include "policy.h"
  59 #include "control.h"
  60 #include "euidindex.h"
  61
  62 #ifndef HAVE_SNPRINTF
  63 #include "snprintf.h"
  64 #endif
  65
  66 #include "ctdl_module.h"
  67
  68
  69 struct CitContext *ContextList = NULL;
  70 struct CitContext* next_session = NULL;
  71 char *unique_session_numbers;
  72 int ScheduledShutdown = 0;
  73 time_t server_startup_time;
  74 int panic_fd;
  75
  76 /**
  77  * \brief print the actual stack frame.
  78  */
  79 void cit_backtrace(void)
  80 {
  81 #ifdef HAVE_BACKTRACE
  82         void *stack_frames[50];
  83         size_t size, i;
  84         char **strings;
  85
  86
  87         size = backtrace(stack_frames, sizeof(stack_frames) / sizeof(void*));
  88         strings = backtrace_symbols(stack_frames, size);
  89         for (i = 0; i < size; i++) {
  90                 if (strings != NULL)
  91                         lprintf(1, "%s\n", strings[i]);
  92                 else
  93                         lprintf(1, "%p\n", stack_frames[i]);
  94         }
  95         free(strings);
  96 #endif
  97 }
  98
  99 /**
 100  * \brief print the actual stack frame.
 101  */
 102 void cit_panic_backtrace(int SigNum)
 103 {
 104 #ifdef HAVE_BACKTRACE
 105         void *stack_frames[10];
 106         size_t size, i;
 107         char **strings;
 108
 109         printf("caught signal 11\n");
 110         size = backtrace(stack_frames, sizeof(stack_frames) / sizeof(void*));
 111         strings = backtrace_symbols(stack_frames, size);
 112         for (i = 0; i < size; i++) {
 113                 if (strings != NULL)
 114                         lprintf(1, "%s\n", strings[i]);
 115                 else
 116                         lprintf(1, "%p\n", stack_frames[i]);
 117         }
 118         free(strings);
 119 #endif
 120         exit(-1);
 121 }
 122
 123 /*
 124  * Various things that need to be initialized at startup
 125  */
 126 void master_startup(void) {
 127         struct timeval tv;
 128         unsigned int seed;
 129         FILE *urandom;
 130         struct ctdlroom qrbuf;
 131
 132         lprintf(CTDL_DEBUG, "master_startup() started\n");
 133         time(&server_startup_time);
 134
 135         lprintf(CTDL_INFO, "Opening databases\n");
 136         open_databases();
 137
 138         ctdl_thread_internal_init_tsd();
 139
 140         CtdlThreadAllocTSD();
 141
 142         check_ref_counts();
 143
 144         lprintf(CTDL_INFO, "Creating base rooms (if necessary)\n");
 145         create_room(config.c_baseroom,  0, "", 0, 1, 0, VIEW_BBS);
 146         create_room(AIDEROOM,           3, "", 0, 1, 0, VIEW_BBS);
 147         create_room(SYSCONFIGROOM,      3, "", 0, 1, 0, VIEW_BBS);
 148         create_room(config.c_twitroom,  0, "", 0, 1, 0, VIEW_BBS);
 149
 150         /* The "Local System Configuration" room doesn't need to be visible */
 151         if (lgetroom(&qrbuf, SYSCONFIGROOM) == 0) {
 152                 qrbuf.QRflags2 |= QR2_SYSTEM;
 153                 lputroom(&qrbuf);
 154         }
 155
 156         /* Aide needs to be public postable, else we're not RFC conformant. */
 157         if (lgetroom(&qrbuf, AIDEROOM) == 0) {
 158                 qrbuf.QRflags2 |= QR2_SMTP_PUBLIC;
 159                 lputroom(&qrbuf);
 160         }
 161
 162         lprintf(CTDL_INFO, "Seeding the pseudo-random number generator...\n");
 163         urandom = fopen("/dev/urandom", "r");
 164         if (urandom != NULL) {
 165                 fread(&seed, sizeof seed, 1, urandom);
 166                 fclose(urandom);
 167         }
 168         else {
 169                 gettimeofday(&tv, NULL);
 170                 seed = tv.tv_usec;
 171         }
 172         srandom(seed);
 173
 174         lprintf(CTDL_INFO, "Initializing ipgm secret\n");
 175         get_config();
 176         config.c_ipgm_secret = rand();
 177         put_config();
 178
 179         lprintf(CTDL_DEBUG, "master_startup() finished\n");
 180 }
 181
 182
 183 /*
 184  * Cleanup routine to be called when the server is shutting down.
 185  */
 186 void master_cleanup(int exitcode) {
 187         struct CleanupFunctionHook *fcn;
 188         static int already_cleaning_up = 0;
 189
 190         if (already_cleaning_up) while(1) sleep(1);
 191         already_cleaning_up = 1;
 192
 193         /* Run any cleanup routines registered by loadable modules */
 194         for (fcn = CleanupHookTable; fcn != NULL; fcn = fcn->next) {
 195                 (*fcn->h_function_pointer)();
 196         }
 197
 198         /* Close the AdjRefCount queue file */
 199         AdjRefCount(-1, 0);
 200
 201         /* Do system-dependent stuff */
 202         sysdep_master_cleanup();
 203
 204         /* Close databases */
 205         lprintf(CTDL_INFO, "Closing databases\n");
 206         close_databases();
 207
 208 #ifdef DEBUG_MEMORY_LEAKS
 209         dump_heap();
 210 #endif
 211
 212         /* If the operator requested a halt but not an exit, halt here. */
 213         if (shutdown_and_halt) {
 214                 lprintf(CTDL_NOTICE, "citserver: Halting server without exiting.\n");
 215                 fflush(stdout); fflush(stderr);
 216                 while(1) {
 217                         sleep(32767);
 218                 }
 219         }
 220
 221         release_control();
 222
 223         /* Now go away. */
 224         lprintf(CTDL_NOTICE, "citserver: Exiting with status %d\n", exitcode);
 225         fflush(stdout); fflush(stderr);
 226
 227         if (restart_server != 0)
 228                 exit(1);
 229         exit(exitcode);
 230 }
 231
 232
 233
 234 /*
 235  * Terminate a session.
 236  */
 237 void RemoveContext (struct CitContext *con)
 238 {
 239         if (con==NULL) {
 240                 lprintf(CTDL_ERR,
 241                         "WARNING: RemoveContext() called with NULL!\n");
 242                 return;
 243         }
 244         lprintf(CTDL_DEBUG, "RemoveContext() session %d\n", con->cs_pid);
 245
 246         /* Run any cleanup routines registered by loadable modules.
 247          * Note: We have to "become_session()" because the cleanup functions
 248          *       might make references to "CC" assuming it's the right one.
 249          */
 250         become_session(con);
 251         logout();
 252         PerformSessionHooks(EVT_STOP);
 253         become_session(NULL);
 254
 255         lprintf(CTDL_NOTICE, "[%3d] Session ended.\n", con->cs_pid);
 256
 257         /* If the client is still connected, blow 'em away. */
 258         lprintf(CTDL_DEBUG, "Closing socket %d\n", con->client_socket);
 259         close(con->client_socket);
 260
 261         lprintf(CTDL_DEBUG, "Done with RemoveContext()\n");
 262 }
 263
 264
 265
 266
 267
 268 /*
 269  * cmd_info()  -  tell the client about this server
 270  */
 271 void cmd_info(void) {
 272         cprintf("%d Server info:\n", LISTING_FOLLOWS);
 273         cprintf("%d\n", CC->cs_pid);
 274         cprintf("%s\n", config.c_nodename);
 275         cprintf("%s\n", config.c_humannode);
 276         cprintf("%s\n", config.c_fqdn);
 277         cprintf("%s\n", CITADEL);
 278         cprintf("%d\n", REV_LEVEL);
 279         cprintf("%s\n", config.c_site_location);
 280         cprintf("%s\n", config.c_sysadm);
 281         cprintf("%d\n", SERVER_TYPE);
 282         cprintf("%s\n", config.c_moreprompt);
 283         cprintf("1\n"); /* 1 = yes, this system supports floors */
 284         cprintf("1\n"); /* 1 = we support the extended paging options */
 285         cprintf("%s\n", CC->cs_nonce);
 286         cprintf("1\n"); /* 1 = yes, this system supports the QNOP command */
 287
 288 #ifdef HAVE_LDAP
 289         cprintf("1\n"); /* 1 = yes, this server is LDAP-enabled */
 290 #else
 291         cprintf("0\n"); /* 1 = no, this server is not LDAP-enabled */
 292 #endif
 293
 294         if (config.c_auth_mode == AUTHMODE_NATIVE) {
 295                 cprintf("%d\n", config.c_disable_newu);
 296         }
 297         else {
 298                 cprintf("1\n"); /* "create new user" does not work with non-native auth modes */
 299         }
 300
 301         cprintf("%s\n", config.c_default_cal_zone);
 302
 303         /* Output load averages */
 304         cprintf("%f\n", CtdlThreadLoadAvg);
 305         cprintf("%f\n", CtdlThreadWorkerAvg);
 306         cprintf("%d\n", CtdlThreadGetCount());
 307
 308         cprintf("1\n");         /* yes, Sieve mail filtering is supported */
 309         cprintf("%d\n", config.c_enable_fulltext);
 310         cprintf("%s\n", svn_revision());
 311
 312         cprintf("000\n");
 313 }
 314
 315
 316 /*
 317  * returns an asterisk if there are any instant messages waiting,
 318  * space otherwise.
 319  */
 320 char CtdlCheckExpress(void) {
 321         if (CC->FirstExpressMessage == NULL) {
 322                 return(' ');
 323         }
 324         else {
 325                 return('*');
 326         }
 327 }
 328
 329 void cmd_time(void)
 330 {
 331    time_t tv;
 332    struct tm tmp;
 333
 334    tv = time(NULL);
 335    localtime_r(&tv, &tmp);
 336
 337    /* timezone and daylight global variables are not portable. */
 338 #ifdef HAVE_STRUCT_TM_TM_GMTOFF
 339    cprintf("%d %ld|%ld|%d\n", CIT_OK, (long)tv, tmp.tm_gmtoff, tmp.tm_isdst);
 340 #else
 341    cprintf("%d %ld|%ld|%d\n", CIT_OK, (long)tv, timezone, tmp.tm_isdst);
 342 #endif
 343 }
 344
 345
 346 /*
 347  * Check originating host against the public_clients file.  This determines
 348  * whether the client is allowed to change the hostname for this session
 349  * (for example, to show the location of the user rather than the location
 350  * of the client).
 351  */
 352 int is_public_client(void)
 353 {
 354         char buf[1024];
 355         char addrbuf[1024];
 356         FILE *fp;
 357         int i;
 358         char *public_clientspos;
 359         char *public_clientsend;
 360         char *paddr = NULL;
 361         struct stat statbuf;
 362         static time_t pc_timestamp = 0;
 363         static char public_clients[SIZ];
 364         static char public_clients_file[SIZ];
 365
 366 #define LOCALHOSTSTR "127.0.0.1"
 367
 368         snprintf(public_clients_file,
 369                          sizeof public_clients_file,
 370                          "%s/public_clients",
 371                          ctdl_etc_dir);
 372
 373         /*
 374          * Check the time stamp on the public_clients file.  If it's been
 375          * updated since the last time we were here (or if this is the first
 376          * time we've been through the loop), read its contents and learn
 377          * the IP addresses of the listed hosts.
 378          */
 379         if (stat(public_clients_file, &statbuf) != 0) {
 380                 /* No public_clients file exists, so bail out */
 381                 lprintf(CTDL_WARNING, "Warning: '%s' does not exist\n",
 382                                 public_clients_file);
 383                 return(0);
 384         }
 385
 386         if (statbuf.st_mtime > pc_timestamp) {
 387                 begin_critical_section(S_PUBLIC_CLIENTS);
 388                 lprintf(CTDL_INFO, "Loading %s\n", public_clients_file);
 389
 390                 public_clientspos = &public_clients[0];
 391                 public_clientsend = public_clientspos + SIZ;
 392                 safestrncpy(public_clientspos, LOCALHOSTSTR, sizeof public_clients);
 393                 public_clientspos += sizeof(LOCALHOSTSTR) - 1;
 394
 395                 if (hostname_to_dotted_quad(addrbuf, config.c_fqdn) == 0) {
 396                         *(public_clientspos++) = '|';
 397                         paddr = &addrbuf[0];
 398                         while (!IsEmptyStr (paddr) &&
 399                                (public_clientspos < public_clientsend))
 400                                 *(public_clientspos++) = *(paddr++);
 401                 }
 402
 403                 fp = fopen(public_clients_file, "r");
 404                 if (fp != NULL)
 405                         while ((fgets(buf, sizeof buf, fp)!=NULL) &&
 406                                (public_clientspos < public_clientsend)){
 407                                 char *ptr;
 408                                 ptr = buf;
 409                                 while (!IsEmptyStr(ptr)) {
 410                                         if (*ptr == '#') {
 411                                                 *ptr = 0;
 412                                                 break;
 413                                         }
 414                                 else ptr++;
 415                                 }
 416                                 ptr--;
 417                                 while (ptr>buf && isspace(*ptr)) {
 418                                         *(ptr--) = 0;
 419                                 }
 420                                 if (hostname_to_dotted_quad(addrbuf, buf) == 0) {
 421                                         *(public_clientspos++) = '|';
 422                                         paddr = addrbuf;
 423                                         while (!IsEmptyStr(paddr) &&
 424                                                (public_clientspos < public_clientsend)){
 425                                                 *(public_clientspos++) = *(paddr++);
 426                                         }
 427                                 }
 428                         }
 429                 fclose(fp);
 430                 pc_timestamp = time(NULL);
 431                 end_critical_section(S_PUBLIC_CLIENTS);
 432         }
 433
 434         lprintf(CTDL_DEBUG, "Checking whether %s is a local or public client\n",
 435                 CC->cs_addr);
 436         for (i=0; i<num_parms(public_clients); ++i) {
 437                 extract_token(addrbuf, public_clients, i, '|', sizeof addrbuf);
 438                 if (!strcasecmp(CC->cs_addr, addrbuf)) {
 439                         lprintf(CTDL_DEBUG, "... yes it is.\n");
 440                         return(1);
 441                 }
 442         }
 443
 444         /* No hits.  This is not a public client. */
 445         lprintf(CTDL_DEBUG, "... no it isn't.\n");
 446         return(0);
 447 }
 448
 449
 450 /*
 451  * the client is identifying itself to the server
 452  */
 453 void cmd_iden(char *argbuf)
 454 {
 455         int dev_code;
 456         int cli_code;
 457         int rev_level;
 458         char desc[128];
 459         char from_host[128];
 460         struct in_addr addr;
 461         int do_lookup = 0;
 462
 463         if (num_parms(argbuf)<4) {
 464                 cprintf("%d usage error\n", ERROR + ILLEGAL_VALUE);
 465                 return;
 466         }
 467
 468         dev_code = extract_int(argbuf,0);
 469         cli_code = extract_int(argbuf,1);
 470         rev_level = extract_int(argbuf,2);
 471         extract_token(desc, argbuf, 3, '|', sizeof desc);
 472
 473         safestrncpy(from_host, config.c_fqdn, sizeof from_host);
 474         from_host[sizeof from_host - 1] = 0;
 475         if (num_parms(argbuf)>=5) extract_token(from_host, argbuf, 4, '|', sizeof from_host);
 476
 477         CC->cs_clientdev = dev_code;
 478         CC->cs_clienttyp = cli_code;
 479         CC->cs_clientver = rev_level;
 480         safestrncpy(CC->cs_clientname, desc, sizeof CC->cs_clientname);
 481         CC->cs_clientname[31] = 0;
 482
 483         if (!IsEmptyStr(from_host)) {
 484                 if (CC->is_local_socket) do_lookup = 1;
 485                 else if (is_public_client()) do_lookup = 1;
 486         }
 487
 488         if (do_lookup) {
 489                 lprintf(CTDL_DEBUG, "Looking up hostname '%s'\n", from_host);
 490                 if ((addr.s_addr = inet_addr(from_host)) != -1) {
 491                         locate_host(CC->cs_host, sizeof CC->cs_host,
 492                                 CC->cs_addr, sizeof CC->cs_addr,
 493                                 &addr);
 494                 }
 495                 else {
 496                         safestrncpy(CC->cs_host, from_host, sizeof CC->cs_host);
 497                         CC->cs_host[sizeof CC->cs_host - 1] = 0;
 498                 }
 499         }
 500
 501         lprintf(CTDL_NOTICE, "Client %d/%d/%01d.%02d (%s) from %s\n",
 502                 dev_code,
 503                 cli_code,
 504                 (rev_level / 100),
 505                 (rev_level % 100),
 506                 desc,
 507                 CC->cs_host);
 508         cprintf("%d Ok\n",CIT_OK);
 509 }
 510
 511
 512 /*
 513  * display system messages or help
 514  */
 515 void cmd_mesg(char *mname)
 516 {
 517         FILE *mfp;
 518         char targ[256];
 519         char buf[256];
 520         char buf2[256];
 521         char *dirs[2];
 522         DIR *dp;
 523         struct dirent *d;
 524
 525         extract_token(buf, mname, 0, '|', sizeof buf);
 526
 527         dirs[0] = strdup(ctdl_message_dir);
 528         dirs[1] = strdup(ctdl_hlp_dir);
 529
 530         snprintf(buf2, sizeof buf2, "%s.%d.%d",
 531                 buf, CC->cs_clientdev, CC->cs_clienttyp);
 532
 533         /* If the client requested "?" then produce a listing */
 534         if (!strcmp(buf, "?")) {
 535                 cprintf("%d %s\n", LISTING_FOLLOWS, buf);
 536                 dp = opendir(dirs[1]);
 537                 if (dp != NULL) {
 538                         while (d = readdir(dp), d != NULL) {
 539                                 if (d->d_name[0] != '.') {
 540                                         cprintf(" %s\n", d->d_name);
 541                                 }
 542                         }
 543                         closedir(dp);
 544                 }
 545                 cprintf("000\n");
 546                 free(dirs[0]);
 547                 free(dirs[1]);
 548                 return;
 549         }
 550
 551         /* Otherwise, look for the requested file by name. */
 552         else {
 553                 mesg_locate(targ, sizeof targ, buf2, 2, (const char **)dirs);
 554                 if (IsEmptyStr(targ)) {
 555                         snprintf(buf2, sizeof buf2, "%s.%d",
 556                                                         buf, CC->cs_clientdev);
 557                         mesg_locate(targ, sizeof targ, buf2, 2,
 558                                                         (const char **)dirs);
 559                         if (IsEmptyStr(targ)) {
 560                                 mesg_locate(targ, sizeof targ, buf, 2,
 561                                                         (const char **)dirs);
 562                         }
 563                 }
 564         }
 565
 566         free(dirs[0]);
 567         free(dirs[1]);
 568
 569         if (IsEmptyStr(targ)) {
 570                 cprintf("%d '%s' not found.  (Searching in %s and %s)\n",
 571                         ERROR + FILE_NOT_FOUND,
 572                         mname,
 573                         ctdl_message_dir,
 574                         ctdl_hlp_dir
 575                 );
 576                 return;
 577         }
 578
 579         mfp = fopen(targ, "r");
 580         if (mfp==NULL) {
 581                 cprintf("%d Cannot open '%s': %s\n",
 582                         ERROR + INTERNAL_ERROR, targ, strerror(errno));
 583                 return;
 584         }
 585         cprintf("%d %s\n", LISTING_FOLLOWS,buf);
 586
 587         while (fgets(buf, (sizeof buf - 1), mfp) != NULL) {
 588                 buf[strlen(buf)-1] = 0;
 589                 do_help_subst(buf);
 590                 cprintf("%s\n",buf);
 591         }
 592
 593         fclose(mfp);
 594         cprintf("000\n");
 595 }
 596
 597
 598 /*
 599  * enter system messages or help
 600  */
 601 void cmd_emsg(char *mname)
 602 {
 603         FILE *mfp;
 604         char targ[256];
 605         char buf[256];
 606         char *dirs[2];
 607         int a;
 608
 609         unbuffer_output();
 610
 611         if (CtdlAccessCheck(ac_aide)) return;
 612
 613         extract_token(buf, mname, 0, '|', sizeof buf);
 614         for (a=0; !IsEmptyStr(&buf[a]); ++a) {          /* security measure */
 615                 if (buf[a] == '/') buf[a] = '.';
 616         }
 617
 618         dirs[0] = strdup(ctdl_message_dir);
 619         dirs[1] = strdup(ctdl_hlp_dir);
 620
 621         mesg_locate(targ, sizeof targ, buf, 2, (const char**)dirs);
 622         free(dirs[0]);
 623         free(dirs[1]);
 624
 625         if (IsEmptyStr(targ)) {
 626                 snprintf(targ, sizeof targ,
 627                                  "%s/%s",
 628                                  ctdl_hlp_dir, buf);
 629         }
 630
 631         mfp = fopen(targ,"w");
 632         if (mfp==NULL) {
 633                 cprintf("%d Cannot open '%s': %s\n",
 634                         ERROR + INTERNAL_ERROR, targ, strerror(errno));
 635                 return;
 636         }
 637         cprintf("%d %s\n", SEND_LISTING, targ);
 638
 639         while (client_getln(buf, sizeof buf), strcmp(buf, "000")) {
 640                 fprintf(mfp, "%s\n", buf);
 641         }
 642
 643         fclose(mfp);
 644 }
 645
 646
 647 /* Don't show the names of private rooms unless the viewing
 648  * user also knows the rooms.
 649  */
 650 void GenerateRoomDisplay(char *real_room,
 651                         struct CitContext *viewed,
 652                         struct CitContext *viewer) {
 653
 654         int ra;
 655
 656         strcpy(real_room, viewed->room.QRname);
 657         if (viewed->room.QRflags & QR_MAILBOX) {
 658                 strcpy(real_room, &real_room[11]);
 659         }
 660         if (viewed->room.QRflags & QR_PRIVATE) {
 661                 CtdlRoomAccess(&viewed->room, &viewer->user, &ra, NULL);
 662                 if ( (ra & UA_KNOWN) == 0) {
 663                         strcpy(real_room, "<private room>");
 664                 }
 665         }
 666
 667         if (viewed->cs_flags & CS_CHAT) {
 668                 while (strlen(real_room) < 14) {
 669                         strcat(real_room, " ");
 670                 }
 671                 strcpy(&real_room[14], "<chat>");
 672         }
 673
 674 }
 675
 676 /*
 677  * Convenience function.
 678  */
 679 int CtdlAccessCheck(int required_level) {
 680
 681         if (CC->internal_pgm) return(0);
 682         if (required_level >= ac_internal) {
 683                 cprintf("%d This is not a user-level command.\n",
 684                         ERROR + HIGHER_ACCESS_REQUIRED);
 685                 return(-1);
 686         }
 687
 688         if ((required_level >= ac_logged_in) && (CC->logged_in == 0)) {
 689                 cprintf("%d Not logged in.\n", ERROR + NOT_LOGGED_IN);
 690                 return(-1);
 691         }
 692
 693         if (CC->user.axlevel >= 6) return(0);
 694         if (required_level >= ac_aide) {
 695                 cprintf("%d This command requires Aide access.\n",
 696                         ERROR + HIGHER_ACCESS_REQUIRED);
 697                 return(-1);
 698         }
 699
 700         if (is_room_aide()) return(0);
 701         if (required_level >= ac_room_aide) {
 702                 cprintf("%d This command requires Aide or Room Aide access.\n",
 703                         ERROR + HIGHER_ACCESS_REQUIRED);
 704                 return(-1);
 705         }
 706
 707         /* shhh ... succeed quietly */
 708         return(0);
 709 }
 710
 711
 712
 713 /*
 714  * Terminate another running session
 715  */
 716 void cmd_term(char *cmdbuf)
 717 {
 718         int session_num;
 719         struct CitContext *ccptr;
 720         int found_it = 0;
 721         int allowed = 0;
 722
 723         session_num = extract_int(cmdbuf, 0);
 724         if (session_num == CC->cs_pid) {
 725                 cprintf("%d You can't kill your own session.\n", ERROR + ILLEGAL_VALUE);
 726                 return;
 727         }
 728
 729         lprintf(CTDL_DEBUG, "Locating session to kill\n");
 730         begin_critical_section(S_SESSION_TABLE);
 731         for (ccptr = ContextList; ccptr != NULL; ccptr = ccptr->next) {
 732                 if (session_num == ccptr->cs_pid) {
 733                         found_it = 1;
 734                         if ((ccptr->user.usernum == CC->user.usernum)
 735                            || (CC->user.axlevel >= 6)) {
 736                                 allowed = 1;
 737                                 ccptr->kill_me = 1;
 738                         }
 739                         else {
 740                                 allowed = 0;
 741                         }
 742                 }
 743         }
 744         end_critical_section(S_SESSION_TABLE);
 745
 746         if (found_it) {
 747                 if (allowed) {
 748                         cprintf("%d Session terminated.\n", CIT_OK);
 749                 }
 750                 else {
 751                         cprintf("%d You are not allowed to do that.\n",
 752                                 ERROR + HIGHER_ACCESS_REQUIRED);
 753                 }
 754         }
 755         else {
 756                 cprintf("%d No such session.\n", ERROR + ILLEGAL_VALUE);
 757         }
 758 }
 759
 760
 761
 762
 763
 764 /*
 765  * get the paginator prompt
 766  */
 767 void cmd_more(void) {
 768         cprintf("%d %s\n", CIT_OK, config.c_moreprompt);
 769 }
 770
 771 /*
 772  * echo
 773  */
 774 void cmd_echo(char *etext)
 775 {
 776         cprintf("%d %s\n", CIT_OK, etext);
 777 }
 778
 779
 780
 781 /*
 782  * identify as internal program
 783  */
 784 void cmd_ipgm(char *argbuf)
 785 {
 786         int secret;
 787
 788         secret = extract_int(argbuf, 0);
 789
 790         /* For security reasons, we do NOT allow this command to run
 791          * over the network.  Local sockets only.
 792          */
 793         if (!CC->is_local_socket) {
 794                 sleep(5);
 795                 cprintf("%d Authentication failed.\n",
 796                         ERROR + PASSWORD_REQUIRED);
 797         }
 798         else if (secret == config.c_ipgm_secret) {
 799                 CC->internal_pgm = 1;
 800                 strcpy(CC->curr_user, "<internal program>");
 801                 CC->cs_flags = CC->cs_flags|CS_STEALTH;
 802                 cprintf("%d Authenticated as an internal program.\n", CIT_OK);
 803         }
 804         else {
 805                 sleep(5);
 806                 cprintf("%d Authentication failed.\n",
 807                         ERROR + PASSWORD_REQUIRED);
 808                 lprintf(CTDL_ERR, "Warning: ipgm authentication failed.\n");
 809                 CC->kill_me = 1;
 810         }
 811
 812         /* Now change the ipgm secret for the next round.
 813          * (Disabled because it breaks concurrent scripts.  The fact that
 814          * we no longer accept IPGM over the network should be sufficient
 815          * to prevent brute-force attacks.  If you don't agree, uncomment
 816          * this block.)
 817         get_config();
 818         config.c_ipgm_secret = rand();
 819         put_config();
 820         */
 821 }
 822
 823
 824 /*
 825  * Shut down the server
 826  */
 827 void cmd_down(char *argbuf) {
 828         char *Reply ="%d Shutting down server.  Goodbye.\n";
 829
 830         if (CtdlAccessCheck(ac_aide)) return;
 831
 832         if (!IsEmptyStr(argbuf))
 833         {
 834                 int state = CIT_OK;
 835                 restart_server = extract_int(argbuf, 0);
 836
 837                 if (restart_server > 0)
 838                         Reply = "%d Restarting server.  See you soon.\n";
 839                 if ((restart_server > 0) && !running_as_daemon)
 840                 {
 841                         lprintf(CTDL_ERR, "The user requested restart, but not running as deamon! Geronimooooooo!\n");
 842                         Reply = "%d Warning, not running in deamon mode. maybe we will come up again, but don't lean on it.\n";
 843                         state = ERROR;
 844                 }
 845                 cprintf(Reply, state);
 846         }
 847         else
 848         {
 849                 cprintf(Reply, CIT_OK + SERVER_SHUTTING_DOWN);
 850         }
 851         CtdlThreadStopAll();
 852 }
 853
 854 /*
 855  * Halt the server without exiting the server process.
 856  */
 857 void cmd_halt(void) {
 858
 859         if (CtdlAccessCheck(ac_aide)) return;
 860
 861         cprintf("%d Halting server.  Goodbye.\n", CIT_OK);
 862         CtdlThreadStopAll();
 863         shutdown_and_halt = 1;
 864 }
 865
 866 /*
 867  * Schedule or cancel a server shutdown
 868  */
 869 void cmd_scdn(char *argbuf)
 870 {
 871         int new_state;
 872         int state = CIT_OK;
 873         char *Reply = "%d %d\n";
 874
 875         if (CtdlAccessCheck(ac_aide)) return;
 876
 877         new_state = extract_int(argbuf, 0);
 878         if ((new_state == 2) || (new_state == 3))
 879         {
 880                 restart_server = 1;
 881                 if (!running_as_daemon)
 882                 {
 883                         lprintf(CTDL_ERR, "The user requested restart, but not running as deamon! Geronimooooooo!\n");
 884                         Reply = "%d %d Warning, not running in deamon mode. maybe we will come up again, but don't lean on it.\n";
 885                         state = ERROR;
 886                 }
 887
 888                 restart_server = extract_int(argbuf, 0);
 889                 new_state -= 2;
 890         }
 891         if ((new_state == 0) || (new_state == 1)) {
 892                 ScheduledShutdown = new_state;
 893         }
 894         cprintf(Reply, state, ScheduledShutdown);
 895 }
 896
 897
 898 /*
 899  * Set or unset asynchronous protocol mode
 900  */
 901 void cmd_asyn(char *argbuf)
 902 {
 903         int new_state;
 904
 905         new_state = extract_int(argbuf, 0);
 906         if ((new_state == 0) || (new_state == 1)) {
 907                 CC->is_async = new_state;
 908         }
 909         cprintf("%d %d\n", CIT_OK, CC->is_async);
 910 }
 911
 912
 913 /*
 914  * Generate a "nonce" for APOP-style authentication.
 915  *
 916  * RFC 1725 et al specify a PID to be placed in front of the nonce.
 917  * Quoth BTX: That would be stupid.
 918  */
 919 void generate_nonce(struct CitContext *con) {
 920         struct timeval tv;
 921
 922         memset(con->cs_nonce, NONCE_SIZE, 0);
 923         gettimeofday(&tv, NULL);
 924         memset(con->cs_nonce, NONCE_SIZE, 0);
 925         snprintf(con->cs_nonce, NONCE_SIZE, "<%d%ld@%s>",
 926                 rand(), (long)tv.tv_usec, config.c_fqdn);
 927 }
 928
 929
 930
 931
 932 /*
 933  * Back-end function for starting a session
 934  */
 935 void begin_session(struct CitContext *con)
 936 {
 937         socklen_t len;
 938         struct sockaddr_in sin;
 939
 940         /*
 941          * Initialize some variables specific to our context.
 942          */
 943         con->logged_in = 0;
 944         con->internal_pgm = 0;
 945         con->download_fp = NULL;
 946         con->upload_fp = NULL;
 947         con->FirstExpressMessage = NULL;
 948         time(&con->lastcmd);
 949         time(&con->lastidle);
 950         strcpy(con->lastcmdname, "    ");
 951         strcpy(con->cs_clientname, "(unknown)");
 952         strcpy(con->curr_user, NLI);
 953         *con->net_node = '\0';
 954         *con->fake_username = '\0';
 955         *con->fake_hostname = '\0';
 956         *con->fake_roomname = '\0';
 957         generate_nonce(con);
 958         safestrncpy(con->cs_host, config.c_fqdn, sizeof con->cs_host);
 959         safestrncpy(con->cs_addr, "", sizeof con->cs_addr);
 960         con->cs_host[sizeof con->cs_host - 1] = 0;
 961         len = sizeof sin;
 962         if (!CC->is_local_socket) {
 963                 if (!getpeername(con->client_socket, (struct sockaddr *) &sin, &len)) {
 964                         locate_host(con->cs_host, sizeof con->cs_host,
 965                                 con->cs_addr, sizeof con->cs_addr,
 966                                 &sin.sin_addr
 967                         );
 968                 }
 969         }
 970         else {
 971                 strcpy(con->cs_host, "");
 972         }
 973         con->cs_flags = 0;
 974         con->upload_type = UPL_FILE;
 975         con->dl_is_net = 0;
 976
 977         con->nologin = 0;
 978         if ((config.c_maxsessions > 0)&&(num_sessions > config.c_maxsessions)) {
 979                 con->nologin = 1;
 980         }
 981
 982         if (!CC->is_local_socket) {
 983                 lprintf(CTDL_NOTICE, "Session started from %s [%s].\n", con->cs_host, con->cs_addr);
 984         }
 985         else {
 986                 lprintf(CTDL_NOTICE, "Session started via local socket.\n");
 987         }
 988
 989         /* Run any session startup routines registered by loadable modules */
 990         PerformSessionHooks(EVT_START);
 991 }
 992
 993
 994 void citproto_begin_session() {
 995         if (CC->nologin==1) {
 996                 cprintf("%d %s: Too many users are already online (maximum is %d)\n",
 997                         ERROR + MAX_SESSIONS_EXCEEDED,
 998                         config.c_nodename, config.c_maxsessions
 999                 );
1000                 CC->kill_me = 1;
1001         }
1002         else {
1003                 cprintf("%d %s Citadel server ready.\n",
1004                         CIT_OK, config.c_nodename);
1005         }
1006 }
1007
1008
1009
1010
1011 /*
1012  * This loop recognizes all server commands.
1013  */
1014 void do_command_loop(void) {
1015         char cmdbuf[SIZ];
1016         const char *old_name = NULL;
1017
1018         old_name = CtdlThreadName("do_command_loop");
1019
1020         time(&CC->lastcmd);
1021         memset(cmdbuf, 0, sizeof cmdbuf); /* Clear it, just in case */
1022         if (client_getln(cmdbuf, sizeof cmdbuf) < 1) {
1023                 lprintf(CTDL_ERR, "Client disconnected: ending session.\n");
1024                 CC->kill_me = 1;
1025                 CtdlThreadName(old_name);
1026                 return;
1027         }
1028
1029         /* Log the server command, but don't show passwords... */
1030         if ( (strncasecmp(cmdbuf, "PASS", 4))
1031            && (strncasecmp(cmdbuf, "SETP", 4)) ) {
1032                 lprintf(CTDL_INFO, "%s\n", cmdbuf);
1033         }
1034         else {
1035                 lprintf(CTDL_INFO, "<password command sent>\n");
1036         }
1037
1038         buffer_output();
1039
1040         /*
1041          * Let other clients see the last command we executed, and
1042          * update the idle time, but not NOOP, QNOP, PEXP, GEXP, RWHO, or TIME.
1043          */
1044         if ( (strncasecmp(cmdbuf, "NOOP", 4))
1045            && (strncasecmp(cmdbuf, "QNOP", 4))
1046            && (strncasecmp(cmdbuf, "PEXP", 4))
1047            && (strncasecmp(cmdbuf, "GEXP", 4))
1048            && (strncasecmp(cmdbuf, "RWHO", 4))
1049            && (strncasecmp(cmdbuf, "TIME", 4)) ) {
1050                 strcpy(CC->lastcmdname, "    ");
1051                 safestrncpy(CC->lastcmdname, cmdbuf, sizeof(CC->lastcmdname));
1052                 time(&CC->lastidle);
1053         }
1054
1055         CtdlThreadName(cmdbuf);
1056
1057         if ((strncasecmp(cmdbuf, "ENT0", 4))
1058            && (strncasecmp(cmdbuf, "MESG", 4))
1059            && (strncasecmp(cmdbuf, "MSGS", 4)))
1060         {
1061            CC->cs_flags &= ~CS_POSTING;
1062         }
1063
1064         if (!strncasecmp(cmdbuf, "NOOP", 4)) {
1065                 cprintf("%d%cok\n", CIT_OK, CtdlCheckExpress() );
1066         }
1067
1068         else if (!strncasecmp(cmdbuf, "XYZZY", 5)) {
1069                 cprintf("%d Nothing happens.\n", CIT_OK);
1070         }
1071
1072         else if (!strncasecmp(cmdbuf, "QNOP", 4)) {
1073                 /* do nothing, this command returns no response */
1074         }
1075
1076         else if (!strncasecmp(cmdbuf,"QUIT",4)) {
1077                 cprintf("%d Goodbye.\n", CIT_OK);
1078                 CC->kill_me = 1;
1079         }
1080
1081         else if (!strncasecmp(cmdbuf,"ASYN",4)) {
1082                 cmd_asyn(&cmdbuf[5]);
1083         }
1084
1085         else if (!strncasecmp(cmdbuf,"LOUT",4)) {
1086                 if (CC->logged_in) logout();
1087                 cprintf("%d logged out.\n", CIT_OK);
1088         }
1089
1090         else if (!strncasecmp(cmdbuf,"USER",4)) {
1091                 cmd_user(&cmdbuf[5]);
1092         }
1093
1094         else if (!strncasecmp(cmdbuf,"PASS",4)) {
1095                 cmd_pass(&cmdbuf[5]);
1096         }
1097
1098         else if (!strncasecmp(cmdbuf,"NEWU",4)) {
1099                 cmd_newu(&cmdbuf[5]);
1100         }
1101
1102         else if (!strncasecmp(cmdbuf,"CREU",4)) {
1103                 cmd_creu(&cmdbuf[5]);
1104         }
1105
1106         else if (!strncasecmp(cmdbuf,"SETP",4)) {
1107                 cmd_setp(&cmdbuf[5]);
1108         }
1109
1110         else if (!strncasecmp(cmdbuf,"LRMS",4)) {
1111                 cmd_lrms(&cmdbuf[5]);
1112         }
1113
1114         else if (!strncasecmp(cmdbuf,"LKRA",4)) {
1115                 cmd_lkra(&cmdbuf[5]);
1116         }
1117
1118         else if (!strncasecmp(cmdbuf,"LKRN",4)) {
1119                 cmd_lkrn(&cmdbuf[5]);
1120         }
1121
1122         else if (!strncasecmp(cmdbuf,"LKRO",4)) {
1123                 cmd_lkro(&cmdbuf[5]);
1124         }
1125
1126         else if (!strncasecmp(cmdbuf,"LZRM",4)) {
1127                 cmd_lzrm(&cmdbuf[5]);
1128         }
1129
1130         else if (!strncasecmp(cmdbuf,"LPRM",4)) {
1131                 cmd_lprm(&cmdbuf[5]);
1132         }
1133
1134         else if (!strncasecmp(cmdbuf,"GETU",4)) {
1135                 cmd_getu();
1136         }
1137
1138         else if (!strncasecmp(cmdbuf,"SETU",4)) {
1139                 cmd_setu(&cmdbuf[5]);
1140         }
1141
1142         else if (!strncasecmp(cmdbuf,"GOTO",4)) {
1143                 cmd_goto(&cmdbuf[5]);
1144         }
1145
1146         else if (!strncasecmp(cmdbuf,"MSGS",4)) {
1147                 cmd_msgs(&cmdbuf[5]);
1148         }
1149
1150         else if (!strncasecmp(cmdbuf,"WHOK",4)) {
1151                 cmd_whok();
1152         }
1153
1154         else if (!strncasecmp(cmdbuf,"RDIR",4)) {
1155                 cmd_rdir();
1156         }
1157
1158         else if (!strncasecmp(cmdbuf,"EUID",4)) {
1159                 cmd_euid(&cmdbuf[5]);
1160         }
1161
1162         else if (!strncasecmp(cmdbuf,"MSG0",4)) {
1163                 cmd_msg0(&cmdbuf[5]);
1164         }
1165
1166         else if (!strncasecmp(cmdbuf,"MSG2",4)) {
1167                 cmd_msg2(&cmdbuf[5]);
1168         }
1169
1170         else if (!strncasecmp(cmdbuf,"MSG3",4)) {
1171                 cmd_msg3(&cmdbuf[5]);
1172         }
1173
1174         else if (!strncasecmp(cmdbuf,"MSG4",4)) {
1175                 cmd_msg4(&cmdbuf[5]);
1176         }
1177
1178         else if (!strncasecmp(cmdbuf,"MSGP",4)) {
1179                 cmd_msgp(&cmdbuf[5]);
1180         }
1181
1182         else if (!strncasecmp(cmdbuf,"OPNA",4)) {
1183                 cmd_opna(&cmdbuf[5]);
1184         }
1185
1186         else if (!strncasecmp(cmdbuf,"DLAT",4)) {
1187                 cmd_dlat(&cmdbuf[5]);
1188         }
1189
1190         else if (!strncasecmp(cmdbuf,"INFO",4)) {
1191                 cmd_info();
1192         }
1193
1194         else if (!strncasecmp(cmdbuf,"SLRP",4)) {
1195                 cmd_slrp(&cmdbuf[5]);
1196         }
1197
1198         else if (!strncasecmp(cmdbuf,"INVT",4)) {
1199                 cmd_invt_kick(&cmdbuf[5],1);
1200         }
1201
1202         else if (!strncasecmp(cmdbuf,"KICK",4)) {
1203                 cmd_invt_kick(&cmdbuf[5],0);
1204         }
1205
1206         else if (!strncasecmp(cmdbuf,"GETR",4)) {
1207                 cmd_getr();
1208         }
1209
1210         else if (!strncasecmp(cmdbuf,"SETR",4)) {
1211                 cmd_setr(&cmdbuf[5]);
1212         }
1213
1214         else if (!strncasecmp(cmdbuf,"GETA",4)) {
1215                 cmd_geta();
1216         }
1217
1218         else if (!strncasecmp(cmdbuf,"SETA",4)) {
1219                 cmd_seta(&cmdbuf[5]);
1220         }
1221
1222         else if (!strncasecmp(cmdbuf,"ENT0",4)) {
1223                 cmd_ent0(&cmdbuf[5]);
1224         }
1225
1226         else if (!strncasecmp(cmdbuf,"RINF",4)) {
1227                 cmd_rinf();
1228         }
1229
1230         else if (!strncasecmp(cmdbuf,"DELE",4)) {
1231                 cmd_dele(&cmdbuf[5]);
1232         }
1233
1234         else if (!strncasecmp(cmdbuf,"KILL",4)) {
1235                 cmd_kill(&cmdbuf[5]);
1236         }
1237
1238         else if (!strncasecmp(cmdbuf,"CRE8",4)) {
1239                 cmd_cre8(&cmdbuf[5]);
1240         }
1241
1242         else if (!strncasecmp(cmdbuf,"MOVE",4)) {
1243                 cmd_move(&cmdbuf[5]);
1244         }
1245
1246         else if (!strncasecmp(cmdbuf,"FORG",4)) {
1247                 cmd_forg();
1248         }
1249
1250         else if (!strncasecmp(cmdbuf,"MESG",4)) {
1251                 cmd_mesg(&cmdbuf[5]);
1252         }
1253
1254         else if (!strncasecmp(cmdbuf,"EMSG",4)) {
1255                 cmd_emsg(&cmdbuf[5]);
1256         }
1257
1258         else if (!strncasecmp(cmdbuf,"GNUR",4)) {
1259                 cmd_gnur();
1260         }
1261
1262         else if (!strncasecmp(cmdbuf,"VALI",4)) {
1263                 cmd_vali(&cmdbuf[5]);
1264         }
1265
1266         else if (!strncasecmp(cmdbuf,"EINF",4)) {
1267                 cmd_einf(&cmdbuf[5]);
1268         }
1269
1270         else if (!strncasecmp(cmdbuf,"LIST",4)) {
1271                 cmd_list(&cmdbuf[5]);
1272         }
1273
1274         else if (!strncasecmp(cmdbuf,"CHEK",4)) {
1275                 cmd_chek();
1276         }
1277
1278         else if (!strncasecmp(cmdbuf,"DELF",4)) {
1279                 cmd_delf(&cmdbuf[5]);
1280         }
1281
1282         else if (!strncasecmp(cmdbuf,"MOVF",4)) {
1283                 cmd_movf(&cmdbuf[5]);
1284         }
1285
1286         else if (!strncasecmp(cmdbuf,"NETF",4)) {
1287                 cmd_netf(&cmdbuf[5]);
1288         }
1289
1290         else if (!strncasecmp(cmdbuf,"OPEN",4)) {
1291                 cmd_open(&cmdbuf[5]);
1292         }
1293
1294         else if (!strncasecmp(cmdbuf,"CLOS",4)) {
1295                 cmd_clos();
1296         }
1297
1298         else if (!strncasecmp(cmdbuf,"UOPN",4)) {
1299                 cmd_uopn(&cmdbuf[5]);
1300         }
1301
1302         else if (!strncasecmp(cmdbuf,"UCLS",4)) {
1303                 cmd_ucls(&cmdbuf[5]);
1304         }
1305
1306         else if (!strncasecmp(cmdbuf,"READ",4)) {
1307                 cmd_read(&cmdbuf[5]);
1308         }
1309
1310         else if (!strncasecmp(cmdbuf,"WRIT",4)) {
1311                 cmd_writ(&cmdbuf[5]);
1312         }
1313
1314         else if (!strncasecmp(cmdbuf,"QUSR",4)) {
1315                 cmd_qusr(&cmdbuf[5]);
1316         }
1317
1318         else if (!strncasecmp(cmdbuf,"ECHO",4)) {
1319                 cmd_echo(&cmdbuf[5]);
1320         }
1321
1322         else if (!strncasecmp(cmdbuf,"OIMG",4)) {
1323                 cmd_oimg(&cmdbuf[5]);
1324         }
1325
1326         else if (!strncasecmp(cmdbuf,"MORE",4)) {
1327                 cmd_more();
1328         }
1329
1330         else if (!strncasecmp(cmdbuf,"NDOP",4)) {
1331                 cmd_ndop(&cmdbuf[5]);
1332         }
1333
1334         else if (!strncasecmp(cmdbuf,"NUOP",4)) {
1335                 cmd_nuop(&cmdbuf[5]);
1336         }
1337
1338         else if (!strncasecmp(cmdbuf,"LFLR",4)) {
1339                 cmd_lflr();
1340         }
1341
1342         else if (!strncasecmp(cmdbuf,"CFLR",4)) {
1343                 cmd_cflr(&cmdbuf[5]);
1344         }
1345
1346         else if (!strncasecmp(cmdbuf,"KFLR",4)) {
1347                 cmd_kflr(&cmdbuf[5]);
1348         }
1349
1350         else if (!strncasecmp(cmdbuf,"EFLR",4)) {
1351                 cmd_eflr(&cmdbuf[5]);
1352         }
1353
1354         else if (!strncasecmp(cmdbuf,"IDEN",4)) {
1355                 cmd_iden(&cmdbuf[5]);
1356         }
1357
1358         else if (!strncasecmp(cmdbuf,"IPGM",4)) {
1359                 cmd_ipgm(&cmdbuf[5]);
1360         }
1361
1362         else if (!strncasecmp(cmdbuf,"TERM",4)) {
1363                 cmd_term(&cmdbuf[5]);
1364         }
1365
1366         else if (!strncasecmp(cmdbuf,"DOWN",4)) {
1367                 cmd_down(&cmdbuf[5]);
1368         }
1369
1370         else if (!strncasecmp(cmdbuf,"HALT",4)) {
1371                 cmd_halt();
1372         }
1373
1374         else if (!strncasecmp(cmdbuf,"SCDN",4)) {
1375                 cmd_scdn(&cmdbuf[5]);
1376         }
1377
1378         else if (!strncasecmp(cmdbuf, "UIMG", 4)) {
1379                 cmd_uimg(&cmdbuf[5]);
1380         }
1381
1382         else if (!strncasecmp(cmdbuf, "TIME", 4)) {
1383                 cmd_time();
1384         }
1385
1386         else if (!strncasecmp(cmdbuf, "AGUP", 4)) {
1387                 cmd_agup(&cmdbuf[5]);
1388         }
1389
1390         else if (!strncasecmp(cmdbuf, "ASUP", 4)) {
1391                 cmd_asup(&cmdbuf[5]);
1392         }
1393
1394         else if (!strncasecmp(cmdbuf, "GPEX", 4)) {
1395                 cmd_gpex(&cmdbuf[5]);
1396         }
1397
1398         else if (!strncasecmp(cmdbuf, "SPEX", 4)) {
1399                 cmd_spex(&cmdbuf[5]);
1400         }
1401
1402         else if (!strncasecmp(cmdbuf, "CONF", 4)) {
1403                 cmd_conf(&cmdbuf[5]);
1404         }
1405
1406         else if (!strncasecmp(cmdbuf, "SEEN", 4)) {
1407                 cmd_seen(&cmdbuf[5]);
1408         }
1409
1410         else if (!strncasecmp(cmdbuf, "GTSN", 4)) {
1411                 cmd_gtsn(&cmdbuf[5]);
1412         }
1413
1414         else if (!strncasecmp(cmdbuf, "VIEW", 4)) {
1415                 cmd_view(&cmdbuf[5]);
1416         }
1417
1418         else if (!strncasecmp(cmdbuf, "ISME", 4)) {
1419                 cmd_isme(&cmdbuf[5]);
1420         }
1421
1422         else if (!strncasecmp(cmdbuf, "RENU", 4)) {
1423                 cmd_renu(&cmdbuf[5]);
1424         }
1425
1426         else if (!DLoader_Exec_Cmd(cmdbuf)) {
1427                 cprintf("%d Unrecognized or unsupported command.\n", ERROR + CMD_NOT_SUPPORTED);
1428         }
1429
1430         unbuffer_output();
1431
1432         /* Run any after-each-command routines registered by modules */
1433         PerformSessionHooks(EVT_CMD);
1434         CtdlThreadName(old_name);
1435 }
1436
1437
1438 /*
1439  * This loop performs all asynchronous functions.
1440  */
1441 void do_async_loop(void) {
1442         PerformSessionHooks(EVT_ASYNC);
1443 }