blob: 010e22d9c8fcf654ec5a5ba0cd04f634c48374dc [file] [log] [blame]
Jack Jansen72781191995-08-07 14:34:15 +00001/*
2** Routines to represent binary data in ASCII and vice-versa
3**
4** This module currently supports the following encodings:
5** uuencode:
6** each line encodes 45 bytes (except possibly the last)
7** First char encodes (binary) length, rest data
8** each char encodes 6 bits, as follows:
9** binary: 01234567 abcdefgh ijklmnop
10** ascii: 012345 67abcd efghij klmnop
11** ASCII encoding method is "excess-space": 000000 is encoded as ' ', etc.
12** short binary data is zero-extended (so the bits are always in the
13** right place), this does *not* reflect in the length.
Jack Jansen84bbc2e1995-10-04 16:38:44 +000014** base64:
15** Line breaks are insignificant, but lines are at most 76 chars
16** each char encodes 6 bits, in similar order as uucode/hqx. Encoding
17** is done via a table.
18** Short binary data is filled (in ASCII) with '='.
Jack Jansen72781191995-08-07 14:34:15 +000019** hqx:
20** File starts with introductory text, real data starts and ends
21** with colons.
22** Data consists of three similar parts: info, datafork, resourcefork.
23** Each part is protected (at the end) with a 16-bit crc
24** The binary data is run-length encoded, and then ascii-fied:
25** binary: 01234567 abcdefgh ijklmnop
26** ascii: 012345 67abcd efghij klmnop
27** ASCII encoding is table-driven, see the code.
28** Short binary data results in the runt ascii-byte being output with
29** the bits in the right place.
30**
31** While I was reading dozens of programs that encode or decode the formats
32** here (documentation? hihi:-) I have formulated Jansen's Observation:
33**
34** Programs that encode binary data in ASCII are written in
35** such a style that they are as unreadable as possible. Devices used
36** include unnecessary global variables, burying important tables
37** in unrelated sourcefiles, putting functions in include files,
38** using seemingly-descriptive variable names for different purposes,
39** calls to empty subroutines and a host of others.
40**
41** I have attempted to break with this tradition, but I guess that that
42** does make the performance sub-optimal. Oh well, too bad...
43**
44** Jack Jansen, CWI, July 1995.
45*/
46
47
48#include "Python.h"
49
50static PyObject *Error;
51static PyObject *Incomplete;
52
53/*
54** hqx lookup table, ascii->binary.
55*/
56
57#define RUNCHAR 0x90
58
59#define DONE 0x7F
60#define SKIP 0x7E
61#define FAIL 0x7D
62
63static unsigned char table_a2b_hqx[256] = {
64/* ^@ ^A ^B ^C ^D ^E ^F ^G */
65/* 0*/ FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
66/* \b \t \n ^K ^L \r ^N ^O */
67/* 1*/ FAIL, FAIL, SKIP, FAIL, FAIL, SKIP, FAIL, FAIL,
68/* ^P ^Q ^R ^S ^T ^U ^V ^W */
69/* 2*/ FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
70/* ^X ^Y ^Z ^[ ^\ ^] ^^ ^_ */
71/* 3*/ FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
72/* ! " # $ % & ' */
73/* 4*/ FAIL, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06,
74/* ( ) * + , - . / */
75/* 5*/ 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, FAIL, FAIL,
76/* 0 1 2 3 4 5 6 7 */
77/* 6*/ 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12, 0x13, FAIL,
78/* 8 9 : ; < = > ? */
79/* 7*/ 0x14, 0x15, DONE, FAIL, FAIL, FAIL, FAIL, FAIL,
80/* @ A B C D E F G */
81/* 8*/ 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D,
82/* H I J K L M N O */
83/* 9*/ 0x1E, 0x1F, 0x20, 0x21, 0x22, 0x23, 0x24, FAIL,
84/* P Q R S T U V W */
85/*10*/ 0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, FAIL,
86/* X Y Z [ \ ] ^ _ */
87/*11*/ 0x2C, 0x2D, 0x2E, 0x2F, FAIL, FAIL, FAIL, FAIL,
88/* ` a b c d e f g */
89/*12*/ 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, FAIL,
90/* h i j k l m n o */
91/*13*/ 0x37, 0x38, 0x39, 0x3A, 0x3B, 0x3C, FAIL, FAIL,
92/* p q r s t u v w */
93/*14*/ 0x3D, 0x3E, 0x3F, FAIL, FAIL, FAIL, FAIL, FAIL,
94/* x y z { | } ~ ^? */
95/*15*/ FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
96/*16*/ FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
97 FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
98 FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
99 FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
100 FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
101 FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
102 FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
103 FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
104 FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
105 FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
106 FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
107 FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
108 FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
109 FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
110 FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
111 FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
112};
113
114static unsigned char table_b2a_hqx[] =
Roger E. Masse5f4ce181997-01-16 17:10:22 +0000115"!\"#$%&'()*+,-012345689@ABCDEFGHIJKLMNPQRSTUVXYZ[`abcdefhijklmpqr";
Jack Jansen72781191995-08-07 14:34:15 +0000116
Jack Jansen84bbc2e1995-10-04 16:38:44 +0000117static char table_a2b_base64[] = {
118 -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,
119 -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,
120 -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,62, -1,-1,-1,63,
121 52,53,54,55, 56,57,58,59, 60,61,-1,-1, -1, 0,-1,-1, /* Note PAD->0 */
122 -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10, 11,12,13,14,
123 15,16,17,18, 19,20,21,22, 23,24,25,-1, -1,-1,-1,-1,
124 -1,26,27,28, 29,30,31,32, 33,34,35,36, 37,38,39,40,
125 41,42,43,44, 45,46,47,48, 49,50,51,-1, -1,-1,-1,-1
126};
127
128#define BASE64_PAD '='
129#define BASE64_MAXBIN 57 /* Max binary chunk size (76 char line) */
130
131static unsigned char table_b2a_base64[] =
Roger E. Masse5f4ce181997-01-16 17:10:22 +0000132"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
Jack Jansen84bbc2e1995-10-04 16:38:44 +0000133
134
135
Jack Jansen72781191995-08-07 14:34:15 +0000136static unsigned short crctab_hqx[256] = {
Roger E. Masse5f4ce181997-01-16 17:10:22 +0000137 0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50a5, 0x60c6, 0x70e7,
138 0x8108, 0x9129, 0xa14a, 0xb16b, 0xc18c, 0xd1ad, 0xe1ce, 0xf1ef,
139 0x1231, 0x0210, 0x3273, 0x2252, 0x52b5, 0x4294, 0x72f7, 0x62d6,
140 0x9339, 0x8318, 0xb37b, 0xa35a, 0xd3bd, 0xc39c, 0xf3ff, 0xe3de,
141 0x2462, 0x3443, 0x0420, 0x1401, 0x64e6, 0x74c7, 0x44a4, 0x5485,
142 0xa56a, 0xb54b, 0x8528, 0x9509, 0xe5ee, 0xf5cf, 0xc5ac, 0xd58d,
143 0x3653, 0x2672, 0x1611, 0x0630, 0x76d7, 0x66f6, 0x5695, 0x46b4,
144 0xb75b, 0xa77a, 0x9719, 0x8738, 0xf7df, 0xe7fe, 0xd79d, 0xc7bc,
145 0x48c4, 0x58e5, 0x6886, 0x78a7, 0x0840, 0x1861, 0x2802, 0x3823,
146 0xc9cc, 0xd9ed, 0xe98e, 0xf9af, 0x8948, 0x9969, 0xa90a, 0xb92b,
147 0x5af5, 0x4ad4, 0x7ab7, 0x6a96, 0x1a71, 0x0a50, 0x3a33, 0x2a12,
148 0xdbfd, 0xcbdc, 0xfbbf, 0xeb9e, 0x9b79, 0x8b58, 0xbb3b, 0xab1a,
149 0x6ca6, 0x7c87, 0x4ce4, 0x5cc5, 0x2c22, 0x3c03, 0x0c60, 0x1c41,
150 0xedae, 0xfd8f, 0xcdec, 0xddcd, 0xad2a, 0xbd0b, 0x8d68, 0x9d49,
151 0x7e97, 0x6eb6, 0x5ed5, 0x4ef4, 0x3e13, 0x2e32, 0x1e51, 0x0e70,
152 0xff9f, 0xefbe, 0xdfdd, 0xcffc, 0xbf1b, 0xaf3a, 0x9f59, 0x8f78,
153 0x9188, 0x81a9, 0xb1ca, 0xa1eb, 0xd10c, 0xc12d, 0xf14e, 0xe16f,
154 0x1080, 0x00a1, 0x30c2, 0x20e3, 0x5004, 0x4025, 0x7046, 0x6067,
155 0x83b9, 0x9398, 0xa3fb, 0xb3da, 0xc33d, 0xd31c, 0xe37f, 0xf35e,
156 0x02b1, 0x1290, 0x22f3, 0x32d2, 0x4235, 0x5214, 0x6277, 0x7256,
157 0xb5ea, 0xa5cb, 0x95a8, 0x8589, 0xf56e, 0xe54f, 0xd52c, 0xc50d,
158 0x34e2, 0x24c3, 0x14a0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405,
159 0xa7db, 0xb7fa, 0x8799, 0x97b8, 0xe75f, 0xf77e, 0xc71d, 0xd73c,
160 0x26d3, 0x36f2, 0x0691, 0x16b0, 0x6657, 0x7676, 0x4615, 0x5634,
161 0xd94c, 0xc96d, 0xf90e, 0xe92f, 0x99c8, 0x89e9, 0xb98a, 0xa9ab,
162 0x5844, 0x4865, 0x7806, 0x6827, 0x18c0, 0x08e1, 0x3882, 0x28a3,
163 0xcb7d, 0xdb5c, 0xeb3f, 0xfb1e, 0x8bf9, 0x9bd8, 0xabbb, 0xbb9a,
164 0x4a75, 0x5a54, 0x6a37, 0x7a16, 0x0af1, 0x1ad0, 0x2ab3, 0x3a92,
165 0xfd2e, 0xed0f, 0xdd6c, 0xcd4d, 0xbdaa, 0xad8b, 0x9de8, 0x8dc9,
166 0x7c26, 0x6c07, 0x5c64, 0x4c45, 0x3ca2, 0x2c83, 0x1ce0, 0x0cc1,
167 0xef1f, 0xff3e, 0xcf5d, 0xdf7c, 0xaf9b, 0xbfba, 0x8fd9, 0x9ff8,
168 0x6e17, 0x7e36, 0x4e55, 0x5e74, 0x2e93, 0x3eb2, 0x0ed1, 0x1ef0,
Jack Jansen72781191995-08-07 14:34:15 +0000169};
170
171static char doc_a2b_uu[] = "(ascii) -> bin. Decode a line of uuencoded data";
172
173static PyObject *
Peter Schneider-Kampa788a7f2000-07-10 09:57:19 +0000174binascii_a2b_uu(PyObject *self, PyObject *args)
Jack Jansen72781191995-08-07 14:34:15 +0000175{
176 unsigned char *ascii_data, *bin_data;
177 int leftbits = 0;
178 unsigned char this_ch;
179 unsigned int leftchar = 0;
180 PyObject *rv;
181 int ascii_len, bin_len;
182
Guido van Rossum43713e52000-02-29 13:59:29 +0000183 if ( !PyArg_ParseTuple(args, "t#:a2b_uu", &ascii_data, &ascii_len) )
Jack Jansen72781191995-08-07 14:34:15 +0000184 return NULL;
185
186 /* First byte: binary data length (in bytes) */
187 bin_len = (*ascii_data++ - ' ') & 077;
188 ascii_len--;
189
190 /* Allocate the buffer */
191 if ( (rv=PyString_FromStringAndSize(NULL, bin_len)) == NULL )
192 return NULL;
193 bin_data = (unsigned char *)PyString_AsString(rv);
194
195 for( ; bin_len > 0 ; ascii_len--, ascii_data++ ) {
196 this_ch = *ascii_data;
197 if ( this_ch == '\n' || this_ch == '\r' || ascii_len <= 0) {
198 /*
199 ** Whitespace. Assume some spaces got eaten at
200 ** end-of-line. (We check this later)
201 */
202 this_ch = 0;
203 } else {
Jack Jansen5d957971995-11-14 10:35:19 +0000204 /* Check the character for legality
Roger E. Masse5f4ce181997-01-16 17:10:22 +0000205 ** The 64 in stead of the expected 63 is because
206 ** there are a few uuencodes out there that use
207 ** '@' as zero instead of space.
Jack Jansen5d957971995-11-14 10:35:19 +0000208 */
209 if ( this_ch < ' ' || this_ch > (' ' + 64)) {
Jack Jansen72781191995-08-07 14:34:15 +0000210 PyErr_SetString(Error, "Illegal char");
211 Py_DECREF(rv);
212 return NULL;
213 }
214 this_ch = (this_ch - ' ') & 077;
215 }
216 /*
217 ** Shift it in on the low end, and see if there's
218 ** a byte ready for output.
219 */
220 leftchar = (leftchar << 6) | (this_ch);
221 leftbits += 6;
222 if ( leftbits >= 8 ) {
223 leftbits -= 8;
224 *bin_data++ = (leftchar >> leftbits) & 0xff;
225 leftchar &= ((1 << leftbits) - 1);
226 bin_len--;
227 }
228 }
229 /*
230 ** Finally, check that if there's anything left on the line
231 ** that it's whitespace only.
232 */
233 while( ascii_len-- > 0 ) {
234 this_ch = *ascii_data++;
Guido van Rossum1243ae71997-07-11 18:36:28 +0000235 /* Extra '@' may be written as padding in some cases */
236 if ( this_ch != ' ' && this_ch != '@' &&
237 this_ch != '\n' && this_ch != '\r' ) {
Jack Jansen72781191995-08-07 14:34:15 +0000238 PyErr_SetString(Error, "Trailing garbage");
239 Py_DECREF(rv);
240 return NULL;
241 }
242 }
243 return rv;
244}
245
246static char doc_b2a_uu[] = "(bin) -> ascii. Uuencode line of data";
247
248static PyObject *
Peter Schneider-Kampa788a7f2000-07-10 09:57:19 +0000249binascii_b2a_uu(PyObject *self, PyObject *args)
Jack Jansen72781191995-08-07 14:34:15 +0000250{
251 unsigned char *ascii_data, *bin_data;
252 int leftbits = 0;
253 unsigned char this_ch;
254 unsigned int leftchar = 0;
255 PyObject *rv;
256 int bin_len;
257
Guido van Rossum43713e52000-02-29 13:59:29 +0000258 if ( !PyArg_ParseTuple(args, "s#:b2a_uu", &bin_data, &bin_len) )
Jack Jansen72781191995-08-07 14:34:15 +0000259 return NULL;
260 if ( bin_len > 45 ) {
261 /* The 45 is a limit that appears in all uuencode's */
262 PyErr_SetString(Error, "At most 45 bytes at once");
263 return NULL;
264 }
265
266 /* We're lazy and allocate to much (fixed up later) */
267 if ( (rv=PyString_FromStringAndSize(NULL, bin_len*2)) == NULL )
268 return NULL;
269 ascii_data = (unsigned char *)PyString_AsString(rv);
270
271 /* Store the length */
272 *ascii_data++ = ' ' + (bin_len & 077);
273
274 for( ; bin_len > 0 || leftbits != 0 ; bin_len--, bin_data++ ) {
275 /* Shift the data (or padding) into our buffer */
276 if ( bin_len > 0 ) /* Data */
277 leftchar = (leftchar << 8) | *bin_data;
278 else /* Padding */
279 leftchar <<= 8;
280 leftbits += 8;
281
282 /* See if there are 6-bit groups ready */
283 while ( leftbits >= 6 ) {
284 this_ch = (leftchar >> (leftbits-6)) & 0x3f;
285 leftbits -= 6;
286 *ascii_data++ = this_ch + ' ';
287 }
288 }
289 *ascii_data++ = '\n'; /* Append a courtesy newline */
290
Roger E. Masse5f4ce181997-01-16 17:10:22 +0000291 _PyString_Resize(&rv, (ascii_data -
292 (unsigned char *)PyString_AsString(rv)));
Jack Jansen72781191995-08-07 14:34:15 +0000293 return rv;
294}
295
Guido van Rossum2db4f471999-10-19 19:05:14 +0000296
297static int
Peter Schneider-Kampa788a7f2000-07-10 09:57:19 +0000298binascii_find_valid(unsigned char *s, int slen, int num)
Guido van Rossum2db4f471999-10-19 19:05:14 +0000299{
300 /* Finds & returns the (num+1)th
301 ** valid character for base64, or -1 if none.
302 */
303
304 int ret = -1;
305 unsigned char c, b64val;
306
307 while ((slen > 0) && (ret == -1)) {
308 c = *s;
309 b64val = table_a2b_base64[c & 0x7f];
310 if ( ((c <= 0x7f) && (b64val != (unsigned char)-1)) ) {
311 if (num == 0)
312 ret = *s;
313 num--;
314 }
315
316 s++;
317 slen--;
318 }
319 return ret;
320}
321
Jack Jansen84bbc2e1995-10-04 16:38:44 +0000322static char doc_a2b_base64[] = "(ascii) -> bin. Decode a line of base64 data";
323
324static PyObject *
Peter Schneider-Kampa788a7f2000-07-10 09:57:19 +0000325binascii_a2b_base64(PyObject *self, PyObject *args)
Jack Jansen84bbc2e1995-10-04 16:38:44 +0000326{
327 unsigned char *ascii_data, *bin_data;
328 int leftbits = 0;
329 unsigned char this_ch;
330 unsigned int leftchar = 0;
Jack Jansen84bbc2e1995-10-04 16:38:44 +0000331 PyObject *rv;
332 int ascii_len, bin_len;
Guido van Rossum2db4f471999-10-19 19:05:14 +0000333 int quad_pos = 0;
Jack Jansen84bbc2e1995-10-04 16:38:44 +0000334
Guido van Rossum43713e52000-02-29 13:59:29 +0000335 if ( !PyArg_ParseTuple(args, "t#:a2b_base64", &ascii_data, &ascii_len) )
Jack Jansen84bbc2e1995-10-04 16:38:44 +0000336 return NULL;
337
338 bin_len = ((ascii_len+3)/4)*3; /* Upper bound, corrected later */
339
340 /* Allocate the buffer */
341 if ( (rv=PyString_FromStringAndSize(NULL, bin_len)) == NULL )
342 return NULL;
343 bin_data = (unsigned char *)PyString_AsString(rv);
344 bin_len = 0;
Guido van Rossum2db4f471999-10-19 19:05:14 +0000345
346 for( ; ascii_len > 0; ascii_len--, ascii_data++) {
347 this_ch = *ascii_data;
348
349 if (this_ch > 0x7f ||
350 this_ch == '\r' || this_ch == '\n' || this_ch == ' ')
Jack Jansenba1de3b1996-01-22 10:47:15 +0000351 continue;
Guido van Rossum2db4f471999-10-19 19:05:14 +0000352
353 /* Check for pad sequences and ignore
354 ** the invalid ones.
355 */
356 if (this_ch == BASE64_PAD) {
357 if ( (quad_pos < 2) ||
358 ((quad_pos == 2) &&
359 (binascii_find_valid(ascii_data, ascii_len, 1)
360 != BASE64_PAD)) )
361 {
362 continue;
363 }
364 else {
365 /* A pad sequence means no more input.
366 ** We've already interpreted the data
367 ** from the quad at this point.
368 */
369 leftbits = 0;
370 break;
371 }
372 }
373
374 this_ch = table_a2b_base64[*ascii_data];
375 if ( this_ch == (unsigned char) -1 )
376 continue;
377
Jack Jansen84bbc2e1995-10-04 16:38:44 +0000378 /*
379 ** Shift it in on the low end, and see if there's
380 ** a byte ready for output.
381 */
Guido van Rossum2db4f471999-10-19 19:05:14 +0000382 quad_pos = (quad_pos + 1) & 0x03;
Jack Jansen84bbc2e1995-10-04 16:38:44 +0000383 leftchar = (leftchar << 6) | (this_ch);
384 leftbits += 6;
Guido van Rossum2db4f471999-10-19 19:05:14 +0000385
Jack Jansen84bbc2e1995-10-04 16:38:44 +0000386 if ( leftbits >= 8 ) {
387 leftbits -= 8;
388 *bin_data++ = (leftchar >> leftbits) & 0xff;
Jack Jansen84bbc2e1995-10-04 16:38:44 +0000389 bin_len++;
Guido van Rossum2db4f471999-10-19 19:05:14 +0000390 leftchar &= ((1 << leftbits) - 1);
Jack Jansen84bbc2e1995-10-04 16:38:44 +0000391 }
Guido van Rossum2db4f471999-10-19 19:05:14 +0000392 }
393
394 if (leftbits != 0) {
Jack Jansen84bbc2e1995-10-04 16:38:44 +0000395 PyErr_SetString(Error, "Incorrect padding");
396 Py_DECREF(rv);
397 return NULL;
398 }
Guido van Rossum2db4f471999-10-19 19:05:14 +0000399
Jack Jansen84bbc2e1995-10-04 16:38:44 +0000400 /* and set string size correctly */
401 _PyString_Resize(&rv, bin_len);
402 return rv;
403}
404
405static char doc_b2a_base64[] = "(bin) -> ascii. Base64-code line of data";
406
407static PyObject *
Peter Schneider-Kampa788a7f2000-07-10 09:57:19 +0000408binascii_b2a_base64(PyObject *self, PyObject *args)
Jack Jansen84bbc2e1995-10-04 16:38:44 +0000409{
410 unsigned char *ascii_data, *bin_data;
411 int leftbits = 0;
412 unsigned char this_ch;
413 unsigned int leftchar = 0;
414 PyObject *rv;
415 int bin_len;
416
Guido van Rossum43713e52000-02-29 13:59:29 +0000417 if ( !PyArg_ParseTuple(args, "s#:b2a_base64", &bin_data, &bin_len) )
Jack Jansen84bbc2e1995-10-04 16:38:44 +0000418 return NULL;
419 if ( bin_len > BASE64_MAXBIN ) {
420 PyErr_SetString(Error, "Too much data for base64 line");
421 return NULL;
422 }
423
424 /* We're lazy and allocate to much (fixed up later) */
425 if ( (rv=PyString_FromStringAndSize(NULL, bin_len*2)) == NULL )
426 return NULL;
427 ascii_data = (unsigned char *)PyString_AsString(rv);
428
429 for( ; bin_len > 0 ; bin_len--, bin_data++ ) {
430 /* Shift the data into our buffer */
431 leftchar = (leftchar << 8) | *bin_data;
432 leftbits += 8;
433
434 /* See if there are 6-bit groups ready */
435 while ( leftbits >= 6 ) {
436 this_ch = (leftchar >> (leftbits-6)) & 0x3f;
437 leftbits -= 6;
438 *ascii_data++ = table_b2a_base64[this_ch];
439 }
440 }
441 if ( leftbits == 2 ) {
442 *ascii_data++ = table_b2a_base64[(leftchar&3) << 4];
443 *ascii_data++ = BASE64_PAD;
444 *ascii_data++ = BASE64_PAD;
445 } else if ( leftbits == 4 ) {
446 *ascii_data++ = table_b2a_base64[(leftchar&0xf) << 2];
447 *ascii_data++ = BASE64_PAD;
448 }
449 *ascii_data++ = '\n'; /* Append a courtesy newline */
450
Roger E. Masse5f4ce181997-01-16 17:10:22 +0000451 _PyString_Resize(&rv, (ascii_data -
452 (unsigned char *)PyString_AsString(rv)));
Jack Jansen84bbc2e1995-10-04 16:38:44 +0000453 return rv;
454}
455
Jack Jansen72781191995-08-07 14:34:15 +0000456static char doc_a2b_hqx[] = "ascii -> bin, done. Decode .hqx coding";
457
458static PyObject *
Peter Schneider-Kampa788a7f2000-07-10 09:57:19 +0000459binascii_a2b_hqx(PyObject *self, PyObject *args)
Jack Jansen72781191995-08-07 14:34:15 +0000460{
461 unsigned char *ascii_data, *bin_data;
462 int leftbits = 0;
463 unsigned char this_ch;
Jack Janseneaeb1c81995-08-14 12:17:57 +0000464 unsigned int leftchar = 0;
Jack Jansen72781191995-08-07 14:34:15 +0000465 PyObject *rv;
466 int len;
467 int done = 0;
468
Guido van Rossum43713e52000-02-29 13:59:29 +0000469 if ( !PyArg_ParseTuple(args, "t#:a2b_hqx", &ascii_data, &len) )
Jack Jansen72781191995-08-07 14:34:15 +0000470 return NULL;
471
472 /* Allocate a string that is too big (fixed later) */
473 if ( (rv=PyString_FromStringAndSize(NULL, len)) == NULL )
474 return NULL;
475 bin_data = (unsigned char *)PyString_AsString(rv);
476
477 for( ; len > 0 ; len--, ascii_data++ ) {
478 /* Get the byte and look it up */
479 this_ch = table_a2b_hqx[*ascii_data];
480 if ( this_ch == SKIP )
481 continue;
482 if ( this_ch == FAIL ) {
483 PyErr_SetString(Error, "Illegal char");
484 Py_DECREF(rv);
485 return NULL;
486 }
487 if ( this_ch == DONE ) {
488 /* The terminating colon */
489 done = 1;
490 break;
491 }
492
493 /* Shift it into the buffer and see if any bytes are ready */
494 leftchar = (leftchar << 6) | (this_ch);
495 leftbits += 6;
496 if ( leftbits >= 8 ) {
497 leftbits -= 8;
498 *bin_data++ = (leftchar >> leftbits) & 0xff;
499 leftchar &= ((1 << leftbits) - 1);
500 }
501 }
502
503 if ( leftbits && !done ) {
504 PyErr_SetString(Incomplete,
505 "String has incomplete number of bytes");
506 Py_DECREF(rv);
507 return NULL;
508 }
Guido van Rossum9c6ba5e1997-01-12 20:02:04 +0000509 _PyString_Resize(
510 &rv, (bin_data - (unsigned char *)PyString_AsString(rv)));
511 if (rv) {
512 PyObject *rrv = Py_BuildValue("Oi", rv, done);
513 Py_DECREF(rv);
514 return rrv;
515 }
Roger E. Masse5f4ce181997-01-16 17:10:22 +0000516
Jack Jansen72781191995-08-07 14:34:15 +0000517 return NULL;
518}
519
520static char doc_rlecode_hqx[] = "Binhex RLE-code binary data";
521
522static PyObject *
Peter Schneider-Kampa788a7f2000-07-10 09:57:19 +0000523binascii_rlecode_hqx(PyObject *self, PyObject *args)
Jack Jansen72781191995-08-07 14:34:15 +0000524{
525 unsigned char *in_data, *out_data;
526 PyObject *rv;
527 unsigned char ch;
528 int in, inend, len;
529
Guido van Rossum43713e52000-02-29 13:59:29 +0000530 if ( !PyArg_ParseTuple(args, "s#:rlecode_hqx", &in_data, &len) )
Jack Jansen72781191995-08-07 14:34:15 +0000531 return NULL;
532
533 /* Worst case: output is twice as big as input (fixed later) */
534 if ( (rv=PyString_FromStringAndSize(NULL, len*2)) == NULL )
535 return NULL;
536 out_data = (unsigned char *)PyString_AsString(rv);
537
538 for( in=0; in<len; in++) {
539 ch = in_data[in];
540 if ( ch == RUNCHAR ) {
541 /* RUNCHAR. Escape it. */
542 *out_data++ = RUNCHAR;
543 *out_data++ = 0;
544 } else {
545 /* Check how many following are the same */
546 for(inend=in+1;
547 inend<len && in_data[inend] == ch &&
Roger E. Masse5f4ce181997-01-16 17:10:22 +0000548 inend < in+255;
Jack Jansen72781191995-08-07 14:34:15 +0000549 inend++) ;
Jack Jansen0223aa11995-08-31 13:44:23 +0000550 if ( inend - in > 3 ) {
551 /* More than 3 in a row. Output RLE. */
Jack Jansen72781191995-08-07 14:34:15 +0000552 *out_data++ = ch;
553 *out_data++ = RUNCHAR;
554 *out_data++ = inend-in;
555 in = inend-1;
556 } else {
557 /* Less than 3. Output the byte itself */
558 *out_data++ = ch;
559 }
560 }
561 }
Roger E. Masse5f4ce181997-01-16 17:10:22 +0000562 _PyString_Resize(&rv, (out_data -
563 (unsigned char *)PyString_AsString(rv)));
Jack Jansen72781191995-08-07 14:34:15 +0000564 return rv;
565}
566
567static char doc_b2a_hqx[] = "Encode .hqx data";
568
569static PyObject *
Peter Schneider-Kampa788a7f2000-07-10 09:57:19 +0000570binascii_b2a_hqx(PyObject *self, PyObject *args)
Jack Jansen72781191995-08-07 14:34:15 +0000571{
572 unsigned char *ascii_data, *bin_data;
573 int leftbits = 0;
574 unsigned char this_ch;
Jack Janseneaeb1c81995-08-14 12:17:57 +0000575 unsigned int leftchar = 0;
Jack Jansen72781191995-08-07 14:34:15 +0000576 PyObject *rv;
577 int len;
578
Guido van Rossum43713e52000-02-29 13:59:29 +0000579 if ( !PyArg_ParseTuple(args, "s#:b2a_hqx", &bin_data, &len) )
Jack Jansen72781191995-08-07 14:34:15 +0000580 return NULL;
581
582 /* Allocate a buffer that is at least large enough */
583 if ( (rv=PyString_FromStringAndSize(NULL, len*2)) == NULL )
584 return NULL;
585 ascii_data = (unsigned char *)PyString_AsString(rv);
586
587 for( ; len > 0 ; len--, bin_data++ ) {
588 /* Shift into our buffer, and output any 6bits ready */
589 leftchar = (leftchar << 8) | *bin_data;
590 leftbits += 8;
591 while ( leftbits >= 6 ) {
592 this_ch = (leftchar >> (leftbits-6)) & 0x3f;
593 leftbits -= 6;
594 *ascii_data++ = table_b2a_hqx[this_ch];
595 }
596 }
597 /* Output a possible runt byte */
598 if ( leftbits ) {
599 leftchar <<= (6-leftbits);
600 *ascii_data++ = table_b2a_hqx[leftchar & 0x3f];
601 }
Roger E. Masse5f4ce181997-01-16 17:10:22 +0000602 _PyString_Resize(&rv, (ascii_data -
603 (unsigned char *)PyString_AsString(rv)));
Jack Jansen72781191995-08-07 14:34:15 +0000604 return rv;
605}
606
607static char doc_rledecode_hqx[] = "Decode hexbin RLE-coded string";
608
609static PyObject *
Peter Schneider-Kampa788a7f2000-07-10 09:57:19 +0000610binascii_rledecode_hqx(PyObject *self, PyObject *args)
Jack Jansen72781191995-08-07 14:34:15 +0000611{
612 unsigned char *in_data, *out_data;
613 unsigned char in_byte, in_repeat;
614 PyObject *rv;
615 int in_len, out_len, out_len_left;
616
Guido van Rossum43713e52000-02-29 13:59:29 +0000617 if ( !PyArg_ParseTuple(args, "s#:rledecode_hqx", &in_data, &in_len) )
Jack Jansen72781191995-08-07 14:34:15 +0000618 return NULL;
619
620 /* Empty string is a special case */
621 if ( in_len == 0 )
622 return Py_BuildValue("s", "");
623
624 /* Allocate a buffer of reasonable size. Resized when needed */
625 out_len = in_len*2;
626 if ( (rv=PyString_FromStringAndSize(NULL, out_len)) == NULL )
627 return NULL;
628 out_len_left = out_len;
629 out_data = (unsigned char *)PyString_AsString(rv);
630
631 /*
632 ** We need two macros here to get/put bytes and handle
633 ** end-of-buffer for input and output strings.
634 */
635#define INBYTE(b) \
Roger E. Masse5f4ce181997-01-16 17:10:22 +0000636 do { \
637 if ( --in_len < 0 ) { \
638 PyErr_SetString(Incomplete, ""); \
639 Py_DECREF(rv); \
640 return NULL; \
641 } \
642 b = *in_data++; \
643 } while(0)
Jack Jansen72781191995-08-07 14:34:15 +0000644
645#define OUTBYTE(b) \
Roger E. Masse5f4ce181997-01-16 17:10:22 +0000646 do { \
647 if ( --out_len_left < 0 ) { \
648 _PyString_Resize(&rv, 2*out_len); \
649 if ( rv == NULL ) return NULL; \
650 out_data = (unsigned char *)PyString_AsString(rv) \
651 + out_len; \
652 out_len_left = out_len-1; \
653 out_len = out_len * 2; \
654 } \
655 *out_data++ = b; \
656 } while(0)
Jack Jansen72781191995-08-07 14:34:15 +0000657
Roger E. Masse5f4ce181997-01-16 17:10:22 +0000658 /*
659 ** Handle first byte separately (since we have to get angry
660 ** in case of an orphaned RLE code).
661 */
662 INBYTE(in_byte);
Jack Jansen72781191995-08-07 14:34:15 +0000663
664 if (in_byte == RUNCHAR) {
665 INBYTE(in_repeat);
666 if (in_repeat != 0) {
667 /* Note Error, not Incomplete (which is at the end
668 ** of the string only). This is a programmer error.
669 */
670 PyErr_SetString(Error, "Orphaned RLE code at start");
671 Py_DECREF(rv);
672 return NULL;
673 }
674 OUTBYTE(RUNCHAR);
675 } else {
676 OUTBYTE(in_byte);
677 }
678
679 while( in_len > 0 ) {
680 INBYTE(in_byte);
681
682 if (in_byte == RUNCHAR) {
683 INBYTE(in_repeat);
684 if ( in_repeat == 0 ) {
685 /* Just an escaped RUNCHAR value */
686 OUTBYTE(RUNCHAR);
687 } else {
688 /* Pick up value and output a sequence of it */
689 in_byte = out_data[-1];
690 while ( --in_repeat > 0 )
691 OUTBYTE(in_byte);
692 }
693 } else {
694 /* Normal byte */
695 OUTBYTE(in_byte);
696 }
697 }
Roger E. Masse5f4ce181997-01-16 17:10:22 +0000698 _PyString_Resize(&rv, (out_data -
699 (unsigned char *)PyString_AsString(rv)));
Jack Jansen72781191995-08-07 14:34:15 +0000700 return rv;
701}
702
Roger E. Masse5f4ce181997-01-16 17:10:22 +0000703static char doc_crc_hqx[] =
704"(data, oldcrc) -> newcrc. Compute hqx CRC incrementally";
Jack Jansen72781191995-08-07 14:34:15 +0000705
706static PyObject *
Peter Schneider-Kampa788a7f2000-07-10 09:57:19 +0000707binascii_crc_hqx(PyObject *self, PyObject *args)
Jack Jansen72781191995-08-07 14:34:15 +0000708{
709 unsigned char *bin_data;
710 unsigned int crc;
711 int len;
712
Guido van Rossum43713e52000-02-29 13:59:29 +0000713 if ( !PyArg_ParseTuple(args, "s#i:crc_hqx", &bin_data, &len, &crc) )
Jack Jansen72781191995-08-07 14:34:15 +0000714 return NULL;
715
716 while(len--) {
717 crc=((crc<<8)&0xff00)^crctab_hqx[((crc>>8)&0xff)^*bin_data++];
718 }
719
720 return Py_BuildValue("i", crc);
721}
722
Guido van Rossum7d47c9e2000-02-16 21:11:52 +0000723static char doc_crc32[] =
724"(data, oldcrc = 0) -> newcrc. Compute CRC-32 incrementally";
725
726/* Crc - 32 BIT ANSI X3.66 CRC checksum files
727 Also known as: ISO 3307
728**********************************************************************|
729* *|
730* Demonstration program to compute the 32-bit CRC used as the frame *|
731* check sequence in ADCCP (ANSI X3.66, also known as FIPS PUB 71 *|
732* and FED-STD-1003, the U.S. versions of CCITT's X.25 link-level *|
733* protocol). The 32-bit FCS was added via the Federal Register, *|
734* 1 June 1982, p.23798. I presume but don't know for certain that *|
735* this polynomial is or will be included in CCITT V.41, which *|
736* defines the 16-bit CRC (often called CRC-CCITT) polynomial. FIPS *|
737* PUB 78 says that the 32-bit FCS reduces otherwise undetected *|
738* errors by a factor of 10^-5 over 16-bit FCS. *|
739* *|
740**********************************************************************|
741
742 Copyright (C) 1986 Gary S. Brown. You may use this program, or
743 code or tables extracted from it, as desired without restriction.
744
745 First, the polynomial itself and its table of feedback terms. The
746 polynomial is
747 X^32+X^26+X^23+X^22+X^16+X^12+X^11+X^10+X^8+X^7+X^5+X^4+X^2+X^1+X^0
748 Note that we take it "backwards" and put the highest-order term in
749 the lowest-order bit. The X^32 term is "implied"; the LSB is the
750 X^31 term, etc. The X^0 term (usually shown as "+1") results in
751 the MSB being 1.
752
753 Note that the usual hardware shift register implementation, which
754 is what we're using (we're merely optimizing it by doing eight-bit
755 chunks at a time) shifts bits into the lowest-order term. In our
756 implementation, that means shifting towards the right. Why do we
757 do it this way? Because the calculated CRC must be transmitted in
758 order from highest-order term to lowest-order term. UARTs transmit
759 characters in order from LSB to MSB. By storing the CRC this way,
760 we hand it to the UART in the order low-byte to high-byte; the UART
761 sends each low-bit to hight-bit; and the result is transmission bit
762 by bit from highest- to lowest-order term without requiring any bit
763 shuffling on our part. Reception works similarly.
764
765 The feedback terms table consists of 256, 32-bit entries. Notes:
766
767 1. The table can be generated at runtime if desired; code to do so
768 is shown later. It might not be obvious, but the feedback
769 terms simply represent the results of eight shift/xor opera-
770 tions for all combinations of data and CRC register values.
771
772 2. The CRC accumulation logic is the same for all CRC polynomials,
773 be they sixteen or thirty-two bits wide. You simply choose the
774 appropriate table. Alternatively, because the table can be
775 generated at runtime, you can start by generating the table for
776 the polynomial in question and use exactly the same "updcrc",
777 if your application needn't simultaneously handle two CRC
778 polynomials. (Note, however, that XMODEM is strange.)
779
780 3. For 16-bit CRCs, the table entries need be only 16 bits wide;
781 of course, 32-bit entries work OK if the high 16 bits are zero.
782
783 4. The values must be right-shifted by eight bits by the "updcrc"
784 logic; the shift must be unsigned (bring in zeroes). On some
785 hardware you could probably optimize the shift in assembler by
786 using byte-swap instructions.
787********************************************************************/
788
789static unsigned long crc_32_tab[256] = {
7900x00000000UL, 0x77073096UL, 0xee0e612cUL, 0x990951baUL, 0x076dc419UL,
7910x706af48fUL, 0xe963a535UL, 0x9e6495a3UL, 0x0edb8832UL, 0x79dcb8a4UL,
7920xe0d5e91eUL, 0x97d2d988UL, 0x09b64c2bUL, 0x7eb17cbdUL, 0xe7b82d07UL,
7930x90bf1d91UL, 0x1db71064UL, 0x6ab020f2UL, 0xf3b97148UL, 0x84be41deUL,
7940x1adad47dUL, 0x6ddde4ebUL, 0xf4d4b551UL, 0x83d385c7UL, 0x136c9856UL,
7950x646ba8c0UL, 0xfd62f97aUL, 0x8a65c9ecUL, 0x14015c4fUL, 0x63066cd9UL,
7960xfa0f3d63UL, 0x8d080df5UL, 0x3b6e20c8UL, 0x4c69105eUL, 0xd56041e4UL,
7970xa2677172UL, 0x3c03e4d1UL, 0x4b04d447UL, 0xd20d85fdUL, 0xa50ab56bUL,
7980x35b5a8faUL, 0x42b2986cUL, 0xdbbbc9d6UL, 0xacbcf940UL, 0x32d86ce3UL,
7990x45df5c75UL, 0xdcd60dcfUL, 0xabd13d59UL, 0x26d930acUL, 0x51de003aUL,
8000xc8d75180UL, 0xbfd06116UL, 0x21b4f4b5UL, 0x56b3c423UL, 0xcfba9599UL,
8010xb8bda50fUL, 0x2802b89eUL, 0x5f058808UL, 0xc60cd9b2UL, 0xb10be924UL,
8020x2f6f7c87UL, 0x58684c11UL, 0xc1611dabUL, 0xb6662d3dUL, 0x76dc4190UL,
8030x01db7106UL, 0x98d220bcUL, 0xefd5102aUL, 0x71b18589UL, 0x06b6b51fUL,
8040x9fbfe4a5UL, 0xe8b8d433UL, 0x7807c9a2UL, 0x0f00f934UL, 0x9609a88eUL,
8050xe10e9818UL, 0x7f6a0dbbUL, 0x086d3d2dUL, 0x91646c97UL, 0xe6635c01UL,
8060x6b6b51f4UL, 0x1c6c6162UL, 0x856530d8UL, 0xf262004eUL, 0x6c0695edUL,
8070x1b01a57bUL, 0x8208f4c1UL, 0xf50fc457UL, 0x65b0d9c6UL, 0x12b7e950UL,
8080x8bbeb8eaUL, 0xfcb9887cUL, 0x62dd1ddfUL, 0x15da2d49UL, 0x8cd37cf3UL,
8090xfbd44c65UL, 0x4db26158UL, 0x3ab551ceUL, 0xa3bc0074UL, 0xd4bb30e2UL,
8100x4adfa541UL, 0x3dd895d7UL, 0xa4d1c46dUL, 0xd3d6f4fbUL, 0x4369e96aUL,
8110x346ed9fcUL, 0xad678846UL, 0xda60b8d0UL, 0x44042d73UL, 0x33031de5UL,
8120xaa0a4c5fUL, 0xdd0d7cc9UL, 0x5005713cUL, 0x270241aaUL, 0xbe0b1010UL,
8130xc90c2086UL, 0x5768b525UL, 0x206f85b3UL, 0xb966d409UL, 0xce61e49fUL,
8140x5edef90eUL, 0x29d9c998UL, 0xb0d09822UL, 0xc7d7a8b4UL, 0x59b33d17UL,
8150x2eb40d81UL, 0xb7bd5c3bUL, 0xc0ba6cadUL, 0xedb88320UL, 0x9abfb3b6UL,
8160x03b6e20cUL, 0x74b1d29aUL, 0xead54739UL, 0x9dd277afUL, 0x04db2615UL,
8170x73dc1683UL, 0xe3630b12UL, 0x94643b84UL, 0x0d6d6a3eUL, 0x7a6a5aa8UL,
8180xe40ecf0bUL, 0x9309ff9dUL, 0x0a00ae27UL, 0x7d079eb1UL, 0xf00f9344UL,
8190x8708a3d2UL, 0x1e01f268UL, 0x6906c2feUL, 0xf762575dUL, 0x806567cbUL,
8200x196c3671UL, 0x6e6b06e7UL, 0xfed41b76UL, 0x89d32be0UL, 0x10da7a5aUL,
8210x67dd4accUL, 0xf9b9df6fUL, 0x8ebeeff9UL, 0x17b7be43UL, 0x60b08ed5UL,
8220xd6d6a3e8UL, 0xa1d1937eUL, 0x38d8c2c4UL, 0x4fdff252UL, 0xd1bb67f1UL,
8230xa6bc5767UL, 0x3fb506ddUL, 0x48b2364bUL, 0xd80d2bdaUL, 0xaf0a1b4cUL,
8240x36034af6UL, 0x41047a60UL, 0xdf60efc3UL, 0xa867df55UL, 0x316e8eefUL,
8250x4669be79UL, 0xcb61b38cUL, 0xbc66831aUL, 0x256fd2a0UL, 0x5268e236UL,
8260xcc0c7795UL, 0xbb0b4703UL, 0x220216b9UL, 0x5505262fUL, 0xc5ba3bbeUL,
8270xb2bd0b28UL, 0x2bb45a92UL, 0x5cb36a04UL, 0xc2d7ffa7UL, 0xb5d0cf31UL,
8280x2cd99e8bUL, 0x5bdeae1dUL, 0x9b64c2b0UL, 0xec63f226UL, 0x756aa39cUL,
8290x026d930aUL, 0x9c0906a9UL, 0xeb0e363fUL, 0x72076785UL, 0x05005713UL,
8300x95bf4a82UL, 0xe2b87a14UL, 0x7bb12baeUL, 0x0cb61b38UL, 0x92d28e9bUL,
8310xe5d5be0dUL, 0x7cdcefb7UL, 0x0bdbdf21UL, 0x86d3d2d4UL, 0xf1d4e242UL,
8320x68ddb3f8UL, 0x1fda836eUL, 0x81be16cdUL, 0xf6b9265bUL, 0x6fb077e1UL,
8330x18b74777UL, 0x88085ae6UL, 0xff0f6a70UL, 0x66063bcaUL, 0x11010b5cUL,
8340x8f659effUL, 0xf862ae69UL, 0x616bffd3UL, 0x166ccf45UL, 0xa00ae278UL,
8350xd70dd2eeUL, 0x4e048354UL, 0x3903b3c2UL, 0xa7672661UL, 0xd06016f7UL,
8360x4969474dUL, 0x3e6e77dbUL, 0xaed16a4aUL, 0xd9d65adcUL, 0x40df0b66UL,
8370x37d83bf0UL, 0xa9bcae53UL, 0xdebb9ec5UL, 0x47b2cf7fUL, 0x30b5ffe9UL,
8380xbdbdf21cUL, 0xcabac28aUL, 0x53b39330UL, 0x24b4a3a6UL, 0xbad03605UL,
8390xcdd70693UL, 0x54de5729UL, 0x23d967bfUL, 0xb3667a2eUL, 0xc4614ab8UL,
8400x5d681b02UL, 0x2a6f2b94UL, 0xb40bbe37UL, 0xc30c8ea1UL, 0x5a05df1bUL,
8410x2d02ef8dUL
842};
843
844static PyObject *
Peter Schneider-Kampa788a7f2000-07-10 09:57:19 +0000845binascii_crc32(PyObject *self, PyObject *args)
Guido van Rossum7d47c9e2000-02-16 21:11:52 +0000846{ /* By Jim Ahlstrom; All rights transferred to CNRI */
847 unsigned char *bin_data;
848 unsigned long crc = 0UL; /* initial value of CRC */
849 int len;
850
Guido van Rossum43713e52000-02-29 13:59:29 +0000851 if ( !PyArg_ParseTuple(args, "s#|l:crc32", &bin_data, &len, &crc) )
Guido van Rossum7d47c9e2000-02-16 21:11:52 +0000852 return NULL;
853
854 crc = crc ^ 0xFFFFFFFFUL;
855 while(len--)
856 crc = crc_32_tab[(crc ^ *bin_data++) & 0xffUL] ^ (crc >> 8);
857 /* Note: (crc >> 8) MUST zero fill on left */
858 return Py_BuildValue("l", crc ^ 0xFFFFFFFFUL);
859}
860
Barry Warsawe977c212000-08-15 06:07:13 +0000861
862static PyObject *
863binascii_hexlify(PyObject *self, PyObject *args)
864{
865 char* argbuf;
866 int arglen;
867 PyObject *retval;
868 char* retbuf;
869 int i, j;
870
871 if (!PyArg_ParseTuple(args, "t#:b2a_hex", &argbuf, &arglen))
872 return NULL;
873
874 retval = PyString_FromStringAndSize(NULL, arglen*2);
875 if (!retval)
876 return NULL;
877 retbuf = PyString_AsString(retval);
878 if (!retbuf)
879 goto finally;
880
881 /* make hex version of string, taken from shamodule.c */
882 for (i=j=0; i < arglen; i++) {
883 char c;
884 c = (argbuf[i] >> 4) & 0xf;
885 c = (c>9) ? c+'a'-10 : c + '0';
886 retbuf[j++] = c;
887 c = argbuf[i] & 0xf;
888 c = (c>9) ? c+'a'-10 : c + '0';
889 retbuf[j++] = c;
890 }
891 return retval;
892
893 finally:
894 Py_DECREF(retval);
895 return NULL;
896}
897
898static char doc_hexlify[] =
899"b2a_hex(data) -> s; Hexadecimal representation of binary data.\n\
900\n\
901This function is also available as \"hexlify()\".";
902
903
904static int
Tim Petersb59ab422000-08-15 16:41:26 +0000905to_int(int c)
Barry Warsawe977c212000-08-15 06:07:13 +0000906{
907 if (isdigit(c))
908 return c - '0';
909 else {
910 if (isupper(c))
911 c = tolower(c);
912 if (c >= 'a' && c <= 'f')
913 return c - 'a' + 10;
914 }
915 return -1;
916}
917
918
919static PyObject *
920binascii_unhexlify(PyObject *self, PyObject *args)
921{
922 char* argbuf;
923 int arglen;
924 PyObject *retval;
925 char* retbuf;
926 int i, j;
927
928 if (!PyArg_ParseTuple(args, "s#:a2b_hex", &argbuf, &arglen))
929 return NULL;
930
Barry Warsaw16168472000-08-15 06:59:58 +0000931 /* XXX What should we do about strings with an odd length? Should
932 * we add an implicit leading zero, or a trailing zero? For now,
933 * raise an exception.
Barry Warsawe977c212000-08-15 06:07:13 +0000934 */
935 if (arglen % 2) {
Barry Warsaw16168472000-08-15 06:59:58 +0000936 PyErr_SetString(PyExc_TypeError, "Odd-length string");
Barry Warsawe977c212000-08-15 06:07:13 +0000937 return NULL;
938 }
939
940 retval = PyString_FromStringAndSize(NULL, (arglen/2));
941 if (!retval)
942 return NULL;
943 retbuf = PyString_AsString(retval);
944 if (!retbuf)
945 goto finally;
946
947 for (i=j=0; i < arglen; i += 2) {
948 int top = to_int(Py_CHARMASK(argbuf[i]));
949 int bot = to_int(Py_CHARMASK(argbuf[i+1]));
950 if (top == -1 || bot == -1) {
951 PyErr_SetString(PyExc_TypeError,
Barry Warsaw16168472000-08-15 06:59:58 +0000952 "Non-hexadecimal digit found");
Barry Warsawe977c212000-08-15 06:07:13 +0000953 goto finally;
954 }
955 retbuf[j++] = (top << 4) + bot;
956 }
957 return retval;
958
959 finally:
960 Py_DECREF(retval);
961 return NULL;
962}
963
964static char doc_unhexlify[] =
965"a2b_hex(hexstr) -> s; Binary data of hexadecimal representation.\n\
966\n\
967hexstr must contain an even number of hex digits (upper or lower case).\n\
968This function is also available as \"unhexlify()\"";
969
970
Jack Jansen72781191995-08-07 14:34:15 +0000971/* List of functions defined in the module */
972
973static struct PyMethodDef binascii_module_methods[] = {
Barry Warsawe977c212000-08-15 06:07:13 +0000974 {"a2b_uu", binascii_a2b_uu, METH_VARARGS, doc_a2b_uu},
975 {"b2a_uu", binascii_b2a_uu, METH_VARARGS, doc_b2a_uu},
976 {"a2b_base64", binascii_a2b_base64, METH_VARARGS, doc_a2b_base64},
977 {"b2a_base64", binascii_b2a_base64, METH_VARARGS, doc_b2a_base64},
978 {"a2b_hqx", binascii_a2b_hqx, METH_VARARGS, doc_a2b_hqx},
979 {"b2a_hqx", binascii_b2a_hqx, METH_VARARGS, doc_b2a_hqx},
980 {"b2a_hex", binascii_hexlify, METH_VARARGS, doc_hexlify},
981 {"a2b_hex", binascii_unhexlify, METH_VARARGS, doc_unhexlify},
982 {"hexlify", binascii_hexlify, METH_VARARGS, doc_hexlify},
983 {"unhexlify", binascii_unhexlify, METH_VARARGS, doc_unhexlify},
984 {"rlecode_hqx", binascii_rlecode_hqx, METH_VARARGS, doc_rlecode_hqx},
985 {"rledecode_hqx", binascii_rledecode_hqx, METH_VARARGS,
986 doc_rledecode_hqx},
987 {"crc_hqx", binascii_crc_hqx, METH_VARARGS, doc_crc_hqx},
988 {"crc32", binascii_crc32, METH_VARARGS, doc_crc32},
989 {NULL, NULL} /* sentinel */
Jack Jansen72781191995-08-07 14:34:15 +0000990};
991
992
993/* Initialization function for the module (*must* be called initbinascii) */
994static char doc_binascii[] = "Conversion between binary data and ASCII";
995
Guido van Rossum3886bb61998-12-04 18:50:17 +0000996DL_EXPORT(void)
Thomas Woutersf3f33dc2000-07-21 06:00:07 +0000997initbinascii(void)
Jack Jansen72781191995-08-07 14:34:15 +0000998{
999 PyObject *m, *d, *x;
1000
1001 /* Create the module and add the functions */
1002 m = Py_InitModule("binascii", binascii_module_methods);
1003
1004 d = PyModule_GetDict(m);
1005 x = PyString_FromString(doc_binascii);
1006 PyDict_SetItemString(d, "__doc__", x);
Guido van Rossum5c159bd1997-08-04 23:55:25 +00001007 Py_XDECREF(x);
Jack Jansen72781191995-08-07 14:34:15 +00001008
Guido van Rossum7dbb48a1997-10-08 15:26:07 +00001009 Error = PyErr_NewException("binascii.Error", NULL, NULL);
Jack Jansen72781191995-08-07 14:34:15 +00001010 PyDict_SetItemString(d, "Error", Error);
Guido van Rossum7dbb48a1997-10-08 15:26:07 +00001011 Incomplete = PyErr_NewException("binascii.Incomplete", NULL, NULL);
Jack Jansen72781191995-08-07 14:34:15 +00001012 PyDict_SetItemString(d, "Incomplete", Incomplete);
Jack Jansen72781191995-08-07 14:34:15 +00001013}