citadel/user_ops.c

   1 /* $Id$ */
   2
   3 #ifndef _SGI_SOURCE
   4 /* needed to properly enable crypt() stuff on some systems */
   5 #define _XOPEN_SOURCE
   6 /* needed for str[n]casecmp() on some systems if the above is defined */
   7 #define _XOPEN_SOURCE_EXTENDED
   8 /* needed to enable threads on some systems if the above are defined */
   9 #define _POSIX_C_SOURCE 199506L
  10 #endif
  11
  12 #include "sysdep.h"
  13 #include <stdlib.h>
  14 #include <unistd.h>
  15 #include <stdio.h>
  16 #include <fcntl.h>
  17 #include <signal.h>
  18 #include <pwd.h>
  19 #include <sys/types.h>
  20 #include <sys/time.h>
  21 #include <string.h>
  22 #include <syslog.h>
  23 #include <limits.h>
  24 #ifdef HAVE_PTHREAD_H
  25 #include <pthread.h>
  26 #endif
  27 #include "citadel.h"
  28 #include "server.h"
  29 #include "database.h"
  30 #include "user_ops.h"
  31 #include "sysdep_decls.h"
  32 #include "support.h"
  33 #include "room_ops.h"
  34 #include "logging.h"
  35 #include "file_ops.h"
  36 #include "control.h"
  37 #include "msgbase.h"
  38 #include "config.h"
  39 #include "dynloader.h"
  40 #include "tools.h"
  41
  42
  43 /*
  44  * getuser()  -  retrieve named user into supplied buffer.
  45  *               returns 0 on success
  46  */
  47 int getuser(struct usersupp *usbuf, char name[]) {
  48
  49         char lowercase_name[32];
  50         int a;
  51         struct cdbdata *cdbus;
  52
  53         memset(usbuf, 0, sizeof(struct usersupp));
  54         for (a=0; a<=strlen(name); ++a) {
  55                 if (a < sizeof(lowercase_name))
  56                         lowercase_name[a] = tolower(name[a]);
  57                 }
  58         lowercase_name[sizeof(lowercase_name)-1] = 0;
  59
  60         cdbus = cdb_fetch(CDB_USERSUPP, lowercase_name, strlen(lowercase_name));
  61         if (cdbus == NULL) {
  62                 return(1);      /* user not found */
  63                 }
  64
  65         memcpy(usbuf, cdbus->ptr,
  66                 ( (cdbus->len > sizeof(struct usersupp)) ?
  67                 sizeof(struct usersupp) : cdbus->len) );
  68         cdb_free(cdbus);
  69         return(0);
  70         }
  71
  72
  73 /*
  74  * lgetuser()  -  same as getuser() but locks the record
  75  */
  76 int lgetuser(struct usersupp *usbuf, char *name)
  77 {
  78         int retcode;
  79
  80         retcode = getuser(usbuf,name);
  81         if (retcode == 0) {
  82                 begin_critical_section(S_USERSUPP);
  83                 }
  84         return(retcode);
  85         }
  86
  87
  88 /*
  89  * putuser()  -  write user buffer into the correct place on disk
  90  */
  91 void putuser(struct usersupp *usbuf, char *name)
  92 {
  93         char lowercase_name[32];
  94         int a;
  95
  96         for (a=0; a<=strlen(name); ++a) {
  97                 if (a < sizeof(lowercase_name))
  98                         lowercase_name[a] = tolower(name[a]);
  99                 }
 100         lowercase_name[sizeof(lowercase_name)-1] = 0;
 101
 102         cdb_store(CDB_USERSUPP,
 103                 lowercase_name, strlen(lowercase_name),
 104                 usbuf, sizeof(struct usersupp));
 105
 106         }
 107
 108
 109 /*
 110  * lputuser()  -  same as putuser() but locks the record
 111  */
 112 void lputuser(struct usersupp *usbuf, char *name) {
 113         putuser(usbuf,name);
 114         end_critical_section(S_USERSUPP);
 115         }
 116
 117 /*
 118  * Index-generating function used by Ctdl[Get|Set]Relationship
 119  */
 120 int GenerateRelationshipIndex(  char *IndexBuf,
 121                                 long RoomID,
 122                                 long RoomGen,
 123                                 long UserID) {
 124
 125         struct {
 126                 long iRoomID;
 127                 long iRoomGen;
 128                 long iUserID;
 129                 } TheIndex;
 130
 131         TheIndex.iRoomID = RoomID;
 132         TheIndex.iRoomGen = RoomGen;
 133         TheIndex.iUserID = UserID;
 134
 135         memcpy(IndexBuf, &TheIndex, sizeof(TheIndex));
 136         return(sizeof(TheIndex));
 137         }
 138
 139 /*
 140  * Define a relationship between a user and a room
 141  */
 142 void CtdlSetRelationship(struct visit *newvisit,
 143                         struct usersupp *rel_user,
 144                         struct quickroom *rel_room) {
 145
 146         char IndexBuf[32];
 147         int IndexLen;
 148
 149         /* We don't use these in Citadel because they're implicit by the
 150          * index, but they must be present if the database is exported.
 151          */
 152         newvisit->v_roomnum = rel_room->QRnumber;
 153         newvisit->v_roomgen = rel_room->QRgen;
 154         newvisit->v_usernum = rel_user->usernum;
 155
 156         /* Generate an index */
 157         IndexLen = GenerateRelationshipIndex(IndexBuf,
 158                 rel_room->QRnumber,
 159                 rel_room->QRgen,
 160                 rel_user->usernum);
 161
 162         /* Store the record */
 163         cdb_store(CDB_VISIT, IndexBuf, IndexLen,
 164                 newvisit, sizeof(struct visit)
 165                 );
 166         }
 167
 168 /*
 169  * Locate a relationship between a user and a room
 170  */
 171 void CtdlGetRelationship(struct visit *vbuf,
 172                         struct usersupp *rel_user,
 173                         struct quickroom *rel_room) {
 174
 175         char IndexBuf[32];
 176         int IndexLen;
 177         struct cdbdata *cdbvisit;
 178
 179         /* Generate an index */
 180         IndexLen = GenerateRelationshipIndex(IndexBuf,
 181                 rel_room->QRnumber,
 182                 rel_room->QRgen,
 183                 rel_user->usernum);
 184
 185         /* Clear out the buffer */
 186         memset(vbuf, 0, sizeof(struct visit));
 187
 188         cdbvisit = cdb_fetch(CDB_VISIT, IndexBuf, IndexLen);
 189         if (cdbvisit != NULL) {
 190                 memcpy(vbuf, cdbvisit->ptr,
 191                         ( (cdbvisit->len > sizeof(struct visit)) ?
 192                         sizeof(struct visit) : cdbvisit->len) );
 193                 cdb_free(cdbvisit);
 194                 return;
 195                 }
 196         }
 197
 198
 199 void MailboxName(char *buf, struct usersupp *who, char *prefix) {
 200         sprintf(buf, "%010ld.%s", who->usernum, prefix);
 201         }
 202
 203
 204 /*
 205  * Is the user currently logged in an Aide?
 206  */
 207 int is_aide(void) {
 208         if (CC->usersupp.axlevel >= 6) return(1);
 209         else return(0);
 210         }
 211
 212
 213 /*
 214  * Is the user currently logged in an Aide *or* the room aide for this room?
 215  */
 216 int is_room_aide(void) {
 217         if ( (CC->usersupp.axlevel >= 6)
 218            || (CC->quickroom.QRroomaide == CC->usersupp.usernum) ) {
 219                 return(1);
 220                 }
 221         else {
 222                 return(0);
 223                 }
 224         }
 225
 226 /*
 227  * getuserbynumber()  -  get user by number
 228  *                       returns 0 if user was found
 229  */
 230 int getuserbynumber(struct usersupp *usbuf, long int number)
 231 {
 232         struct cdbdata *cdbus;
 233
 234         cdb_rewind(CDB_USERSUPP);
 235
 236         while(cdbus = cdb_next_item(CDB_USERSUPP), cdbus != NULL) {
 237                 memset(usbuf, 0, sizeof(struct usersupp));
 238                 memcpy(usbuf, cdbus->ptr,
 239                         ( (cdbus->len > sizeof(struct usersupp)) ?
 240                         sizeof(struct usersupp) : cdbus->len) );
 241                 cdb_free(cdbus);
 242                 if (usbuf->usernum == number) {
 243                         return(0);
 244                         }
 245                 }
 246         return(-1);
 247         }
 248
 249
 250 /*
 251  * USER cmd
 252  */
 253 void cmd_user(char *cmdbuf)
 254 {
 255         char username[256];
 256         char autoname[256];
 257         int found_user = 0;
 258         struct passwd *p;
 259         int a;
 260
 261         extract(username,cmdbuf,0);
 262         username[25] = 0;
 263         strproc(username);
 264
 265         if ((CC->logged_in)) {
 266                 cprintf("%d Already logged in.\n",ERROR);
 267                 return;
 268                 }
 269
 270         found_user = getuser(&CC->usersupp,username);
 271         if (found_user != 0) {
 272                 p = (struct passwd *)getpwnam(username);
 273                 if (p!=NULL) {
 274                         strcpy(autoname,p->pw_gecos);
 275                         for (a=0; a<strlen(autoname); ++a)
 276                                 if (autoname[a]==',') autoname[a]=0;
 277                         found_user = getuser(&CC->usersupp,autoname);
 278                         }
 279                 }
 280         if (found_user == 0) {
 281                 if (((CC->nologin)) && (CC->usersupp.axlevel < 6)) {
 282                         cprintf("%d %s: Too many users are already online (maximum is %d)\n",
 283                         ERROR+MAX_SESSIONS_EXCEEDED,
 284                         config.c_nodename,config.c_maxsessions);
 285                         }
 286                 else {
 287                         strcpy(CC->curr_user,CC->usersupp.fullname);
 288                         cprintf("%d Password required for %s\n",
 289                                 MORE_DATA,CC->curr_user);
 290                         }
 291                 }
 292         else {
 293                 cprintf("%d %s not found.\n",ERROR,username);
 294                 }
 295         }
 296
 297
 298
 299 /*
 300  * session startup code which is common to both cmd_pass() and cmd_newu()
 301  */
 302 void session_startup(void) {
 303         syslog(LOG_NOTICE,"user <%s> logged in",CC->curr_user);
 304
 305         lgetuser(&CC->usersupp,CC->curr_user);
 306         ++(CC->usersupp.timescalled);
 307         CC->fake_username[0] = '\0';
 308         CC->fake_postname[0] = '\0';
 309         CC->fake_hostname[0] = '\0';
 310         CC->fake_roomname[0] = '\0';
 311         time(&CC->usersupp.lastcall);
 312
 313         /* If this user's name is the name of the system administrator
 314          * (as specified in setup), automatically assign access level 6.
 315          */
 316         if (!strcasecmp(CC->usersupp.fullname, config.c_sysadm)) {
 317                 CC->usersupp.axlevel = 6;
 318                 }
 319
 320         lputuser(&CC->usersupp,CC->curr_user);
 321
 322         /* Run any cleanup routines registered by loadable modules */
 323         PerformSessionHooks(EVT_LOGIN);
 324
 325         cprintf("%d %s|%d|%d|%d|%u|%ld\n",OK,CC->usersupp.fullname,CC->usersupp.axlevel,
 326                 CC->usersupp.timescalled,CC->usersupp.posted,CC->usersupp.flags,
 327                 CC->usersupp.usernum);
 328         usergoto(BASEROOM,0);           /* Enter the lobby */
 329         rec_log(CL_LOGIN,CC->curr_user);
 330         }
 331
 332
 333 /*
 334  * misc things to be taken care of when a user is logged out
 335  */
 336 void logout(struct CitContext *who)
 337 {
 338         who->logged_in = 0;
 339         if (who->download_fp != NULL) {
 340                 fclose(who->download_fp);
 341                 who->download_fp = NULL;
 342                 }
 343         if (who->upload_fp != NULL) {
 344                 abort_upl(who);
 345                 }
 346
 347         /* Do modular stuff... */
 348         PerformSessionHooks(EVT_LOGOUT);
 349         }
 350
 351
 352 void cmd_pass(char *buf)
 353 {
 354         char password[256];
 355         int code;
 356         struct passwd *p;
 357
 358         extract(password,buf,0);
 359
 360         if ((CC->logged_in)) {
 361                 cprintf("%d Already logged in.\n",ERROR);
 362                 return;
 363                 }
 364         if (!strcmp(CC->curr_user,"")) {
 365                 cprintf("%d You must send a name with USER first.\n",ERROR);
 366                 return;
 367                 }
 368         if (getuser(&CC->usersupp,CC->curr_user)) {
 369                 cprintf("%d Can't find user record!\n",ERROR+INTERNAL_ERROR);
 370                 return;
 371                 }
 372
 373         code = (-1);
 374         if (CC->usersupp.USuid == BBSUID) {
 375                 strproc(password);
 376                 strproc(CC->usersupp.password);
 377                 code = strcasecmp(CC->usersupp.password,password);
 378                 }
 379         else {
 380                 p = (struct passwd *)getpwuid(CC->usersupp.USuid);
 381 #ifdef ENABLE_AUTOLOGIN
 382                 if (p!=NULL) {
 383                         if (!strcmp(p->pw_passwd,
 384                            (char *)crypt(password,p->pw_passwd))) {
 385                                 code = 0;
 386                                 lgetuser(&CC->usersupp, CC->curr_user);
 387                                 strcpy(CC->usersupp.password, password);
 388                                 lputuser(&CC->usersupp, CC->curr_user);
 389                                 }
 390                         }
 391 #endif
 392                 }
 393
 394         if (!code) {
 395                 (CC->logged_in) = 1;
 396                 session_startup();
 397                 }
 398         else {
 399                 cprintf("%d Wrong password.\n",ERROR);
 400                 rec_log(CL_BADPW,CC->curr_user);
 401                 }
 402         }
 403
 404
 405 /*
 406  * Delete a user record *and* all of its related resources.
 407  */
 408 int purge_user(char pname[]) {
 409         char filename[64];
 410         char mailboxname[ROOMNAMELEN];
 411         struct usersupp usbuf;
 412         struct quickroom qrbuf;
 413         char lowercase_name[32];
 414         int a;
 415         struct CitContext *ccptr;
 416         int user_is_logged_in = 0;
 417
 418         for (a=0; a<=strlen(pname); ++a) {
 419                 lowercase_name[a] = tolower(pname[a]);
 420                 }
 421
 422         if (getuser(&usbuf, pname) != 0) {
 423                 lprintf(5, "Cannot purge user <%s> - not found\n", pname);
 424                 return(ERROR+NO_SUCH_USER);
 425                 }
 426
 427         /* Don't delete a user who is currently logged in.  Instead, just
 428          * set the access level to 0, and let the account get swept up
 429          * during the next purge.
 430          */
 431         user_is_logged_in = 0;
 432         begin_critical_section(S_SESSION_TABLE);
 433         for (ccptr=ContextList; ccptr!=NULL; ccptr=ccptr->next) {
 434                 if (ccptr->usersupp.usernum == usbuf.usernum) {
 435                         user_is_logged_in = 1;
 436                         }
 437                 }
 438         end_critical_section(S_SESSION_TABLE);
 439         if (user_is_logged_in == 1) {
 440                 lprintf(5, "User <%s> is logged in; not deleting.\n", pname);
 441                 usbuf.axlevel = 0;
 442                 putuser(&usbuf, pname);
 443                 return(1);
 444                 }
 445
 446         lprintf(5, "Deleting user <%s>\n", pname);
 447
 448         /* Perform any purge functions registered by server extensions */
 449         PerformUserHooks(usbuf.fullname, usbuf.usernum, EVT_PURGEUSER);
 450
 451         /* delete any existing user/room relationships */
 452         cdb_delete(CDB_VISIT, &usbuf.usernum, sizeof(long));
 453
 454         /* Delete the user's mailbox and its contents */
 455         MailboxName(mailboxname, &usbuf, MAILROOM);
 456         if (getroom(&qrbuf, mailboxname)==0) {
 457                 delete_room(&qrbuf);
 458                 }
 459
 460         /* delete the userlog entry */
 461         cdb_delete(CDB_USERSUPP, lowercase_name, strlen(lowercase_name));
 462
 463         /* remove the user's bio file */
 464         sprintf(filename, "./bio/%ld", usbuf.usernum);
 465         unlink(filename);
 466
 467         /* remove the user's picture */
 468         sprintf(filename, "./userpics/%ld.gif", usbuf.usernum);
 469         unlink(filename);
 470
 471         return(0);
 472         }
 473
 474
 475 /*
 476  * create_user()  -  back end processing to create a new user
 477  */
 478 int create_user(char *newusername)
 479 {
 480         struct usersupp usbuf;
 481         int a;
 482         struct passwd *p = NULL;
 483         char username[64];
 484         char mailboxname[ROOMNAMELEN];
 485
 486         strcpy(username, newusername);
 487         strproc(username);
 488
 489 #ifdef ENABLE_AUTOLOGIN
 490         p = (struct passwd *)getpwnam(username);
 491 #endif
 492         if (p != NULL) {
 493                 strcpy(username, p->pw_gecos);
 494                 for (a=0; a<strlen(username); ++a) {
 495                         if (username[a] == ',') username[a] = 0;
 496                         }
 497                 CC->usersupp.USuid = p->pw_uid;
 498                 }
 499         else {
 500                 CC->usersupp.USuid = BBSUID;
 501                 }
 502
 503         if (!getuser(&usbuf,username)) {
 504                 return(ERROR+ALREADY_EXISTS);
 505                 }
 506
 507         strcpy(CC->curr_user,username);
 508         strcpy(CC->usersupp.fullname,username);
 509         strcpy(CC->usersupp.password,"");
 510         (CC->logged_in) = 1;
 511
 512         /* These are the default flags on new accounts */
 513         CC->usersupp.flags =
 514                 US_NEEDVALID|US_LASTOLD|US_DISAPPEAR|US_PAGINATOR|US_FLOORS;
 515
 516         CC->usersupp.timescalled = 0;
 517         CC->usersupp.posted = 0;
 518         CC->usersupp.axlevel = config.c_initax;
 519         CC->usersupp.USscreenwidth = 80;
 520         CC->usersupp.USscreenheight = 24;
 521         time(&CC->usersupp.lastcall);
 522         strcpy(CC->usersupp.USname, "");
 523         strcpy(CC->usersupp.USaddr, "");
 524         strcpy(CC->usersupp.UScity, "");
 525         strcpy(CC->usersupp.USstate, "");
 526         strcpy(CC->usersupp.USzip, "");
 527         strcpy(CC->usersupp.USphone, "");
 528
 529         /* fetch a new user number */
 530         CC->usersupp.usernum = get_new_user_number();
 531
 532         if (CC->usersupp.usernum == 1L) {
 533                 CC->usersupp.axlevel = 6;
 534                 }
 535
 536         /* add user to userlog */
 537         putuser(&CC->usersupp,CC->curr_user);
 538         if (getuser(&CC->usersupp,CC->curr_user)) {
 539                 return(ERROR+INTERNAL_ERROR);
 540                 }
 541
 542         /* give the user a private mailbox */
 543         MailboxName(mailboxname, &CC->usersupp, MAILROOM);
 544         create_room(mailboxname, 4, "", 0);
 545
 546         rec_log(CL_NEWUSER,CC->curr_user);
 547         return(0);
 548         }
 549
 550
 551
 552
 553 /*
 554  * cmd_newu()  -  create a new user account
 555  */
 556 void cmd_newu(char *cmdbuf)
 557 {
 558         int a;
 559         char username[256];
 560
 561         if ((CC->logged_in)) {
 562                 cprintf("%d Already logged in.\n",ERROR);
 563                 return;
 564                 }
 565
 566         if ((CC->nologin)) {
 567                 cprintf("%d %s: Too many users are already online (maximum is %d)\n",
 568                 ERROR+MAX_SESSIONS_EXCEEDED,
 569                 config.c_nodename,config.c_maxsessions);
 570                 }
 571
 572         extract(username,cmdbuf,0);
 573         username[25] = 0;
 574         strproc(username);
 575
 576         if (strlen(username)==0) {
 577                 cprintf("%d You must supply a user name.\n",ERROR);
 578                 return;
 579                 }
 580
 581         a = create_user(username);
 582         if ((!strcasecmp(username, "bbs")) ||
 583             (!strcasecmp(username, "new")) ||
 584             (!strcasecmp(username, ".")))
 585         {
 586            cprintf("%d '%s' is an invalid login name.\n", ERROR);
 587            return;
 588         }
 589         if (a==ERROR+ALREADY_EXISTS) {
 590                 cprintf("%d '%s' already exists.\n",
 591                         ERROR+ALREADY_EXISTS,username);
 592                 return;
 593                 }
 594         else if (a==ERROR+INTERNAL_ERROR) {
 595                 cprintf("%d Internal error - user record disappeared?\n",
 596                         ERROR+INTERNAL_ERROR);
 597                 return;
 598                 }
 599         else if (a==0) {
 600                 session_startup();
 601                 }
 602         else {
 603                 cprintf("%d unknown error\n",ERROR);
 604                 }
 605         rec_log(CL_NEWUSER,CC->curr_user);
 606         }
 607
 608
 609
 610 /*
 611  * set password
 612  */
 613 void cmd_setp(char *new_pw)
 614 {
 615         if (!(CC->logged_in)) {
 616                 cprintf("%d Not logged in.\n",ERROR+NOT_LOGGED_IN);
 617                 return;
 618                 }
 619         if (CC->usersupp.USuid != BBSUID) {
 620                 cprintf("%d Not allowed.  Use the 'passwd' command.\n",ERROR);
 621                 return;
 622                 }
 623         strproc(new_pw);
 624         if (strlen(new_pw)==0) {
 625                 cprintf("%d Password unchanged.\n",OK);
 626                 return;
 627                 }
 628         lgetuser(&CC->usersupp,CC->curr_user);
 629         strcpy(CC->usersupp.password,new_pw);
 630         lputuser(&CC->usersupp,CC->curr_user);
 631         cprintf("%d Password changed.\n",OK);
 632         rec_log(CL_PWCHANGE,CC->curr_user);
 633         PerformSessionHooks(EVT_SETPASS);
 634         }
 635
 636 /*
 637  * get user parameters
 638  */
 639 void cmd_getu(void) {
 640         if (!(CC->logged_in)) {
 641                 cprintf("%d Not logged in.\n",ERROR+NOT_LOGGED_IN);
 642                 return;
 643                 }
 644         getuser(&CC->usersupp,CC->curr_user);
 645         cprintf("%d %d|%d|%d\n",
 646                 OK,
 647                 CC->usersupp.USscreenwidth,
 648                 CC->usersupp.USscreenheight,
 649                 (CC->usersupp.flags & US_USER_SET)
 650                 );
 651         }
 652
 653 /*
 654  * set user parameters
 655  */
 656 void cmd_setu(char *new_parms)
 657 {
 658
 659         if (num_parms(new_parms)!=3) {
 660                 cprintf("%d Usage error.\n",ERROR);
 661                 return;
 662                 }
 663         if (!(CC->logged_in)) {
 664                 cprintf("%d Not logged in.\n",ERROR+NOT_LOGGED_IN);
 665                 return;
 666                 }
 667         lgetuser(&CC->usersupp,CC->curr_user);
 668         CC->usersupp.USscreenwidth = extract_int(new_parms,0);
 669         CC->usersupp.USscreenheight = extract_int(new_parms,1);
 670         CC->usersupp.flags = CC->usersupp.flags & (~US_USER_SET);
 671         CC->usersupp.flags = CC->usersupp.flags |
 672                 (extract_int(new_parms,2) & US_USER_SET);
 673         lputuser(&CC->usersupp,CC->curr_user);
 674         cprintf("%d Ok\n",OK);
 675         }
 676
 677 /*
 678  * set last read pointer
 679  */
 680 void cmd_slrp(char *new_ptr)
 681 {
 682         long newlr;
 683         struct visit vbuf;
 684
 685         if (!(CC->logged_in)) {
 686                 cprintf("%d Not logged in.\n",ERROR+NOT_LOGGED_IN);
 687                 return;
 688                 }
 689
 690         if (!strncasecmp(new_ptr,"highest",7)) {
 691                 newlr = CC->quickroom.QRhighest;
 692                 }
 693         else {
 694                 newlr = atol(new_ptr);
 695                 }
 696
 697         lgetuser(&CC->usersupp, CC->curr_user);
 698
 699         CtdlGetRelationship(&vbuf, &CC->usersupp, &CC->quickroom);
 700         vbuf.v_lastseen = newlr;
 701         CtdlSetRelationship(&vbuf, &CC->usersupp, &CC->quickroom);
 702
 703         lputuser(&CC->usersupp, CC->curr_user);
 704         cprintf("%d %ld\n",OK,newlr);
 705         }
 706
 707
 708 /*
 709  * INVT and KICK commands
 710  */
 711 void cmd_invt_kick(char *iuser, int op)
 712                         /* user name */
 713         {               /* 1 = invite, 0 = kick out */
 714         struct usersupp USscratch;
 715         char bbb[256];
 716         struct visit vbuf;
 717
 718         if (!(CC->logged_in)) {
 719                 cprintf("%d Not logged in.\n",ERROR+NOT_LOGGED_IN);
 720                 return;
 721                 }
 722
 723         if (is_room_aide()==0) {
 724                 cprintf("%d Higher access required.\n",
 725                         ERROR+HIGHER_ACCESS_REQUIRED);
 726                 return;
 727                 }
 728
 729         if (lgetuser(&USscratch,iuser)!=0) {
 730                 cprintf("%d No such user.\n",ERROR);
 731                 return;
 732                 }
 733
 734         CtdlGetRelationship(&vbuf, &USscratch, &CC->quickroom);
 735
 736         if (op==1) {
 737                 vbuf.v_flags = vbuf.v_flags & ~V_FORGET & ~V_LOCKOUT;
 738                 vbuf.v_flags = vbuf.v_flags | V_ACCESS;
 739                 }
 740
 741         if (op==0) {
 742                 vbuf.v_flags = vbuf.v_flags & ~V_ACCESS;
 743                 vbuf.v_flags = vbuf.v_flags | V_FORGET | V_LOCKOUT;
 744                 }
 745
 746         CtdlSetRelationship(&vbuf, &USscratch, &CC->quickroom);
 747
 748         lputuser(&USscratch,iuser);
 749
 750         /* post a message in Aide> saying what we just did */
 751         sprintf(bbb,"%s %s %s> by %s",
 752                 iuser,
 753                 ((op == 1) ? "invited to" : "kicked out of"),
 754                 CC->quickroom.QRname,
 755                 CC->usersupp.fullname);
 756         aide_message(bbb);
 757
 758         cprintf("%d %s %s %s.\n",
 759                 OK, iuser,
 760                 ((op == 1) ? "invited to" : "kicked out of"),
 761                 CC->quickroom.QRname);
 762         return;
 763         }
 764
 765
 766 /*
 767  * forget (Zap) the current room
 768  */
 769 void cmd_forg(void) {
 770         struct visit vbuf;
 771
 772         if (!(CC->logged_in)) {
 773                 cprintf("%d Not logged in.\n",ERROR+NOT_LOGGED_IN);
 774                 return;
 775                 }
 776
 777         if (is_aide()) {
 778                 cprintf("%d Aides cannot forget rooms.\n",ERROR);
 779                 return;
 780                 }
 781
 782         lgetuser(&CC->usersupp,CC->curr_user);
 783         CtdlGetRelationship(&vbuf, &CC->usersupp, &CC->quickroom);
 784
 785         vbuf.v_flags = vbuf.v_flags | V_FORGET;
 786         vbuf.v_flags = vbuf.v_flags & ~V_ACCESS;
 787
 788         CtdlSetRelationship(&vbuf, &CC->usersupp, &CC->quickroom);
 789         lputuser(&CC->usersupp,CC->curr_user);
 790         cprintf("%d Ok\n",OK);
 791         usergoto(BASEROOM, 0);
 792         }
 793
 794 /*
 795  * Get Next Unregistered User
 796  */
 797 void cmd_gnur(void) {
 798         struct cdbdata *cdbus;
 799         struct usersupp usbuf;
 800
 801         if (!(CC->logged_in)) {
 802                 cprintf("%d Not logged in.\n",ERROR+NOT_LOGGED_IN);
 803                 return;
 804                 }
 805
 806         if (CC->usersupp.axlevel < 6) {
 807                 cprintf("%d Higher access required.\n",
 808                         ERROR+HIGHER_ACCESS_REQUIRED);
 809                 return;
 810                 }
 811
 812         if ((CitControl.MMflags&MM_VALID)==0) {
 813                 cprintf("%d There are no unvalidated users.\n",OK);
 814                 return;
 815                 }
 816
 817         /* There are unvalidated users.  Traverse the usersupp database,
 818          * and return the first user we find that needs validation.
 819          */
 820         cdb_rewind(CDB_USERSUPP);
 821         while (cdbus = cdb_next_item(CDB_USERSUPP), cdbus != NULL) {
 822                 memset(&usbuf, 0, sizeof(struct usersupp));
 823                 memcpy(&usbuf, cdbus->ptr,
 824                         ( (cdbus->len > sizeof(struct usersupp)) ?
 825                         sizeof(struct usersupp) : cdbus->len) );
 826                 cdb_free(cdbus);
 827                 if ((usbuf.flags & US_NEEDVALID)
 828                    &&(usbuf.axlevel > 0)) {
 829                         cprintf("%d %s\n",MORE_DATA,usbuf.fullname);
 830                         return;
 831                         }
 832                 }
 833
 834         /* If we get to this point, there are no more unvalidated users.
 835          * Therefore we clear the "users need validation" flag.
 836          */
 837
 838         begin_critical_section(S_CONTROL);
 839         get_control();
 840         CitControl.MMflags = CitControl.MMflags&(~MM_VALID);
 841         put_control();
 842         end_critical_section(S_CONTROL);
 843         cprintf("%d *** End of registration.\n",OK);
 844
 845
 846         }
 847
 848
 849 /*
 850  * get registration info for a user
 851  */
 852 void cmd_greg(char *who)
 853 {
 854         struct usersupp usbuf;
 855         int a,b;
 856         char pbuf[32];
 857
 858         if (!(CC->logged_in)) {
 859                 cprintf("%d Not logged in.\n",ERROR+NOT_LOGGED_IN);
 860                 return;
 861                 }
 862
 863         if (!strcasecmp(who,"_SELF_")) strcpy(who,CC->curr_user);
 864
 865         if ((CC->usersupp.axlevel < 6) && (strcasecmp(who,CC->curr_user))) {
 866                 cprintf("%d Higher access required.\n",
 867                         ERROR+HIGHER_ACCESS_REQUIRED);
 868                 return;
 869                 }
 870
 871         if (getuser(&usbuf,who) != 0) {
 872                 cprintf("%d '%s' not found.\n",ERROR+NO_SUCH_USER,who);
 873                 return;
 874                 }
 875
 876         cprintf("%d %s\n",LISTING_FOLLOWS,usbuf.fullname);
 877         cprintf("%ld\n",usbuf.usernum);
 878         cprintf("%s\n",usbuf.password);
 879         cprintf("%s\n",usbuf.USname);
 880         cprintf("%s\n",usbuf.USaddr);
 881         cprintf("%s\n%s\n%s\n",
 882                 usbuf.UScity,usbuf.USstate,usbuf.USzip);
 883         strcpy(pbuf,usbuf.USphone);
 884         usbuf.USphone[0]=0;
 885         for (a=0; a<strlen(pbuf); ++a) {
 886                 if ((pbuf[a]>='0')&&(pbuf[a]<='9')) {
 887                         b=strlen(usbuf.USphone);
 888                         usbuf.USphone[b]=pbuf[a];
 889                         usbuf.USphone[b+1]=0;
 890                         }
 891                 }
 892         while(strlen(usbuf.USphone)<10) {
 893                 strcpy(pbuf,usbuf.USphone);
 894                 strcpy(usbuf.USphone," ");
 895                 strcat(usbuf.USphone,pbuf);
 896                 }
 897
 898         cprintf("(%c%c%c) %c%c%c-%c%c%c%c\n",
 899                 usbuf.USphone[0],usbuf.USphone[1],
 900                 usbuf.USphone[2],usbuf.USphone[3],
 901                 usbuf.USphone[4],usbuf.USphone[5],
 902                 usbuf.USphone[6],usbuf.USphone[7],
 903                 usbuf.USphone[8],usbuf.USphone[9]);
 904
 905         cprintf("%d\n",usbuf.axlevel);
 906         cprintf("%s\n",usbuf.USemail);
 907         cprintf("000\n");
 908         }
 909
 910 /*
 911  * validate a user
 912  */
 913 void cmd_vali(char *v_args)
 914 {
 915         char user[256];
 916         int newax;
 917         struct usersupp userbuf;
 918
 919         extract(user,v_args,0);
 920         newax = extract_int(v_args,1);
 921
 922         if (!(CC->logged_in)) {
 923                 cprintf("%d Not logged in.\n",ERROR+NOT_LOGGED_IN);
 924                 return;
 925                 }
 926
 927         if (CC->usersupp.axlevel < 6) {
 928                 cprintf("%d Higher access required.\n",
 929                         ERROR+HIGHER_ACCESS_REQUIRED);
 930                 return;
 931                 }
 932
 933         if (lgetuser(&userbuf,user)!=0) {
 934                 cprintf("%d '%s' not found.\n",ERROR+NO_SUCH_USER,user);
 935                 return;
 936                 }
 937
 938         userbuf.axlevel = newax;
 939         userbuf.flags = (userbuf.flags & ~US_NEEDVALID);
 940
 941         lputuser(&userbuf,user);
 942
 943         /* If the access level was set to zero, delete the user */
 944         if (newax == 0) {
 945                 if (purge_user(user)==0) {
 946                         cprintf("%d %s Deleted.\n", OK, userbuf.fullname);
 947                         return;
 948                         }
 949                 }
 950
 951         cprintf("%d ok\n",OK);
 952         }
 953
 954
 955
 956 /*
 957  *  Traverse the user file...
 958  */
 959 void ForEachUser(void (*CallBack)(struct usersupp *EachUser)) {
 960         struct usersupp usbuf;
 961         struct cdbdata *cdbus;
 962
 963         cdb_rewind(CDB_USERSUPP);
 964
 965         while(cdbus = cdb_next_item(CDB_USERSUPP), cdbus != NULL) {
 966                 memset(&usbuf, 0, sizeof(struct usersupp));
 967                 memcpy(&usbuf, cdbus->ptr,
 968                         ( (cdbus->len > sizeof(struct usersupp)) ?
 969                         sizeof(struct usersupp) : cdbus->len) );
 970                 cdb_free(cdbus);
 971                 (*CallBack)(&usbuf);
 972                 }
 973         }
 974
 975
 976 /*
 977  * List one user (this works with cmd_list)
 978  */
 979 void ListThisUser(struct usersupp *usbuf) {
 980         if (usbuf->axlevel > 0) {
 981                 if ((CC->usersupp.axlevel>=6)
 982                    ||((usbuf->flags&US_UNLISTED)==0)
 983                    ||((CC->internal_pgm))) {
 984                         cprintf("%s|%d|%ld|%ld|%d|%d|",
 985                                 usbuf->fullname,
 986                                 usbuf->axlevel,
 987                                 usbuf->usernum,
 988                                 usbuf->lastcall,
 989                                 usbuf->timescalled,
 990                                 usbuf->posted);
 991                         if (CC->usersupp.axlevel >= 6)
 992                                 cprintf("%s",usbuf->password);
 993                         cprintf("\n");
 994                         }
 995                 }
 996         }
 997
 998 /*
 999  *  List users
1000  */
1001 void cmd_list(void) {
1002         cprintf("%d \n",LISTING_FOLLOWS);
1003         ForEachUser(ListThisUser);
1004         cprintf("000\n");
1005         }
1006
1007
1008 /*
1009  * enter registration info
1010  */
1011 void cmd_regi(void) {
1012         int a,b,c;
1013         char buf[256];
1014
1015         char tmpname[256];
1016         char tmpaddr[256];
1017         char tmpcity[256];
1018         char tmpstate[256];
1019         char tmpzip[256];
1020         char tmpphone[256];
1021         char tmpemail[256];
1022
1023         if (!(CC->logged_in)) {
1024                 cprintf("%d Not logged in.\n",ERROR+NOT_LOGGED_IN);
1025                 return;
1026                 }
1027
1028         strcpy(tmpname,"");
1029         strcpy(tmpaddr,"");
1030         strcpy(tmpcity,"");
1031         strcpy(tmpstate,"");
1032         strcpy(tmpzip,"");
1033         strcpy(tmpphone,"");
1034         strcpy(tmpemail,"");
1035
1036         cprintf("%d Send registration...\n",SEND_LISTING);
1037         a=0;
1038         while (client_gets(buf), strcmp(buf,"000")) {
1039                 if (a==0) strcpy(tmpname,buf);
1040                 if (a==1) strcpy(tmpaddr,buf);
1041                 if (a==2) strcpy(tmpcity,buf);
1042                 if (a==3) strcpy(tmpstate,buf);
1043                 if (a==4) {
1044                         for (c=0; c<strlen(buf); ++c) {
1045                                 if ((buf[c]>='0')&&(buf[c]<='9')) {
1046                                         b=strlen(tmpzip);
1047                                         tmpzip[b]=buf[c];
1048                                         tmpzip[b+1]=0;
1049                                         }
1050                                 }
1051                         }
1052                 if (a==5) {
1053                         for (c=0; c<strlen(buf); ++c) {
1054                                 if ((buf[c]>='0')&&(buf[c]<='9')) {
1055                                         b=strlen(tmpphone);
1056                                         tmpphone[b]=buf[c];
1057                                         tmpphone[b+1]=0;
1058                                         }
1059                                 }
1060                         }
1061                 if (a==6) strncpy(tmpemail,buf,31);
1062                 ++a;
1063                 }
1064
1065         tmpname[29]=0;
1066         tmpaddr[24]=0;
1067         tmpcity[14]=0;
1068         tmpstate[2]=0;
1069         tmpzip[9]=0;
1070         tmpphone[10]=0;
1071         tmpemail[31]=0;
1072
1073         lgetuser(&CC->usersupp,CC->curr_user);
1074         strcpy(CC->usersupp.USname,tmpname);
1075         strcpy(CC->usersupp.USaddr,tmpaddr);
1076         strcpy(CC->usersupp.UScity,tmpcity);
1077         strcpy(CC->usersupp.USstate,tmpstate);
1078         strcpy(CC->usersupp.USzip,tmpzip);
1079         strcpy(CC->usersupp.USphone,tmpphone);
1080         strcpy(CC->usersupp.USemail,tmpemail);
1081         CC->usersupp.flags=(CC->usersupp.flags|US_REGIS|US_NEEDVALID);
1082         lputuser(&CC->usersupp,CC->curr_user);
1083
1084         /* set global flag calling for validation */
1085         begin_critical_section(S_CONTROL);
1086         get_control();
1087         CitControl.MMflags = CitControl.MMflags | MM_VALID ;
1088         put_control();
1089         end_critical_section(S_CONTROL);
1090         }
1091
1092
1093 /*
1094  * assorted info we need to check at login
1095  */
1096 void cmd_chek(void) {
1097         int mail = 0;
1098         int regis = 0;
1099         int vali = 0;
1100
1101         if (!(CC->logged_in)) {
1102                 cprintf("%d Not logged in.\n",ERROR+NOT_LOGGED_IN);
1103                 return;
1104                 }
1105
1106         getuser(&CC->usersupp,CC->curr_user); /* no lock is needed here */
1107         if ((REGISCALL!=0)&&((CC->usersupp.flags&US_REGIS)==0)) regis = 1;
1108
1109         if (CC->usersupp.axlevel >= 6) {
1110                 get_control();
1111                 if (CitControl.MMflags&MM_VALID) vali = 1;
1112                 }
1113
1114
1115         /* check for mail */
1116         mail = NewMailCount();
1117
1118         cprintf("%d %d|%d|%d\n",OK,mail,regis,vali);
1119         }
1120
1121
1122 /*
1123  * check to see if a user exists
1124  */
1125 void cmd_qusr(char *who)
1126 {
1127         struct usersupp usbuf;
1128
1129         if (getuser(&usbuf,who) == 0) {
1130                 cprintf("%d %s\n",OK,usbuf.fullname);
1131                 }
1132         else {
1133                 cprintf("%d No such user.\n",ERROR+NO_SUCH_USER);
1134                 }
1135         }
1136
1137
1138 /*
1139  * enter user bio
1140  */
1141 void cmd_ebio(void) {
1142         char buf[256];
1143         FILE *fp;
1144
1145         if (!(CC->logged_in)) {
1146                 cprintf("%d Not logged in.\n",ERROR+NOT_LOGGED_IN);
1147                 return;
1148                 }
1149
1150         sprintf(buf,"./bio/%ld",CC->usersupp.usernum);
1151         fp = fopen(buf,"w");
1152         if (fp == NULL) {
1153                 cprintf("%d Cannot create file\n",ERROR);
1154                 return;
1155                 }
1156         cprintf("%d  \n",SEND_LISTING);
1157         while(client_gets(buf), strcmp(buf,"000")) {
1158                 fprintf(fp,"%s\n",buf);
1159                 }
1160         fclose(fp);
1161         }
1162
1163 /*
1164  * read user bio
1165  */
1166 void cmd_rbio(char *cmdbuf)
1167 {
1168         struct usersupp ruser;
1169         char buf[256];
1170         FILE *fp;
1171
1172         extract(buf,cmdbuf,0);
1173         if (getuser(&ruser,buf)!=0) {
1174                 cprintf("%d No such user.\n",ERROR+NO_SUCH_USER);
1175                 return;
1176                 }
1177         sprintf(buf,"./bio/%ld",ruser.usernum);
1178
1179         fp = fopen(buf,"r");
1180         if (fp == NULL) {
1181                 cprintf("%d %s has no bio on file.\n",
1182                         ERROR+FILE_NOT_FOUND,ruser.fullname);
1183                 return;
1184                 }
1185         cprintf("%d  \n",LISTING_FOLLOWS);
1186         while (fgets(buf,256,fp)!=NULL) cprintf("%s",buf);
1187         fclose(fp);
1188         cprintf("000\n");
1189         }
1190
1191 /*
1192  * list of users who have entered bios
1193  */
1194 void cmd_lbio(void) {
1195         char buf[256];
1196         FILE *ls;
1197         struct usersupp usbuf;
1198
1199         ls=popen("cd ./bio; ls","r");
1200         if (ls==NULL) {
1201                 cprintf("%d Cannot open listing.\n",ERROR+FILE_NOT_FOUND);
1202                 return;
1203                 }
1204
1205         cprintf("%d\n",LISTING_FOLLOWS);
1206         while (fgets(buf,255,ls)!=NULL)
1207                 if (getuserbynumber(&usbuf,atol(buf))==0)
1208                         cprintf("%s\n",usbuf.fullname);
1209         pclose(ls);
1210         cprintf("000\n");
1211         }
1212
1213
1214 /*
1215  * Administrative Get User Parameters
1216  */
1217 void cmd_agup(char *cmdbuf) {
1218         struct usersupp usbuf;
1219         char requested_user[256];
1220
1221         if ( (CC->internal_pgm==0)
1222            && ( (CC->logged_in == 0) || (is_aide()==0) ) ) {
1223                 cprintf("%d Higher access required.\n",
1224                         ERROR + HIGHER_ACCESS_REQUIRED);
1225                 return;
1226                 }
1227
1228         extract(requested_user, cmdbuf, 0);
1229         if (getuser(&usbuf, requested_user) != 0) {
1230                 cprintf("%d No such user.\n", ERROR + NO_SUCH_USER);
1231                 return;
1232                 }
1233
1234         cprintf("%d %s|%s|%u|%d|%d|%d|%ld|%ld|%d\n",
1235                 OK,
1236                 usbuf.fullname,
1237                 usbuf.password,
1238                 usbuf.flags,
1239                 usbuf.timescalled,
1240                 usbuf.posted,
1241                 (int)usbuf.axlevel,
1242                 usbuf.usernum,
1243                 usbuf.lastcall,
1244                 usbuf.USuserpurge);
1245         }
1246
1247
1248
1249 /*
1250  * Administrative Set User Parameters
1251  */
1252 void cmd_asup(char *cmdbuf) {
1253         struct usersupp usbuf;
1254         char requested_user[256];
1255         int np;
1256         int newax;
1257
1258         if ( (CC->internal_pgm==0)
1259            && ( (CC->logged_in == 0) || (is_aide()==0) ) ) {
1260                 cprintf("%d Higher access required.\n",
1261                         ERROR + HIGHER_ACCESS_REQUIRED);
1262                 return;
1263                 }
1264
1265         extract(requested_user, cmdbuf, 0);
1266         if (lgetuser(&usbuf, requested_user) != 0) {
1267                 cprintf("%d No such user.\n", ERROR + NO_SUCH_USER);
1268                 return;
1269                 }
1270
1271         np = num_parms(cmdbuf);
1272         if (np > 1) extract(usbuf.password, cmdbuf, 1);
1273         if (np > 2) usbuf.flags = extract_int(cmdbuf, 2);
1274         if (np > 3) usbuf.timescalled = extract_int(cmdbuf, 3);
1275         if (np > 4) usbuf.posted = extract_int(cmdbuf, 4);
1276         if (np > 5) {
1277                 newax = extract_int(cmdbuf, 5);
1278                 if ((newax >=0) && (newax <= 6)) {
1279                         usbuf.axlevel = extract_int(cmdbuf, 5);
1280                         }
1281                 }
1282         if (np > 7) {
1283                 usbuf.lastcall = extract_long(cmdbuf, 7);
1284                 }
1285         if (np > 8) {
1286                 usbuf.USuserpurge = extract_int(cmdbuf, 8);
1287                 }
1288
1289         lputuser(&usbuf, requested_user);
1290         if (usbuf.axlevel == 0) {
1291                 if (purge_user(requested_user)==0) {
1292                         cprintf("%d %s deleted.\n", OK, requested_user);
1293                         }
1294                 }
1295         cprintf("%d Ok\n", OK);
1296         }
1297
1298
1299 /*
1300  * Count the number of new mail messages the user has
1301  */
1302 int NewMailCount() {
1303         int num_newmsgs = 0;
1304         int a;
1305         char mailboxname[32];
1306         struct quickroom mailbox;
1307         struct visit vbuf;
1308
1309         MailboxName(mailboxname, &CC->usersupp, MAILROOM);
1310         if (getroom(&mailbox, mailboxname)!=0) return(0);
1311         CtdlGetRelationship(&vbuf, &CC->usersupp, &mailbox);
1312
1313         get_msglist(&mailbox);
1314         for (a=0; a<CC->num_msgs; ++a) {
1315                 if (MessageFromList(a)>0L) {
1316                         if (MessageFromList(a) > vbuf.v_lastseen) {
1317                                 ++num_newmsgs;
1318                                 }
1319                         }
1320                 }
1321
1322         return(num_newmsgs);
1323         }