Remove APPDIR support in database_cleanup.sh
[citadel] / webcit / useredit.c
1 /*
2  * Copyright (c) 1996-2020 by the citadel.org team
3  *
4  * This program is open source software.  You can redistribute it and/or
5  * modify it under the terms of the GNU General Public License, version 3.
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  * GNU General Public License for more details.
11  */
12
13 #include "webcit.h"
14 #include "webserver.h"
15
16 CtxType CTX_USERLIST = CTX_NONE;
17 /*
18  *  show a list of available users to edit them
19  *  message the header message???
20  *  preselect = which user should be selected in the browser
21  */
22 void select_user_to_edit(const char *preselect)
23 {
24         output_headers(1, 0, 0, 0, 1, 0);
25         do_template("aide_edituser_select");
26         end_burst();
27 }
28
29
30 typedef struct _UserListEntry {
31         int UID;
32         int AccessLevel;
33         int nLogons;
34         int nPosts;
35
36         StrBuf *UserName;
37         StrBuf *Passvoid;
38         time_t LastLogonT;
39         /* Just available for Single users to view: */
40         unsigned int Flags;
41         int DaysTillPurge;
42         int HasBio;
43
44         StrBuf *PrimaryEmail;
45         StrBuf *OtherEmails;
46
47 } UserListEntry;
48
49
50 UserListEntry* NewUserListOneEntry(StrBuf *SerializedUser, const char *Pos)
51 {
52         UserListEntry *ul;
53
54         if (StrLength(SerializedUser) < 8) 
55                 return NULL;
56
57         ul = (UserListEntry*) malloc(sizeof(UserListEntry));
58         ul->UserName = NewStrBuf();
59         ul->Passvoid = NewStrBuf();
60         ul->PrimaryEmail = NewStrBuf();
61         ul->OtherEmails = NewStrBuf();
62
63         StrBufExtract_NextToken(ul->UserName,               SerializedUser, &Pos, '|');
64         StrBufExtract_NextToken(ul->Passvoid,               SerializedUser, &Pos, '|');
65         ul->Flags         = StrBufExtractNext_unsigned_long(SerializedUser, &Pos, '|');
66         ul->nLogons       = StrBufExtractNext_int(          SerializedUser, &Pos, '|');
67         ul->nPosts        = StrBufExtractNext_int(          SerializedUser, &Pos, '|');
68         ul->AccessLevel   = StrBufExtractNext_int(          SerializedUser, &Pos, '|');
69         ul->UID           = StrBufExtractNext_int(          SerializedUser, &Pos, '|');
70         ul->LastLogonT    = StrBufExtractNext_long(         SerializedUser, &Pos, '|');
71         ul->DaysTillPurge = StrBufExtractNext_int(          SerializedUser, &Pos, '|');
72         return ul;
73 }
74
75 void DeleteUserListEntry(void *vUserList)
76 {
77         UserListEntry *ul = (UserListEntry*) vUserList;
78         if (!ul) return;
79         FreeStrBuf(&ul->UserName);
80         FreeStrBuf(&ul->Passvoid);
81         FreeStrBuf(&ul->PrimaryEmail);
82         FreeStrBuf(&ul->OtherEmails);
83         free(ul);
84 }
85
86 UserListEntry* NewUserListEntry(StrBuf *SerializedUserList)
87 {
88         const char *Pos = NULL;
89         UserListEntry *ul;
90
91         if (StrLength(SerializedUserList) < 8) 
92                 return NULL;
93
94         ul = (UserListEntry*) malloc(sizeof(UserListEntry));
95         ul->UserName = NewStrBuf();
96         ul->Passvoid = NewStrBuf();
97         ul->PrimaryEmail = NewStrBuf();
98         ul->OtherEmails = NewStrBuf();
99
100         StrBufExtract_NextToken(ul->UserName,    SerializedUserList, &Pos, '|');
101         ul->AccessLevel = StrBufExtractNext_int( SerializedUserList, &Pos, '|');
102         ul->UID         = StrBufExtractNext_int( SerializedUserList, &Pos, '|');
103         ul->LastLogonT  = StrBufExtractNext_long(SerializedUserList, &Pos, '|');
104         ul->nLogons     = StrBufExtractNext_int( SerializedUserList, &Pos, '|');
105         ul->nPosts      = StrBufExtractNext_int( SerializedUserList, &Pos, '|');
106         StrBufExtract_NextToken(ul->Passvoid,    SerializedUserList, &Pos, '|');
107         ul->Flags = 0;
108         ul->HasBio = 0;
109         ul->DaysTillPurge = -1;
110         return ul;
111 }
112
113 /*
114  * Sort by Username
115  */
116 int CompareUserListName(const void *vUser1, const void *vUser2)
117 {
118         UserListEntry *u1 = (UserListEntry*) GetSearchPayload(vUser1);
119         UserListEntry *u2 = (UserListEntry*) GetSearchPayload(vUser2);
120
121         return strcmp(ChrPtr(u1->UserName), ChrPtr(u2->UserName));
122 }
123
124 int CompareUserListNameRev(const void *vUser1, const void *vUser2)
125 {
126         UserListEntry *u1 = (UserListEntry*) GetSearchPayload(vUser1);
127         UserListEntry *u2 = (UserListEntry*) GetSearchPayload(vUser2);
128         return strcmp(ChrPtr(u2->UserName), ChrPtr(u1->UserName));
129 }
130
131 int GroupchangeUserListName(const void *vUser1, const void *vUser2)
132 {
133         UserListEntry *u1 = (UserListEntry*) vUser1;
134         UserListEntry *u2 = (UserListEntry*) vUser2;
135         return ChrPtr(u2->UserName)[0] != ChrPtr(u1->UserName)[0];
136 }
137
138 /*
139  * Sort by access level
140  */
141 int CompareAccessLevel(const void *vUser1, const void *vUser2)
142 {
143         UserListEntry *u1 = (UserListEntry*) GetSearchPayload(vUser1);
144         UserListEntry *u2 = (UserListEntry*) GetSearchPayload(vUser2);
145
146         return (u1->AccessLevel > u2->AccessLevel);
147 }
148
149 int CompareAccessLevelRev(const void *vUser1, const void *vUser2)
150 {
151         UserListEntry *u1 = (UserListEntry*) GetSearchPayload(vUser1);
152         UserListEntry *u2 = (UserListEntry*) GetSearchPayload(vUser2);
153
154         return (u2->AccessLevel > u1->AccessLevel);
155 }
156
157 int GroupchangeAccessLevel(const void *vUser1, const void *vUser2)
158 {
159         UserListEntry *u1 = (UserListEntry*) vUser1;
160         UserListEntry *u2 = (UserListEntry*) vUser2;
161
162         return u2->AccessLevel != u1->AccessLevel;
163 }
164
165 /*
166  * Sort by UID
167  */
168 int CompareUID(const void *vUser1, const void *vUser2)
169 {
170         UserListEntry *u1 = (UserListEntry*) GetSearchPayload(vUser1);
171         UserListEntry *u2 = (UserListEntry*) GetSearchPayload(vUser2);
172
173         return (u1->UID > u2->UID);
174 }
175
176 int CompareUIDRev(const void *vUser1, const void *vUser2)
177 {
178         UserListEntry *u1 = (UserListEntry*) GetSearchPayload(vUser1);
179         UserListEntry *u2 = (UserListEntry*) GetSearchPayload(vUser2);
180
181         return (u2->UID > u1->UID);
182 }
183
184 int GroupchangeUID(const void *vUser1, const void *vUser2)
185 {
186         UserListEntry *u1 = (UserListEntry*) vUser1;
187         UserListEntry *u2 = (UserListEntry*) vUser2;
188
189         return (u2->UID / 10) != (u1->UID / 10);
190 }
191
192 /*
193  * Sort By Date /// TODO!
194  */
195 int CompareLastLogon(const void *vUser1, const void *vUser2)
196 {
197         UserListEntry *u1 = (UserListEntry*) GetSearchPayload(vUser1);
198         UserListEntry *u2 = (UserListEntry*) GetSearchPayload(vUser2);
199
200         return (u1->LastLogonT > u2->LastLogonT);
201 }
202
203 int CompareLastLogonRev(const void *vUser1, const void *vUser2)
204 {
205         UserListEntry *u1 = (UserListEntry*) GetSearchPayload(vUser1);
206         UserListEntry *u2 = (UserListEntry*) GetSearchPayload(vUser2);
207
208         return (u2->LastLogonT > u1->LastLogonT);
209 }
210
211 int GroupchangeLastLogon(const void *vUser1, const void *vUser2)
212 {
213         UserListEntry *u1 = (UserListEntry*) vUser1;
214         UserListEntry *u2 = (UserListEntry*) vUser2;
215
216         return (u2->LastLogonT != u1->LastLogonT);
217 }
218
219 /*
220  * Sort By Number of Logons
221  */
222 int ComparenLogons(const void *vUser1, const void *vUser2)
223 {
224         UserListEntry *u1 = (UserListEntry*) GetSearchPayload(vUser1);
225         UserListEntry *u2 = (UserListEntry*) GetSearchPayload(vUser2);
226
227         return (u1->nLogons > u2->nLogons);
228 }
229
230 int ComparenLogonsRev(const void *vUser1, const void *vUser2)
231 {
232         UserListEntry *u1 = (UserListEntry*) GetSearchPayload(vUser1);
233         UserListEntry *u2 = (UserListEntry*) GetSearchPayload(vUser2);
234
235         return (u2->nLogons > u1->nLogons);
236 }
237
238 int GroupchangenLogons(const void *vUser1, const void *vUser2)
239 {
240         UserListEntry *u1 = (UserListEntry*) vUser1;
241         UserListEntry *u2 = (UserListEntry*) vUser2;
242
243         return (u2->nLogons / 100) != (u1->nLogons / 100);
244 }
245
246 /*
247  * Sort By Number of Posts
248  */
249 int ComparenPosts(const void *vUser1, const void *vUser2)
250 {
251         UserListEntry *u1 = (UserListEntry*) GetSearchPayload(vUser1);
252         UserListEntry *u2 = (UserListEntry*) GetSearchPayload(vUser2);
253
254         return (u1->nPosts > u2->nPosts);
255 }
256
257 int ComparenPostsRev(const void *vUser1, const void *vUser2)
258 {
259         UserListEntry *u1 = (UserListEntry*) GetSearchPayload(vUser1);
260         UserListEntry *u2 = (UserListEntry*) GetSearchPayload(vUser2);
261
262         return (u2->nPosts > u1->nPosts);
263 }
264
265 int GroupchangenPosts(const void *vUser1, const void *vUser2)
266 {
267         UserListEntry *u1 = (UserListEntry*) vUser1;
268         UserListEntry *u2 = (UserListEntry*) vUser2;
269
270         return (u2->nPosts / 100) != (u1->nPosts / 100);
271 }
272
273
274 HashList *iterate_load_userlist(StrBuf *Target, WCTemplputParams *TP)
275 {
276         int Done = 0;
277         CompareFunc SortIt;
278         HashList *Hash = NULL;
279         StrBuf *Buf;
280         UserListEntry* ul;
281         int len;
282         int UID;
283         void *vData;
284         WCTemplputParams SubTP;
285
286         memset(&SubTP, 0, sizeof(WCTemplputParams));    
287         serv_puts("LIST");
288         Buf = NewStrBuf();
289         StrBuf_ServGetln(Buf);
290         if (GetServerStatus(Buf, NULL) == 1) {
291                 Hash = NewHash(1, Flathash);
292                 Done = 0;
293                 while (!Done) {
294                         len = StrBuf_ServGetln(Buf);
295                         if ((len <0) || 
296                             ((len == 3) &&
297                              !strcmp(ChrPtr(Buf), "000")))
298                         {
299                                 Done = 1;
300                                 break;
301                         }
302                         ul = NewUserListEntry(Buf);
303                         if (ul == NULL)
304                                 continue;
305
306                         Put(Hash, IKEY(ul->UID), ul, DeleteUserListEntry); 
307                 }
308
309                 serv_puts("LBIO 1");
310                 StrBuf_ServGetln(Buf);
311                 if (GetServerStatus(Buf, NULL) == 1) {
312                         Done = 0;
313                         while (!Done) {
314                                 len = StrBuf_ServGetln(Buf);
315                                 if ((len <0) || ((len == 3) && !strcmp(ChrPtr(Buf), "000")))
316                                 {
317                                         Done = 1;
318                                         break;
319                                 }
320                         }
321                         UID = atoi(ChrPtr(Buf));
322                         if (GetHash(Hash, IKEY(UID), &vData) && vData != 0)
323                         {
324                                 ul = (UserListEntry*)vData;
325                                 ul->HasBio = 1;
326                         }
327                 }
328                 SubTP.Filter.ContextType = CTX_USERLIST;
329                 SortIt = RetrieveSort(&SubTP, HKEY("USER"), HKEY("user:uid"), 0);
330                 if (SortIt != NULL)
331                         SortByPayload(Hash, SortIt);
332                 else 
333                         SortByPayload(Hash, CompareUID);
334         }
335         FreeStrBuf(&Buf);
336         return Hash;
337 }
338
339
340 void tmplput_USERLIST_UserName(StrBuf *Target, WCTemplputParams *TP)
341 {
342         UserListEntry *ul = (UserListEntry*) CTX(CTX_USERLIST);
343         StrBufAppendTemplate(Target, TP, ul->UserName, 0);
344 }
345
346 void tmplput_USERLIST_Password(StrBuf *Target, WCTemplputParams *TP)
347 {
348         UserListEntry *ul = (UserListEntry*) CTX(CTX_USERLIST);
349         StrBufAppendTemplate(Target, TP, ul->Passvoid, 0);
350 }
351
352 void tmplput_USERLIST_PrimaryEmail(StrBuf *Target, WCTemplputParams *TP)
353 {
354         UserListEntry *ul = (UserListEntry*) CTX(CTX_USERLIST);
355         StrBufAppendTemplate(Target, TP, ul->PrimaryEmail, 0);
356 }
357
358 void tmplput_USERLIST_OtherEmails(StrBuf *Target, WCTemplputParams *TP)
359 {
360         UserListEntry *ul = (UserListEntry*) CTX(CTX_USERLIST);
361         StrBufAppendTemplate(Target, TP, ul->OtherEmails, 0);
362 }
363
364 void tmplput_USERLIST_AccessLevelNo(StrBuf *Target, WCTemplputParams *TP)
365 {
366         UserListEntry *ul = (UserListEntry*) CTX(CTX_USERLIST);
367
368         StrBufAppendPrintf(Target, "%d", ul->AccessLevel, 0);
369 }
370
371 void tmplput_USERLIST_AccessLevelStr(StrBuf *Target, WCTemplputParams *TP)
372 {
373         UserListEntry *ul = (UserListEntry*) CTX(CTX_USERLIST);
374         
375         StrBufAppendBufPlain(Target, _(axdefs[ul->AccessLevel]), -1, 0);
376 }
377
378 void tmplput_USERLIST_UID(StrBuf *Target, WCTemplputParams *TP)
379 {
380         UserListEntry *ul = (UserListEntry*) CTX(CTX_USERLIST);
381
382         StrBufAppendPrintf(Target, "%d", ul->UID, 0);
383 }
384
385
386 void tmplput_USERLIST_LastLogonNo(StrBuf *Target, WCTemplputParams *TP)
387 {
388         UserListEntry *ul = (UserListEntry*) CTX(CTX_USERLIST);
389
390         StrBufAppendPrintf(Target,"%ld", ul->LastLogonT, 0);
391 }
392
393
394 void tmplput_USERLIST_LastLogonStr(StrBuf *Target, WCTemplputParams *TP)
395 {
396         UserListEntry *ul = (UserListEntry*) CTX(CTX_USERLIST);
397         StrEscAppend(Target, NULL, asctime(localtime(&ul->LastLogonT)), 0, 0);
398 }
399
400
401 void tmplput_USERLIST_nLogons(StrBuf *Target, WCTemplputParams *TP)
402 {
403         UserListEntry *ul = (UserListEntry*) CTX(CTX_USERLIST);
404
405         StrBufAppendPrintf(Target, "%d", ul->nLogons, 0);
406 }
407
408
409 void tmplput_USERLIST_nPosts(StrBuf *Target, WCTemplputParams *TP)
410 {
411         UserListEntry *ul = (UserListEntry*) CTX(CTX_USERLIST);
412
413         StrBufAppendPrintf(Target, "%d", ul->nPosts, 0);
414 }
415
416
417 void tmplput_USERLIST_Flags(StrBuf *Target, WCTemplputParams *TP)
418 {
419         UserListEntry *ul = (UserListEntry*) CTX(CTX_USERLIST);
420
421         StrBufAppendPrintf(Target, "%d", ul->Flags, 0);
422 }
423
424
425 void tmplput_USERLIST_DaysTillPurge(StrBuf *Target, WCTemplputParams *TP)
426 {
427         UserListEntry *ul = (UserListEntry*) CTX(CTX_USERLIST);
428
429         StrBufAppendPrintf(Target, "%d", ul->DaysTillPurge, 0);
430 }
431
432
433 int ConditionalUser(StrBuf *Target, WCTemplputParams *TP)
434 {
435         UserListEntry *ul = (UserListEntry*) CTX(CTX_USERLIST);
436         if (havebstr("usernum")) {
437                 return ibstr("usernum") == ul->UID;
438         }
439         else if (havebstr("username")) {
440                 return strcmp(bstr("username"), ChrPtr(ul->UserName)) == 0;
441         }
442         else 
443                 return 0;
444 }
445
446
447 int ConditionalFlagINetEmail(StrBuf *Target, WCTemplputParams *TP)
448 {
449         UserListEntry *ul = (UserListEntry*) CTX(CTX_USERLIST);
450         return (ul->Flags & US_INTERNET) != 0;
451 }
452
453
454 int ConditionalUserAccess(StrBuf *Target, WCTemplputParams *TP)
455 {
456         UserListEntry *ul = (UserListEntry*) CTX(CTX_USERLIST);
457         
458         if (ul == NULL)
459                 return 0;
460
461         return GetTemplateTokenNumber(Target, 
462                                       TP, 
463                                       3, 
464                                       AxNewU)
465                 ==
466                 ul->AccessLevel;
467 }
468
469
470 int ConditionalHaveBIO(StrBuf *Target, WCTemplputParams *TP)
471 {
472         UserListEntry *ul = (UserListEntry*) CTX(CTX_USERLIST);
473         
474         if (ul == NULL)
475                 return 0;
476         return ul->HasBio;
477 }
478
479
480 int ConditionalSuppressEmailFields(StrBuf *Target, WCTemplputParams *TP)
481 {
482         return 0;               // FIXME this makes all email fields display
483 }
484
485
486 void tmplput_USER_BIO(StrBuf *Target, WCTemplputParams *TP)
487 {
488         int Done = 0;
489         StrBuf *Buf;
490         const char *who;
491         long len;
492
493         GetTemplateTokenString(Target, TP, 0, &who, &len);
494         if (len == 0) {
495                 who = ChrPtr(WC->wc_fullname);
496         }
497
498         Buf = NewStrBuf();
499         serv_printf("RBIO %s", who);
500         StrBuf_ServGetln(Buf);
501         if (GetServerStatus(Buf, NULL) == 1) {
502                 StrBuf *BioBuf = NewStrBufPlain(NULL, SIZ);
503                 while (!Done && StrBuf_ServGetln(Buf)>=0) {
504                         if ( (StrLength(Buf)==3) && 
505                              !strcmp(ChrPtr(Buf), "000")) 
506                                 Done = 1;
507                         else {
508                                 StrBufAppendBuf(BioBuf, Buf, 0);
509                                 StrBufAppendBufPlain(BioBuf, HKEY("\n"), 0);
510                         }
511                 }
512                 StrBufAppendTemplate(Target, TP, BioBuf, 1);
513                 FreeStrBuf(&BioBuf);
514         }
515         FreeStrBuf(&Buf);
516 }
517
518
519 int Conditional_USER_HAS_PIC(StrBuf *Target, WCTemplputParams *TP)
520 {
521         // ajc 2016apr10 this needs to be re-evaluated with the new protocol
522         return(0);
523 }
524
525
526 /*
527  *  Locate the message number of a user's vCard in the current room
528  *  Returns the message id of his vcard
529  */
530 long locate_user_vcard_in_this_room(message_summary **VCMsg, wc_mime_attachment **VCAtt)
531 {
532         wcsession *WCC = WC;
533         HashPos *at;
534         HashPos *att;
535         const char *HashKey;
536         long HKLen;
537         void *vMsg;
538         message_summary *Msg;
539         wc_mime_attachment *Att;
540         StrBuf *Buf;
541         long vcard_msgnum = (-1L);
542         int already_tried_creating_one = 0;
543         StrBuf *FoundCharset = NewStrBuf();
544         StrBuf *Error = NULL;
545         SharedMessageStatus Stat;
546
547
548         Buf = NewStrBuf();
549 TRYAGAIN:
550         memset(&Stat, 0, sizeof(SharedMessageStatus));
551         Stat.maxload = 10000;
552         Stat.lowest_found = (-1);
553         Stat.highest_found = (-1);
554         /* Search for the user's vCard */
555         if (load_msg_ptrs("MSGS ALL||||1", NULL, NULL, &Stat, NULL, NULL, NULL, NULL, 0) > 0) {
556                 at = GetNewHashPos(WCC->summ, 0);
557                 while (GetNextHashPos(WCC->summ, at, &HKLen, &HashKey, &vMsg)) {
558                         Msg = (message_summary*) vMsg;          
559                         Msg->MsgBody =  (wc_mime_attachment*) malloc(sizeof(wc_mime_attachment));
560                         memset(Msg->MsgBody, 0, sizeof(wc_mime_attachment));
561                         Msg->MsgBody->msgnum = Msg->msgnum;
562
563                         load_message(Msg, FoundCharset, &Error);
564                         
565                         if (Msg->AllAttach != NULL) {
566                                 att = GetNewHashPos(Msg->AllAttach, 0);
567                                 while (GetNextHashPos(Msg->AllAttach, att, &HKLen, &HashKey, &vMsg) && 
568                                        (vcard_msgnum == -1)) {
569                                         Att = (wc_mime_attachment*) vMsg;
570                                         if (
571                                                 (strcasecmp(ChrPtr(Att->ContentType), "text/x-vcard") == 0)
572                                                 || (strcasecmp(ChrPtr(Att->ContentType), "text/vcard") == 0)
573                                         ) {
574                                                 *VCAtt = Att;
575                                                 *VCMsg = Msg;
576                                                 vcard_msgnum = Msg->msgnum;
577                                                 if (Att->Data == NULL) {
578                                                         MimeLoadData(Att);
579                                                 }
580                                         }
581                                 }
582                                 DeleteHashPos(&att);
583                         }
584                         FreeStrBuf(&Error);     /* don't care... */
585                         
586                 }
587                 DeleteHashPos(&at);             
588         }
589
590         /* If there's no vcard, create one */
591         if ((*VCMsg == NULL) && (already_tried_creating_one == 0)) {
592                 FlushStrBuf(Buf);
593                 already_tried_creating_one = 1;
594                 serv_puts("ENT0 1|||4");
595                 StrBuf_ServGetln(Buf);
596                 if (GetServerStatus(Buf, NULL) == 4) {
597                         serv_puts("Content-type: text/x-vcard");
598                         serv_puts("");
599                         serv_puts("begin:vcard");
600                         serv_puts("end:vcard");
601                         serv_puts("000");
602                 }
603                 else 
604                         syslog(LOG_WARNING, "Error while creating user vcard: %s\n", ChrPtr(Buf));
605                 goto TRYAGAIN;
606         }
607         FreeStrBuf(&Buf);
608         FreeStrBuf(&FoundCharset);
609
610         return(vcard_msgnum);
611 }
612
613
614 /*
615  *  Display the form for editing a user's address book entry
616  *  username the name of the user
617  *  usernum the citadel-uid of the user
618  */
619 void display_edit_address_book_entry(const char *username, long usernum) {
620         message_summary *VCMsg = NULL;
621         wc_mime_attachment *VCAtt = NULL;
622         StrBuf *roomname;
623         StrBuf *Buf;
624         long vcard_msgnum = (-1L);
625
626         /* Locate the user's config room, creating it if necessary */
627         Buf = NewStrBuf();
628         roomname = NewStrBuf();
629         StrBufPrintf(roomname, "%010ld.%s", usernum, USERCONFIGROOM);
630         serv_printf("GOTO %s||1", ChrPtr(roomname));
631         StrBuf_ServGetln(Buf);
632         if (GetServerStatus(Buf, NULL) != 2) {
633                 serv_printf("CRE8 1|%s|5|||1|", ChrPtr(roomname));
634                 StrBuf_ServGetln(Buf);
635                 GetServerStatus(Buf, NULL);
636                 serv_printf("GOTO %s||1", ChrPtr(roomname));
637                 StrBuf_ServGetln(Buf);
638                 if (GetServerStatusMsg(Buf, NULL, 1, 2) != 2) {
639                         select_user_to_edit(username);
640                         FreeStrBuf(&Buf);
641                         FreeStrBuf(&roomname);
642                         return;
643                 }
644         }
645         FreeStrBuf(&Buf);
646
647         locate_user_vcard_in_this_room(&VCMsg, &VCAtt);
648
649         if (VCMsg == NULL) {
650                 AppendImportantMessage(_("An error occurred while trying to create or edit this address book entry."), -1);
651                 select_user_to_edit(username);
652                 FreeStrBuf(&roomname);
653                 return;
654         }
655
656         do_edit_vcard(vcard_msgnum, "1", 
657                       VCMsg,
658                       VCAtt,
659                       "select_user_to_edit", 
660                       ChrPtr(roomname));
661         FreeStrBuf(&roomname);
662 }
663
664 /*
665  *  purge a user 
666  *  username the name of the user to remove
667  */
668 void delete_user(char *username) {
669         StrBuf *Buf;
670         
671         Buf = NewStrBuf();
672         serv_printf("ASUP %s|0|0|0|0|0|", username);
673         StrBuf_ServGetln(Buf);
674         GetServerStatusMsg(Buf, NULL, 1, 2);
675
676         select_user_to_edit( bstr("username"));
677         FreeStrBuf(&Buf);
678 }
679                 
680
681 void display_edituser(const char *supplied_username, int is_new) {
682         const char *Pos;
683         UserListEntry* UL;
684         StrBuf *Buf;
685         char username[256];
686         int i = 0;
687
688         if (supplied_username != NULL) {
689                 safestrncpy(username, supplied_username, sizeof username);
690         }
691         else {
692                 safestrncpy(username, bstr("username"), sizeof username);
693         }
694
695         Buf = NewStrBuf();
696         serv_printf("AGUP %s", username);
697         StrBuf_ServGetln(Buf);
698         if (GetServerStatusMsg(Buf, NULL, 1, 2) != 2) {
699                 select_user_to_edit(username);
700                 FreeStrBuf(&Buf);
701                 return;
702         }
703         else {
704                 Pos = ChrPtr(Buf) + 4;
705                 UL = NewUserListOneEntry(Buf, Pos);
706                 if ((UL != NULL) && havebstr("edit_abe_button")) {
707                         display_edit_address_book_entry(username, UL->UID);
708                 }
709                 else if ((UL != NULL) && havebstr("delete_button")) {
710                         delete_user(username);
711                 }
712                 else if (UL != NULL) {
713
714                         serv_printf("AGEA %s", username);
715                         StrBuf_ServGetln(Buf);
716                         if (GetServerStatusMsg(Buf, NULL, 1, 2) == 1) {
717                                 while(StrBuf_ServGetln(Buf) , strcmp(ChrPtr(Buf), "000")) {
718                                         if (i == 0) {
719                                                 StrBufAppendPrintf(UL->PrimaryEmail, "%s", ChrPtr(Buf));
720                                         }
721                                         if (i > 1) {
722                                                 StrBufAppendPrintf(UL->OtherEmails, ",");
723                                         }
724                                         if (i > 0) {
725                                                 StrBufAppendPrintf(UL->OtherEmails, "%s", ChrPtr(Buf));
726                                         }
727                                         ++i;
728                                 }
729                         }
730
731                         WCTemplputParams SubTP;
732                         memset(&SubTP, 0, sizeof(WCTemplputParams));
733                         SubTP.Filter.ContextType = CTX_USERLIST;
734                         SubTP.Context = UL;
735                         output_headers(1, 0, 0, 0, 1, 0);
736                         DoTemplate(HKEY("aide_edituser_detailview"), NULL, &SubTP);
737                         end_burst();
738                 }
739                 DeleteUserListEntry(UL);
740                 
741         }
742         FreeStrBuf(&Buf);
743 }
744
745 /*
746  *  do the backend operation of the user edit on the server
747  */
748 void edituser(void) {
749         int is_new = 0;
750         unsigned int flags = 0;
751         const char *username;
752
753         is_new = ibstr("is_new");
754         username = bstr("username");
755
756         if (!havebstr("ok_button")) {
757                 AppendImportantMessage(_("Changes were not saved."), -1);
758         }       
759         else {
760                 StrBuf *Buf = NewStrBuf();
761
762                 flags = ibstr("flags");
763                 if (yesbstr("inetmail")) {
764                         flags |= US_INTERNET;
765                 }
766                 else {
767                         flags &= ~US_INTERNET ;
768                 }
769
770                 if ((havebstr("newname")) && (strcasecmp(bstr("username"), bstr("newname")))) {
771                         serv_printf("RENU %s|%s", bstr("username"), bstr("newname"));
772                         StrBuf_ServGetln(Buf);
773                         if (GetServerStatusMsg(Buf, NULL, 1, 2) != 2) {
774                                 username = bstr("newname");
775                         }
776                 }
777
778                 /* Send the new account parameters */
779                 serv_printf("ASUP %s|%s|%d|%s|%s|%s|%s|%s|%s|",
780                         username,
781                         bstr("password"),
782                         flags,
783                         bstr("timescalled"),
784                         bstr("msgsposted"),
785                         bstr("axlevel"),
786                         bstr("usernum"),
787                         bstr("lastcall"),
788                         bstr("purgedays")
789                 );
790                 StrBuf_ServGetln(Buf);
791                 GetServerStatusMsg(Buf, NULL, 1, 2);
792
793                 /* Send the new email addresses.  First make up a delimited list... */
794                 char all_the_emails[512];
795                 snprintf(all_the_emails, sizeof all_the_emails, "%s,%s", bstr("primaryemail"), bstr("otheremails"));
796
797                 /* Replace any commas, semicolons, or spaces with newlines */
798                 char *pos;
799                 for (pos=all_the_emails; *pos!=0; ++pos) {
800                         if ((*pos == ',') || (*pos == ';') || (*pos == ' ')) *pos = '\n' ;
801                 }
802
803                 /* Remove any naughty inappropriate whitespace */
804                 striplt(all_the_emails);
805                 while (pos = strstr(all_the_emails, "\n,"), (pos != NULL)) {
806                         strcpy(pos, pos+1);
807                 }
808                 while (pos = strstr(all_the_emails, ",\n"), (pos != NULL)) {
809                         strcpy(pos+1, pos+2);
810                 }
811                 while (pos = strstr(all_the_emails, "\n\n"), (pos != NULL)) {
812                         strcpy(pos+1, pos+2);
813                 }
814
815                 /* Now send it to the server. */
816                 serv_printf("ASEA %s", username);
817                 StrBuf_ServGetln(Buf);
818                 if (GetServerStatusMsg(Buf, NULL, 1, 2) == 4) {
819                         serv_printf("%s\n000", all_the_emails);
820                 }
821
822                 FreeStrBuf(&Buf);
823         }
824
825         /*
826          * If we are in the middle of creating a new user, move on to
827          * the vCard edit screen.
828          */
829         if (is_new) {
830                 display_edit_address_book_entry(username, lbstr("usernum") );
831         }
832         else {
833                 select_user_to_edit(username);
834         }
835 }
836
837
838 /*
839  * create a new user
840  * (take the web environment username and create it on the citadel server)
841  */
842 void create_user(void) {
843         long FullState;
844         StrBuf *Buf;
845         const char *username;
846
847         Buf = NewStrBuf();
848         username = bstr("username");
849         serv_printf("CREU %s", username);
850         StrBuf_ServGetln(Buf);
851         if (GetServerStatus(Buf, &FullState) == 2) {
852                 AppendImportantMessage(_("A new user has been created."), -1);
853                 display_edituser(username, 1);
854         }
855         else if (FullState == 570) {
856                 AppendImportantMessage(_("You are attempting to create a new user from within Citadel "
857                                          "while running in host based authentication mode.  In this mode, "
858                                          "you must create new users on the host system, not within Citadel."), 
859                                        -1);
860                 select_user_to_edit(NULL);
861         }
862         else {
863                 AppendImportantMessage(ChrPtr(Buf) + 4, StrLength(Buf) - 4);
864                 select_user_to_edit(NULL);
865         }
866         FreeStrBuf(&Buf);
867 }
868
869
870 void display_userpic(void) {
871         off_t bytes;
872         StrBuf *Buf = NewStrBuf();
873         const char *username = bstr("user");
874         serv_printf("DLUI %s", username);
875         StrBuf_ServGetln(Buf);
876         if (GetServerStatus(Buf, NULL) == 6) {
877                 StrBufCutLeft(Buf, 4);
878                 bytes = StrBufExtract_long(Buf, 0, '|');
879                 StrBuf *content_type = NewStrBuf();
880                 StrBufExtract_token(content_type, Buf, 3, '|');
881                 WC->WBuf = NewStrBuf();
882                 StrBuf_ServGetBLOBBuffered(WC->WBuf, bytes);
883                 http_transmit_thing(ChrPtr(content_type), 0);
884                 FreeStrBuf(&content_type);
885         }
886         else {
887                 output_error_pic("", "");
888         }
889         FreeStrBuf(&Buf);
890 }
891
892
893 void _select_user_to_edit(void) {
894         select_user_to_edit(NULL);
895 }
896
897
898 void _display_edituser(void) {
899         display_edituser(NULL, 0);
900 }
901
902
903 void 
904 InitModule_USEREDIT
905 (void)
906 {
907         RegisterCTX(CTX_USERLIST);
908         WebcitAddUrlHandler(HKEY("select_user_to_edit"), "", 0, _select_user_to_edit, 0);
909         WebcitAddUrlHandler(HKEY("display_edituser"), "", 0, _display_edituser, 0);
910         WebcitAddUrlHandler(HKEY("edituser"), "", 0, edituser, 0);
911         WebcitAddUrlHandler(HKEY("create_user"), "", 0, create_user, 0);
912         WebcitAddUrlHandler(HKEY("userpic"), "", 0, display_userpic, 0);
913
914         RegisterNamespace("USERLIST:USERNAME",      0, 1, tmplput_USERLIST_UserName, NULL, CTX_USERLIST);
915         RegisterNamespace("USERLIST:PASSWD",        0, 1, tmplput_USERLIST_Password, NULL, CTX_USERLIST);
916         RegisterNamespace("USERLIST:ACCLVLNO",      0, 0, tmplput_USERLIST_AccessLevelNo, NULL, CTX_USERLIST);
917         RegisterNamespace("USERLIST:ACCLVLSTR",     0, 0, tmplput_USERLIST_AccessLevelStr, NULL, CTX_USERLIST);
918         RegisterNamespace("USERLIST:UID",           0, 0, tmplput_USERLIST_UID, NULL, CTX_USERLIST);
919         RegisterNamespace("USERLIST:LASTLOGON:STR", 0, 0, tmplput_USERLIST_LastLogonStr, NULL, CTX_USERLIST);
920         RegisterNamespace("USERLIST:LASTLOGON:NO",  0, 0, tmplput_USERLIST_LastLogonNo, NULL, CTX_USERLIST);
921         RegisterNamespace("USERLIST:NLOGONS",       0, 0, tmplput_USERLIST_nLogons, NULL, CTX_USERLIST);
922         RegisterNamespace("USERLIST:NPOSTS",        0, 0, tmplput_USERLIST_nPosts, NULL, CTX_USERLIST);
923         RegisterNamespace("USERLIST:PRIMARYEMAIL",  0, 1, tmplput_USERLIST_PrimaryEmail, NULL, CTX_USERLIST);
924         RegisterNamespace("USERLIST:OTHEREMAILS",   0, 1, tmplput_USERLIST_OtherEmails, NULL, CTX_USERLIST);
925         RegisterNamespace("USERLIST:FLAGS",         0, 0, tmplput_USERLIST_Flags, NULL, CTX_USERLIST);
926         RegisterNamespace("USERLIST:DAYSTILLPURGE", 0, 0, tmplput_USERLIST_DaysTillPurge, NULL, CTX_USERLIST);
927
928         RegisterNamespace("USER:BIO", 1, 2, tmplput_USER_BIO,  NULL, CTX_NONE);
929
930         RegisterConditional("COND:USERNAME",                    0,      ConditionalUser,                CTX_USERLIST);
931         RegisterConditional("COND:USERACCESS",                  0,      ConditionalUserAccess,          CTX_USERLIST);
932         RegisterConditional("COND:USERLIST:FLAG:USE_INTERNET",  0,      ConditionalFlagINetEmail,       CTX_USERLIST);
933         RegisterConditional("COND:USERLIST:HAVEBIO",            0,      ConditionalHaveBIO,             CTX_USERLIST);
934         RegisterConditional("COND:USER:PIC",                    1,      Conditional_USER_HAS_PIC,       CTX_NONE);
935
936         RegisterIterator("USERLIST", 0, NULL, iterate_load_userlist, NULL, DeleteHash, CTX_USERLIST, CTX_NONE, IT_FLAG_DETECT_GROUPCHANGE);
937
938         RegisterSortFunc(HKEY("user:name"),
939                          HKEY("userlist"),
940                          CompareUserListName,
941                          CompareUserListNameRev,
942                          GroupchangeUserListName,
943                          CTX_USERLIST);
944         RegisterSortFunc(HKEY("user:accslvl"),
945                          HKEY("userlist"),
946                          CompareAccessLevel,
947                          CompareAccessLevelRev,
948                          GroupchangeAccessLevel,
949                          CTX_USERLIST);
950
951         RegisterSortFunc(HKEY("user:nlogons"),
952                          HKEY("userlist"),
953                          ComparenLogons,
954                          ComparenLogonsRev,
955                          GroupchangenLogons,
956                          CTX_USERLIST);
957
958         RegisterSortFunc(HKEY("user:uid"),
959                          HKEY("userlist"),
960                          CompareUID,
961                          CompareUIDRev,
962                          GroupchangeUID,
963                          CTX_USERLIST);
964
965         RegisterSortFunc(HKEY("user:lastlogon"),
966                          HKEY("userlist"),
967                          CompareLastLogon,
968                          CompareLastLogonRev,
969                          GroupchangeLastLogon,
970                          CTX_USERLIST);
971
972         RegisterSortFunc(HKEY("user:nmsgposts"),
973                          HKEY("userlist"),
974                          ComparenPosts,
975                          ComparenPostsRev,
976                          GroupchangenPosts,
977                          CTX_USERLIST);
978
979         REGISTERTokenParamDefine(AxDeleted);
980         REGISTERTokenParamDefine(AxNewU);
981         REGISTERTokenParamDefine(AxProbU);
982         REGISTERTokenParamDefine(AxLocU);
983         REGISTERTokenParamDefine(AxNetU);
984         REGISTERTokenParamDefine(AxPrefU);
985         REGISTERTokenParamDefine(AxAideU);
986 }
987