Initial vendor import of ldns-1.6.4 into contrib.
[dragonfly.git] / contrib / ldns / compat / b64_pton.c
1 /*
2  * Copyright (c) 1996, 1998 by Internet Software Consortium.
3  *
4  * Permission to use, copy, modify, and distribute this software for any
5  * purpose with or without fee is hereby granted, provided that the above
6  * copyright notice and this permission notice appear in all copies.
7  *
8  * THE SOFTWARE IS PROVIDED "AS IS" AND INTERNET SOFTWARE CONSORTIUM DISCLAIMS
9  * ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES
10  * OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL INTERNET SOFTWARE
11  * CONSORTIUM BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
12  * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
13  * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
14  * ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
15  * SOFTWARE.
16  */
17
18 /*
19  * Portions Copyright (c) 1995 by International Business Machines, Inc.
20  *
21  * International Business Machines, Inc. (hereinafter called IBM) grants
22  * permission under its copyrights to use, copy, modify, and distribute this
23  * Software with or without fee, provided that the above copyright notice and
24  * all paragraphs of this notice appear in all copies, and that the name of IBM
25  * not be used in connection with the marketing of any product incorporating
26  * the Software or modifications thereof, without specific, written prior
27  * permission.
28  *
29  * To the extent it has a right to do so, IBM grants an immunity from suit
30  * under its patents, if any, for the use, sale or manufacture of products to
31  * the extent that such products are used for performing Domain Name System
32  * dynamic updates in TCP/IP networks by means of the Software.  No immunity is
33  * granted for any product per se or for any other function of any product.
34  *
35  * THE SOFTWARE IS PROVIDED "AS IS", AND IBM DISCLAIMS ALL WARRANTIES,
36  * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
37  * PARTICULAR PURPOSE.  IN NO EVENT SHALL IBM BE LIABLE FOR ANY SPECIAL,
38  * DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER ARISING
39  * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE, EVEN
40  * IF IBM IS APPRISED OF THE POSSIBILITY OF SUCH DAMAGES.
41  */
42 #include <ldns/config.h>
43
44 #include <ldns/ldns.h>
45
46 #include <sys/types.h>
47 #include <sys/param.h>
48 #ifdef HAVE_SYS_SOCKET_H
49 #include <sys/socket.h>
50 #endif
51
52 #ifdef HAVE_NETINET_IN_H
53 #include <netinet/in.h>
54 #endif
55 #ifdef HAVE_ARPA_INET_H
56 #include <arpa/inet.h>
57 #endif
58
59 #include <ctype.h>
60 #include <stdio.h>
61 #include <stdlib.h>
62 #include <string.h>
63
64 #define Assert(Cond) if (!(Cond)) abort()
65
66 static const char Base64[] =
67         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
68 static const char Pad64 = '=';
69
70 /* (From RFC1521 and draft-ietf-dnssec-secext-03.txt)
71    The following encoding technique is taken from RFC 1521 by Borenstein
72    and Freed.  It is reproduced here in a slightly edited form for
73    convenience.
74
75    A 65-character subset of US-ASCII is used, enabling 6 bits to be
76    represented per printable character. (The extra 65th character, "=",
77    is used to signify a special processing function.)
78
79    The encoding process represents 24-bit groups of input bits as output
80    strings of 4 encoded characters. Proceeding from left to right, a
81    24-bit input group is formed by concatenating 3 8-bit input groups.
82    These 24 bits are then treated as 4 concatenated 6-bit groups, each
83    of which is translated into a single digit in the base64 alphabet.
84
85    Each 6-bit group is used as an index into an array of 64 printable
86    characters. The character referenced by the index is placed in the
87    output string.
88
89                          Table 1: The Base64 Alphabet
90
91       Value Encoding  Value Encoding  Value Encoding  Value Encoding
92           0 A            17 R            34 i            51 z
93           1 B            18 S            35 j            52 0
94           2 C            19 T            36 k            53 1
95           3 D            20 U            37 l            54 2
96           4 E            21 V            38 m            55 3
97           5 F            22 W            39 n            56 4
98           6 G            23 X            40 o            57 5
99           7 H            24 Y            41 p            58 6
100           8 I            25 Z            42 q            59 7
101           9 J            26 a            43 r            60 8
102          10 K            27 b            44 s            61 9
103          11 L            28 c            45 t            62 +
104          12 M            29 d            46 u            63 /
105          13 N            30 e            47 v
106          14 O            31 f            48 w         (pad) =
107          15 P            32 g            49 x
108          16 Q            33 h            50 y
109
110    Special processing is performed if fewer than 24 bits are available
111    at the end of the data being encoded.  A full encoding quantum is
112    always completed at the end of a quantity.  When fewer than 24 input
113    bits are available in an input group, zero bits are added (on the
114    right) to form an integral number of 6-bit groups.  Padding at the
115    end of the data is performed using the '=' character.
116
117    Since all base64 input is an integral number of octets, only the
118          -------------------------------------------------                       
119    following cases can arise:
120    
121        (1) the final quantum of encoding input is an integral
122            multiple of 24 bits; here, the final unit of encoded
123            output will be an integral multiple of 4 characters
124            with no "=" padding,
125        (2) the final quantum of encoding input is exactly 8 bits;
126            here, the final unit of encoded output will be two
127            characters followed by two "=" padding characters, or
128        (3) the final quantum of encoding input is exactly 16 bits;
129            here, the final unit of encoded output will be three
130            characters followed by one "=" padding character.
131    */
132
133 /* skips all whitespace anywhere.
134    converts characters, four at a time, starting at (or after)
135    src from base - 64 numbers into three 8 bit bytes in the target area.
136    it returns the number of data bytes stored at the target, or -1 on error.
137  */
138
139 int
140 ldns_b64_pton(char const *src, uint8_t *target, size_t targsize)
141 {
142         int tarindex, state, ch;
143         char *pos;
144
145         state = 0;
146         tarindex = 0;
147
148         if (strlen(src) == 0) {
149                 return 0;
150         }
151
152         while ((ch = *src++) != '\0') {
153                 if (isspace((unsigned char)ch))        /* Skip whitespace anywhere. */
154                         continue;
155
156                 if (ch == Pad64)
157                         break;
158
159                 pos = strchr(Base64, ch);
160                 if (pos == 0) {
161                         /* A non-base64 character. */
162                         return (-1);
163                 }
164
165                 switch (state) {
166                 case 0:
167                         if (target) {
168                                 if ((size_t)tarindex >= targsize)
169                                         return (-1);
170                                 target[tarindex] = (pos - Base64) << 2;
171                         }
172                         state = 1;
173                         break;
174                 case 1:
175                         if (target) {
176                                 if ((size_t)tarindex + 1 >= targsize)
177                                         return (-1);
178                                 target[tarindex]   |=  (pos - Base64) >> 4;
179                                 target[tarindex+1]  = ((pos - Base64) & 0x0f)
180                                                         << 4 ;
181                         }
182                         tarindex++;
183                         state = 2;
184                         break;
185                 case 2:
186                         if (target) {
187                                 if ((size_t)tarindex + 1 >= targsize)
188                                         return (-1);
189                                 target[tarindex]   |=  (pos - Base64) >> 2;
190                                 target[tarindex+1]  = ((pos - Base64) & 0x03)
191                                                         << 6;
192                         }
193                         tarindex++;
194                         state = 3;
195                         break;
196                 case 3:
197                         if (target) {
198                                 if ((size_t)tarindex >= targsize)
199                                         return (-1);
200                                 target[tarindex] |= (pos - Base64);
201                         }
202                         tarindex++;
203                         state = 0;
204                         break;
205                 default:
206                         abort();
207                 }
208         }
209
210         /*
211          * We are done decoding Base-64 chars.  Let's see if we ended
212          * on a byte boundary, and/or with erroneous trailing characters.
213          */
214
215         if (ch == Pad64) {              /* We got a pad char. */
216                 ch = *src++;            /* Skip it, get next. */
217                 switch (state) {
218                 case 0:         /* Invalid = in first position */
219                 case 1:         /* Invalid = in second position */
220                         return (-1);
221
222                 case 2:         /* Valid, means one byte of info */
223                         /* Skip any number of spaces. */
224                         for ((void)NULL; ch != '\0'; ch = *src++)
225                                 if (!isspace((unsigned char)ch))
226                                         break;
227                         /* Make sure there is another trailing = sign. */
228                         if (ch != Pad64)
229                                 return (-1);
230                         ch = *src++;            /* Skip the = */
231                         /* Fall through to "single trailing =" case. */
232                         /* FALLTHROUGH */
233
234                 case 3:         /* Valid, means two bytes of info */
235                         /*
236                          * We know this char is an =.  Is there anything but
237                          * whitespace after it?
238                          */
239                         for ((void)NULL; ch != '\0'; ch = *src++)
240                                 if (!isspace((unsigned char)ch))
241                                         return (-1);
242
243                         /*
244                          * Now make sure for cases 2 and 3 that the "extra"
245                          * bits that slopped past the last full byte were
246                          * zeros.  If we don't check them, they become a
247                          * subliminal channel.
248                          */
249                         if (target && target[tarindex] != 0)
250                                 return (-1);
251                 }
252         } else {
253                 /*
254                  * We ended by seeing the end of the string.  Make sure we
255                  * have no partial bytes lying around.
256                  */
257                 if (state != 0)
258                         return (-1);
259         }
260
261         return (tarindex);
262 }