Back to index

python3.2  3.2.2
Defines | Functions | Variables
binascii.c File Reference
#include "Python.h"

Go to the source code of this file.

Defines

#define PY_SSIZE_T_CLEAN
#define RUNCHAR   0x90
#define DONE   0x7F
#define SKIP   0x7E
#define FAIL   0x7D
#define BASE64_PAD   '='
#define BASE64_MAXBIN   ((PY_SSIZE_T_MAX - 3) / 2)
#define INBYTE(b)
#define OUTBYTE(b)
#define hexval(c)   table_hex[(unsigned int)(c)]
#define MAXLINESIZE   76

Functions

 PyDoc_STRVAR (doc_a2b_uu,"(ascii) -> bin. Decode a line of uuencoded data")
static PyObjectbinascii_a2b_uu (PyObject *self, PyObject *args)
 PyDoc_STRVAR (doc_b2a_uu,"(bin) -> ascii. Uuencode line of data")
static PyObjectbinascii_b2a_uu (PyObject *self, PyObject *args)
static int binascii_find_valid (unsigned char *s, Py_ssize_t slen, int num)
 PyDoc_STRVAR (doc_a2b_base64,"(ascii) -> bin. Decode a line of base64 data")
static PyObjectbinascii_a2b_base64 (PyObject *self, PyObject *args)
 PyDoc_STRVAR (doc_b2a_base64,"(bin) -> ascii. Base64-code line of data")
static PyObjectbinascii_b2a_base64 (PyObject *self, PyObject *args)
 PyDoc_STRVAR (doc_a2b_hqx,"ascii -> bin, done. Decode .hqx coding")
static PyObjectbinascii_a2b_hqx (PyObject *self, PyObject *args)
 PyDoc_STRVAR (doc_rlecode_hqx,"Binhex RLE-code binary data")
static PyObjectbinascii_rlecode_hqx (PyObject *self, PyObject *args)
 PyDoc_STRVAR (doc_b2a_hqx,"Encode .hqx data")
static PyObjectbinascii_b2a_hqx (PyObject *self, PyObject *args)
 PyDoc_STRVAR (doc_rledecode_hqx,"Decode hexbin RLE-coded string")
static PyObjectbinascii_rledecode_hqx (PyObject *self, PyObject *args)
 PyDoc_STRVAR (doc_crc_hqx,"(data, oldcrc) -> newcrc. Compute hqx CRC incrementally")
static PyObjectbinascii_crc_hqx (PyObject *self, PyObject *args)
 PyDoc_STRVAR (doc_crc32,"(data, oldcrc = 0) -> newcrc. Compute CRC-32 incrementally")
static PyObjectbinascii_crc32 (PyObject *self, PyObject *args)
static PyObjectbinascii_hexlify (PyObject *self, PyObject *args)
 PyDoc_STRVAR (doc_hexlify,"b2a_hex(data) -> s; Hexadecimal representation of binary data.\n\ \n\ This function is also available as \"hexlify()\".")
static int to_int (int c)
static PyObjectbinascii_unhexlify (PyObject *self, PyObject *args)
 PyDoc_STRVAR (doc_unhexlify,"a2b_hex(hexstr) -> s; Binary data of hexadecimal representation.\n\ \n\ hexstr must contain an even number of hex digits (upper or lower case).\n\ This function is also available as \"unhexlify()\"")
 PyDoc_STRVAR (doc_a2b_qp,"Decode a string of qp-encoded data")
static PyObjectbinascii_a2b_qp (PyObject *self, PyObject *args, PyObject *kwargs)
static int to_hex (unsigned char ch, unsigned char *s)
 PyDoc_STRVAR (doc_b2a_qp,"b2a_qp(data, quotetabs=0, istext=1, header=0) -> s; \n\ Encode a string using quoted-printable encoding. \n\ \n\ On encoding, when istext is set, newlines are not encoded, and white \n\ space at end of lines is. When istext is not set, \\r and \\n (CR/LF) are \n\ both encoded. When quotetabs is set, space and tabs are encoded.")
static PyObjectbinascii_b2a_qp (PyObject *self, PyObject *args, PyObject *kwargs)
 PyDoc_STRVAR (doc_binascii,"Conversion between binary data and ASCII")
PyMODINIT_FUNC PyInit_binascii (void)

Variables

static PyObjectError
static PyObjectIncomplete
static unsigned char table_a2b_hqx [256]
static unsigned char table_b2a_hqx [] = "!\"#$%&'()*+,-012345689@ABCDEFGHIJKLMNPQRSTUVXYZ[`abcdefhijklmpqr"
static char table_a2b_base64 []
static unsigned char table_b2a_base64 [] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
static unsigned short crctab_hqx [256]
static unsigned int crc_32_tab [256]
static int table_hex [128]
static struct PyMethodDef []
static struct PyModuleDef

Define Documentation

#define BASE64_MAXBIN   ((PY_SSIZE_T_MAX - 3) / 2)

Definition at line 144 of file binascii.c.

#define BASE64_PAD   '='

Definition at line 141 of file binascii.c.

#define DONE   0x7F

Definition at line 72 of file binascii.c.

#define FAIL   0x7D

Definition at line 74 of file binascii.c.

#define hexval (   c)    table_hex[(unsigned int)(c)]

Definition at line 1184 of file binascii.c.

#define INBYTE (   b)
Value:
do { \
             if ( --in_len < 0 ) { \
                       PyErr_SetString(Incomplete, ""); \
                       Py_DECREF(rv); \
                       PyBuffer_Release(&pin); \
                       return NULL; \
             } \
             b = *in_data++; \
    } while(0)
#define MAXLINESIZE   76

Definition at line 1186 of file binascii.c.

#define OUTBYTE (   b)
Value:
do { \
             if ( --out_len_left < 0 ) { \
                      if ( out_len > PY_SSIZE_T_MAX / 2) return PyErr_NoMemory(); \
                      if (_PyBytes_Resize(&rv, 2*out_len) < 0) \
                        { Py_DECREF(rv); PyBuffer_Release(&pin); return NULL; } \
                      out_data = (unsigned char *)PyBytes_AS_STRING(rv) \
                                                             + out_len; \
                      out_len_left = out_len-1; \
                      out_len = out_len * 2; \
             } \
             *out_data++ = b; \
    } while(0)

Definition at line 56 of file binascii.c.

#define RUNCHAR   0x90

Definition at line 70 of file binascii.c.

#define SKIP   0x7E

Definition at line 73 of file binascii.c.


Function Documentation

static PyObject* binascii_a2b_base64 ( PyObject self,
PyObject args 
) [static]

Definition at line 362 of file binascii.c.

{
    Py_buffer pascii;
    unsigned char *ascii_data, *bin_data;
    int leftbits = 0;
    unsigned char this_ch;
    unsigned int leftchar = 0;
    PyObject *rv;
    Py_ssize_t ascii_len, bin_len;
    int quad_pos = 0;

    if ( !PyArg_ParseTuple(args, "y*:a2b_base64", &pascii) )
        return NULL;
    ascii_data = pascii.buf;
    ascii_len = pascii.len;

    assert(ascii_len >= 0);

    if (ascii_len > PY_SSIZE_T_MAX - 3) {
        PyBuffer_Release(&pascii);
        return PyErr_NoMemory();
    }

    bin_len = ((ascii_len+3)/4)*3; /* Upper bound, corrected later */

    /* Allocate the buffer */
    if ( (rv=PyBytes_FromStringAndSize(NULL, bin_len)) == NULL ) {
        PyBuffer_Release(&pascii);
        return NULL;
    }
    bin_data = (unsigned char *)PyBytes_AS_STRING(rv);
    bin_len = 0;

    for( ; ascii_len > 0; ascii_len--, ascii_data++) {
        this_ch = *ascii_data;

        if (this_ch > 0x7f ||
            this_ch == '\r' || this_ch == '\n' || this_ch == ' ')
            continue;

        /* Check for pad sequences and ignore
        ** the invalid ones.
        */
        if (this_ch == BASE64_PAD) {
            if ( (quad_pos < 2) ||
                 ((quad_pos == 2) &&
                  (binascii_find_valid(ascii_data, ascii_len, 1)
                   != BASE64_PAD)) )
            {
                continue;
            }
            else {
                /* A pad sequence means no more input.
                ** We've already interpreted the data
                ** from the quad at this point.
                */
                leftbits = 0;
                break;
            }
        }

        this_ch = table_a2b_base64[*ascii_data];
        if ( this_ch == (unsigned char) -1 )
            continue;

        /*
        ** Shift it in on the low end, and see if there's
        ** a byte ready for output.
        */
        quad_pos = (quad_pos + 1) & 0x03;
        leftchar = (leftchar << 6) | (this_ch);
        leftbits += 6;

        if ( leftbits >= 8 ) {
            leftbits -= 8;
            *bin_data++ = (leftchar >> leftbits) & 0xff;
            bin_len++;
            leftchar &= ((1 << leftbits) - 1);
        }
    }

    if (leftbits != 0) {
        PyBuffer_Release(&pascii);
        PyErr_SetString(Error, "Incorrect padding");
        Py_DECREF(rv);
        return NULL;
    }

    /* And set string size correctly. If the result string is empty
    ** (because the input was all invalid) return the shared empty
    ** string instead; _PyBytes_Resize() won't do this for us.
    */
    if (bin_len > 0) {
        if (_PyBytes_Resize(&rv, bin_len) < 0) {
            Py_DECREF(rv);
            rv = NULL;
        }
    }
    else {
        Py_DECREF(rv);
        rv = PyBytes_FromStringAndSize("", 0);
    }
    PyBuffer_Release(&pascii);
    return rv;
}

Here is the call graph for this function:

static PyObject* binascii_a2b_hqx ( PyObject self,
PyObject args 
) [static]

Definition at line 538 of file binascii.c.

{
    Py_buffer pascii;
    unsigned char *ascii_data, *bin_data;
    int leftbits = 0;
    unsigned char this_ch;
    unsigned int leftchar = 0;
    PyObject *rv;
    Py_ssize_t len;
    int done = 0;

    if ( !PyArg_ParseTuple(args, "y*:a2b_hqx", &pascii) )
        return NULL;
    ascii_data = pascii.buf;
    len = pascii.len;

    assert(len >= 0);

    if (len > PY_SSIZE_T_MAX - 2) {
        PyBuffer_Release(&pascii);
        return PyErr_NoMemory();
    }

    /* Allocate a string that is too big (fixed later)
       Add two to the initial length to prevent interning which
       would preclude subsequent resizing.  */
    if ( (rv=PyBytes_FromStringAndSize(NULL, len+2)) == NULL ) {
        PyBuffer_Release(&pascii);
        return NULL;
    }
    bin_data = (unsigned char *)PyBytes_AS_STRING(rv);

    for( ; len > 0 ; len--, ascii_data++ ) {
        /* Get the byte and look it up */
        this_ch = table_a2b_hqx[*ascii_data];
        if ( this_ch == SKIP )
            continue;
        if ( this_ch == FAIL ) {
            PyErr_SetString(Error, "Illegal char");
            PyBuffer_Release(&pascii);
            Py_DECREF(rv);
            return NULL;
        }
        if ( this_ch == DONE ) {
            /* The terminating colon */
            done = 1;
            break;
        }

        /* Shift it into the buffer and see if any bytes are ready */
        leftchar = (leftchar << 6) | (this_ch);
        leftbits += 6;
        if ( leftbits >= 8 ) {
            leftbits -= 8;
            *bin_data++ = (leftchar >> leftbits) & 0xff;
            leftchar &= ((1 << leftbits) - 1);
        }
    }

    if ( leftbits && !done ) {
        PyErr_SetString(Incomplete,
                        "String has incomplete number of bytes");
        PyBuffer_Release(&pascii);
        Py_DECREF(rv);
        return NULL;
    }
    if (_PyBytes_Resize(&rv,
                       (bin_data -
                        (unsigned char *)PyBytes_AS_STRING(rv))) < 0) {
        Py_DECREF(rv);
        rv = NULL;
    }
    if (rv) {
        PyObject *rrv = Py_BuildValue("Oi", rv, done);
        PyBuffer_Release(&pascii);
        Py_DECREF(rv);
        return rrv;
    }

    PyBuffer_Release(&pascii);
    return NULL;
}

Here is the call graph for this function:

static PyObject* binascii_a2b_qp ( PyObject self,
PyObject args,
PyObject kwargs 
) [static]

Definition at line 1191 of file binascii.c.

{
    Py_ssize_t in, out;
    char ch;
    Py_buffer pdata;
    unsigned char *data, *odata;
    Py_ssize_t datalen = 0;
    PyObject *rv;
    static char *kwlist[] = {"data", "header", NULL};
    int header = 0;

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "y*|i", kwlist, &pdata,
          &header))
        return NULL;
    data = pdata.buf;
    datalen = pdata.len;

    /* We allocate the output same size as input, this is overkill.
     * The previous implementation used calloc() so we'll zero out the
     * memory here too, since PyMem_Malloc() does not guarantee that.
     */
    odata = (unsigned char *) PyMem_Malloc(datalen);
    if (odata == NULL) {
        PyBuffer_Release(&pdata);
        PyErr_NoMemory();
        return NULL;
    }
    memset(odata, 0, datalen);

    in = out = 0;
    while (in < datalen) {
        if (data[in] == '=') {
            in++;
            if (in >= datalen) break;
            /* Soft line breaks */
            if ((data[in] == '\n') || (data[in] == '\r')) {
                if (data[in] != '\n') {
                    while (in < datalen && data[in] != '\n') in++;
                }
                if (in < datalen) in++;
            }
            else if (data[in] == '=') {
                /* broken case from broken python qp */
                odata[out++] = '=';
                in++;
            }
            else if (((data[in] >= 'A' && data[in] <= 'F') ||
                      (data[in] >= 'a' && data[in] <= 'f') ||
                      (data[in] >= '0' && data[in] <= '9')) &&
                     ((data[in+1] >= 'A' && data[in+1] <= 'F') ||
                      (data[in+1] >= 'a' && data[in+1] <= 'f') ||
                      (data[in+1] >= '0' && data[in+1] <= '9'))) {
                /* hexval */
                ch = hexval(data[in]) << 4;
                in++;
                ch |= hexval(data[in]);
                in++;
                odata[out++] = ch;
            }
            else {
              odata[out++] = '=';
            }
        }
        else if (header && data[in] == '_') {
            odata[out++] = ' ';
            in++;
        }
        else {
            odata[out] = data[in];
            in++;
            out++;
        }
    }
    if ((rv = PyBytes_FromStringAndSize((char *)odata, out)) == NULL) {
        PyBuffer_Release(&pdata);
        PyMem_Free(odata);
        return NULL;
    }
    PyBuffer_Release(&pdata);
    PyMem_Free(odata);
    return rv;
}

Here is the call graph for this function:

static PyObject* binascii_a2b_uu ( PyObject self,
PyObject args 
) [static]

Definition at line 189 of file binascii.c.

{
    Py_buffer pascii;
    unsigned char *ascii_data, *bin_data;
    int leftbits = 0;
    unsigned char this_ch;
    unsigned int leftchar = 0;
    PyObject *rv;
    Py_ssize_t ascii_len, bin_len;

    if ( !PyArg_ParseTuple(args, "y*:a2b_uu", &pascii) )
        return NULL;
    ascii_data = pascii.buf;
    ascii_len = pascii.len;

    assert(ascii_len >= 0);

    /* First byte: binary data length (in bytes) */
    bin_len = (*ascii_data++ - ' ') & 077;
    ascii_len--;

    /* Allocate the buffer */
    if ( (rv=PyBytes_FromStringAndSize(NULL, bin_len)) == NULL ) {
        PyBuffer_Release(&pascii);
        return NULL;
    }
    bin_data = (unsigned char *)PyBytes_AS_STRING(rv);

    for( ; bin_len > 0 ; ascii_len--, ascii_data++ ) {
        /* XXX is it really best to add NULs if there's no more data */
        this_ch = (ascii_len > 0) ? *ascii_data : 0;
        if ( this_ch == '\n' || this_ch == '\r' || ascii_len <= 0) {
            /*
            ** Whitespace. Assume some spaces got eaten at
            ** end-of-line. (We check this later)
            */
            this_ch = 0;
        } else {
            /* Check the character for legality
            ** The 64 in stead of the expected 63 is because
            ** there are a few uuencodes out there that use
            ** '`' as zero instead of space.
            */
            if ( this_ch < ' ' || this_ch > (' ' + 64)) {
                PyErr_SetString(Error, "Illegal char");
                PyBuffer_Release(&pascii);
                Py_DECREF(rv);
                return NULL;
            }
            this_ch = (this_ch - ' ') & 077;
        }
        /*
        ** Shift it in on the low end, and see if there's
        ** a byte ready for output.
        */
        leftchar = (leftchar << 6) | (this_ch);
        leftbits += 6;
        if ( leftbits >= 8 ) {
            leftbits -= 8;
            *bin_data++ = (leftchar >> leftbits) & 0xff;
            leftchar &= ((1 << leftbits) - 1);
            bin_len--;
        }
    }
    /*
    ** Finally, check that if there's anything left on the line
    ** that it's whitespace only.
    */
    while( ascii_len-- > 0 ) {
        this_ch = *ascii_data++;
        /* Extra '`' may be written as padding in some cases */
        if ( this_ch != ' ' && this_ch != ' '+64 &&
             this_ch != '\n' && this_ch != '\r' ) {
            PyErr_SetString(Error, "Trailing garbage");
            PyBuffer_Release(&pascii);
            Py_DECREF(rv);
            return NULL;
        }
    }
    PyBuffer_Release(&pascii);
    return rv;
}

Here is the call graph for this function:

static PyObject* binascii_b2a_base64 ( PyObject self,
PyObject args 
) [static]

Definition at line 471 of file binascii.c.

{
    Py_buffer pbuf;
    unsigned char *ascii_data, *bin_data;
    int leftbits = 0;
    unsigned char this_ch;
    unsigned int leftchar = 0;
    PyObject *rv;
    Py_ssize_t bin_len;

    if ( !PyArg_ParseTuple(args, "y*:b2a_base64", &pbuf) )
        return NULL;
    bin_data = pbuf.buf;
    bin_len = pbuf.len;

    assert(bin_len >= 0);

    if ( bin_len > BASE64_MAXBIN ) {
        PyErr_SetString(Error, "Too much data for base64 line");
        PyBuffer_Release(&pbuf);
        return NULL;
    }

    /* We're lazy and allocate too much (fixed up later).
       "+3" leaves room for up to two pad characters and a trailing
       newline.  Note that 'b' gets encoded as 'Yg==\n' (1 in, 5 out). */
    if ( (rv=PyBytes_FromStringAndSize(NULL, bin_len*2 + 3)) == NULL ) {
        PyBuffer_Release(&pbuf);
        return NULL;
    }
    ascii_data = (unsigned char *)PyBytes_AS_STRING(rv);

    for( ; bin_len > 0 ; bin_len--, bin_data++ ) {
        /* Shift the data into our buffer */
        leftchar = (leftchar << 8) | *bin_data;
        leftbits += 8;

        /* See if there are 6-bit groups ready */
        while ( leftbits >= 6 ) {
            this_ch = (leftchar >> (leftbits-6)) & 0x3f;
            leftbits -= 6;
            *ascii_data++ = table_b2a_base64[this_ch];
        }
    }
    if ( leftbits == 2 ) {
        *ascii_data++ = table_b2a_base64[(leftchar&3) << 4];
        *ascii_data++ = BASE64_PAD;
        *ascii_data++ = BASE64_PAD;
    } else if ( leftbits == 4 ) {
        *ascii_data++ = table_b2a_base64[(leftchar&0xf) << 2];
        *ascii_data++ = BASE64_PAD;
    }
    *ascii_data++ = '\n';       /* Append a courtesy newline */

    if (_PyBytes_Resize(&rv,
                       (ascii_data -
                        (unsigned char *)PyBytes_AS_STRING(rv))) < 0) {
        Py_DECREF(rv);
        rv = NULL;
    }
    PyBuffer_Release(&pbuf);
    return rv;
}

Here is the call graph for this function:

static PyObject* binascii_b2a_hqx ( PyObject self,
PyObject args 
) [static]

Definition at line 688 of file binascii.c.

{
    Py_buffer pbin;
    unsigned char *ascii_data, *bin_data;
    int leftbits = 0;
    unsigned char this_ch;
    unsigned int leftchar = 0;
    PyObject *rv;
    Py_ssize_t len;

    if ( !PyArg_ParseTuple(args, "y*:b2a_hqx", &pbin) )
        return NULL;
    bin_data = pbin.buf;
    len = pbin.len;

    assert(len >= 0);

    if (len > PY_SSIZE_T_MAX / 2 - 2) {
        PyBuffer_Release(&pbin);
        return PyErr_NoMemory();
    }

    /* Allocate a buffer that is at least large enough */
    if ( (rv=PyBytes_FromStringAndSize(NULL, len*2+2)) == NULL ) {
        PyBuffer_Release(&pbin);
        return NULL;
    }
    ascii_data = (unsigned char *)PyBytes_AS_STRING(rv);

    for( ; len > 0 ; len--, bin_data++ ) {
        /* Shift into our buffer, and output any 6bits ready */
        leftchar = (leftchar << 8) | *bin_data;
        leftbits += 8;
        while ( leftbits >= 6 ) {
            this_ch = (leftchar >> (leftbits-6)) & 0x3f;
            leftbits -= 6;
            *ascii_data++ = table_b2a_hqx[this_ch];
        }
    }
    /* Output a possible runt byte */
    if ( leftbits ) {
        leftchar <<= (6-leftbits);
        *ascii_data++ = table_b2a_hqx[leftchar & 0x3f];
    }
    if (_PyBytes_Resize(&rv,
                       (ascii_data -
                        (unsigned char *)PyBytes_AS_STRING(rv))) < 0) {
        Py_DECREF(rv);
        rv = NULL;
    }
    PyBuffer_Release(&pbin);
    return rv;
}

Here is the call graph for this function:

static PyObject* binascii_b2a_qp ( PyObject self,
PyObject args,
PyObject kwargs 
) [static]

Definition at line 1297 of file binascii.c.

{
    Py_ssize_t in, out;
    Py_buffer pdata;
    unsigned char *data, *odata;
    Py_ssize_t datalen = 0, odatalen = 0;
    PyObject *rv;
    unsigned int linelen = 0;
    static char *kwlist[] = {"data", "quotetabs", "istext",
                                   "header", NULL};
    int istext = 1;
    int quotetabs = 0;
    int header = 0;
    unsigned char ch;
    int crlf = 0;
    unsigned char *p;

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "y*|iii", kwlist, &pdata,
          &quotetabs, &istext, &header))
        return NULL;
    data = pdata.buf;
    datalen = pdata.len;

    /* See if this string is using CRLF line ends */
    /* XXX: this function has the side effect of converting all of
     * the end of lines to be the same depending on this detection
     * here */
    p = (unsigned char *) memchr(data, '\n', datalen);
    if ((p != NULL) && (p > data) && (*(p-1) == '\r'))
        crlf = 1;

    /* First, scan to see how many characters need to be encoded */
    in = 0;
    while (in < datalen) {
        if ((data[in] > 126) ||
            (data[in] == '=') ||
            (header && data[in] == '_') ||
            ((data[in] == '.') && (linelen == 0) &&
             (data[in+1] == '\n' || data[in+1] == '\r' || data[in+1] == 0)) ||
            (!istext && ((data[in] == '\r') || (data[in] == '\n'))) ||
            ((data[in] == '\t' || data[in] == ' ') && (in + 1 == datalen)) ||
            ((data[in] < 33) &&
             (data[in] != '\r') && (data[in] != '\n') &&
             (quotetabs || ((data[in] != '\t') && (data[in] != ' ')))))
        {
            if ((linelen + 3) >= MAXLINESIZE) {
                linelen = 0;
                if (crlf)
                    odatalen += 3;
                else
                    odatalen += 2;
            }
            linelen += 3;
            odatalen += 3;
            in++;
        }
        else {
            if (istext &&
                ((data[in] == '\n') ||
                 ((in+1 < datalen) && (data[in] == '\r') &&
                 (data[in+1] == '\n'))))
            {
                linelen = 0;
                /* Protect against whitespace on end of line */
                if (in && ((data[in-1] == ' ') || (data[in-1] == '\t')))
                    odatalen += 2;
                if (crlf)
                    odatalen += 2;
                else
                    odatalen += 1;
                if (data[in] == '\r')
                    in += 2;
                else
                    in++;
            }
            else {
                if ((in + 1 != datalen) &&
                    (data[in+1] != '\n') &&
                    (linelen + 1) >= MAXLINESIZE) {
                    linelen = 0;
                    if (crlf)
                        odatalen += 3;
                    else
                        odatalen += 2;
                }
                linelen++;
                odatalen++;
                in++;
            }
        }
    }

    /* We allocate the output same size as input, this is overkill.
     * The previous implementation used calloc() so we'll zero out the
     * memory here too, since PyMem_Malloc() does not guarantee that.
     */
    odata = (unsigned char *) PyMem_Malloc(odatalen);
    if (odata == NULL) {
        PyBuffer_Release(&pdata);
        PyErr_NoMemory();
        return NULL;
    }
    memset(odata, 0, odatalen);

    in = out = linelen = 0;
    while (in < datalen) {
        if ((data[in] > 126) ||
            (data[in] == '=') ||
            (header && data[in] == '_') ||
            ((data[in] == '.') && (linelen == 0) &&
             (data[in+1] == '\n' || data[in+1] == '\r' || data[in+1] == 0)) ||
            (!istext && ((data[in] == '\r') || (data[in] == '\n'))) ||
            ((data[in] == '\t' || data[in] == ' ') && (in + 1 == datalen)) ||
            ((data[in] < 33) &&
             (data[in] != '\r') && (data[in] != '\n') &&
             (quotetabs ||
            (!quotetabs && ((data[in] != '\t') && (data[in] != ' '))))))
        {
            if ((linelen + 3 )>= MAXLINESIZE) {
                odata[out++] = '=';
                if (crlf) odata[out++] = '\r';
                odata[out++] = '\n';
                linelen = 0;
            }
            odata[out++] = '=';
            to_hex(data[in], &odata[out]);
            out += 2;
            in++;
            linelen += 3;
        }
        else {
            if (istext &&
                ((data[in] == '\n') ||
                 ((in+1 < datalen) && (data[in] == '\r') &&
                 (data[in+1] == '\n'))))
            {
                linelen = 0;
                /* Protect against whitespace on end of line */
                if (out && ((odata[out-1] == ' ') || (odata[out-1] == '\t'))) {
                    ch = odata[out-1];
                    odata[out-1] = '=';
                    to_hex(ch, &odata[out]);
                    out += 2;
                }

                if (crlf) odata[out++] = '\r';
                odata[out++] = '\n';
                if (data[in] == '\r')
                    in += 2;
                else
                    in++;
            }
            else {
                if ((in + 1 != datalen) &&
                    (data[in+1] != '\n') &&
                    (linelen + 1) >= MAXLINESIZE) {
                    odata[out++] = '=';
                    if (crlf) odata[out++] = '\r';
                    odata[out++] = '\n';
                    linelen = 0;
                }
                linelen++;
                if (header && data[in] == ' ') {
                    odata[out++] = '_';
                    in++;
                }
                else {
                    odata[out++] = data[in++];
                }
            }
        }
    }
    if ((rv = PyBytes_FromStringAndSize((char *)odata, out)) == NULL) {
        PyBuffer_Release(&pdata);
        PyMem_Free(odata);
        return NULL;
    }
    PyBuffer_Release(&pdata);
    PyMem_Free(odata);
    return rv;
}

Here is the call graph for this function:

static PyObject* binascii_b2a_uu ( PyObject self,
PyObject args 
) [static]

Definition at line 275 of file binascii.c.

{
    Py_buffer pbin;
    unsigned char *ascii_data, *bin_data;
    int leftbits = 0;
    unsigned char this_ch;
    unsigned int leftchar = 0;
    PyObject *rv;
    Py_ssize_t bin_len;

    if ( !PyArg_ParseTuple(args, "y*:b2a_uu", &pbin) )
        return NULL;
    bin_data = pbin.buf;
    bin_len = pbin.len;
    if ( bin_len > 45 ) {
        /* The 45 is a limit that appears in all uuencode's */
        PyErr_SetString(Error, "At most 45 bytes at once");
        PyBuffer_Release(&pbin);
        return NULL;
    }

    /* We're lazy and allocate to much (fixed up later) */
    if ( (rv=PyBytes_FromStringAndSize(NULL, 2 + (bin_len+2)/3*4)) == NULL ) {
        PyBuffer_Release(&pbin);
        return NULL;
    }
    ascii_data = (unsigned char *)PyBytes_AS_STRING(rv);

    /* Store the length */
    *ascii_data++ = ' ' + (bin_len & 077);

    for( ; bin_len > 0 || leftbits != 0 ; bin_len--, bin_data++ ) {
        /* Shift the data (or padding) into our buffer */
        if ( bin_len > 0 )              /* Data */
            leftchar = (leftchar << 8) | *bin_data;
        else                            /* Padding */
            leftchar <<= 8;
        leftbits += 8;

        /* See if there are 6-bit groups ready */
        while ( leftbits >= 6 ) {
            this_ch = (leftchar >> (leftbits-6)) & 0x3f;
            leftbits -= 6;
            *ascii_data++ = this_ch + ' ';
        }
    }
    *ascii_data++ = '\n';       /* Append a courtesy newline */

    if (_PyBytes_Resize(&rv,
                       (ascii_data -
                        (unsigned char *)PyBytes_AS_STRING(rv))) < 0) {
        Py_DECREF(rv);
        rv = NULL;
    }
    PyBuffer_Release(&pbin);
    return rv;
}

Here is the call graph for this function:

static PyObject* binascii_crc32 ( PyObject self,
PyObject args 
) [static]

Definition at line 1025 of file binascii.c.

{ /* By Jim Ahlstrom; All rights transferred to CNRI */
    Py_buffer pbin;
    unsigned char *bin_data;
    unsigned int crc = 0;       /* initial value of CRC */
    Py_ssize_t len;
    unsigned int result;

    if ( !PyArg_ParseTuple(args, "y*|I:crc32", &pbin, &crc) )
        return NULL;
    bin_data = pbin.buf;
    len = pbin.len;

    crc = ~ crc;
    while (len-- > 0) {
        crc = crc_32_tab[(crc ^ *bin_data++) & 0xff] ^ (crc >> 8);
        /* Note:  (crc >> 8) MUST zero fill on left */
    }

    result = (crc ^ 0xFFFFFFFF);
    PyBuffer_Release(&pbin);
    return PyLong_FromUnsignedLong(result & 0xffffffff);
}

Here is the call graph for this function:

static PyObject* binascii_crc_hqx ( PyObject self,
PyObject args 
) [static]

Definition at line 863 of file binascii.c.

{
    Py_buffer pin;
    unsigned char *bin_data;
    unsigned int crc;
    Py_ssize_t len;

    if ( !PyArg_ParseTuple(args, "y*i:crc_hqx", &pin, &crc) )
        return NULL;
    bin_data = pin.buf;
    len = pin.len;

    while(len-- > 0) {
        crc=((crc<<8)&0xff00)^crctab_hqx[((crc>>8)&0xff)^*bin_data++];
    }

    PyBuffer_Release(&pin);
    return Py_BuildValue("i", crc);
}

Here is the call graph for this function:

static int binascii_find_valid ( unsigned char *  s,
Py_ssize_t  slen,
int  num 
) [static]

Definition at line 335 of file binascii.c.

{
    /* Finds & returns the (num+1)th
    ** valid character for base64, or -1 if none.
    */

    int ret = -1;
    unsigned char c, b64val;

    while ((slen > 0) && (ret == -1)) {
        c = *s;
        b64val = table_a2b_base64[c & 0x7f];
        if ( ((c <= 0x7f) && (b64val != (unsigned char)-1)) ) {
            if (num == 0)
                ret = *s;
            num--;
        }

        s++;
        slen--;
    }
    return ret;
}

Here is the caller graph for this function:

static PyObject* binascii_hexlify ( PyObject self,
PyObject args 
) [static]

Definition at line 1052 of file binascii.c.

{
    Py_buffer parg;
    char* argbuf;
    Py_ssize_t arglen;
    PyObject *retval;
    char* retbuf;
    Py_ssize_t i, j;

    if (!PyArg_ParseTuple(args, "y*:b2a_hex", &parg))
        return NULL;
    argbuf = parg.buf;
    arglen = parg.len;

    assert(arglen >= 0);
    if (arglen > PY_SSIZE_T_MAX / 2) {
        PyBuffer_Release(&parg);
        return PyErr_NoMemory();
    }

    retval = PyBytes_FromStringAndSize(NULL, arglen*2);
    if (!retval) {
        PyBuffer_Release(&parg);
        return NULL;
    }
    retbuf = PyBytes_AS_STRING(retval);

    /* make hex version of string, taken from shamodule.c */
    for (i=j=0; i < arglen; i++) {
        char c;
        c = (argbuf[i] >> 4) & 0xf;
        c = (c>9) ? c+'a'-10 : c + '0';
        retbuf[j++] = c;
        c = argbuf[i] & 0xf;
        c = (c>9) ? c+'a'-10 : c + '0';
        retbuf[j++] = c;
    }
    PyBuffer_Release(&parg);
    return retval;
}

Here is the call graph for this function:

static PyObject* binascii_rlecode_hqx ( PyObject self,
PyObject args 
) [static]

Definition at line 624 of file binascii.c.

{
    Py_buffer pbuf;
    unsigned char *in_data, *out_data;
    PyObject *rv;
    unsigned char ch;
    Py_ssize_t in, inend, len;

    if ( !PyArg_ParseTuple(args, "y*:rlecode_hqx", &pbuf) )
        return NULL;
    in_data = pbuf.buf;
    len = pbuf.len;

    assert(len >= 0);

    if (len > PY_SSIZE_T_MAX / 2 - 2) {
        PyBuffer_Release(&pbuf);
        return PyErr_NoMemory();
    }

    /* Worst case: output is twice as big as input (fixed later) */
    if ( (rv=PyBytes_FromStringAndSize(NULL, len*2+2)) == NULL ) {
        PyBuffer_Release(&pbuf);
        return NULL;
    }
    out_data = (unsigned char *)PyBytes_AS_STRING(rv);

    for( in=0; in<len; in++) {
        ch = in_data[in];
        if ( ch == RUNCHAR ) {
            /* RUNCHAR. Escape it. */
            *out_data++ = RUNCHAR;
            *out_data++ = 0;
        } else {
            /* Check how many following are the same */
            for(inend=in+1;
                inend<len && in_data[inend] == ch &&
                    inend < in+255;
                inend++) ;
            if ( inend - in > 3 ) {
                /* More than 3 in a row. Output RLE. */
                *out_data++ = ch;
                *out_data++ = RUNCHAR;
                *out_data++ = (unsigned char) (inend-in);
                in = inend-1;
            } else {
                /* Less than 3. Output the byte itself */
                *out_data++ = ch;
            }
        }
    }
    if (_PyBytes_Resize(&rv,
                       (out_data -
                        (unsigned char *)PyBytes_AS_STRING(rv))) < 0) {
        Py_DECREF(rv);
        rv = NULL;
    }
    PyBuffer_Release(&pbuf);
    return rv;
}

Here is the call graph for this function:

static PyObject* binascii_rledecode_hqx ( PyObject self,
PyObject args 
) [static]

Definition at line 745 of file binascii.c.

{
    Py_buffer pin;
    unsigned char *in_data, *out_data;
    unsigned char in_byte, in_repeat;
    PyObject *rv;
    Py_ssize_t in_len, out_len, out_len_left;

    if ( !PyArg_ParseTuple(args, "y*:rledecode_hqx", &pin) )
        return NULL;
    in_data = pin.buf;
    in_len = pin.len;

    assert(in_len >= 0);

    /* Empty string is a special case */
    if ( in_len == 0 ) {
        PyBuffer_Release(&pin);
        return PyBytes_FromStringAndSize("", 0);
    }
    else if (in_len > PY_SSIZE_T_MAX / 2) {
        PyBuffer_Release(&pin);
        return PyErr_NoMemory();
    }

    /* Allocate a buffer of reasonable size. Resized when needed */
    out_len = in_len*2;
    if ( (rv=PyBytes_FromStringAndSize(NULL, out_len)) == NULL ) {
        PyBuffer_Release(&pin);
        return NULL;
    }
    out_len_left = out_len;
    out_data = (unsigned char *)PyBytes_AS_STRING(rv);

    /*
    ** We need two macros here to get/put bytes and handle
    ** end-of-buffer for input and output strings.
    */
#define INBYTE(b) \
    do { \
             if ( --in_len < 0 ) { \
                       PyErr_SetString(Incomplete, ""); \
                       Py_DECREF(rv); \
                       PyBuffer_Release(&pin); \
                       return NULL; \
             } \
             b = *in_data++; \
    } while(0)

#define OUTBYTE(b) \
    do { \
             if ( --out_len_left < 0 ) { \
                      if ( out_len > PY_SSIZE_T_MAX / 2) return PyErr_NoMemory(); \
                      if (_PyBytes_Resize(&rv, 2*out_len) < 0) \
                        { Py_DECREF(rv); PyBuffer_Release(&pin); return NULL; } \
                      out_data = (unsigned char *)PyBytes_AS_STRING(rv) \
                                                             + out_len; \
                      out_len_left = out_len-1; \
                      out_len = out_len * 2; \
             } \
             *out_data++ = b; \
    } while(0)

        /*
        ** Handle first byte separately (since we have to get angry
        ** in case of an orphaned RLE code).
        */
        INBYTE(in_byte);

    if (in_byte == RUNCHAR) {
        INBYTE(in_repeat);
        if (in_repeat != 0) {
            /* Note Error, not Incomplete (which is at the end
            ** of the string only). This is a programmer error.
            */
            PyErr_SetString(Error, "Orphaned RLE code at start");
            PyBuffer_Release(&pin);
            Py_DECREF(rv);
            return NULL;
        }
        OUTBYTE(RUNCHAR);
    } else {
        OUTBYTE(in_byte);
    }

    while( in_len > 0 ) {
        INBYTE(in_byte);

        if (in_byte == RUNCHAR) {
            INBYTE(in_repeat);
            if ( in_repeat == 0 ) {
                /* Just an escaped RUNCHAR value */
                OUTBYTE(RUNCHAR);
            } else {
                /* Pick up value and output a sequence of it */
                in_byte = out_data[-1];
                while ( --in_repeat > 0 )
                    OUTBYTE(in_byte);
            }
        } else {
            /* Normal byte */
            OUTBYTE(in_byte);
        }
    }
    if (_PyBytes_Resize(&rv,
                       (out_data -
                        (unsigned char *)PyBytes_AS_STRING(rv))) < 0) {
        Py_DECREF(rv);
        rv = NULL;
    }
    PyBuffer_Release(&pin);
    return rv;
}

Here is the call graph for this function:

static PyObject* binascii_unhexlify ( PyObject self,
PyObject args 
) [static]

Definition at line 1115 of file binascii.c.

{
    Py_buffer parg;
    char* argbuf;
    Py_ssize_t arglen;
    PyObject *retval;
    char* retbuf;
    Py_ssize_t i, j;

    if (!PyArg_ParseTuple(args, "y*:a2b_hex", &parg))
        return NULL;
    argbuf = parg.buf;
    arglen = parg.len;

    assert(arglen >= 0);

    /* XXX What should we do about strings with an odd length?  Should
     * we add an implicit leading zero, or a trailing zero?  For now,
     * raise an exception.
     */
    if (arglen % 2) {
        PyBuffer_Release(&parg);
        PyErr_SetString(Error, "Odd-length string");
        return NULL;
    }

    retval = PyBytes_FromStringAndSize(NULL, (arglen/2));
    if (!retval) {
        PyBuffer_Release(&parg);
        return NULL;
    }
    retbuf = PyBytes_AS_STRING(retval);

    for (i=j=0; i < arglen; i += 2) {
        int top = to_int(Py_CHARMASK(argbuf[i]));
        int bot = to_int(Py_CHARMASK(argbuf[i+1]));
        if (top == -1 || bot == -1) {
            PyErr_SetString(Error,
                            "Non-hexadecimal digit found");
            goto finally;
        }
        retbuf[j++] = (top << 4) + bot;
    }
    PyBuffer_Release(&parg);
    return retval;

  finally:
    PyBuffer_Release(&parg);
    Py_DECREF(retval);
    return NULL;
}

Here is the call graph for this function:

PyDoc_STRVAR ( doc_a2b_uu  ,
"(ascii) -> bin. Decode a line of uuencoded data  
)
PyDoc_STRVAR ( doc_b2a_uu  ,
"(bin) -> ascii. Uuencode line of data  
)
PyDoc_STRVAR ( doc_a2b_base64  ,
"(ascii) -> bin. Decode a line of base64 data  
)
PyDoc_STRVAR ( doc_b2a_base64  ,
"(bin) -> ascii. Base64-code line of data  
)
PyDoc_STRVAR ( doc_a2b_hqx  ,
"ascii ->  bin,
done.Decode.hqx coding"   
)
PyDoc_STRVAR ( doc_rlecode_hqx  ,
"Binhex RLE-code binary data  
)
PyDoc_STRVAR ( doc_b2a_hqx  ,
"Encode .hqx data  
)
PyDoc_STRVAR ( doc_rledecode_hqx  ,
"Decode hexbin RLE-coded string  
)
PyDoc_STRVAR ( doc_crc_hqx  ,
"(data, oldcrc) -> newcrc. Compute hqx CRC incrementally"   
)
PyDoc_STRVAR ( doc_crc32  ,
"(data, oldcrc = 0) -> newcrc. Compute CRC-32 incrementally"   
)
PyDoc_STRVAR ( doc_hexlify  ,
"b2a_hex(data) -> s; Hexadecimal representation of binary data.\n\\n\This function is also available as \"hexlify()\"."   
)
PyDoc_STRVAR ( doc_unhexlify  ,
"a2b_hex(hexstr) -> s; Binary data of hexadecimal representation.\n\\n\hexstr must contain an even number of hex digits (upper or lower case).\n\This function is also available as \"unhexlify()\""   
)
PyDoc_STRVAR ( doc_a2b_qp  ,
"Decode a string of qp-encoded data  
)
PyDoc_STRVAR ( doc_b2a_qp  ,
"b2a_qp(data, quotetabs=0, istext=1, header=0) -> s; \n\ Encode a string using quoted-printable encoding. \n\\n\On  encoding,
when istext is  set,
newlines are not  encoded,
and white\n\space at end of lines is.When istext is not  set,
\\r and\\n(CR/LF) are\n\both encoded.When quotetabs is  set,
space and tabs are encoded."   
)
PyDoc_STRVAR ( doc_binascii  ,
"Conversion between binary data and ASCII"   
)

Definition at line 1522 of file binascii.c.

{
    PyObject *m, *d;

    /* Create the module and add the functions */
    m = PyModule_Create(&binasciimodule);
    if (m == NULL)
        return NULL;

    d = PyModule_GetDict(m);

    Error = PyErr_NewException("binascii.Error", PyExc_ValueError, NULL);
    PyDict_SetItemString(d, "Error", Error);
    Incomplete = PyErr_NewException("binascii.Incomplete", NULL, NULL);
    PyDict_SetItemString(d, "Incomplete", Incomplete);
    if (PyErr_Occurred()) {
        Py_DECREF(m);
        m = NULL;
    }
    return m;
}

Here is the call graph for this function:

static int to_hex ( unsigned char  ch,
unsigned char *  s 
) [static]

Definition at line 1275 of file binascii.c.

{
    unsigned int uvalue = ch;

    s[1] = "0123456789ABCDEF"[uvalue % 16];
    uvalue = (uvalue / 16);
    s[0] = "0123456789ABCDEF"[uvalue % 16];
    return 0;
}

Here is the caller graph for this function:

static int to_int ( int  c) [static]

Definition at line 1100 of file binascii.c.

{
    if (isdigit(c))
        return c - '0';
    else {
        if (isupper(c))
            c = tolower(c);
        if (c >= 'a' && c <= 'f')
            return c - 'a' + 10;
    }
    return -1;
}

Here is the call graph for this function:

Here is the caller graph for this function:


Variable Documentation

unsigned int crc_32_tab[256] [static]

Definition at line 969 of file binascii.c.

unsigned short crctab_hqx[256] [static]

Definition at line 151 of file binascii.c.

PyObject* Error [static]

Definition at line 63 of file binascii.c.

PyObject* Incomplete [static]

Definition at line 64 of file binascii.c.

struct PyMethodDef[] [static]
Initial value:
 {
    {"a2b_uu",     binascii_a2b_uu,     METH_VARARGS, doc_a2b_uu},
    {"b2a_uu",     binascii_b2a_uu,     METH_VARARGS, doc_b2a_uu},
    {"a2b_base64", binascii_a2b_base64, METH_VARARGS, doc_a2b_base64},
    {"b2a_base64", binascii_b2a_base64, METH_VARARGS, doc_b2a_base64},
    {"a2b_hqx",    binascii_a2b_hqx,    METH_VARARGS, doc_a2b_hqx},
    {"b2a_hqx",    binascii_b2a_hqx,    METH_VARARGS, doc_b2a_hqx},
    {"b2a_hex",    binascii_hexlify,    METH_VARARGS, doc_hexlify},
    {"a2b_hex",    binascii_unhexlify,  METH_VARARGS, doc_unhexlify},
    {"hexlify",    binascii_hexlify,    METH_VARARGS, doc_hexlify},
    {"unhexlify",  binascii_unhexlify,  METH_VARARGS, doc_unhexlify},
    {"rlecode_hqx",   binascii_rlecode_hqx, METH_VARARGS, doc_rlecode_hqx},
    {"rledecode_hqx", binascii_rledecode_hqx, METH_VARARGS,
     doc_rledecode_hqx},
    {"crc_hqx",    binascii_crc_hqx,    METH_VARARGS, doc_crc_hqx},
    {"crc32",      binascii_crc32,      METH_VARARGS, doc_crc32},
    {"a2b_qp", (PyCFunction)binascii_a2b_qp, METH_VARARGS | METH_KEYWORDS,
      doc_a2b_qp},
    {"b2a_qp", (PyCFunction)binascii_b2a_qp, METH_VARARGS | METH_KEYWORDS,
      doc_b2a_qp},
    {NULL, NULL}                             
}

Definition at line 1481 of file binascii.c.

struct PyModuleDef [static]
Initial value:
 {
    PyModuleDef_HEAD_INIT,
    "binascii",
    doc_binascii,
    -1,
    binascii_module_methods,
    NULL,
    NULL,
    NULL,
    NULL
}

Definition at line 1509 of file binascii.c.

char table_a2b_base64[] [static]
Initial value:
 {
    -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,
    -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,
    -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,62, -1,-1,-1,63,
    52,53,54,55, 56,57,58,59, 60,61,-1,-1, -1, 0,-1,-1, 
    -1, 0, 1, 2,  3, 4, 5, 6,  7, 8, 9,10, 11,12,13,14,
    15,16,17,18, 19,20,21,22, 23,24,25,-1, -1,-1,-1,-1,
    -1,26,27,28, 29,30,31,32, 33,34,35,36, 37,38,39,40,
    41,42,43,44, 45,46,47,48, 49,50,51,-1, -1,-1,-1,-1
}

Definition at line 130 of file binascii.c.

unsigned char table_a2b_hqx[256] [static]

Definition at line 76 of file binascii.c.

unsigned char table_b2a_base64[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/" [static]

Definition at line 146 of file binascii.c.

unsigned char table_b2a_hqx[] = "!\"#$%&'()*+,-012345689@ABCDEFGHIJKLMNPQRSTUVXYZ[`abcdefhijklmpqr" [static]

Definition at line 127 of file binascii.c.

int table_hex[128] [static]
Initial value:
 {
  -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,
  -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,
  -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,
   0, 1, 2, 3,  4, 5, 6, 7,  8, 9,-1,-1, -1,-1,-1,-1,
  -1,10,11,12, 13,14,15,-1, -1,-1,-1,-1, -1,-1,-1,-1,
  -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,
  -1,10,11,12, 13,14,15,-1, -1,-1,-1,-1, -1,-1,-1,-1,
  -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1
}

Definition at line 1173 of file binascii.c.