blob: fca4ca09d804bf52f8709d8e015cffc55ded8fc9 [file] [log] [blame]
Jack Jansen72781191995-08-07 14:34:15 +00001/***********************************************************
2Copyright 1991, 1992, 1993, 1994 by Stichting Mathematisch Centrum,
3Amsterdam, The Netherlands.
4
5 All Rights Reserved
6
Guido van Rossumfd71b9e2000-06-30 23:50:40 +00007Copyright (c) 2000, BeOpen.com.
8Copyright (c) 1995-2000, Corporation for National Research Initiatives.
9Copyright (c) 1990-1995, Stichting Mathematisch Centrum.
10All rights reserved.
Jack Jansen72781191995-08-07 14:34:15 +000011
Guido van Rossumfd71b9e2000-06-30 23:50:40 +000012See the file "Misc/COPYRIGHT" for information on usage and
13redistribution of this file, and for a DISCLAIMER OF ALL WARRANTIES.
Jack Jansen72781191995-08-07 14:34:15 +000014
15******************************************************************/
16
17/*
18** Routines to represent binary data in ASCII and vice-versa
19**
20** This module currently supports the following encodings:
21** uuencode:
22** each line encodes 45 bytes (except possibly the last)
23** First char encodes (binary) length, rest data
24** each char encodes 6 bits, as follows:
25** binary: 01234567 abcdefgh ijklmnop
26** ascii: 012345 67abcd efghij klmnop
27** ASCII encoding method is "excess-space": 000000 is encoded as ' ', etc.
28** short binary data is zero-extended (so the bits are always in the
29** right place), this does *not* reflect in the length.
Jack Jansen84bbc2e1995-10-04 16:38:44 +000030** base64:
31** Line breaks are insignificant, but lines are at most 76 chars
32** each char encodes 6 bits, in similar order as uucode/hqx. Encoding
33** is done via a table.
34** Short binary data is filled (in ASCII) with '='.
Jack Jansen72781191995-08-07 14:34:15 +000035** hqx:
36** File starts with introductory text, real data starts and ends
37** with colons.
38** Data consists of three similar parts: info, datafork, resourcefork.
39** Each part is protected (at the end) with a 16-bit crc
40** The binary data is run-length encoded, and then ascii-fied:
41** binary: 01234567 abcdefgh ijklmnop
42** ascii: 012345 67abcd efghij klmnop
43** ASCII encoding is table-driven, see the code.
44** Short binary data results in the runt ascii-byte being output with
45** the bits in the right place.
46**
47** While I was reading dozens of programs that encode or decode the formats
48** here (documentation? hihi:-) I have formulated Jansen's Observation:
49**
50** Programs that encode binary data in ASCII are written in
51** such a style that they are as unreadable as possible. Devices used
52** include unnecessary global variables, burying important tables
53** in unrelated sourcefiles, putting functions in include files,
54** using seemingly-descriptive variable names for different purposes,
55** calls to empty subroutines and a host of others.
56**
57** I have attempted to break with this tradition, but I guess that that
58** does make the performance sub-optimal. Oh well, too bad...
59**
60** Jack Jansen, CWI, July 1995.
61*/
62
63
64#include "Python.h"
65
66static PyObject *Error;
67static PyObject *Incomplete;
68
69/*
70** hqx lookup table, ascii->binary.
71*/
72
73#define RUNCHAR 0x90
74
75#define DONE 0x7F
76#define SKIP 0x7E
77#define FAIL 0x7D
78
79static unsigned char table_a2b_hqx[256] = {
80/* ^@ ^A ^B ^C ^D ^E ^F ^G */
81/* 0*/ FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
82/* \b \t \n ^K ^L \r ^N ^O */
83/* 1*/ FAIL, FAIL, SKIP, FAIL, FAIL, SKIP, FAIL, FAIL,
84/* ^P ^Q ^R ^S ^T ^U ^V ^W */
85/* 2*/ FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
86/* ^X ^Y ^Z ^[ ^\ ^] ^^ ^_ */
87/* 3*/ FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
88/* ! " # $ % & ' */
89/* 4*/ FAIL, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06,
90/* ( ) * + , - . / */
91/* 5*/ 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, FAIL, FAIL,
92/* 0 1 2 3 4 5 6 7 */
93/* 6*/ 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12, 0x13, FAIL,
94/* 8 9 : ; < = > ? */
95/* 7*/ 0x14, 0x15, DONE, FAIL, FAIL, FAIL, FAIL, FAIL,
96/* @ A B C D E F G */
97/* 8*/ 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D,
98/* H I J K L M N O */
99/* 9*/ 0x1E, 0x1F, 0x20, 0x21, 0x22, 0x23, 0x24, FAIL,
100/* P Q R S T U V W */
101/*10*/ 0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, FAIL,
102/* X Y Z [ \ ] ^ _ */
103/*11*/ 0x2C, 0x2D, 0x2E, 0x2F, FAIL, FAIL, FAIL, FAIL,
104/* ` a b c d e f g */
105/*12*/ 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, FAIL,
106/* h i j k l m n o */
107/*13*/ 0x37, 0x38, 0x39, 0x3A, 0x3B, 0x3C, FAIL, FAIL,
108/* p q r s t u v w */
109/*14*/ 0x3D, 0x3E, 0x3F, FAIL, FAIL, FAIL, FAIL, FAIL,
110/* x y z { | } ~ ^? */
111/*15*/ FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
112/*16*/ FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
113 FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
114 FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
115 FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
116 FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
117 FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
118 FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
119 FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
120 FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
121 FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
122 FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
123 FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
124 FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
125 FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
126 FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
127 FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
128};
129
130static unsigned char table_b2a_hqx[] =
Roger E. Masse5f4ce181997-01-16 17:10:22 +0000131"!\"#$%&'()*+,-012345689@ABCDEFGHIJKLMNPQRSTUVXYZ[`abcdefhijklmpqr";
Jack Jansen72781191995-08-07 14:34:15 +0000132
Jack Jansen84bbc2e1995-10-04 16:38:44 +0000133static char table_a2b_base64[] = {
134 -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,
135 -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,
136 -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,62, -1,-1,-1,63,
137 52,53,54,55, 56,57,58,59, 60,61,-1,-1, -1, 0,-1,-1, /* Note PAD->0 */
138 -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10, 11,12,13,14,
139 15,16,17,18, 19,20,21,22, 23,24,25,-1, -1,-1,-1,-1,
140 -1,26,27,28, 29,30,31,32, 33,34,35,36, 37,38,39,40,
141 41,42,43,44, 45,46,47,48, 49,50,51,-1, -1,-1,-1,-1
142};
143
144#define BASE64_PAD '='
145#define BASE64_MAXBIN 57 /* Max binary chunk size (76 char line) */
146
147static unsigned char table_b2a_base64[] =
Roger E. Masse5f4ce181997-01-16 17:10:22 +0000148"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
Jack Jansen84bbc2e1995-10-04 16:38:44 +0000149
150
151
Jack Jansen72781191995-08-07 14:34:15 +0000152static unsigned short crctab_hqx[256] = {
Roger E. Masse5f4ce181997-01-16 17:10:22 +0000153 0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50a5, 0x60c6, 0x70e7,
154 0x8108, 0x9129, 0xa14a, 0xb16b, 0xc18c, 0xd1ad, 0xe1ce, 0xf1ef,
155 0x1231, 0x0210, 0x3273, 0x2252, 0x52b5, 0x4294, 0x72f7, 0x62d6,
156 0x9339, 0x8318, 0xb37b, 0xa35a, 0xd3bd, 0xc39c, 0xf3ff, 0xe3de,
157 0x2462, 0x3443, 0x0420, 0x1401, 0x64e6, 0x74c7, 0x44a4, 0x5485,
158 0xa56a, 0xb54b, 0x8528, 0x9509, 0xe5ee, 0xf5cf, 0xc5ac, 0xd58d,
159 0x3653, 0x2672, 0x1611, 0x0630, 0x76d7, 0x66f6, 0x5695, 0x46b4,
160 0xb75b, 0xa77a, 0x9719, 0x8738, 0xf7df, 0xe7fe, 0xd79d, 0xc7bc,
161 0x48c4, 0x58e5, 0x6886, 0x78a7, 0x0840, 0x1861, 0x2802, 0x3823,
162 0xc9cc, 0xd9ed, 0xe98e, 0xf9af, 0x8948, 0x9969, 0xa90a, 0xb92b,
163 0x5af5, 0x4ad4, 0x7ab7, 0x6a96, 0x1a71, 0x0a50, 0x3a33, 0x2a12,
164 0xdbfd, 0xcbdc, 0xfbbf, 0xeb9e, 0x9b79, 0x8b58, 0xbb3b, 0xab1a,
165 0x6ca6, 0x7c87, 0x4ce4, 0x5cc5, 0x2c22, 0x3c03, 0x0c60, 0x1c41,
166 0xedae, 0xfd8f, 0xcdec, 0xddcd, 0xad2a, 0xbd0b, 0x8d68, 0x9d49,
167 0x7e97, 0x6eb6, 0x5ed5, 0x4ef4, 0x3e13, 0x2e32, 0x1e51, 0x0e70,
168 0xff9f, 0xefbe, 0xdfdd, 0xcffc, 0xbf1b, 0xaf3a, 0x9f59, 0x8f78,
169 0x9188, 0x81a9, 0xb1ca, 0xa1eb, 0xd10c, 0xc12d, 0xf14e, 0xe16f,
170 0x1080, 0x00a1, 0x30c2, 0x20e3, 0x5004, 0x4025, 0x7046, 0x6067,
171 0x83b9, 0x9398, 0xa3fb, 0xb3da, 0xc33d, 0xd31c, 0xe37f, 0xf35e,
172 0x02b1, 0x1290, 0x22f3, 0x32d2, 0x4235, 0x5214, 0x6277, 0x7256,
173 0xb5ea, 0xa5cb, 0x95a8, 0x8589, 0xf56e, 0xe54f, 0xd52c, 0xc50d,
174 0x34e2, 0x24c3, 0x14a0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405,
175 0xa7db, 0xb7fa, 0x8799, 0x97b8, 0xe75f, 0xf77e, 0xc71d, 0xd73c,
176 0x26d3, 0x36f2, 0x0691, 0x16b0, 0x6657, 0x7676, 0x4615, 0x5634,
177 0xd94c, 0xc96d, 0xf90e, 0xe92f, 0x99c8, 0x89e9, 0xb98a, 0xa9ab,
178 0x5844, 0x4865, 0x7806, 0x6827, 0x18c0, 0x08e1, 0x3882, 0x28a3,
179 0xcb7d, 0xdb5c, 0xeb3f, 0xfb1e, 0x8bf9, 0x9bd8, 0xabbb, 0xbb9a,
180 0x4a75, 0x5a54, 0x6a37, 0x7a16, 0x0af1, 0x1ad0, 0x2ab3, 0x3a92,
181 0xfd2e, 0xed0f, 0xdd6c, 0xcd4d, 0xbdaa, 0xad8b, 0x9de8, 0x8dc9,
182 0x7c26, 0x6c07, 0x5c64, 0x4c45, 0x3ca2, 0x2c83, 0x1ce0, 0x0cc1,
183 0xef1f, 0xff3e, 0xcf5d, 0xdf7c, 0xaf9b, 0xbfba, 0x8fd9, 0x9ff8,
184 0x6e17, 0x7e36, 0x4e55, 0x5e74, 0x2e93, 0x3eb2, 0x0ed1, 0x1ef0,
Jack Jansen72781191995-08-07 14:34:15 +0000185};
186
187static char doc_a2b_uu[] = "(ascii) -> bin. Decode a line of uuencoded data";
188
189static PyObject *
Peter Schneider-Kampa788a7f2000-07-10 09:57:19 +0000190binascii_a2b_uu(PyObject *self, PyObject *args)
Jack Jansen72781191995-08-07 14:34:15 +0000191{
192 unsigned char *ascii_data, *bin_data;
193 int leftbits = 0;
194 unsigned char this_ch;
195 unsigned int leftchar = 0;
196 PyObject *rv;
197 int ascii_len, bin_len;
198
Guido van Rossum43713e52000-02-29 13:59:29 +0000199 if ( !PyArg_ParseTuple(args, "t#:a2b_uu", &ascii_data, &ascii_len) )
Jack Jansen72781191995-08-07 14:34:15 +0000200 return NULL;
201
202 /* First byte: binary data length (in bytes) */
203 bin_len = (*ascii_data++ - ' ') & 077;
204 ascii_len--;
205
206 /* Allocate the buffer */
207 if ( (rv=PyString_FromStringAndSize(NULL, bin_len)) == NULL )
208 return NULL;
209 bin_data = (unsigned char *)PyString_AsString(rv);
210
211 for( ; bin_len > 0 ; ascii_len--, ascii_data++ ) {
212 this_ch = *ascii_data;
213 if ( this_ch == '\n' || this_ch == '\r' || ascii_len <= 0) {
214 /*
215 ** Whitespace. Assume some spaces got eaten at
216 ** end-of-line. (We check this later)
217 */
218 this_ch = 0;
219 } else {
Jack Jansen5d957971995-11-14 10:35:19 +0000220 /* Check the character for legality
Roger E. Masse5f4ce181997-01-16 17:10:22 +0000221 ** The 64 in stead of the expected 63 is because
222 ** there are a few uuencodes out there that use
223 ** '@' as zero instead of space.
Jack Jansen5d957971995-11-14 10:35:19 +0000224 */
225 if ( this_ch < ' ' || this_ch > (' ' + 64)) {
Jack Jansen72781191995-08-07 14:34:15 +0000226 PyErr_SetString(Error, "Illegal char");
227 Py_DECREF(rv);
228 return NULL;
229 }
230 this_ch = (this_ch - ' ') & 077;
231 }
232 /*
233 ** Shift it in on the low end, and see if there's
234 ** a byte ready for output.
235 */
236 leftchar = (leftchar << 6) | (this_ch);
237 leftbits += 6;
238 if ( leftbits >= 8 ) {
239 leftbits -= 8;
240 *bin_data++ = (leftchar >> leftbits) & 0xff;
241 leftchar &= ((1 << leftbits) - 1);
242 bin_len--;
243 }
244 }
245 /*
246 ** Finally, check that if there's anything left on the line
247 ** that it's whitespace only.
248 */
249 while( ascii_len-- > 0 ) {
250 this_ch = *ascii_data++;
Guido van Rossum1243ae71997-07-11 18:36:28 +0000251 /* Extra '@' may be written as padding in some cases */
252 if ( this_ch != ' ' && this_ch != '@' &&
253 this_ch != '\n' && this_ch != '\r' ) {
Jack Jansen72781191995-08-07 14:34:15 +0000254 PyErr_SetString(Error, "Trailing garbage");
255 Py_DECREF(rv);
256 return NULL;
257 }
258 }
259 return rv;
260}
261
262static char doc_b2a_uu[] = "(bin) -> ascii. Uuencode line of data";
263
264static PyObject *
Peter Schneider-Kampa788a7f2000-07-10 09:57:19 +0000265binascii_b2a_uu(PyObject *self, PyObject *args)
Jack Jansen72781191995-08-07 14:34:15 +0000266{
267 unsigned char *ascii_data, *bin_data;
268 int leftbits = 0;
269 unsigned char this_ch;
270 unsigned int leftchar = 0;
271 PyObject *rv;
272 int bin_len;
273
Guido van Rossum43713e52000-02-29 13:59:29 +0000274 if ( !PyArg_ParseTuple(args, "s#:b2a_uu", &bin_data, &bin_len) )
Jack Jansen72781191995-08-07 14:34:15 +0000275 return NULL;
276 if ( bin_len > 45 ) {
277 /* The 45 is a limit that appears in all uuencode's */
278 PyErr_SetString(Error, "At most 45 bytes at once");
279 return NULL;
280 }
281
282 /* We're lazy and allocate to much (fixed up later) */
283 if ( (rv=PyString_FromStringAndSize(NULL, bin_len*2)) == NULL )
284 return NULL;
285 ascii_data = (unsigned char *)PyString_AsString(rv);
286
287 /* Store the length */
288 *ascii_data++ = ' ' + (bin_len & 077);
289
290 for( ; bin_len > 0 || leftbits != 0 ; bin_len--, bin_data++ ) {
291 /* Shift the data (or padding) into our buffer */
292 if ( bin_len > 0 ) /* Data */
293 leftchar = (leftchar << 8) | *bin_data;
294 else /* Padding */
295 leftchar <<= 8;
296 leftbits += 8;
297
298 /* See if there are 6-bit groups ready */
299 while ( leftbits >= 6 ) {
300 this_ch = (leftchar >> (leftbits-6)) & 0x3f;
301 leftbits -= 6;
302 *ascii_data++ = this_ch + ' ';
303 }
304 }
305 *ascii_data++ = '\n'; /* Append a courtesy newline */
306
Roger E. Masse5f4ce181997-01-16 17:10:22 +0000307 _PyString_Resize(&rv, (ascii_data -
308 (unsigned char *)PyString_AsString(rv)));
Jack Jansen72781191995-08-07 14:34:15 +0000309 return rv;
310}
311
Guido van Rossum2db4f471999-10-19 19:05:14 +0000312
313static int
Peter Schneider-Kampa788a7f2000-07-10 09:57:19 +0000314binascii_find_valid(unsigned char *s, int slen, int num)
Guido van Rossum2db4f471999-10-19 19:05:14 +0000315{
316 /* Finds & returns the (num+1)th
317 ** valid character for base64, or -1 if none.
318 */
319
320 int ret = -1;
321 unsigned char c, b64val;
322
323 while ((slen > 0) && (ret == -1)) {
324 c = *s;
325 b64val = table_a2b_base64[c & 0x7f];
326 if ( ((c <= 0x7f) && (b64val != (unsigned char)-1)) ) {
327 if (num == 0)
328 ret = *s;
329 num--;
330 }
331
332 s++;
333 slen--;
334 }
335 return ret;
336}
337
Jack Jansen84bbc2e1995-10-04 16:38:44 +0000338static char doc_a2b_base64[] = "(ascii) -> bin. Decode a line of base64 data";
339
340static PyObject *
Peter Schneider-Kampa788a7f2000-07-10 09:57:19 +0000341binascii_a2b_base64(PyObject *self, PyObject *args)
Jack Jansen84bbc2e1995-10-04 16:38:44 +0000342{
343 unsigned char *ascii_data, *bin_data;
344 int leftbits = 0;
345 unsigned char this_ch;
346 unsigned int leftchar = 0;
Jack Jansen84bbc2e1995-10-04 16:38:44 +0000347 PyObject *rv;
348 int ascii_len, bin_len;
Guido van Rossum2db4f471999-10-19 19:05:14 +0000349 int quad_pos = 0;
Jack Jansen84bbc2e1995-10-04 16:38:44 +0000350
Guido van Rossum43713e52000-02-29 13:59:29 +0000351 if ( !PyArg_ParseTuple(args, "t#:a2b_base64", &ascii_data, &ascii_len) )
Jack Jansen84bbc2e1995-10-04 16:38:44 +0000352 return NULL;
353
354 bin_len = ((ascii_len+3)/4)*3; /* Upper bound, corrected later */
355
356 /* Allocate the buffer */
357 if ( (rv=PyString_FromStringAndSize(NULL, bin_len)) == NULL )
358 return NULL;
359 bin_data = (unsigned char *)PyString_AsString(rv);
360 bin_len = 0;
Guido van Rossum2db4f471999-10-19 19:05:14 +0000361
362 for( ; ascii_len > 0; ascii_len--, ascii_data++) {
363 this_ch = *ascii_data;
364
365 if (this_ch > 0x7f ||
366 this_ch == '\r' || this_ch == '\n' || this_ch == ' ')
Jack Jansenba1de3b1996-01-22 10:47:15 +0000367 continue;
Guido van Rossum2db4f471999-10-19 19:05:14 +0000368
369 /* Check for pad sequences and ignore
370 ** the invalid ones.
371 */
372 if (this_ch == BASE64_PAD) {
373 if ( (quad_pos < 2) ||
374 ((quad_pos == 2) &&
375 (binascii_find_valid(ascii_data, ascii_len, 1)
376 != BASE64_PAD)) )
377 {
378 continue;
379 }
380 else {
381 /* A pad sequence means no more input.
382 ** We've already interpreted the data
383 ** from the quad at this point.
384 */
385 leftbits = 0;
386 break;
387 }
388 }
389
390 this_ch = table_a2b_base64[*ascii_data];
391 if ( this_ch == (unsigned char) -1 )
392 continue;
393
Jack Jansen84bbc2e1995-10-04 16:38:44 +0000394 /*
395 ** Shift it in on the low end, and see if there's
396 ** a byte ready for output.
397 */
Guido van Rossum2db4f471999-10-19 19:05:14 +0000398 quad_pos = (quad_pos + 1) & 0x03;
Jack Jansen84bbc2e1995-10-04 16:38:44 +0000399 leftchar = (leftchar << 6) | (this_ch);
400 leftbits += 6;
Guido van Rossum2db4f471999-10-19 19:05:14 +0000401
Jack Jansen84bbc2e1995-10-04 16:38:44 +0000402 if ( leftbits >= 8 ) {
403 leftbits -= 8;
404 *bin_data++ = (leftchar >> leftbits) & 0xff;
Jack Jansen84bbc2e1995-10-04 16:38:44 +0000405 bin_len++;
Guido van Rossum2db4f471999-10-19 19:05:14 +0000406 leftchar &= ((1 << leftbits) - 1);
Jack Jansen84bbc2e1995-10-04 16:38:44 +0000407 }
Guido van Rossum2db4f471999-10-19 19:05:14 +0000408 }
409
410 if (leftbits != 0) {
Jack Jansen84bbc2e1995-10-04 16:38:44 +0000411 PyErr_SetString(Error, "Incorrect padding");
412 Py_DECREF(rv);
413 return NULL;
414 }
Guido van Rossum2db4f471999-10-19 19:05:14 +0000415
Jack Jansen84bbc2e1995-10-04 16:38:44 +0000416 /* and set string size correctly */
417 _PyString_Resize(&rv, bin_len);
418 return rv;
419}
420
421static char doc_b2a_base64[] = "(bin) -> ascii. Base64-code line of data";
422
423static PyObject *
Peter Schneider-Kampa788a7f2000-07-10 09:57:19 +0000424binascii_b2a_base64(PyObject *self, PyObject *args)
Jack Jansen84bbc2e1995-10-04 16:38:44 +0000425{
426 unsigned char *ascii_data, *bin_data;
427 int leftbits = 0;
428 unsigned char this_ch;
429 unsigned int leftchar = 0;
430 PyObject *rv;
431 int bin_len;
432
Guido van Rossum43713e52000-02-29 13:59:29 +0000433 if ( !PyArg_ParseTuple(args, "s#:b2a_base64", &bin_data, &bin_len) )
Jack Jansen84bbc2e1995-10-04 16:38:44 +0000434 return NULL;
435 if ( bin_len > BASE64_MAXBIN ) {
436 PyErr_SetString(Error, "Too much data for base64 line");
437 return NULL;
438 }
439
440 /* We're lazy and allocate to much (fixed up later) */
441 if ( (rv=PyString_FromStringAndSize(NULL, bin_len*2)) == NULL )
442 return NULL;
443 ascii_data = (unsigned char *)PyString_AsString(rv);
444
445 for( ; bin_len > 0 ; bin_len--, bin_data++ ) {
446 /* Shift the data into our buffer */
447 leftchar = (leftchar << 8) | *bin_data;
448 leftbits += 8;
449
450 /* See if there are 6-bit groups ready */
451 while ( leftbits >= 6 ) {
452 this_ch = (leftchar >> (leftbits-6)) & 0x3f;
453 leftbits -= 6;
454 *ascii_data++ = table_b2a_base64[this_ch];
455 }
456 }
457 if ( leftbits == 2 ) {
458 *ascii_data++ = table_b2a_base64[(leftchar&3) << 4];
459 *ascii_data++ = BASE64_PAD;
460 *ascii_data++ = BASE64_PAD;
461 } else if ( leftbits == 4 ) {
462 *ascii_data++ = table_b2a_base64[(leftchar&0xf) << 2];
463 *ascii_data++ = BASE64_PAD;
464 }
465 *ascii_data++ = '\n'; /* Append a courtesy newline */
466
Roger E. Masse5f4ce181997-01-16 17:10:22 +0000467 _PyString_Resize(&rv, (ascii_data -
468 (unsigned char *)PyString_AsString(rv)));
Jack Jansen84bbc2e1995-10-04 16:38:44 +0000469 return rv;
470}
471
Jack Jansen72781191995-08-07 14:34:15 +0000472static char doc_a2b_hqx[] = "ascii -> bin, done. Decode .hqx coding";
473
474static PyObject *
Peter Schneider-Kampa788a7f2000-07-10 09:57:19 +0000475binascii_a2b_hqx(PyObject *self, PyObject *args)
Jack Jansen72781191995-08-07 14:34:15 +0000476{
477 unsigned char *ascii_data, *bin_data;
478 int leftbits = 0;
479 unsigned char this_ch;
Jack Janseneaeb1c81995-08-14 12:17:57 +0000480 unsigned int leftchar = 0;
Jack Jansen72781191995-08-07 14:34:15 +0000481 PyObject *rv;
482 int len;
483 int done = 0;
484
Guido van Rossum43713e52000-02-29 13:59:29 +0000485 if ( !PyArg_ParseTuple(args, "t#:a2b_hqx", &ascii_data, &len) )
Jack Jansen72781191995-08-07 14:34:15 +0000486 return NULL;
487
488 /* Allocate a string that is too big (fixed later) */
489 if ( (rv=PyString_FromStringAndSize(NULL, len)) == NULL )
490 return NULL;
491 bin_data = (unsigned char *)PyString_AsString(rv);
492
493 for( ; len > 0 ; len--, ascii_data++ ) {
494 /* Get the byte and look it up */
495 this_ch = table_a2b_hqx[*ascii_data];
496 if ( this_ch == SKIP )
497 continue;
498 if ( this_ch == FAIL ) {
499 PyErr_SetString(Error, "Illegal char");
500 Py_DECREF(rv);
501 return NULL;
502 }
503 if ( this_ch == DONE ) {
504 /* The terminating colon */
505 done = 1;
506 break;
507 }
508
509 /* Shift it into the buffer and see if any bytes are ready */
510 leftchar = (leftchar << 6) | (this_ch);
511 leftbits += 6;
512 if ( leftbits >= 8 ) {
513 leftbits -= 8;
514 *bin_data++ = (leftchar >> leftbits) & 0xff;
515 leftchar &= ((1 << leftbits) - 1);
516 }
517 }
518
519 if ( leftbits && !done ) {
520 PyErr_SetString(Incomplete,
521 "String has incomplete number of bytes");
522 Py_DECREF(rv);
523 return NULL;
524 }
Guido van Rossum9c6ba5e1997-01-12 20:02:04 +0000525 _PyString_Resize(
526 &rv, (bin_data - (unsigned char *)PyString_AsString(rv)));
527 if (rv) {
528 PyObject *rrv = Py_BuildValue("Oi", rv, done);
529 Py_DECREF(rv);
530 return rrv;
531 }
Roger E. Masse5f4ce181997-01-16 17:10:22 +0000532
Jack Jansen72781191995-08-07 14:34:15 +0000533 return NULL;
534}
535
536static char doc_rlecode_hqx[] = "Binhex RLE-code binary data";
537
538static PyObject *
Peter Schneider-Kampa788a7f2000-07-10 09:57:19 +0000539binascii_rlecode_hqx(PyObject *self, PyObject *args)
Jack Jansen72781191995-08-07 14:34:15 +0000540{
541 unsigned char *in_data, *out_data;
542 PyObject *rv;
543 unsigned char ch;
544 int in, inend, len;
545
Guido van Rossum43713e52000-02-29 13:59:29 +0000546 if ( !PyArg_ParseTuple(args, "s#:rlecode_hqx", &in_data, &len) )
Jack Jansen72781191995-08-07 14:34:15 +0000547 return NULL;
548
549 /* Worst case: output is twice as big as input (fixed later) */
550 if ( (rv=PyString_FromStringAndSize(NULL, len*2)) == NULL )
551 return NULL;
552 out_data = (unsigned char *)PyString_AsString(rv);
553
554 for( in=0; in<len; in++) {
555 ch = in_data[in];
556 if ( ch == RUNCHAR ) {
557 /* RUNCHAR. Escape it. */
558 *out_data++ = RUNCHAR;
559 *out_data++ = 0;
560 } else {
561 /* Check how many following are the same */
562 for(inend=in+1;
563 inend<len && in_data[inend] == ch &&
Roger E. Masse5f4ce181997-01-16 17:10:22 +0000564 inend < in+255;
Jack Jansen72781191995-08-07 14:34:15 +0000565 inend++) ;
Jack Jansen0223aa11995-08-31 13:44:23 +0000566 if ( inend - in > 3 ) {
567 /* More than 3 in a row. Output RLE. */
Jack Jansen72781191995-08-07 14:34:15 +0000568 *out_data++ = ch;
569 *out_data++ = RUNCHAR;
570 *out_data++ = inend-in;
571 in = inend-1;
572 } else {
573 /* Less than 3. Output the byte itself */
574 *out_data++ = ch;
575 }
576 }
577 }
Roger E. Masse5f4ce181997-01-16 17:10:22 +0000578 _PyString_Resize(&rv, (out_data -
579 (unsigned char *)PyString_AsString(rv)));
Jack Jansen72781191995-08-07 14:34:15 +0000580 return rv;
581}
582
583static char doc_b2a_hqx[] = "Encode .hqx data";
584
585static PyObject *
Peter Schneider-Kampa788a7f2000-07-10 09:57:19 +0000586binascii_b2a_hqx(PyObject *self, PyObject *args)
Jack Jansen72781191995-08-07 14:34:15 +0000587{
588 unsigned char *ascii_data, *bin_data;
589 int leftbits = 0;
590 unsigned char this_ch;
Jack Janseneaeb1c81995-08-14 12:17:57 +0000591 unsigned int leftchar = 0;
Jack Jansen72781191995-08-07 14:34:15 +0000592 PyObject *rv;
593 int len;
594
Guido van Rossum43713e52000-02-29 13:59:29 +0000595 if ( !PyArg_ParseTuple(args, "s#:b2a_hqx", &bin_data, &len) )
Jack Jansen72781191995-08-07 14:34:15 +0000596 return NULL;
597
598 /* Allocate a buffer that is at least large enough */
599 if ( (rv=PyString_FromStringAndSize(NULL, len*2)) == NULL )
600 return NULL;
601 ascii_data = (unsigned char *)PyString_AsString(rv);
602
603 for( ; len > 0 ; len--, bin_data++ ) {
604 /* Shift into our buffer, and output any 6bits ready */
605 leftchar = (leftchar << 8) | *bin_data;
606 leftbits += 8;
607 while ( leftbits >= 6 ) {
608 this_ch = (leftchar >> (leftbits-6)) & 0x3f;
609 leftbits -= 6;
610 *ascii_data++ = table_b2a_hqx[this_ch];
611 }
612 }
613 /* Output a possible runt byte */
614 if ( leftbits ) {
615 leftchar <<= (6-leftbits);
616 *ascii_data++ = table_b2a_hqx[leftchar & 0x3f];
617 }
Roger E. Masse5f4ce181997-01-16 17:10:22 +0000618 _PyString_Resize(&rv, (ascii_data -
619 (unsigned char *)PyString_AsString(rv)));
Jack Jansen72781191995-08-07 14:34:15 +0000620 return rv;
621}
622
623static char doc_rledecode_hqx[] = "Decode hexbin RLE-coded string";
624
625static PyObject *
Peter Schneider-Kampa788a7f2000-07-10 09:57:19 +0000626binascii_rledecode_hqx(PyObject *self, PyObject *args)
Jack Jansen72781191995-08-07 14:34:15 +0000627{
628 unsigned char *in_data, *out_data;
629 unsigned char in_byte, in_repeat;
630 PyObject *rv;
631 int in_len, out_len, out_len_left;
632
Guido van Rossum43713e52000-02-29 13:59:29 +0000633 if ( !PyArg_ParseTuple(args, "s#:rledecode_hqx", &in_data, &in_len) )
Jack Jansen72781191995-08-07 14:34:15 +0000634 return NULL;
635
636 /* Empty string is a special case */
637 if ( in_len == 0 )
638 return Py_BuildValue("s", "");
639
640 /* Allocate a buffer of reasonable size. Resized when needed */
641 out_len = in_len*2;
642 if ( (rv=PyString_FromStringAndSize(NULL, out_len)) == NULL )
643 return NULL;
644 out_len_left = out_len;
645 out_data = (unsigned char *)PyString_AsString(rv);
646
647 /*
648 ** We need two macros here to get/put bytes and handle
649 ** end-of-buffer for input and output strings.
650 */
651#define INBYTE(b) \
Roger E. Masse5f4ce181997-01-16 17:10:22 +0000652 do { \
653 if ( --in_len < 0 ) { \
654 PyErr_SetString(Incomplete, ""); \
655 Py_DECREF(rv); \
656 return NULL; \
657 } \
658 b = *in_data++; \
659 } while(0)
Jack Jansen72781191995-08-07 14:34:15 +0000660
661#define OUTBYTE(b) \
Roger E. Masse5f4ce181997-01-16 17:10:22 +0000662 do { \
663 if ( --out_len_left < 0 ) { \
664 _PyString_Resize(&rv, 2*out_len); \
665 if ( rv == NULL ) return NULL; \
666 out_data = (unsigned char *)PyString_AsString(rv) \
667 + out_len; \
668 out_len_left = out_len-1; \
669 out_len = out_len * 2; \
670 } \
671 *out_data++ = b; \
672 } while(0)
Jack Jansen72781191995-08-07 14:34:15 +0000673
Roger E. Masse5f4ce181997-01-16 17:10:22 +0000674 /*
675 ** Handle first byte separately (since we have to get angry
676 ** in case of an orphaned RLE code).
677 */
678 INBYTE(in_byte);
Jack Jansen72781191995-08-07 14:34:15 +0000679
680 if (in_byte == RUNCHAR) {
681 INBYTE(in_repeat);
682 if (in_repeat != 0) {
683 /* Note Error, not Incomplete (which is at the end
684 ** of the string only). This is a programmer error.
685 */
686 PyErr_SetString(Error, "Orphaned RLE code at start");
687 Py_DECREF(rv);
688 return NULL;
689 }
690 OUTBYTE(RUNCHAR);
691 } else {
692 OUTBYTE(in_byte);
693 }
694
695 while( in_len > 0 ) {
696 INBYTE(in_byte);
697
698 if (in_byte == RUNCHAR) {
699 INBYTE(in_repeat);
700 if ( in_repeat == 0 ) {
701 /* Just an escaped RUNCHAR value */
702 OUTBYTE(RUNCHAR);
703 } else {
704 /* Pick up value and output a sequence of it */
705 in_byte = out_data[-1];
706 while ( --in_repeat > 0 )
707 OUTBYTE(in_byte);
708 }
709 } else {
710 /* Normal byte */
711 OUTBYTE(in_byte);
712 }
713 }
Roger E. Masse5f4ce181997-01-16 17:10:22 +0000714 _PyString_Resize(&rv, (out_data -
715 (unsigned char *)PyString_AsString(rv)));
Jack Jansen72781191995-08-07 14:34:15 +0000716 return rv;
717}
718
Roger E. Masse5f4ce181997-01-16 17:10:22 +0000719static char doc_crc_hqx[] =
720"(data, oldcrc) -> newcrc. Compute hqx CRC incrementally";
Jack Jansen72781191995-08-07 14:34:15 +0000721
722static PyObject *
Peter Schneider-Kampa788a7f2000-07-10 09:57:19 +0000723binascii_crc_hqx(PyObject *self, PyObject *args)
Jack Jansen72781191995-08-07 14:34:15 +0000724{
725 unsigned char *bin_data;
726 unsigned int crc;
727 int len;
728
Guido van Rossum43713e52000-02-29 13:59:29 +0000729 if ( !PyArg_ParseTuple(args, "s#i:crc_hqx", &bin_data, &len, &crc) )
Jack Jansen72781191995-08-07 14:34:15 +0000730 return NULL;
731
732 while(len--) {
733 crc=((crc<<8)&0xff00)^crctab_hqx[((crc>>8)&0xff)^*bin_data++];
734 }
735
736 return Py_BuildValue("i", crc);
737}
738
Guido van Rossum7d47c9e2000-02-16 21:11:52 +0000739static char doc_crc32[] =
740"(data, oldcrc = 0) -> newcrc. Compute CRC-32 incrementally";
741
742/* Crc - 32 BIT ANSI X3.66 CRC checksum files
743 Also known as: ISO 3307
744**********************************************************************|
745* *|
746* Demonstration program to compute the 32-bit CRC used as the frame *|
747* check sequence in ADCCP (ANSI X3.66, also known as FIPS PUB 71 *|
748* and FED-STD-1003, the U.S. versions of CCITT's X.25 link-level *|
749* protocol). The 32-bit FCS was added via the Federal Register, *|
750* 1 June 1982, p.23798. I presume but don't know for certain that *|
751* this polynomial is or will be included in CCITT V.41, which *|
752* defines the 16-bit CRC (often called CRC-CCITT) polynomial. FIPS *|
753* PUB 78 says that the 32-bit FCS reduces otherwise undetected *|
754* errors by a factor of 10^-5 over 16-bit FCS. *|
755* *|
756**********************************************************************|
757
758 Copyright (C) 1986 Gary S. Brown. You may use this program, or
759 code or tables extracted from it, as desired without restriction.
760
761 First, the polynomial itself and its table of feedback terms. The
762 polynomial is
763 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
764 Note that we take it "backwards" and put the highest-order term in
765 the lowest-order bit. The X^32 term is "implied"; the LSB is the
766 X^31 term, etc. The X^0 term (usually shown as "+1") results in
767 the MSB being 1.
768
769 Note that the usual hardware shift register implementation, which
770 is what we're using (we're merely optimizing it by doing eight-bit
771 chunks at a time) shifts bits into the lowest-order term. In our
772 implementation, that means shifting towards the right. Why do we
773 do it this way? Because the calculated CRC must be transmitted in
774 order from highest-order term to lowest-order term. UARTs transmit
775 characters in order from LSB to MSB. By storing the CRC this way,
776 we hand it to the UART in the order low-byte to high-byte; the UART
777 sends each low-bit to hight-bit; and the result is transmission bit
778 by bit from highest- to lowest-order term without requiring any bit
779 shuffling on our part. Reception works similarly.
780
781 The feedback terms table consists of 256, 32-bit entries. Notes:
782
783 1. The table can be generated at runtime if desired; code to do so
784 is shown later. It might not be obvious, but the feedback
785 terms simply represent the results of eight shift/xor opera-
786 tions for all combinations of data and CRC register values.
787
788 2. The CRC accumulation logic is the same for all CRC polynomials,
789 be they sixteen or thirty-two bits wide. You simply choose the
790 appropriate table. Alternatively, because the table can be
791 generated at runtime, you can start by generating the table for
792 the polynomial in question and use exactly the same "updcrc",
793 if your application needn't simultaneously handle two CRC
794 polynomials. (Note, however, that XMODEM is strange.)
795
796 3. For 16-bit CRCs, the table entries need be only 16 bits wide;
797 of course, 32-bit entries work OK if the high 16 bits are zero.
798
799 4. The values must be right-shifted by eight bits by the "updcrc"
800 logic; the shift must be unsigned (bring in zeroes). On some
801 hardware you could probably optimize the shift in assembler by
802 using byte-swap instructions.
803********************************************************************/
804
805static unsigned long crc_32_tab[256] = {
8060x00000000UL, 0x77073096UL, 0xee0e612cUL, 0x990951baUL, 0x076dc419UL,
8070x706af48fUL, 0xe963a535UL, 0x9e6495a3UL, 0x0edb8832UL, 0x79dcb8a4UL,
8080xe0d5e91eUL, 0x97d2d988UL, 0x09b64c2bUL, 0x7eb17cbdUL, 0xe7b82d07UL,
8090x90bf1d91UL, 0x1db71064UL, 0x6ab020f2UL, 0xf3b97148UL, 0x84be41deUL,
8100x1adad47dUL, 0x6ddde4ebUL, 0xf4d4b551UL, 0x83d385c7UL, 0x136c9856UL,
8110x646ba8c0UL, 0xfd62f97aUL, 0x8a65c9ecUL, 0x14015c4fUL, 0x63066cd9UL,
8120xfa0f3d63UL, 0x8d080df5UL, 0x3b6e20c8UL, 0x4c69105eUL, 0xd56041e4UL,
8130xa2677172UL, 0x3c03e4d1UL, 0x4b04d447UL, 0xd20d85fdUL, 0xa50ab56bUL,
8140x35b5a8faUL, 0x42b2986cUL, 0xdbbbc9d6UL, 0xacbcf940UL, 0x32d86ce3UL,
8150x45df5c75UL, 0xdcd60dcfUL, 0xabd13d59UL, 0x26d930acUL, 0x51de003aUL,
8160xc8d75180UL, 0xbfd06116UL, 0x21b4f4b5UL, 0x56b3c423UL, 0xcfba9599UL,
8170xb8bda50fUL, 0x2802b89eUL, 0x5f058808UL, 0xc60cd9b2UL, 0xb10be924UL,
8180x2f6f7c87UL, 0x58684c11UL, 0xc1611dabUL, 0xb6662d3dUL, 0x76dc4190UL,
8190x01db7106UL, 0x98d220bcUL, 0xefd5102aUL, 0x71b18589UL, 0x06b6b51fUL,
8200x9fbfe4a5UL, 0xe8b8d433UL, 0x7807c9a2UL, 0x0f00f934UL, 0x9609a88eUL,
8210xe10e9818UL, 0x7f6a0dbbUL, 0x086d3d2dUL, 0x91646c97UL, 0xe6635c01UL,
8220x6b6b51f4UL, 0x1c6c6162UL, 0x856530d8UL, 0xf262004eUL, 0x6c0695edUL,
8230x1b01a57bUL, 0x8208f4c1UL, 0xf50fc457UL, 0x65b0d9c6UL, 0x12b7e950UL,
8240x8bbeb8eaUL, 0xfcb9887cUL, 0x62dd1ddfUL, 0x15da2d49UL, 0x8cd37cf3UL,
8250xfbd44c65UL, 0x4db26158UL, 0x3ab551ceUL, 0xa3bc0074UL, 0xd4bb30e2UL,
8260x4adfa541UL, 0x3dd895d7UL, 0xa4d1c46dUL, 0xd3d6f4fbUL, 0x4369e96aUL,
8270x346ed9fcUL, 0xad678846UL, 0xda60b8d0UL, 0x44042d73UL, 0x33031de5UL,
8280xaa0a4c5fUL, 0xdd0d7cc9UL, 0x5005713cUL, 0x270241aaUL, 0xbe0b1010UL,
8290xc90c2086UL, 0x5768b525UL, 0x206f85b3UL, 0xb966d409UL, 0xce61e49fUL,
8300x5edef90eUL, 0x29d9c998UL, 0xb0d09822UL, 0xc7d7a8b4UL, 0x59b33d17UL,
8310x2eb40d81UL, 0xb7bd5c3bUL, 0xc0ba6cadUL, 0xedb88320UL, 0x9abfb3b6UL,
8320x03b6e20cUL, 0x74b1d29aUL, 0xead54739UL, 0x9dd277afUL, 0x04db2615UL,
8330x73dc1683UL, 0xe3630b12UL, 0x94643b84UL, 0x0d6d6a3eUL, 0x7a6a5aa8UL,
8340xe40ecf0bUL, 0x9309ff9dUL, 0x0a00ae27UL, 0x7d079eb1UL, 0xf00f9344UL,
8350x8708a3d2UL, 0x1e01f268UL, 0x6906c2feUL, 0xf762575dUL, 0x806567cbUL,
8360x196c3671UL, 0x6e6b06e7UL, 0xfed41b76UL, 0x89d32be0UL, 0x10da7a5aUL,
8370x67dd4accUL, 0xf9b9df6fUL, 0x8ebeeff9UL, 0x17b7be43UL, 0x60b08ed5UL,
8380xd6d6a3e8UL, 0xa1d1937eUL, 0x38d8c2c4UL, 0x4fdff252UL, 0xd1bb67f1UL,
8390xa6bc5767UL, 0x3fb506ddUL, 0x48b2364bUL, 0xd80d2bdaUL, 0xaf0a1b4cUL,
8400x36034af6UL, 0x41047a60UL, 0xdf60efc3UL, 0xa867df55UL, 0x316e8eefUL,
8410x4669be79UL, 0xcb61b38cUL, 0xbc66831aUL, 0x256fd2a0UL, 0x5268e236UL,
8420xcc0c7795UL, 0xbb0b4703UL, 0x220216b9UL, 0x5505262fUL, 0xc5ba3bbeUL,
8430xb2bd0b28UL, 0x2bb45a92UL, 0x5cb36a04UL, 0xc2d7ffa7UL, 0xb5d0cf31UL,
8440x2cd99e8bUL, 0x5bdeae1dUL, 0x9b64c2b0UL, 0xec63f226UL, 0x756aa39cUL,
8450x026d930aUL, 0x9c0906a9UL, 0xeb0e363fUL, 0x72076785UL, 0x05005713UL,
8460x95bf4a82UL, 0xe2b87a14UL, 0x7bb12baeUL, 0x0cb61b38UL, 0x92d28e9bUL,
8470xe5d5be0dUL, 0x7cdcefb7UL, 0x0bdbdf21UL, 0x86d3d2d4UL, 0xf1d4e242UL,
8480x68ddb3f8UL, 0x1fda836eUL, 0x81be16cdUL, 0xf6b9265bUL, 0x6fb077e1UL,
8490x18b74777UL, 0x88085ae6UL, 0xff0f6a70UL, 0x66063bcaUL, 0x11010b5cUL,
8500x8f659effUL, 0xf862ae69UL, 0x616bffd3UL, 0x166ccf45UL, 0xa00ae278UL,
8510xd70dd2eeUL, 0x4e048354UL, 0x3903b3c2UL, 0xa7672661UL, 0xd06016f7UL,
8520x4969474dUL, 0x3e6e77dbUL, 0xaed16a4aUL, 0xd9d65adcUL, 0x40df0b66UL,
8530x37d83bf0UL, 0xa9bcae53UL, 0xdebb9ec5UL, 0x47b2cf7fUL, 0x30b5ffe9UL,
8540xbdbdf21cUL, 0xcabac28aUL, 0x53b39330UL, 0x24b4a3a6UL, 0xbad03605UL,
8550xcdd70693UL, 0x54de5729UL, 0x23d967bfUL, 0xb3667a2eUL, 0xc4614ab8UL,
8560x5d681b02UL, 0x2a6f2b94UL, 0xb40bbe37UL, 0xc30c8ea1UL, 0x5a05df1bUL,
8570x2d02ef8dUL
858};
859
860static PyObject *
Peter Schneider-Kampa788a7f2000-07-10 09:57:19 +0000861binascii_crc32(PyObject *self, PyObject *args)
Guido van Rossum7d47c9e2000-02-16 21:11:52 +0000862{ /* By Jim Ahlstrom; All rights transferred to CNRI */
863 unsigned char *bin_data;
864 unsigned long crc = 0UL; /* initial value of CRC */
865 int len;
866
Guido van Rossum43713e52000-02-29 13:59:29 +0000867 if ( !PyArg_ParseTuple(args, "s#|l:crc32", &bin_data, &len, &crc) )
Guido van Rossum7d47c9e2000-02-16 21:11:52 +0000868 return NULL;
869
870 crc = crc ^ 0xFFFFFFFFUL;
871 while(len--)
872 crc = crc_32_tab[(crc ^ *bin_data++) & 0xffUL] ^ (crc >> 8);
873 /* Note: (crc >> 8) MUST zero fill on left */
874 return Py_BuildValue("l", crc ^ 0xFFFFFFFFUL);
875}
876
Jack Jansen72781191995-08-07 14:34:15 +0000877/* List of functions defined in the module */
878
879static struct PyMethodDef binascii_module_methods[] = {
880 {"a2b_uu", binascii_a2b_uu, 1, doc_a2b_uu},
881 {"b2a_uu", binascii_b2a_uu, 1, doc_b2a_uu},
Jack Jansen84bbc2e1995-10-04 16:38:44 +0000882 {"a2b_base64", binascii_a2b_base64, 1,
Roger E. Masse5f4ce181997-01-16 17:10:22 +0000883 doc_a2b_base64},
Jack Jansen84bbc2e1995-10-04 16:38:44 +0000884 {"b2a_base64", binascii_b2a_base64, 1,
Roger E. Masse5f4ce181997-01-16 17:10:22 +0000885 doc_b2a_base64},
Jack Jansen72781191995-08-07 14:34:15 +0000886 {"a2b_hqx", binascii_a2b_hqx, 1, doc_a2b_hqx},
887 {"b2a_hqx", binascii_b2a_hqx, 1, doc_b2a_hqx},
888 {"rlecode_hqx", binascii_rlecode_hqx, 1,
Roger E. Masse5f4ce181997-01-16 17:10:22 +0000889 doc_rlecode_hqx},
Jack Jansen72781191995-08-07 14:34:15 +0000890 {"rledecode_hqx", binascii_rledecode_hqx, 1,
Roger E. Masse5f4ce181997-01-16 17:10:22 +0000891 doc_rledecode_hqx},
Jack Jansen72781191995-08-07 14:34:15 +0000892 {"crc_hqx", binascii_crc_hqx, 1, doc_crc_hqx},
Guido van Rossum7d47c9e2000-02-16 21:11:52 +0000893 {"crc32", binascii_crc32, 1, doc_crc32},
Jack Jansen72781191995-08-07 14:34:15 +0000894 {NULL, NULL} /* sentinel */
895};
896
897
898/* Initialization function for the module (*must* be called initbinascii) */
899static char doc_binascii[] = "Conversion between binary data and ASCII";
900
Guido van Rossum3886bb61998-12-04 18:50:17 +0000901DL_EXPORT(void)
Jack Jansen72781191995-08-07 14:34:15 +0000902initbinascii()
903{
904 PyObject *m, *d, *x;
905
906 /* Create the module and add the functions */
907 m = Py_InitModule("binascii", binascii_module_methods);
908
909 d = PyModule_GetDict(m);
910 x = PyString_FromString(doc_binascii);
911 PyDict_SetItemString(d, "__doc__", x);
Guido van Rossum5c159bd1997-08-04 23:55:25 +0000912 Py_XDECREF(x);
Jack Jansen72781191995-08-07 14:34:15 +0000913
Guido van Rossum7dbb48a1997-10-08 15:26:07 +0000914 Error = PyErr_NewException("binascii.Error", NULL, NULL);
Jack Jansen72781191995-08-07 14:34:15 +0000915 PyDict_SetItemString(d, "Error", Error);
Guido van Rossum7dbb48a1997-10-08 15:26:07 +0000916 Incomplete = PyErr_NewException("binascii.Incomplete", NULL, NULL);
Jack Jansen72781191995-08-07 14:34:15 +0000917 PyDict_SetItemString(d, "Incomplete", Incomplete);
Jack Jansen72781191995-08-07 14:34:15 +0000918}