source: rtems/cpukit/libnetworking/libc/base64.c @ ff0f694d

4.104.114.84.95
Last change on this file since ff0f694d was ff0f694d, checked in by Joel Sherrill <joel.sherrill@…>, on 08/20/98 at 21:47:37

Fixed many warnings.

  • Property mode set to 100644
File size: 10.2 KB
Line 
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
43#if !defined(__rtems__)
44#if !defined(LINT) && !defined(CODECENTER)
45static char rcsid[] = "$Id$";
46#endif /* not lint */
47#endif /* not rtems */
48
49#include <sys/types.h>
50#include <sys/param.h>
51#include <sys/socket.h>
52
53#include <netinet/in.h>
54#include <arpa/inet.h>
55#include <arpa/nameser.h>
56
57#include <ctype.h>
58#include <resolv.h>
59#include <stdio.h>
60#include <stdlib.h>
61#include <string.h>
62
63#define Assert(Cond) if (!(Cond)) abort()
64
65static const char Base64[] =
66        "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
67static const char Pad64 = '=';
68
69/* (From RFC1521 and draft-ietf-dnssec-secext-03.txt)
70   The following encoding technique is taken from RFC 1521 by Borenstein
71   and Freed.  It is reproduced here in a slightly edited form for
72   convenience.
73
74   A 65-character subset of US-ASCII is used, enabling 6 bits to be
75   represented per printable character. (The extra 65th character, "=",
76   is used to signify a special processing function.)
77
78   The encoding process represents 24-bit groups of input bits as output
79   strings of 4 encoded characters. Proceeding from left to right, a
80   24-bit input group is formed by concatenating 3 8-bit input groups.
81   These 24 bits are then treated as 4 concatenated 6-bit groups, each
82   of which is translated into a single digit in the base64 alphabet.
83
84   Each 6-bit group is used as an index into an array of 64 printable
85   characters. The character referenced by the index is placed in the
86   output string.
87
88                         Table 1: The Base64 Alphabet
89
90      Value Encoding  Value Encoding  Value Encoding  Value Encoding
91          0 A            17 R            34 i            51 z
92          1 B            18 S            35 j            52 0
93          2 C            19 T            36 k            53 1
94          3 D            20 U            37 l            54 2
95          4 E            21 V            38 m            55 3
96          5 F            22 W            39 n            56 4
97          6 G            23 X            40 o            57 5
98          7 H            24 Y            41 p            58 6
99          8 I            25 Z            42 q            59 7
100          9 J            26 a            43 r            60 8
101         10 K            27 b            44 s            61 9
102         11 L            28 c            45 t            62 +
103         12 M            29 d            46 u            63 /
104         13 N            30 e            47 v
105         14 O            31 f            48 w         (pad) =
106         15 P            32 g            49 x
107         16 Q            33 h            50 y
108
109   Special processing is performed if fewer than 24 bits are available
110   at the end of the data being encoded.  A full encoding quantum is
111   always completed at the end of a quantity.  When fewer than 24 input
112   bits are available in an input group, zero bits are added (on the
113   right) to form an integral number of 6-bit groups.  Padding at the
114   end of the data is performed using the '=' character.
115
116   Since all base64 input is an integral number of octets, only the
117         -------------------------------------------------                       
118   following cases can arise:
119   
120       (1) the final quantum of encoding input is an integral
121           multiple of 24 bits; here, the final unit of encoded
122           output will be an integral multiple of 4 characters
123           with no "=" padding,
124       (2) the final quantum of encoding input is exactly 8 bits;
125           here, the final unit of encoded output will be two
126           characters followed by two "=" padding characters, or
127       (3) the final quantum of encoding input is exactly 16 bits;
128           here, the final unit of encoded output will be three
129           characters followed by one "=" padding character.
130   */
131
132int
133b64_ntop(u_char const *src, size_t srclength, char *target, size_t targsize) {
134        size_t datalength = 0;
135        u_char input[3];
136        u_char output[4];
137        size_t i;
138
139        while (2 < srclength) {
140                input[0] = *src++;
141                input[1] = *src++;
142                input[2] = *src++;
143                srclength -= 3;
144
145                output[0] = input[0] >> 2;
146                output[1] = ((input[0] & 0x03) << 4) + (input[1] >> 4);
147                output[2] = ((input[1] & 0x0f) << 2) + (input[2] >> 6);
148                output[3] = input[2] & 0x3f;
149                Assert(output[0] < 64);
150                Assert(output[1] < 64);
151                Assert(output[2] < 64);
152                Assert(output[3] < 64);
153
154                if (datalength + 4 > targsize)
155                        return (-1);
156                target[datalength++] = Base64[output[0]];
157                target[datalength++] = Base64[output[1]];
158                target[datalength++] = Base64[output[2]];
159                target[datalength++] = Base64[output[3]];
160        }
161   
162        /* Now we worry about padding. */
163        if (0 != srclength) {
164                /* Get what's left. */
165                input[0] = input[1] = input[2] = '\0';
166                for (i = 0; i < srclength; i++)
167                        input[i] = *src++;
168       
169                output[0] = input[0] >> 2;
170                output[1] = ((input[0] & 0x03) << 4) + (input[1] >> 4);
171                output[2] = ((input[1] & 0x0f) << 2) + (input[2] >> 6);
172                Assert(output[0] < 64);
173                Assert(output[1] < 64);
174                Assert(output[2] < 64);
175
176                if (datalength + 4 > targsize)
177                        return (-1);
178                target[datalength++] = Base64[output[0]];
179                target[datalength++] = Base64[output[1]];
180                if (srclength == 1)
181                        target[datalength++] = Pad64;
182                else
183                        target[datalength++] = Base64[output[2]];
184                target[datalength++] = Pad64;
185        }
186        if (datalength >= targsize)
187                return (-1);
188        target[datalength] = '\0';      /* Returned value doesn't count \0. */
189        return (datalength);
190}
191
192/* skips all whitespace anywhere.
193   converts characters, four at a time, starting at (or after)
194   src from base - 64 numbers into three 8 bit bytes in the target area.
195   it returns the number of data bytes stored at the target, or -1 on error.
196 */
197
198int
199b64_pton(src, target, targsize)
200        char const *src;
201        u_char *target;
202        size_t targsize;
203{
204        int tarindex, state, ch;
205        char *pos;
206
207        state = 0;
208        tarindex = 0;
209
210        while ((ch = *src++) != '\0') {
211                if (isspace(ch))        /* Skip whitespace anywhere. */
212                        continue;
213
214                if (ch == Pad64)
215                        break;
216
217                pos = strchr(Base64, ch);
218                if (pos == 0)           /* A non-base64 character. */
219                        return (-1);
220
221                switch (state) {
222                case 0:
223                        if (target) {
224                                if ((size_t)tarindex >= targsize)
225                                        return (-1);
226                                target[tarindex] = (pos - Base64) << 2;
227                        }
228                        state = 1;
229                        break;
230                case 1:
231                        if (target) {
232                                if ((size_t)tarindex + 1 >= targsize)
233                                        return (-1);
234                                target[tarindex]   |=  (pos - Base64) >> 4;
235                                target[tarindex+1]  = ((pos - Base64) & 0x0f)
236                                                        << 4 ;
237                        }
238                        tarindex++;
239                        state = 2;
240                        break;
241                case 2:
242                        if (target) {
243                                if ((size_t)tarindex + 1 >= targsize)
244                                        return (-1);
245                                target[tarindex]   |=  (pos - Base64) >> 2;
246                                target[tarindex+1]  = ((pos - Base64) & 0x03)
247                                                        << 6;
248                        }
249                        tarindex++;
250                        state = 3;
251                        break;
252                case 3:
253                        if (target) {
254                                if ((size_t)tarindex >= targsize)
255                                        return (-1);
256                                target[tarindex] |= (pos - Base64);
257                        }
258                        tarindex++;
259                        state = 0;
260                        break;
261                default:
262                        abort();
263                }
264        }
265
266        /*
267         * We are done decoding Base-64 chars.  Let's see if we ended
268         * on a byte boundary, and/or with erroneous trailing characters.
269         */
270
271        if (ch == Pad64) {              /* We got a pad char. */
272                ch = *src++;            /* Skip it, get next. */
273                switch (state) {
274                case 0:         /* Invalid = in first position */
275                case 1:         /* Invalid = in second position */
276                        return (-1);
277
278                case 2:         /* Valid, means one byte of info */
279                        /* Skip any number of spaces. */
280                        for ((void)NULL; ch != '\0'; ch = *src++)
281                                if (!isspace(ch))
282                                        break;
283                        /* Make sure there is another trailing = sign. */
284                        if (ch != Pad64)
285                                return (-1);
286                        ch = *src++;            /* Skip the = */
287                        /* Fall through to "single trailing =" case. */
288                        /* FALLTHROUGH */
289
290                case 3:         /* Valid, means two bytes of info */
291                        /*
292                         * We know this char is an =.  Is there anything but
293                         * whitespace after it?
294                         */
295                        for ((void)NULL; ch != '\0'; ch = *src++)
296                                if (!isspace(ch))
297                                        return (-1);
298
299                        /*
300                         * Now make sure for cases 2 and 3 that the "extra"
301                         * bits that slopped past the last full byte were
302                         * zeros.  If we don't check them, they become a
303                         * subliminal channel.
304                         */
305                        if (target && target[tarindex] != 0)
306                                return (-1);
307                }
308        } else {
309                /*
310                 * We ended by seeing the end of the string.  Make sure we
311                 * have no partial bytes lying around.
312                 */
313                if (state != 0)
314                        return (-1);
315        }
316
317        return (tarindex);
318}
Note: See TracBrowser for help on using the repository browser.