webcit/useredit.c

   1
   2 #include "webcit.h"
   3 #include "webserver.h"
   4
   5
   6 /*
   7  *  show a list of available users to edit them
   8  *  message the header message???
   9  *  preselect = which user should be selected in the browser
  10  */
  11 void select_user_to_edit(const char *preselect)
  12 {
  13         output_headers(1, 0, 0, 0, 1, 0);
  14         do_template("aide_edituser_select", NULL);
  15         end_burst();
  16 }
  17
  18
  19 typedef struct _UserListEntry {
  20         int UID;
  21         int AccessLevel;
  22         int nLogons;
  23         int nPosts;
  24
  25         StrBuf *UserName;
  26         StrBuf *Passvoid;
  27         time_t LastLogonT;
  28         /* Just available for Single users to view: */
  29         unsigned int Flags;
  30         int DaysTillPurge;
  31 } UserListEntry;
  32
  33
  34 UserListEntry* NewUserListOneEntry(StrBuf *SerializedUser, const char *Pos)
  35 {
  36         UserListEntry *ul;
  37
  38         if (StrLength(SerializedUser) < 8)
  39                 return NULL;
  40
  41         ul = (UserListEntry*) malloc(sizeof(UserListEntry));
  42         ul->UserName = NewStrBuf();
  43         ul->Passvoid = NewStrBuf();
  44
  45         StrBufExtract_NextToken(ul->UserName,               SerializedUser, &Pos, '|');
  46         StrBufExtract_NextToken(ul->Passvoid,               SerializedUser, &Pos, '|');
  47         ul->Flags         = StrBufExtractNext_unsigned_long(SerializedUser, &Pos, '|');
  48         ul->nLogons       = StrBufExtractNext_int(          SerializedUser, &Pos, '|');
  49         ul->nPosts        = StrBufExtractNext_int(          SerializedUser, &Pos, '|');
  50         ul->AccessLevel   = StrBufExtractNext_int(          SerializedUser, &Pos, '|');
  51         ul->UID           = StrBufExtractNext_int(          SerializedUser, &Pos, '|');
  52         ul->LastLogonT    = StrBufExtractNext_long(         SerializedUser, &Pos, '|');
  53         ul->DaysTillPurge = StrBufExtractNext_int(          SerializedUser, &Pos, '|');
  54         return ul;
  55 }
  56
  57 void DeleteUserListEntry(void *vUserList)
  58 {
  59         UserListEntry *ul = (UserListEntry*) vUserList;
  60         if (!ul) return;
  61         FreeStrBuf(&ul->UserName);
  62         FreeStrBuf(&ul->Passvoid);
  63         free(ul);
  64 }
  65
  66 UserListEntry* NewUserListEntry(StrBuf *SerializedUserList)
  67 {
  68         const char *Pos = NULL;
  69         UserListEntry *ul;
  70
  71         if (StrLength(SerializedUserList) < 8)
  72                 return NULL;
  73
  74         ul = (UserListEntry*) malloc(sizeof(UserListEntry));
  75         ul->UserName = NewStrBuf();
  76         ul->Passvoid = NewStrBuf();
  77
  78         StrBufExtract_NextToken(ul->UserName,    SerializedUserList, &Pos, '|');
  79         ul->AccessLevel = StrBufExtractNext_int( SerializedUserList, &Pos, '|');
  80         ul->UID         = StrBufExtractNext_int( SerializedUserList, &Pos, '|');
  81         ul->LastLogonT  = StrBufExtractNext_long(SerializedUserList, &Pos, '|');
  82         ul->nLogons     = StrBufExtractNext_int( SerializedUserList, &Pos, '|');
  83         ul->nPosts      = StrBufExtractNext_int( SerializedUserList, &Pos, '|');
  84         StrBufExtract_NextToken(ul->Passvoid,    SerializedUserList, &Pos, '|');
  85         ul->Flags = 0;
  86         ul->DaysTillPurge = -1;
  87         return ul;
  88 }
  89
  90 /*
  91  * Sort by Username
  92  */
  93 int CompareUserListName(const void *vUser1, const void *vUser2)
  94 {
  95         UserListEntry *u1 = (UserListEntry*) GetSearchPayload(vUser1);
  96         UserListEntry *u2 = (UserListEntry*) GetSearchPayload(vUser2);
  97
  98         return strcmp(ChrPtr(u1->UserName), ChrPtr(u2->UserName));
  99 }
 100
 101 int CompareUserListNameRev(const void *vUser1, const void *vUser2)
 102 {
 103         UserListEntry *u1 = (UserListEntry*) GetSearchPayload(vUser1);
 104         UserListEntry *u2 = (UserListEntry*) GetSearchPayload(vUser2);
 105         return strcmp(ChrPtr(u2->UserName), ChrPtr(u1->UserName));
 106 }
 107
 108 int GroupchangeUserListName(const void *vUser1, const void *vUser2)
 109 {
 110         UserListEntry *u1 = (UserListEntry*) vUser1;
 111         UserListEntry *u2 = (UserListEntry*) vUser2;
 112         return ChrPtr(u2->UserName)[0] != ChrPtr(u1->UserName)[0];
 113 }
 114
 115 /*
 116  * Sort by access level
 117  */
 118 int CompareAccessLevel(const void *vUser1, const void *vUser2)
 119 {
 120         UserListEntry *u1 = (UserListEntry*) GetSearchPayload(vUser1);
 121         UserListEntry *u2 = (UserListEntry*) GetSearchPayload(vUser2);
 122
 123         return (u1->AccessLevel > u2->AccessLevel);
 124 }
 125
 126 int CompareAccessLevelRev(const void *vUser1, const void *vUser2)
 127 {
 128         UserListEntry *u1 = (UserListEntry*) GetSearchPayload(vUser1);
 129         UserListEntry *u2 = (UserListEntry*) GetSearchPayload(vUser2);
 130
 131         return (u2->AccessLevel > u1->AccessLevel);
 132 }
 133
 134 int GroupchangeAccessLevel(const void *vUser1, const void *vUser2)
 135 {
 136         UserListEntry *u1 = (UserListEntry*) vUser1;
 137         UserListEntry *u2 = (UserListEntry*) vUser2;
 138
 139         return u2->AccessLevel != u1->AccessLevel;
 140 }
 141
 142 /*
 143  * Sort by UID
 144  */
 145 int CompareUID(const void *vUser1, const void *vUser2)
 146 {
 147         UserListEntry *u1 = (UserListEntry*) GetSearchPayload(vUser1);
 148         UserListEntry *u2 = (UserListEntry*) GetSearchPayload(vUser2);
 149
 150         return (u1->UID > u2->UID);
 151 }
 152
 153 int CompareUIDRev(const void *vUser1, const void *vUser2)
 154 {
 155         UserListEntry *u1 = (UserListEntry*) GetSearchPayload(vUser1);
 156         UserListEntry *u2 = (UserListEntry*) GetSearchPayload(vUser2);
 157
 158         return (u2->UID > u1->UID);
 159 }
 160
 161 int GroupchangeUID(const void *vUser1, const void *vUser2)
 162 {
 163         UserListEntry *u1 = (UserListEntry*) vUser1;
 164         UserListEntry *u2 = (UserListEntry*) vUser2;
 165
 166         return (u2->UID / 10) != (u1->UID / 10);
 167 }
 168
 169 /*
 170  * Sort By Date /// TODO!
 171  */
 172 int CompareLastLogon(const void *vUser1, const void *vUser2)
 173 {
 174         UserListEntry *u1 = (UserListEntry*) GetSearchPayload(vUser1);
 175         UserListEntry *u2 = (UserListEntry*) GetSearchPayload(vUser2);
 176
 177         return (u1->LastLogonT > u2->LastLogonT);
 178 }
 179
 180 int CompareLastLogonRev(const void *vUser1, const void *vUser2)
 181 {
 182         UserListEntry *u1 = (UserListEntry*) GetSearchPayload(vUser1);
 183         UserListEntry *u2 = (UserListEntry*) GetSearchPayload(vUser2);
 184
 185         return (u2->LastLogonT > u1->LastLogonT);
 186 }
 187
 188 int GroupchangeLastLogon(const void *vUser1, const void *vUser2)
 189 {
 190         UserListEntry *u1 = (UserListEntry*) vUser1;
 191         UserListEntry *u2 = (UserListEntry*) vUser2;
 192
 193         return (u2->LastLogonT != u1->LastLogonT);
 194 }
 195
 196 /*
 197  * Sort By Number of Logons
 198  */
 199 int ComparenLogons(const void *vUser1, const void *vUser2)
 200 {
 201         UserListEntry *u1 = (UserListEntry*) GetSearchPayload(vUser1);
 202         UserListEntry *u2 = (UserListEntry*) GetSearchPayload(vUser2);
 203
 204         return (u1->nLogons > u2->nLogons);
 205 }
 206
 207 int ComparenLogonsRev(const void *vUser1, const void *vUser2)
 208 {
 209         UserListEntry *u1 = (UserListEntry*) GetSearchPayload(vUser1);
 210         UserListEntry *u2 = (UserListEntry*) GetSearchPayload(vUser2);
 211
 212         return (u2->nLogons > u1->nLogons);
 213 }
 214
 215 int GroupchangenLogons(const void *vUser1, const void *vUser2)
 216 {
 217         UserListEntry *u1 = (UserListEntry*) vUser1;
 218         UserListEntry *u2 = (UserListEntry*) vUser2;
 219
 220         return (u2->nLogons / 100) != (u1->nLogons / 100);
 221 }
 222
 223 /*
 224  * Sort By Number of Posts
 225  */
 226 int ComparenPosts(const void *vUser1, const void *vUser2)
 227 {
 228         UserListEntry *u1 = (UserListEntry*) GetSearchPayload(vUser1);
 229         UserListEntry *u2 = (UserListEntry*) GetSearchPayload(vUser2);
 230
 231         return (u1->nPosts > u2->nPosts);
 232 }
 233
 234 int ComparenPostsRev(const void *vUser1, const void *vUser2)
 235 {
 236         UserListEntry *u1 = (UserListEntry*) GetSearchPayload(vUser1);
 237         UserListEntry *u2 = (UserListEntry*) GetSearchPayload(vUser2);
 238
 239         return (u2->nPosts > u1->nPosts);
 240 }
 241
 242 int GroupchangenPosts(const void *vUser1, const void *vUser2)
 243 {
 244         UserListEntry *u1 = (UserListEntry*) vUser1;
 245         UserListEntry *u2 = (UserListEntry*) vUser2;
 246
 247         return (u2->nPosts / 100) != (u1->nPosts / 100);
 248 }
 249
 250
 251 HashList *iterate_load_userlist(StrBuf *Target, WCTemplputParams *TP)
 252 {
 253         int Done = 0;
 254         CompareFunc SortIt;
 255         HashList *Hash = NULL;
 256         StrBuf *Buf;
 257         UserListEntry* ul;
 258         char nnn[64];
 259         int nUsed;
 260         int len;
 261         WCTemplputParams SubTP;
 262
 263         memset(&SubTP, 0, sizeof(WCTemplputParams));
 264         serv_puts("LIST");
 265         Buf = NewStrBuf();
 266         StrBuf_ServGetln(Buf);
 267         if (GetServerStatus(Buf, NULL) == 1) {
 268                 Hash = NewHash(1, NULL);
 269
 270                 while (!Done) {
 271                         len = StrBuf_ServGetln(Buf);
 272                         if ((len <0) ||
 273                             ((len == 3) &&
 274                              strcmp(ChrPtr(Buf), "000")))
 275                         {
 276                                 Done = 1;
 277                                 break;
 278                         }
 279                         ul = NewUserListEntry(Buf);
 280                         if (ul == NULL)
 281                                 continue;
 282                         nUsed = GetCount(Hash);
 283                         nUsed = snprintf(nnn, sizeof(nnn), "%d", nUsed+1);
 284                         Put(Hash, nnn, nUsed, ul, DeleteUserListEntry);
 285                 }
 286                 SubTP.Filter.ContextType = CTX_USERLIST;
 287                 SortIt = RetrieveSort(&SubTP, HKEY("USER"), HKEY("user:uid"), 0);
 288                 if (SortIt != NULL)
 289                         SortByPayload(Hash, SortIt);
 290                 else
 291                         SortByPayload(Hash, CompareUID);
 292         }
 293         FreeStrBuf(&Buf);
 294         return Hash;
 295 }
 296
 297
 298 void tmplput_USERLIST_UserName(StrBuf *Target, WCTemplputParams *TP)
 299 {
 300         UserListEntry *ul = (UserListEntry*) CTX;
 301         StrBufAppendTemplate(Target, TP, ul->UserName, 0);
 302 }
 303
 304 void tmplput_USERLIST_Password(StrBuf *Target, WCTemplputParams *TP)
 305 {
 306         UserListEntry *ul = (UserListEntry*) CTX;
 307         StrBufAppendTemplate(Target, TP, ul->Passvoid, 0);
 308 }
 309
 310 void tmplput_USERLIST_AccessLevelNo(StrBuf *Target, WCTemplputParams *TP)
 311 {
 312         UserListEntry *ul = (UserListEntry*) CTX;
 313
 314         StrBufAppendPrintf(Target, "%d", ul->AccessLevel, 0);
 315 }
 316
 317 void tmplput_USERLIST_AccessLevelStr(StrBuf *Target, WCTemplputParams *TP)
 318 {
 319         UserListEntry *ul = (UserListEntry*) CTX;
 320
 321         StrBufAppendBufPlain(Target, _(axdefs[ul->AccessLevel]), -1, 0);
 322 }
 323
 324 void tmplput_USERLIST_UID(StrBuf *Target, WCTemplputParams *TP)
 325 {
 326         UserListEntry *ul = (UserListEntry*) CTX;
 327
 328         StrBufAppendPrintf(Target, "%d", ul->UID, 0);
 329 }
 330
 331 void tmplput_USERLIST_LastLogonNo(StrBuf *Target, WCTemplputParams *TP)
 332 {
 333         UserListEntry *ul = (UserListEntry*) CTX;
 334
 335         StrBufAppendPrintf(Target,"%ld", ul->LastLogonT, 0);
 336 }
 337 void tmplput_USERLIST_LastLogonStr(StrBuf *Target, WCTemplputParams *TP)
 338 {
 339         UserListEntry *ul = (UserListEntry*) CTX;
 340         StrEscAppend(Target, NULL, asctime(localtime(&ul->LastLogonT)), 0, 0);
 341 }
 342
 343 void tmplput_USERLIST_nLogons(StrBuf *Target, WCTemplputParams *TP)
 344 {
 345         UserListEntry *ul = (UserListEntry*) CTX;
 346
 347         StrBufAppendPrintf(Target, "%d", ul->nLogons, 0);
 348 }
 349
 350 void tmplput_USERLIST_nPosts(StrBuf *Target, WCTemplputParams *TP)
 351 {
 352         UserListEntry *ul = (UserListEntry*) CTX;
 353
 354         StrBufAppendPrintf(Target, "%d", ul->nPosts, 0);
 355 }
 356
 357 void tmplput_USERLIST_Flags(StrBuf *Target, WCTemplputParams *TP)
 358 {
 359         UserListEntry *ul = (UserListEntry*) CTX;
 360
 361         StrBufAppendPrintf(Target, "%d", ul->Flags, 0);
 362 }
 363
 364 void tmplput_USERLIST_DaysTillPurge(StrBuf *Target, WCTemplputParams *TP)
 365 {
 366         UserListEntry *ul = (UserListEntry*) CTX;
 367
 368         StrBufAppendPrintf(Target, "%d", ul->DaysTillPurge, 0);
 369 }
 370
 371 int ConditionalUser(StrBuf *Target, WCTemplputParams *TP)
 372 {
 373         UserListEntry *ul = (UserListEntry*) CTX;
 374         if (havebstr("usernum")) {
 375                 return ibstr("usernum") == ul->UID;
 376         }
 377         else if (havebstr("username")) {
 378                 return strcmp(bstr("username"), ChrPtr(ul->UserName)) == 0;
 379         }
 380         else
 381                 return 0;
 382 }
 383
 384 int ConditionalFlagINetEmail(StrBuf *Target, WCTemplputParams *TP)
 385 {
 386         UserListEntry *ul = (UserListEntry*) CTX;
 387         return (ul->Flags & US_INTERNET) != 0;
 388 }
 389
 390 int ConditionalUserAccess(StrBuf *Target, WCTemplputParams *TP)
 391 {
 392         UserListEntry *ul = (UserListEntry*) CTX;
 393
 394         if (ul == NULL)
 395                 return 0;
 396
 397         return GetTemplateTokenNumber(Target,
 398                                       TP,
 399                                       3,
 400                                       AxNewU)
 401                 ==
 402                 ul->AccessLevel;
 403 }
 404
 405 /*
 406  *  Locate the message number of a user's vCard in the current room
 407  *  Returns the message id of his vcard
 408  */
 409 long locate_user_vcard_in_this_room(message_summary **VCMsg, wc_mime_attachment **VCAtt)
 410 {
 411         wcsession *WCC = WC;
 412         HashPos *at;
 413         HashPos *att;
 414         const char *HashKey;
 415         long HKLen;
 416         void *vMsg;
 417         message_summary *Msg;
 418         wc_mime_attachment *Att;
 419         int Done;
 420         StrBuf *Buf;
 421         long vcard_msgnum = (-1L);
 422         int already_tried_creating_one = 0;
 423         StrBuf *FoundCharset = NewStrBuf();
 424         StrBuf *Error = NULL;
 425         SharedMessageStatus Stat;
 426
 427
 428         Buf = NewStrBuf();
 429 TRYAGAIN:
 430         memset(&Stat, 0, sizeof(SharedMessageStatus));
 431         Stat.maxload = 10000;
 432         Stat.lowest_found = (-1);
 433         Stat.highest_found = (-1);
 434         Done = 0;
 435         /* Search for the user's vCard */
 436         if (load_msg_ptrs("MSGS ALL||||1", &Stat, NULL) > 0) {
 437                 at = GetNewHashPos(WCC->summ, 0);
 438                 while (GetNextHashPos(WCC->summ, at, &HKLen, &HashKey, &vMsg)) {
 439                         Msg = (message_summary*) vMsg;
 440                         Msg->MsgBody =  (wc_mime_attachment*) malloc(sizeof(wc_mime_attachment));
 441                         memset(Msg->MsgBody, 0, sizeof(wc_mime_attachment));
 442                         Msg->MsgBody->msgnum = Msg->msgnum;
 443
 444                         load_message(Msg, FoundCharset, &Error);
 445
 446                         if (Msg->AllAttach != NULL) {
 447                                 att = GetNewHashPos(Msg->AllAttach, 0);
 448                                 while (GetNextHashPos(Msg->AllAttach, att, &HKLen, &HashKey, &vMsg) &&
 449                                        (vcard_msgnum == -1)) {
 450                                         Att = (wc_mime_attachment*) vMsg;
 451                                         if (
 452                                                 (strcasecmp(ChrPtr(Att->ContentType), "text/x-vcard") == 0)
 453                                                 || (strcasecmp(ChrPtr(Att->ContentType), "text/vcard") == 0)
 454                                         ) {
 455                                                 *VCAtt = Att;
 456                                                 *VCMsg = Msg;
 457                                                 vcard_msgnum = Msg->msgnum;
 458                                                 if (Att->Data == NULL) {
 459                                                         MimeLoadData(Att);
 460                                                 }
 461                                         }
 462                                 }
 463                                 DeleteHashPos(&att);
 464                         }
 465                         FreeStrBuf(&Error);     /* don't care... */
 466
 467                 }
 468                 DeleteHashPos(&at);
 469         }
 470
 471         /* If there's no vcard, create one */
 472         if ((*VCMsg == NULL) && (already_tried_creating_one == 0)) {
 473                 FlushStrBuf(Buf);
 474                 already_tried_creating_one = 1;
 475                 serv_puts("ENT0 1|||4");
 476                 StrBuf_ServGetln(Buf);
 477                 if (GetServerStatus(Buf, NULL) == 4) {
 478                         serv_puts("Content-type: text/x-vcard");
 479                         serv_puts("");
 480                         serv_puts("begin:vcard");
 481                         serv_puts("end:vcard");
 482                         serv_puts("000");
 483                 }
 484                 else
 485                         syslog(1, "Error while creating user vcard: %s\n", ChrPtr(Buf));
 486                 goto TRYAGAIN;
 487         }
 488         FreeStrBuf(&Buf);
 489         FreeStrBuf(&FoundCharset);
 490
 491         return(vcard_msgnum);
 492 }
 493
 494
 495 /*
 496  *  Display the form for editing a user's address book entry
 497  *  username the name of the user
 498  *  usernum the citadel-uid of the user
 499  */
 500 void display_edit_address_book_entry(const char *username, long usernum) {
 501         wcsession *WCC = WC;
 502         message_summary *VCMsg = NULL;
 503         wc_mime_attachment *VCAtt = NULL;
 504         StrBuf *roomname;
 505         StrBuf *Buf;
 506         long vcard_msgnum = (-1L);
 507
 508         /* Locate the user's config room, creating it if necessary */
 509         Buf = NewStrBuf();
 510         roomname = NewStrBuf();
 511         StrBufPrintf(roomname, "%010ld.%s", usernum, USERCONFIGROOM);
 512         serv_printf("GOTO %s||1", ChrPtr(roomname));
 513         StrBuf_ServGetln(Buf);
 514         if (GetServerStatus(Buf, NULL) != 2) {
 515                 serv_printf("CRE8 1|%s|5|||1|", ChrPtr(roomname));
 516                 StrBuf_ServGetln(Buf);
 517                 GetServerStatus(Buf, NULL);
 518                 serv_printf("GOTO %s||1", ChrPtr(roomname));
 519                 StrBuf_ServGetln(Buf);
 520                 if (GetServerStatus(Buf, NULL) != 2) {
 521                         FlushStrBuf(WCC->ImportantMsg);
 522                         StrBufAppendBuf(WCC->ImportantMsg, Buf, 4);
 523                         select_user_to_edit(username);
 524                         FreeStrBuf(&Buf);
 525                         FreeStrBuf(&roomname);
 526                         return;
 527                 }
 528         }
 529         FreeStrBuf(&Buf);
 530
 531         locate_user_vcard_in_this_room(&VCMsg, &VCAtt);
 532
 533         if (VCMsg == NULL) {
 534                 StrBufPlain(WCC->ImportantMsg,
 535                             _("An error occurred while trying to create or edit this address book entry."),
 536                             0);
 537                 select_user_to_edit(username);
 538                 FreeStrBuf(&roomname);
 539                 return;
 540         }
 541
 542         do_edit_vcard(vcard_msgnum, "1",
 543                       VCMsg,
 544                       VCAtt,
 545                       "select_user_to_edit",
 546                       ChrPtr(roomname));
 547         FreeStrBuf(&roomname);
 548 }
 549
 550
 551 void display_edituser(const char *supplied_username, int is_new) {
 552         const char *Pos;
 553         wcsession *WCC = WC;
 554         UserListEntry* UL;
 555         StrBuf *Buf;
 556         char username[256];
 557
 558         if (supplied_username != NULL) {
 559                 safestrncpy(username, supplied_username, sizeof username);
 560         }
 561         else {
 562                 safestrncpy(username, bstr("username"), sizeof username);
 563         }
 564
 565         Buf = NewStrBuf();
 566         serv_printf("AGUP %s", username);
 567         StrBuf_ServGetln(Buf);
 568         if (GetServerStatus(Buf, NULL) != 2) {
 569                 FlushStrBuf(WCC->ImportantMsg);
 570                 StrBufAppendBuf(WCC->ImportantMsg, Buf, 4);
 571                 select_user_to_edit(username);
 572                 FreeStrBuf(&Buf);
 573                 return;
 574         }
 575         else {
 576                 Pos = ChrPtr(Buf) + 4;
 577                 UL = NewUserListOneEntry(Buf, Pos);
 578                 if ((UL != NULL) && havebstr("edit_abe_button")) {
 579                         display_edit_address_book_entry(username, UL->UID);
 580                 }
 581                 else if ((UL != NULL) && havebstr("delete_button")) {
 582                         delete_user(username);
 583                 }
 584                 else if (UL != NULL) {
 585                         WCTemplputParams SubTP;
 586                         memset(&SubTP, 0, sizeof(WCTemplputParams));
 587                         SubTP.Filter.ContextType = CTX_USERLIST;
 588                         SubTP.Context = UL;
 589                         output_headers(1, 0, 0, 0, 1, 0);
 590                         DoTemplate(HKEY("aide_edituser_detailview"), NULL, &SubTP);
 591                         end_burst();
 592                 }
 593                 DeleteUserListEntry(UL);
 594
 595         }
 596         FreeStrBuf(&Buf);
 597 }
 598
 599 /*
 600  *  do the backend operation of the user edit on the server
 601  */
 602 void edituser(void) {
 603         wcsession *WCC = WC;
 604         int is_new = 0;
 605         unsigned int flags = 0;
 606         const char *username;
 607
 608         is_new = ibstr("is_new");
 609         username = bstr("username");
 610
 611         if (!havebstr("ok_button")) {
 612                 StrBufPlain(WCC->ImportantMsg, _("Changes were not saved."), -1);
 613         }
 614         else {
 615                 StrBuf *Buf = NewStrBuf();
 616
 617                 flags = ibstr("flags");
 618                 if (yesbstr("inetmail")) {
 619                         flags |= US_INTERNET;
 620                 }
 621                 else {
 622                         flags &= ~US_INTERNET ;
 623                 }
 624
 625                 if ((havebstr("newname")) && (strcasecmp(bstr("username"), bstr("newname")))) {
 626                         serv_printf("RENU %s|%s", bstr("username"), bstr("newname"));
 627                         StrBuf_ServGetln(Buf);
 628                         if (GetServerStatus(Buf, NULL) == 2) {
 629                                 FlushStrBuf(WCC->ImportantMsg);
 630                                 StrBufAppendBuf(WCC->ImportantMsg, Buf, 4);
 631                         }
 632                         else {
 633                                 username = bstr("newname");
 634                         }
 635                 }
 636
 637                 serv_printf("ASUP %s|%s|%d|%s|%s|%s|%s|%s|%s|",
 638                         username,
 639                         bstr("password"),
 640                         flags,
 641                         bstr("timescalled"),
 642                         bstr("msgsposted"),
 643                         bstr("axlevel"),
 644                         bstr("usernum"),
 645                         bstr("lastcall"),
 646                         bstr("purgedays")
 647                 );
 648                 StrBuf_ServGetln(Buf);
 649                 if (GetServerStatus(Buf, NULL) == 2) {
 650                         StrBufAppendBuf(WCC->ImportantMsg, Buf, 4);
 651                 }
 652                 FreeStrBuf(&Buf);
 653         }
 654
 655         /*
 656          * If we are in the middle of creating a new user, move on to
 657          * the vCard edit screen.
 658          */
 659         if (is_new) {
 660                 display_edit_address_book_entry(username, lbstr("usernum") );
 661         }
 662         else {
 663                 select_user_to_edit(username);
 664         }
 665 }
 666
 667 /*
 668  *  burge a user
 669  *  username the name of the user to remove
 670  */
 671 void delete_user(char *username) {
 672         wcsession *WCC = WC;
 673         StrBuf *Buf;
 674
 675         Buf = NewStrBuf();
 676         serv_printf("ASUP %s|0|0|0|0|0|", username);
 677         StrBuf_ServGetln(Buf);
 678         if (GetServerStatus(Buf, NULL) != 2)
 679                 StrBufAppendBuf(WCC->ImportantMsg, Buf, 4);
 680
 681         select_user_to_edit( bstr("username"));
 682         FreeStrBuf(&Buf);
 683 }
 684
 685
 686
 687 /*
 688  *  create a new user
 689  * take the web environment username and create it on the citadel server
 690  */
 691 void create_user(void) {
 692         wcsession *WCC = WC;
 693         long FullState;
 694         StrBuf *Buf;
 695         const char *username;
 696
 697         Buf = NewStrBuf();
 698         username = bstr("username");
 699         serv_printf("CREU %s", username);
 700         StrBuf_ServGetln(Buf);
 701         if (GetServerStatus(Buf, &FullState) == 2) {
 702                 sprintf(WC->ImportantMessage, _("A new user has been created."));
 703                 display_edituser(username, 1);
 704         }
 705         else if (FullState == 570) {
 706                 StrBufPlain(WCC->ImportantMsg,
 707                             _("You are attempting to create a new user from within Citadel "
 708                               "while running in host based authentication mode.  In this mode, "
 709                               "you must create new users on the host system, not within Citadel."),
 710                             0);
 711                 select_user_to_edit(NULL);
 712         }
 713         else {
 714                 StrBufAppendBuf(WCC->ImportantMsg, Buf, 4);
 715                 select_user_to_edit(NULL);
 716         }
 717         FreeStrBuf(&Buf);
 718 }
 719
 720
 721 void _select_user_to_edit(void) {
 722         select_user_to_edit(NULL);
 723 }
 724
 725
 726 void _display_edituser(void) {
 727         display_edituser(NULL, 0);
 728 }
 729
 730
 731 void
 732 InitModule_USEREDIT
 733 (void)
 734 {
 735         WebcitAddUrlHandler(HKEY("select_user_to_edit"), "", 0, _select_user_to_edit, 0);
 736         WebcitAddUrlHandler(HKEY("display_edituser"), "", 0, _display_edituser, 0);
 737         WebcitAddUrlHandler(HKEY("edituser"), "", 0, edituser, 0);
 738         WebcitAddUrlHandler(HKEY("create_user"), "", 0, create_user, 0);
 739
 740         RegisterNamespace("USERLIST:USERNAME",      0, 1, tmplput_USERLIST_UserName, NULL, CTX_USERLIST);
 741         RegisterNamespace("USERLIST:PASSWD",        0, 1, tmplput_USERLIST_Password, NULL, CTX_USERLIST);
 742         RegisterNamespace("USERLIST:ACCLVLNO",      0, 0, tmplput_USERLIST_AccessLevelNo, NULL, CTX_USERLIST);
 743         RegisterNamespace("USERLIST:ACCLVLSTR",     0, 0, tmplput_USERLIST_AccessLevelStr, NULL, CTX_USERLIST);
 744         RegisterNamespace("USERLIST:UID",           0, 0, tmplput_USERLIST_UID, NULL, CTX_USERLIST);
 745         RegisterNamespace("USERLIST:LASTLOGON:STR", 0, 0, tmplput_USERLIST_LastLogonStr, NULL, CTX_USERLIST);
 746         RegisterNamespace("USERLIST:LASTLOGON:NO",  0, 0, tmplput_USERLIST_LastLogonNo, NULL, CTX_USERLIST);
 747         RegisterNamespace("USERLIST:NLOGONS",       0, 0, tmplput_USERLIST_nLogons, NULL, CTX_USERLIST);
 748         RegisterNamespace("USERLIST:NPOSTS",        0, 0, tmplput_USERLIST_nPosts, NULL, CTX_USERLIST);
 749
 750         RegisterNamespace("USERLIST:FLAGS",         0, 0, tmplput_USERLIST_Flags, NULL, CTX_USERLIST);
 751         RegisterNamespace("USERLIST:DAYSTILLPURGE", 0, 0, tmplput_USERLIST_DaysTillPurge, NULL, CTX_USERLIST);
 752
 753         RegisterConditional(HKEY("COND:USERNAME"),  0,    ConditionalUser, CTX_USERLIST);
 754         RegisterConditional(HKEY("COND:USERACCESS"), 0,   ConditionalUserAccess, CTX_USERLIST);
 755         RegisterConditional(HKEY("COND:USERLIST:FLAG:USE_INTERNET"), 0, ConditionalFlagINetEmail, CTX_USERLIST);
 756
 757         RegisterIterator("USERLIST", 0, NULL, iterate_load_userlist, NULL, DeleteHash, CTX_USERLIST, CTX_NONE, IT_FLAG_DETECT_GROUPCHANGE);
 758
 759
 760
 761         RegisterSortFunc(HKEY("user:name"),
 762                          HKEY("userlist"),
 763                          CompareUserListName,
 764                          CompareUserListNameRev,
 765                          GroupchangeUserListName,
 766                          CTX_USERLIST);
 767         RegisterSortFunc(HKEY("user:accslvl"),
 768                          HKEY("userlist"),
 769                          CompareAccessLevel,
 770                          CompareAccessLevelRev,
 771                          GroupchangeAccessLevel,
 772                          CTX_USERLIST);
 773
 774         RegisterSortFunc(HKEY("user:nlogons"),
 775                          HKEY("userlist"),
 776                          ComparenLogons,
 777                          ComparenLogonsRev,
 778                          GroupchangenLogons,
 779                          CTX_USERLIST);
 780
 781         RegisterSortFunc(HKEY("user:uid"),
 782                          HKEY("userlist"),
 783                          CompareUID,
 784                          CompareUIDRev,
 785                          GroupchangeUID,
 786                          CTX_USERLIST);
 787
 788         RegisterSortFunc(HKEY("user:lastlogon"),
 789                          HKEY("userlist"),
 790                          CompareLastLogon,
 791                          CompareLastLogonRev,
 792                          GroupchangeLastLogon,
 793                          CTX_USERLIST);
 794
 795         RegisterSortFunc(HKEY("user:nmsgposts"),
 796                          HKEY("userlist"),
 797                          ComparenPosts,
 798                          ComparenPostsRev,
 799                          GroupchangenPosts,
 800                          CTX_USERLIST);
 801
 802         REGISTERTokenParamDefine(AxDeleted);
 803         REGISTERTokenParamDefine(AxNewU);
 804         REGISTERTokenParamDefine(AxProbU);
 805         REGISTERTokenParamDefine(AxLocU);
 806         REGISTERTokenParamDefine(AxNetU);
 807         REGISTERTokenParamDefine(AxPrefU);
 808         REGISTERTokenParamDefine(AxAideU);
 809 }
 810