2 ** Routines to represent binary data in ASCII and vice-versa
4 ** This module currently supports the following encodings:
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.
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 '='.
20 ** File starts with introductory text, real data starts and ends
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.
31 ** While I was reading dozens of programs that encode or decode the formats
32 ** here (documentation? hihi:-) I have formulated Jansen's Observation:
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.
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...
44 ** Jack Jansen, CWI, July 1995.
46 ** Added support for quoted-printable encoding, based on rfc 1521 et al
47 ** quoted-printable encoding specifies that non printable characters (anything
48 ** below 32 and above 126) be encoded as =XX where XX is the hexadecimal value
49 ** of the character. It also specifies some other behavior to enable 8bit data
50 ** in a mail message with little difficulty (maximum line sizes, protecting
51 ** some cases of whitespace, etc).
53 ** Brandon Long, September 2001.
56 #define PY_SSIZE_T_CLEAN
63 static PyObject
*Error
;
64 static PyObject
*Incomplete
;
67 ** hqx lookup table, ascii->binary.
76 static unsigned char table_a2b_hqx
[256] = {
77 /* ^@ ^A ^B ^C ^D ^E ^F ^G */
78 /* 0*/ FAIL
, FAIL
, FAIL
, FAIL
, FAIL
, FAIL
, FAIL
, FAIL
,
79 /* \b \t \n ^K ^L \r ^N ^O */
80 /* 1*/ FAIL
, FAIL
, SKIP
, FAIL
, FAIL
, SKIP
, FAIL
, FAIL
,
81 /* ^P ^Q ^R ^S ^T ^U ^V ^W */
82 /* 2*/ FAIL
, FAIL
, FAIL
, FAIL
, FAIL
, FAIL
, FAIL
, FAIL
,
83 /* ^X ^Y ^Z ^[ ^\ ^] ^^ ^_ */
84 /* 3*/ FAIL
, FAIL
, FAIL
, FAIL
, FAIL
, FAIL
, FAIL
, FAIL
,
86 /* 4*/ FAIL
, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06,
88 /* 5*/ 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, FAIL
, FAIL
,
90 /* 6*/ 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12, 0x13, FAIL
,
92 /* 7*/ 0x14, 0x15, DONE
, FAIL
, FAIL
, FAIL
, FAIL
, FAIL
,
94 /* 8*/ 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D,
96 /* 9*/ 0x1E, 0x1F, 0x20, 0x21, 0x22, 0x23, 0x24, FAIL
,
98 /*10*/ 0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, FAIL
,
100 /*11*/ 0x2C, 0x2D, 0x2E, 0x2F, FAIL
, FAIL
, FAIL
, FAIL
,
101 /* ` a b c d e f g */
102 /*12*/ 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, FAIL
,
103 /* h i j k l m n o */
104 /*13*/ 0x37, 0x38, 0x39, 0x3A, 0x3B, 0x3C, FAIL
, FAIL
,
105 /* p q r s t u v w */
106 /*14*/ 0x3D, 0x3E, 0x3F, FAIL
, FAIL
, FAIL
, FAIL
, FAIL
,
107 /* x y z { | } ~ ^? */
108 /*15*/ FAIL
, FAIL
, FAIL
, FAIL
, FAIL
, FAIL
, FAIL
, FAIL
,
109 /*16*/ 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 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
,
127 static unsigned char table_b2a_hqx
[] =
128 "!\"#$%&'()*+,-012345689@ABCDEFGHIJKLMNPQRSTUVXYZ[`abcdefhijklmpqr";
130 static char table_a2b_base64
[] = {
131 -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,
132 -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,
133 -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,62, -1,-1,-1,63,
134 52,53,54,55, 56,57,58,59, 60,61,-1,-1, -1, 0,-1,-1, /* Note PAD->0 */
135 -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10, 11,12,13,14,
136 15,16,17,18, 19,20,21,22, 23,24,25,-1, -1,-1,-1,-1,
137 -1,26,27,28, 29,30,31,32, 33,34,35,36, 37,38,39,40,
138 41,42,43,44, 45,46,47,48, 49,50,51,-1, -1,-1,-1,-1
141 #define BASE64_PAD '='
143 /* Max binary chunk size; limited only by available memory */
144 #define BASE64_MAXBIN (INT_MAX/2 - sizeof(PyBytesObject) - 3)
146 static unsigned char table_b2a_base64
[] =
147 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
151 static unsigned short crctab_hqx
[256] = {
152 0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50a5, 0x60c6, 0x70e7,
153 0x8108, 0x9129, 0xa14a, 0xb16b, 0xc18c, 0xd1ad, 0xe1ce, 0xf1ef,
154 0x1231, 0x0210, 0x3273, 0x2252, 0x52b5, 0x4294, 0x72f7, 0x62d6,
155 0x9339, 0x8318, 0xb37b, 0xa35a, 0xd3bd, 0xc39c, 0xf3ff, 0xe3de,
156 0x2462, 0x3443, 0x0420, 0x1401, 0x64e6, 0x74c7, 0x44a4, 0x5485,
157 0xa56a, 0xb54b, 0x8528, 0x9509, 0xe5ee, 0xf5cf, 0xc5ac, 0xd58d,
158 0x3653, 0x2672, 0x1611, 0x0630, 0x76d7, 0x66f6, 0x5695, 0x46b4,
159 0xb75b, 0xa77a, 0x9719, 0x8738, 0xf7df, 0xe7fe, 0xd79d, 0xc7bc,
160 0x48c4, 0x58e5, 0x6886, 0x78a7, 0x0840, 0x1861, 0x2802, 0x3823,
161 0xc9cc, 0xd9ed, 0xe98e, 0xf9af, 0x8948, 0x9969, 0xa90a, 0xb92b,
162 0x5af5, 0x4ad4, 0x7ab7, 0x6a96, 0x1a71, 0x0a50, 0x3a33, 0x2a12,
163 0xdbfd, 0xcbdc, 0xfbbf, 0xeb9e, 0x9b79, 0x8b58, 0xbb3b, 0xab1a,
164 0x6ca6, 0x7c87, 0x4ce4, 0x5cc5, 0x2c22, 0x3c03, 0x0c60, 0x1c41,
165 0xedae, 0xfd8f, 0xcdec, 0xddcd, 0xad2a, 0xbd0b, 0x8d68, 0x9d49,
166 0x7e97, 0x6eb6, 0x5ed5, 0x4ef4, 0x3e13, 0x2e32, 0x1e51, 0x0e70,
167 0xff9f, 0xefbe, 0xdfdd, 0xcffc, 0xbf1b, 0xaf3a, 0x9f59, 0x8f78,
168 0x9188, 0x81a9, 0xb1ca, 0xa1eb, 0xd10c, 0xc12d, 0xf14e, 0xe16f,
169 0x1080, 0x00a1, 0x30c2, 0x20e3, 0x5004, 0x4025, 0x7046, 0x6067,
170 0x83b9, 0x9398, 0xa3fb, 0xb3da, 0xc33d, 0xd31c, 0xe37f, 0xf35e,
171 0x02b1, 0x1290, 0x22f3, 0x32d2, 0x4235, 0x5214, 0x6277, 0x7256,
172 0xb5ea, 0xa5cb, 0x95a8, 0x8589, 0xf56e, 0xe54f, 0xd52c, 0xc50d,
173 0x34e2, 0x24c3, 0x14a0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405,
174 0xa7db, 0xb7fa, 0x8799, 0x97b8, 0xe75f, 0xf77e, 0xc71d, 0xd73c,
175 0x26d3, 0x36f2, 0x0691, 0x16b0, 0x6657, 0x7676, 0x4615, 0x5634,
176 0xd94c, 0xc96d, 0xf90e, 0xe92f, 0x99c8, 0x89e9, 0xb98a, 0xa9ab,
177 0x5844, 0x4865, 0x7806, 0x6827, 0x18c0, 0x08e1, 0x3882, 0x28a3,
178 0xcb7d, 0xdb5c, 0xeb3f, 0xfb1e, 0x8bf9, 0x9bd8, 0xabbb, 0xbb9a,
179 0x4a75, 0x5a54, 0x6a37, 0x7a16, 0x0af1, 0x1ad0, 0x2ab3, 0x3a92,
180 0xfd2e, 0xed0f, 0xdd6c, 0xcd4d, 0xbdaa, 0xad8b, 0x9de8, 0x8dc9,
181 0x7c26, 0x6c07, 0x5c64, 0x4c45, 0x3ca2, 0x2c83, 0x1ce0, 0x0cc1,
182 0xef1f, 0xff3e, 0xcf5d, 0xdf7c, 0xaf9b, 0xbfba, 0x8fd9, 0x9ff8,
183 0x6e17, 0x7e36, 0x4e55, 0x5e74, 0x2e93, 0x3eb2, 0x0ed1, 0x1ef0,
186 PyDoc_STRVAR(doc_a2b_uu
, "(ascii) -> bin. Decode a line of uuencoded data");
189 binascii_a2b_uu(PyObject
*self
, PyObject
*args
)
191 unsigned char *ascii_data
, *bin_data
;
193 unsigned char this_ch
;
194 unsigned int leftchar
= 0;
196 Py_ssize_t ascii_len
, bin_len
;
198 if ( !PyArg_ParseTuple(args
, "t#:a2b_uu", &ascii_data
, &ascii_len
) )
201 /* First byte: binary data length (in bytes) */
202 bin_len
= (*ascii_data
++ - ' ') & 077;
205 /* Allocate the buffer */
206 if ( (rv
=PyBytes_FromStringAndSize(NULL
, bin_len
)) == NULL
)
208 bin_data
= (unsigned char *)PyBytes_AsString(rv
);
210 for( ; bin_len
> 0 ; ascii_len
--, ascii_data
++ ) {
211 /* XXX is it really best to add NULs if there's no more data */
212 this_ch
= (ascii_len
> 0) ? *ascii_data
: 0;
213 if ( this_ch
== '\n' || this_ch
== '\r' || ascii_len
<= 0) {
215 ** Whitespace. Assume some spaces got eaten at
216 ** end-of-line. (We check this later)
220 /* Check the character for legality
221 ** 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.
225 if ( this_ch
< ' ' || this_ch
> (' ' + 64)) {
226 PyErr_SetString(Error
, "Illegal char");
230 this_ch
= (this_ch
- ' ') & 077;
233 ** Shift it in on the low end, and see if there's
234 ** a byte ready for output.
236 leftchar
= (leftchar
<< 6) | (this_ch
);
238 if ( leftbits
>= 8 ) {
240 *bin_data
++ = (leftchar
>> leftbits
) & 0xff;
241 leftchar
&= ((1 << leftbits
) - 1);
246 ** Finally, check that if there's anything left on the line
247 ** that it's whitespace only.
249 while( ascii_len
-- > 0 ) {
250 this_ch
= *ascii_data
++;
251 /* Extra '`' may be written as padding in some cases */
252 if ( this_ch
!= ' ' && this_ch
!= ' '+64 &&
253 this_ch
!= '\n' && this_ch
!= '\r' ) {
254 PyErr_SetString(Error
, "Trailing garbage");
262 PyDoc_STRVAR(doc_b2a_uu
, "(bin) -> ascii. Uuencode line of data");
265 binascii_b2a_uu(PyObject
*self
, PyObject
*args
)
267 unsigned char *ascii_data
, *bin_data
;
269 unsigned char this_ch
;
270 unsigned int leftchar
= 0;
274 if ( !PyArg_ParseTuple(args
, "s#:b2a_uu", &bin_data
, &bin_len
) )
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");
282 /* We're lazy and allocate to much (fixed up later) */
283 if ( (rv
=PyBytes_FromStringAndSize(NULL
, bin_len
*2+2)) == NULL
)
285 ascii_data
= (unsigned char *)PyBytes_AsString(rv
);
287 /* Store the length */
288 *ascii_data
++ = ' ' + (bin_len
& 077);
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
;
298 /* See if there are 6-bit groups ready */
299 while ( leftbits
>= 6 ) {
300 this_ch
= (leftchar
>> (leftbits
-6)) & 0x3f;
302 *ascii_data
++ = this_ch
+ ' ';
305 *ascii_data
++ = '\n'; /* Append a courtesy newline */
307 _PyBytes_Resize(&rv
, (ascii_data
-
308 (unsigned char *)PyBytes_AsString(rv
)));
314 binascii_find_valid(unsigned char *s
, Py_ssize_t slen
, int num
)
316 /* Finds & returns the (num+1)th
317 ** valid character for base64, or -1 if none.
321 unsigned char c
, b64val
;
323 while ((slen
> 0) && (ret
== -1)) {
325 b64val
= table_a2b_base64
[c
& 0x7f];
326 if ( ((c
<= 0x7f) && (b64val
!= (unsigned char)-1)) ) {
338 PyDoc_STRVAR(doc_a2b_base64
, "(ascii) -> bin. Decode a line of base64 data");
341 binascii_a2b_base64(PyObject
*self
, PyObject
*args
)
343 unsigned char *ascii_data
, *bin_data
;
345 unsigned char this_ch
;
346 unsigned int leftchar
= 0;
348 Py_ssize_t ascii_len
, bin_len
;
351 if ( !PyArg_ParseTuple(args
, "t#:a2b_base64", &ascii_data
, &ascii_len
) )
354 bin_len
= ((ascii_len
+3)/4)*3; /* Upper bound, corrected later */
356 /* Allocate the buffer */
357 if ( (rv
=PyBytes_FromStringAndSize(NULL
, bin_len
)) == NULL
)
359 bin_data
= (unsigned char *)PyBytes_AsString(rv
);
362 for( ; ascii_len
> 0; ascii_len
--, ascii_data
++) {
363 this_ch
= *ascii_data
;
365 if (this_ch
> 0x7f ||
366 this_ch
== '\r' || this_ch
== '\n' || this_ch
== ' ')
369 /* Check for pad sequences and ignore
372 if (this_ch
== BASE64_PAD
) {
373 if ( (quad_pos
< 2) ||
375 (binascii_find_valid(ascii_data
, ascii_len
, 1)
381 /* A pad sequence means no more input.
382 ** We've already interpreted the data
383 ** from the quad at this point.
390 this_ch
= table_a2b_base64
[*ascii_data
];
391 if ( this_ch
== (unsigned char) -1 )
395 ** Shift it in on the low end, and see if there's
396 ** a byte ready for output.
398 quad_pos
= (quad_pos
+ 1) & 0x03;
399 leftchar
= (leftchar
<< 6) | (this_ch
);
402 if ( leftbits
>= 8 ) {
404 *bin_data
++ = (leftchar
>> leftbits
) & 0xff;
406 leftchar
&= ((1 << leftbits
) - 1);
411 PyErr_SetString(Error
, "Incorrect padding");
416 /* And set string size correctly. If the result string is empty
417 ** (because the input was all invalid) return the shared empty
418 ** string instead; _PyBytes_Resize() won't do this for us.
421 _PyBytes_Resize(&rv
, bin_len
);
424 rv
= PyBytes_FromString("");
429 PyDoc_STRVAR(doc_b2a_base64
, "(bin) -> ascii. Base64-code line of data");
432 binascii_b2a_base64(PyObject
*self
, PyObject
*args
)
434 unsigned char *ascii_data
, *bin_data
;
436 unsigned char this_ch
;
437 unsigned int leftchar
= 0;
441 if ( !PyArg_ParseTuple(args
, "s#:b2a_base64", &bin_data
, &bin_len
) )
443 if ( bin_len
> BASE64_MAXBIN
) {
444 PyErr_SetString(Error
, "Too much data for base64 line");
448 /* We're lazy and allocate too much (fixed up later).
449 "+3" leaves room for up to two pad characters and a trailing
450 newline. Note that 'b' gets encoded as 'Yg==\n' (1 in, 5 out). */
451 if ( (rv
=PyBytes_FromStringAndSize(NULL
, bin_len
*2 + 3)) == NULL
)
453 ascii_data
= (unsigned char *)PyBytes_AsString(rv
);
455 for( ; bin_len
> 0 ; bin_len
--, bin_data
++ ) {
456 /* Shift the data into our buffer */
457 leftchar
= (leftchar
<< 8) | *bin_data
;
460 /* See if there are 6-bit groups ready */
461 while ( leftbits
>= 6 ) {
462 this_ch
= (leftchar
>> (leftbits
-6)) & 0x3f;
464 *ascii_data
++ = table_b2a_base64
[this_ch
];
467 if ( leftbits
== 2 ) {
468 *ascii_data
++ = table_b2a_base64
[(leftchar
&3) << 4];
469 *ascii_data
++ = BASE64_PAD
;
470 *ascii_data
++ = BASE64_PAD
;
471 } else if ( leftbits
== 4 ) {
472 *ascii_data
++ = table_b2a_base64
[(leftchar
&0xf) << 2];
473 *ascii_data
++ = BASE64_PAD
;
475 *ascii_data
++ = '\n'; /* Append a courtesy newline */
477 _PyBytes_Resize(&rv
, (ascii_data
-
478 (unsigned char *)PyBytes_AsString(rv
)));
482 PyDoc_STRVAR(doc_a2b_hqx
, "ascii -> bin, done. Decode .hqx coding");
485 binascii_a2b_hqx(PyObject
*self
, PyObject
*args
)
487 unsigned char *ascii_data
, *bin_data
;
489 unsigned char this_ch
;
490 unsigned int leftchar
= 0;
495 if ( !PyArg_ParseTuple(args
, "t#:a2b_hqx", &ascii_data
, &len
) )
498 /* Allocate a string that is too big (fixed later)
499 Add two to the initial length to prevent interning which
500 would preclude subsequent resizing. */
501 if ( (rv
=PyBytes_FromStringAndSize(NULL
, len
+2)) == NULL
)
503 bin_data
= (unsigned char *)PyBytes_AsString(rv
);
505 for( ; len
> 0 ; len
--, ascii_data
++ ) {
506 /* Get the byte and look it up */
507 this_ch
= table_a2b_hqx
[*ascii_data
];
508 if ( this_ch
== SKIP
)
510 if ( this_ch
== FAIL
) {
511 PyErr_SetString(Error
, "Illegal char");
515 if ( this_ch
== DONE
) {
516 /* The terminating colon */
521 /* Shift it into the buffer and see if any bytes are ready */
522 leftchar
= (leftchar
<< 6) | (this_ch
);
524 if ( leftbits
>= 8 ) {
526 *bin_data
++ = (leftchar
>> leftbits
) & 0xff;
527 leftchar
&= ((1 << leftbits
) - 1);
531 if ( leftbits
&& !done
) {
532 PyErr_SetString(Incomplete
,
533 "String has incomplete number of bytes");
538 &rv
, (bin_data
- (unsigned char *)PyBytes_AsString(rv
)));
540 PyObject
*rrv
= Py_BuildValue("Oi", rv
, done
);
548 PyDoc_STRVAR(doc_rlecode_hqx
, "Binhex RLE-code binary data");
551 binascii_rlecode_hqx(PyObject
*self
, PyObject
*args
)
553 unsigned char *in_data
, *out_data
;
556 Py_ssize_t in
, inend
, len
;
558 if ( !PyArg_ParseTuple(args
, "s#:rlecode_hqx", &in_data
, &len
) )
561 /* Worst case: output is twice as big as input (fixed later) */
562 if ( (rv
=PyBytes_FromStringAndSize(NULL
, len
*2+2)) == NULL
)
564 out_data
= (unsigned char *)PyBytes_AsString(rv
);
566 for( in
=0; in
<len
; in
++) {
568 if ( ch
== RUNCHAR
) {
569 /* RUNCHAR. Escape it. */
570 *out_data
++ = RUNCHAR
;
573 /* Check how many following are the same */
575 inend
<len
&& in_data
[inend
] == ch
&&
578 if ( inend
- in
> 3 ) {
579 /* More than 3 in a row. Output RLE. */
581 *out_data
++ = RUNCHAR
;
582 *out_data
++ = inend
-in
;
585 /* Less than 3. Output the byte itself */
590 _PyBytes_Resize(&rv
, (out_data
-
591 (unsigned char *)PyBytes_AsString(rv
)));
595 PyDoc_STRVAR(doc_b2a_hqx
, "Encode .hqx data");
598 binascii_b2a_hqx(PyObject
*self
, PyObject
*args
)
600 unsigned char *ascii_data
, *bin_data
;
602 unsigned char this_ch
;
603 unsigned int leftchar
= 0;
607 if ( !PyArg_ParseTuple(args
, "s#:b2a_hqx", &bin_data
, &len
) )
610 /* Allocate a buffer that is at least large enough */
611 if ( (rv
=PyBytes_FromStringAndSize(NULL
, len
*2+2)) == NULL
)
613 ascii_data
= (unsigned char *)PyBytes_AsString(rv
);
615 for( ; len
> 0 ; len
--, bin_data
++ ) {
616 /* Shift into our buffer, and output any 6bits ready */
617 leftchar
= (leftchar
<< 8) | *bin_data
;
619 while ( leftbits
>= 6 ) {
620 this_ch
= (leftchar
>> (leftbits
-6)) & 0x3f;
622 *ascii_data
++ = table_b2a_hqx
[this_ch
];
625 /* Output a possible runt byte */
627 leftchar
<<= (6-leftbits
);
628 *ascii_data
++ = table_b2a_hqx
[leftchar
& 0x3f];
630 _PyBytes_Resize(&rv
, (ascii_data
-
631 (unsigned char *)PyBytes_AsString(rv
)));
635 PyDoc_STRVAR(doc_rledecode_hqx
, "Decode hexbin RLE-coded string");
638 binascii_rledecode_hqx(PyObject
*self
, PyObject
*args
)
640 unsigned char *in_data
, *out_data
;
641 unsigned char in_byte
, in_repeat
;
643 Py_ssize_t in_len
, out_len
, out_len_left
;
645 if ( !PyArg_ParseTuple(args
, "s#:rledecode_hqx", &in_data
, &in_len
) )
648 /* Empty string is a special case */
650 return PyBytes_FromString("");
652 /* Allocate a buffer of reasonable size. Resized when needed */
654 if ( (rv
=PyBytes_FromStringAndSize(NULL
, out_len
)) == NULL
)
656 out_len_left
= out_len
;
657 out_data
= (unsigned char *)PyBytes_AsString(rv
);
660 ** We need two macros here to get/put bytes and handle
661 ** end-of-buffer for input and output strings.
665 if ( --in_len < 0 ) { \
666 PyErr_SetString(Incomplete, ""); \
675 if ( --out_len_left < 0 ) { \
676 _PyBytes_Resize(&rv, 2*out_len); \
677 if ( rv == NULL ) return NULL; \
678 out_data = (unsigned char *)PyBytes_AsString(rv) \
680 out_len_left = out_len-1; \
681 out_len = out_len * 2; \
687 ** Handle first byte separately (since we have to get angry
688 ** in case of an orphaned RLE code).
692 if (in_byte
== RUNCHAR
) {
694 if (in_repeat
!= 0) {
695 /* Note Error, not Incomplete (which is at the end
696 ** of the string only). This is a programmer error.
698 PyErr_SetString(Error
, "Orphaned RLE code at start");
707 while( in_len
> 0 ) {
710 if (in_byte
== RUNCHAR
) {
712 if ( in_repeat
== 0 ) {
713 /* Just an escaped RUNCHAR value */
716 /* Pick up value and output a sequence of it */
717 in_byte
= out_data
[-1];
718 while ( --in_repeat
> 0 )
726 _PyBytes_Resize(&rv
, (out_data
-
727 (unsigned char *)PyBytes_AsString(rv
)));
731 PyDoc_STRVAR(doc_crc_hqx
,
732 "(data, oldcrc) -> newcrc. Compute hqx CRC incrementally");
735 binascii_crc_hqx(PyObject
*self
, PyObject
*args
)
737 unsigned char *bin_data
;
741 if ( !PyArg_ParseTuple(args
, "s#i:crc_hqx", &bin_data
, &len
, &crc
) )
745 crc
=((crc
<<8)&0xff00)^crctab_hqx
[((crc
>>8)&0xff)^*bin_data
++];
748 return Py_BuildValue("i", crc
);
751 PyDoc_STRVAR(doc_crc32
,
752 "(data, oldcrc = 0) -> newcrc. Compute CRC-32 incrementally");
754 #ifdef USE_ZLIB_CRC32
755 /* This was taken from zlibmodule.c PyZlib_crc32 (but is PY_SSIZE_T_CLEAN) */
757 binascii_crc32(PyObject
*self
, PyObject
*args
)
759 unsigned int crc32val
= 0; /* crc32(0L, Z_NULL, 0) */
764 if (!PyArg_ParseTuple(args
, "s#|I:crc32", &buf
, &len
, &crc32val
))
766 /* In Python 2.x we return a signed integer regardless of native platform
767 * long size (the 32bit unsigned long is treated as 32-bit signed and sign
768 * extended into a 64-bit long inside the integer object). 3.0 does the
769 * right thing and returns unsigned. http://bugs.python.org/issue1202 */
770 signed_val
= crc32(crc32val
, buf
, len
);
771 return PyInt_FromLong(signed_val
);
773 #else /* USE_ZLIB_CRC32 */
774 /* Crc - 32 BIT ANSI X3.66 CRC checksum files
775 Also known as: ISO 3307
776 **********************************************************************|
778 * Demonstration program to compute the 32-bit CRC used as the frame *|
779 * check sequence in ADCCP (ANSI X3.66, also known as FIPS PUB 71 *|
780 * and FED-STD-1003, the U.S. versions of CCITT's X.25 link-level *|
781 * protocol). The 32-bit FCS was added via the Federal Register, *|
782 * 1 June 1982, p.23798. I presume but don't know for certain that *|
783 * this polynomial is or will be included in CCITT V.41, which *|
784 * defines the 16-bit CRC (often called CRC-CCITT) polynomial. FIPS *|
785 * PUB 78 says that the 32-bit FCS reduces otherwise undetected *|
786 * errors by a factor of 10^-5 over 16-bit FCS. *|
788 **********************************************************************|
790 Copyright (C) 1986 Gary S. Brown. You may use this program, or
791 code or tables extracted from it, as desired without restriction.
793 First, the polynomial itself and its table of feedback terms. The
795 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
796 Note that we take it "backwards" and put the highest-order term in
797 the lowest-order bit. The X^32 term is "implied"; the LSB is the
798 X^31 term, etc. The X^0 term (usually shown as "+1") results in
801 Note that the usual hardware shift register implementation, which
802 is what we're using (we're merely optimizing it by doing eight-bit
803 chunks at a time) shifts bits into the lowest-order term. In our
804 implementation, that means shifting towards the right. Why do we
805 do it this way? Because the calculated CRC must be transmitted in
806 order from highest-order term to lowest-order term. UARTs transmit
807 characters in order from LSB to MSB. By storing the CRC this way,
808 we hand it to the UART in the order low-byte to high-byte; the UART
809 sends each low-bit to hight-bit; and the result is transmission bit
810 by bit from highest- to lowest-order term without requiring any bit
811 shuffling on our part. Reception works similarly.
813 The feedback terms table consists of 256, 32-bit entries. Notes:
815 1. The table can be generated at runtime if desired; code to do so
816 is shown later. It might not be obvious, but the feedback
817 terms simply represent the results of eight shift/xor opera-
818 tions for all combinations of data and CRC register values.
820 2. The CRC accumulation logic is the same for all CRC polynomials,
821 be they sixteen or thirty-two bits wide. You simply choose the
822 appropriate table. Alternatively, because the table can be
823 generated at runtime, you can start by generating the table for
824 the polynomial in question and use exactly the same "updcrc",
825 if your application needn't simultaneously handle two CRC
826 polynomials. (Note, however, that XMODEM is strange.)
828 3. For 16-bit CRCs, the table entries need be only 16 bits wide;
829 of course, 32-bit entries work OK if the high 16 bits are zero.
831 4. The values must be right-shifted by eight bits by the "updcrc"
832 logic; the shift must be unsigned (bring in zeroes). On some
833 hardware you could probably optimize the shift in assembler by
834 using byte-swap instructions.
835 ********************************************************************/
837 static unsigned int crc_32_tab
[256] = {
838 0x00000000U
, 0x77073096U
, 0xee0e612cU
, 0x990951baU
, 0x076dc419U
,
839 0x706af48fU
, 0xe963a535U
, 0x9e6495a3U
, 0x0edb8832U
, 0x79dcb8a4U
,
840 0xe0d5e91eU
, 0x97d2d988U
, 0x09b64c2bU
, 0x7eb17cbdU
, 0xe7b82d07U
,
841 0x90bf1d91U
, 0x1db71064U
, 0x6ab020f2U
, 0xf3b97148U
, 0x84be41deU
,
842 0x1adad47dU
, 0x6ddde4ebU
, 0xf4d4b551U
, 0x83d385c7U
, 0x136c9856U
,
843 0x646ba8c0U
, 0xfd62f97aU
, 0x8a65c9ecU
, 0x14015c4fU
, 0x63066cd9U
,
844 0xfa0f3d63U
, 0x8d080df5U
, 0x3b6e20c8U
, 0x4c69105eU
, 0xd56041e4U
,
845 0xa2677172U
, 0x3c03e4d1U
, 0x4b04d447U
, 0xd20d85fdU
, 0xa50ab56bU
,
846 0x35b5a8faU
, 0x42b2986cU
, 0xdbbbc9d6U
, 0xacbcf940U
, 0x32d86ce3U
,
847 0x45df5c75U
, 0xdcd60dcfU
, 0xabd13d59U
, 0x26d930acU
, 0x51de003aU
,
848 0xc8d75180U
, 0xbfd06116U
, 0x21b4f4b5U
, 0x56b3c423U
, 0xcfba9599U
,
849 0xb8bda50fU
, 0x2802b89eU
, 0x5f058808U
, 0xc60cd9b2U
, 0xb10be924U
,
850 0x2f6f7c87U
, 0x58684c11U
, 0xc1611dabU
, 0xb6662d3dU
, 0x76dc4190U
,
851 0x01db7106U
, 0x98d220bcU
, 0xefd5102aU
, 0x71b18589U
, 0x06b6b51fU
,
852 0x9fbfe4a5U
, 0xe8b8d433U
, 0x7807c9a2U
, 0x0f00f934U
, 0x9609a88eU
,
853 0xe10e9818U
, 0x7f6a0dbbU
, 0x086d3d2dU
, 0x91646c97U
, 0xe6635c01U
,
854 0x6b6b51f4U
, 0x1c6c6162U
, 0x856530d8U
, 0xf262004eU
, 0x6c0695edU
,
855 0x1b01a57bU
, 0x8208f4c1U
, 0xf50fc457U
, 0x65b0d9c6U
, 0x12b7e950U
,
856 0x8bbeb8eaU
, 0xfcb9887cU
, 0x62dd1ddfU
, 0x15da2d49U
, 0x8cd37cf3U
,
857 0xfbd44c65U
, 0x4db26158U
, 0x3ab551ceU
, 0xa3bc0074U
, 0xd4bb30e2U
,
858 0x4adfa541U
, 0x3dd895d7U
, 0xa4d1c46dU
, 0xd3d6f4fbU
, 0x4369e96aU
,
859 0x346ed9fcU
, 0xad678846U
, 0xda60b8d0U
, 0x44042d73U
, 0x33031de5U
,
860 0xaa0a4c5fU
, 0xdd0d7cc9U
, 0x5005713cU
, 0x270241aaU
, 0xbe0b1010U
,
861 0xc90c2086U
, 0x5768b525U
, 0x206f85b3U
, 0xb966d409U
, 0xce61e49fU
,
862 0x5edef90eU
, 0x29d9c998U
, 0xb0d09822U
, 0xc7d7a8b4U
, 0x59b33d17U
,
863 0x2eb40d81U
, 0xb7bd5c3bU
, 0xc0ba6cadU
, 0xedb88320U
, 0x9abfb3b6U
,
864 0x03b6e20cU
, 0x74b1d29aU
, 0xead54739U
, 0x9dd277afU
, 0x04db2615U
,
865 0x73dc1683U
, 0xe3630b12U
, 0x94643b84U
, 0x0d6d6a3eU
, 0x7a6a5aa8U
,
866 0xe40ecf0bU
, 0x9309ff9dU
, 0x0a00ae27U
, 0x7d079eb1U
, 0xf00f9344U
,
867 0x8708a3d2U
, 0x1e01f268U
, 0x6906c2feU
, 0xf762575dU
, 0x806567cbU
,
868 0x196c3671U
, 0x6e6b06e7U
, 0xfed41b76U
, 0x89d32be0U
, 0x10da7a5aU
,
869 0x67dd4accU
, 0xf9b9df6fU
, 0x8ebeeff9U
, 0x17b7be43U
, 0x60b08ed5U
,
870 0xd6d6a3e8U
, 0xa1d1937eU
, 0x38d8c2c4U
, 0x4fdff252U
, 0xd1bb67f1U
,
871 0xa6bc5767U
, 0x3fb506ddU
, 0x48b2364bU
, 0xd80d2bdaU
, 0xaf0a1b4cU
,
872 0x36034af6U
, 0x41047a60U
, 0xdf60efc3U
, 0xa867df55U
, 0x316e8eefU
,
873 0x4669be79U
, 0xcb61b38cU
, 0xbc66831aU
, 0x256fd2a0U
, 0x5268e236U
,
874 0xcc0c7795U
, 0xbb0b4703U
, 0x220216b9U
, 0x5505262fU
, 0xc5ba3bbeU
,
875 0xb2bd0b28U
, 0x2bb45a92U
, 0x5cb36a04U
, 0xc2d7ffa7U
, 0xb5d0cf31U
,
876 0x2cd99e8bU
, 0x5bdeae1dU
, 0x9b64c2b0U
, 0xec63f226U
, 0x756aa39cU
,
877 0x026d930aU
, 0x9c0906a9U
, 0xeb0e363fU
, 0x72076785U
, 0x05005713U
,
878 0x95bf4a82U
, 0xe2b87a14U
, 0x7bb12baeU
, 0x0cb61b38U
, 0x92d28e9bU
,
879 0xe5d5be0dU
, 0x7cdcefb7U
, 0x0bdbdf21U
, 0x86d3d2d4U
, 0xf1d4e242U
,
880 0x68ddb3f8U
, 0x1fda836eU
, 0x81be16cdU
, 0xf6b9265bU
, 0x6fb077e1U
,
881 0x18b74777U
, 0x88085ae6U
, 0xff0f6a70U
, 0x66063bcaU
, 0x11010b5cU
,
882 0x8f659effU
, 0xf862ae69U
, 0x616bffd3U
, 0x166ccf45U
, 0xa00ae278U
,
883 0xd70dd2eeU
, 0x4e048354U
, 0x3903b3c2U
, 0xa7672661U
, 0xd06016f7U
,
884 0x4969474dU
, 0x3e6e77dbU
, 0xaed16a4aU
, 0xd9d65adcU
, 0x40df0b66U
,
885 0x37d83bf0U
, 0xa9bcae53U
, 0xdebb9ec5U
, 0x47b2cf7fU
, 0x30b5ffe9U
,
886 0xbdbdf21cU
, 0xcabac28aU
, 0x53b39330U
, 0x24b4a3a6U
, 0xbad03605U
,
887 0xcdd70693U
, 0x54de5729U
, 0x23d967bfU
, 0xb3667a2eU
, 0xc4614ab8U
,
888 0x5d681b02U
, 0x2a6f2b94U
, 0xb40bbe37U
, 0xc30c8ea1U
, 0x5a05df1bU
,
893 binascii_crc32(PyObject
*self
, PyObject
*args
)
894 { /* By Jim Ahlstrom; All rights transferred to CNRI */
895 unsigned char *bin_data
;
896 unsigned int crc
= 0U; /* initial value of CRC */
900 if ( !PyArg_ParseTuple(args
, "s#|I:crc32", &bin_data
, &len
, &crc
) )
905 crc
= crc_32_tab
[(crc
^ *bin_data
++) & 0xffU
] ^ (crc
>> 8);
906 /* Note: (crc >> 8) MUST zero fill on left */
908 result
= (int)(crc
^ 0xFFFFFFFFU
);
909 return PyInt_FromLong(result
);
911 #endif /* USE_ZLIB_CRC32 */
915 binascii_hexlify(PyObject
*self
, PyObject
*args
)
923 if (!PyArg_ParseTuple(args
, "s#:b2a_hex", &argbuf
, &arglen
))
926 retval
= PyBytes_FromStringAndSize(NULL
, arglen
*2);
929 retbuf
= PyBytes_AsString(retval
);
933 /* make hex version of string, taken from shamodule.c */
934 for (i
=j
=0; i
< arglen
; i
++) {
936 c
= (argbuf
[i
] >> 4) & 0xf;
937 c
= (c
>9) ? c
+'a'-10 : c
+ '0';
940 c
= (c
>9) ? c
+'a'-10 : c
+ '0';
950 PyDoc_STRVAR(doc_hexlify
,
951 "b2a_hex(data) -> s; Hexadecimal representation of binary data.\n\
953 This function is also available as \"hexlify()\".");
964 if (c
>= 'a' && c
<= 'f')
972 binascii_unhexlify(PyObject
*self
, PyObject
*args
)
980 if (!PyArg_ParseTuple(args
, "s#:a2b_hex", &argbuf
, &arglen
))
983 /* XXX What should we do about strings with an odd length? Should
984 * we add an implicit leading zero, or a trailing zero? For now,
985 * raise an exception.
988 PyErr_SetString(PyExc_TypeError
, "Odd-length string");
992 retval
= PyBytes_FromStringAndSize(NULL
, (arglen
/2));
995 retbuf
= PyBytes_AsString(retval
);
999 for (i
=j
=0; i
< arglen
; i
+= 2) {
1000 int top
= to_int(Py_CHARMASK(argbuf
[i
]));
1001 int bot
= to_int(Py_CHARMASK(argbuf
[i
+1]));
1002 if (top
== -1 || bot
== -1) {
1003 PyErr_SetString(PyExc_TypeError
,
1004 "Non-hexadecimal digit found");
1007 retbuf
[j
++] = (top
<< 4) + bot
;
1016 PyDoc_STRVAR(doc_unhexlify
,
1017 "a2b_hex(hexstr) -> s; Binary data of hexadecimal representation.\n\
1019 hexstr must contain an even number of hex digits (upper or lower case).\n\
1020 This function is also available as \"unhexlify()\"");
1022 static int table_hex
[128] = {
1023 -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,
1024 -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,
1025 -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,
1026 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,-1,-1, -1,-1,-1,-1,
1027 -1,10,11,12, 13,14,15,-1, -1,-1,-1,-1, -1,-1,-1,-1,
1028 -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,
1029 -1,10,11,12, 13,14,15,-1, -1,-1,-1,-1, -1,-1,-1,-1,
1030 -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1
1033 #define hexval(c) table_hex[(unsigned int)(c)]
1035 #define MAXLINESIZE 76
1037 PyDoc_STRVAR(doc_a2b_qp
, "Decode a string of qp-encoded data");
1040 binascii_a2b_qp(PyObject
*self
, PyObject
*args
, PyObject
*kwargs
)
1044 unsigned char *data
, *odata
;
1045 Py_ssize_t datalen
= 0;
1047 static char *kwlist
[] = {"data", "header", NULL
};
1050 if (!PyArg_ParseTupleAndKeywords(args
, kwargs
, "s#|i", kwlist
, &data
,
1054 /* We allocate the output same size as input, this is overkill.
1055 * The previous implementation used calloc() so we'll zero out the
1056 * memory here too, since PyMem_Malloc() does not guarantee that.
1058 odata
= (unsigned char *) PyMem_Malloc(datalen
);
1059 if (odata
== NULL
) {
1063 memset(odata
, 0, datalen
);
1066 while (in
< datalen
) {
1067 if (data
[in
] == '=') {
1069 if (in
>= datalen
) break;
1070 /* Soft line breaks */
1071 if ((data
[in
] == '\n') || (data
[in
] == '\r')) {
1072 if (data
[in
] != '\n') {
1073 while (in
< datalen
&& data
[in
] != '\n') in
++;
1075 if (in
< datalen
) in
++;
1077 else if (data
[in
] == '=') {
1078 /* broken case from broken python qp */
1082 else if (((data
[in
] >= 'A' && data
[in
] <= 'F') ||
1083 (data
[in
] >= 'a' && data
[in
] <= 'f') ||
1084 (data
[in
] >= '0' && data
[in
] <= '9')) &&
1085 ((data
[in
+1] >= 'A' && data
[in
+1] <= 'F') ||
1086 (data
[in
+1] >= 'a' && data
[in
+1] <= 'f') ||
1087 (data
[in
+1] >= '0' && data
[in
+1] <= '9'))) {
1089 ch
= hexval(data
[in
]) << 4;
1091 ch
|= hexval(data
[in
]);
1099 else if (header
&& data
[in
] == '_') {
1104 odata
[out
] = data
[in
];
1109 if ((rv
= PyBytes_FromStringAndSize((char *)odata
, out
)) == NULL
) {
1118 to_hex (unsigned char ch
, unsigned char *s
)
1120 unsigned int uvalue
= ch
;
1122 s
[1] = "0123456789ABCDEF"[uvalue
% 16];
1123 uvalue
= (uvalue
/ 16);
1124 s
[0] = "0123456789ABCDEF"[uvalue
% 16];
1128 PyDoc_STRVAR(doc_b2a_qp
,
1129 "b2a_qp(data, quotetabs=0, istext=1, header=0) -> s; \n\
1130 Encode a string using quoted-printable encoding. \n\
1132 On encoding, when istext is set, newlines are not encoded, and white \n\
1133 space at end of lines is. When istext is not set, \\r and \\n (CR/LF) are \n\
1134 both encoded. When quotetabs is set, space and tabs are encoded.");
1136 /* XXX: This is ridiculously complicated to be backward compatible
1137 * (mostly) with the quopri module. It doesn't re-create the quopri
1138 * module bug where text ending in CRLF has the CR encoded */
1140 binascii_b2a_qp (PyObject
*self
, PyObject
*args
, PyObject
*kwargs
)
1143 unsigned char *data
, *odata
;
1144 Py_ssize_t datalen
= 0, odatalen
= 0;
1146 unsigned int linelen
= 0;
1147 static char *kwlist
[] = {"data", "quotetabs", "istext",
1156 if (!PyArg_ParseTupleAndKeywords(args
, kwargs
, "s#|iii", kwlist
, &data
,
1157 &datalen
, "etabs
, &istext
, &header
))
1160 /* See if this string is using CRLF line ends */
1161 /* XXX: this function has the side effect of converting all of
1162 * the end of lines to be the same depending on this detection
1164 p
= (unsigned char *) memchr(data
, '\n', datalen
);
1165 if ((p
!= NULL
) && (p
> data
) && (*(p
-1) == '\r'))
1168 /* First, scan to see how many characters need to be encoded */
1170 while (in
< datalen
) {
1171 if ((data
[in
] > 126) ||
1172 (data
[in
] == '=') ||
1173 (header
&& data
[in
] == '_') ||
1174 ((data
[in
] == '.') && (linelen
== 0) &&
1175 (data
[in
+1] == '\n' || data
[in
+1] == '\r' || data
[in
+1] == 0)) ||
1176 (!istext
&& ((data
[in
] == '\r') || (data
[in
] == '\n'))) ||
1177 ((data
[in
] == '\t' || data
[in
] == ' ') && (in
+ 1 == datalen
)) ||
1179 (data
[in
] != '\r') && (data
[in
] != '\n') &&
1181 (!quotetabs
&& ((data
[in
] != '\t') && (data
[in
] != ' '))))))
1183 if ((linelen
+ 3) >= MAXLINESIZE
) {
1196 ((data
[in
] == '\n') ||
1197 ((in
+1 < datalen
) && (data
[in
] == '\r') &&
1198 (data
[in
+1] == '\n'))))
1201 /* Protect against whitespace on end of line */
1202 if (in
&& ((data
[in
-1] == ' ') || (data
[in
-1] == '\t')))
1208 if (data
[in
] == '\r')
1214 if ((in
+ 1 != datalen
) &&
1215 (data
[in
+1] != '\n') &&
1216 (linelen
+ 1) >= MAXLINESIZE
) {
1230 /* We allocate the output same size as input, this is overkill.
1231 * The previous implementation used calloc() so we'll zero out the
1232 * memory here too, since PyMem_Malloc() does not guarantee that.
1234 odata
= (unsigned char *) PyMem_Malloc(odatalen
);
1235 if (odata
== NULL
) {
1239 memset(odata
, 0, odatalen
);
1241 in
= out
= linelen
= 0;
1242 while (in
< datalen
) {
1243 if ((data
[in
] > 126) ||
1244 (data
[in
] == '=') ||
1245 (header
&& data
[in
] == '_') ||
1246 ((data
[in
] == '.') && (linelen
== 0) &&
1247 (data
[in
+1] == '\n' || data
[in
+1] == '\r' || data
[in
+1] == 0)) ||
1248 (!istext
&& ((data
[in
] == '\r') || (data
[in
] == '\n'))) ||
1249 ((data
[in
] == '\t' || data
[in
] == ' ') && (in
+ 1 == datalen
)) ||
1251 (data
[in
] != '\r') && (data
[in
] != '\n') &&
1253 (!quotetabs
&& ((data
[in
] != '\t') && (data
[in
] != ' '))))))
1255 if ((linelen
+ 3 )>= MAXLINESIZE
) {
1257 if (crlf
) odata
[out
++] = '\r';
1258 odata
[out
++] = '\n';
1262 to_hex(data
[in
], &odata
[out
]);
1269 ((data
[in
] == '\n') ||
1270 ((in
+1 < datalen
) && (data
[in
] == '\r') &&
1271 (data
[in
+1] == '\n'))))
1274 /* Protect against whitespace on end of line */
1275 if (out
&& ((odata
[out
-1] == ' ') || (odata
[out
-1] == '\t'))) {
1278 to_hex(ch
, &odata
[out
]);
1282 if (crlf
) odata
[out
++] = '\r';
1283 odata
[out
++] = '\n';
1284 if (data
[in
] == '\r')
1290 if ((in
+ 1 != datalen
) &&
1291 (data
[in
+1] != '\n') &&
1292 (linelen
+ 1) >= MAXLINESIZE
) {
1294 if (crlf
) odata
[out
++] = '\r';
1295 odata
[out
++] = '\n';
1299 if (header
&& data
[in
] == ' ') {
1304 odata
[out
++] = data
[in
++];
1309 if ((rv
= PyBytes_FromStringAndSize((char *)odata
, out
)) == NULL
) {
1317 /* List of functions defined in the module */
1319 static struct PyMethodDef binascii_module_methods
[] = {
1320 {"a2b_uu", binascii_a2b_uu
, METH_VARARGS
, doc_a2b_uu
},
1321 {"b2a_uu", binascii_b2a_uu
, METH_VARARGS
, doc_b2a_uu
},
1322 {"a2b_base64", binascii_a2b_base64
, METH_VARARGS
, doc_a2b_base64
},
1323 {"b2a_base64", binascii_b2a_base64
, METH_VARARGS
, doc_b2a_base64
},
1324 {"a2b_hqx", binascii_a2b_hqx
, METH_VARARGS
, doc_a2b_hqx
},
1325 {"b2a_hqx", binascii_b2a_hqx
, METH_VARARGS
, doc_b2a_hqx
},
1326 {"b2a_hex", binascii_hexlify
, METH_VARARGS
, doc_hexlify
},
1327 {"a2b_hex", binascii_unhexlify
, METH_VARARGS
, doc_unhexlify
},
1328 {"hexlify", binascii_hexlify
, METH_VARARGS
, doc_hexlify
},
1329 {"unhexlify", binascii_unhexlify
, METH_VARARGS
, doc_unhexlify
},
1330 {"rlecode_hqx", binascii_rlecode_hqx
, METH_VARARGS
, doc_rlecode_hqx
},
1331 {"rledecode_hqx", binascii_rledecode_hqx
, METH_VARARGS
,
1333 {"crc_hqx", binascii_crc_hqx
, METH_VARARGS
, doc_crc_hqx
},
1334 {"crc32", binascii_crc32
, METH_VARARGS
, doc_crc32
},
1335 {"a2b_qp", (PyCFunction
)binascii_a2b_qp
, METH_VARARGS
| METH_KEYWORDS
,
1337 {"b2a_qp", (PyCFunction
)binascii_b2a_qp
, METH_VARARGS
| METH_KEYWORDS
,
1339 {NULL
, NULL
} /* sentinel */
1343 /* Initialization function for the module (*must* be called initbinascii) */
1344 PyDoc_STRVAR(doc_binascii
, "Conversion between binary data and ASCII");
1349 PyObject
*m
, *d
, *x
;
1351 /* Create the module and add the functions */
1352 m
= Py_InitModule("binascii", binascii_module_methods
);
1356 d
= PyModule_GetDict(m
);
1357 x
= PyBytes_FromString(doc_binascii
);
1358 PyDict_SetItemString(d
, "__doc__", x
);
1361 Error
= PyErr_NewException("binascii.Error", NULL
, NULL
);
1362 PyDict_SetItemString(d
, "Error", Error
);
1363 Incomplete
= PyErr_NewException("binascii.Incomplete", NULL
, NULL
);
1364 PyDict_SetItemString(d
, "Incomplete", Incomplete
);