mutt_idna.c

   1 /*
   2  * Copyright (C) 2003,2005,2008 Thomas Roessler <roessler@does-not-exist.org>
   3  *
   4  *     This program is free software; you can redistribute it and/or modify
   5  *     it under the terms of the GNU General Public License as published by
   6  *     the Free Software Foundation; either version 2 of the License, or
   7  *     (at your option) any later version.
   8  *
   9  *     This program is distributed in the hope that it will be useful,
  10  *     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  *     GNU General Public License for more details.
  13  *
  14  *     You should have received a copy of the GNU General Public License
  15  *     along with this program; if not, write to the Free Software
  16  *     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  17  */
  18
  19 #if HAVE_CONFIG_H
  20 # include "config.h"
  21 #endif
  22
  23 #include "mutt.h"
  24 #include "charset.h"
  25 #include "mutt_idna.h"
  26
  27 /* The low-level interface we use. */
  28
  29 #ifdef HAVE_LIBIDN
  30
  31 /* check whether an address is an IDN */
  32
  33 static int check_idn (ADDRESS *ap)
  34 {
  35   char *p = 0;
  36
  37   if (!ap || !ap->mailbox)
  38     return 0;
  39
  40   if (!ap->idn_checked)
  41   {
  42     ap->idn_checked = 1;
  43     for (p = strchr (ap->mailbox, '@'); p && *p; p = strchr (p, '.'))
  44       if (ascii_strncasecmp (++p, "xn--", 4) == 0)
  45       {
  46         ap->is_idn = 1;
  47         break;
  48       }
  49   }
  50
  51   return ap->is_idn;
  52 }
  53
  54 static int mutt_idna_to_local (const char *in, char **out, int flags)
  55 {
  56   *out = NULL;
  57
  58   if (!option (OPTUSEIDN))
  59     goto notrans;
  60
  61   if (!in)
  62     goto notrans;
  63
  64   /* Is this the right function?  Interesting effects with some bad identifiers! */
  65   if (idna_to_unicode_8z8z (in, out, 1) != IDNA_SUCCESS)
  66     goto notrans;
  67
  68   /* we don't want charset-hook effects, so we set flags to 0 */
  69   if (mutt_convert_string (out, "utf-8", Charset, 0) == -1)
  70     goto notrans;
  71
  72   /*
  73    * make sure that we can convert back and come out with the same
  74    * domain name.
  75    */
  76
  77   if ((flags & MI_MAY_BE_IRREVERSIBLE) == 0)
  78   {
  79     int irrev = 0;
  80     char *t2 = NULL;
  81     char *tmp = safe_strdup (*out);
  82
  83     /* we don't want charset-hook effects, so we set flags to 0 */
  84     if (mutt_convert_string (&tmp, Charset, "utf-8", 0) == -1)
  85       irrev = 1;
  86     if (!irrev && idna_to_ascii_8z (tmp, &t2, 1) != IDNA_SUCCESS)
  87       irrev = 1;
  88     if (!irrev && ascii_strcasecmp (t2, in))
  89     {
  90       dprint (1, (debugfile, "mutt_idna_to_local: Not reversible. in = '%s', t2 = '%s'.\n",
  91                   in, t2));
  92       irrev = 1;
  93     }
  94
  95     FREE (&t2);
  96     FREE (&tmp);
  97
  98     if (irrev)
  99       goto notrans;
 100   }
 101
 102   return 0;
 103
 104  notrans:
 105   FREE (out);           /* __FREE_CHECKED__ */
 106   *out = safe_strdup (in);
 107   return 1;
 108 }
 109
 110 static int mutt_local_to_idna (const char *in, char **out)
 111 {
 112   int rv = 0;
 113   char *tmp = safe_strdup (in);
 114   *out = NULL;
 115
 116   if (!in)
 117   {
 118     *out = NULL;
 119     return -1;
 120   }
 121
 122   /* we don't want charset-hook effects, so we set flags to 0 */
 123   if (mutt_convert_string (&tmp, Charset, "utf-8", 0) == -1)
 124     rv = -1;
 125   if (!rv && idna_to_ascii_8z (tmp, out, 1) != IDNA_SUCCESS)
 126     rv = -2;
 127
 128   FREE (&tmp);
 129   if (rv < 0)
 130   {
 131     FREE (out);         /* __FREE_CHECKED__ */
 132     *out = safe_strdup (in);
 133   }
 134   return rv;
 135 }
 136
 137 /* higher level functions */
 138
 139 static int mbox_to_udomain (const char *mbx, char **user, char **domain)
 140 {
 141   static char *buff = NULL;
 142   char *p;
 143
 144   mutt_str_replace (&buff, mbx);
 145
 146   p = strchr (buff, '@');
 147   if (!p || !p[1])
 148     return -1;
 149   *p = '\0';
 150   *user = buff;
 151   *domain  = p + 1;
 152   return 0;
 153 }
 154
 155 int mutt_addrlist_to_idna (ADDRESS *a, char **err)
 156 {
 157   char *user = NULL, *domain = NULL;
 158   char *tmp = NULL;
 159   int e = 0;
 160
 161   if (err)
 162     *err = NULL;
 163
 164   for (; a; a = a->next)
 165   {
 166     if (!a->mailbox)
 167       continue;
 168     if (mbox_to_udomain (a->mailbox, &user, &domain) == -1)
 169       continue;
 170
 171     if (mutt_local_to_idna (domain, &tmp) < 0)
 172     {
 173       e = 1;
 174       if (err)
 175         *err = safe_strdup (domain);
 176     }
 177     else
 178     {
 179       safe_realloc (&a->mailbox, mutt_strlen (user) + mutt_strlen (tmp) + 2);
 180       sprintf (a->mailbox, "%s@%s", NONULL(user), NONULL(tmp)); /* __SPRINTF_CHECKED__ */
 181       a->idn_checked = 0;
 182     }
 183
 184     FREE (&tmp);
 185
 186     if (e)
 187       return -1;
 188   }
 189
 190   return 0;
 191 }
 192
 193 int mutt_addrlist_to_local (ADDRESS *a)
 194 {
 195   char *user, *domain;
 196   char *tmp = NULL;
 197
 198   for (; a; a = a->next)
 199   {
 200     if (!a->mailbox)
 201       continue;
 202     if (!check_idn (a))
 203       continue;
 204     if (mbox_to_udomain (a->mailbox, &user, &domain) == -1)
 205       continue;
 206     if (mutt_idna_to_local (domain, &tmp, 0) == 0)
 207     {
 208       safe_realloc (&a->mailbox, mutt_strlen (user) + mutt_strlen (tmp) + 2);
 209       sprintf (a->mailbox, "%s@%s", NONULL (user), NONULL (tmp)); /* __SPRINTF_CHECKED__ */
 210       a->idn_checked = 0;
 211     }
 212
 213     FREE (&tmp);
 214   }
 215
 216   return 0;
 217 }
 218
 219 /* convert just for displaying purposes */
 220 const char *mutt_addr_for_display (ADDRESS *a)
 221 {
 222   static char *buff = NULL;
 223   char *tmp = NULL;
 224   /* user and domain will be either allocated or reseted to the NULL in
 225    * the mbox_to_udomain(), but for safety... */
 226   char *domain = NULL;
 227   char *user = NULL;
 228
 229   FREE (&buff);
 230
 231   if (!check_idn (a))
 232     return a->mailbox;
 233   if (mbox_to_udomain (a->mailbox, &user, &domain) != 0)
 234     return a->mailbox;
 235   if (mutt_idna_to_local (domain, &tmp, MI_MAY_BE_IRREVERSIBLE) != 0)
 236   {
 237     FREE (&tmp);
 238     return a->mailbox;
 239   }
 240
 241   safe_realloc (&buff, mutt_strlen (tmp) + mutt_strlen (user) + 2);
 242   sprintf (buff, "%s@%s", NONULL(user), NONULL(tmp)); /* __SPRINTF_CHECKED__ */
 243   FREE (&tmp);
 244   return buff;
 245 }
 246
 247 /* Convert an ENVELOPE structure */
 248
 249 void mutt_env_to_local (ENVELOPE *e)
 250 {
 251   mutt_addrlist_to_local (e->return_path);
 252   mutt_addrlist_to_local (e->from);
 253   mutt_addrlist_to_local (e->to);
 254   mutt_addrlist_to_local (e->cc);
 255   mutt_addrlist_to_local (e->bcc);
 256   mutt_addrlist_to_local (e->reply_to);
 257   mutt_addrlist_to_local (e->mail_followup_to);
 258 }
 259
 260 /* Note that `a' in the `env->a' expression is macro argument, not
 261  * "real" name of an `env' compound member.  Real name will be substituted
 262  * by preprocessor at the macro-expansion time.
 263  */
 264 #define H_TO_IDNA(a)    \
 265   if (mutt_addrlist_to_idna (env->a, err) && !e) \
 266   { \
 267      if (tag) *tag = #a; e = 1; err = NULL; \
 268   }
 269
 270 int mutt_env_to_idna (ENVELOPE *env, char **tag, char **err)
 271 {
 272   int e = 0;
 273   H_TO_IDNA(return_path);
 274   H_TO_IDNA(from);
 275   H_TO_IDNA(to);
 276   H_TO_IDNA(cc);
 277   H_TO_IDNA(bcc);
 278   H_TO_IDNA(reply_to);
 279   H_TO_IDNA(mail_followup_to);
 280   return e;
 281 }
 282
 283 #undef H_TO_IDNA
 284
 285 #endif /* HAVE_LIBIDN */