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 == 3) &&
 273                             (strcmp(ChrPtr(Buf), "000")==0)) {
 274                                 Done = 1;
 275                                 break;
 276                         }
 277                         ul = NewUserListEntry(Buf);
 278                         if (ul == NULL)
 279                                 continue;
 280                         nUsed = GetCount(Hash);
 281                         nUsed = snprintf(nnn, sizeof(nnn), "%d", nUsed+1);
 282                         Put(Hash, nnn, nUsed, ul, DeleteUserListEntry);
 283                 }
 284                 SubTP.Filter.ContextType = CTX_USERLIST;
 285                 SortIt = RetrieveSort(&SubTP, HKEY("USER"), HKEY("user:uid"), 0);
 286                 if (SortIt != NULL)
 287                         SortByPayload(Hash, SortIt);
 288                 else
 289                         SortByPayload(Hash, CompareUID);
 290         }
 291         FreeStrBuf(&Buf);
 292         return Hash;
 293 }
 294
 295
 296 void tmplput_USERLIST_UserName(StrBuf *Target, WCTemplputParams *TP)
 297 {
 298         UserListEntry *ul = (UserListEntry*) CTX;
 299         StrBufAppendTemplate(Target, TP, ul->UserName, 0);
 300 }
 301
 302 void tmplput_USERLIST_Password(StrBuf *Target, WCTemplputParams *TP)
 303 {
 304         UserListEntry *ul = (UserListEntry*) CTX;
 305         StrBufAppendTemplate(Target, TP, ul->Passvoid, 0);
 306 }
 307
 308 void tmplput_USERLIST_AccessLevelNo(StrBuf *Target, WCTemplputParams *TP)
 309 {
 310         UserListEntry *ul = (UserListEntry*) CTX;
 311
 312         StrBufAppendPrintf(Target, "%d", ul->AccessLevel, 0);
 313 }
 314
 315 void tmplput_USERLIST_AccessLevelStr(StrBuf *Target, WCTemplputParams *TP)
 316 {
 317         UserListEntry *ul = (UserListEntry*) CTX;
 318
 319         StrBufAppendBufPlain(Target, _(axdefs[ul->AccessLevel]), -1, 0);
 320 }
 321
 322 void tmplput_USERLIST_UID(StrBuf *Target, WCTemplputParams *TP)
 323 {
 324         UserListEntry *ul = (UserListEntry*) CTX;
 325
 326         StrBufAppendPrintf(Target, "%d", ul->UID, 0);
 327 }
 328
 329 void tmplput_USERLIST_LastLogonNo(StrBuf *Target, WCTemplputParams *TP)
 330 {
 331         UserListEntry *ul = (UserListEntry*) CTX;
 332
 333         StrBufAppendPrintf(Target,"%ld", ul->LastLogonT, 0);
 334 }
 335 void tmplput_USERLIST_LastLogonStr(StrBuf *Target, WCTemplputParams *TP)
 336 {
 337         UserListEntry *ul = (UserListEntry*) CTX;
 338         StrEscAppend(Target, NULL, asctime(localtime(&ul->LastLogonT)), 0, 0);
 339 }
 340
 341 void tmplput_USERLIST_nLogons(StrBuf *Target, WCTemplputParams *TP)
 342 {
 343         UserListEntry *ul = (UserListEntry*) CTX;
 344
 345         StrBufAppendPrintf(Target, "%d", ul->nLogons, 0);
 346 }
 347
 348 void tmplput_USERLIST_nPosts(StrBuf *Target, WCTemplputParams *TP)
 349 {
 350         UserListEntry *ul = (UserListEntry*) CTX;
 351
 352         StrBufAppendPrintf(Target, "%d", ul->nPosts, 0);
 353 }
 354
 355 void tmplput_USERLIST_Flags(StrBuf *Target, WCTemplputParams *TP)
 356 {
 357         UserListEntry *ul = (UserListEntry*) CTX;
 358
 359         StrBufAppendPrintf(Target, "%d", ul->Flags, 0);
 360 }
 361
 362 void tmplput_USERLIST_DaysTillPurge(StrBuf *Target, WCTemplputParams *TP)
 363 {
 364         UserListEntry *ul = (UserListEntry*) CTX;
 365
 366         StrBufAppendPrintf(Target, "%d", ul->DaysTillPurge, 0);
 367 }
 368
 369 int ConditionalUser(StrBuf *Target, WCTemplputParams *TP)
 370 {
 371         UserListEntry *ul = (UserListEntry*) CTX;
 372         if (havebstr("usernum")) {
 373                 return ibstr("usernum") == ul->UID;
 374         }
 375         else if (havebstr("username")) {
 376                 return strcmp(bstr("username"), ChrPtr(ul->UserName)) == 0;
 377         }
 378         else
 379                 return 0;
 380 }
 381
 382 int ConditionalFlagINetEmail(StrBuf *Target, WCTemplputParams *TP)
 383 {
 384         UserListEntry *ul = (UserListEntry*) CTX;
 385         return (ul->Flags & US_INTERNET) != 0;
 386 }
 387
 388 int ConditionalUserAccess(StrBuf *Target, WCTemplputParams *TP)
 389 {
 390         UserListEntry *ul = (UserListEntry*) CTX;
 391
 392         if (ul == NULL)
 393                 return 0;
 394
 395         return GetTemplateTokenNumber(Target,
 396                                       TP,
 397                                       3,
 398                                       AxNewU)
 399                 ==
 400                 ul->AccessLevel;
 401 }
 402
 403 /*
 404  *  Locate the message number of a user's vCard in the current room
 405  *  Returns the message id of his vcard
 406  */
 407 long locate_user_vcard_in_this_room(message_summary **VCMsg, wc_mime_attachment **VCAtt)
 408 {
 409         wcsession *WCC = WC;
 410         HashPos *at;
 411         HashPos *att;
 412         const char *HashKey;
 413         long HKLen;
 414         void *vMsg;
 415         message_summary *Msg;
 416         wc_mime_attachment *Att;
 417         int Done;
 418         StrBuf *Buf;
 419         long vcard_msgnum = (-1L);
 420         int already_tried_creating_one = 0;
 421         StrBuf *FoundCharset = NewStrBuf();
 422         StrBuf *Error = NULL;
 423         SharedMessageStatus Stat;
 424
 425
 426         Buf = NewStrBuf();
 427 TRYAGAIN:
 428         memset(&Stat, 0, sizeof(SharedMessageStatus));
 429         Stat.maxload = 10000;
 430         Stat.lowest_found = (-1);
 431         Stat.highest_found = (-1);
 432         Done = 0;
 433         /* Search for the user's vCard */
 434         if (load_msg_ptrs("MSGS ALL||||1", &Stat, NULL) > 0) {
 435                 at = GetNewHashPos(WCC->summ, 0);
 436                 while (GetNextHashPos(WCC->summ, at, &HKLen, &HashKey, &vMsg)) {
 437                         Msg = (message_summary*) vMsg;
 438                         Msg->MsgBody =  (wc_mime_attachment*) malloc(sizeof(wc_mime_attachment));
 439                         memset(Msg->MsgBody, 0, sizeof(wc_mime_attachment));
 440                         Msg->MsgBody->msgnum = Msg->msgnum;
 441
 442                         load_message(Msg, FoundCharset, &Error);
 443
 444                         if (Msg->AllAttach != NULL) {
 445                                 att = GetNewHashPos(Msg->AllAttach, 0);
 446                                 while (GetNextHashPos(Msg->AllAttach, att, &HKLen, &HashKey, &vMsg) &&
 447                                        (vcard_msgnum == -1)) {
 448                                         Att = (wc_mime_attachment*) vMsg;
 449                                         if (
 450                                                 (strcasecmp(ChrPtr(Att->ContentType), "text/x-vcard") == 0)
 451                                                 || (strcasecmp(ChrPtr(Att->ContentType), "text/vcard") == 0)
 452                                         ) {
 453                                                 *VCAtt = Att;
 454                                                 *VCMsg = Msg;
 455                                                 vcard_msgnum = Msg->msgnum;
 456                                                 if (Att->Data == NULL) {
 457                                                         MimeLoadData(Att);
 458                                                 }
 459                                         }
 460                                 }
 461                                 DeleteHashPos(&att);
 462                         }
 463                         FreeStrBuf(&Error);     /* don't care... */
 464
 465                 }
 466                 DeleteHashPos(&at);
 467         }
 468
 469         /* If there's no vcard, create one */
 470         if ((*VCMsg == NULL) && (already_tried_creating_one == 0)) {
 471                 FlushStrBuf(Buf);
 472                 already_tried_creating_one = 1;
 473                 serv_puts("ENT0 1|||4");
 474                 StrBuf_ServGetln(Buf);
 475                 if (GetServerStatus(Buf, NULL) == 4) {
 476                         serv_puts("Content-type: text/x-vcard");
 477                         serv_puts("");
 478                         serv_puts("begin:vcard");
 479                         serv_puts("end:vcard");
 480                         serv_puts("000");
 481                 }
 482                 else
 483                         syslog(1, "Error while creating user vcard: %s\n", ChrPtr(Buf));
 484                 goto TRYAGAIN;
 485         }
 486         FreeStrBuf(&Buf);
 487         FreeStrBuf(&FoundCharset);
 488
 489         return(vcard_msgnum);
 490 }
 491
 492
 493 /*
 494  *  Display the form for editing a user's address book entry
 495  *  username the name of the user
 496  *  usernum the citadel-uid of the user
 497  */
 498 void display_edit_address_book_entry(const char *username, long usernum) {
 499         wcsession *WCC = WC;
 500         message_summary *VCMsg = NULL;
 501         wc_mime_attachment *VCAtt = NULL;
 502         StrBuf *roomname;
 503         StrBuf *Buf;
 504         long vcard_msgnum = (-1L);
 505
 506         /* Locate the user's config room, creating it if necessary */
 507         Buf = NewStrBuf();
 508         roomname = NewStrBuf();
 509         StrBufPrintf(roomname, "%010ld.%s", usernum, USERCONFIGROOM);
 510         serv_printf("GOTO %s||1", ChrPtr(roomname));
 511         StrBuf_ServGetln(Buf);
 512         if (GetServerStatus(Buf, NULL) != 2) {
 513                 serv_printf("CRE8 1|%s|5|||1|", ChrPtr(roomname));
 514                 StrBuf_ServGetln(Buf);
 515                 GetServerStatus(Buf, NULL);
 516                 serv_printf("GOTO %s||1", ChrPtr(roomname));
 517                 StrBuf_ServGetln(Buf);
 518                 if (GetServerStatus(Buf, NULL) != 2) {
 519                         FlushStrBuf(WCC->ImportantMsg);
 520                         StrBufAppendBuf(WCC->ImportantMsg, Buf, 4);
 521                         select_user_to_edit(username);
 522                         FreeStrBuf(&Buf);
 523                         FreeStrBuf(&roomname);
 524                         return;
 525                 }
 526         }
 527         FreeStrBuf(&Buf);
 528
 529         locate_user_vcard_in_this_room(&VCMsg, &VCAtt);
 530
 531         if (VCMsg == NULL) {
 532                 StrBufPlain(WCC->ImportantMsg,
 533                             _("An error occurred while trying to create or edit this address book entry."),
 534                             0);
 535                 select_user_to_edit(username);
 536                 FreeStrBuf(&roomname);
 537                 return;
 538         }
 539
 540         do_edit_vcard(vcard_msgnum, "1",
 541                       VCMsg,
 542                       VCAtt,
 543                       "select_user_to_edit",
 544                       ChrPtr(roomname));
 545         FreeStrBuf(&roomname);
 546 }
 547
 548
 549 void display_edituser(const char *supplied_username, int is_new) {
 550         const char *Pos;
 551         wcsession *WCC = WC;
 552         UserListEntry* UL;
 553         StrBuf *Buf;
 554         char username[256];
 555
 556         if (supplied_username != NULL) {
 557                 safestrncpy(username, supplied_username, sizeof username);
 558         }
 559         else {
 560                 safestrncpy(username, bstr("username"), sizeof username);
 561         }
 562
 563         Buf = NewStrBuf();
 564         serv_printf("AGUP %s", username);
 565         StrBuf_ServGetln(Buf);
 566         if (GetServerStatus(Buf, NULL) != 2) {
 567                 FlushStrBuf(WCC->ImportantMsg);
 568                 StrBufAppendBuf(WCC->ImportantMsg, Buf, 4);
 569                 select_user_to_edit(username);
 570                 FreeStrBuf(&Buf);
 571                 return;
 572         }
 573         else {
 574                 Pos = ChrPtr(Buf) + 4;
 575                 UL = NewUserListOneEntry(Buf, Pos);
 576                 if ((UL != NULL) && havebstr("edit_abe_button")) {
 577                         display_edit_address_book_entry(username, UL->UID);
 578                 }
 579                 else if ((UL != NULL) && havebstr("delete_button")) {
 580                         delete_user(username);
 581                 }
 582                 else if (UL != NULL) {
 583                         WCTemplputParams SubTP;
 584                         memset(&SubTP, 0, sizeof(WCTemplputParams));
 585                         SubTP.Filter.ContextType = CTX_USERLIST;
 586                         SubTP.Context = UL;
 587                         output_headers(1, 0, 0, 0, 1, 0);
 588                         DoTemplate(HKEY("aide_edituser_detailview"), NULL, &SubTP);
 589                         end_burst();
 590                 }
 591                 DeleteUserListEntry(UL);
 592
 593         }
 594         FreeStrBuf(&Buf);
 595 }
 596
 597 /*
 598  *  do the backend operation of the user edit on the server
 599  */
 600 void edituser(void) {
 601         wcsession *WCC = WC;
 602         int is_new = 0;
 603         unsigned int flags = 0;
 604         const char *username;
 605
 606         is_new = ibstr("is_new");
 607         username = bstr("username");
 608
 609         if (!havebstr("ok_button")) {
 610                 StrBufPlain(WCC->ImportantMsg, _("Changes were not saved."), -1);
 611         }
 612         else {
 613                 StrBuf *Buf = NewStrBuf();
 614
 615                 flags = ibstr("flags");
 616                 if (yesbstr("inetmail")) {
 617                         flags |= US_INTERNET;
 618                 }
 619                 else {
 620                         flags &= ~US_INTERNET ;
 621                 }
 622
 623                 if ((havebstr("newname")) && (strcasecmp(bstr("username"), bstr("newname")))) {
 624                         serv_printf("RENU %s|%s", bstr("username"), bstr("newname"));
 625                         StrBuf_ServGetln(Buf);
 626                         if (GetServerStatus(Buf, NULL) == 2) {
 627                                 FlushStrBuf(WCC->ImportantMsg);
 628                                 StrBufAppendBuf(WCC->ImportantMsg, Buf, 4);
 629                         }
 630                         else {
 631                                 username = bstr("newname");
 632                         }
 633                 }
 634
 635                 serv_printf("ASUP %s|%s|%d|%s|%s|%s|%s|%s|%s|",
 636                         username,
 637                         bstr("password"),
 638                         flags,
 639                         bstr("timescalled"),
 640                         bstr("msgsposted"),
 641                         bstr("axlevel"),
 642                         bstr("usernum"),
 643                         bstr("lastcall"),
 644                         bstr("purgedays")
 645                 );
 646                 StrBuf_ServGetln(Buf);
 647                 if (GetServerStatus(Buf, NULL) == 2) {
 648                         StrBufAppendBuf(WCC->ImportantMsg, Buf, 4);
 649                 }
 650                 FreeStrBuf(&Buf);
 651         }
 652
 653         /*
 654          * If we are in the middle of creating a new user, move on to
 655          * the vCard edit screen.
 656          */
 657         if (is_new) {
 658                 display_edit_address_book_entry(username, lbstr("usernum") );
 659         }
 660         else {
 661                 select_user_to_edit(username);
 662         }
 663 }
 664
 665 /*
 666  *  burge a user
 667  *  username the name of the user to remove
 668  */
 669 void delete_user(char *username) {
 670         wcsession *WCC = WC;
 671         StrBuf *Buf;
 672
 673         Buf = NewStrBuf();
 674         serv_printf("ASUP %s|0|0|0|0|0|", username);
 675         StrBuf_ServGetln(Buf);
 676         if (GetServerStatus(Buf, NULL) != 2)
 677                 StrBufAppendBuf(WCC->ImportantMsg, Buf, 4);
 678
 679         select_user_to_edit( bstr("username"));
 680         FreeStrBuf(&Buf);
 681 }
 682
 683
 684
 685 /*
 686  *  create a new user
 687  * take the web environment username and create it on the citadel server
 688  */
 689 void create_user(void) {
 690         wcsession *WCC = WC;
 691         long FullState;
 692         StrBuf *Buf;
 693         const char *username;
 694
 695         Buf = NewStrBuf();
 696         username = bstr("username");
 697         serv_printf("CREU %s", username);
 698         StrBuf_ServGetln(Buf);
 699         if (GetServerStatus(Buf, &FullState) == 2) {
 700                 sprintf(WC->ImportantMessage, _("A new user has been created."));
 701                 display_edituser(username, 1);
 702         }
 703         else if (FullState == 570) {
 704                 StrBufPlain(WCC->ImportantMsg,
 705                             _("You are attempting to create a new user from within Citadel "
 706                               "while running in host based authentication mode.  In this mode, "
 707                               "you must create new users on the host system, not within Citadel."),
 708                             0);
 709                 select_user_to_edit(NULL);
 710         }
 711         else {
 712                 StrBufAppendBuf(WCC->ImportantMsg, Buf, 4);
 713                 select_user_to_edit(NULL);
 714         }
 715         FreeStrBuf(&Buf);
 716 }
 717
 718
 719 void _select_user_to_edit(void) {
 720         select_user_to_edit(NULL);
 721 }
 722
 723
 724 void _display_edituser(void) {
 725         display_edituser(NULL, 0);
 726 }
 727
 728
 729 void
 730 InitModule_USEREDIT
 731 (void)
 732 {
 733         WebcitAddUrlHandler(HKEY("select_user_to_edit"), "", 0, _select_user_to_edit, 0);
 734         WebcitAddUrlHandler(HKEY("display_edituser"), "", 0, _display_edituser, 0);
 735         WebcitAddUrlHandler(HKEY("edituser"), "", 0, edituser, 0);
 736         WebcitAddUrlHandler(HKEY("create_user"), "", 0, create_user, 0);
 737
 738         RegisterNamespace("USERLIST:USERNAME",      0, 1, tmplput_USERLIST_UserName, NULL, CTX_USERLIST);
 739         RegisterNamespace("USERLIST:PASSWD",        0, 1, tmplput_USERLIST_Password, NULL, CTX_USERLIST);
 740         RegisterNamespace("USERLIST:ACCLVLNO",      0, 0, tmplput_USERLIST_AccessLevelNo, NULL, CTX_USERLIST);
 741         RegisterNamespace("USERLIST:ACCLVLSTR",     0, 0, tmplput_USERLIST_AccessLevelStr, NULL, CTX_USERLIST);
 742         RegisterNamespace("USERLIST:UID",           0, 0, tmplput_USERLIST_UID, NULL, CTX_USERLIST);
 743         RegisterNamespace("USERLIST:LASTLOGON:STR", 0, 0, tmplput_USERLIST_LastLogonStr, NULL, CTX_USERLIST);
 744         RegisterNamespace("USERLIST:LASTLOGON:NO",  0, 0, tmplput_USERLIST_LastLogonNo, NULL, CTX_USERLIST);
 745         RegisterNamespace("USERLIST:NLOGONS",       0, 0, tmplput_USERLIST_nLogons, NULL, CTX_USERLIST);
 746         RegisterNamespace("USERLIST:NPOSTS",        0, 0, tmplput_USERLIST_nPosts, NULL, CTX_USERLIST);
 747
 748         RegisterNamespace("USERLIST:FLAGS",         0, 0, tmplput_USERLIST_Flags, NULL, CTX_USERLIST);
 749         RegisterNamespace("USERLIST:DAYSTILLPURGE", 0, 0, tmplput_USERLIST_DaysTillPurge, NULL, CTX_USERLIST);
 750
 751         RegisterConditional(HKEY("COND:USERNAME"),  0,    ConditionalUser, CTX_USERLIST);
 752         RegisterConditional(HKEY("COND:USERACCESS"), 0,   ConditionalUserAccess, CTX_USERLIST);
 753         RegisterConditional(HKEY("COND:USERLIST:FLAG:USE_INTERNET"), 0, ConditionalFlagINetEmail, CTX_USERLIST);
 754
 755         RegisterIterator("USERLIST", 0, NULL, iterate_load_userlist, NULL, DeleteHash, CTX_USERLIST, CTX_NONE, IT_FLAG_DETECT_GROUPCHANGE);
 756
 757
 758
 759         RegisterSortFunc(HKEY("user:name"),
 760                          HKEY("userlist"),
 761                          CompareUserListName,
 762                          CompareUserListNameRev,
 763                          GroupchangeUserListName,
 764                          CTX_USERLIST);
 765         RegisterSortFunc(HKEY("user:accslvl"),
 766                          HKEY("userlist"),
 767                          CompareAccessLevel,
 768                          CompareAccessLevelRev,
 769                          GroupchangeAccessLevel,
 770                          CTX_USERLIST);
 771
 772         RegisterSortFunc(HKEY("user:nlogons"),
 773                          HKEY("userlist"),
 774                          ComparenLogons,
 775                          ComparenLogonsRev,
 776                          GroupchangenLogons,
 777                          CTX_USERLIST);
 778
 779         RegisterSortFunc(HKEY("user:uid"),
 780                          HKEY("userlist"),
 781                          CompareUID,
 782                          CompareUIDRev,
 783                          GroupchangeUID,
 784                          CTX_USERLIST);
 785
 786         RegisterSortFunc(HKEY("user:lastlogon"),
 787                          HKEY("userlist"),
 788                          CompareLastLogon,
 789                          CompareLastLogonRev,
 790                          GroupchangeLastLogon,
 791                          CTX_USERLIST);
 792
 793         RegisterSortFunc(HKEY("user:nmsgposts"),
 794                          HKEY("userlist"),
 795                          ComparenPosts,
 796                          ComparenPostsRev,
 797                          GroupchangenPosts,
 798                          CTX_USERLIST);
 799
 800         REGISTERTokenParamDefine(AxDeleted);
 801         REGISTERTokenParamDefine(AxNewU);
 802         REGISTERTokenParamDefine(AxProbU);
 803         REGISTERTokenParamDefine(AxLocU);
 804         REGISTERTokenParamDefine(AxNetU);
 805         REGISTERTokenParamDefine(AxPrefU);
 806         REGISTERTokenParamDefine(AxAideU);
 807 }
 808