Update the python bindings to work with current version
[deb_shairplay.git] / src / lib / base64.c
1 /**
2 * Copyright (C) 2011-2012 Juho Vähä-Herttua
3 *
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2.1 of the License, or (at your option) any later version.
8 *
9 * This library 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 GNU
12 * Lesser General Public License for more details.
13 */
14
15 #include <stdlib.h>
16 #include <string.h>
17 #include <ctype.h>
18
19 #include "base64.h"
20
21 #define DEFAULT_CHARLIST "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
22
23 #define BASE64_PADDING 0x40
24 #define BASE64_INVALID 0x80
25
26 struct base64_s {
27 char charlist[65];
28 char charmap[256];
29 int charmap_inited;
30
31 int use_padding;
32 int skip_spaces;
33 };
34
35 static base64_t default_base64 =
36 { .charlist = DEFAULT_CHARLIST,
37 .use_padding = 1 };
38
39 static void
40 initialize_charmap(base64_t *base64)
41 {
42 int i;
43
44 memset(base64->charmap, BASE64_INVALID, sizeof(base64->charmap));
45 for (i=0; i<64; i++) {
46 base64->charmap[(int)base64->charlist[i]] = i;
47 }
48 base64->charmap['='] = BASE64_PADDING;
49 base64->charmap_inited = 1;
50 }
51
52 base64_t *
53 base64_init(const char *charlist, int use_padding, int skip_spaces)
54 {
55 base64_t *base64;
56 int i;
57
58 if (!charlist) {
59 charlist = DEFAULT_CHARLIST;
60 }
61 if (strlen(charlist) != 64) {
62 return NULL;
63 }
64 for (i=0; i<64; i++) {
65 switch (charlist[i]) {
66 case '\r':
67 case '\n':
68 case '=':
69 return NULL;
70 }
71 }
72
73 base64 = calloc(1, sizeof(base64_t));
74 if (!base64) {
75 return NULL;
76 }
77 strncpy(base64->charlist, charlist, sizeof(base64->charlist)-1);
78 base64->use_padding = use_padding;
79 base64->skip_spaces = skip_spaces;
80
81 return base64;
82 }
83
84 void
85 base64_destroy(base64_t *base64)
86 {
87 free(base64);
88 }
89
90 int
91 base64_encoded_length(base64_t *base64, int srclen)
92 {
93 if (!base64) {
94 base64 = &default_base64;
95 }
96
97 if (base64->use_padding) {
98 return ((srclen+2)/3*4)+1;
99 } else {
100 int strlen = 0;
101 switch (srclen % 3) {
102 case 2:
103 strlen += 1;
104 case 1:
105 strlen += 2;
106 default:
107 strlen += srclen/3*4;
108 break;
109 }
110 return strlen+1;
111 }
112 }
113
114 int
115 base64_encode(base64_t *base64, char *dst, const unsigned char *src, int srclen)
116 {
117 int src_idx, dst_idx;
118 int residue;
119
120 if (!base64) {
121 base64 = &default_base64;
122 }
123
124 residue = 0;
125 for (src_idx=dst_idx=0; src_idx<srclen; src_idx++) {
126 residue |= src[src_idx];
127
128 switch (src_idx%3) {
129 case 0:
130 dst[dst_idx++] = base64->charlist[(residue>>2)%64];
131 residue &= 0x03;
132 break;
133 case 1:
134 dst[dst_idx++] = base64->charlist[residue>>4];
135 residue &= 0x0f;
136 break;
137 case 2:
138 dst[dst_idx++] = base64->charlist[residue>>6];
139 dst[dst_idx++] = base64->charlist[residue&0x3f];
140 residue = 0;
141 break;
142 }
143 residue <<= 8;
144 }
145
146 /* Add padding */
147 if (src_idx%3 == 1) {
148 dst[dst_idx++] = base64->charlist[residue>>4];
149 if (base64->use_padding) {
150 dst[dst_idx++] = '=';
151 dst[dst_idx++] = '=';
152 }
153 } else if (src_idx%3 == 2) {
154 dst[dst_idx++] = base64->charlist[residue>>6];
155 if (base64->use_padding) {
156 dst[dst_idx++] = '=';
157 }
158 }
159 dst[dst_idx] = '\0';
160 return dst_idx;
161 }
162
163 int
164 base64_decode(base64_t *base64, unsigned char **dst, const char *src, int srclen)
165 {
166 char *inbuf;
167 int inbuflen;
168 unsigned char *outbuf;
169 int outbuflen;
170 char *srcptr;
171 int index;
172
173 if (!base64) {
174 base64 = &default_base64;
175 }
176 if (!base64->charmap_inited) {
177 initialize_charmap(base64);
178 }
179
180 inbuf = malloc(srclen+4);
181 if (!inbuf) {
182 return -1;
183 }
184 memcpy(inbuf, src, srclen);
185 inbuf[srclen] = '\0';
186
187 /* Remove all whitespaces from inbuf */
188 if (base64->skip_spaces) {
189 int i, inbuflen = strlen(inbuf);
190 for (i=0; i<inbuflen; i++) {
191 if (inbuf[i] == '\0') {
192 break;
193 } else if (isspace(inbuf[i])) {
194 memmove(inbuf+i, inbuf+i+1, inbuflen-i);
195 inbuflen -= 1;
196 i -= 1;
197 }
198 }
199 }
200
201 /* Add padding to inbuf if required */
202 inbuflen = strlen(inbuf);
203 if (!base64->use_padding) {
204 if (inbuflen%4 == 1) {
205 free(inbuf);
206 return -2;
207 }
208 if (inbuflen%4 == 2) {
209 inbuf[inbuflen] = '=';
210 inbuf[inbuflen+1] = '=';
211 inbuf[inbuflen+2] = '\0';
212 inbuflen += 2;
213 } else if (inbuflen%4 == 3) {
214 inbuf[inbuflen] = '=';
215 inbuf[inbuflen+1] = '\0';
216 inbuflen += 1;
217 }
218 }
219
220 /* Make sure data is divisible by 4 */
221 if (inbuflen%4 != 0) {
222 free(inbuf);
223 return -3;
224 }
225
226 /* Calculate the output length without padding */
227 outbuflen = inbuflen/4*3;
228 if (inbuflen >= 4 && inbuf[inbuflen-1] == '=') {
229 outbuflen -= 1;
230 if (inbuf[inbuflen-2] == '=') {
231 outbuflen -= 1;
232 }
233 }
234
235 /* Allocate buffer for outputting data */
236 outbuf = malloc(outbuflen);
237 if (!outbuf) {
238 free(inbuf);
239 return -4;
240 }
241
242 index = 0;
243 srcptr = inbuf;
244 while (*srcptr) {
245 unsigned char a = base64->charmap[(unsigned char)*(srcptr++)];
246 unsigned char b = base64->charmap[(unsigned char)*(srcptr++)];
247 unsigned char c = base64->charmap[(unsigned char)*(srcptr++)];
248 unsigned char d = base64->charmap[(unsigned char)*(srcptr++)];
249
250 if (a == BASE64_INVALID || b == BASE64_INVALID ||
251 c == BASE64_INVALID || d == BASE64_INVALID) {
252 return -5;
253 }
254 if (a == BASE64_PADDING || b == BASE64_PADDING) {
255 return -6;
256 }
257
258 /* Update the first byte */
259 outbuf[index++] = (a << 2) | ((b & 0x30) >> 4);
260
261 /* Update the second byte */
262 if (c == BASE64_PADDING) {
263 break;
264 }
265 outbuf[index++] = ((b & 0x0f) << 4) | ((c & 0x3c) >> 2);
266
267 /* Update the third byte */
268 if (d == BASE64_PADDING) {
269 break;
270 }
271 outbuf[index++] = ((c & 0x03) << 6) | d;
272 }
273 if (index != outbuflen) {
274 free(inbuf);
275 free(outbuf);
276 return -7;
277 }
278
279 free(inbuf);
280 *dst = outbuf;
281 return outbuflen;
282 }