Move OpenPGP OID helpers to common/.
[gnupg.git] / common / convert.c
1 /* convert.c - Hex conversion functions.
2  *      Copyright (C) 2006, 2008 Free Software Foundation, Inc.
3  *
4  * This file is part of GnuPG.
5  *
6  * GnuPG is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 3 of the License, or
9  * (at your option) any later version.
10  *
11  * GnuPG is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, see <http://www.gnu.org/licenses/>.
18  */
19
20 #include <config.h>
21 #include <stdlib.h>
22 #include <errno.h>
23 #include <ctype.h>
24
25 #include "util.h"
26 #include "gcrypt.h"  /* FIXME: really needed?  */
27
28
29 #define tohex(n) ((n) < 10 ? ((n) + '0') : (((n) - 10) + 'A'))
30
31
32 /* Convert STRING consisting of hex characters into its binary
33    representation and store that at BUFFER.  BUFFER needs to be of
34    LENGTH bytes.  The function checks that the STRING will convert
35    exactly to LENGTH bytes. The string is delimited by either end of
36    string or a white space character.  The function returns -1 on
37    error or the length of the parsed string.  */
38 int
39 hex2bin (const char *string, void *buffer, size_t length)
40 {
41   int i;
42   const char *s = string;
43
44   for (i=0; i < length; )
45     {
46       if (!hexdigitp (s) || !hexdigitp (s+1))
47         return -1;           /* Invalid hex digits. */
48       ((unsigned char*)buffer)[i++] = xtoi_2 (s);
49       s += 2;
50     }
51   if (*s && (!isascii (*s) || !isspace (*s)) )
52     return -1;             /* Not followed by Nul or white space.  */
53   if (i != length)
54     return -1;             /* Not of expected length.  */
55   if (*s)
56     s++; /* Skip the delimiter. */
57   return s - string;
58 }
59
60
61 /* Convert STRING consisting of hex characters into its binary representation
62    and store that at BUFFER.  BUFFER needs to be of LENGTH bytes.  The
63    function check that the STRING will convert exactly to LENGTH
64    bytes. Colons inbetween the hex digits are allowed, if one colon
65    has been given a colon is expected very 2 characters. The string
66    is delimited by either end of string or a white space character.
67    The function returns -1 on error or the length of the parsed
68    string.  */
69 int
70 hexcolon2bin (const char *string, void *buffer, size_t length)
71 {
72   int i;
73   const char *s = string;
74   int need_colon = 0;
75
76   for (i=0; i < length; )
77     {
78       if (i==1 && *s == ':')  /* Skip colons between hex digits.  */
79         {
80           need_colon = 1;
81           s++;
82         }
83       else if (need_colon && *s == ':')
84         s++;
85       else if (need_colon)
86         return -1;           /* Colon expected. */
87       if (!hexdigitp (s) || !hexdigitp (s+1))
88         return -1;           /* Invalid hex digits. */
89       ((unsigned char*)buffer)[i++] = xtoi_2 (s);
90       s += 2;
91     }
92   if (*s == ':')
93     return -1;             /* Trailing colons are not allowed.  */
94   if (*s && (!isascii (*s) || !isspace (*s)) )
95     return -1;             /* Not followed by Nul or white space.  */
96   if (i != length)
97     return -1;             /* Not of expected length.  */
98   if (*s)
99     s++; /* Skip the delimiter. */
100   return s - string;
101 }
102
103
104
105 static char *
106 do_bin2hex (const void *buffer, size_t length, char *stringbuf, int with_colon)
107 {
108   const unsigned char *s;
109   char *p;
110   
111   if (!stringbuf)
112     {
113       /* Not really correct for with_colon but we don't care about the
114          one wasted byte. */
115       size_t n = with_colon? 3:2; 
116       size_t nbytes = n * length + 1; 
117       if (length &&  (nbytes-1) / n != length) 
118         {
119           gpg_err_set_errno (ENOMEM);
120           return NULL;
121         }
122       stringbuf = xtrymalloc (nbytes);
123       if (!stringbuf)
124         return NULL;
125     }
126   
127   for (s = buffer, p = stringbuf; length; length--, s++)
128     {
129       if (with_colon && s != buffer)
130         *p++ = ':';
131       *p++ = tohex ((*s>>4)&15);
132       *p++ = tohex (*s&15);
133     }
134   *p = 0;
135
136   return stringbuf;
137 }
138
139
140 /* Convert LENGTH bytes of data in BUFFER into hex encoding and store
141    that at the provided STRINGBUF.  STRINGBUF must be allocated of at
142    least (2*LENGTH+1) bytes or be NULL so that the function mallocs an
143    appropriate buffer.  Returns STRINGBUF or NULL on error (which may
144    only occur if STRINGBUF has been NULL and the internal malloc
145    failed). */
146 char *
147 bin2hex (const void *buffer, size_t length, char *stringbuf)
148 {
149   return do_bin2hex (buffer, length, stringbuf, 0);
150 }
151
152 /* Convert LENGTH bytes of data in BUFFER into hex encoding and store
153    that at the provided STRINGBUF.  STRINGBUF must be allocated of at
154    least (3*LENGTH+1) bytes or be NULL so that the function mallocs an
155    appropriate buffer.  Returns STRINGBUF or NULL on error (which may
156    only occur if STRINGBUF has been NULL and the internal malloc
157    failed). */
158 char *
159 bin2hexcolon (const void *buffer, size_t length, char *stringbuf)
160 {
161   return do_bin2hex (buffer, length, stringbuf, 1);
162 }
163
164
165
166 /* Convert HEXSTRING consisting of hex characters into string and
167    store that at BUFFER.  HEXSTRING is either delimited by end of
168    string or a white space character.  The function makes sure that
169    the resulting string in BUFFER is terminated by a Nul character.
170    BUFSIZE is the availabe length of BUFFER; if the converted result
171    plus a possible required Nul character does not fit into this
172    buffer, the function returns NULL and won't change the existing
173    conent of buffer.  In-place conversion is possible as long as
174    BUFFER points to HEXSTRING.
175    
176    If BUFFER is NULL and bufsize is 0 the function scans HEXSTRING but
177    does not store anything.  This may be used to find the end of
178    hexstring.
179
180    On sucess the function returns a pointer to the next character
181    after HEXSTRING (which is either end-of-string or a the next white
182    space).  If BUFLEN is not NULL the strlen of buffer is stored
183    there; this will even be done if BUFFER has been passed as NULL. */
184 const char *
185 hex2str (const char *hexstring, char *buffer, size_t bufsize, size_t *buflen)
186 {
187   const char *s = hexstring;
188   int idx, count;
189   int need_nul = 0;
190
191   if (buflen)
192     *buflen = 0;
193
194   for (s=hexstring, count=0; hexdigitp (s) && hexdigitp (s+1); s += 2, count++)
195     ;
196   if (*s && (!isascii (*s) || !isspace (*s)) )
197     return NULL;   /* Not followed by Nul or white space.  */
198   /* We need to append a nul character.  However we don't want that if
199      the hexstring already ends with "00".  */
200   need_nul = ((s == hexstring) || !(s[-2] == '0' && s[-1] == '0'));
201   if (need_nul)
202     count++;
203
204   if (buffer)
205     {
206       if (count > bufsize)
207         return NULL; /* Too long.  */
208       
209       for (s=hexstring, idx=0; hexdigitp (s) && hexdigitp (s+1); s += 2)
210         ((unsigned char*)buffer)[idx++] = xtoi_2 (s);
211       if (need_nul)
212         buffer[idx] = 0;
213     }
214
215   if (buflen)
216     *buflen = count - 1;
217   return s;
218 }
219
220
221 /* Same as hex2str but this function allocated a new string.  Returns
222    NULL on error.  If R_COUNT is not NULL, the number of scanned bytes
223    will be stored there.  ERRNO is set on error. */
224 char *
225 hex2str_alloc (const char *hexstring, size_t *r_count)
226 {
227   const char *tail;
228   size_t nbytes;
229   char *result;
230
231   tail = hex2str (hexstring, NULL, 0, &nbytes);
232   if (!tail)
233     {
234       if (r_count)
235         *r_count = 0;
236       gpg_err_set_errno (EINVAL);
237       return NULL;
238     }
239   if (r_count)
240     *r_count = tail - hexstring;
241   result = xtrymalloc (nbytes+1);
242   if (!result)
243     return NULL;
244   if (!hex2str (hexstring, result, nbytes+1, NULL))
245     BUG ();
246   return result;
247 }