Changeset 388 for python/vendor/current/Modules/binascii.c
- Timestamp:
- Mar 19, 2014, 11:11:30 AM (11 years ago)
- File:
-
- 1 edited
-
python/vendor/current/Modules/binascii.c (modified) (25 diffs)
Legend:
- Unmodified
- Added
- Removed
-
python/vendor/current/Modules/binascii.c
r2 r388 4 4 ** This module currently supports the following encodings: 5 5 ** uuencode: 6 ** 7 ** 8 ** 9 ** 10 ** 11 ** 12 ** 13 ** 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. 14 14 ** base64: 15 15 ** Line breaks are insignificant, but lines are at most 76 chars … … 18 18 ** Short binary data is filled (in ASCII) with '='. 19 19 ** hqx: 20 ** 21 ** 22 ** 23 ** 24 ** 25 ** 26 ** 27 ** 28 ** 29 ** 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 30 ** 31 31 ** While I was reading dozens of programs that encode or decode the formats 32 32 ** here (documentation? hihi:-) I have formulated Jansen's Observation: 33 33 ** 34 ** 35 ** 36 ** 37 ** 38 ** 39 ** 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 40 ** 41 41 ** I have attempted to break with this tradition, but I guess that that … … 76 76 static unsigned char table_a2b_hqx[256] = { 77 77 /* ^@ ^A ^B ^C ^D ^E ^F ^G */ 78 /* 0*/ 78 /* 0*/ FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, 79 79 /* \b \t \n ^K ^L \r ^N ^O */ 80 /* 1*/ 80 /* 1*/ FAIL, FAIL, SKIP, FAIL, FAIL, SKIP, FAIL, FAIL, 81 81 /* ^P ^Q ^R ^S ^T ^U ^V ^W */ 82 /* 2*/ 82 /* 2*/ FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, 83 83 /* ^X ^Y ^Z ^[ ^\ ^] ^^ ^_ */ 84 /* 3*/ 84 /* 3*/ FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, 85 85 /* ! " # $ % & ' */ 86 /* 4*/ 86 /* 4*/ FAIL, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 87 87 /* ( ) * + , - . / */ 88 /* 5*/ 88 /* 5*/ 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, FAIL, FAIL, 89 89 /* 0 1 2 3 4 5 6 7 */ 90 /* 6*/ 90 /* 6*/ 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12, 0x13, FAIL, 91 91 /* 8 9 : ; < = > ? */ 92 /* 7*/ 92 /* 7*/ 0x14, 0x15, DONE, FAIL, FAIL, FAIL, FAIL, FAIL, 93 93 /* @ A B C D E F G */ 94 /* 8*/ 94 /* 8*/ 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 95 95 /* H I J K L M N O */ 96 /* 9*/ 96 /* 9*/ 0x1E, 0x1F, 0x20, 0x21, 0x22, 0x23, 0x24, FAIL, 97 97 /* P Q R S T U V W */ 98 /*10*/ 98 /*10*/ 0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, FAIL, 99 99 /* X Y Z [ \ ] ^ _ */ 100 /*11*/ 100 /*11*/ 0x2C, 0x2D, 0x2E, 0x2F, FAIL, FAIL, FAIL, FAIL, 101 101 /* ` a b c d e f g */ 102 /*12*/ 102 /*12*/ 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, FAIL, 103 103 /* h i j k l m n o */ 104 /*13*/ 104 /*13*/ 0x37, 0x38, 0x39, 0x3A, 0x3B, 0x3C, FAIL, FAIL, 105 105 /* p q r s t u v w */ 106 /*14*/ 106 /*14*/ 0x3D, 0x3E, 0x3F, FAIL, FAIL, FAIL, FAIL, FAIL, 107 107 /* x y z { | } ~ ^? */ 108 /*15*/ 109 /*16*/ 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 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, 125 125 }; 126 126 … … 129 129 130 130 static char table_a2b_base64[] = { 131 132 133 134 135 136 137 138 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 139 139 }; 140 140 … … 150 150 151 151 static unsigned short crctab_hqx[256] = { 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 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, 184 184 }; 185 185 … … 189 189 binascii_a2b_uu(PyObject *self, PyObject *args) 190 190 { 191 unsigned char *ascii_data, *bin_data; 192 int leftbits = 0; 193 unsigned char this_ch; 194 unsigned int leftchar = 0; 195 PyObject *rv; 196 Py_ssize_t ascii_len, bin_len; 197 198 if ( !PyArg_ParseTuple(args, "t#:a2b_uu", &ascii_data, &ascii_len) ) 199 return NULL; 200 201 assert(ascii_len >= 0); 202 203 /* First byte: binary data length (in bytes) */ 204 bin_len = (*ascii_data++ - ' ') & 077; 205 ascii_len--; 206 207 /* Allocate the buffer */ 208 if ( (rv=PyString_FromStringAndSize(NULL, bin_len)) == NULL ) 209 return NULL; 210 bin_data = (unsigned char *)PyString_AsString(rv); 211 212 for( ; bin_len > 0 ; ascii_len--, ascii_data++ ) { 213 /* XXX is it really best to add NULs if there's no more data */ 214 this_ch = (ascii_len > 0) ? *ascii_data : 0; 215 if ( this_ch == '\n' || this_ch == '\r' || ascii_len <= 0) { 216 /* 217 ** Whitespace. Assume some spaces got eaten at 218 ** end-of-line. (We check this later) 219 */ 220 this_ch = 0; 221 } else { 222 /* Check the character for legality 223 ** The 64 in stead of the expected 63 is because 224 ** there are a few uuencodes out there that use 225 ** '`' as zero instead of space. 226 */ 227 if ( this_ch < ' ' || this_ch > (' ' + 64)) { 228 PyErr_SetString(Error, "Illegal char"); 229 Py_DECREF(rv); 230 return NULL; 231 } 232 this_ch = (this_ch - ' ') & 077; 233 } 234 /* 235 ** Shift it in on the low end, and see if there's 236 ** a byte ready for output. 237 */ 238 leftchar = (leftchar << 6) | (this_ch); 239 leftbits += 6; 240 if ( leftbits >= 8 ) { 241 leftbits -= 8; 242 *bin_data++ = (leftchar >> leftbits) & 0xff; 243 leftchar &= ((1 << leftbits) - 1); 244 bin_len--; 245 } 246 } 247 /* 248 ** Finally, check that if there's anything left on the line 249 ** that it's whitespace only. 250 */ 251 while( ascii_len-- > 0 ) { 252 this_ch = *ascii_data++; 253 /* Extra '`' may be written as padding in some cases */ 254 if ( this_ch != ' ' && this_ch != ' '+64 && 255 this_ch != '\n' && this_ch != '\r' ) { 256 PyErr_SetString(Error, "Trailing garbage"); 257 Py_DECREF(rv); 258 return NULL; 259 } 260 } 261 return rv; 191 Py_buffer pascii; 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 Py_ssize_t ascii_len, bin_len; 198 199 if ( !PyArg_ParseTuple(args, "s*:a2b_uu", &pascii) ) 200 return NULL; 201 ascii_data = pascii.buf; 202 ascii_len = pascii.len; 203 204 assert(ascii_len >= 0); 205 206 /* First byte: binary data length (in bytes) */ 207 bin_len = (*ascii_data++ - ' ') & 077; 208 ascii_len--; 209 210 /* Allocate the buffer */ 211 if ( (rv=PyString_FromStringAndSize(NULL, bin_len)) == NULL ) { 212 PyBuffer_Release(&pascii); 213 return NULL; 214 } 215 bin_data = (unsigned char *)PyString_AS_STRING(rv); 216 217 for( ; bin_len > 0 ; ascii_len--, ascii_data++ ) { 218 /* XXX is it really best to add NULs if there's no more data */ 219 this_ch = (ascii_len > 0) ? *ascii_data : 0; 220 if ( this_ch == '\n' || this_ch == '\r' || ascii_len <= 0) { 221 /* 222 ** Whitespace. Assume some spaces got eaten at 223 ** end-of-line. (We check this later) 224 */ 225 this_ch = 0; 226 } else { 227 /* Check the character for legality 228 ** The 64 in stead of the expected 63 is because 229 ** there are a few uuencodes out there that use 230 ** '`' as zero instead of space. 231 */ 232 if ( this_ch < ' ' || this_ch > (' ' + 64)) { 233 PyErr_SetString(Error, "Illegal char"); 234 PyBuffer_Release(&pascii); 235 Py_DECREF(rv); 236 return NULL; 237 } 238 this_ch = (this_ch - ' ') & 077; 239 } 240 /* 241 ** Shift it in on the low end, and see if there's 242 ** a byte ready for output. 243 */ 244 leftchar = (leftchar << 6) | (this_ch); 245 leftbits += 6; 246 if ( leftbits >= 8 ) { 247 leftbits -= 8; 248 *bin_data++ = (leftchar >> leftbits) & 0xff; 249 leftchar &= ((1 << leftbits) - 1); 250 bin_len--; 251 } 252 } 253 /* 254 ** Finally, check that if there's anything left on the line 255 ** that it's whitespace only. 256 */ 257 while( ascii_len-- > 0 ) { 258 this_ch = *ascii_data++; 259 /* Extra '`' may be written as padding in some cases */ 260 if ( this_ch != ' ' && this_ch != ' '+64 && 261 this_ch != '\n' && this_ch != '\r' ) { 262 PyErr_SetString(Error, "Trailing garbage"); 263 PyBuffer_Release(&pascii); 264 Py_DECREF(rv); 265 return NULL; 266 } 267 } 268 PyBuffer_Release(&pascii); 269 return rv; 262 270 } 263 271 … … 267 275 binascii_b2a_uu(PyObject *self, PyObject *args) 268 276 { 269 unsigned char *ascii_data, *bin_data; 270 int leftbits = 0; 271 unsigned char this_ch; 272 unsigned int leftchar = 0; 273 PyObject *rv; 274 Py_ssize_t bin_len; 275 276 if ( !PyArg_ParseTuple(args, "s#:b2a_uu", &bin_data, &bin_len) ) 277 return NULL; 278 if ( bin_len > 45 ) { 279 /* The 45 is a limit that appears in all uuencode's */ 280 PyErr_SetString(Error, "At most 45 bytes at once"); 281 return NULL; 282 } 283 284 /* We're lazy and allocate to much (fixed up later) */ 285 if ( (rv=PyString_FromStringAndSize(NULL, 2 + (bin_len+2)/3*4)) == NULL ) 286 return NULL; 287 ascii_data = (unsigned char *)PyString_AsString(rv); 288 289 /* Store the length */ 290 *ascii_data++ = ' ' + (bin_len & 077); 291 292 for( ; bin_len > 0 || leftbits != 0 ; bin_len--, bin_data++ ) { 293 /* Shift the data (or padding) into our buffer */ 294 if ( bin_len > 0 ) /* Data */ 295 leftchar = (leftchar << 8) | *bin_data; 296 else /* Padding */ 297 leftchar <<= 8; 298 leftbits += 8; 299 300 /* See if there are 6-bit groups ready */ 301 while ( leftbits >= 6 ) { 302 this_ch = (leftchar >> (leftbits-6)) & 0x3f; 303 leftbits -= 6; 304 *ascii_data++ = this_ch + ' '; 305 } 306 } 307 *ascii_data++ = '\n'; /* Append a courtesy newline */ 308 309 _PyString_Resize(&rv, (ascii_data - 310 (unsigned char *)PyString_AsString(rv))); 311 return rv; 277 Py_buffer pbin; 278 unsigned char *ascii_data, *bin_data; 279 int leftbits = 0; 280 unsigned char this_ch; 281 unsigned int leftchar = 0; 282 PyObject *rv; 283 Py_ssize_t bin_len; 284 285 if ( !PyArg_ParseTuple(args, "s*:b2a_uu", &pbin) ) 286 return NULL; 287 bin_data = pbin.buf; 288 bin_len = pbin.len; 289 if ( bin_len > 45 ) { 290 /* The 45 is a limit that appears in all uuencode's */ 291 PyErr_SetString(Error, "At most 45 bytes at once"); 292 PyBuffer_Release(&pbin); 293 return NULL; 294 } 295 296 /* We're lazy and allocate to much (fixed up later) */ 297 if ( (rv=PyString_FromStringAndSize(NULL, 2 + (bin_len+2)/3*4)) == NULL ) { 298 PyBuffer_Release(&pbin); 299 return NULL; 300 } 301 ascii_data = (unsigned char *)PyString_AS_STRING(rv); 302 303 /* Store the length */ 304 *ascii_data++ = ' ' + (bin_len & 077); 305 306 for( ; bin_len > 0 || leftbits != 0 ; bin_len--, bin_data++ ) { 307 /* Shift the data (or padding) into our buffer */ 308 if ( bin_len > 0 ) /* Data */ 309 leftchar = (leftchar << 8) | *bin_data; 310 else /* Padding */ 311 leftchar <<= 8; 312 leftbits += 8; 313 314 /* See if there are 6-bit groups ready */ 315 while ( leftbits >= 6 ) { 316 this_ch = (leftchar >> (leftbits-6)) & 0x3f; 317 leftbits -= 6; 318 *ascii_data++ = this_ch + ' '; 319 } 320 } 321 *ascii_data++ = '\n'; /* Append a courtesy newline */ 322 323 if (_PyString_Resize(&rv, 324 (ascii_data - 325 (unsigned char *)PyString_AS_STRING(rv))) < 0) { 326 Py_DECREF(rv); 327 rv = NULL; 328 } 329 PyBuffer_Release(&pbin); 330 return rv; 312 331 } 313 332 … … 316 335 binascii_find_valid(unsigned char *s, Py_ssize_t slen, int num) 317 336 { 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 337 /* Finds & returns the (num+1)th 338 ** valid character for base64, or -1 if none. 339 */ 340 341 int ret = -1; 342 unsigned char c, b64val; 343 344 while ((slen > 0) && (ret == -1)) { 345 c = *s; 346 b64val = table_a2b_base64[c & 0x7f]; 347 if ( ((c <= 0x7f) && (b64val != (unsigned char)-1)) ) { 348 if (num == 0) 349 ret = *s; 350 num--; 351 } 352 353 s++; 354 slen--; 355 } 356 return ret; 338 357 } 339 358 … … 343 362 binascii_a2b_base64(PyObject *self, PyObject *args) 344 363 { 345 unsigned char *ascii_data, *bin_data; 346 int leftbits = 0; 347 unsigned char this_ch; 348 unsigned int leftchar = 0; 349 PyObject *rv; 350 Py_ssize_t ascii_len, bin_len; 351 int quad_pos = 0; 352 353 if ( !PyArg_ParseTuple(args, "t#:a2b_base64", &ascii_data, &ascii_len) ) 354 return NULL; 355 356 assert(ascii_len >= 0); 357 358 if (ascii_len > PY_SSIZE_T_MAX - 3) 359 return PyErr_NoMemory(); 360 361 bin_len = ((ascii_len+3)/4)*3; /* Upper bound, corrected later */ 362 363 /* Allocate the buffer */ 364 if ( (rv=PyString_FromStringAndSize(NULL, bin_len)) == NULL ) 365 return NULL; 366 bin_data = (unsigned char *)PyString_AsString(rv); 367 bin_len = 0; 368 369 for( ; ascii_len > 0; ascii_len--, ascii_data++) { 370 this_ch = *ascii_data; 371 372 if (this_ch > 0x7f || 373 this_ch == '\r' || this_ch == '\n' || this_ch == ' ') 374 continue; 375 376 /* Check for pad sequences and ignore 377 ** the invalid ones. 378 */ 379 if (this_ch == BASE64_PAD) { 380 if ( (quad_pos < 2) || 381 ((quad_pos == 2) && 382 (binascii_find_valid(ascii_data, ascii_len, 1) 383 != BASE64_PAD)) ) 384 { 385 continue; 386 } 387 else { 388 /* A pad sequence means no more input. 389 ** We've already interpreted the data 390 ** from the quad at this point. 391 */ 392 leftbits = 0; 393 break; 394 } 395 } 396 397 this_ch = table_a2b_base64[*ascii_data]; 398 if ( this_ch == (unsigned char) -1 ) 399 continue; 400 401 /* 402 ** Shift it in on the low end, and see if there's 403 ** a byte ready for output. 404 */ 405 quad_pos = (quad_pos + 1) & 0x03; 406 leftchar = (leftchar << 6) | (this_ch); 407 leftbits += 6; 408 409 if ( leftbits >= 8 ) { 410 leftbits -= 8; 411 *bin_data++ = (leftchar >> leftbits) & 0xff; 412 bin_len++; 413 leftchar &= ((1 << leftbits) - 1); 414 } 415 } 416 417 if (leftbits != 0) { 418 PyErr_SetString(Error, "Incorrect padding"); 419 Py_DECREF(rv); 420 return NULL; 421 } 422 423 /* And set string size correctly. If the result string is empty 424 ** (because the input was all invalid) return the shared empty 425 ** string instead; _PyString_Resize() won't do this for us. 426 */ 427 if (bin_len > 0) 428 _PyString_Resize(&rv, bin_len); 429 else { 430 Py_DECREF(rv); 431 rv = PyString_FromString(""); 432 } 433 return rv; 364 Py_buffer pascii; 365 unsigned char *ascii_data, *bin_data; 366 int leftbits = 0; 367 unsigned char this_ch; 368 unsigned int leftchar = 0; 369 PyObject *rv; 370 Py_ssize_t ascii_len, bin_len; 371 int quad_pos = 0; 372 373 if ( !PyArg_ParseTuple(args, "s*:a2b_base64", &pascii) ) 374 return NULL; 375 ascii_data = pascii.buf; 376 ascii_len = pascii.len; 377 378 assert(ascii_len >= 0); 379 380 if (ascii_len > PY_SSIZE_T_MAX - 3) { 381 PyBuffer_Release(&pascii); 382 return PyErr_NoMemory(); 383 } 384 385 bin_len = ((ascii_len+3)/4)*3; /* Upper bound, corrected later */ 386 387 /* Allocate the buffer */ 388 if ( (rv=PyString_FromStringAndSize(NULL, bin_len)) == NULL ) { 389 PyBuffer_Release(&pascii); 390 return NULL; 391 } 392 bin_data = (unsigned char *)PyString_AS_STRING(rv); 393 bin_len = 0; 394 395 for( ; ascii_len > 0; ascii_len--, ascii_data++) { 396 this_ch = *ascii_data; 397 398 if (this_ch > 0x7f || 399 this_ch == '\r' || this_ch == '\n' || this_ch == ' ') 400 continue; 401 402 /* Check for pad sequences and ignore 403 ** the invalid ones. 404 */ 405 if (this_ch == BASE64_PAD) { 406 if ( (quad_pos < 2) || 407 ((quad_pos == 2) && 408 (binascii_find_valid(ascii_data, ascii_len, 1) 409 != BASE64_PAD)) ) 410 { 411 continue; 412 } 413 else { 414 /* A pad sequence means no more input. 415 ** We've already interpreted the data 416 ** from the quad at this point. 417 */ 418 leftbits = 0; 419 break; 420 } 421 } 422 423 this_ch = table_a2b_base64[*ascii_data]; 424 if ( this_ch == (unsigned char) -1 ) 425 continue; 426 427 /* 428 ** Shift it in on the low end, and see if there's 429 ** a byte ready for output. 430 */ 431 quad_pos = (quad_pos + 1) & 0x03; 432 leftchar = (leftchar << 6) | (this_ch); 433 leftbits += 6; 434 435 if ( leftbits >= 8 ) { 436 leftbits -= 8; 437 *bin_data++ = (leftchar >> leftbits) & 0xff; 438 bin_len++; 439 leftchar &= ((1 << leftbits) - 1); 440 } 441 } 442 443 if (leftbits != 0) { 444 PyBuffer_Release(&pascii); 445 PyErr_SetString(Error, "Incorrect padding"); 446 Py_DECREF(rv); 447 return NULL; 448 } 449 450 /* And set string size correctly. If the result string is empty 451 ** (because the input was all invalid) return the shared empty 452 ** string instead; _PyString_Resize() won't do this for us. 453 */ 454 if (bin_len > 0) { 455 if (_PyString_Resize(&rv, bin_len) < 0) { 456 Py_DECREF(rv); 457 rv = NULL; 458 } 459 } 460 else { 461 Py_DECREF(rv); 462 rv = PyString_FromStringAndSize("", 0); 463 } 464 PyBuffer_Release(&pascii); 465 return rv; 434 466 } 435 467 … … 439 471 binascii_b2a_base64(PyObject *self, PyObject *args) 440 472 { 441 unsigned char *ascii_data, *bin_data; 442 int leftbits = 0; 443 unsigned char this_ch; 444 unsigned int leftchar = 0; 445 PyObject *rv; 446 Py_ssize_t bin_len; 447 448 if ( !PyArg_ParseTuple(args, "s#:b2a_base64", &bin_data, &bin_len) ) 449 return NULL; 450 451 assert(bin_len >= 0); 452 453 if ( bin_len > BASE64_MAXBIN ) { 454 PyErr_SetString(Error, "Too much data for base64 line"); 455 return NULL; 456 } 457 458 /* We're lazy and allocate too much (fixed up later). 459 "+3" leaves room for up to two pad characters and a trailing 460 newline. Note that 'b' gets encoded as 'Yg==\n' (1 in, 5 out). */ 461 if ( (rv=PyString_FromStringAndSize(NULL, bin_len*2 + 3)) == NULL ) 462 return NULL; 463 ascii_data = (unsigned char *)PyString_AsString(rv); 464 465 for( ; bin_len > 0 ; bin_len--, bin_data++ ) { 466 /* Shift the data into our buffer */ 467 leftchar = (leftchar << 8) | *bin_data; 468 leftbits += 8; 469 470 /* See if there are 6-bit groups ready */ 471 while ( leftbits >= 6 ) { 472 this_ch = (leftchar >> (leftbits-6)) & 0x3f; 473 leftbits -= 6; 474 *ascii_data++ = table_b2a_base64[this_ch]; 475 } 476 } 477 if ( leftbits == 2 ) { 478 *ascii_data++ = table_b2a_base64[(leftchar&3) << 4]; 479 *ascii_data++ = BASE64_PAD; 480 *ascii_data++ = BASE64_PAD; 481 } else if ( leftbits == 4 ) { 482 *ascii_data++ = table_b2a_base64[(leftchar&0xf) << 2]; 483 *ascii_data++ = BASE64_PAD; 484 } 485 *ascii_data++ = '\n'; /* Append a courtesy newline */ 486 487 _PyString_Resize(&rv, (ascii_data - 488 (unsigned char *)PyString_AsString(rv))); 489 return rv; 473 Py_buffer pbuf; 474 unsigned char *ascii_data, *bin_data; 475 int leftbits = 0; 476 unsigned char this_ch; 477 unsigned int leftchar = 0; 478 PyObject *rv; 479 Py_ssize_t bin_len; 480 481 if ( !PyArg_ParseTuple(args, "s*:b2a_base64", &pbuf) ) 482 return NULL; 483 bin_data = pbuf.buf; 484 bin_len = pbuf.len; 485 486 assert(bin_len >= 0); 487 488 if ( bin_len > BASE64_MAXBIN ) { 489 PyErr_SetString(Error, "Too much data for base64 line"); 490 PyBuffer_Release(&pbuf); 491 return NULL; 492 } 493 494 /* We're lazy and allocate too much (fixed up later). 495 "+3" leaves room for up to two pad characters and a trailing 496 newline. Note that 'b' gets encoded as 'Yg==\n' (1 in, 5 out). */ 497 if ( (rv=PyString_FromStringAndSize(NULL, bin_len*2 + 3)) == NULL ) { 498 PyBuffer_Release(&pbuf); 499 return NULL; 500 } 501 ascii_data = (unsigned char *)PyString_AS_STRING(rv); 502 503 for( ; bin_len > 0 ; bin_len--, bin_data++ ) { 504 /* Shift the data into our buffer */ 505 leftchar = (leftchar << 8) | *bin_data; 506 leftbits += 8; 507 508 /* See if there are 6-bit groups ready */ 509 while ( leftbits >= 6 ) { 510 this_ch = (leftchar >> (leftbits-6)) & 0x3f; 511 leftbits -= 6; 512 *ascii_data++ = table_b2a_base64[this_ch]; 513 } 514 } 515 if ( leftbits == 2 ) { 516 *ascii_data++ = table_b2a_base64[(leftchar&3) << 4]; 517 *ascii_data++ = BASE64_PAD; 518 *ascii_data++ = BASE64_PAD; 519 } else if ( leftbits == 4 ) { 520 *ascii_data++ = table_b2a_base64[(leftchar&0xf) << 2]; 521 *ascii_data++ = BASE64_PAD; 522 } 523 *ascii_data++ = '\n'; /* Append a courtesy newline */ 524 525 if (_PyString_Resize(&rv, 526 (ascii_data - 527 (unsigned char *)PyString_AS_STRING(rv))) < 0) { 528 Py_DECREF(rv); 529 rv = NULL; 530 } 531 PyBuffer_Release(&pbuf); 532 return rv; 490 533 } 491 534 … … 495 538 binascii_a2b_hqx(PyObject *self, PyObject *args) 496 539 { 497 unsigned char *ascii_data, *bin_data; 498 int leftbits = 0; 499 unsigned char this_ch; 500 unsigned int leftchar = 0; 501 PyObject *rv; 502 Py_ssize_t len; 503 int done = 0; 504 505 if ( !PyArg_ParseTuple(args, "t#:a2b_hqx", &ascii_data, &len) ) 506 return NULL; 507 508 assert(len >= 0); 509 510 if (len > PY_SSIZE_T_MAX - 2) 511 return PyErr_NoMemory(); 512 513 /* Allocate a string that is too big (fixed later) 514 Add two to the initial length to prevent interning which 515 would preclude subsequent resizing. */ 516 if ( (rv=PyString_FromStringAndSize(NULL, len+2)) == NULL ) 517 return NULL; 518 bin_data = (unsigned char *)PyString_AsString(rv); 519 520 for( ; len > 0 ; len--, ascii_data++ ) { 521 /* Get the byte and look it up */ 522 this_ch = table_a2b_hqx[*ascii_data]; 523 if ( this_ch == SKIP ) 524 continue; 525 if ( this_ch == FAIL ) { 526 PyErr_SetString(Error, "Illegal char"); 527 Py_DECREF(rv); 528 return NULL; 529 } 530 if ( this_ch == DONE ) { 531 /* The terminating colon */ 532 done = 1; 533 break; 534 } 535 536 /* Shift it into the buffer and see if any bytes are ready */ 537 leftchar = (leftchar << 6) | (this_ch); 538 leftbits += 6; 539 if ( leftbits >= 8 ) { 540 leftbits -= 8; 541 *bin_data++ = (leftchar >> leftbits) & 0xff; 542 leftchar &= ((1 << leftbits) - 1); 543 } 544 } 545 546 if ( leftbits && !done ) { 547 PyErr_SetString(Incomplete, 548 "String has incomplete number of bytes"); 549 Py_DECREF(rv); 550 return NULL; 551 } 552 _PyString_Resize( 553 &rv, (bin_data - (unsigned char *)PyString_AsString(rv))); 554 if (rv) { 555 PyObject *rrv = Py_BuildValue("Oi", rv, done); 556 Py_DECREF(rv); 557 return rrv; 558 } 559 560 return NULL; 540 Py_buffer pascii; 541 unsigned char *ascii_data, *bin_data; 542 int leftbits = 0; 543 unsigned char this_ch; 544 unsigned int leftchar = 0; 545 PyObject *rv; 546 Py_ssize_t len; 547 int done = 0; 548 549 if ( !PyArg_ParseTuple(args, "s*:a2b_hqx", &pascii) ) 550 return NULL; 551 ascii_data = pascii.buf; 552 len = pascii.len; 553 554 assert(len >= 0); 555 556 if (len > PY_SSIZE_T_MAX - 2) { 557 PyBuffer_Release(&pascii); 558 return PyErr_NoMemory(); 559 } 560 561 /* Allocate a string that is too big (fixed later) 562 Add two to the initial length to prevent interning which 563 would preclude subsequent resizing. */ 564 if ( (rv=PyString_FromStringAndSize(NULL, len+2)) == NULL ) { 565 PyBuffer_Release(&pascii); 566 return NULL; 567 } 568 bin_data = (unsigned char *)PyString_AS_STRING(rv); 569 570 for( ; len > 0 ; len--, ascii_data++ ) { 571 /* Get the byte and look it up */ 572 this_ch = table_a2b_hqx[*ascii_data]; 573 if ( this_ch == SKIP ) 574 continue; 575 if ( this_ch == FAIL ) { 576 PyErr_SetString(Error, "Illegal char"); 577 PyBuffer_Release(&pascii); 578 Py_DECREF(rv); 579 return NULL; 580 } 581 if ( this_ch == DONE ) { 582 /* The terminating colon */ 583 done = 1; 584 break; 585 } 586 587 /* Shift it into the buffer and see if any bytes are ready */ 588 leftchar = (leftchar << 6) | (this_ch); 589 leftbits += 6; 590 if ( leftbits >= 8 ) { 591 leftbits -= 8; 592 *bin_data++ = (leftchar >> leftbits) & 0xff; 593 leftchar &= ((1 << leftbits) - 1); 594 } 595 } 596 597 if ( leftbits && !done ) { 598 PyErr_SetString(Incomplete, 599 "String has incomplete number of bytes"); 600 PyBuffer_Release(&pascii); 601 Py_DECREF(rv); 602 return NULL; 603 } 604 if (_PyString_Resize(&rv, 605 (bin_data - 606 (unsigned char *)PyString_AS_STRING(rv))) < 0) { 607 Py_DECREF(rv); 608 rv = NULL; 609 } 610 if (rv) { 611 PyObject *rrv = Py_BuildValue("Oi", rv, done); 612 PyBuffer_Release(&pascii); 613 Py_DECREF(rv); 614 return rrv; 615 } 616 617 PyBuffer_Release(&pascii); 618 return NULL; 561 619 } 562 620 … … 566 624 binascii_rlecode_hqx(PyObject *self, PyObject *args) 567 625 { 568 unsigned char *in_data, *out_data; 569 PyObject *rv; 570 unsigned char ch; 571 Py_ssize_t in, inend, len; 572 573 if ( !PyArg_ParseTuple(args, "s#:rlecode_hqx", &in_data, &len) ) 574 return NULL; 575 576 assert(len >= 0); 577 578 if (len > PY_SSIZE_T_MAX / 2 - 2) 579 return PyErr_NoMemory(); 580 581 /* Worst case: output is twice as big as input (fixed later) */ 582 if ( (rv=PyString_FromStringAndSize(NULL, len*2+2)) == NULL ) 583 return NULL; 584 out_data = (unsigned char *)PyString_AsString(rv); 585 586 for( in=0; in<len; in++) { 587 ch = in_data[in]; 588 if ( ch == RUNCHAR ) { 589 /* RUNCHAR. Escape it. */ 590 *out_data++ = RUNCHAR; 591 *out_data++ = 0; 592 } else { 593 /* Check how many following are the same */ 594 for(inend=in+1; 595 inend<len && in_data[inend] == ch && 596 inend < in+255; 597 inend++) ; 598 if ( inend - in > 3 ) { 599 /* More than 3 in a row. Output RLE. */ 600 *out_data++ = ch; 601 *out_data++ = RUNCHAR; 602 *out_data++ = inend-in; 603 in = inend-1; 604 } else { 605 /* Less than 3. Output the byte itself */ 606 *out_data++ = ch; 607 } 608 } 609 } 610 _PyString_Resize(&rv, (out_data - 611 (unsigned char *)PyString_AsString(rv))); 612 return rv; 626 Py_buffer pbuf; 627 unsigned char *in_data, *out_data; 628 PyObject *rv; 629 unsigned char ch; 630 Py_ssize_t in, inend, len; 631 632 if ( !PyArg_ParseTuple(args, "s*:rlecode_hqx", &pbuf) ) 633 return NULL; 634 in_data = pbuf.buf; 635 len = pbuf.len; 636 637 assert(len >= 0); 638 639 if (len > PY_SSIZE_T_MAX / 2 - 2) { 640 PyBuffer_Release(&pbuf); 641 return PyErr_NoMemory(); 642 } 643 644 /* Worst case: output is twice as big as input (fixed later) */ 645 if ( (rv=PyString_FromStringAndSize(NULL, len*2+2)) == NULL ) { 646 PyBuffer_Release(&pbuf); 647 return NULL; 648 } 649 out_data = (unsigned char *)PyString_AS_STRING(rv); 650 651 for( in=0; in<len; in++) { 652 ch = in_data[in]; 653 if ( ch == RUNCHAR ) { 654 /* RUNCHAR. Escape it. */ 655 *out_data++ = RUNCHAR; 656 *out_data++ = 0; 657 } else { 658 /* Check how many following are the same */ 659 for(inend=in+1; 660 inend<len && in_data[inend] == ch && 661 inend < in+255; 662 inend++) ; 663 if ( inend - in > 3 ) { 664 /* More than 3 in a row. Output RLE. */ 665 *out_data++ = ch; 666 *out_data++ = RUNCHAR; 667 *out_data++ = inend-in; 668 in = inend-1; 669 } else { 670 /* Less than 3. Output the byte itself */ 671 *out_data++ = ch; 672 } 673 } 674 } 675 if (_PyString_Resize(&rv, 676 (out_data - 677 (unsigned char *)PyString_AS_STRING(rv))) < 0) { 678 Py_DECREF(rv); 679 rv = NULL; 680 } 681 PyBuffer_Release(&pbuf); 682 return rv; 613 683 } 614 684 … … 618 688 binascii_b2a_hqx(PyObject *self, PyObject *args) 619 689 { 620 unsigned char *ascii_data, *bin_data; 621 int leftbits = 0; 622 unsigned char this_ch; 623 unsigned int leftchar = 0; 624 PyObject *rv; 625 Py_ssize_t len; 626 627 if ( !PyArg_ParseTuple(args, "s#:b2a_hqx", &bin_data, &len) ) 628 return NULL; 629 630 assert(len >= 0); 631 632 if (len > PY_SSIZE_T_MAX / 2 - 2) 633 return PyErr_NoMemory(); 634 635 /* Allocate a buffer that is at least large enough */ 636 if ( (rv=PyString_FromStringAndSize(NULL, len*2+2)) == NULL ) 637 return NULL; 638 ascii_data = (unsigned char *)PyString_AsString(rv); 639 640 for( ; len > 0 ; len--, bin_data++ ) { 641 /* Shift into our buffer, and output any 6bits ready */ 642 leftchar = (leftchar << 8) | *bin_data; 643 leftbits += 8; 644 while ( leftbits >= 6 ) { 645 this_ch = (leftchar >> (leftbits-6)) & 0x3f; 646 leftbits -= 6; 647 *ascii_data++ = table_b2a_hqx[this_ch]; 648 } 649 } 650 /* Output a possible runt byte */ 651 if ( leftbits ) { 652 leftchar <<= (6-leftbits); 653 *ascii_data++ = table_b2a_hqx[leftchar & 0x3f]; 654 } 655 _PyString_Resize(&rv, (ascii_data - 656 (unsigned char *)PyString_AsString(rv))); 657 return rv; 690 Py_buffer pbin; 691 unsigned char *ascii_data, *bin_data; 692 int leftbits = 0; 693 unsigned char this_ch; 694 unsigned int leftchar = 0; 695 PyObject *rv; 696 Py_ssize_t len; 697 698 if ( !PyArg_ParseTuple(args, "s*:b2a_hqx", &pbin) ) 699 return NULL; 700 bin_data = pbin.buf; 701 len = pbin.len; 702 703 assert(len >= 0); 704 705 if (len > PY_SSIZE_T_MAX / 2 - 2) { 706 PyBuffer_Release(&pbin); 707 return PyErr_NoMemory(); 708 } 709 710 /* Allocate a buffer that is at least large enough */ 711 if ( (rv=PyString_FromStringAndSize(NULL, len*2+2)) == NULL ) { 712 PyBuffer_Release(&pbin); 713 return NULL; 714 } 715 ascii_data = (unsigned char *)PyString_AS_STRING(rv); 716 717 for( ; len > 0 ; len--, bin_data++ ) { 718 /* Shift into our buffer, and output any 6bits ready */ 719 leftchar = (leftchar << 8) | *bin_data; 720 leftbits += 8; 721 while ( leftbits >= 6 ) { 722 this_ch = (leftchar >> (leftbits-6)) & 0x3f; 723 leftbits -= 6; 724 *ascii_data++ = table_b2a_hqx[this_ch]; 725 } 726 } 727 /* Output a possible runt byte */ 728 if ( leftbits ) { 729 leftchar <<= (6-leftbits); 730 *ascii_data++ = table_b2a_hqx[leftchar & 0x3f]; 731 } 732 if (_PyString_Resize(&rv, 733 (ascii_data - 734 (unsigned char *)PyString_AS_STRING(rv))) < 0) { 735 Py_DECREF(rv); 736 rv = NULL; 737 } 738 PyBuffer_Release(&pbin); 739 return rv; 658 740 } 659 741 … … 663 745 binascii_rledecode_hqx(PyObject *self, PyObject *args) 664 746 { 665 unsigned char *in_data, *out_data; 666 unsigned char in_byte, in_repeat; 667 PyObject *rv; 668 Py_ssize_t in_len, out_len, out_len_left; 669 670 if ( !PyArg_ParseTuple(args, "s#:rledecode_hqx", &in_data, &in_len) ) 671 return NULL; 672 673 assert(in_len >= 0); 674 675 /* Empty string is a special case */ 676 if ( in_len == 0 ) 677 return PyString_FromString(""); 678 else if (in_len > PY_SSIZE_T_MAX / 2) 747 Py_buffer pin; 748 unsigned char *in_data, *out_data; 749 unsigned char in_byte, in_repeat; 750 PyObject *rv; 751 Py_ssize_t in_len, out_len, out_len_left; 752 753 if ( !PyArg_ParseTuple(args, "s*:rledecode_hqx", &pin) ) 754 return NULL; 755 in_data = pin.buf; 756 in_len = pin.len; 757 758 assert(in_len >= 0); 759 760 /* Empty string is a special case */ 761 if ( in_len == 0 ) { 762 PyBuffer_Release(&pin); 763 return PyString_FromStringAndSize("", 0); 764 } 765 else if (in_len > PY_SSIZE_T_MAX / 2) { 766 PyBuffer_Release(&pin); 679 767 return PyErr_NoMemory(); 680 681 /* Allocate a buffer of reasonable size. Resized when needed */ 682 out_len = in_len*2; 683 if ( (rv=PyString_FromStringAndSize(NULL, out_len)) == NULL ) 684 return NULL; 685 out_len_left = out_len; 686 out_data = (unsigned char *)PyString_AsString(rv); 687 688 /* 689 ** We need two macros here to get/put bytes and handle 690 ** end-of-buffer for input and output strings. 691 */ 768 } 769 770 /* Allocate a buffer of reasonable size. Resized when needed */ 771 out_len = in_len*2; 772 if ( (rv=PyString_FromStringAndSize(NULL, out_len)) == NULL ) { 773 PyBuffer_Release(&pin); 774 return NULL; 775 } 776 out_len_left = out_len; 777 out_data = (unsigned char *)PyString_AS_STRING(rv); 778 779 /* 780 ** We need two macros here to get/put bytes and handle 781 ** end-of-buffer for input and output strings. 782 */ 692 783 #define INBYTE(b) \ 693 do { \ 694 if ( --in_len < 0 ) { \ 695 PyErr_SetString(Incomplete, ""); \ 696 Py_DECREF(rv); \ 697 return NULL; \ 698 } \ 699 b = *in_data++; \ 700 } while(0) 784 do { \ 785 if ( --in_len < 0 ) { \ 786 PyErr_SetString(Incomplete, ""); \ 787 Py_DECREF(rv); \ 788 PyBuffer_Release(&pin); \ 789 return NULL; \ 790 } \ 791 b = *in_data++; \ 792 } while(0) 701 793 702 794 #define OUTBYTE(b) \ 703 do { \ 704 if ( --out_len_left < 0 ) { \ 705 if ( out_len > PY_SSIZE_T_MAX / 2) return PyErr_NoMemory(); \ 706 _PyString_Resize(&rv, 2*out_len); \ 707 if ( rv == NULL ) return NULL; \ 708 out_data = (unsigned char *)PyString_AsString(rv) \ 709 + out_len; \ 710 out_len_left = out_len-1; \ 711 out_len = out_len * 2; \ 712 } \ 713 *out_data++ = b; \ 714 } while(0) 715 716 /* 717 ** Handle first byte separately (since we have to get angry 718 ** in case of an orphaned RLE code). 719 */ 720 INBYTE(in_byte); 721 722 if (in_byte == RUNCHAR) { 723 INBYTE(in_repeat); 724 if (in_repeat != 0) { 725 /* Note Error, not Incomplete (which is at the end 726 ** of the string only). This is a programmer error. 727 */ 728 PyErr_SetString(Error, "Orphaned RLE code at start"); 729 Py_DECREF(rv); 730 return NULL; 731 } 732 OUTBYTE(RUNCHAR); 733 } else { 734 OUTBYTE(in_byte); 735 } 736 737 while( in_len > 0 ) { 738 INBYTE(in_byte); 739 740 if (in_byte == RUNCHAR) { 741 INBYTE(in_repeat); 742 if ( in_repeat == 0 ) { 743 /* Just an escaped RUNCHAR value */ 744 OUTBYTE(RUNCHAR); 745 } else { 746 /* Pick up value and output a sequence of it */ 747 in_byte = out_data[-1]; 748 while ( --in_repeat > 0 ) 749 OUTBYTE(in_byte); 750 } 751 } else { 752 /* Normal byte */ 753 OUTBYTE(in_byte); 754 } 755 } 756 _PyString_Resize(&rv, (out_data - 757 (unsigned char *)PyString_AsString(rv))); 758 return rv; 795 do { \ 796 if ( --out_len_left < 0 ) { \ 797 if ( out_len > PY_SSIZE_T_MAX / 2) return PyErr_NoMemory(); \ 798 if (_PyString_Resize(&rv, 2*out_len) < 0) \ 799 { Py_DECREF(rv); PyBuffer_Release(&pin); return NULL; } \ 800 out_data = (unsigned char *)PyString_AS_STRING(rv) \ 801 + out_len; \ 802 out_len_left = out_len-1; \ 803 out_len = out_len * 2; \ 804 } \ 805 *out_data++ = b; \ 806 } while(0) 807 808 /* 809 ** Handle first byte separately (since we have to get angry 810 ** in case of an orphaned RLE code). 811 */ 812 INBYTE(in_byte); 813 814 if (in_byte == RUNCHAR) { 815 INBYTE(in_repeat); 816 if (in_repeat != 0) { 817 /* Note Error, not Incomplete (which is at the end 818 ** of the string only). This is a programmer error. 819 */ 820 PyErr_SetString(Error, "Orphaned RLE code at start"); 821 PyBuffer_Release(&pin); 822 Py_DECREF(rv); 823 return NULL; 824 } 825 OUTBYTE(RUNCHAR); 826 } else { 827 OUTBYTE(in_byte); 828 } 829 830 while( in_len > 0 ) { 831 INBYTE(in_byte); 832 833 if (in_byte == RUNCHAR) { 834 INBYTE(in_repeat); 835 if ( in_repeat == 0 ) { 836 /* Just an escaped RUNCHAR value */ 837 OUTBYTE(RUNCHAR); 838 } else { 839 /* Pick up value and output a sequence of it */ 840 in_byte = out_data[-1]; 841 while ( --in_repeat > 0 ) 842 OUTBYTE(in_byte); 843 } 844 } else { 845 /* Normal byte */ 846 OUTBYTE(in_byte); 847 } 848 } 849 if (_PyString_Resize(&rv, 850 (out_data - 851 (unsigned char *)PyString_AS_STRING(rv))) < 0) { 852 Py_DECREF(rv); 853 rv = NULL; 854 } 855 PyBuffer_Release(&pin); 856 return rv; 759 857 } 760 858 … … 765 863 binascii_crc_hqx(PyObject *self, PyObject *args) 766 864 { 767 unsigned char *bin_data; 768 unsigned int crc; 769 Py_ssize_t len; 770 771 if ( !PyArg_ParseTuple(args, "s#i:crc_hqx", &bin_data, &len, &crc) ) 772 return NULL; 773 774 while(len-- > 0) { 775 crc=((crc<<8)&0xff00)^crctab_hqx[((crc>>8)&0xff)^*bin_data++]; 776 } 777 778 return Py_BuildValue("i", crc); 865 Py_buffer pin; 866 unsigned char *bin_data; 867 unsigned int crc; 868 Py_ssize_t len; 869 870 if ( !PyArg_ParseTuple(args, "s*i:crc_hqx", &pin, &crc) ) 871 return NULL; 872 bin_data = pin.buf; 873 len = pin.len; 874 875 while(len-- > 0) { 876 crc=((crc<<8)&0xff00)^crctab_hqx[((crc>>8)&0xff)^*bin_data++]; 877 } 878 879 PyBuffer_Release(&pin); 880 return Py_BuildValue("i", crc); 779 881 } 780 882 … … 788 890 { 789 891 unsigned int crc32val = 0; /* crc32(0L, Z_NULL, 0) */ 892 Py_buffer pbuf; 790 893 Byte *buf; 791 894 Py_ssize_t len; 792 895 int signed_val; 793 896 794 if (!PyArg_ParseTuple(args, "s #|I:crc32", &buf, &len, &crc32val))795 897 if (!PyArg_ParseTuple(args, "s*|I:crc32", &pbuf, &crc32val)) 898 return NULL; 796 899 /* In Python 2.x we return a signed integer regardless of native platform 797 900 * long size (the 32bit unsigned long is treated as 32-bit signed and sign 798 901 * extended into a 64-bit long inside the integer object). 3.0 does the 799 902 * right thing and returns unsigned. http://bugs.python.org/issue1202 */ 903 buf = (Byte*)pbuf.buf; 904 len = pbuf.len; 800 905 signed_val = crc32(crc32val, buf, len); 906 PyBuffer_Release(&pbuf); 801 907 return PyInt_FromLong(signed_val); 802 908 } … … 923 1029 binascii_crc32(PyObject *self, PyObject *args) 924 1030 { /* By Jim Ahlstrom; All rights transferred to CNRI */ 925 unsigned char *bin_data; 926 unsigned int crc = 0U; /* initial value of CRC */ 927 Py_ssize_t len; 928 int result; 929 930 if ( !PyArg_ParseTuple(args, "s#|I:crc32", &bin_data, &len, &crc) ) 931 return NULL; 932 933 crc = ~ crc; 934 while (len-- > 0) 935 crc = crc_32_tab[(crc ^ *bin_data++) & 0xffU] ^ (crc >> 8); 936 /* Note: (crc >> 8) MUST zero fill on left */ 937 938 result = (int)(crc ^ 0xFFFFFFFFU); 939 return PyInt_FromLong(result); 1031 Py_buffer pbin; 1032 unsigned char *bin_data; 1033 unsigned int crc = 0U; /* initial value of CRC */ 1034 Py_ssize_t len; 1035 int result; 1036 1037 if ( !PyArg_ParseTuple(args, "s*|I:crc32", &pbin, &crc) ) 1038 return NULL; 1039 bin_data = pbin.buf; 1040 len = pbin.len; 1041 1042 crc = ~ crc; 1043 while (len-- > 0) 1044 crc = crc_32_tab[(crc ^ *bin_data++) & 0xffU] ^ (crc >> 8); 1045 /* Note: (crc >> 8) MUST zero fill on left */ 1046 1047 result = (int)(crc ^ 0xFFFFFFFFU); 1048 PyBuffer_Release(&pbin); 1049 return PyInt_FromLong(result); 940 1050 } 941 1051 #endif /* USE_ZLIB_CRC32 */ … … 945 1055 binascii_hexlify(PyObject *self, PyObject *args) 946 1056 { 947 char* argbuf; 948 Py_ssize_t arglen; 949 PyObject *retval; 950 char* retbuf; 951 Py_ssize_t i, j; 952 953 if (!PyArg_ParseTuple(args, "s#:b2a_hex", &argbuf, &arglen)) 954 return NULL; 955 956 assert(arglen >= 0); 957 if (arglen > PY_SSIZE_T_MAX / 2) 958 return PyErr_NoMemory(); 959 960 retval = PyString_FromStringAndSize(NULL, arglen*2); 961 if (!retval) 962 return NULL; 963 retbuf = PyString_AsString(retval); 964 if (!retbuf) 965 goto finally; 966 967 /* make hex version of string, taken from shamodule.c */ 968 for (i=j=0; i < arglen; i++) { 969 char c; 970 c = (argbuf[i] >> 4) & 0xf; 971 c = (c>9) ? c+'a'-10 : c + '0'; 972 retbuf[j++] = c; 973 c = argbuf[i] & 0xf; 974 c = (c>9) ? c+'a'-10 : c + '0'; 975 retbuf[j++] = c; 976 } 977 return retval; 978 979 finally: 980 Py_DECREF(retval); 981 return NULL; 1057 Py_buffer parg; 1058 char* argbuf; 1059 Py_ssize_t arglen; 1060 PyObject *retval; 1061 char* retbuf; 1062 Py_ssize_t i, j; 1063 1064 if (!PyArg_ParseTuple(args, "s*:b2a_hex", &parg)) 1065 return NULL; 1066 argbuf = parg.buf; 1067 arglen = parg.len; 1068 1069 assert(arglen >= 0); 1070 if (arglen > PY_SSIZE_T_MAX / 2) { 1071 PyBuffer_Release(&parg); 1072 return PyErr_NoMemory(); 1073 } 1074 1075 retval = PyString_FromStringAndSize(NULL, arglen*2); 1076 if (!retval) { 1077 PyBuffer_Release(&parg); 1078 return NULL; 1079 } 1080 retbuf = PyString_AS_STRING(retval); 1081 1082 /* make hex version of string, taken from shamodule.c */ 1083 for (i=j=0; i < arglen; i++) { 1084 char c; 1085 c = (argbuf[i] >> 4) & 0xf; 1086 c = (c>9) ? c+'a'-10 : c + '0'; 1087 retbuf[j++] = c; 1088 c = argbuf[i] & 0xf; 1089 c = (c>9) ? c+'a'-10 : c + '0'; 1090 retbuf[j++] = c; 1091 } 1092 PyBuffer_Release(&parg); 1093 return retval; 982 1094 } 983 1095 … … 991 1103 to_int(int c) 992 1104 { 993 994 995 996 if (isupper(c))997 c = tolower(c);998 999 1000 1001 1105 if (isdigit(c)) 1106 return c - '0'; 1107 else { 1108 if (Py_ISUPPER(c)) 1109 c = Py_TOLOWER(c); 1110 if (c >= 'a' && c <= 'f') 1111 return c - 'a' + 10; 1112 } 1113 return -1; 1002 1114 } 1003 1115 … … 1006 1118 binascii_unhexlify(PyObject *self, PyObject *args) 1007 1119 { 1008 char* argbuf; 1009 Py_ssize_t arglen; 1010 PyObject *retval; 1011 char* retbuf; 1012 Py_ssize_t i, j; 1013 1014 if (!PyArg_ParseTuple(args, "s#:a2b_hex", &argbuf, &arglen)) 1015 return NULL; 1016 1017 assert(arglen >= 0); 1018 1019 /* XXX What should we do about strings with an odd length? Should 1020 * we add an implicit leading zero, or a trailing zero? For now, 1021 * raise an exception. 1022 */ 1023 if (arglen % 2) { 1024 PyErr_SetString(PyExc_TypeError, "Odd-length string"); 1025 return NULL; 1026 } 1027 1028 retval = PyString_FromStringAndSize(NULL, (arglen/2)); 1029 if (!retval) 1030 return NULL; 1031 retbuf = PyString_AsString(retval); 1032 if (!retbuf) 1033 goto finally; 1034 1035 for (i=j=0; i < arglen; i += 2) { 1036 int top = to_int(Py_CHARMASK(argbuf[i])); 1037 int bot = to_int(Py_CHARMASK(argbuf[i+1])); 1038 if (top == -1 || bot == -1) { 1039 PyErr_SetString(PyExc_TypeError, 1040 "Non-hexadecimal digit found"); 1041 goto finally; 1042 } 1043 retbuf[j++] = (top << 4) + bot; 1044 } 1045 return retval; 1120 Py_buffer parg; 1121 char* argbuf; 1122 Py_ssize_t arglen; 1123 PyObject *retval; 1124 char* retbuf; 1125 Py_ssize_t i, j; 1126 1127 if (!PyArg_ParseTuple(args, "s*:a2b_hex", &parg)) 1128 return NULL; 1129 argbuf = parg.buf; 1130 arglen = parg.len; 1131 1132 assert(arglen >= 0); 1133 1134 /* XXX What should we do about strings with an odd length? Should 1135 * we add an implicit leading zero, or a trailing zero? For now, 1136 * raise an exception. 1137 */ 1138 if (arglen % 2) { 1139 PyBuffer_Release(&parg); 1140 PyErr_SetString(PyExc_TypeError, "Odd-length string"); 1141 return NULL; 1142 } 1143 1144 retval = PyString_FromStringAndSize(NULL, (arglen/2)); 1145 if (!retval) { 1146 PyBuffer_Release(&parg); 1147 return NULL; 1148 } 1149 retbuf = PyString_AS_STRING(retval); 1150 1151 for (i=j=0; i < arglen; i += 2) { 1152 int top = to_int(Py_CHARMASK(argbuf[i])); 1153 int bot = to_int(Py_CHARMASK(argbuf[i+1])); 1154 if (top == -1 || bot == -1) { 1155 PyErr_SetString(PyExc_TypeError, 1156 "Non-hexadecimal digit found"); 1157 goto finally; 1158 } 1159 retbuf[j++] = (top << 4) + bot; 1160 } 1161 PyBuffer_Release(&parg); 1162 return retval; 1046 1163 1047 1164 finally: 1048 Py_DECREF(retval); 1049 return NULL; 1165 PyBuffer_Release(&parg); 1166 Py_DECREF(retval); 1167 return NULL; 1050 1168 } 1051 1169 … … 1076 1194 binascii_a2b_qp(PyObject *self, PyObject *args, PyObject *kwargs) 1077 1195 { 1078 Py_ssize_t in, out; 1079 char ch; 1080 unsigned char *data, *odata; 1081 Py_ssize_t datalen = 0; 1082 PyObject *rv; 1083 static char *kwlist[] = {"data", "header", NULL}; 1084 int header = 0; 1085 1086 if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s#|i", kwlist, &data, 1087 &datalen, &header)) 1088 return NULL; 1089 1090 /* We allocate the output same size as input, this is overkill. 1091 * The previous implementation used calloc() so we'll zero out the 1092 * memory here too, since PyMem_Malloc() does not guarantee that. 1093 */ 1094 odata = (unsigned char *) PyMem_Malloc(datalen); 1095 if (odata == NULL) { 1096 PyErr_NoMemory(); 1097 return NULL; 1098 } 1099 memset(odata, 0, datalen); 1100 1101 in = out = 0; 1102 while (in < datalen) { 1103 if (data[in] == '=') { 1104 in++; 1105 if (in >= datalen) break; 1106 /* Soft line breaks */ 1107 if ((data[in] == '\n') || (data[in] == '\r')) { 1108 if (data[in] != '\n') { 1109 while (in < datalen && data[in] != '\n') in++; 1110 } 1111 if (in < datalen) in++; 1112 } 1113 else if (data[in] == '=') { 1114 /* broken case from broken python qp */ 1115 odata[out++] = '='; 1116 in++; 1117 } 1118 else if (((data[in] >= 'A' && data[in] <= 'F') || 1119 (data[in] >= 'a' && data[in] <= 'f') || 1120 (data[in] >= '0' && data[in] <= '9')) && 1121 ((data[in+1] >= 'A' && data[in+1] <= 'F') || 1122 (data[in+1] >= 'a' && data[in+1] <= 'f') || 1123 (data[in+1] >= '0' && data[in+1] <= '9'))) { 1124 /* hexval */ 1125 ch = hexval(data[in]) << 4; 1126 in++; 1127 ch |= hexval(data[in]); 1128 in++; 1129 odata[out++] = ch; 1130 } 1131 else { 1132 odata[out++] = '='; 1133 } 1134 } 1135 else if (header && data[in] == '_') { 1136 odata[out++] = ' '; 1137 in++; 1138 } 1139 else { 1140 odata[out] = data[in]; 1141 in++; 1142 out++; 1143 } 1144 } 1145 if ((rv = PyString_FromStringAndSize((char *)odata, out)) == NULL) { 1146 PyMem_Free(odata); 1147 return NULL; 1148 } 1149 PyMem_Free(odata); 1150 return rv; 1196 Py_ssize_t in, out; 1197 char ch; 1198 Py_buffer pdata; 1199 unsigned char *data, *odata; 1200 Py_ssize_t datalen = 0; 1201 PyObject *rv; 1202 static char *kwlist[] = {"data", "header", NULL}; 1203 int header = 0; 1204 1205 if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s*|i", kwlist, &pdata, 1206 &header)) 1207 return NULL; 1208 data = pdata.buf; 1209 datalen = pdata.len; 1210 1211 /* We allocate the output same size as input, this is overkill. 1212 * The previous implementation used calloc() so we'll zero out the 1213 * memory here too, since PyMem_Malloc() does not guarantee that. 1214 */ 1215 odata = (unsigned char *) PyMem_Malloc(datalen); 1216 if (odata == NULL) { 1217 PyBuffer_Release(&pdata); 1218 PyErr_NoMemory(); 1219 return NULL; 1220 } 1221 memset(odata, 0, datalen); 1222 1223 in = out = 0; 1224 while (in < datalen) { 1225 if (data[in] == '=') { 1226 in++; 1227 if (in >= datalen) break; 1228 /* Soft line breaks */ 1229 if ((data[in] == '\n') || (data[in] == '\r')) { 1230 if (data[in] != '\n') { 1231 while (in < datalen && data[in] != '\n') in++; 1232 } 1233 if (in < datalen) in++; 1234 } 1235 else if (data[in] == '=') { 1236 /* broken case from broken python qp */ 1237 odata[out++] = '='; 1238 in++; 1239 } 1240 else if (((data[in] >= 'A' && data[in] <= 'F') || 1241 (data[in] >= 'a' && data[in] <= 'f') || 1242 (data[in] >= '0' && data[in] <= '9')) && 1243 ((data[in+1] >= 'A' && data[in+1] <= 'F') || 1244 (data[in+1] >= 'a' && data[in+1] <= 'f') || 1245 (data[in+1] >= '0' && data[in+1] <= '9'))) { 1246 /* hexval */ 1247 ch = hexval(data[in]) << 4; 1248 in++; 1249 ch |= hexval(data[in]); 1250 in++; 1251 odata[out++] = ch; 1252 } 1253 else { 1254 odata[out++] = '='; 1255 } 1256 } 1257 else if (header && data[in] == '_') { 1258 odata[out++] = ' '; 1259 in++; 1260 } 1261 else { 1262 odata[out] = data[in]; 1263 in++; 1264 out++; 1265 } 1266 } 1267 if ((rv = PyString_FromStringAndSize((char *)odata, out)) == NULL) { 1268 PyBuffer_Release(&pdata); 1269 PyMem_Free(odata); 1270 return NULL; 1271 } 1272 PyBuffer_Release(&pdata); 1273 PyMem_Free(odata); 1274 return rv; 1151 1275 } 1152 1276 … … 1154 1278 to_hex (unsigned char ch, unsigned char *s) 1155 1279 { 1156 1157 1158 1159 1160 1161 1280 unsigned int uvalue = ch; 1281 1282 s[1] = "0123456789ABCDEF"[uvalue % 16]; 1283 uvalue = (uvalue / 16); 1284 s[0] = "0123456789ABCDEF"[uvalue % 16]; 1285 return 0; 1162 1286 } 1163 1287 … … 1176 1300 binascii_b2a_qp (PyObject *self, PyObject *args, PyObject *kwargs) 1177 1301 { 1178 Py_ssize_t in, out; 1179 unsigned char *data, *odata; 1180 Py_ssize_t datalen = 0, odatalen = 0; 1181 PyObject *rv; 1182 unsigned int linelen = 0; 1183 static char *kwlist[] = {"data", "quotetabs", "istext", 1184 "header", NULL}; 1185 int istext = 1; 1186 int quotetabs = 0; 1187 int header = 0; 1188 unsigned char ch; 1189 int crlf = 0; 1190 unsigned char *p; 1191 1192 if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s#|iii", kwlist, &data, 1193 &datalen, "etabs, &istext, &header)) 1194 return NULL; 1195 1196 /* See if this string is using CRLF line ends */ 1197 /* XXX: this function has the side effect of converting all of 1198 * the end of lines to be the same depending on this detection 1199 * here */ 1200 p = (unsigned char *) memchr(data, '\n', datalen); 1201 if ((p != NULL) && (p > data) && (*(p-1) == '\r')) 1202 crlf = 1; 1203 1204 /* First, scan to see how many characters need to be encoded */ 1205 in = 0; 1206 while (in < datalen) { 1207 if ((data[in] > 126) || 1208 (data[in] == '=') || 1209 (header && data[in] == '_') || 1210 ((data[in] == '.') && (linelen == 0) && 1211 (data[in+1] == '\n' || data[in+1] == '\r' || data[in+1] == 0)) || 1212 (!istext && ((data[in] == '\r') || (data[in] == '\n'))) || 1213 ((data[in] == '\t' || data[in] == ' ') && (in + 1 == datalen)) || 1214 ((data[in] < 33) && 1215 (data[in] != '\r') && (data[in] != '\n') && 1216 (quotetabs || 1217 (!quotetabs && ((data[in] != '\t') && (data[in] != ' ')))))) 1218 { 1219 if ((linelen + 3) >= MAXLINESIZE) { 1220 linelen = 0; 1221 if (crlf) 1222 odatalen += 3; 1223 else 1224 odatalen += 2; 1225 } 1226 linelen += 3; 1227 odatalen += 3; 1228 in++; 1229 } 1230 else { 1231 if (istext && 1232 ((data[in] == '\n') || 1233 ((in+1 < datalen) && (data[in] == '\r') && 1234 (data[in+1] == '\n')))) 1235 { 1236 linelen = 0; 1237 /* Protect against whitespace on end of line */ 1238 if (in && ((data[in-1] == ' ') || (data[in-1] == '\t'))) 1239 odatalen += 2; 1240 if (crlf) 1241 odatalen += 2; 1242 else 1243 odatalen += 1; 1244 if (data[in] == '\r') 1245 in += 2; 1246 else 1247 in++; 1248 } 1249 else { 1250 if ((in + 1 != datalen) && 1251 (data[in+1] != '\n') && 1252 (linelen + 1) >= MAXLINESIZE) { 1253 linelen = 0; 1254 if (crlf) 1255 odatalen += 3; 1256 else 1257 odatalen += 2; 1258 } 1259 linelen++; 1260 odatalen++; 1261 in++; 1262 } 1263 } 1264 } 1265 1266 /* We allocate the output same size as input, this is overkill. 1267 * The previous implementation used calloc() so we'll zero out the 1268 * memory here too, since PyMem_Malloc() does not guarantee that. 1269 */ 1270 odata = (unsigned char *) PyMem_Malloc(odatalen); 1271 if (odata == NULL) { 1272 PyErr_NoMemory(); 1273 return NULL; 1274 } 1275 memset(odata, 0, odatalen); 1276 1277 in = out = linelen = 0; 1278 while (in < datalen) { 1279 if ((data[in] > 126) || 1280 (data[in] == '=') || 1281 (header && data[in] == '_') || 1282 ((data[in] == '.') && (linelen == 0) && 1283 (data[in+1] == '\n' || data[in+1] == '\r' || data[in+1] == 0)) || 1284 (!istext && ((data[in] == '\r') || (data[in] == '\n'))) || 1285 ((data[in] == '\t' || data[in] == ' ') && (in + 1 == datalen)) || 1286 ((data[in] < 33) && 1287 (data[in] != '\r') && (data[in] != '\n') && 1288 (quotetabs || 1289 (!quotetabs && ((data[in] != '\t') && (data[in] != ' ')))))) 1290 { 1291 if ((linelen + 3 )>= MAXLINESIZE) { 1292 odata[out++] = '='; 1293 if (crlf) odata[out++] = '\r'; 1294 odata[out++] = '\n'; 1295 linelen = 0; 1296 } 1297 odata[out++] = '='; 1298 to_hex(data[in], &odata[out]); 1299 out += 2; 1300 in++; 1301 linelen += 3; 1302 } 1303 else { 1304 if (istext && 1305 ((data[in] == '\n') || 1306 ((in+1 < datalen) && (data[in] == '\r') && 1307 (data[in+1] == '\n')))) 1308 { 1309 linelen = 0; 1310 /* Protect against whitespace on end of line */ 1311 if (out && ((odata[out-1] == ' ') || (odata[out-1] == '\t'))) { 1312 ch = odata[out-1]; 1313 odata[out-1] = '='; 1314 to_hex(ch, &odata[out]); 1315 out += 2; 1316 } 1317 1318 if (crlf) odata[out++] = '\r'; 1319 odata[out++] = '\n'; 1320 if (data[in] == '\r') 1321 in += 2; 1322 else 1323 in++; 1324 } 1325 else { 1326 if ((in + 1 != datalen) && 1327 (data[in+1] != '\n') && 1328 (linelen + 1) >= MAXLINESIZE) { 1329 odata[out++] = '='; 1330 if (crlf) odata[out++] = '\r'; 1331 odata[out++] = '\n'; 1332 linelen = 0; 1333 } 1334 linelen++; 1335 if (header && data[in] == ' ') { 1336 odata[out++] = '_'; 1337 in++; 1338 } 1339 else { 1340 odata[out++] = data[in++]; 1341 } 1342 } 1343 } 1344 } 1345 if ((rv = PyString_FromStringAndSize((char *)odata, out)) == NULL) { 1346 PyMem_Free(odata); 1347 return NULL; 1348 } 1349 PyMem_Free(odata); 1350 return rv; 1302 Py_ssize_t in, out; 1303 Py_buffer pdata; 1304 unsigned char *data, *odata; 1305 Py_ssize_t datalen = 0, odatalen = 0; 1306 PyObject *rv; 1307 unsigned int linelen = 0; 1308 static char *kwlist[] = {"data", "quotetabs", "istext", 1309 "header", NULL}; 1310 int istext = 1; 1311 int quotetabs = 0; 1312 int header = 0; 1313 unsigned char ch; 1314 int crlf = 0; 1315 unsigned char *p; 1316 1317 if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s*|iii", kwlist, &pdata, 1318 "etabs, &istext, &header)) 1319 return NULL; 1320 data = pdata.buf; 1321 datalen = pdata.len; 1322 1323 /* See if this string is using CRLF line ends */ 1324 /* XXX: this function has the side effect of converting all of 1325 * the end of lines to be the same depending on this detection 1326 * here */ 1327 p = (unsigned char *) memchr(data, '\n', datalen); 1328 if ((p != NULL) && (p > data) && (*(p-1) == '\r')) 1329 crlf = 1; 1330 1331 /* First, scan to see how many characters need to be encoded */ 1332 in = 0; 1333 while (in < datalen) { 1334 if ((data[in] > 126) || 1335 (data[in] == '=') || 1336 (header && data[in] == '_') || 1337 ((data[in] == '.') && (linelen == 0) && 1338 (data[in+1] == '\n' || data[in+1] == '\r' || data[in+1] == 0)) || 1339 (!istext && ((data[in] == '\r') || (data[in] == '\n'))) || 1340 ((data[in] == '\t' || data[in] == ' ') && (in + 1 == datalen)) || 1341 ((data[in] < 33) && 1342 (data[in] != '\r') && (data[in] != '\n') && 1343 (quotetabs || 1344 (!quotetabs && ((data[in] != '\t') && (data[in] != ' ')))))) 1345 { 1346 if ((linelen + 3) >= MAXLINESIZE) { 1347 linelen = 0; 1348 if (crlf) 1349 odatalen += 3; 1350 else 1351 odatalen += 2; 1352 } 1353 linelen += 3; 1354 odatalen += 3; 1355 in++; 1356 } 1357 else { 1358 if (istext && 1359 ((data[in] == '\n') || 1360 ((in+1 < datalen) && (data[in] == '\r') && 1361 (data[in+1] == '\n')))) 1362 { 1363 linelen = 0; 1364 /* Protect against whitespace on end of line */ 1365 if (in && ((data[in-1] == ' ') || (data[in-1] == '\t'))) 1366 odatalen += 2; 1367 if (crlf) 1368 odatalen += 2; 1369 else 1370 odatalen += 1; 1371 if (data[in] == '\r') 1372 in += 2; 1373 else 1374 in++; 1375 } 1376 else { 1377 if ((in + 1 != datalen) && 1378 (data[in+1] != '\n') && 1379 (linelen + 1) >= MAXLINESIZE) { 1380 linelen = 0; 1381 if (crlf) 1382 odatalen += 3; 1383 else 1384 odatalen += 2; 1385 } 1386 linelen++; 1387 odatalen++; 1388 in++; 1389 } 1390 } 1391 } 1392 1393 /* We allocate the output same size as input, this is overkill. 1394 * The previous implementation used calloc() so we'll zero out the 1395 * memory here too, since PyMem_Malloc() does not guarantee that. 1396 */ 1397 odata = (unsigned char *) PyMem_Malloc(odatalen); 1398 if (odata == NULL) { 1399 PyBuffer_Release(&pdata); 1400 PyErr_NoMemory(); 1401 return NULL; 1402 } 1403 memset(odata, 0, odatalen); 1404 1405 in = out = linelen = 0; 1406 while (in < datalen) { 1407 if ((data[in] > 126) || 1408 (data[in] == '=') || 1409 (header && data[in] == '_') || 1410 ((data[in] == '.') && (linelen == 0) && 1411 (data[in+1] == '\n' || data[in+1] == '\r' || data[in+1] == 0)) || 1412 (!istext && ((data[in] == '\r') || (data[in] == '\n'))) || 1413 ((data[in] == '\t' || data[in] == ' ') && (in + 1 == datalen)) || 1414 ((data[in] < 33) && 1415 (data[in] != '\r') && (data[in] != '\n') && 1416 (quotetabs || 1417 (!quotetabs && ((data[in] != '\t') && (data[in] != ' ')))))) 1418 { 1419 if ((linelen + 3 )>= MAXLINESIZE) { 1420 odata[out++] = '='; 1421 if (crlf) odata[out++] = '\r'; 1422 odata[out++] = '\n'; 1423 linelen = 0; 1424 } 1425 odata[out++] = '='; 1426 to_hex(data[in], &odata[out]); 1427 out += 2; 1428 in++; 1429 linelen += 3; 1430 } 1431 else { 1432 if (istext && 1433 ((data[in] == '\n') || 1434 ((in+1 < datalen) && (data[in] == '\r') && 1435 (data[in+1] == '\n')))) 1436 { 1437 linelen = 0; 1438 /* Protect against whitespace on end of line */ 1439 if (out && ((odata[out-1] == ' ') || (odata[out-1] == '\t'))) { 1440 ch = odata[out-1]; 1441 odata[out-1] = '='; 1442 to_hex(ch, &odata[out]); 1443 out += 2; 1444 } 1445 1446 if (crlf) odata[out++] = '\r'; 1447 odata[out++] = '\n'; 1448 if (data[in] == '\r') 1449 in += 2; 1450 else 1451 in++; 1452 } 1453 else { 1454 if ((in + 1 != datalen) && 1455 (data[in+1] != '\n') && 1456 (linelen + 1) >= MAXLINESIZE) { 1457 odata[out++] = '='; 1458 if (crlf) odata[out++] = '\r'; 1459 odata[out++] = '\n'; 1460 linelen = 0; 1461 } 1462 linelen++; 1463 if (header && data[in] == ' ') { 1464 odata[out++] = '_'; 1465 in++; 1466 } 1467 else { 1468 odata[out++] = data[in++]; 1469 } 1470 } 1471 } 1472 } 1473 if ((rv = PyString_FromStringAndSize((char *)odata, out)) == NULL) { 1474 PyBuffer_Release(&pdata); 1475 PyMem_Free(odata); 1476 return NULL; 1477 } 1478 PyBuffer_Release(&pdata); 1479 PyMem_Free(odata); 1480 return rv; 1351 1481 } 1352 1482 … … 1354 1484 1355 1485 static struct PyMethodDef binascii_module_methods[] = { 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 {NULL, NULL}/* sentinel */1486 {"a2b_uu", binascii_a2b_uu, METH_VARARGS, doc_a2b_uu}, 1487 {"b2a_uu", binascii_b2a_uu, METH_VARARGS, doc_b2a_uu}, 1488 {"a2b_base64", binascii_a2b_base64, METH_VARARGS, doc_a2b_base64}, 1489 {"b2a_base64", binascii_b2a_base64, METH_VARARGS, doc_b2a_base64}, 1490 {"a2b_hqx", binascii_a2b_hqx, METH_VARARGS, doc_a2b_hqx}, 1491 {"b2a_hqx", binascii_b2a_hqx, METH_VARARGS, doc_b2a_hqx}, 1492 {"b2a_hex", binascii_hexlify, METH_VARARGS, doc_hexlify}, 1493 {"a2b_hex", binascii_unhexlify, METH_VARARGS, doc_unhexlify}, 1494 {"hexlify", binascii_hexlify, METH_VARARGS, doc_hexlify}, 1495 {"unhexlify", binascii_unhexlify, METH_VARARGS, doc_unhexlify}, 1496 {"rlecode_hqx", binascii_rlecode_hqx, METH_VARARGS, doc_rlecode_hqx}, 1497 {"rledecode_hqx", binascii_rledecode_hqx, METH_VARARGS, 1498 doc_rledecode_hqx}, 1499 {"crc_hqx", binascii_crc_hqx, METH_VARARGS, doc_crc_hqx}, 1500 {"crc32", binascii_crc32, METH_VARARGS, doc_crc32}, 1501 {"a2b_qp", (PyCFunction)binascii_a2b_qp, METH_VARARGS | METH_KEYWORDS, 1502 doc_a2b_qp}, 1503 {"b2a_qp", (PyCFunction)binascii_b2a_qp, METH_VARARGS | METH_KEYWORDS, 1504 doc_b2a_qp}, 1505 {NULL, NULL} /* sentinel */ 1376 1506 }; 1377 1507 … … 1383 1513 initbinascii(void) 1384 1514 { 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 } 1515 PyObject *m, *d, *x; 1516 1517 /* Create the module and add the functions */ 1518 m = Py_InitModule("binascii", binascii_module_methods); 1519 if (m == NULL) 1520 return; 1521 1522 d = PyModule_GetDict(m); 1523 x = PyString_FromString(doc_binascii); 1524 PyDict_SetItemString(d, "__doc__", x); 1525 Py_XDECREF(x); 1526 1527 Error = PyErr_NewException("binascii.Error", NULL, NULL); 1528 PyDict_SetItemString(d, "Error", Error); 1529 Incomplete = PyErr_NewException("binascii.Incomplete", NULL, NULL); 1530 PyDict_SetItemString(d, "Incomplete", Incomplete); 1531 }
Note:
See TracChangeset
for help on using the changeset viewer.
