common: Change license of mbox-util to LGPLv2.1+.
[gnupg.git] / common / mbox-util.c
1 /* mbox-util.c - Mail address helper functions
2  * Copyright (C) 1998-2010 Free Software Foundation, Inc.
3  * Copyright (C) 1998-2015 Werner Koch
4  *
5  * This file is part of GnuPG.
6  *
7  * This file is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU Lesser General Public License as
9  * published by the Free Software Foundation; either version 2.1 of
10  * the License, or (at your option) any later version.
11  *
12  * This file is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public License
18  * along with this program; if not, see <http://www.gnu.org/licenses/>.
19  */
20
21 #include <config.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <unistd.h>
26 #include <errno.h>
27
28 #include "util.h"
29 #include "mbox-util.h"
30
31
32 static int
33 string_count_chr (const char *string, int c)
34 {
35   int count;
36
37   for (count=0; *string; string++ )
38     if ( *string == c )
39       count++;
40   return count;
41 }
42
43 static int
44 mem_count_chr (const void *buffer, int c, size_t length)
45 {
46   const char *s = buffer;
47   int count;
48
49   for (count=0; length; length--, s++)
50     if (*s == c)
51       count++;
52   return count;
53 }
54
55
56 /* This is a case-sensitive version of our memistr.  I wonder why no
57    standard function memstr exists but I better do not use the name
58    memstr to avoid future conflicts.  */
59 static const char *
60 my_memstr (const void *buffer, size_t buflen, const char *sub)
61 {
62   const unsigned char *buf = buffer;
63   const unsigned char *t = (const unsigned char *)buf;
64   const unsigned char *s = (const unsigned char *)sub;
65   size_t n = buflen;
66
67   for ( ; n ; t++, n-- )
68     {
69       if (*t == *s)
70         {
71           for (buf = t++, buflen = n--, s++; n && *t ==*s; t++, s++, n--)
72             ;
73           if (!*s)
74             return (const char*)buf;
75           t = (const unsigned char *)buf;
76           s = (const unsigned char *)sub ;
77           n = buflen;
78         }
79     }
80   return NULL;
81 }
82
83
84
85 static int
86 string_has_ctrl_or_space (const char *string)
87 {
88   for (; *string; string++ )
89     if (!(*string & 0x80) && *string <= 0x20)
90       return 1;
91   return 0;
92 }
93
94
95 /* Return true if STRING has two consecutive '.' after an '@'
96    sign.  */
97 static int
98 has_dotdot_after_at (const char *string)
99 {
100   string = strchr (string, '@');
101   if (!string)
102     return 0; /* No at-sign.  */
103   string++;
104   return !!strstr (string, "..");
105 }
106
107
108 /* Check whether BUFFER has characters not valid in an RFC-822
109    address.  LENGTH gives the length of BUFFER.
110
111    To cope with OpenPGP we ignore non-ascii characters so that for
112    example umlauts are legal in an email address.  An OpenPGP user ID
113    must be utf-8 encoded but there is no strict requirement for
114    RFC-822.  Thus to avoid IDNA encoding we put the address verbatim
115    as utf-8 into the user ID under the assumption that mail programs
116    handle IDNA at a lower level and take OpenPGP user IDs as utf-8.
117    Note that we can't do an utf-8 encoding checking here because in
118    keygen.c this function is called with the native encoding and
119    native to utf-8 encoding is only done later.  */
120 int
121 has_invalid_email_chars (const void *buffer, size_t length)
122 {
123   const unsigned char *s = buffer;
124   int at_seen=0;
125   const char *valid_chars=
126     "01234567890_-.abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
127
128   for ( ; length && *s; length--, s++ )
129     {
130       if ((*s & 0x80))
131         continue; /* We only care about ASCII.  */
132       if (*s == '@')
133         at_seen=1;
134       else if (!at_seen && !(strchr (valid_chars, *s)
135                              || strchr ("!#$%&'*+/=?^`{|}~", *s)))
136         return 1;
137       else if (at_seen && !strchr (valid_chars, *s))
138         return 1;
139     }
140   return 0;
141 }
142
143
144 /* Same as is_valid_mailbox (see below) but operates on non-nul
145    terminated buffer.  */
146 int
147 is_valid_mailbox_mem (const void *name_arg, size_t namelen)
148 {
149   const char *name = name_arg;
150
151   return !( !name
152             || !namelen
153             || has_invalid_email_chars (name, namelen)
154             || mem_count_chr (name, '@', namelen) != 1
155             || *name == '@'
156             || name[namelen-1] == '@'
157             || name[namelen-1] == '.'
158             || my_memstr (name, namelen, ".."));
159 }
160
161
162 /* Check whether NAME represents a valid mailbox according to
163    RFC822. Returns true if so. */
164 int
165 is_valid_mailbox (const char *name)
166 {
167   return name? is_valid_mailbox_mem (name, strlen (name)) : 0;
168 }
169
170
171 /* Return the mailbox (local-part@domain) form a standard user id.
172    All plain ASCII characters in the result are converted to
173    lowercase.  Caller must free the result.  Returns NULL if no valid
174    mailbox was found (or we are out of memory). */
175 char *
176 mailbox_from_userid (const char *userid)
177 {
178   const char *s, *s_end;
179   size_t len;
180   char *result = NULL;
181
182   s = strchr (userid, '<');
183   if (s)
184     {
185       /* Seems to be a standard user id.  */
186       s++;
187       s_end = strchr (s, '>');
188       if (s_end && s_end > s)
189         {
190           len = s_end - s;
191           result = xtrymalloc (len + 1);
192           if (!result)
193             return NULL; /* Ooops - out of core.  */
194           strncpy (result, s, len);
195           result[len] = 0;
196           /* Apply some basic checks on the address.  We do not use
197              is_valid_mailbox because those checks are too strict.  */
198           if (string_count_chr (result, '@') != 1  /* Need exactly one '@.  */
199               || *result == '@'           /* local-part missing.  */
200               || result[len-1] == '@'     /* domain missing.  */
201               || result[len-1] == '.'     /* ends with a dot.  */
202               || string_has_ctrl_or_space (result)
203               || has_dotdot_after_at (result))
204             {
205               xfree (result);
206               result = NULL;
207               errno = EINVAL;
208             }
209         }
210       else
211         errno = EINVAL;
212     }
213   else if (is_valid_mailbox (userid))
214     {
215       /* The entire user id is a mailbox.  Return that one.  Note that
216          this fallback method has some restrictions on the valid
217          syntax of the mailbox.  However, those who want weird
218          addresses should know about it and use the regular <...>
219          syntax.  */
220       result = xtrystrdup (userid);
221     }
222   else
223     errno = EINVAL;
224
225   return result? ascii_strlwr (result): NULL;
226 }
227
228
229 /* Check whether UID is a valid standard user id of the form
230      "Heinrich Heine <heinrichh@duesseldorf.de>"
231    and return true if this is the case. */
232 int
233 is_valid_user_id (const char *uid)
234 {
235   if (!uid || !*uid)
236     return 0;
237
238   return 1;
239 }