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