summaryrefslogtreecommitdiff
path: root/pith/addrstring.c
diff options
context:
space:
mode:
Diffstat (limited to 'pith/addrstring.c')
-rw-r--r--pith/addrstring.c452
1 files changed, 452 insertions, 0 deletions
diff --git a/pith/addrstring.c b/pith/addrstring.c
new file mode 100644
index 00000000..928de43e
--- /dev/null
+++ b/pith/addrstring.c
@@ -0,0 +1,452 @@
+#if !defined(lint) && !defined(DOS)
+static char rcsid[] = "$Id: addrstring.c 770 2007-10-24 00:23:09Z hubert@u.washington.edu $";
+#endif
+
+/*
+ * ========================================================================
+ * Copyright 2006-2007 University of Washington
+ * Copyright 2013 Eduardo Chappa
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * ========================================================================
+ */
+
+#include "../pith/headers.h"
+#include "../pith/addrstring.h"
+#include "../pith/state.h"
+#include "../pith/copyaddr.h"
+#include "../pith/charset.h"
+#include "../pith/stream.h"
+
+
+/*
+ * Internal prototypes
+ */
+void rfc822_write_address_decode(char *, size_t, ADDRESS *, int);
+
+
+/*
+ * Format an address structure into a string
+ *
+ * Args: addr -- Single ADDRESS structure to turn into a string
+ *
+ * Result: Fills in buf and returns pointer to it.
+ * Just uses the c-client call to do this.
+ * (the address is not rfc1522 decoded)
+ */
+char *
+addr_string(struct mail_address *addr, char *buf, size_t buflen)
+{
+ ADDRESS *next_addr;
+ RFC822BUFFER rbuf;
+
+ *buf = '\0';
+ next_addr = addr->next;
+ addr->next = NULL;
+ rbuf.f = dummy_soutr;
+ rbuf.s = NULL;
+ rbuf.beg = buf;
+ rbuf.cur = buf;
+ rbuf.end = buf+buflen-1;
+ rfc822_output_address_list(&rbuf, addr, 0L, NULL);
+ *rbuf.cur = '\0';
+ addr->next = next_addr;
+ return(buf);
+}
+
+
+/*
+ * Same as addr_string only it doesn't have to be a
+ * single address.
+ */
+char *
+addr_string_mult(struct mail_address *addr, char *buf, size_t buflen)
+{
+ RFC822BUFFER rbuf;
+
+ *buf = '\0';
+ rbuf.f = dummy_soutr;
+ rbuf.s = NULL;
+ rbuf.beg = buf;
+ rbuf.cur = buf;
+ rbuf.end = buf+buflen-1;
+ rfc822_output_address_list(&rbuf, addr, 0L, NULL);
+ *rbuf.cur = '\0';
+ return(buf);
+}
+
+
+/*
+ * Format an address structure into a simple string: "mailbox@host"
+ *
+ * Args: addr -- Single ADDRESS structure to turn into a string
+ * buf -- buffer to write address in;
+ *
+ * Result: Returns pointer to buf;
+ */
+char *
+simple_addr_string(struct mail_address *addr, char *buf, size_t buflen)
+{
+ RFC822BUFFER rbuf;
+
+ rbuf.f = dummy_soutr;
+ rbuf.s = NULL;
+ rbuf.beg = buf;
+ rbuf.cur = buf;
+ rbuf.end = buf+buflen-1;
+ rfc822_output_address(&rbuf, addr);
+ *rbuf.cur = '\0';
+
+ return(buf);
+}
+
+
+/*
+ * Format an address structure into a simple string: "mailbox@host"
+ * Like simple_addr_string but can be multiple addresses.
+ *
+ * Args: addr -- ADDRESS structure to turn into a string
+ * buf -- buffer to write address in;
+ * buflen -- length of buffer
+ * sep -- separator string
+ *
+ * Result: Returns pointer to internal static formatted string.
+ * Just uses the c-client call to do this.
+ */
+char *
+simple_mult_addr_string(struct mail_address *addr, char *buf, size_t buflen, char *sep)
+{
+ ADDRESS *a;
+ char *dest = buf;
+ size_t seplen = 0;
+
+ if(sep)
+ seplen = strlen(sep);
+
+ *dest = '\0';
+ for(a = addr; a; a = a->next){
+ if(dest > buf && seplen > 0 && buflen-1-(dest-buf) >= seplen){
+ strncpy(dest, sep, seplen);
+ dest += seplen;
+ *dest = '\0';
+ }
+
+ simple_addr_string(a, dest, buflen-(dest-buf));
+ dest += strlen(dest);
+ }
+
+ buf[buflen-1] = '\0';
+
+ return(buf);
+}
+
+
+/*
+ * 1522 encode the personal name portion of addr and return an allocated
+ * copy of the resulting address string.
+ */
+char *
+encode_fullname_of_addrstring(char *addr, char *charset)
+{
+ char *pers_encoded,
+ *tmp_a_string,
+ *ret = NULL;
+ ADDRESS *adr;
+ static char *fakedomain = "@";
+ RFC822BUFFER rbuf;
+ size_t len;
+
+ tmp_a_string = cpystr(addr ? addr : "");
+ adr = NULL;
+ rfc822_parse_adrlist(&adr, tmp_a_string, fakedomain);
+ fs_give((void **)&tmp_a_string);
+
+ if(!adr)
+ return(cpystr(""));
+
+ if(adr->personal && adr->personal[0]){
+ pers_encoded = cpystr(rfc1522_encode(tmp_20k_buf, SIZEOF_20KBUF,
+ (unsigned char *)adr->personal,
+ charset));
+ fs_give((void **)&adr->personal);
+ adr->personal = pers_encoded;
+ }
+
+ len = est_size(adr);
+ ret = (char *) fs_get(len * sizeof(char));
+ ret[0] = '\0';
+ rbuf.f = dummy_soutr;
+ rbuf.s = NULL;
+ rbuf.beg = ret;
+ rbuf.cur = ret;
+ rbuf.end = ret+len-1;
+ rfc822_output_address_list(&rbuf, adr, 0L, NULL);
+ *rbuf.cur = '\0';
+ mail_free_address(&adr);
+ return(ret);
+}
+
+
+/*
+ * 1522 decode the personal name portion of addr and return an allocated
+ * copy of the resulting address string.
+ */
+char *
+decode_fullname_of_addrstring(char *addr, int verbose)
+{
+ char *pers_decoded,
+ *tmp_a_string,
+ *ret = NULL;
+ ADDRESS *adr;
+ static char *fakedomain = "@";
+ RFC822BUFFER rbuf;
+ size_t len;
+
+ tmp_a_string = cpystr(addr ? addr : "");
+ adr = NULL;
+ rfc822_parse_adrlist(&adr, tmp_a_string, fakedomain);
+ fs_give((void **)&tmp_a_string);
+
+ if(!adr)
+ return(cpystr(""));
+
+ if(adr->personal && adr->personal[0]){
+ pers_decoded
+ = cpystr((char *)rfc1522_decode_to_utf8((unsigned char *)tmp_20k_buf,
+ SIZEOF_20KBUF, adr->personal));
+ fs_give((void **)&adr->personal);
+ adr->personal = pers_decoded;
+ }
+
+ len = est_size(adr);
+ ret = (char *) fs_get(len * sizeof(char));
+ ret[0] = '\0';
+ rbuf.f = dummy_soutr;
+ rbuf.s = NULL;
+ rbuf.beg = ret;
+ rbuf.cur = ret;
+ rbuf.end = ret+len-1;
+ rfc822_output_address_list(&rbuf, adr, 0L, NULL);
+ *rbuf.cur = '\0';
+ mail_free_address(&adr);
+ return(ret);
+}
+
+
+/*
+ * Turn a list of address structures into a formatted string
+ *
+ * Args: adrlist -- An adrlist
+ * f -- Function to use to print one address in list. If NULL,
+ * use rfc822_write_address_decode to print whole list.
+ * do_quote -- Quote quotes and dots (only used if f == NULL).
+ * Result: comma separated list of addresses which is
+ * malloced here and returned
+ * (the list is rfc1522 decoded unless f is *not* NULL)
+ */
+char *
+addr_list_string(struct mail_address *adrlist,
+ char *(*f)(struct mail_address *, char *, size_t),
+ int do_quote)
+{
+ size_t len;
+ char *list, *s, string[MAX_ADDR_EXPN+1];
+ register ADDRESS *a;
+
+ if(!adrlist)
+ return(cpystr(""));
+
+ if(f){
+ len = 0;
+ for(a = adrlist; a; a = a->next)
+ len += (strlen((*f)(a, string, sizeof(string))) + 2);
+
+ list = (char *) fs_get((len+1) * sizeof(char));
+ s = list;
+ s[0] = '\0';
+
+ for(a = adrlist; a; a = a->next){
+ sstrncpy(&s, (*f)(a, string, sizeof(string)), len-(s-list));
+ if(a->next && len-(s-list) > 2){
+ *s++ = ',';
+ *s++ = SPACE;
+ }
+ }
+ }
+ else{
+ len = est_size(adrlist);
+ list = (char *) fs_get((len+1) * sizeof(char));
+ list[0] = '\0';
+ rfc822_write_address_decode(list, len+1, adrlist, do_quote);
+ removing_leading_and_trailing_white_space(list);
+ }
+
+ list[len] = '\0';
+ return(list);
+}
+
+
+static long rfc822_dummy_soutr (void *stream, char *string)
+{
+ return LONGT;
+}
+
+/*
+ * Copied from c-client/rfc822.c buf with dot and double quote removed.
+ */
+static const char *rspecials_minus_quote_and_dot = "()<>@,;:\\[]\1\2\3\4\5\6\7\10\11\12\13\14\15\16\17\20\21\22\23\24\25\26\27\30\31\32\33\34\35\36\37\177";
+
+/* Write RFC822 address with 1522 decoding of personal name
+ * and optional quoting.
+ *
+ * The idea is that there are some places where we'd just like to display
+ * the personal name as is before applying confusing quoting. However,
+ * we do want to be careful not to break things that should be quoted so
+ * we'll only use this where we are sure. Quoting may look ugly but it
+ * doesn't usually break anything.
+ */
+void
+rfc822_write_address_decode(char *dest, size_t destlen, struct mail_address *adr, int do_quote)
+{
+ RFC822BUFFER buf;
+ extern const char *rspecials;
+ ADDRESS *copy, *a;
+
+ /*
+ * We want to print the adr list after decoding it. C-client knows
+ * how to parse and print, so we want to use that. But c-client
+ * doesn't decode. So we make a copy of the address list, decode
+ * things there, and let c-client print that.
+ */
+ copy = copyaddrlist(adr);
+ for(a = copy; a; a = a->next){
+ if(a->host){ /* ordinary address? */
+ if(a->personal && *a->personal){
+ unsigned char *p;
+
+ p = rfc1522_decode_to_utf8((unsigned char *) tmp_20k_buf,
+ SIZEOF_20KBUF, a->personal);
+
+ if(p && (char *) p != a->personal){
+ fs_give((void **) &a->personal);
+ a->personal = cpystr((char *) p);
+ }
+ }
+ }
+ else if(a->mailbox && *a->mailbox){ /* start of group? */
+ unsigned char *p;
+
+ p = rfc1522_decode_to_utf8((unsigned char *) tmp_20k_buf, SIZEOF_20KBUF, a->mailbox);
+
+ if(p && (char *) p != a->mailbox){
+ fs_give((void **) &a->mailbox);
+ a->mailbox = cpystr((char *) p);
+ }
+ }
+ }
+
+ buf.end = (buf.beg = buf.cur = dest) + destlen;
+ buf.f = rfc822_dummy_soutr;
+ *buf.cur = '\0';
+ buf.s = NIL;
+
+ (void) rfc822_output_address_list(&buf, copy, 0,
+ do_quote ? rspecials : rspecials_minus_quote_and_dot);
+
+ *buf.cur = '\0';
+
+ if(copy)
+ mail_free_address(&copy);
+}
+
+
+/*
+ * Compute an upper bound on the size of the array required by
+ * rfc822_write_address for this list of addresses.
+ *
+ * Args: adrlist -- The address list.
+ *
+ * Returns -- an integer giving the upper bound
+ */
+int
+est_size(struct mail_address *a)
+{
+ int cnt = 0;
+
+ for(; a; a = a->next){
+
+ /* two times personal for possible quoting */
+ cnt += 2 * (a->personal ? (strlen(a->personal)+1) : 0);
+ cnt += 2 * (a->mailbox ? (strlen(a->mailbox)+1) : 0);
+ cnt += (a->adl ? strlen(a->adl) : 0);
+ cnt += (a->host ? strlen(a->host) : 0);
+
+ /*
+ * add room for:
+ * possible single space between fullname and addr
+ * left and right brackets
+ * @ sign
+ * possible : for route addr
+ * , <space>
+ *
+ * So I really think that adding 7 is enough. Instead, I'll add 10.
+ */
+ cnt += 10;
+ }
+
+ return(MAX(cnt, 50)); /* just making sure */
+}
+
+
+/*
+ * Returns the number of addresses in the list.
+ */
+int
+count_addrs(struct mail_address *adrlist)
+{
+ int cnt = 0;
+
+ while(adrlist){
+ if(adrlist->mailbox && adrlist->mailbox[0])
+ cnt++;
+
+ adrlist = adrlist->next;
+ }
+
+ return(cnt);
+}
+
+
+/*
+ * Buf is at least size maxlen+1
+ */
+void
+a_little_addr_string(struct mail_address *addr, char *buf, size_t maxlen)
+{
+ buf[0] = '\0';
+ if(addr){
+ if(addr->personal && addr->personal[0]){
+ char tmp[MAILTMPLEN];
+
+ snprintf(tmp, sizeof(tmp), "%s", addr->personal);
+ iutf8ncpy(buf, (char *)rfc1522_decode_to_utf8((unsigned char *)tmp_20k_buf,
+ SIZEOF_20KBUF, tmp),
+ maxlen);
+ }
+ else if(addr->mailbox && addr->mailbox[0]){
+ strncpy(buf, addr->mailbox, maxlen);
+ buf[maxlen] = '\0';
+ if(addr->host && addr->host[0] && addr->host[0] != '.'){
+ strncat(buf, "@", maxlen+1-1-strlen(buf));
+ strncat(buf, addr->host, maxlen+1-1-strlen(buf));
+ }
+ }
+ }
+
+ buf[maxlen] = '\0';
+}
generated by cgit v1.2.3-70-g09d2 (git 2.47.0) at 2024-11-05 17:23:32 +0000