ADDRESS -> address_t

Signed-off-by: Pierre Habouzit <madcoder@debian.org>

diff --git a/alias.c b/alias.c
index 835d55a..aec85d6 100644 (file)
--- a/alias.c
+++ b/alias.c
@@ -42,7 +42,7 @@ static struct mapping_t AliasHelp[] = {
   {NULL, OP_NULL}
 };
 
   {NULL, OP_NULL}
 };
 

-ADDRESS *mutt_lookup_alias (const char *s)
+address_t *mutt_lookup_alias (const char *s)

 {
   ALIAS *t = Aliases;
 
 {
   ALIAS *t = Aliases;
 


@@ -52,9 +52,9 @@ ADDRESS *mutt_lookup_alias (const char *s)
   return (NULL);                /* no such alias */
 }
 
   return (NULL);                /* no such alias */
 }
 

-static ADDRESS *mutt_expand_aliases_r (ADDRESS * a, LIST ** expn)
+static address_t *mutt_expand_aliases_r (address_t * a, LIST ** expn)

 {
 {

-  ADDRESS *head = NULL, *last = NULL, *t, *w;
+  address_t *head = NULL, *last = NULL, *t, *w;

   LIST *u;
   char i;
   const char *fqdn;
   LIST *u;
   char i;
   const char *fqdn;


@@ -124,9 +124,9 @@ static ADDRESS *mutt_expand_aliases_r (ADDRESS * a, LIST ** expn)
   return (head);
 }
 
   return (head);
 }
 

-ADDRESS *mutt_expand_aliases (ADDRESS * a)
+address_t *mutt_expand_aliases (address_t * a)

 {
 {

-  ADDRESS *t;
+  address_t *t;

   LIST *expn = NULL;            /* previously expanded aliases to avoid loops */
 
   t = mutt_expand_aliases_r (a, &expn);
   LIST *expn = NULL;            /* previously expanded aliases to avoid loops */
 
   t = mutt_expand_aliases_r (a, &expn);


@@ -176,9 +176,9 @@ static void write_safe_address (FILE * fp, char *s)
   }
 }
 
   }
 }
 

-ADDRESS *mutt_get_address (ENVELOPE * env, const char **pfxp)
+address_t *mutt_get_address (ENVELOPE * env, const char **pfxp)

 {
 {

-  ADDRESS *adr;
+  address_t *adr;

   const char *pfx = NULL;
 
   if (mutt_addr_is_user (env->from)) {
   const char *pfx = NULL;
 
   if (mutt_addr_is_user (env->from)) {


@@ -206,14 +206,14 @@ ADDRESS *mutt_get_address (ENVELOPE * env, const char **pfxp)
   return adr;
 }
 
   return adr;
 }
 

-void mutt_create_alias (ENVELOPE * cur, ADDRESS * iadr)
+void mutt_create_alias (ENVELOPE * cur, address_t * iadr)

 {
   ALIAS *new, *t;
   char buf[LONG_STRING], prompt[SHORT_STRING], *pc;
   char *err = NULL;
   char fixed[LONG_STRING];
   FILE *rc;
 {
   ALIAS *new, *t;
   char buf[LONG_STRING], prompt[SHORT_STRING], *pc;
   char *err = NULL;
   char fixed[LONG_STRING];
   FILE *rc;

-  ADDRESS *adr = NULL;
+  address_t *adr = NULL;

 
   if (cur) {
     adr = mutt_get_address (cur, NULL);
 
   if (cur) {
     adr = mutt_get_address (cur, NULL);


@@ -369,10 +369,10 @@ int mutt_check_alias_name (const char *s, char *d)
  * This routine looks to see if the user has an alias defined for the given
  * address.
  */
  * This routine looks to see if the user has an alias defined for the given
  * address.
  */

-ADDRESS *alias_reverse_lookup (ADDRESS * a)
+address_t *alias_reverse_lookup (address_t * a)

 {
   ALIAS *t = Aliases;
 {
   ALIAS *t = Aliases;

-  ADDRESS *ap;
+  address_t *ap;

 
   if (!a || !a->mailbox)
     return NULL;
 
   if (!a || !a->mailbox)
     return NULL;


@@ -495,7 +495,7 @@ static int string_is_address (const char *str, const char *u, const char *d)
 }
 
 /* returns TRUE if the given address belongs to the user. */
 }
 
 /* returns TRUE if the given address belongs to the user. */

-int mutt_addr_is_user (ADDRESS * addr)
+int mutt_addr_is_user (address_t * addr)

 {
   /* NULL address is assumed to be the user. */
   if (!addr) {
 {
   /* NULL address is assumed to be the user. */
   if (!addr) {


@@ -605,8 +605,8 @@ static int alias_SortAlias (const void *a, const void *b)
 
 static int alias_SortAddress (const void *a, const void *b)
 {
 
 static int alias_SortAddress (const void *a, const void *b)
 {

-  ADDRESS *pa = (*(ALIAS **) a)->addr;
-  ADDRESS *pb = (*(ALIAS **) b)->addr;
+  address_t *pa = (*(ALIAS **) a)->addr;
+  address_t *pb = (*(ALIAS **) b)->addr;

   int r;
 
   if (pa == pb)
   int r;
 
   if (pa == pb)

diff --git a/alias.h b/alias.h
index f20e8af..59086f5 100644 (file)
--- a/alias.h
+++ b/alias.h
@@ -14,23 +14,23 @@
 typedef struct alias {
   struct alias *self;           /* XXX - ugly hack */
   char *name;
 typedef struct alias {
   struct alias *self;           /* XXX - ugly hack */
   char *name;

-  ADDRESS *addr;
+  address_t *addr;

   struct alias *next;
   short tagged;
   short del;
   short num;
 } ALIAS;
 
   struct alias *next;
   short tagged;
   short del;
   short num;
 } ALIAS;
 

-void mutt_create_alias (ENVELOPE *, ADDRESS *);
+void mutt_create_alias (ENVELOPE *, address_t *);

 int mutt_check_alias_name (const char *, char *);
 int mutt_check_alias_name (const char *, char *);

-ADDRESS *mutt_get_address (ENVELOPE *, const char **);
-ADDRESS *mutt_lookup_alias (const char *s);
-ADDRESS *mutt_expand_aliases (ADDRESS *);
+address_t *mutt_get_address (ENVELOPE *, const char **);
+address_t *mutt_lookup_alias (const char *s);
+address_t *mutt_expand_aliases (address_t *);

 void mutt_expand_aliases_env (ENVELOPE *);
 void mutt_free_alias (ALIAS **);
 void mutt_expand_aliases_env (ENVELOPE *);
 void mutt_free_alias (ALIAS **);

-ADDRESS *alias_reverse_lookup (ADDRESS *);
+address_t *alias_reverse_lookup (address_t *);

 int mutt_alias_complete (char *, size_t);
 int mutt_alias_complete (char *, size_t);

-int mutt_addr_is_user (ADDRESS *);
+int mutt_addr_is_user (address_t *);

 void mutt_alias_menu (char *, size_t, ALIAS *);
 
 #endif /* !_MUTT_ALIAS_H */
 void mutt_alias_menu (char *, size_t, ALIAS *);
 
 #endif /* !_MUTT_ALIAS_H */

diff --git a/commands.c b/commands.c
index b80e250..00a8446 100644 (file)
--- a/commands.c
+++ b/commands.c
@@ -244,7 +244,7 @@ void ci_bounce_message (HEADER * h, int *redraw)
 {
   char prompt[SHORT_STRING];
   char buf[HUGE_STRING] = { 0 };
 {
   char prompt[SHORT_STRING];
   char buf[HUGE_STRING] = { 0 };

-  ADDRESS *adr = NULL;
+  address_t *adr = NULL;

   char *err = NULL;
   int rc;
 
   char *err = NULL;
   int rc;
 


@@ -596,7 +596,7 @@ void mutt_display_address (ENVELOPE * env)
 {
   const char *pfx = NULL;
   char buf[SHORT_STRING];
 {
   const char *pfx = NULL;
   char buf[SHORT_STRING];

-  ADDRESS *adr = NULL;
+  address_t *adr = NULL;

 
   adr = mutt_get_address(env, &pfx);
 
 
   adr = mutt_get_address(env, &pfx);
 

diff --git a/compose.c b/compose.c
index 91a2894..5b3687a 100644 (file)
--- a/compose.c
+++ b/compose.c
@@ -266,7 +266,7 @@ static int check_attachments (ATTACHPTR ** idx, short idxlen)
   return 0;
 }
 
   return 0;
 }
 

-static void draw_envelope_addr (int line, ADDRESS * addr)
+static void draw_envelope_addr (int line, address_t * addr)

 {
   char buf[STRING];
 
 {
   char buf[STRING];
 


@@ -320,7 +320,7 @@ static void draw_envelope (HEADER * msg, char *fcc)
   SETCOLOR (MT_COLOR_NORMAL);
 }
 
   SETCOLOR (MT_COLOR_NORMAL);
 }
 

-static int edit_address_list (int line, ADDRESS ** addr)
+static int edit_address_list (int line, address_t ** addr)

 {
   char buf[HUGE_STRING] = "";   /* needs to be large for alias expansion */
   char *err = NULL;
 {
   char buf[HUGE_STRING] = "";   /* needs to be large for alias expansion */
   char *err = NULL;

diff --git a/copy.c b/copy.c
index d0af92d..565fcb0 100644 (file)
--- a/copy.c
+++ b/copy.c
@@ -813,7 +813,7 @@ static int copy_delete_attach (BODY * b, FILE * fpin, FILE * fpout,
  * XXX - fix that. 
  */
 
  * XXX - fix that. 
  */
 

-static void format_address_header (char **h, ADDRESS * a)
+static void format_address_header (char **h, address_t * a)

 {
   char buf[HUGE_STRING];
   char cbuf[STRING];
 {
   char buf[HUGE_STRING];
   char cbuf[STRING];


@@ -827,7 +827,7 @@ static void format_address_header (char **h, ADDRESS * a)
 
   p_realloc(h, buflen);
   for (count = 0; a; a = a->next, count++) {
 
   p_realloc(h, buflen);
   for (count = 0; a; a = a->next, count++) {

-    ADDRESS *tmp = a->next;
+    address_t *tmp = a->next;

 
     a->next = NULL;
     *buf = *cbuf = *c2buf = '\0';
 
     a->next = NULL;
     *buf = *cbuf = *c2buf = '\0';


@@ -868,7 +868,7 @@ static int address_header_decode (char **h)
   char *s = *h;
   int l;
 
   char *s = *h;
   int l;
 

-  ADDRESS *a = NULL;
+  address_t *a = NULL;

 
   switch (tolower ((unsigned char) *s)) {
   case 'r':
 
   switch (tolower ((unsigned char) *s)) {
   case 'r':

diff --git a/crypt-gpgme.c b/crypt-gpgme.c
index dfd2645..bca29d0 100644 (file)
--- a/crypt-gpgme.c
+++ b/crypt-gpgme.c
@@ -288,7 +288,7 @@ static int crypt_id_is_valid (crypt_key_t * key)
 
 /* Return a bit vector describing how well the addresses ADDR and
    U_ADDR match and whether KEY is valid. */
 
 /* Return a bit vector describing how well the addresses ADDR and
    U_ADDR match and whether KEY is valid. */

-static int crypt_id_matches_addr (ADDRESS * addr, ADDRESS * u_addr,
+static int crypt_id_matches_addr (address_t * addr, address_t * u_addr,

                                   crypt_key_t * key)
 {
   int rv = 0;
                                   crypt_key_t * key)
 {
   int rv = 0;


@@ -3233,7 +3233,7 @@ static LIST *crypt_add_string_to_hints (LIST * hints, const char *str)
    will be set to true on return if the user did override the the
    key's validity. */
 static crypt_key_t *crypt_select_key (crypt_key_t * keys,
    will be set to true on return if the user did override the the
    key's validity. */
 static crypt_key_t *crypt_select_key (crypt_key_t * keys,

-                                      ADDRESS * p, const char *s,
+                                      address_t * p, const char *s,

                                       unsigned int app, int *forced_valid)
 {
   int keymax;
                                       unsigned int app, int *forced_valid)
 {
   int keymax;


@@ -3424,10 +3424,10 @@ static crypt_key_t *crypt_select_key (crypt_key_t * keys,
   return k;
 }
 
   return k;
 }
 

-static crypt_key_t *crypt_getkeybyaddr (ADDRESS * a, short abilities,
+static crypt_key_t *crypt_getkeybyaddr (address_t * a, short abilities,

                                         unsigned int app, int *forced_valid)
 {
                                         unsigned int app, int *forced_valid)
 {

-  ADDRESS *r, *p;
+  address_t *r, *p;

   LIST *hints = NULL;
 
   int weak = 0;
   LIST *hints = NULL;
 
   int weak = 0;


@@ -3656,15 +3656,15 @@ static crypt_key_t *crypt_ask_for_key (char *tag,
 
 /* This routine attempts to find the keyids of the recipients of a
    message.  It returns NULL if any of the keys can not be found.  */
 
 /* This routine attempts to find the keyids of the recipients of a
    message.  It returns NULL if any of the keys can not be found.  */

-static char *find_keys (ADDRESS * to, ADDRESS * cc, ADDRESS * bcc,
+static char *find_keys (address_t * to, address_t * cc, address_t * bcc,

                         unsigned int app)
 {
   char *keyID, *keylist = NULL, *t;
   size_t keylist_size = 0;
   size_t keylist_used = 0;
                         unsigned int app)
 {
   char *keyID, *keylist = NULL, *t;
   size_t keylist_size = 0;
   size_t keylist_used = 0;

-  ADDRESS *tmp = NULL, *addr = NULL;
-  ADDRESS **last = &tmp;
-  ADDRESS *p, *q;
+  address_t *tmp = NULL, *addr = NULL;
+  address_t **last = &tmp;
+  address_t *p, *q;

   int i;
   crypt_key_t *k_info, *key;
   const char *fqdn = mutt_fqdn (1);
   int i;
   crypt_key_t *k_info, *key;
   const char *fqdn = mutt_fqdn (1);


@@ -3781,12 +3781,12 @@ static char *find_keys (ADDRESS * to, ADDRESS * cc, ADDRESS * bcc,
   return (keylist);
 }
 
   return (keylist);
 }
 

-char *pgp_gpgme_findkeys (ADDRESS * to, ADDRESS * cc, ADDRESS * bcc)
+char *pgp_gpgme_findkeys (address_t * to, address_t * cc, address_t * bcc)

 {
   return find_keys (to, cc, bcc, APPLICATION_PGP);
 }
 
 {
   return find_keys (to, cc, bcc, APPLICATION_PGP);
 }
 

-char *smime_gpgme_findkeys (ADDRESS * to, ADDRESS * cc, ADDRESS * bcc)
+char *smime_gpgme_findkeys (address_t * to, address_t * cc, address_t * bcc)

 {
   return find_keys (to, cc, bcc, APPLICATION_SMIME);
 }
 {
   return find_keys (to, cc, bcc, APPLICATION_SMIME);
 }


@@ -3907,7 +3907,7 @@ int smime_gpgme_send_menu (HEADER * msg, int *redraw)
 
 static int verify_sender (HEADER * h, gpgme_protocol_t protocol)
 {
 
 static int verify_sender (HEADER * h, gpgme_protocol_t protocol)
 {

-  ADDRESS *sender = NULL;
+  address_t *sender = NULL;

   unsigned int ret = 1;
 
   if (h->env->from) {
   unsigned int ret = 1;
 
   if (h->env->from) {

diff --git a/crypt-gpgme.h b/crypt-gpgme.h
index c630053..db048be 100644 (file)
--- a/crypt-gpgme.h
+++ b/crypt-gpgme.h
@@ -15,8 +15,8 @@
 void pgp_gpgme_init (void);
 void smime_gpgme_init (void);
 
 void pgp_gpgme_init (void);
 void smime_gpgme_init (void);
 

-char *pgp_gpgme_findkeys (ADDRESS * to, ADDRESS * cc, ADDRESS * bcc);
-char *smime_gpgme_findkeys (ADDRESS * to, ADDRESS * cc, ADDRESS * bcc);
+char *pgp_gpgme_findkeys (address_t * to, address_t * cc, address_t * bcc);
+char *smime_gpgme_findkeys (address_t * to, address_t * cc, address_t * bcc);

 
 BODY *pgp_gpgme_encrypt_message (BODY * a, char *keylist, int sign);
 BODY *smime_gpgme_build_smime_entity (BODY * a, char *keylist);
 
 BODY *pgp_gpgme_encrypt_message (BODY * a, char *keylist, int sign);
 BODY *smime_gpgme_build_smime_entity (BODY * a, char *keylist);

diff --git a/crypt-mod-pgp-classic.c b/crypt-mod-pgp-classic.c
index ae82663..c6c417f 100644 (file)
--- a/crypt-mod-pgp-classic.c
+++ b/crypt-mod-pgp-classic.c
@@ -38,8 +38,8 @@ static int crypt_mod_pgp_application_handler (BODY * m, STATE * s)
   return pgp_application_pgp_handler (m, s);
 }
 
   return pgp_application_pgp_handler (m, s);
 }
 

-static char *crypt_mod_pgp_findkeys (ADDRESS * to, ADDRESS * cc,
-                                     ADDRESS * bcc)
+static char *crypt_mod_pgp_findkeys (address_t * to, address_t * cc,
+                                     address_t * bcc)

 {
   return pgp_findKeys (to, cc, bcc);
 }
 {
   return pgp_findKeys (to, cc, bcc);
 }


@@ -87,7 +87,7 @@ static int crypt_mod_pgp_encrypted_handler (BODY * m, STATE * s)
   return pgp_encrypted_handler (m, s);
 }
 
   return pgp_encrypted_handler (m, s);
 }
 

-static void crypt_mod_pgp_invoke_getkeys (ADDRESS * addr)
+static void crypt_mod_pgp_invoke_getkeys (address_t * addr)

 {
   pgp_invoke_getkeys (addr);
 }
 {
   pgp_invoke_getkeys (addr);
 }

diff --git a/crypt-mod-pgp-gpgme.c b/crypt-mod-pgp-gpgme.c
index 8dd7c30..cd18717 100644 (file)
--- a/crypt-mod-pgp-gpgme.c
+++ b/crypt-mod-pgp-gpgme.c
@@ -58,8 +58,8 @@ static int crypt_mod_pgp_check_traditional (FILE * fp, BODY * b,
   return pgp_gpgme_check_traditional (fp, b, tagged_only);
 }
 
   return pgp_gpgme_check_traditional (fp, b, tagged_only);
 }
 

-static char *crypt_mod_pgp_findkeys (ADDRESS * to, ADDRESS * cc,
-                                     ADDRESS * bcc)
+static char *crypt_mod_pgp_findkeys (address_t * to, address_t * cc,
+                                     address_t * bcc)

 {
   return pgp_gpgme_findkeys (to, cc, bcc);
 }
 {
   return pgp_gpgme_findkeys (to, cc, bcc);
 }

diff --git a/crypt-mod-smime-classic.c b/crypt-mod-smime-classic.c
index 95acdb7..6a2483a 100644 (file)
--- a/crypt-mod-smime-classic.c
+++ b/crypt-mod-smime-classic.c
@@ -38,8 +38,8 @@ static int crypt_mod_smime_application_handler (BODY * m, STATE * s)
   return smime_application_smime_handler (m, s);
 }
 
   return smime_application_smime_handler (m, s);
 }
 

-static char *crypt_mod_smime_findkeys (ADDRESS * to, ADDRESS * cc,
-                                       ADDRESS * bcc)
+static char *crypt_mod_smime_findkeys (address_t * to, address_t * cc,
+                                       address_t * bcc)

 {
   return smime_findKeys (to, cc, bcc);
 }
 {
   return smime_findKeys (to, cc, bcc);
 }

diff --git a/crypt-mod-smime-gpgme.c b/crypt-mod-smime-gpgme.c
index 601d96a..fdf391b 100644 (file)
--- a/crypt-mod-smime-gpgme.c
+++ b/crypt-mod-smime-gpgme.c
@@ -47,8 +47,8 @@ static int crypt_mod_smime_application_handler (BODY * m, STATE * s)
   return smime_gpgme_application_handler (m, s);
 }
 
   return smime_gpgme_application_handler (m, s);
 }
 

-static char *crypt_mod_smime_findkeys (ADDRESS * to, ADDRESS * cc,
-                                       ADDRESS * bcc)
+static char *crypt_mod_smime_findkeys (address_t * to, address_t * cc,
+                                       address_t * bcc)

 {
   return smime_gpgme_findkeys (to, cc, bcc);
 }
 {
   return smime_gpgme_findkeys (to, cc, bcc);
 }

diff --git a/crypt-mod.h b/crypt-mod.h
index eb12b93..09cc59a 100644 (file)
--- a/crypt-mod.h
+++ b/crypt-mod.h
@@ -28,15 +28,15 @@ typedef int (*crypt_func_decrypt_mime_t) (FILE * a, FILE ** b,
 typedef int (*crypt_func_application_handler_t) (BODY * m, STATE * s);
 typedef int (*crypt_func_encrypted_handler_t) (BODY * m, STATE * s);
 
 typedef int (*crypt_func_application_handler_t) (BODY * m, STATE * s);
 typedef int (*crypt_func_encrypted_handler_t) (BODY * m, STATE * s);
 

-typedef void (*crypt_func_pgp_invoke_getkeys_t) (ADDRESS * addr);
+typedef void (*crypt_func_pgp_invoke_getkeys_t) (address_t * addr);

 typedef int (*crypt_func_pgp_check_traditional_t) (FILE * fp, BODY * b,
                                                    int tagged_only);
 typedef BODY *(*crypt_func_pgp_traditional_encryptsign_t) (BODY * a,
                                                            int flags,
                                                            char *keylist);
 typedef BODY *(*crypt_func_pgp_make_key_attachment_t) (char *tempf);
 typedef int (*crypt_func_pgp_check_traditional_t) (FILE * fp, BODY * b,
                                                    int tagged_only);
 typedef BODY *(*crypt_func_pgp_traditional_encryptsign_t) (BODY * a,
                                                            int flags,
                                                            char *keylist);
 typedef BODY *(*crypt_func_pgp_make_key_attachment_t) (char *tempf);

-typedef char *(*crypt_func_findkeys_t) (ADDRESS * to,
-                                        ADDRESS * cc, ADDRESS * bcc);
+typedef char *(*crypt_func_findkeys_t) (address_t * to,
+                                        address_t * cc, address_t * bcc);

 typedef BODY *(*crypt_func_sign_message_t) (BODY * a);
 typedef BODY *(*crypt_func_pgp_encrypt_message_t) (BODY * a, char *keylist,
                                                    int sign);
 typedef BODY *(*crypt_func_sign_message_t) (BODY * a);
 typedef BODY *(*crypt_func_pgp_encrypt_message_t) (BODY * a, char *keylist,
                                                    int sign);

diff --git a/crypt.c b/crypt.c
index ab611bf..c0c64ad 100644 (file)
--- a/crypt.c
+++ b/crypt.c
@@ -556,7 +556,7 @@ void crypt_extract_keys_from_messages (HEADER * h)
 {
   int i;
   char tempfname[_POSIX_PATH_MAX], *mbox;
 {
   int i;
   char tempfname[_POSIX_PATH_MAX], *mbox;

-  ADDRESS *tmp = NULL;
+  address_t *tmp = NULL;

   FILE *fpout;
 
   if (!WithCrypto)
   FILE *fpout;
 
   if (!WithCrypto)

diff --git a/cryptglue.c b/cryptglue.c
index dc82b4a..d83b612 100644 (file)
--- a/cryptglue.c
+++ b/cryptglue.c
@@ -158,7 +158,7 @@ int crypt_pgp_encrypted_handler (BODY * a, STATE * s)
 }
 
 /* fixme: needs documentation. */
 }
 
 /* fixme: needs documentation. */

-void crypt_pgp_invoke_getkeys (ADDRESS * addr)
+void crypt_pgp_invoke_getkeys (address_t * addr)

 {
   if (CRYPT_MOD_CALL_CHECK (PGP, pgp_invoke_getkeys))
     (CRYPT_MOD_CALL (PGP, pgp_invoke_getkeys)) (addr);
 {
   if (CRYPT_MOD_CALL_CHECK (PGP, pgp_invoke_getkeys))
     (CRYPT_MOD_CALL (PGP, pgp_invoke_getkeys)) (addr);


@@ -194,7 +194,7 @@ BODY *crypt_pgp_make_key_attachment (char *tempf)
 
 /* This routine attempts to find the keyids of the recipients of a
    message.  It returns NULL if any of the keys can not be found.  */
 
 /* This routine attempts to find the keyids of the recipients of a
    message.  It returns NULL if any of the keys can not be found.  */

-char *crypt_pgp_findkeys (ADDRESS * to, ADDRESS * cc, ADDRESS * bcc)
+char *crypt_pgp_findkeys (address_t * to, address_t * cc, address_t * bcc)

 {
   if (CRYPT_MOD_CALL_CHECK (PGP, findkeys))
     return (CRYPT_MOD_CALL (PGP, findkeys)) (to, cc, bcc);
 {
   if (CRYPT_MOD_CALL_CHECK (PGP, findkeys))
     return (CRYPT_MOD_CALL (PGP, findkeys)) (to, cc, bcc);


@@ -323,7 +323,7 @@ int crypt_smime_verify_sender (HEADER * h)
 
 /* This routine attempts to find the keyids of the recipients of a
    message.  It returns NULL if any of the keys can not be found.  */
 
 /* This routine attempts to find the keyids of the recipients of a
    message.  It returns NULL if any of the keys can not be found.  */

-char *crypt_smime_findkeys (ADDRESS * to, ADDRESS * cc, ADDRESS * bcc)
+char *crypt_smime_findkeys (address_t * to, address_t * cc, address_t * bcc)

 {
   if (CRYPT_MOD_CALL_CHECK (SMIME, findkeys))
     return (CRYPT_MOD_CALL (SMIME, findkeys)) (to, cc, bcc);
 {
   if (CRYPT_MOD_CALL_CHECK (SMIME, findkeys))
     return (CRYPT_MOD_CALL (SMIME, findkeys)) (to, cc, bcc);

diff --git a/globals.h b/globals.h
index fac8994..7a624d9 100644 (file)
--- a/globals.h
+++ b/globals.h
@@ -29,8 +29,8 @@ WHERE char Quotebuf[SHORT_STRING];
 WHERE char *MuttDotlock;
 #endif
 
 WHERE char *MuttDotlock;
 #endif
 

-WHERE ADDRESS *EnvFrom;
-WHERE ADDRESS *From;
+WHERE address_t *EnvFrom;
+WHERE address_t *From;

 
 WHERE char *AliasFile;
 WHERE char *AliasFmt;
 
 WHERE char *AliasFile;
 WHERE char *AliasFmt;

diff --git a/hcache.c b/hcache.c
index e6a1b6d..140df18 100644 (file)
--- a/hcache.c
+++ b/hcache.c
@@ -172,7 +172,7 @@ static void restore_char (char **c, const unsigned char *d, int *off)
   *off += size;
 }
 
   *off += size;
 }
 

-static unsigned char *dump_address (ADDRESS * a, unsigned char *d, int *off)
+static unsigned char *dump_address (address_t * a, unsigned char *d, int *off)

 {
   unsigned int counter = 0;
   unsigned int start_off = *off;
 {
   unsigned int counter = 0;
   unsigned int start_off = *off;


@@ -192,14 +192,14 @@ static unsigned char *dump_address (ADDRESS * a, unsigned char *d, int *off)
   return d;
 }
 
   return d;
 }
 

-static void restore_address (ADDRESS ** a, const unsigned char *d, int *off)
+static void restore_address (address_t ** a, const unsigned char *d, int *off)

 {
   unsigned int counter;
 
   restore_int (&counter, d, off);
 
   while (counter) {
 {
   unsigned int counter;
 
   restore_int (&counter, d, off);
 
   while (counter) {

-    *a = p_new(ADDRESS, 1);
+    *a = p_new(address_t, 1);

     restore_char (&(*a)->personal, d, off);
     restore_char (&(*a)->mailbox, d, off);
     restore_int ((unsigned int *) &(*a)->group, d, off);
     restore_char (&(*a)->personal, d, off);
     restore_char (&(*a)->mailbox, d, off);
     restore_int ((unsigned int *) &(*a)->group, d, off);

diff --git a/hdrline.c b/hdrline.c
index a568c9a..b47e2bd 100644 (file)
--- a/hdrline.c
+++ b/hdrline.c
@@ -30,14 +30,14 @@
 #include <string.h>
 #include <locale.h>
 
 #include <string.h>
 #include <locale.h>
 

-int mutt_is_mail_list (ADDRESS * addr)
+int mutt_is_mail_list (address_t * addr)

 {
   if (!rx_list_match (UnMailLists, addr->mailbox))
     return rx_list_match (MailLists, addr->mailbox);
   return 0;
 }
 
 {
   if (!rx_list_match (UnMailLists, addr->mailbox))
     return rx_list_match (MailLists, addr->mailbox);
   return 0;
 }
 

-int mutt_is_subscribed_list (ADDRESS * addr)
+int mutt_is_subscribed_list (address_t * addr)

 {
   if (!rx_list_match (UnMailLists, addr->mailbox)
       && !rx_list_match (UnSubscribedLists, addr->mailbox))
 {
   if (!rx_list_match (UnMailLists, addr->mailbox)
       && !rx_list_match (UnSubscribedLists, addr->mailbox))


@@ -50,7 +50,7 @@ int mutt_is_subscribed_list (ADDRESS * addr)
  * return 1.  Otherwise, simply return 0.
  */
 static int
  * return 1.  Otherwise, simply return 0.
  */
 static int

-check_for_mailing_list (ADDRESS * adr, const char *pfx, char *buf, int buflen)
+check_for_mailing_list (address_t * adr, const char *pfx, char *buf, int buflen)

 {
   for (; adr; adr = adr->next) {
     if (mutt_is_subscribed_list (adr)) {
 {
   for (; adr; adr = adr->next) {
     if (mutt_is_subscribed_list (adr)) {


@@ -66,7 +66,7 @@ check_for_mailing_list (ADDRESS * adr, const char *pfx, char *buf, int buflen)
  * If one is found, print the address of the list into buf, then return 1.
  * Otherwise, simply return 0.
  */
  * If one is found, print the address of the list into buf, then return 1.
  * Otherwise, simply return 0.
  */

-static int check_for_mailing_list_addr (ADDRESS * adr, char *buf, int buflen)
+static int check_for_mailing_list_addr (address_t * adr, char *buf, int buflen)

 {
   for (; adr; adr = adr->next) {
     if (mutt_is_subscribed_list (adr)) {
 {
   for (; adr; adr = adr->next) {
     if (mutt_is_subscribed_list (adr)) {


@@ -79,7 +79,7 @@ static int check_for_mailing_list_addr (ADDRESS * adr, char *buf, int buflen)
 }
 
 
 }
 
 

-static int first_mailing_list (char *buf, size_t buflen, ADDRESS * a)
+static int first_mailing_list (char *buf, size_t buflen, address_t * a)

 {
   for (; a; a = a->next) {
     if (mutt_is_subscribed_list (a)) {
 {
   for (; a; a = a->next) {
     if (mutt_is_subscribed_list (a)) {


@@ -137,7 +137,7 @@ static void make_from_addr (ENVELOPE * hdr, char *buf, size_t len,
     *buf = 0;
 }
 
     *buf = 0;
 }
 

-static int user_in_addr (ADDRESS * a)
+static int user_in_addr (address_t * a)

 {
   for (; a; a = a->next)
     if (mutt_addr_is_user (a))
 {
   for (; a; a = a->next)
     if (mutt_addr_is_user (a))

diff --git a/hook.c b/hook.c
index c6686ae..7347070 100644 (file)
--- a/hook.c
+++ b/hook.c
@@ -375,7 +375,7 @@ void mutt_default_save (char *path, size_t pathlen, HEADER * hdr)
   *path = 0;
   if (mutt_addr_hook (path, pathlen, M_SAVEHOOK, Context, hdr) != 0) {
     char tmp[_POSIX_PATH_MAX];
   *path = 0;
   if (mutt_addr_hook (path, pathlen, M_SAVEHOOK, Context, hdr) != 0) {
     char tmp[_POSIX_PATH_MAX];

-    ADDRESS *adr;
+    address_t *adr;

     ENVELOPE *env = hdr->env;
     int fromMe = mutt_addr_is_user (env->from);
 
     ENVELOPE *env = hdr->env;
     int fromMe = mutt_addr_is_user (env->from);
 


@@ -398,7 +398,7 @@ void mutt_default_save (char *path, size_t pathlen, HEADER * hdr)
 
 void mutt_select_fcc (char *path, size_t pathlen, HEADER * hdr)
 {
 
 void mutt_select_fcc (char *path, size_t pathlen, HEADER * hdr)
 {

-  ADDRESS *adr;
+  address_t *adr;

   char buf[_POSIX_PATH_MAX];
   ENVELOPE *env = hdr->env;
 
   char buf[_POSIX_PATH_MAX];
   ENVELOPE *env = hdr->env;
 


@@ -440,7 +440,7 @@ char *mutt_iconv_hook (const char *chs)
   return _mutt_string_hook (chs, M_ICONVHOOK);
 }
 
   return _mutt_string_hook (chs, M_ICONVHOOK);
 }
 

-char *mutt_crypt_hook (ADDRESS * adr)
+char *mutt_crypt_hook (address_t * adr)

 {
   return _mutt_string_hook (adr->mailbox, M_CRYPTHOOK);
 }
 {
   return _mutt_string_hook (adr->mailbox, M_CRYPTHOOK);
 }

diff --git a/init.c b/init.c
index c96e350..94e1707 100644 (file)
--- a/init.c
+++ b/init.c
@@ -517,7 +517,7 @@ static void addr_to_string (char* dst, size_t dstlen,
                             struct option_t* option) {
   char s[HUGE_STRING];
   s[0] = '\0';
                             struct option_t* option) {
   char s[HUGE_STRING];
   s[0] = '\0';

-  rfc822_write_address (s, sizeof(s), *((ADDRESS**) option->data), 0);
+  rfc822_write_address (s, sizeof(s), *((address_t**) option->data), 0);

   snprintf (dst, dstlen, "%s=\"%s\"", option->option, NONULL (s));
 }
 
   snprintf (dst, dstlen, "%s=\"%s\"", option->option, NONULL (s));
 }
 


@@ -525,9 +525,9 @@ static int addr_from_string (struct option_t* dst, const char* val,
                              char* errbuf, size_t errlen) {
   if (!dst)
     return (0);
                              char* errbuf, size_t errlen) {
   if (!dst)
     return (0);

-  rfc822_free_address ((ADDRESS**) dst->data);
+  rfc822_free_address ((address_t**) dst->data);

   if (val && *val)
   if (val && *val)

-    *((ADDRESS**) dst->data) = rfc822_parse_adrlist (NULL, val);
+    *((address_t**) dst->data) = rfc822_parse_adrlist (NULL, val);

   return (1);
 }
 
   return (1);
 }
 


@@ -1460,7 +1460,7 @@ static int parse_alias (BUFFER * buf, BUFFER * s, unsigned long data,
   }
 #ifdef DEBUG
   if (DebugLevel >= 2) {
   }
 #ifdef DEBUG
   if (DebugLevel >= 2) {

-    ADDRESS *a;
+    address_t *a;

 
     /* A group is terminated with an empty address, so check a->mailbox */
     for (a = tmp->addr; a && a->mailbox; a = a->next) {
 
     /* A group is terminated with an empty address, so check a->mailbox */
     for (a = tmp->addr; a && a->mailbox; a = a->next) {


@@ -1972,7 +1972,7 @@ static int parse_set (BUFFER * tmp, BUFFER * s, unsigned long data,
             r = -1;
             break;
           } else if (DTYPE (option->type) == DT_ADDR)
             r = -1;
             break;
           } else if (DTYPE (option->type) == DT_ADDR)

-            rfc822_free_address ((ADDRESS **) option->data);
+            rfc822_free_address ((address_t **) option->data);

           else if (DTYPE (option->type) == DT_USER)
             /* to unset $user_ means remove */
             hash_delete (ConfigOptions, option->option,
           else if (DTYPE (option->type) == DT_USER)
             /* to unset $user_ means remove */
             hash_delete (ConfigOptions, option->option,


@@ -2424,7 +2424,7 @@ int mutt_var_value_complete (char *buffer, size_t len, int pos)
       }
       else if (DTYPE (option->type) == DT_ADDR) {
         rfc822_write_address (tmp, sizeof(tmp),
       }
       else if (DTYPE (option->type) == DT_ADDR) {
         rfc822_write_address (tmp, sizeof(tmp),

-                              *((ADDRESS **) option->data), 0);
+                              *((address_t **) option->data), 0);

       }
       else if (DTYPE (option->type) == DT_QUAD)
         m_strcpy(tmp, sizeof(tmp), vals[quadoption(option->data)]);
       }
       else if (DTYPE (option->type) == DT_QUAD)
         m_strcpy(tmp, sizeof(tmp), vals[quadoption(option->data)]);

diff --git a/lib-mime/mime.h b/lib-mime/mime.h
index 1cf264a..f2e7b6a 100644 (file)
--- a/lib-mime/mime.h
+++ b/lib-mime/mime.h
@@ -102,16 +102,16 @@ typedef struct address_t {
     char *mailbox;                /* mailbox and host address */
     int group;                    /* group mailbox? */
     struct address_t *next;
     char *mailbox;                /* mailbox and host address */
     int group;                    /* group mailbox? */
     struct address_t *next;

-} ADDRESS;
-
-void rfc822_free_address(ADDRESS **);
-void rfc822_qualify(ADDRESS *, const char *);
-ADDRESS *rfc822_parse_adrlist(ADDRESS *, const char *s);
-ADDRESS *rfc822_cpy_adr(ADDRESS * addr);
-ADDRESS *rfc822_cpy_adr_real(ADDRESS * addr);
-ADDRESS *rfc822_append(ADDRESS ** a, ADDRESS * b);
-void rfc822_write_address(char *, size_t, ADDRESS *, int);
-void rfc822_write_address_single(char *, size_t, ADDRESS *, int);
+} address_t;
+
+void rfc822_free_address(address_t **);
+void rfc822_qualify(address_t *, const char *);
+address_t *rfc822_parse_adrlist(address_t *, const char *s);
+address_t *rfc822_cpy_adr(address_t * addr);
+address_t *rfc822_cpy_adr_real(address_t * addr);
+address_t *rfc822_append(address_t ** a, address_t * b);
+void rfc822_write_address(char *, size_t, address_t *, int);
+void rfc822_write_address_single(char *, size_t, address_t *, int);

 void rfc822_cat(char *, size_t, const char *, const char *);
 
 extern int RFC822Error;
 void rfc822_cat(char *, size_t, const char *, const char *);
 
 extern int RFC822Error;


@@ -119,7 +119,7 @@ extern const char *RFC822Errors[];
 extern const char RFC822Specials[];
 
 #define rfc822_error(x) RFC822Errors[x]
 extern const char RFC822Specials[];
 
 #define rfc822_error(x) RFC822Errors[x]

-#define rfc822_new_address() calloc(1,sizeof(ADDRESS))
+#define rfc822_new_address() calloc(1,sizeof(address_t))

 
 /****************************************************************************/
 /* RFC 2231                                                                 */
 
 /****************************************************************************/
 /* RFC 2231                                                                 */

diff --git a/lib-mime/rfc822.c b/lib-mime/rfc822.c
index 82c3e7c..0337478 100644 (file)
--- a/lib-mime/rfc822.c
+++ b/lib-mime/rfc822.c
@@ -79,9 +79,9 @@ void rfc822_dequote_comment (char *s)
   *w = 0;
 }
 
   *w = 0;
 }
 

-void rfc822_free_address (ADDRESS ** p)
+void rfc822_free_address (address_t ** p)

 {
 {

-  ADDRESS *t;
+  address_t *t;

 
   while (*p) {
     t = *p;
 
   while (*p) {
     t = *p;


@@ -202,7 +202,7 @@ static const char *parse_address (const char *s,
                                   char *token, size_t * tokenlen,
                                   size_t tokenmax, char *comment,
                                   size_t * commentlen, size_t commentmax,
                                   char *token, size_t * tokenlen,
                                   size_t tokenmax, char *comment,
                                   size_t * commentlen, size_t commentmax,

-                                  ADDRESS * addr)
+                                  address_t * addr)

 {
   s = parse_mailboxdomain (s, ".\"(\\",
                            token, tokenlen, tokenmax,
 {
   s = parse_mailboxdomain (s, ".\"(\\",
                            token, tokenlen, tokenmax,


@@ -233,7 +233,7 @@ static const char *parse_address (const char *s,
 
 static const char *parse_route_addr (const char *s,
                                      char *comment, size_t * commentlen,
 
 static const char *parse_route_addr (const char *s,
                                      char *comment, size_t * commentlen,

-                                     size_t commentmax, ADDRESS * addr)
+                                     size_t commentmax, address_t * addr)

 {
   char token[STRING];
   size_t tokenlen = 0;
 {
   char token[STRING];
   size_t tokenlen = 0;


@@ -278,7 +278,7 @@ static const char *parse_route_addr (const char *s,
 
 static const char *parse_addr_spec (const char *s,
                                     char *comment, size_t * commentlen,
 
 static const char *parse_addr_spec (const char *s,
                                     char *comment, size_t * commentlen,

-                                    size_t commentmax, ADDRESS * addr)
+                                    size_t commentmax, address_t * addr)

 {
   char token[STRING];
   size_t tokenlen = 0;
 {
   char token[STRING];
   size_t tokenlen = 0;


@@ -294,10 +294,10 @@ static const char *parse_addr_spec (const char *s,
 }
 
 static void
 }
 
 static void

-add_addrspec (ADDRESS ** top, ADDRESS ** last, const char *phrase,
+add_addrspec (address_t ** top, address_t ** last, const char *phrase,

               char *comment, size_t * commentlen, size_t commentmax)
 {
               char *comment, size_t * commentlen, size_t commentmax)
 {

-  ADDRESS *cur = rfc822_new_address ();
+  address_t *cur = rfc822_new_address ();

 
   if (parse_addr_spec (phrase, comment, commentlen, commentmax, cur) == NULL) {
     rfc822_free_address (&cur);
 
   if (parse_addr_spec (phrase, comment, commentlen, commentmax, cur) == NULL) {
     rfc822_free_address (&cur);


@@ -311,13 +311,13 @@ add_addrspec (ADDRESS ** top, ADDRESS ** last, const char *phrase,
   *last = cur;
 }
 
   *last = cur;
 }
 

-ADDRESS *rfc822_parse_adrlist (ADDRESS * top, const char *s)
+address_t *rfc822_parse_adrlist (address_t * top, const char *s)

 {
   int ws_pending;
   const char *begin, *ps;
   char comment[STRING], phrase[STRING];
   size_t phraselen = 0, commentlen = 0;
 {
   int ws_pending;
   const char *begin, *ps;
   char comment[STRING], phrase[STRING];
   size_t phraselen = 0, commentlen = 0;

-  ADDRESS *cur, *last = NULL;
+  address_t *cur, *last = NULL;

 
   RFC822Error = 0;
 
 
   RFC822Error = 0;
 


@@ -452,7 +452,7 @@ ADDRESS *rfc822_parse_adrlist (ADDRESS * top, const char *s)
   return top;
 }
 
   return top;
 }
 

-void rfc822_qualify (ADDRESS * addr, const char *host)
+void rfc822_qualify (address_t * addr, const char *host)

 {
   char *p;
 
 {
   char *p;
 


@@ -489,7 +489,7 @@ rfc822_cat (char *buf, size_t buflen, const char *value, const char *specials)
     m_strcpy(buf, buflen, value);
 }
 
     m_strcpy(buf, buflen, value);
 }
 

-void rfc822_write_address_single (char *buf, size_t buflen, ADDRESS * addr,
+void rfc822_write_address_single (char *buf, size_t buflen, address_t * addr,

                                   int display)
 {
   size_t len;
                                   int display)
 {
   size_t len;


@@ -595,7 +595,7 @@ done:
 }
 
 /* note: it is assumed that `buf' is nul terminated! */
 }
 
 /* note: it is assumed that `buf' is nul terminated! */

-void rfc822_write_address (char *buf, size_t buflen, ADDRESS * addr,
+void rfc822_write_address (char *buf, size_t buflen, address_t * addr,

                            int display)
 {
   char *pbuf = buf;
                            int display)
 {
   char *pbuf = buf;


@@ -648,9 +648,9 @@ done:
 }
 
 /* this should be rfc822_cpy_adr */
 }
 
 /* this should be rfc822_cpy_adr */

-ADDRESS *rfc822_cpy_adr_real (ADDRESS * addr)
+address_t *rfc822_cpy_adr_real (address_t * addr)

 {
 {

-  ADDRESS *p = rfc822_new_address ();
+  address_t *p = rfc822_new_address ();

 
   p->personal = m_strdup(addr->personal);
   p->mailbox = m_strdup(addr->mailbox);
 
   p->personal = m_strdup(addr->personal);
   p->mailbox = m_strdup(addr->mailbox);


@@ -659,9 +659,9 @@ ADDRESS *rfc822_cpy_adr_real (ADDRESS * addr)
 }
 
 /* this should be rfc822_cpy_adrlist */
 }
 
 /* this should be rfc822_cpy_adrlist */

-ADDRESS *rfc822_cpy_adr (ADDRESS * addr)
+address_t *rfc822_cpy_adr (address_t * addr)

 {
 {

-  ADDRESS *top = NULL, *last = NULL;
+  address_t *top = NULL, *last = NULL;

 
   for (; addr; addr = addr->next) {
     if (last) {
 
   for (; addr; addr = addr->next) {
     if (last) {


@@ -675,9 +675,9 @@ ADDRESS *rfc822_cpy_adr (ADDRESS * addr)
 }
 
 /* append list 'b' to list 'a' and return the last element in the new list */
 }
 
 /* append list 'b' to list 'a' and return the last element in the new list */

-ADDRESS *rfc822_append (ADDRESS ** a, ADDRESS * b)
+address_t *rfc822_append (address_t ** a, address_t * b)

 {
 {

-  ADDRESS *tmp = *a;
+  address_t *tmp = *a;

 
   while (tmp && tmp->next)
     tmp = tmp->next;
 
   while (tmp && tmp->next)
     tmp = tmp->next;

diff --git a/main.c b/main.c
index 54899d8..2fd4155 100644 (file)
--- a/main.c
+++ b/main.c
@@ -788,7 +788,7 @@ int main (int argc, char **argv)
 
   if (alias_queries) {
     int rv = 0;
 
   if (alias_queries) {
     int rv = 0;

-    ADDRESS *a;
+    address_t *a;

 
     for (; alias_queries; alias_queries = alias_queries->next) {
       if ((a = mutt_lookup_alias (alias_queries->data))) {
 
     for (; alias_queries; alias_queries = alias_queries->next) {
       if ((a = mutt_lookup_alias (alias_queries->data))) {

diff --git a/mutt.h b/mutt.h
index 2ef4a1b..e4e192d 100644 (file)
--- a/mutt.h
+++ b/mutt.h
@@ -536,14 +536,14 @@ int mutt_matches_ignore (const char *, LIST *);
 void mutt_init (int, LIST *);
 
 typedef struct envelope {
 void mutt_init (int, LIST *);
 
 typedef struct envelope {

-  ADDRESS *return_path;
-  ADDRESS *from;
-  ADDRESS *to;
-  ADDRESS *cc;
-  ADDRESS *bcc;
-  ADDRESS *sender;
-  ADDRESS *reply_to;
-  ADDRESS *mail_followup_to;
+  address_t *return_path;
+  address_t *from;
+  address_t *to;
+  address_t *cc;
+  address_t *bcc;
+  address_t *sender;
+  address_t *reply_to;
+  address_t *mail_followup_to;

   char *list_post;              /* this stores a mailto URL, or nothing */
   char *subject;
   char *real_subj;              /* offset of the real subject */
   char *list_post;              /* this stores a mailto URL, or nothing */
   char *subject;
   char *real_subj;              /* offset of the real subject */

diff --git a/mutt_crypt.h b/mutt_crypt.h
index 8d64d35..e9713f4 100644 (file)
--- a/mutt_crypt.h
+++ b/mutt_crypt.h
@@ -16,7 +16,7 @@
 #ifndef MUTT_CRYPT_H
 #define MUTT_CRYPT_H
 
 #ifndef MUTT_CRYPT_H
 #define MUTT_CRYPT_H
 

-#include "mutt.h"               /* Need this to declare BODY, ADDRESS. STATE etc. */
+#include "mutt.h"               /* Need this to declare BODY, address_t. STATE etc. */

 #include "state.h"
 
 /* FIXME: They should be pointer to anonymous structures for better
 #include "state.h"
 
 /* FIXME: They should be pointer to anonymous structures for better


@@ -169,7 +169,7 @@ int crypt_pgp_application_pgp_handler (BODY * m, STATE * s);
 int crypt_pgp_encrypted_handler (BODY * a, STATE * s);
 
 /* fixme: needs documentation. */
 int crypt_pgp_encrypted_handler (BODY * a, STATE * s);
 
 /* fixme: needs documentation. */

-void crypt_pgp_invoke_getkeys (ADDRESS * addr);
+void crypt_pgp_invoke_getkeys (address_t * addr);

 
 /* Ask for a PGP key. */
 pgp_key_t crypt_pgp_ask_for_key (char *tag, char *whatfor,
 
 /* Ask for a PGP key. */
 pgp_key_t crypt_pgp_ask_for_key (char *tag, char *whatfor,


@@ -189,7 +189,7 @@ BODY *crypt_pgp_make_key_attachment (char *tempf);
 
 /* This routine attempts to find the keyids of the recipients of a
    message.  It returns NULL if any of the keys can not be found.  */
 
 /* This routine attempts to find the keyids of the recipients of a
    message.  It returns NULL if any of the keys can not be found.  */

-char *crypt_pgp_findkeys (ADDRESS * to, ADDRESS * cc, ADDRESS * bcc);
+char *crypt_pgp_findkeys (address_t * to, address_t * cc, address_t * bcc);

 
 /* Create a new body with a PGP signed message from A. */
 BODY *crypt_pgp_sign_message (BODY * a);
 
 /* Create a new body with a PGP signed message from A. */
 BODY *crypt_pgp_sign_message (BODY * a);


@@ -239,7 +239,7 @@ char *crypt_smime_ask_for_key (char *prompt, char *mailbox, short public);
 
 /* This routine attempts to find the keyids of the recipients of a
    message.  It returns NULL if any of the keys can not be found.  */
 
 /* This routine attempts to find the keyids of the recipients of a
    message.  It returns NULL if any of the keys can not be found.  */

-char *crypt_smime_findkeys (ADDRESS * to, ADDRESS * cc, ADDRESS * bcc);
+char *crypt_smime_findkeys (address_t * to, address_t * cc, address_t * bcc);

 
 /* fixme: Needs documentation. */
 BODY *crypt_smime_sign_message (BODY * a);
 
 /* fixme: Needs documentation. */
 BODY *crypt_smime_sign_message (BODY * a);

diff --git a/mutt_idna.c b/mutt_idna.c
index 91a3349..c08f2f7 100644 (file)
--- a/mutt_idna.c
+++ b/mutt_idna.c
@@ -135,7 +135,7 @@ static int mbox_to_udomain (const char *mbx, char **user, char **domain)
   return 0;
 }
 
   return 0;
 }
 

-int mutt_addrlist_to_idna (ADDRESS * a, char **err)
+int mutt_addrlist_to_idna (address_t * a, char **err)

 {
   char *user = NULL, *domain = NULL;
   char *tmp = NULL;
 {
   char *user = NULL, *domain = NULL;
   char *tmp = NULL;


@@ -171,7 +171,7 @@ int mutt_addrlist_to_idna (ADDRESS * a, char **err)
   return 0;
 }
 
   return 0;
 }
 

-int mutt_addrlist_to_local (ADDRESS * a)
+int mutt_addrlist_to_local (address_t * a)

 {
   char *user, *domain;
   char *tmp = NULL;
 {
   char *user, *domain;
   char *tmp = NULL;


@@ -196,7 +196,7 @@ int mutt_addrlist_to_local (ADDRESS * a)
 }
 
 /* convert just for displaying purposes */
 }
 
 /* convert just for displaying purposes */

-const char *mutt_addr_for_display (ADDRESS * a)
+const char *mutt_addr_for_display (address_t * a)

 {
   static char *buff = NULL;
   char *tmp = NULL;
 {
   static char *buff = NULL;
   char *tmp = NULL;

diff --git a/mutt_idna.h b/mutt_idna.h
index 1149283..25443b2 100644 (file)
--- a/mutt_idna.h
+++ b/mutt_idna.h
@@ -26,13 +26,13 @@
 int mutt_idna_to_local (const char *, char **, int);
 int mutt_local_to_idna (const char *, char **);
 
 int mutt_idna_to_local (const char *, char **, int);
 int mutt_local_to_idna (const char *, char **);
 

-int mutt_addrlist_to_idna (ADDRESS *, char **);
-int mutt_addrlist_to_local (ADDRESS *);
+int mutt_addrlist_to_idna (address_t *, char **);
+int mutt_addrlist_to_local (address_t *);

 
 void mutt_env_to_local (ENVELOPE *);
 int mutt_env_to_idna (ENVELOPE *, const char **, const char **);
 
 
 void mutt_env_to_local (ENVELOPE *);
 int mutt_env_to_idna (ENVELOPE *, const char **, const char **);
 

-const char *mutt_addr_for_display (ADDRESS * a);
+const char *mutt_addr_for_display (address_t * a);

 
 /* Work around incompatibilities in the libidn API */
 
 
 /* Work around incompatibilities in the libidn API */
 

diff --git a/mutt_libesmtp.c b/mutt_libesmtp.c
index 11ea993..f51bd2e 100644 (file)
--- a/mutt_libesmtp.c
+++ b/mutt_libesmtp.c
@@ -95,7 +95,7 @@ static void _mutt_libesmtp_perror (const char *msg)
  *   Very similar to sendlib.c::add_args
  */
 static int
  *   Very similar to sendlib.c::add_args
  */
 static int

-_mutt_libesmtp_add_recipients (smtp_message_t message, ADDRESS * addr)
+_mutt_libesmtp_add_recipients (smtp_message_t message, address_t * addr)

 {
   int ret = 0;
 
 {
   int ret = 0;
 


@@ -304,8 +304,8 @@ int mutt_libesmtp_check_usetls (const char* option, unsigned long p,
  *   Returns 0 upon success, -1 upon failure (and prints an error
  *   message).
  */
  *   Returns 0 upon success, -1 upon failure (and prints an error
  *   message).
  */

-int mutt_libesmtp_invoke (ADDRESS * from,       /* the sender */
-                          ADDRESS * to, ADDRESS * cc, ADDRESS * bcc,    /* recips */
+int mutt_libesmtp_invoke (address_t * from,       /* the sender */
+                          address_t * to, address_t * cc, address_t * bcc,    /* recips */

                           const char *msg,      /* file containing message */
                           int eightbit)
 {                               /* message contains 8bit chars */
                           const char *msg,      /* file containing message */
                           int eightbit)
 {                               /* message contains 8bit chars */

diff --git a/mutt_libesmtp.h b/mutt_libesmtp.h
index 0592002..c11ee2c 100644 (file)
--- a/mutt_libesmtp.h
+++ b/mutt_libesmtp.h
@@ -15,8 +15,8 @@ int mutt_libesmtp_check_usetls (const char* option, unsigned long p,
                                 char* errbuf, size_t errlen);
 #endif
 
                                 char* errbuf, size_t errlen);
 #endif
 

-int mutt_libesmtp_invoke (ADDRESS * from,       /* the sender */
-                          ADDRESS * to, ADDRESS * cc, ADDRESS * bcc,    /* recips */
+int mutt_libesmtp_invoke (address_t * from,       /* the sender */
+                          address_t * to, address_t * cc, address_t * bcc,    /* recips */

                           const char *msg,      /* file containing message */
                           int eightbit);        /* message contains 8bit chars */
 
                           const char *msg,      /* file containing message */
                           int eightbit);        /* message contains 8bit chars */
 

diff --git a/muttlib.c b/muttlib.c
index f82560a..442a8fc 100644 (file)
--- a/muttlib.c
+++ b/muttlib.c
@@ -357,7 +357,7 @@ char *_mutt_expand_path (char *s, size_t slen, int rx)
     case '@':
       {
         HEADER *h;
     case '@':
       {
         HEADER *h;

-        ADDRESS *alias;
+        address_t *alias;

 
         if ((alias = mutt_lookup_alias (s + 1))) {
           h = mutt_new_header ();
 
         if ((alias = mutt_lookup_alias (s + 1))) {
           h = mutt_new_header ();


@@ -879,7 +879,7 @@ int mutt_check_overwrite (const char *attname, const char *path,
   return 0;
 }
 
   return 0;
 }
 

-void mutt_save_path (char *d, size_t dsize, ADDRESS * a)
+void mutt_save_path (char *d, size_t dsize, address_t * a)

 {
   if (a && a->mailbox) {
     m_strcpy(d, dsize, a->mailbox);
 {
   if (a && a->mailbox) {
     m_strcpy(d, dsize, a->mailbox);


@@ -895,7 +895,7 @@ void mutt_save_path (char *d, size_t dsize, ADDRESS * a)
     *d = 0;
 }
 
     *d = 0;
 }
 

-void mutt_safe_path (char *s, size_t l, ADDRESS * a)
+void mutt_safe_path (char *s, size_t l, address_t * a)

 {
   char *p;
 
 {
   char *p;
 


@@ -1392,7 +1392,7 @@ int mutt_cmp_header (const HEADER * h1, const HEADER * h2) {
 }
 
 /* return 1 if address lists are strictly identical */
 }
 
 /* return 1 if address lists are strictly identical */

-int mutt_cmp_addr (const ADDRESS * a, const ADDRESS * b)
+int mutt_cmp_addr (const address_t * a, const address_t * b)

 {
   while (a && b) {
     if (m_strcmp(a->mailbox, b->mailbox) ||
 {
   while (a && b) {
     if (m_strcmp(a->mailbox, b->mailbox) ||

diff --git a/mx.c b/mx.c
index 5348821..4f831ca 100644 (file)
--- a/mx.c
+++ b/mx.c
@@ -1122,7 +1122,7 @@ int mx_sync_mailbox (CONTEXT* ctx, int* index_hint) {
 MESSAGE *mx_open_new_message (CONTEXT * dest, HEADER * hdr, int flags)
 {
   MESSAGE *msg;
 MESSAGE *mx_open_new_message (CONTEXT * dest, HEADER * hdr, int flags)
 {
   MESSAGE *msg;

-  ADDRESS *p = NULL;
+  address_t *p = NULL;

 
   if (!MX_IDX(dest->magic-1)) {
     debug_print (1, ("function unimplemented for mailbox type %d.\n", dest->magic));
 
   if (!MX_IDX(dest->magic-1)) {
     debug_print (1, ("function unimplemented for mailbox type %d.\n", dest->magic));

diff --git a/parse.c b/parse.c
index 8175f6f..d83f12b 100644 (file)
--- a/parse.c
+++ b/parse.c
@@ -1398,7 +1398,7 @@ ENVELOPE *mutt_read_rfc822_header (FILE * f, HEADER * hdr, short user_hdrs,
   return (e);
 }
 
   return (e);
 }
 

-ADDRESS *mutt_parse_adrlist (ADDRESS * p, const char *s)
+address_t *mutt_parse_adrlist (address_t * p, const char *s)

 {
   const char *q;
 
 {
   const char *q;
 

diff --git a/pattern.c b/pattern.c
index 7a535bb..66d8290 100644 (file)
--- a/pattern.c
+++ b/pattern.c
@@ -877,11 +877,11 @@ static int match_adrlist (pattern_t* pat, int match_personal, int alladdr,
                           int n, ...)
 {
   va_list ap;
                           int n, ...)
 {
   va_list ap;

-  ADDRESS *a;
+  address_t *a;

 
   va_start (ap, n);
   for (; n; n--) {
 
   va_start (ap, n);
   for (; n; n--) {

-    for (a = va_arg (ap, ADDRESS *); a; a = a->next) {
+    for (a = va_arg (ap, address_t *); a; a = a->next) {

       if (pat->alladdr ^
           ((a->mailbox && patmatch (pat, a->mailbox) == 0) ||
            (match_personal && a->personal &&
       if (pat->alladdr ^
           ((a->mailbox && patmatch (pat, a->mailbox) == 0) ||
            (match_personal && a->personal &&


@@ -903,7 +903,7 @@ static int match_reference (pattern_t* pat, LIST * refs)
   return 0;
 }
 
   return 0;
 }
 

-int mutt_is_list_recipient (int alladdr, ADDRESS * a1, ADDRESS * a2)
+int mutt_is_list_recipient (int alladdr, address_t * a1, address_t * a2)

 {
   for (; a1; a1 = a1->next)
     if (alladdr ^ mutt_is_subscribed_list (a1))
 {
   for (; a1; a1 = a1->next)
     if (alladdr ^ mutt_is_subscribed_list (a1))


@@ -914,7 +914,7 @@ int mutt_is_list_recipient (int alladdr, ADDRESS * a1, ADDRESS * a2)
   return alladdr;
 }
 
   return alladdr;
 }
 

-int mutt_is_list_cc (int alladdr, ADDRESS * a1, ADDRESS * a2)
+int mutt_is_list_cc (int alladdr, address_t * a1, address_t * a2)

 {
   for (; a1; a1 = a1->next)
     if (alladdr ^ mutt_is_mail_list (a1))
 {
   for (; a1; a1 = a1->next)
     if (alladdr ^ mutt_is_mail_list (a1))


@@ -925,7 +925,7 @@ int mutt_is_list_cc (int alladdr, ADDRESS * a1, ADDRESS * a2)
   return alladdr;
 }
 
   return alladdr;
 }
 

-static int match_user (int alladdr, ADDRESS * a1, ADDRESS * a2)
+static int match_user (int alladdr, address_t * a1, address_t * a2)

 {
   for (; a1; a1 = a1->next)
     if (alladdr ^ mutt_addr_is_user (a1))
 {
   for (; a1; a1 = a1->next)
     if (alladdr ^ mutt_addr_is_user (a1))

diff --git a/pgp.c b/pgp.c
index bdcba07..e198331 100644 (file)
--- a/pgp.c
+++ b/pgp.c
@@ -1078,14 +1078,14 @@ static short is_numerical_keyid (const char *s)
 /* This routine attempts to find the keyids of the recipients of a message.
  * It returns NULL if any of the keys can not be found.
  */
 /* This routine attempts to find the keyids of the recipients of a message.
  * It returns NULL if any of the keys can not be found.
  */

-char *pgp_findKeys (ADDRESS * to, ADDRESS * cc, ADDRESS * bcc)
+char *pgp_findKeys (address_t * to, address_t * cc, address_t * bcc)

 {
   char *keyID, *keylist = NULL, *t;
   size_t keylist_size = 0;
   size_t keylist_used = 0;
 {
   char *keyID, *keylist = NULL, *t;
   size_t keylist_size = 0;
   size_t keylist_used = 0;

-  ADDRESS *tmp = NULL, *addr = NULL;
-  ADDRESS **last = &tmp;
-  ADDRESS *p, *q;
+  address_t *tmp = NULL, *addr = NULL;
+  address_t **last = &tmp;
+  address_t *p, *q;

   int i;
   pgp_key_t k_info = NULL, key = NULL;
 
   int i;
   pgp_key_t k_info = NULL, key = NULL;
 

diff --git a/pgp.h b/pgp.h
index 92d9fac..55b1db3 100644 (file)
--- a/pgp.h
+++ b/pgp.h
@@ -37,10 +37,10 @@ int pgp_decrypt_mime (FILE *, FILE **, BODY *, BODY **);
 /* pgp_key_t gpg_get_candidates (struct pgp_vinfo *, pgp_ring_t, LIST *); */
 pgp_key_t pgp_ask_for_key (char *, char *, short, pgp_ring_t);
 pgp_key_t pgp_get_candidates (pgp_ring_t, LIST *);
 /* pgp_key_t gpg_get_candidates (struct pgp_vinfo *, pgp_ring_t, LIST *); */
 pgp_key_t pgp_ask_for_key (char *, char *, short, pgp_ring_t);
 pgp_key_t pgp_get_candidates (pgp_ring_t, LIST *);

-pgp_key_t pgp_getkeybyaddr (ADDRESS *, short, pgp_ring_t);
+pgp_key_t pgp_getkeybyaddr (address_t *, short, pgp_ring_t);

 pgp_key_t pgp_getkeybystr (char *, short, pgp_ring_t);
 
 pgp_key_t pgp_getkeybystr (char *, short, pgp_ring_t);
 

-char *pgp_findKeys (ADDRESS * to, ADDRESS * cc, ADDRESS * bcc);
+char *pgp_findKeys (address_t * to, address_t * cc, address_t * bcc);

 
 void pgp_forget_passphrase (void);
 int pgp_application_pgp_handler (BODY *, STATE *);
 
 void pgp_forget_passphrase (void);
 int pgp_application_pgp_handler (BODY *, STATE *);


@@ -82,7 +82,7 @@ pid_t pgp_invoke_traditional (FILE ** pgpin, FILE ** pgpout, FILE ** pgperr,
 
 
 void pgp_invoke_import (const char *fname);
 
 
 void pgp_invoke_import (const char *fname);

-void pgp_invoke_getkeys (ADDRESS *);
+void pgp_invoke_getkeys (address_t *);

 
 
 /* private ? */
 
 
 /* private ? */

diff --git a/pgpinvoke.c b/pgpinvoke.c
index b24687f..e22086e 100644 (file)
--- a/pgpinvoke.c
+++ b/pgpinvoke.c
@@ -265,7 +265,7 @@ void pgp_invoke_import (const char *fname)
   mutt_system (cmd);
 }
 
   mutt_system (cmd);
 }
 

-void pgp_invoke_getkeys (ADDRESS * addr)
+void pgp_invoke_getkeys (address_t * addr)

 {
   char buff[LONG_STRING];
   char tmp[LONG_STRING];
 {
   char buff[LONG_STRING];
   char tmp[LONG_STRING];

diff --git a/pgpkey.c b/pgpkey.c
index 425289e..62d050e 100644 (file)
--- a/pgpkey.c
+++ b/pgpkey.c
@@ -401,7 +401,7 @@ static int pgp_id_is_valid (pgp_uid_t * uid)
 
 #define PGP_KV_MATCH (PGP_KV_ADDR|PGP_KV_STRING)
 
 
 #define PGP_KV_MATCH (PGP_KV_ADDR|PGP_KV_STRING)
 

-static int pgp_id_matches_addr (ADDRESS * addr, ADDRESS * u_addr,
+static int pgp_id_matches_addr (address_t * addr, address_t * u_addr,

                                 pgp_uid_t * uid)
 {
   int rv = 0;
                                 pgp_uid_t * uid)
 {
   int rv = 0;


@@ -423,7 +423,7 @@ static int pgp_id_matches_addr (ADDRESS * addr, ADDRESS * u_addr,
   return rv;
 }
 
   return rv;
 }
 

-static pgp_key_t pgp_select_key (pgp_key_t keys, ADDRESS * p, const char *s)
+static pgp_key_t pgp_select_key (pgp_key_t keys, address_t * p, const char *s)

 {
   int keymax;
   pgp_uid_t **KeyTable;
 {
   int keymax;
   pgp_uid_t **KeyTable;


@@ -786,9 +786,9 @@ static pgp_key_t *pgp_get_lastp (pgp_key_t p)
   return NULL;
 }
 
   return NULL;
 }
 

-pgp_key_t pgp_getkeybyaddr (ADDRESS * a, short abilities, pgp_ring_t keyring)
+pgp_key_t pgp_getkeybyaddr (address_t * a, short abilities, pgp_ring_t keyring)

 {
 {

-  ADDRESS *r, *p;
+  address_t *r, *p;

   LIST *hints = NULL;
 
   int weak = 0;
   LIST *hints = NULL;
 
   int weak = 0;

diff --git a/protos.h b/protos.h
index d097ee6..7381c01 100644 (file)
--- a/protos.h
+++ b/protos.h
@@ -55,9 +55,9 @@ int quadoption (int);
 
 int mutt_option_value (const char* val, char* dst, size_t dstlen);
 
 
 int mutt_option_value (const char* val, char* dst, size_t dstlen);
 

-ADDRESS *mutt_default_from (void);
-ADDRESS *mutt_remove_duplicates (ADDRESS *);
-ADDRESS *mutt_parse_adrlist (ADDRESS *, const char *);
+address_t *mutt_default_from (void);
+address_t *mutt_remove_duplicates (address_t *);
+address_t *mutt_parse_adrlist (address_t *, const char *);

 
 BODY *mutt_make_file_attach (const char *);
 BODY *mutt_make_message_attach (CONTEXT *, HEADER *, int);
 
 BODY *mutt_make_file_attach (const char *);
 BODY *mutt_make_message_attach (CONTEXT *, HEADER *, int);


@@ -78,7 +78,7 @@ ENVELOPE *mutt_read_rfc822_header (FILE *, HEADER *, short, short);
 HEADER *mutt_dup_header (HEADER *);
 
 int mutt_cmp_header (const HEADER*, const HEADER*);
 HEADER *mutt_dup_header (HEADER *);
 
 int mutt_cmp_header (const HEADER*, const HEADER*);

-int mutt_cmp_addr (const ADDRESS * a, const ADDRESS * b);
+int mutt_cmp_addr (const address_t * a, const address_t * b);

 int mutt_cmp_list (const LIST * a, const LIST * b);
 int mutt_cmp_env (const ENVELOPE * e1, const ENVELOPE * e2);
 int mutt_cmp_param (const PARAMETER * p1, const PARAMETER * p2);
 int mutt_cmp_list (const LIST * a, const LIST * b);
 int mutt_cmp_env (const ENVELOPE * e1, const ENVELOPE * e2);
 int mutt_cmp_param (const PARAMETER * p1, const PARAMETER * p2);


@@ -99,9 +99,9 @@ char *mutt_find_hook (int, const char *);
 char *mutt_gecos_name (char *, size_t, struct passwd *);
 char *mutt_gen_msgid (void);
 char *mutt_get_body_charset (char *, size_t, BODY *);
 char *mutt_gecos_name (char *, size_t, struct passwd *);
 char *mutt_gen_msgid (void);
 char *mutt_get_body_charset (char *, size_t, BODY *);

-const char *mutt_get_name (ADDRESS *);
+const char *mutt_get_name (address_t *);

 char *mutt_get_parameter (const char *, PARAMETER *);
 char *mutt_get_parameter (const char *, PARAMETER *);

-char *mutt_crypt_hook (ADDRESS *);
+char *mutt_crypt_hook (address_t *);

 char *mutt_make_date (char *, size_t);
 
 const char *mutt_make_version (int full);
 char *mutt_make_date (char *, size_t);
 
 const char *mutt_make_version (int full);


@@ -115,7 +115,7 @@ void mutt_adv_mktemp (const char*, char*, size_t);
 void mutt_allow_interrupt (int);
 void mutt_block_signals (void);
 void mutt_block_signals_system (void);
 void mutt_allow_interrupt (int);
 void mutt_block_signals (void);
 void mutt_block_signals_system (void);

-int mutt_bounce_message (FILE * fp, HEADER *, ADDRESS *);
+int mutt_bounce_message (FILE * fp, HEADER *, address_t *);

 void mutt_canonical_charset (char *, size_t, const char *);
 int mutt_count_body_parts (HEADER *hdr, int flags);
 void mutt_check_rescore (CONTEXT *);
 void mutt_canonical_charset (char *, size_t, const char *);
 int mutt_count_body_parts (HEADER *hdr, int flags);
 void mutt_check_rescore (CONTEXT *);


@@ -174,8 +174,8 @@ void mutt_pipe_message (HEADER *);
 void mutt_print_message (HEADER *);
 void mutt_query_exit (void);
 void mutt_query_menu (char *, size_t);
 void mutt_print_message (HEADER *);
 void mutt_query_exit (void);
 void mutt_query_menu (char *, size_t);

-void mutt_safe_path (char *s, size_t l, ADDRESS * a);
-void mutt_save_path (char *s, size_t l, ADDRESS * a);
+void mutt_safe_path (char *s, size_t l, address_t * a);
+void mutt_save_path (char *s, size_t l, address_t * a);

 void mutt_score_message (CONTEXT *, HEADER *, int);
 void mutt_select_fcc (char *, size_t, HEADER *);
 
 void mutt_score_message (CONTEXT *, HEADER *, int);
 void mutt_select_fcc (char *, size_t, HEADER *);
 


@@ -197,7 +197,7 @@ void mutt_unblock_signals_system (int);
 void mutt_update_encoding (BODY * a);
 void mutt_version (void);
 void mutt_write_references (LIST *, FILE *);
 void mutt_update_encoding (BODY * a);
 void mutt_version (void);
 void mutt_write_references (LIST *, FILE *);

-void mutt_write_address_list (ADDRESS * adr, FILE * fp, int linelen,
+void mutt_write_address_list (address_t * adr, FILE * fp, int linelen,

                               int display);
 
 int mutt_addwch (wchar_t);
                               int display);
 
 int mutt_addwch (wchar_t);


@@ -239,12 +239,12 @@ int mutt_get_field_unbuffered (char *, char *, size_t, int);
 int mutt_get_hook_type (const char *);
 int mutt_get_postponed (CONTEXT *, HEADER *, HEADER **, char *, size_t);
 int mutt_index_menu (void);
 int mutt_get_hook_type (const char *);
 int mutt_get_postponed (CONTEXT *, HEADER *, HEADER **, char *, size_t);
 int mutt_index_menu (void);

-int mutt_invoke_mta (ADDRESS *, ADDRESS *, ADDRESS *, ADDRESS *, const char *,
+int mutt_invoke_mta (address_t *, address_t *, address_t *, address_t *, const char *,

                      int);
                      int);

-int mutt_is_mail_list (ADDRESS *);
-int mutt_is_list_cc (int, ADDRESS *, ADDRESS *);
-int mutt_is_list_recipient (int, ADDRESS *, ADDRESS *);
-int mutt_is_subscribed_list (ADDRESS *);
+int mutt_is_mail_list (address_t *);
+int mutt_is_list_cc (int, address_t *, address_t *);
+int mutt_is_list_recipient (int, address_t *, address_t *);
+int mutt_is_subscribed_list (address_t *);

 int mutt_is_text_part (BODY *);
 int mutt_is_valid_mailbox (const char *);
 int mutt_lookup_mime_type (BODY *, const char *);
 int mutt_is_text_part (BODY *);
 int mutt_is_valid_mailbox (const char *);
 int mutt_lookup_mime_type (BODY *, const char *);

diff --git a/query.c b/query.c
index e5dbd16..1cf41d2 100644 (file)
--- a/query.c
+++ b/query.c
@@ -29,7 +29,7 @@
 #include <ctype.h>
 
 typedef struct query {
 #include <ctype.h>
 
 typedef struct query {

-  ADDRESS *addr;
+  address_t *addr;

   char *name;
   char *other;
   struct query *next;
   char *name;
   char *other;
   struct query *next;


@@ -57,9 +57,9 @@ static int SecondColumn;
 static void query_menu (char *buf, size_t buflen, QUERY * results,
                         int retbuf);
 
 static void query_menu (char *buf, size_t buflen, QUERY * results,
                         int retbuf);
 

-static ADDRESS *result_to_addr (QUERY * r)
+static address_t *result_to_addr (QUERY * r)

 {
 {

-  static ADDRESS *tmp;
+  static address_t *tmp;

 
   tmp = rfc822_cpy_adr (r->addr);
 
 
   tmp = rfc822_cpy_adr (r->addr);
 


@@ -209,7 +209,7 @@ static int query_tag (MUTTMENU * menu, int n, int m)
 int mutt_query_complete (char *buf, size_t buflen)
 {
   QUERY *results = NULL;
 int mutt_query_complete (char *buf, size_t buflen)
 {
   QUERY *results = NULL;

-  ADDRESS *tmpa;
+  address_t *tmpa;

 
   if (!QueryCmd) {
     mutt_error _("Query command not defined.");
 
   if (!QueryCmd) {
     mutt_error _("Query command not defined.");


@@ -376,11 +376,11 @@ static void query_menu (char *buf, size_t buflen, QUERY * results, int retbuf)
 
       case OP_CREATE_ALIAS:
         if (menu->tagprefix) {
 
       case OP_CREATE_ALIAS:
         if (menu->tagprefix) {

-          ADDRESS *naddr = NULL;
+          address_t *naddr = NULL;

 
           for (i = 0; i < menu->max; i++)
             if (QueryTable[i].tagged) {
 
           for (i = 0; i < menu->max; i++)
             if (QueryTable[i].tagged) {

-              ADDRESS *a = result_to_addr (QueryTable[i].data);
+              address_t *a = result_to_addr (QueryTable[i].data);

 
               rfc822_append (&naddr, a);
               rfc822_free_address (&a);
 
               rfc822_append (&naddr, a);
               rfc822_free_address (&a);


@@ -389,7 +389,7 @@ static void query_menu (char *buf, size_t buflen, QUERY * results, int retbuf)
           mutt_create_alias (NULL, naddr);
         }
         else {
           mutt_create_alias (NULL, naddr);
         }
         else {

-          ADDRESS *a = result_to_addr (QueryTable[menu->current].data);
+          address_t *a = result_to_addr (QueryTable[menu->current].data);

 
           mutt_create_alias (NULL, a);
           rfc822_free_address (&a);
 
           mutt_create_alias (NULL, a);
           rfc822_free_address (&a);


@@ -412,7 +412,7 @@ static void query_menu (char *buf, size_t buflen, QUERY * results, int retbuf)
         else {
           for (i = 0; i < menu->max; i++)
             if (QueryTable[i].tagged) {
         else {
           for (i = 0; i < menu->max; i++)
             if (QueryTable[i].tagged) {

-              ADDRESS *a = result_to_addr (QueryTable[i].data);
+              address_t *a = result_to_addr (QueryTable[i].data);

 
               rfc822_append (&msg->env->to, a);
               rfc822_free_address (&a);
 
               rfc822_append (&msg->env->to, a);
               rfc822_free_address (&a);


@@ -439,7 +439,7 @@ static void query_menu (char *buf, size_t buflen, QUERY * results, int retbuf)
       for (i = 0; i < menu->max; i++) {
         if (QueryTable[i].tagged) {
           if (curpos == 0) {
       for (i = 0; i < menu->max; i++) {
         if (QueryTable[i].tagged) {
           if (curpos == 0) {

-            ADDRESS *tmpa = result_to_addr (QueryTable[i].data);
+            address_t *tmpa = result_to_addr (QueryTable[i].data);

 
             mutt_addrlist_to_local (tmpa);
             tagged = 1;
 
             mutt_addrlist_to_local (tmpa);
             tagged = 1;


@@ -448,7 +448,7 @@ static void query_menu (char *buf, size_t buflen, QUERY * results, int retbuf)
             rfc822_free_address (&tmpa);
           }
           else if (curpos + 2 < buflen) {
             rfc822_free_address (&tmpa);
           }
           else if (curpos + 2 < buflen) {

-            ADDRESS *tmpa = result_to_addr (QueryTable[i].data);
+            address_t *tmpa = result_to_addr (QueryTable[i].data);

 
             mutt_addrlist_to_local (tmpa);
             strcat (buf, ", "); /* __STRCAT_CHECKED__ */
 
             mutt_addrlist_to_local (tmpa);
             strcat (buf, ", "); /* __STRCAT_CHECKED__ */


@@ -461,7 +461,7 @@ static void query_menu (char *buf, size_t buflen, QUERY * results, int retbuf)
       }
       /* then enter current message */
       if (!tagged) {
       }
       /* then enter current message */
       if (!tagged) {

-        ADDRESS *tmpa = result_to_addr (QueryTable[menu->current].data);
+        address_t *tmpa = result_to_addr (QueryTable[menu->current].data);

 
         mutt_addrlist_to_local (tmpa);
         rfc822_write_address (buf, buflen, tmpa, 0);
 
         mutt_addrlist_to_local (tmpa);
         rfc822_write_address (buf, buflen, tmpa, 0);

diff --git a/recvcmd.c b/recvcmd.c
index f5fe28b..0ecc70b 100644 (file)
--- a/recvcmd.c
+++ b/recvcmd.c
@@ -126,7 +126,7 @@ void mutt_attach_bounce (FILE * fp, HEADER * hdr,
   char prompt[STRING];
   char buf[HUGE_STRING];
   char *err = NULL;
   char prompt[STRING];
   char buf[HUGE_STRING];
   char *err = NULL;

-  ADDRESS *adr = NULL;
+  address_t *adr = NULL;

   int ret = 0;
   int p = 0;
 
   int ret = 0;
   int p = 0;
 

diff --git a/remailer.c b/remailer.c
index b4e526e..2a0ffa2 100644 (file)
--- a/remailer.c
+++ b/remailer.c
@@ -674,7 +674,7 @@ int mix_check_message (HEADER * msg)
 {
   const char *fqdn;
   short need_hostname = 0;
 {
   const char *fqdn;
   short need_hostname = 0;

-  ADDRESS *p;
+  address_t *p;

 
   if (msg->env->cc || msg->env->bcc) {
     mutt_error _("Mixmaster doesn't accept Cc or Bcc headers.");
 
   if (msg->env->cc || msg->env->bcc) {
     mutt_error _("Mixmaster doesn't accept Cc or Bcc headers.");

diff --git a/rfc2047.c b/rfc2047.c
index a181e9d..dd62416 100644 (file)
--- a/rfc2047.c
+++ b/rfc2047.c
@@ -533,9 +533,9 @@ void _rfc2047_encode_string (char **pd, int encode_specials, int col)
   *pd = e;
 }
 
   *pd = e;
 }
 

-void rfc2047_encode_adrlist (ADDRESS * addr, const char *tag)
+void rfc2047_encode_adrlist (address_t * addr, const char *tag)

 {
 {

-  ADDRESS *ptr = addr;
+  address_t *ptr = addr;

   int col = tag ? m_strlen(tag) + 2 : 32;
 
   while (ptr) {
   int col = tag ? m_strlen(tag) + 2 : 32;
 
   while (ptr) {


@@ -785,7 +785,7 @@ void rfc2047_decode (char **pd)
   str_adjust (pd);
 }
 
   str_adjust (pd);
 }
 

-void rfc2047_decode_adrlist (ADDRESS * a)
+void rfc2047_decode_adrlist (address_t * a)

 {
   while (a) {
     if (a->personal)
 {
   while (a) {
     if (a->personal)

diff --git a/rfc2047.h b/rfc2047.h
index 670d299..6bf5b5d 100644 (file)
--- a/rfc2047.h
+++ b/rfc2047.h
@@ -13,11 +13,11 @@ char *mutt_choose_charset (const char *fromcode, const char *charsets,
                            char *u, size_t ulen, char **d, size_t * dlen);
 
 void _rfc2047_encode_string (char **, int, int);
                            char *u, size_t ulen, char **d, size_t * dlen);
 
 void _rfc2047_encode_string (char **, int, int);

-void rfc2047_encode_adrlist (ADDRESS *, const char *);
+void rfc2047_encode_adrlist (address_t *, const char *);

 
 #define rfc2047_encode_string(a) _rfc2047_encode_string (a, 0, 32);
 
 void rfc2047_decode (char **);
 
 #define rfc2047_encode_string(a) _rfc2047_encode_string (a, 0, 32);
 
 void rfc2047_decode (char **);

-void rfc2047_decode_adrlist (ADDRESS *);
+void rfc2047_decode_adrlist (address_t *);

 
 void rfc2047_decode_envelope (ENVELOPE* e);
 
 void rfc2047_decode_envelope (ENVELOPE* e);

diff --git a/send.c b/send.c
index 30db12a..ef1ef49 100644 (file)
--- a/send.c
+++ b/send.c
@@ -77,7 +77,7 @@ static void append_signature (FILE * f)
 }
 
 /* compare two e-mail addresses and return 1 if they are equivalent */
 }
 
 /* compare two e-mail addresses and return 1 if they are equivalent */

-static int mutt_addrcmp (ADDRESS * a, ADDRESS * b)
+static int mutt_addrcmp (address_t * a, address_t * b)

 {
   if (!a->mailbox || !b->mailbox)
     return 0;
 {
   if (!a->mailbox || !b->mailbox)
     return 0;


@@ -87,7 +87,7 @@ static int mutt_addrcmp (ADDRESS * a, ADDRESS * b)
 }
 
 /* search an e-mail address in a list */
 }
 
 /* search an e-mail address in a list */

-static int mutt_addrsrc (ADDRESS * a, ADDRESS * lst)
+static int mutt_addrsrc (address_t * a, address_t * lst)

 {
   for (; lst; lst = lst->next) {
     if (mutt_addrcmp (a, lst))
 {
   for (; lst; lst = lst->next) {
     if (mutt_addrcmp (a, lst))


@@ -97,9 +97,9 @@ static int mutt_addrsrc (ADDRESS * a, ADDRESS * lst)
 }
 
 /* removes addresses from "b" which are contained in "a" */
 }
 
 /* removes addresses from "b" which are contained in "a" */

-static ADDRESS *mutt_remove_xrefs (ADDRESS * a, ADDRESS * b)
+static address_t *mutt_remove_xrefs (address_t * a, address_t * b)

 {
 {

-  ADDRESS *top, *p, *prev = NULL;
+  address_t *top, *p, *prev = NULL;

 
   top = b;
   while (b) {
 
   top = b;
   while (b) {


@@ -132,9 +132,9 @@ static ADDRESS *mutt_remove_xrefs (ADDRESS * a, ADDRESS * b)
 /* remove any address which matches the current user.  if `leave_only' is
  * nonzero, don't remove the user's address if it is the only one in the list
  */
 /* remove any address which matches the current user.  if `leave_only' is
  * nonzero, don't remove the user's address if it is the only one in the list
  */

-static ADDRESS *remove_user (ADDRESS * a, int leave_only)
+static address_t *remove_user (address_t * a, int leave_only)

 {
 {

-  ADDRESS *top = NULL, *last = NULL;
+  address_t *top = NULL, *last = NULL;

 
   while (a) {
     if (!mutt_addr_is_user (a)) {
 
   while (a) {
     if (!mutt_addr_is_user (a)) {


@@ -148,7 +148,7 @@ static ADDRESS *remove_user (ADDRESS * a, int leave_only)
       last->next = NULL;
     }
     else {
       last->next = NULL;
     }
     else {

-      ADDRESS *tmp = a;
+      address_t *tmp = a;

 
       a = a->next;
       if (!leave_only || a || last) {
 
       a = a->next;
       if (!leave_only || a || last) {


@@ -162,9 +162,9 @@ static ADDRESS *remove_user (ADDRESS * a, int leave_only)
   return top;
 }
 
   return top;
 }
 

-static ADDRESS *find_mailing_lists (ADDRESS * t, ADDRESS * c)
+static address_t *find_mailing_lists (address_t * t, address_t * c)

 {
 {

-  ADDRESS *top = NULL, *ptr = NULL;
+  address_t *top = NULL, *ptr = NULL;

 
   for (; t || c; t = c, c = NULL) {
     for (; t; t = t->next) {
 
   for (; t || c; t = c, c = NULL) {
     for (; t; t = t->next) {


@@ -181,7 +181,7 @@ static ADDRESS *find_mailing_lists (ADDRESS * t, ADDRESS * c)
   return top;
 }
 
   return top;
 }
 

-static int edit_address (ADDRESS ** a, const char *field)
+static int edit_address (address_t ** a, const char *field)

 {
   char buf[HUGE_STRING];
   char *err = NULL;
 {
   char buf[HUGE_STRING];
   char *err = NULL;


@@ -470,10 +470,10 @@ static int include_reply (CONTEXT * ctx, HEADER * cur, FILE * out)
   return 0;
 }
 
   return 0;
 }
 

-static int default_to (ADDRESS ** to, ENVELOPE * env, int flags, int hmfupto)
+static int default_to (address_t ** to, ENVELOPE * env, int flags, int hmfupto)

 {
   char prompt[STRING];
 {
   char prompt[STRING];

-  ADDRESS *tmp;
+  address_t *tmp;

 
   if (flags && env->mail_followup_to && hmfupto == M_YES) {
     rfc822_append (to, env->mail_followup_to);
 
   if (flags && env->mail_followup_to && hmfupto == M_YES) {
     rfc822_append (to, env->mail_followup_to);


@@ -557,7 +557,7 @@ static int default_to (ADDRESS ** to, ENVELOPE * env, int flags, int hmfupto)
 int mutt_fetch_recips (ENVELOPE * out, ENVELOPE * in, int flags)
 {
   char prompt[STRING];
 int mutt_fetch_recips (ENVELOPE * out, ENVELOPE * in, int flags)
 {
   char prompt[STRING];

-  ADDRESS *tmp;
+  address_t *tmp;

   int hmfupto = -1;
 
   if ((flags & (SENDLISTREPLY | SENDGROUPREPLY)) && in->mail_followup_to) {
   int hmfupto = -1;
 
   if ((flags & (SENDLISTREPLY | SENDGROUPREPLY)) && in->mail_followup_to) {


@@ -881,8 +881,8 @@ static int generate_body (FILE * tempfp,        /* stream for outgoing message *
 
 void mutt_set_followup_to (ENVELOPE * e)
 {
 
 void mutt_set_followup_to (ENVELOPE * e)
 {

-  ADDRESS *t = NULL;
-  ADDRESS *from;
+  address_t *t = NULL;
+  address_t *from;

 
   /* 
    * Only generate the Mail-Followup-To if the user has requested it, and
 
   /* 
    * Only generate the Mail-Followup-To if the user has requested it, and


@@ -946,9 +946,9 @@ void mutt_set_followup_to (ENVELOPE * e)
 /* look through the recipients of the message we are replying to, and if
    we find an address that matches $alternates, we use that as the default
    from field */
 /* look through the recipients of the message we are replying to, and if
    we find an address that matches $alternates, we use that as the default
    from field */

-static ADDRESS *set_reverse_name (ENVELOPE * env)
+static address_t *set_reverse_name (ENVELOPE * env)

 {
 {

-  ADDRESS *tmp;
+  address_t *tmp;

 
   for (tmp = env->to; tmp; tmp = tmp->next) {
     if (mutt_addr_is_user (tmp))
 
   for (tmp = env->to; tmp; tmp = tmp->next) {
     if (mutt_addr_is_user (tmp))


@@ -972,9 +972,9 @@ static ADDRESS *set_reverse_name (ENVELOPE * env)
   return (tmp);
 }
 
   return (tmp);
 }
 

-ADDRESS *mutt_default_from (void)
+address_t *mutt_default_from (void)

 {
 {

-  ADDRESS *adr;
+  address_t *adr;

   const char *fqdn = mutt_fqdn (1);
 
   /* 
   const char *fqdn = mutt_fqdn (1);
 
   /* 

diff --git a/sendlib.c b/sendlib.c
index 208b434..33b7e9a 100644 (file)
--- a/sendlib.c
+++ b/sendlib.c
@@ -1372,10 +1372,10 @@ char *mutt_make_date (char *s, size_t len)
 
 /* wrapper around mutt_write_address() so we can handle very large
    recipient lists without needing a huge temporary buffer in memory */
 
 /* wrapper around mutt_write_address() so we can handle very large
    recipient lists without needing a huge temporary buffer in memory */

-void mutt_write_address_list (ADDRESS * adr, FILE * fp, int linelen,
+void mutt_write_address_list (address_t * adr, FILE * fp, int linelen,

                               int display)
 {
                               int display)
 {

-  ADDRESS *tmp;
+  address_t *tmp;

   char buf[LONG_STRING];
   int count = 0;
   int len;
   char buf[LONG_STRING];
   int count = 0;
   int len;


@@ -1926,7 +1926,7 @@ send_msg(const char *path, const char **args, const char *msg, char **tempfile)
 }
 
 static const char **
 }
 
 static const char **

-add_args(const char **args, size_t *argslen, size_t *argsmax, ADDRESS * addr)
+add_args(const char **args, size_t *argslen, size_t *argsmax, address_t * addr)

 {
   for (; addr; addr = addr->next) {
     /* weed out group mailboxes, since those are for display only */
 {
   for (; addr; addr = addr->next) {
     /* weed out group mailboxes, since those are for display only */


@@ -1949,8 +1949,8 @@ add_option(const char **args, size_t *argslen, size_t *argsmax, const char *s)
     return (args);
 }
 
     return (args);
 }
 

-static int mutt_invoke_sendmail (ADDRESS * from,        /* the sender */
-                                 ADDRESS * to, ADDRESS * cc, ADDRESS * bcc,     /* recips */
+static int mutt_invoke_sendmail (address_t * from,        /* the sender */
+                                 address_t * to, address_t * cc, address_t * bcc,     /* recips */

                                  const char *msg,       /* file containing message */
                                  int eightbit)
 {                               /* message contains 8bit chars */
                                  const char *msg,       /* file containing message */
                                  int eightbit)
 {                               /* message contains 8bit chars */


@@ -2005,7 +2005,7 @@ static int mutt_invoke_sendmail (ADDRESS * from,        /* the sender */
       args = add_option(args, &argslen, &argsmax, "-B8BITMIME");
 
     if (option (OPTENVFROM)) {
       args = add_option(args, &argslen, &argsmax, "-B8BITMIME");
 
     if (option (OPTENVFROM)) {

-      ADDRESS *f = NULL;
+      address_t *f = NULL;

       if (EnvFrom)
         f = EnvFrom;
       else if (from && !from->next)
       if (EnvFrom)
         f = EnvFrom;
       else if (from && !from->next)


@@ -2069,8 +2069,8 @@ static int mutt_invoke_sendmail (ADDRESS * from,        /* the sender */
   return (i);
 }
 
   return (i);
 }
 

-int mutt_invoke_mta (ADDRESS * from,    /* the sender */
-                     ADDRESS * to, ADDRESS * cc, ADDRESS * bcc, /* recips */
+int mutt_invoke_mta (address_t * from,    /* the sender */
+                     address_t * to, address_t * cc, address_t * bcc, /* recips */

                      const char *msg,   /* file containing message */
                      int eightbit)
 {                               /* message contains 8bit chars */
                      const char *msg,   /* file containing message */
                      int eightbit)
 {                               /* message contains 8bit chars */


@@ -2201,8 +2201,8 @@ void mutt_unprepare_envelope (ENVELOPE * env)
   rfc2047_decode (&env->subject);
 }
 
   rfc2047_decode (&env->subject);
 }
 

-static int _mutt_bounce_message (FILE * fp, HEADER * h, ADDRESS * to,
-                                 const char *resent_from, ADDRESS * env_from)
+static int _mutt_bounce_message (FILE * fp, HEADER * h, address_t * to,
+                                 const char *resent_from, address_t * env_from)

 {
   int i, ret = 0;
   FILE *f;
 {
   int i, ret = 0;
   FILE *f;


@@ -2255,9 +2255,9 @@ static int _mutt_bounce_message (FILE * fp, HEADER * h, ADDRESS * to,
   return ret;
 }
 
   return ret;
 }
 

-int mutt_bounce_message (FILE * fp, HEADER * h, ADDRESS * to)
+int mutt_bounce_message (FILE * fp, HEADER * h, address_t * to)

 {
 {

-  ADDRESS *from;
+  address_t *from;

   const char *fqdn = mutt_fqdn (1);
   char resent_from[STRING];
   int ret;
   const char *fqdn = mutt_fqdn (1);
   char resent_from[STRING];
   int ret;


@@ -2289,11 +2289,11 @@ int mutt_bounce_message (FILE * fp, HEADER * h, ADDRESS * to)
 
 
 /* given a list of addresses, return a list of unique addresses */
 
 
 /* given a list of addresses, return a list of unique addresses */

-ADDRESS *mutt_remove_duplicates (ADDRESS * addr)
+address_t *mutt_remove_duplicates (address_t * addr)

 {
 {

-  ADDRESS *top = addr;
-  ADDRESS **last = ⊤
-  ADDRESS *tmp;
+  address_t *top = addr;
+  address_t **last = ⊤
+  address_t *tmp;

   int dup;
 
   while (addr) {
   int dup;
 
   while (addr) {

diff --git a/smime.c b/smime.c
index 092c1bd..1bad22a 100644 (file)
--- a/smime.c
+++ b/smime.c
@@ -696,7 +696,7 @@ void _smime_getkeys (char *mailbox)
 
 void smime_getkeys (ENVELOPE * env)
 {
 
 void smime_getkeys (ENVELOPE * env)
 {

-  ADDRESS *t;
+  address_t *t;

   int found = 0;
 
   if (option (OPTSDEFAULTDECRYPTKEY) && SmimeDefaultKey && *SmimeDefaultKey) {
   int found = 0;
 
   if (option (OPTSDEFAULTDECRYPTKEY) && SmimeDefaultKey && *SmimeDefaultKey) {


@@ -729,14 +729,14 @@ void smime_getkeys (ENVELOPE * env)
  * It returns NULL if any of the keys can not be found.
  */
 
  * It returns NULL if any of the keys can not be found.
  */
 

-char *smime_findKeys (ADDRESS * to, ADDRESS * cc, ADDRESS * bcc)
+char *smime_findKeys (address_t * to, address_t * cc, address_t * bcc)

 {
   char *keyID, *keylist = NULL;
   size_t keylist_size = 0;
   size_t keylist_used = 0;
 {
   char *keyID, *keylist = NULL;
   size_t keylist_size = 0;
   size_t keylist_used = 0;

-  ADDRESS *tmp = NULL, *addr = NULL;
-  ADDRESS **last = &tmp;
-  ADDRESS *p, *q;
+  address_t *tmp = NULL, *addr = NULL;
+  address_t **last = &tmp;
+  address_t *p, *q;

   int i;
 
   const char *fqdn = mutt_fqdn (1);
   int i;
 
   const char *fqdn = mutt_fqdn (1);

diff --git a/smime.h b/smime.h
index 2822fc7..e344a11 100644 (file)
--- a/smime.h
+++ b/smime.h
@@ -40,7 +40,7 @@ void smime_getkeys (ENVELOPE *);
 
 char *smime_ask_for_key (char *, char *, short);
 
 
 char *smime_ask_for_key (char *, char *, short);
 

-char *smime_findKeys (ADDRESS * to, ADDRESS * cc, ADDRESS * bcc);
+char *smime_findKeys (address_t * to, address_t * cc, address_t * bcc);

 
 void smime_invoke_import (char *, char *);
 
 
 void smime_invoke_import (char *, char *);
 

diff --git a/sort.c b/sort.c
index b6aad71..c19ef98 100644 (file)
--- a/sort.c
+++ b/sort.c
@@ -88,9 +88,9 @@ int compare_subject (const void *a, const void *b)
   return (SORTCODE (rc));
 }
 
   return (SORTCODE (rc));
 }
 

-const char *mutt_get_name (ADDRESS * a)
+const char *mutt_get_name (address_t * a)

 {
 {

-  ADDRESS *ali;
+  address_t *ali;

   const char *name = "";
 
   if (a) {
   const char *name = "";
 
   if (a) {