A bit of prep work to bring back the global alias table. This time I want to be...
[citadel] / citadel / internet_addressing.c
1 /*
2  * This file contains functions which handle the mapping of Internet addresses
3  * to users on the Citadel system.
4  *
5  * Copyright (c) 1987-2021 by the citadel.org team
6  *
7  * This program is open source software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License version 3.
9  *
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  * GNU General Public License for more details.
14  */
15
16 #include "sysdep.h"
17 #include <stdlib.h>
18 #include <unistd.h>
19 #include <stdio.h>
20 #include <fcntl.h>
21 #include <ctype.h>
22 #include <signal.h>
23 #include <pwd.h>
24 #include <errno.h>
25 #include <sys/types.h>
26 #include <time.h>
27 #include <sys/wait.h>
28 #include <string.h>
29 #include <limits.h>
30 #include <libcitadel.h>
31 #include "citadel.h"
32 #include "server.h"
33 #include "sysdep_decls.h"
34 #include "citserver.h"
35 #include "support.h"
36 #include "config.h"
37 #include "msgbase.h"
38 #include "internet_addressing.h"
39 #include "user_ops.h"
40 #include "room_ops.h"
41 #include "parsedate.h"
42 #include "database.h"
43 #include "ctdl_module.h"
44 #ifdef HAVE_ICONV
45 #include <iconv.h>
46
47 #if 0
48 /* This is the non-define version in case it is needed for debugging */
49 inline void FindNextEnd (char *bptr, char *end)
50 {
51         /* Find the next ?Q? */
52         end = strchr(bptr + 2, '?');
53         if (end == NULL) return NULL;
54         if (((*(end + 1) == 'B') || (*(end + 1) == 'Q')) && 
55             (*(end + 2) == '?')) {
56                 /* skip on to the end of the cluster, the next ?= */
57                 end = strstr(end + 3, "?=");
58         }
59         else
60                 /* sort of half valid encoding, try to find an end. */
61                 end = strstr(bptr, "?=");
62 }
63 #endif
64
65 #define FindNextEnd(bptr, end) { \
66         end = strchr(bptr + 2, '?'); \
67         if (end != NULL) { \
68                 if (((*(end + 1) == 'B') || (*(end + 1) == 'Q')) && (*(end + 2) == '?')) { \
69                         end = strstr(end + 3, "?="); \
70                 } else end = strstr(bptr, "?="); \
71         } \
72 }
73
74 /*
75  * Handle subjects with RFC2047 encoding such as:
76  * =?koi8-r?B?78bP0s3Mxc7JxSDXz9rE1dvO2c3JINvB0sHNySDP?=
77  */
78 void utf8ify_rfc822_string(char *buf) {
79         char *start, *end, *next, *nextend, *ptr;
80         char newbuf[1024];
81         char charset[128];
82         char encoding[16];
83         char istr[1024];
84         iconv_t ic = (iconv_t)(-1) ;
85         char *ibuf;                     // Buffer of characters to be converted
86         char *obuf;                     // Buffer for converted characters
87         size_t ibuflen;                 // Length of input buffer
88         size_t obuflen;                 // Length of output buffer
89         char *isav;                     // Saved pointer to input buffer
90         char *osav;                     // Saved pointer to output buffer
91         int passes = 0;
92         int i, len, delta;
93         int illegal_non_rfc2047_encoding = 0;
94
95         /* Sometimes, badly formed messages contain strings which were simply
96          * written out directly in some foreign character set instead of
97          * using RFC2047 encoding.  This is illegal but we will attempt to
98          * handle it anyway by converting from a user-specified default
99          * charset to UTF-8 if we see any nonprintable characters.
100          */
101         len = strlen(buf);
102         for (i=0; i<len; ++i) {
103                 if ((buf[i] < 32) || (buf[i] > 126)) {
104                         illegal_non_rfc2047_encoding = 1;
105                         i = len;        // take a shortcut, it won't be more than one.
106                 }
107         }
108         if (illegal_non_rfc2047_encoding) {
109                 const char *default_header_charset = "iso-8859-1";
110                 if ( (strcasecmp(default_header_charset, "UTF-8")) && (strcasecmp(default_header_charset, "us-ascii")) ) {
111                         ctdl_iconv_open("UTF-8", default_header_charset, &ic);
112                         if (ic != (iconv_t)(-1) ) {
113                                 ibuf = malloc(1024);
114                                 isav = ibuf;
115                                 safestrncpy(ibuf, buf, 1024);
116                                 ibuflen = strlen(ibuf);
117                                 obuflen = 1024;
118                                 obuf = (char *) malloc(obuflen);
119                                 osav = obuf;
120                                 iconv(ic, &ibuf, &ibuflen, &obuf, &obuflen);
121                                 osav[1024-obuflen] = 0;
122                                 strcpy(buf, osav);
123                                 free(osav);
124                                 iconv_close(ic);
125                                 free(isav);
126                         }
127                 }
128         }
129
130         /* pre evaluate the first pair */
131         nextend = end = NULL;
132         len = strlen(buf);
133         start = strstr(buf, "=?");
134         if (start != NULL) 
135                 FindNextEnd (start, end);
136
137         while ((start != NULL) && (end != NULL)) {
138                 next = strstr(end, "=?");
139                 if (next != NULL)
140                         FindNextEnd(next, nextend);
141                 if (nextend == NULL)
142                         next = NULL;
143
144                 /* did we find two partitions */
145                 if ((next != NULL) && ((next - end) > 2)) {
146                         ptr = end + 2;
147                         while ((ptr < next) && 
148                                (isspace(*ptr) ||
149                                 (*ptr == '\r') ||
150                                 (*ptr == '\n') || 
151                                 (*ptr == '\t')))
152                                 ptr ++;
153                         /* did we find a gab just filled with blanks? */
154                         if (ptr == next)
155                         {
156                                 memmove (end + 2,
157                                          next,
158                                          len - (next - start));
159
160                                 /* now terminate the gab at the end */
161                                 delta = (next - end) - 2;
162                                 len -= delta;
163                                 buf[len] = '\0';
164
165                                 /* move next to its new location. */
166                                 next -= delta;
167                                 nextend -= delta;
168                         }
169                 }
170                 /* our next-pair is our new first pair now. */
171                 start = next;
172                 end = nextend;
173         }
174
175         /* Now we handle foreign character sets properly encoded
176          * in RFC2047 format.
177          */
178         start = strstr(buf, "=?");
179         FindNextEnd((start != NULL)? start : buf, end);
180         while (start != NULL && end != NULL && end > start) {
181                 extract_token(charset, start, 1, '?', sizeof charset);
182                 extract_token(encoding, start, 2, '?', sizeof encoding);
183                 extract_token(istr, start, 3, '?', sizeof istr);
184
185                 ibuf = malloc(1024);
186                 isav = ibuf;
187                 if (!strcasecmp(encoding, "B")) {       // base64
188                         ibuflen = CtdlDecodeBase64(ibuf, istr, strlen(istr));
189                 }
190                 else if (!strcasecmp(encoding, "Q")) {  // quoted-printable
191                         size_t len;
192                         unsigned long pos;
193                         
194                         len = strlen(istr);
195                         pos = 0;
196                         while (pos < len) {
197                                 if (istr[pos] == '_') istr[pos] = ' ';
198                                 pos++;
199                         }
200                         ibuflen = CtdlDecodeQuotedPrintable(ibuf, istr, len);
201                 }
202                 else {
203                         strcpy(ibuf, istr);             // unknown encoding
204                         ibuflen = strlen(istr);
205                 }
206
207                 ctdl_iconv_open("UTF-8", charset, &ic);
208                 if (ic != (iconv_t)(-1) ) {
209                         obuflen = 1024;
210                         obuf = (char *) malloc(obuflen);
211                         osav = obuf;
212                         iconv(ic, &ibuf, &ibuflen, &obuf, &obuflen);
213                         osav[1024-obuflen] = 0;
214
215                         end = start;
216                         end++;
217                         strcpy(start, "");
218                         remove_token(end, 0, '?');
219                         remove_token(end, 0, '?');
220                         remove_token(end, 0, '?');
221                         remove_token(end, 0, '?');
222                         strcpy(end, &end[1]);
223
224                         snprintf(newbuf, sizeof newbuf, "%s%s%s", buf, osav, end);
225                         strcpy(buf, newbuf);
226                         free(osav);
227                         iconv_close(ic);
228                 }
229                 else {
230                         end = start;
231                         end++;
232                         strcpy(start, "");
233                         remove_token(end, 0, '?');
234                         remove_token(end, 0, '?');
235                         remove_token(end, 0, '?');
236                         remove_token(end, 0, '?');
237                         strcpy(end, &end[1]);
238
239                         snprintf(newbuf, sizeof newbuf, "%s(unreadable)%s", buf, end);
240                         strcpy(buf, newbuf);
241                 }
242
243                 free(isav);
244
245                 /*
246                  * Since spammers will go to all sorts of absurd lengths to get their
247                  * messages through, there are LOTS of corrupt headers out there.
248                  * So, prevent a really badly formed RFC2047 header from throwing
249                  * this function into an infinite loop.
250                  */
251                 ++passes;
252                 if (passes > 20) return;
253
254                 start = strstr(buf, "=?");
255                 FindNextEnd((start != NULL)? start : buf, end);
256         }
257
258 }
259 #else
260 inline void utf8ify_rfc822_string(char *a){};
261
262 #endif
263
264
265 struct trynamebuf {
266         char buffer1[SIZ];
267         char buffer2[SIZ];
268 };
269
270 char *inetcfg = NULL;
271
272 /*
273  * Return nonzero if the supplied name is an alias for this host.
274  */
275 int CtdlHostAlias(char *fqdn) {
276         int config_lines;
277         int i;
278         char buf[256];
279         char host[256], type[256];
280         int found = 0;
281
282         if (fqdn == NULL)                                       return(hostalias_nomatch);
283         if (IsEmptyStr(fqdn))                                   return(hostalias_nomatch);
284         if (!strcasecmp(fqdn, "localhost"))                     return(hostalias_localhost);
285         if (!strcasecmp(fqdn, CtdlGetConfigStr("c_fqdn")))      return(hostalias_localhost);
286         if (!strcasecmp(fqdn, CtdlGetConfigStr("c_nodename")))  return(hostalias_localhost);
287         if (inetcfg == NULL)                                    return(hostalias_nomatch);
288
289         config_lines = num_tokens(inetcfg, '\n');
290         for (i=0; i<config_lines; ++i) {
291                 extract_token(buf, inetcfg, i, '\n', sizeof buf);
292                 extract_token(host, buf, 0, '|', sizeof host);
293                 extract_token(type, buf, 1, '|', sizeof type);
294
295                 found = 0;
296
297                 /* Process these in a specific order, in case there are multiple matches.
298                  * We want localhost to override masq, for example.
299                  */
300
301                 if ( (!strcasecmp(type, "masqdomain")) && (!strcasecmp(fqdn, host))) {
302                         found = hostalias_masq;
303                 }
304
305                 if ( (!strcasecmp(type, "localhost")) && (!strcasecmp(fqdn, host))) {
306                         found = hostalias_localhost;
307                 }
308
309                 // "directory" used to be a distributed version of "localhost" but they're both the same now
310                 if ( (!strcasecmp(type, "directory")) && (!strcasecmp(fqdn, host))) {
311                         found = hostalias_localhost;
312                 }
313
314                 if (found) return(found);
315         }
316         return(hostalias_nomatch);
317 }
318
319
320 /*
321  * Determine whether a given Internet address belongs to the current user
322  */
323 int CtdlIsMe(char *addr, int addr_buf_len)
324 {
325         struct recptypes *recp;
326         int i;
327
328         recp = validate_recipients(addr, NULL, 0);
329         if (recp == NULL) return(0);
330
331         if (recp->num_local == 0) {
332                 free_recipients(recp);
333                 return(0);
334         }
335
336         for (i=0; i<recp->num_local; ++i) {
337                 extract_token(addr, recp->recp_local, i, '|', addr_buf_len);
338                 if (!strcasecmp(addr, CC->user.fullname)) {
339                         free_recipients(recp);
340                         return(1);
341                 }
342         }
343
344         free_recipients(recp);
345         return(0);
346 }
347
348
349 /* If the last item in a list of recipients was truncated to a partial address,
350  * remove it completely in order to avoid choking library functions.
351  */
352 void sanitize_truncated_recipient(char *str)
353 {
354         if (!str) return;
355         if (num_tokens(str, ',') < 2) return;
356
357         int len = strlen(str);
358         if (len < 900) return;
359         if (len > 998) str[998] = 0;
360
361         char *cptr = strrchr(str, ',');
362         if (!cptr) return;
363
364         char *lptr = strchr(cptr, '<');
365         char *rptr = strchr(cptr, '>');
366
367         if ( (lptr) && (rptr) && (rptr > lptr) ) return;
368
369         *cptr = 0;
370 }
371
372
373 /*
374  * This function is self explanatory.
375  * (What can I say, I'm in a weird mood today...)
376  */
377 void remove_any_whitespace_to_the_left_or_right_of_at_symbol(char *name) {
378         char *ptr;
379         if (!name) return;
380
381         for (ptr=name; *ptr; ++ptr) {
382                 while ( (isspace(*ptr)) && (*(ptr+1)=='@') ) {
383                         strcpy(ptr, ptr+1);
384                         if (ptr > name) --ptr;
385                 }
386                 while ( (*ptr=='@') && (*(ptr+1)!=0) && (isspace(*(ptr+1))) ) {
387                         strcpy(ptr+1, ptr+2);
388                 }
389         }
390 }
391
392
393 /*
394  * Aliasing for network mail.
395  */
396 int alias(char *name) {                         /* process alias and routing info for mail */
397         int a;
398         char aaa[SIZ];
399         int at = 0;
400         char node[64];
401
402         char original_name[256];
403         safestrncpy(original_name, name, sizeof original_name);
404
405         striplt(name);
406         remove_any_whitespace_to_the_left_or_right_of_at_symbol(name);
407         stripallbut(name, '<', '>');
408
409         /* Hit the email address directory */
410         if (CtdlDirectoryLookup(aaa, name, sizeof aaa) == 0) {
411                 strcpy(name, aaa);
412         }
413
414         if (strcasecmp(original_name, name)) {
415                 syslog(LOG_INFO, "internet_addressing: %s is being forwarded to %s", original_name, name);
416         }
417
418         /* Change "user @ xxx" to "user" if xxx is an alias for this host */
419         for (a=0; name[a] != '\0'; ++a) {
420                 if (name[a] == '@') {
421                         if (CtdlHostAlias(&name[a+1]) == hostalias_localhost) {
422                                 name[a] = 0;
423                                 syslog(LOG_DEBUG, "internet_addressing: changed to <%s>", name);
424                                 break;
425                         }
426                 }
427         }
428
429         /* determine local or remote type, see citadel.h */
430         at = haschar(name, '@');
431         if (at == 0) return(MES_LOCAL);         /* no @'s - local address */
432         if (at > 1) return(MES_ERROR);          /* >1 @'s - invalid address */
433         remove_any_whitespace_to_the_left_or_right_of_at_symbol(name);
434
435         /* figure out the delivery mode */
436         extract_token(node, name, 1, '@', sizeof node);
437
438         /* If there are one or more dots in the nodename, we assume that it
439          * is an FQDN and will attempt SMTP delivery to the Internet.
440          */
441         if (haschar(node, '.') > 0) {
442                 return(MES_INTERNET);
443         }
444
445         /* If we get to this point it's an invalid node name */
446         return (MES_ERROR);
447 }
448
449
450 /*
451  * Validate recipients, count delivery types and errors, and handle aliasing
452  * FIXME check for dupes!!!!!
453  *
454  * Returns 0 if all addresses are ok, ret->num_error = -1 if no addresses 
455  * were specified, or the number of addresses found invalid.
456  *
457  * Caller needs to free the result using free_recipients()
458  */
459 struct recptypes *validate_recipients(const char *supplied_recipients, const char *RemoteIdentifier, int Flags) {
460         struct recptypes *ret;
461         char *recipients = NULL;
462         char *org_recp;
463         char this_recp[256];
464         char this_recp_cooked[256];
465         char append[SIZ];
466         long len;
467         int i, j;
468         int mailtype;
469         int invalid;
470         struct ctdluser tempUS;
471         struct ctdlroom tempQR;
472         struct ctdlroom tempQR2;
473         int err = 0;
474         char errmsg[SIZ];
475         int in_quotes = 0;
476
477         /* Initialize */
478         ret = (struct recptypes *) malloc(sizeof(struct recptypes));
479         if (ret == NULL) return(NULL);
480
481         /* Set all strings to null and numeric values to zero */
482         memset(ret, 0, sizeof(struct recptypes));
483
484         if (supplied_recipients == NULL) {
485                 recipients = strdup("");
486         }
487         else {
488                 recipients = strdup(supplied_recipients);
489         }
490
491         /* Allocate some memory.  Yes, this allocates 500% more memory than we will
492          * actually need, but it's healthier for the heap than doing lots of tiny
493          * realloc() calls instead.
494          */
495         len = strlen(recipients) + 1024;
496         ret->errormsg = malloc(len);
497         ret->recp_local = malloc(len);
498         ret->recp_internet = malloc(len);
499         ret->recp_room = malloc(len);
500         ret->display_recp = malloc(len);
501         ret->recp_orgroom = malloc(len);
502         org_recp = malloc(len);
503
504         ret->errormsg[0] = 0;
505         ret->recp_local[0] = 0;
506         ret->recp_internet[0] = 0;
507         ret->recp_room[0] = 0;
508         ret->recp_orgroom[0] = 0;
509         ret->display_recp[0] = 0;
510
511         ret->recptypes_magic = RECPTYPES_MAGIC;
512
513         /* Change all valid separator characters to commas */
514         for (i=0; !IsEmptyStr(&recipients[i]); ++i) {
515                 if ((recipients[i] == ';') || (recipients[i] == '|')) {
516                         recipients[i] = ',';
517                 }
518         }
519
520         /* Now start extracting recipients... */
521         Array *recp_array = array_new(1024);
522         while (!IsEmptyStr(recipients)) {
523                 for (i=0; i<=strlen(recipients); ++i) {
524                         if (recipients[i] == '\"') in_quotes = 1 - in_quotes;
525                         if ( ( (recipients[i] == ',') && (!in_quotes) ) || (recipients[i] == 0) ) {
526                                 safestrncpy(this_recp, recipients, i+1);
527                                 this_recp[i] = 0;
528                                 if (recipients[i] == ',') {
529                                         strcpy(recipients, &recipients[i+1]);
530                                 }
531                                 else {
532                                         strcpy(recipients, "");
533                                 }
534                                 break;
535                         }
536                 }
537
538                 striplt(this_recp);
539                 if (IsEmptyStr(this_recp))
540                         break;
541                 syslog(LOG_DEBUG, "internet_addressing: evaluating recipient: %s", this_recp);
542                 array_append(recp_array, this_recp);
543         }
544
545         for (int r=0; r<array_len(recp_array); ++r) {
546                 strcpy(this_recp, (char *)array_get_element_at(recp_array, r));
547
548                 strcpy(org_recp, this_recp);
549                 alias(this_recp);
550                 alias(this_recp);
551                 mailtype = alias(this_recp);
552
553                 for (j = 0; !IsEmptyStr(&this_recp[j]); ++j) {
554                         if (this_recp[j]=='_') {
555                                 this_recp_cooked[j] = ' ';
556                         }
557                         else {
558                                 this_recp_cooked[j] = this_recp[j];
559                         }
560                 }
561                 this_recp_cooked[j] = '\0';
562                 invalid = 0;
563                 errmsg[0] = 0;
564                 switch(mailtype) {
565                 case MES_LOCAL:
566                         if (!strcasecmp(this_recp, "sysop")) {
567                                 ++ret->num_room;
568                                 strcpy(this_recp, CtdlGetConfigStr("c_aideroom"));
569                                 if (!IsEmptyStr(ret->recp_room)) {
570                                         strcat(ret->recp_room, "|");
571                                 }
572                                 strcat(ret->recp_room, this_recp);
573                         }
574                         else if ( (!strncasecmp(this_recp, "room_", 5)) && (!CtdlGetRoom(&tempQR, &this_recp_cooked[5])) ) {
575
576                                 /* Save room so we can restore it later */
577                                 tempQR2 = CC->room;
578                                 CC->room = tempQR;
579                                         
580                                 /* Check permissions to send mail to this room */
581                                 err = CtdlDoIHavePermissionToPostInThisRoom(
582                                         errmsg, 
583                                         sizeof errmsg, 
584                                         RemoteIdentifier,
585                                         Flags,
586                                         0                       /* 0 = not a reply */
587                                         );
588                                 if (err) {
589                                         ++ret->num_error;
590                                         invalid = 1;
591                                 } 
592                                 else {
593                                         ++ret->num_room;
594                                         if (!IsEmptyStr(ret->recp_room)) {
595                                                 strcat(ret->recp_room, "|");
596                                         }
597                                         strcat(ret->recp_room, &this_recp_cooked[5]);
598
599                                         if (!IsEmptyStr(ret->recp_orgroom)) {
600                                                 strcat(ret->recp_orgroom, "|");
601                                         }
602                                         strcat(ret->recp_orgroom, org_recp);
603
604                                 }
605                                         
606                                 /* Restore room in case something needs it */
607                                 CC->room = tempQR2;
608
609                         }
610                         else if (CtdlGetUser(&tempUS, this_recp) == 0) {
611                                 ++ret->num_local;
612                                 strcpy(this_recp, tempUS.fullname);
613                                 if (!IsEmptyStr(ret->recp_local)) {
614                                         strcat(ret->recp_local, "|");
615                                 }
616                                 strcat(ret->recp_local, this_recp);
617                         }
618                         else if (CtdlGetUser(&tempUS, this_recp_cooked) == 0) {
619                                 ++ret->num_local;
620                                 strcpy(this_recp, tempUS.fullname);
621                                 if (!IsEmptyStr(ret->recp_local)) {
622                                         strcat(ret->recp_local, "|");
623                                 }
624                                 strcat(ret->recp_local, this_recp);
625                         }
626                         else {
627                                 ++ret->num_error;
628                                 invalid = 1;
629                         }
630                         break;
631                 case MES_INTERNET:
632                         /* Yes, you're reading this correctly: if the target
633                          * domain points back to the local system,
634                          * the address is invalid.  That's
635                          * because if the address were valid, we would have
636                          * already translated it to a local address by now.
637                          */
638                         if (IsDirectory(this_recp, 0)) {
639                                 ++ret->num_error;
640                                 invalid = 1;
641                         }
642                         else {
643                                 ++ret->num_internet;
644                                 if (!IsEmptyStr(ret->recp_internet)) {
645                                         strcat(ret->recp_internet, "|");
646                                 }
647                                 strcat(ret->recp_internet, this_recp);
648                         }
649                         break;
650                 case MES_ERROR:
651                         ++ret->num_error;
652                         invalid = 1;
653                         break;
654                 }
655                 if (invalid) {
656                         if (IsEmptyStr(errmsg)) {
657                                 snprintf(append, sizeof append, "Invalid recipient: %s", this_recp);
658                         }
659                         else {
660                                 snprintf(append, sizeof append, "%s", errmsg);
661                         }
662                         if ( (strlen(ret->errormsg) + strlen(append) + 3) < SIZ) {
663                                 if (!IsEmptyStr(ret->errormsg)) {
664                                         strcat(ret->errormsg, "; ");
665                                 }
666                                 strcat(ret->errormsg, append);
667                         }
668                 }
669                 else {
670                         if (IsEmptyStr(ret->display_recp)) {
671                                 strcpy(append, this_recp);
672                         }
673                         else {
674                                 snprintf(append, sizeof append, ", %s", this_recp);
675                         }
676                         if ( (strlen(ret->display_recp)+strlen(append)) < SIZ) {
677                                 strcat(ret->display_recp, append);
678                         }
679                 }
680         }
681         free(org_recp);
682
683         if ( (ret->num_local + ret->num_internet + ret->num_room + ret->num_error) == 0) {
684                 ret->num_error = (-1);
685                 strcpy(ret->errormsg, "No recipients specified.");
686         }
687
688         syslog(LOG_DEBUG, "internet_addressing: validate_recipients() = %d local, %d room, %d SMTP, %d error",
689                 ret->num_local, ret->num_room, ret->num_internet, ret->num_error
690         );
691
692         free(recipients);
693         array_free(recp_array);
694
695         return(ret);
696 }
697
698
699 /*
700  * Destructor for recptypes
701  */
702 void free_recipients(struct recptypes *valid) {
703
704         if (valid == NULL) {
705                 return;
706         }
707
708         if (valid->recptypes_magic != RECPTYPES_MAGIC) {
709                 syslog(LOG_ERR, "internet_addressing: attempt to call free_recipients() on some other data type!");
710                 abort();
711         }
712
713         if (valid->errormsg != NULL)            free(valid->errormsg);
714         if (valid->recp_local != NULL)          free(valid->recp_local);
715         if (valid->recp_internet != NULL)       free(valid->recp_internet);
716         if (valid->recp_room != NULL)           free(valid->recp_room);
717         if (valid->recp_orgroom != NULL)        free(valid->recp_orgroom);
718         if (valid->display_recp != NULL)        free(valid->display_recp);
719         if (valid->bounce_to != NULL)           free(valid->bounce_to);
720         if (valid->envelope_from != NULL)       free(valid->envelope_from);
721         if (valid->sending_room != NULL)        free(valid->sending_room);
722         free(valid);
723 }
724
725
726 char *qp_encode_email_addrs(char *source) {
727         char *user, *node, *name;
728         const char headerStr[] = "=?UTF-8?Q?";
729         char *Encoded;
730         char *EncodedName;
731         char *nPtr;
732         int need_to_encode = 0;
733         long SourceLen;
734         long EncodedMaxLen;
735         long nColons = 0;
736         long *AddrPtr;
737         long *AddrUtf8;
738         long nAddrPtrMax = 50;
739         long nmax;
740         int InQuotes = 0;
741         int i, n;
742
743         if (source == NULL) return source;
744         if (IsEmptyStr(source)) return source;
745         syslog(LOG_DEBUG, "internet_addressing: qp_encode_email_addrs <%s>", source);
746
747         AddrPtr = malloc (sizeof (long) * nAddrPtrMax);
748         AddrUtf8 = malloc (sizeof (long) * nAddrPtrMax);
749         memset(AddrUtf8, 0, sizeof (long) * nAddrPtrMax);
750         *AddrPtr = 0;
751         i = 0;
752         while (!IsEmptyStr (&source[i])) {
753                 if (nColons >= nAddrPtrMax){
754                         long *ptr;
755
756                         ptr = (long *) malloc(sizeof (long) * nAddrPtrMax * 2);
757                         memcpy (ptr, AddrPtr, sizeof (long) * nAddrPtrMax);
758                         free (AddrPtr), AddrPtr = ptr;
759
760                         ptr = (long *) malloc(sizeof (long) * nAddrPtrMax * 2);
761                         memset(&ptr[nAddrPtrMax], 0, sizeof (long) * nAddrPtrMax);
762
763                         memcpy (ptr, AddrUtf8, sizeof (long) * nAddrPtrMax);
764                         free (AddrUtf8), AddrUtf8 = ptr;
765                         nAddrPtrMax *= 2;                               
766                 }
767                 if (((unsigned char) source[i] < 32) || ((unsigned char) source[i] > 126)) {
768                         need_to_encode = 1;
769                         AddrUtf8[nColons] = 1;
770                 }
771                 if (source[i] == '"') {
772                         InQuotes = !InQuotes;
773                 }
774                 if (!InQuotes && source[i] == ',') {
775                         AddrPtr[nColons] = i;
776                         nColons++;
777                 }
778                 i++;
779         }
780         if (need_to_encode == 0) {
781                 free(AddrPtr);
782                 free(AddrUtf8);
783                 return source;
784         }
785
786         SourceLen = i;
787         EncodedMaxLen = nColons * (sizeof(headerStr) + 3) + SourceLen * 3;
788         Encoded = (char*) malloc (EncodedMaxLen);
789
790         for (i = 0; i < nColons; i++) {
791                 source[AddrPtr[i]++] = '\0';
792         }
793         /* TODO: if libidn, this might get larger*/
794         user = malloc(SourceLen + 1);
795         node = malloc(SourceLen + 1);
796         name = malloc(SourceLen + 1);
797
798         nPtr = Encoded;
799         *nPtr = '\0';
800         for (i = 0; i < nColons && nPtr != NULL; i++) {
801                 nmax = EncodedMaxLen - (nPtr - Encoded);
802                 if (AddrUtf8[i]) {
803                         process_rfc822_addr(&source[AddrPtr[i]], user, node, name);
804                         /* TODO: libIDN here ! */
805                         if (IsEmptyStr(name)) {
806                                 n = snprintf(nPtr, nmax, (i==0)?"%s@%s" : ",%s@%s", user, node);
807                         }
808                         else {
809                                 EncodedName = rfc2047encode(name, strlen(name));                        
810                                 n = snprintf(nPtr, nmax, (i==0)?"%s <%s@%s>" : ",%s <%s@%s>", EncodedName, user, node);
811                                 free(EncodedName);
812                         }
813                 }
814                 else { 
815                         n = snprintf(nPtr, nmax, (i==0)?"%s" : ",%s", &source[AddrPtr[i]]);
816                 }
817                 if (n > 0 )
818                         nPtr += n;
819                 else { 
820                         char *ptr, *nnPtr;
821                         ptr = (char*) malloc(EncodedMaxLen * 2);
822                         memcpy(ptr, Encoded, EncodedMaxLen);
823                         nnPtr = ptr + (nPtr - Encoded), nPtr = nnPtr;
824                         free(Encoded), Encoded = ptr;
825                         EncodedMaxLen *= 2;
826                         i--; /* do it once more with properly lengthened buffer */
827                 }
828         }
829         for (i = 0; i < nColons; i++)
830                 source[--AddrPtr[i]] = ',';
831
832         free(user);
833         free(node);
834         free(name);
835         free(AddrUtf8);
836         free(AddrPtr);
837         return Encoded;
838 }
839
840
841 /*
842  * Unfold a multi-line field into a single line, removing multi-whitespaces
843  */
844 void unfold_rfc822_field(char **field, char **FieldEnd) 
845 {
846         int quote = 0;
847         char *pField = *field;
848         char *sField;
849         char *pFieldEnd = *FieldEnd;
850
851         while (isspace(*pField))
852                 pField++;
853         /* remove leading/trailing whitespace */
854         ;
855
856         while (isspace(*pFieldEnd))
857                 pFieldEnd --;
858
859         *FieldEnd = pFieldEnd;
860         /* convert non-space whitespace to spaces, and remove double blanks */
861         for (sField = *field = pField; 
862              sField < pFieldEnd; 
863              pField++, sField++)
864         {
865                 if ((*sField=='\r') || (*sField=='\n'))
866                 {
867                         int offset = 1;
868                         while ( ( (*(sField + offset) == '\r') || (*(sField + offset) == '\n' )) && (sField + offset < pFieldEnd) ) {
869                                 offset ++;
870                         }
871                         sField += offset;
872                         *pField = *sField;
873                 }
874                 else {
875                         if (*sField=='\"') quote = 1 - quote;
876                         if (!quote) {
877                                 if (isspace(*sField)) {
878                                         *pField = ' ';
879                                         pField++;
880                                         sField++;
881                                         
882                                         while ((sField < pFieldEnd) && 
883                                                isspace(*sField))
884                                                 sField++;
885                                         *pField = *sField;
886                                 }
887                                 else *pField = *sField;
888                         }
889                         else *pField = *sField;
890                 }
891         }
892         *pField = '\0';
893         *FieldEnd = pField - 1;
894 }
895
896
897 /*
898  * Split an RFC822-style address into userid, host, and full name
899  *
900  */
901 void process_rfc822_addr(const char *rfc822, char *user, char *node, char *name) {
902         int a;
903
904         strcpy(user, "");
905         strcpy(node, CtdlGetConfigStr("c_fqdn"));
906         strcpy(name, "");
907
908         if (rfc822 == NULL) return;
909
910         /* extract full name - first, it's From minus <userid> */
911         strcpy(name, rfc822);
912         stripout(name, '<', '>');
913
914         /* strip anything to the left of a bang */
915         while ((!IsEmptyStr(name)) && (haschar(name, '!') > 0))
916                 strcpy(name, &name[1]);
917
918         /* and anything to the right of a @ or % */
919         for (a = 0; name[a] != '\0'; ++a) {
920                 if (name[a] == '@') {
921                         name[a] = 0;
922                         break;
923                 }
924                 if (name[a] == '%') {
925                         name[a] = 0;
926                         break;
927                 }
928         }
929
930         /* but if there are parentheses, that changes the rules... */
931         if ((haschar(rfc822, '(') == 1) && (haschar(rfc822, ')') == 1)) {
932                 strcpy(name, rfc822);
933                 stripallbut(name, '(', ')');
934         }
935
936         /* but if there are a set of quotes, that supersedes everything */
937         if (haschar(rfc822, 34) == 2) {
938                 strcpy(name, rfc822);
939                 while ((!IsEmptyStr(name)) && (name[0] != 34)) {
940                         strcpy(&name[0], &name[1]);
941                 }
942                 strcpy(&name[0], &name[1]);
943                 for (a = 0; name[a] != '\0'; ++a)
944                         if (name[a] == 34) {
945                                 name[a] = 0;
946                                 break;
947                         }
948         }
949         /* extract user id */
950         strcpy(user, rfc822);
951
952         /* first get rid of anything in parens */
953         stripout(user, '(', ')');
954
955         /* if there's a set of angle brackets, strip it down to that */
956         if ((haschar(user, '<') == 1) && (haschar(user, '>') == 1)) {
957                 stripallbut(user, '<', '>');
958         }
959
960         /* strip anything to the left of a bang */
961         while ((!IsEmptyStr(user)) && (haschar(user, '!') > 0))
962                 strcpy(user, &user[1]);
963
964         /* and anything to the right of a @ or % */
965         for (a = 0; user[a] != '\0'; ++a) {
966                 if (user[a] == '@') {
967                         user[a] = 0;
968                         break;
969                 }
970                 if (user[a] == '%') {
971                         user[a] = 0;
972                         break;
973                 }
974         }
975
976
977         /* extract node name */
978         strcpy(node, rfc822);
979
980         /* first get rid of anything in parens */
981         stripout(node, '(', ')');
982
983         /* if there's a set of angle brackets, strip it down to that */
984         if ((haschar(node, '<') == 1) && (haschar(node, '>') == 1)) {
985                 stripallbut(node, '<', '>');
986         }
987
988         /* If no node specified, tack ours on instead */
989         if (
990                 (haschar(node, '@')==0)
991                 && (haschar(node, '%')==0)
992                 && (haschar(node, '!')==0)
993         ) {
994                 strcpy(node, CtdlGetConfigStr("c_nodename"));
995         }
996         else {
997
998                 /* strip anything to the left of a @ */
999                 while ((!IsEmptyStr(node)) && (haschar(node, '@') > 0))
1000                         strcpy(node, &node[1]);
1001         
1002                 /* strip anything to the left of a % */
1003                 while ((!IsEmptyStr(node)) && (haschar(node, '%') > 0))
1004                         strcpy(node, &node[1]);
1005         
1006                 /* reduce multiple system bang paths to node!user */
1007                 while ((!IsEmptyStr(node)) && (haschar(node, '!') > 1))
1008                         strcpy(node, &node[1]);
1009         
1010                 /* now get rid of the user portion of a node!user string */
1011                 for (a = 0; node[a] != '\0'; ++a)
1012                         if (node[a] == '!') {
1013                                 node[a] = 0;
1014                                 break;
1015                         }
1016         }
1017
1018         /* strip leading and trailing spaces in all strings */
1019         striplt(user);
1020         striplt(node);
1021         striplt(name);
1022
1023         /* If we processed a string that had the address in angle brackets
1024          * but no name outside the brackets, we now have an empty name.  In
1025          * this case, use the user portion of the address as the name.
1026          */
1027         if ((IsEmptyStr(name)) && (!IsEmptyStr(user))) {
1028                 strcpy(name, user);
1029         }
1030 }
1031
1032
1033 /*
1034  * convert_field() is a helper function for convert_internet_message().
1035  * Given start/end positions for an rfc822 field, it converts it to a Citadel
1036  * field if it wants to, and unfolds it if necessary.
1037  *
1038  * Returns 1 if the field was converted and inserted into the Citadel message
1039  * structure, implying that the source field should be removed from the
1040  * message text.
1041  */
1042 int convert_field(struct CtdlMessage *msg, const char *beg, const char *end) {
1043         char *key, *value, *valueend;
1044         long len;
1045         const char *pos;
1046         int i;
1047         const char *colonpos = NULL;
1048         int processed = 0;
1049         char user[1024];
1050         char node[1024];
1051         char name[1024];
1052         char addr[1024];
1053         time_t parsed_date;
1054         long valuelen;
1055
1056         for (pos = end; pos >= beg; pos--) {
1057                 if (*pos == ':') colonpos = pos;
1058         }
1059
1060         if (colonpos == NULL) return(0);        /* no colon? not a valid header line */
1061
1062         len = end - beg;
1063         key = malloc(len + 2);
1064         memcpy(key, beg, len + 1);
1065         key[len] = '\0';
1066         valueend = key + len;
1067         * ( key + (colonpos - beg) ) = '\0';
1068         value = &key[(colonpos - beg) + 1];
1069 /*      printf("Header: [%s]\nValue: [%s]\n", key, value); */
1070         unfold_rfc822_field(&value, &valueend);
1071         valuelen = valueend - value + 1;
1072 /*      printf("UnfoldedValue: [%s]\n", value); */
1073
1074         /*
1075          * Here's the big rfc822-to-citadel loop.
1076          */
1077
1078         /* Date/time is converted into a unix timestamp.  If the conversion
1079          * fails, we replace it with the time the message arrived locally.
1080          */
1081         if (!strcasecmp(key, "Date")) {
1082                 parsed_date = parsedate(value);
1083                 if (parsed_date < 0L) parsed_date = time(NULL);
1084
1085                 if (CM_IsEmpty(msg, eTimestamp))
1086                         CM_SetFieldLONG(msg, eTimestamp, parsed_date);
1087                 processed = 1;
1088         }
1089
1090         else if (!strcasecmp(key, "From")) {
1091                 process_rfc822_addr(value, user, node, name);
1092                 syslog(LOG_DEBUG, "internet_addressing: converted to <%s@%s> (%s)", user, node, name);
1093                 snprintf(addr, sizeof(addr), "%s@%s", user, node);
1094                 if (CM_IsEmpty(msg, eAuthor) && !IsEmptyStr(name)) {
1095                         CM_SetField(msg, eAuthor, name, -1);
1096                 }
1097                 if (CM_IsEmpty(msg, erFc822Addr) && !IsEmptyStr(addr)) {
1098                         CM_SetField(msg, erFc822Addr, addr, -1);
1099                 }
1100                 processed = 1;
1101         }
1102
1103         else if (!strcasecmp(key, "Subject")) {
1104                 if (CM_IsEmpty(msg, eMsgSubject))
1105                         CM_SetField(msg, eMsgSubject, value, valuelen);
1106                 processed = 1;
1107         }
1108
1109         else if (!strcasecmp(key, "List-ID")) {
1110                 if (CM_IsEmpty(msg, eListID))
1111                         CM_SetField(msg, eListID, value, valuelen);
1112                 processed = 1;
1113         }
1114
1115         else if (!strcasecmp(key, "To")) {
1116                 if (CM_IsEmpty(msg, eRecipient))
1117                         CM_SetField(msg, eRecipient, value, valuelen);
1118                 processed = 1;
1119         }
1120
1121         else if (!strcasecmp(key, "CC")) {
1122                 if (CM_IsEmpty(msg, eCarbonCopY))
1123                         CM_SetField(msg, eCarbonCopY, value, valuelen);
1124                 processed = 1;
1125         }
1126
1127         else if (!strcasecmp(key, "Message-ID")) {
1128                 if (!CM_IsEmpty(msg, emessageId)) {
1129                         syslog(LOG_WARNING, "internet_addressing: duplicate message id");
1130                 }
1131                 else {
1132                         char *pValue;
1133                         long pValueLen;
1134
1135                         pValue = value;
1136                         pValueLen = valuelen;
1137                         /* Strip angle brackets */
1138                         while (haschar(pValue, '<') > 0) {
1139                                 pValue ++;
1140                                 pValueLen --;
1141                         }
1142
1143                         for (i = 0; i <= pValueLen; ++i)
1144                                 if (pValue[i] == '>') {
1145                                         pValueLen = i;
1146                                         break;
1147                                 }
1148
1149                         CM_SetField(msg, emessageId, pValue, pValueLen);
1150                 }
1151
1152                 processed = 1;
1153         }
1154
1155         else if (!strcasecmp(key, "Return-Path")) {
1156                 if (CM_IsEmpty(msg, eMessagePath))
1157                         CM_SetField(msg, eMessagePath, value, valuelen);
1158                 processed = 1;
1159         }
1160
1161         else if (!strcasecmp(key, "Envelope-To")) {
1162                 if (CM_IsEmpty(msg, eenVelopeTo))
1163                         CM_SetField(msg, eenVelopeTo, value, valuelen);
1164                 processed = 1;
1165         }
1166
1167         else if (!strcasecmp(key, "References")) {
1168                 CM_SetField(msg, eWeferences, value, valuelen);
1169                 processed = 1;
1170         }
1171
1172         else if (!strcasecmp(key, "Reply-To")) {
1173                 CM_SetField(msg, eReplyTo, value, valuelen);
1174                 processed = 1;
1175         }
1176
1177         else if (!strcasecmp(key, "In-reply-to")) {
1178                 if (CM_IsEmpty(msg, eWeferences)) /* References: supersedes In-reply-to: */
1179                         CM_SetField(msg, eWeferences, value, valuelen);
1180                 processed = 1;
1181         }
1182
1183
1184
1185         /* Clean up and move on. */
1186         free(key);      /* Don't free 'value', it's actually the same buffer */
1187         return processed;
1188 }
1189
1190
1191 /*
1192  * Convert RFC822 references format (References) to Citadel references format (Weferences)
1193  */
1194 void convert_references_to_wefewences(char *str) {
1195         int bracket_nesting = 0;
1196         char *ptr = str;
1197         char *moveptr = NULL;
1198         char ch;
1199
1200         while(*ptr) {
1201                 ch = *ptr;
1202                 if (ch == '>') {
1203                         --bracket_nesting;
1204                         if (bracket_nesting < 0) bracket_nesting = 0;
1205                 }
1206                 if ((ch == '>') && (bracket_nesting == 0) && (*(ptr+1)) && (ptr>str) ) {
1207                         *ptr = '|';
1208                         ++ptr;
1209                 }
1210                 else if (bracket_nesting > 0) {
1211                         ++ptr;
1212                 }
1213                 else {
1214                         moveptr = ptr;
1215                         while (*moveptr) {
1216                                 *moveptr = *(moveptr+1);
1217                                 ++moveptr;
1218                         }
1219                 }
1220                 if (ch == '<') ++bracket_nesting;
1221         }
1222
1223 }
1224
1225
1226 /*
1227  * Convert an RFC822 message (headers + body) to a CtdlMessage structure.
1228  * NOTE: the supplied buffer becomes part of the CtdlMessage structure, and
1229  * will be deallocated when CM_Free() is called.  Therefore, the
1230  * supplied buffer should be DEREFERENCED.  It should not be freed or used
1231  * again.
1232  */
1233 struct CtdlMessage *convert_internet_message(char *rfc822) {
1234         StrBuf *RFCBuf = NewStrBufPlain(rfc822, -1);
1235         free (rfc822);
1236         return convert_internet_message_buf(&RFCBuf);
1237 }
1238
1239
1240 struct CtdlMessage *convert_internet_message_buf(StrBuf **rfc822)
1241 {
1242         struct CtdlMessage *msg;
1243         const char *pos, *beg, *end, *totalend;
1244         int done, alldone = 0;
1245         int converted;
1246         StrBuf *OtherHeaders;
1247
1248         msg = malloc(sizeof(struct CtdlMessage));
1249         if (msg == NULL) return msg;
1250
1251         memset(msg, 0, sizeof(struct CtdlMessage));
1252         msg->cm_magic = CTDLMESSAGE_MAGIC;      /* self check */
1253         msg->cm_anon_type = 0;                  /* never anonymous */
1254         msg->cm_format_type = FMT_RFC822;       /* internet message */
1255
1256         pos = ChrPtr(*rfc822);
1257         totalend = pos + StrLength(*rfc822);
1258         done = 0;
1259         OtherHeaders = NewStrBufPlain(NULL, StrLength(*rfc822));
1260
1261         while (!alldone) {
1262
1263                 /* Locate beginning and end of field, keeping in mind that
1264                  * some fields might be multiline
1265                  */
1266                 end = beg = pos;
1267
1268                 while ((end < totalend) && 
1269                        (end == beg) && 
1270                        (done == 0) ) 
1271                 {
1272
1273                         if ( (*pos=='\n') && ((*(pos+1))!=0x20) && ((*(pos+1))!=0x09) )
1274                         {
1275                                 end = pos;
1276                         }
1277
1278                         /* done with headers? */
1279                         if ((*pos=='\n') &&
1280                             ( (*(pos+1)=='\n') ||
1281                               (*(pos+1)=='\r')) ) 
1282                         {
1283                                 alldone = 1;
1284                         }
1285
1286                         if (pos >= (totalend - 1) )
1287                         {
1288                                 end = pos;
1289                                 done = 1;
1290                         }
1291
1292                         ++pos;
1293
1294                 }
1295
1296                 /* At this point we have a field.  Are we interested in it? */
1297                 converted = convert_field(msg, beg, end);
1298
1299                 /* Strip the field out of the RFC822 header if we used it */
1300                 if (!converted) {
1301                         StrBufAppendBufPlain(OtherHeaders, beg, end - beg, 0);
1302                         StrBufAppendBufPlain(OtherHeaders, HKEY("\n"), 0);
1303                 }
1304
1305                 /* If we've hit the end of the message, bail out */
1306                 if (pos >= totalend)
1307                         alldone = 1;
1308         }
1309         StrBufAppendBufPlain(OtherHeaders, HKEY("\n"), 0);
1310         if (pos < totalend)
1311                 StrBufAppendBufPlain(OtherHeaders, pos, totalend - pos, 0);
1312         FreeStrBuf(rfc822);
1313         CM_SetAsFieldSB(msg, eMesageText, &OtherHeaders);
1314
1315         /* Follow-up sanity checks... */
1316
1317         /* If there's no timestamp on this message, set it to now. */
1318         if (CM_IsEmpty(msg, eTimestamp)) {
1319                 CM_SetFieldLONG(msg, eTimestamp, time(NULL));
1320         }
1321
1322         /* If a W (references, or rather, Wefewences) field is present, we
1323          * have to convert it from RFC822 format to Citadel format.
1324          */
1325         if (!CM_IsEmpty(msg, eWeferences)) {
1326                 /// todo: API!
1327                 convert_references_to_wefewences(msg->cm_fields[eWeferences]);
1328         }
1329
1330         return msg;
1331 }
1332
1333
1334 /*
1335  * Look for a particular header field in an RFC822 message text.  If the
1336  * requested field is found, it is unfolded (if necessary) and returned to
1337  * the caller.  The field name is stripped out, leaving only its contents.
1338  * The caller is responsible for freeing the returned buffer.  If the requested
1339  * field is not present, or anything else goes wrong, it returns NULL.
1340  */
1341 char *rfc822_fetch_field(const char *rfc822, const char *fieldname) {
1342         char *fieldbuf = NULL;
1343         const char *end_of_headers;
1344         const char *field_start;
1345         const char *ptr;
1346         char *cont;
1347         char fieldhdr[SIZ];
1348
1349         /* Should never happen, but sometimes we get stupid */
1350         if (rfc822 == NULL) return(NULL);
1351         if (fieldname == NULL) return(NULL);
1352
1353         snprintf(fieldhdr, sizeof fieldhdr, "%s:", fieldname);
1354
1355         /* Locate the end of the headers, so we don't run past that point */
1356         end_of_headers = cbmstrcasestr(rfc822, "\n\r\n");
1357         if (end_of_headers == NULL) {
1358                 end_of_headers = cbmstrcasestr(rfc822, "\n\n");
1359         }
1360         if (end_of_headers == NULL) return (NULL);
1361
1362         field_start = cbmstrcasestr(rfc822, fieldhdr);
1363         if (field_start == NULL) return(NULL);
1364         if (field_start > end_of_headers) return(NULL);
1365
1366         fieldbuf = malloc(SIZ);
1367         strcpy(fieldbuf, "");
1368
1369         ptr = field_start;
1370         ptr = cmemreadline(ptr, fieldbuf, SIZ-strlen(fieldbuf) );
1371         while ( (isspace(ptr[0])) && (ptr < end_of_headers) ) {
1372                 strcat(fieldbuf, " ");
1373                 cont = &fieldbuf[strlen(fieldbuf)];
1374                 ptr = cmemreadline(ptr, cont, SIZ-strlen(fieldbuf) );
1375                 striplt(cont);
1376         }
1377
1378         strcpy(fieldbuf, &fieldbuf[strlen(fieldhdr)]);
1379         striplt(fieldbuf);
1380
1381         return(fieldbuf);
1382 }
1383
1384
1385 /*****************************************************************************
1386  *                      DIRECTORY MANAGEMENT FUNCTIONS                       *
1387  *****************************************************************************/
1388
1389 /*
1390  * Generate the index key for an Internet e-mail address to be looked up
1391  * in the database.
1392  */
1393 void directory_key(char *key, char *addr) {
1394         int i;
1395         int keylen = 0;
1396
1397         for (i=0; !IsEmptyStr(&addr[i]); ++i) {
1398                 if (!isspace(addr[i])) {
1399                         key[keylen++] = tolower(addr[i]);
1400                 }
1401         }
1402         key[keylen++] = 0;
1403
1404         syslog(LOG_DEBUG, "internet_addressing: directory key is <%s>", key);
1405 }
1406
1407
1408 /*
1409  * Return nonzero if the supplied address is in one of "our" domains
1410  */
1411 int IsDirectory(char *addr, int allow_masq_domains) {
1412         char domain[256];
1413         int h;
1414
1415         extract_token(domain, addr, 1, '@', sizeof domain);
1416         striplt(domain);
1417
1418         h = CtdlHostAlias(domain);
1419
1420         if ( (h == hostalias_masq) && allow_masq_domains)
1421                 return(1);
1422         
1423         if (h == hostalias_localhost) {
1424                 return(1);
1425         }
1426         else {
1427                 return(0);
1428         }
1429 }
1430
1431
1432 /*
1433  * Add an Internet e-mail address to the directory for a user
1434  */
1435 int CtdlDirectoryAddUser(char *internet_addr, char *citadel_addr) {
1436         char key[SIZ];
1437
1438         if (IsDirectory(internet_addr, 0) == 0) {
1439                 return 0;
1440         }
1441         syslog(LOG_DEBUG, "internet_addressing: create directory entry: %s --> %s", internet_addr, citadel_addr);
1442         directory_key(key, internet_addr);
1443         cdb_store(CDB_DIRECTORY, key, strlen(key), citadel_addr, strlen(citadel_addr)+1 );
1444         return 1;
1445 }
1446
1447
1448 /*
1449  * Delete an Internet e-mail address from the directory.
1450  *
1451  * (NOTE: we don't actually use or need the citadel_addr variable; it's merely
1452  * here because the callback API expects to be able to send it.)
1453  */
1454 int CtdlDirectoryDelUser(char *internet_addr, char *citadel_addr) {
1455         char key[SIZ];
1456         
1457         syslog(LOG_DEBUG, "internet_addressing: delete directory entry: %s --> %s", internet_addr, citadel_addr);
1458         directory_key(key, internet_addr);
1459         return cdb_delete(CDB_DIRECTORY, key, strlen(key) ) == 0;
1460 }
1461
1462
1463 /*
1464  * Look up an Internet e-mail address in the directory.
1465  * On success: returns 0, and Citadel address stored in 'target'
1466  * On failure: returns nonzero
1467  */
1468 int CtdlDirectoryLookup(char *target, char *internet_addr, size_t targbuflen) {
1469         struct cdbdata *cdbrec;
1470         char key[SIZ];
1471
1472         /* Dump it in there unchanged, just for kicks */
1473         if (target != NULL) {
1474                 safestrncpy(target, internet_addr, targbuflen);
1475         }
1476
1477         /* Only do lookups for addresses with hostnames in them */
1478         if (num_tokens(internet_addr, '@') != 2) return(-1);
1479
1480         /* Only do lookups for domains in the directory */
1481         if (IsDirectory(internet_addr, 0) == 0) return(-1);
1482
1483         directory_key(key, internet_addr);
1484         cdbrec = cdb_fetch(CDB_DIRECTORY, key, strlen(key) );
1485         if (cdbrec != NULL) {
1486                 if (target != NULL) {
1487                         safestrncpy(target, cdbrec->ptr, targbuflen);
1488                 }
1489                 cdb_free(cdbrec);
1490                 return(0);
1491         }
1492
1493         return(-1);
1494 }
1495
1496
1497 /*
1498  * Harvest any email addresses that someone might want to have in their
1499  * "collected addresses" book.
1500  */
1501 char *harvest_collected_addresses(struct CtdlMessage *msg) {
1502         char *coll = NULL;
1503         char addr[256];
1504         char user[256], node[256], name[256];
1505         int is_harvestable;
1506         int i, j, h;
1507         eMsgField field = 0;
1508
1509         if (msg == NULL) return(NULL);
1510
1511         is_harvestable = 1;
1512         strcpy(addr, "");       
1513         if (!CM_IsEmpty(msg, eAuthor)) {
1514                 strcat(addr, msg->cm_fields[eAuthor]);
1515         }
1516         if (!CM_IsEmpty(msg, erFc822Addr)) {
1517                 strcat(addr, " <");
1518                 strcat(addr, msg->cm_fields[erFc822Addr]);
1519                 strcat(addr, ">");
1520                 if (IsDirectory(msg->cm_fields[erFc822Addr], 0)) {
1521                         is_harvestable = 0;
1522                 }
1523         }
1524
1525         if (is_harvestable) {
1526                 coll = strdup(addr);
1527         }
1528         else {
1529                 coll = strdup("");
1530         }
1531
1532         if (coll == NULL) return(NULL);
1533
1534         /* Scan both the R (To) and Y (CC) fields */
1535         for (i = 0; i < 2; ++i) {
1536                 if (i == 0) field = eRecipient;
1537                 if (i == 1) field = eCarbonCopY;
1538
1539                 if (!CM_IsEmpty(msg, field)) {
1540                         for (j=0; j<num_tokens(msg->cm_fields[field], ','); ++j) {
1541                                 extract_token(addr, msg->cm_fields[field], j, ',', sizeof addr);
1542                                 if (strstr(addr, "=?") != NULL)
1543                                         utf8ify_rfc822_string(addr);
1544                                 process_rfc822_addr(addr, user, node, name);
1545                                 h = CtdlHostAlias(node);
1546                                 if (h != hostalias_localhost) {
1547                                         coll = realloc(coll, strlen(coll) + strlen(addr) + 4);
1548                                         if (coll == NULL) return(NULL);
1549                                         if (!IsEmptyStr(coll)) {
1550                                                 strcat(coll, ",");
1551                                         }
1552                                         striplt(addr);
1553                                         strcat(coll, addr);
1554                                 }
1555                         }
1556                 }
1557         }
1558
1559         if (IsEmptyStr(coll)) {
1560                 free(coll);
1561                 return(NULL);
1562         }
1563         return(coll);
1564 }
1565
1566
1567 /*
1568  * Helper function for CtdlRebuildDirectoryIndex()
1569  */
1570 void CtdlRebuildDirectoryIndex_backend(char *username, void *data) {
1571
1572         int j = 0;
1573         struct ctdluser usbuf;
1574
1575         if (CtdlGetUser(&usbuf, username) != 0) {
1576                 return;
1577         }
1578
1579         if ( (!IsEmptyStr(usbuf.fullname)) && (!IsEmptyStr(usbuf.emailaddrs)) ) {
1580                 for (j=0; j<num_tokens(usbuf.emailaddrs, '|'); ++j) {
1581                         char one_email[512];
1582                         extract_token(one_email, usbuf.emailaddrs, j, '|', sizeof one_email);
1583                         CtdlDirectoryAddUser(one_email, usbuf.fullname);
1584                 }
1585         }
1586 }
1587
1588
1589 /*
1590  * Initialize the directory database (erasing anything already there)
1591  */
1592 void CtdlRebuildDirectoryIndex(void) {
1593         syslog(LOG_INFO, "internet_addressing: rebuilding email address directory index");
1594         cdb_trunc(CDB_DIRECTORY);
1595         ForEachUser(CtdlRebuildDirectoryIndex_backend, NULL);
1596 }
1597
1598
1599 /*
1600  * Configure Internet email addresses for a user account, updating the Directory Index in the process
1601  */
1602 void CtdlSetEmailAddressesForUser(char *requested_user, char *new_emailaddrs)
1603 {
1604         struct ctdluser usbuf;
1605         int i;
1606         char buf[SIZ];
1607
1608         if (CtdlGetUserLock(&usbuf, requested_user) != 0) {     // We are relying on the fact that the DirectoryIndex functions don't lock.
1609                 return;                                         // Silently fail here if we can't acquire a lock on the user record.
1610         }
1611
1612         syslog(LOG_DEBUG, "internet_addressing: setting email addresses for <%s> to <%s>", usbuf.fullname, new_emailaddrs);
1613
1614         /* Delete all of the existing directory index records for the user (easier this way) */
1615         for (i=0; i<num_tokens(usbuf.emailaddrs, '|'); ++i) {
1616                 extract_token(buf, usbuf.emailaddrs, i, '|', sizeof buf);
1617                 CtdlDirectoryDelUser(buf, requested_user);
1618         }
1619
1620         strcpy(usbuf.emailaddrs, new_emailaddrs);               // make it official.
1621
1622         /* Index all of the new email addresses (they've already been sanitized) */
1623         for (i=0; i<num_tokens(usbuf.emailaddrs, '|'); ++i) {
1624                 extract_token(buf, usbuf.emailaddrs, i, '|', sizeof buf);
1625                 CtdlDirectoryAddUser(buf, requested_user);
1626         }
1627
1628         CtdlPutUserLock(&usbuf);
1629 }
1630
1631
1632 /*
1633  * Auto-generate an Internet email address for a user account
1634  */
1635 void AutoGenerateEmailAddressForUser(struct ctdluser *user)
1636 {
1637         char synthetic_email_addr[1024];
1638         int i, j;
1639         int u = 0;
1640
1641         for (i=0; u==0; ++i) {
1642                 if (i == 0) {
1643                         // first try just converting the user name to lowercase and replacing spaces with underscores
1644                         snprintf(synthetic_email_addr, sizeof synthetic_email_addr, "%s@%s", user->fullname, CtdlGetConfigStr("c_fqdn"));
1645                         for (j=0; ((synthetic_email_addr[j] != '\0')&&(synthetic_email_addr[j] != '@')); j++) {
1646                                 synthetic_email_addr[j] = tolower(synthetic_email_addr[j]);
1647                                 if (!isalnum(synthetic_email_addr[j])) {
1648                                         synthetic_email_addr[j] = '_';
1649                                 }
1650                         }
1651                 }
1652                 else if (i == 1) {
1653                         // then try 'ctdl' followed by the user number
1654                         snprintf(synthetic_email_addr, sizeof synthetic_email_addr, "ctdl%08lx@%s", user->usernum, CtdlGetConfigStr("c_fqdn"));
1655                 }
1656                 else if (i > 1) {
1657                         // oof.  just keep trying other numbers until we find one
1658                         snprintf(synthetic_email_addr, sizeof synthetic_email_addr, "ctdl%08x@%s", i, CtdlGetConfigStr("c_fqdn"));
1659                 }
1660                 u = CtdlDirectoryLookup(NULL, synthetic_email_addr, 0);
1661                 syslog(LOG_DEBUG, "user_ops: address <%s> lookup returned <%d>", synthetic_email_addr, u);
1662         }
1663
1664         CtdlSetEmailAddressesForUser(user->fullname, synthetic_email_addr);
1665         strncpy(CC->user.emailaddrs, synthetic_email_addr, sizeof(user->emailaddrs));
1666         syslog(LOG_DEBUG, "user_ops: auto-generated email address <%s> for <%s>", synthetic_email_addr, user->fullname);
1667 }