mirror of
https://github.com/python/cpython.git
synced 2025-11-17 01:25:57 +00:00
35b98e38b6
binascii.a2b_base64 gains a strict_mode= parameter. When enabled it will raise an error on input that deviates from the base64 spec in any way. The default remains False for backward compatibility. Code reviews and minor tweaks by: Gregory P. Smith <greg@krypto.org> [Google]
770 lines
21 KiB
C
Generated
770 lines
21 KiB
C
Generated
/*[clinic input]
|
|
preserve
|
|
[clinic start generated code]*/
|
|
|
|
PyDoc_STRVAR(binascii_a2b_uu__doc__,
|
|
"a2b_uu($module, data, /)\n"
|
|
"--\n"
|
|
"\n"
|
|
"Decode a line of uuencoded data.");
|
|
|
|
#define BINASCII_A2B_UU_METHODDEF \
|
|
{"a2b_uu", (PyCFunction)binascii_a2b_uu, METH_O, binascii_a2b_uu__doc__},
|
|
|
|
static PyObject *
|
|
binascii_a2b_uu_impl(PyObject *module, Py_buffer *data);
|
|
|
|
static PyObject *
|
|
binascii_a2b_uu(PyObject *module, PyObject *arg)
|
|
{
|
|
PyObject *return_value = NULL;
|
|
Py_buffer data = {NULL, NULL};
|
|
|
|
if (!ascii_buffer_converter(arg, &data)) {
|
|
goto exit;
|
|
}
|
|
return_value = binascii_a2b_uu_impl(module, &data);
|
|
|
|
exit:
|
|
/* Cleanup for data */
|
|
if (data.obj)
|
|
PyBuffer_Release(&data);
|
|
|
|
return return_value;
|
|
}
|
|
|
|
PyDoc_STRVAR(binascii_b2a_uu__doc__,
|
|
"b2a_uu($module, data, /, *, backtick=False)\n"
|
|
"--\n"
|
|
"\n"
|
|
"Uuencode line of data.");
|
|
|
|
#define BINASCII_B2A_UU_METHODDEF \
|
|
{"b2a_uu", (PyCFunction)(void(*)(void))binascii_b2a_uu, METH_FASTCALL|METH_KEYWORDS, binascii_b2a_uu__doc__},
|
|
|
|
static PyObject *
|
|
binascii_b2a_uu_impl(PyObject *module, Py_buffer *data, int backtick);
|
|
|
|
static PyObject *
|
|
binascii_b2a_uu(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
|
|
{
|
|
PyObject *return_value = NULL;
|
|
static const char * const _keywords[] = {"", "backtick", NULL};
|
|
static _PyArg_Parser _parser = {NULL, _keywords, "b2a_uu", 0};
|
|
PyObject *argsbuf[2];
|
|
Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;
|
|
Py_buffer data = {NULL, NULL};
|
|
int backtick = 0;
|
|
|
|
args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 1, 0, argsbuf);
|
|
if (!args) {
|
|
goto exit;
|
|
}
|
|
if (PyObject_GetBuffer(args[0], &data, PyBUF_SIMPLE) != 0) {
|
|
goto exit;
|
|
}
|
|
if (!PyBuffer_IsContiguous(&data, 'C')) {
|
|
_PyArg_BadArgument("b2a_uu", "argument 1", "contiguous buffer", args[0]);
|
|
goto exit;
|
|
}
|
|
if (!noptargs) {
|
|
goto skip_optional_kwonly;
|
|
}
|
|
backtick = _PyLong_AsInt(args[1]);
|
|
if (backtick == -1 && PyErr_Occurred()) {
|
|
goto exit;
|
|
}
|
|
skip_optional_kwonly:
|
|
return_value = binascii_b2a_uu_impl(module, &data, backtick);
|
|
|
|
exit:
|
|
/* Cleanup for data */
|
|
if (data.obj) {
|
|
PyBuffer_Release(&data);
|
|
}
|
|
|
|
return return_value;
|
|
}
|
|
|
|
PyDoc_STRVAR(binascii_a2b_base64__doc__,
|
|
"a2b_base64($module, data, /, *, strict_mode=False)\n"
|
|
"--\n"
|
|
"\n"
|
|
"Decode a line of base64 data.\n"
|
|
"\n"
|
|
" strict_mode\n"
|
|
" When set to True, bytes that are not part of the base64 standard are not allowed.\n"
|
|
" The same applies to excess data after padding (= / ==).");
|
|
|
|
#define BINASCII_A2B_BASE64_METHODDEF \
|
|
{"a2b_base64", (PyCFunction)(void(*)(void))binascii_a2b_base64, METH_FASTCALL|METH_KEYWORDS, binascii_a2b_base64__doc__},
|
|
|
|
static PyObject *
|
|
binascii_a2b_base64_impl(PyObject *module, Py_buffer *data, int strict_mode);
|
|
|
|
static PyObject *
|
|
binascii_a2b_base64(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
|
|
{
|
|
PyObject *return_value = NULL;
|
|
static const char * const _keywords[] = {"", "strict_mode", NULL};
|
|
static _PyArg_Parser _parser = {NULL, _keywords, "a2b_base64", 0};
|
|
PyObject *argsbuf[2];
|
|
Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;
|
|
Py_buffer data = {NULL, NULL};
|
|
int strict_mode = 0;
|
|
|
|
args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 1, 0, argsbuf);
|
|
if (!args) {
|
|
goto exit;
|
|
}
|
|
if (!ascii_buffer_converter(args[0], &data)) {
|
|
goto exit;
|
|
}
|
|
if (!noptargs) {
|
|
goto skip_optional_kwonly;
|
|
}
|
|
strict_mode = _PyLong_AsInt(args[1]);
|
|
if (strict_mode == -1 && PyErr_Occurred()) {
|
|
goto exit;
|
|
}
|
|
skip_optional_kwonly:
|
|
return_value = binascii_a2b_base64_impl(module, &data, strict_mode);
|
|
|
|
exit:
|
|
/* Cleanup for data */
|
|
if (data.obj)
|
|
PyBuffer_Release(&data);
|
|
|
|
return return_value;
|
|
}
|
|
|
|
PyDoc_STRVAR(binascii_b2a_base64__doc__,
|
|
"b2a_base64($module, data, /, *, newline=True)\n"
|
|
"--\n"
|
|
"\n"
|
|
"Base64-code line of data.");
|
|
|
|
#define BINASCII_B2A_BASE64_METHODDEF \
|
|
{"b2a_base64", (PyCFunction)(void(*)(void))binascii_b2a_base64, METH_FASTCALL|METH_KEYWORDS, binascii_b2a_base64__doc__},
|
|
|
|
static PyObject *
|
|
binascii_b2a_base64_impl(PyObject *module, Py_buffer *data, int newline);
|
|
|
|
static PyObject *
|
|
binascii_b2a_base64(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
|
|
{
|
|
PyObject *return_value = NULL;
|
|
static const char * const _keywords[] = {"", "newline", NULL};
|
|
static _PyArg_Parser _parser = {NULL, _keywords, "b2a_base64", 0};
|
|
PyObject *argsbuf[2];
|
|
Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;
|
|
Py_buffer data = {NULL, NULL};
|
|
int newline = 1;
|
|
|
|
args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 1, 0, argsbuf);
|
|
if (!args) {
|
|
goto exit;
|
|
}
|
|
if (PyObject_GetBuffer(args[0], &data, PyBUF_SIMPLE) != 0) {
|
|
goto exit;
|
|
}
|
|
if (!PyBuffer_IsContiguous(&data, 'C')) {
|
|
_PyArg_BadArgument("b2a_base64", "argument 1", "contiguous buffer", args[0]);
|
|
goto exit;
|
|
}
|
|
if (!noptargs) {
|
|
goto skip_optional_kwonly;
|
|
}
|
|
newline = _PyLong_AsInt(args[1]);
|
|
if (newline == -1 && PyErr_Occurred()) {
|
|
goto exit;
|
|
}
|
|
skip_optional_kwonly:
|
|
return_value = binascii_b2a_base64_impl(module, &data, newline);
|
|
|
|
exit:
|
|
/* Cleanup for data */
|
|
if (data.obj) {
|
|
PyBuffer_Release(&data);
|
|
}
|
|
|
|
return return_value;
|
|
}
|
|
|
|
PyDoc_STRVAR(binascii_a2b_hqx__doc__,
|
|
"a2b_hqx($module, data, /)\n"
|
|
"--\n"
|
|
"\n"
|
|
"Decode .hqx coding.");
|
|
|
|
#define BINASCII_A2B_HQX_METHODDEF \
|
|
{"a2b_hqx", (PyCFunction)binascii_a2b_hqx, METH_O, binascii_a2b_hqx__doc__},
|
|
|
|
static PyObject *
|
|
binascii_a2b_hqx_impl(PyObject *module, Py_buffer *data);
|
|
|
|
static PyObject *
|
|
binascii_a2b_hqx(PyObject *module, PyObject *arg)
|
|
{
|
|
PyObject *return_value = NULL;
|
|
Py_buffer data = {NULL, NULL};
|
|
|
|
if (!ascii_buffer_converter(arg, &data)) {
|
|
goto exit;
|
|
}
|
|
return_value = binascii_a2b_hqx_impl(module, &data);
|
|
|
|
exit:
|
|
/* Cleanup for data */
|
|
if (data.obj)
|
|
PyBuffer_Release(&data);
|
|
|
|
return return_value;
|
|
}
|
|
|
|
PyDoc_STRVAR(binascii_rlecode_hqx__doc__,
|
|
"rlecode_hqx($module, data, /)\n"
|
|
"--\n"
|
|
"\n"
|
|
"Binhex RLE-code binary data.");
|
|
|
|
#define BINASCII_RLECODE_HQX_METHODDEF \
|
|
{"rlecode_hqx", (PyCFunction)binascii_rlecode_hqx, METH_O, binascii_rlecode_hqx__doc__},
|
|
|
|
static PyObject *
|
|
binascii_rlecode_hqx_impl(PyObject *module, Py_buffer *data);
|
|
|
|
static PyObject *
|
|
binascii_rlecode_hqx(PyObject *module, PyObject *arg)
|
|
{
|
|
PyObject *return_value = NULL;
|
|
Py_buffer data = {NULL, NULL};
|
|
|
|
if (PyObject_GetBuffer(arg, &data, PyBUF_SIMPLE) != 0) {
|
|
goto exit;
|
|
}
|
|
if (!PyBuffer_IsContiguous(&data, 'C')) {
|
|
_PyArg_BadArgument("rlecode_hqx", "argument", "contiguous buffer", arg);
|
|
goto exit;
|
|
}
|
|
return_value = binascii_rlecode_hqx_impl(module, &data);
|
|
|
|
exit:
|
|
/* Cleanup for data */
|
|
if (data.obj) {
|
|
PyBuffer_Release(&data);
|
|
}
|
|
|
|
return return_value;
|
|
}
|
|
|
|
PyDoc_STRVAR(binascii_b2a_hqx__doc__,
|
|
"b2a_hqx($module, data, /)\n"
|
|
"--\n"
|
|
"\n"
|
|
"Encode .hqx data.");
|
|
|
|
#define BINASCII_B2A_HQX_METHODDEF \
|
|
{"b2a_hqx", (PyCFunction)binascii_b2a_hqx, METH_O, binascii_b2a_hqx__doc__},
|
|
|
|
static PyObject *
|
|
binascii_b2a_hqx_impl(PyObject *module, Py_buffer *data);
|
|
|
|
static PyObject *
|
|
binascii_b2a_hqx(PyObject *module, PyObject *arg)
|
|
{
|
|
PyObject *return_value = NULL;
|
|
Py_buffer data = {NULL, NULL};
|
|
|
|
if (PyObject_GetBuffer(arg, &data, PyBUF_SIMPLE) != 0) {
|
|
goto exit;
|
|
}
|
|
if (!PyBuffer_IsContiguous(&data, 'C')) {
|
|
_PyArg_BadArgument("b2a_hqx", "argument", "contiguous buffer", arg);
|
|
goto exit;
|
|
}
|
|
return_value = binascii_b2a_hqx_impl(module, &data);
|
|
|
|
exit:
|
|
/* Cleanup for data */
|
|
if (data.obj) {
|
|
PyBuffer_Release(&data);
|
|
}
|
|
|
|
return return_value;
|
|
}
|
|
|
|
PyDoc_STRVAR(binascii_rledecode_hqx__doc__,
|
|
"rledecode_hqx($module, data, /)\n"
|
|
"--\n"
|
|
"\n"
|
|
"Decode hexbin RLE-coded string.");
|
|
|
|
#define BINASCII_RLEDECODE_HQX_METHODDEF \
|
|
{"rledecode_hqx", (PyCFunction)binascii_rledecode_hqx, METH_O, binascii_rledecode_hqx__doc__},
|
|
|
|
static PyObject *
|
|
binascii_rledecode_hqx_impl(PyObject *module, Py_buffer *data);
|
|
|
|
static PyObject *
|
|
binascii_rledecode_hqx(PyObject *module, PyObject *arg)
|
|
{
|
|
PyObject *return_value = NULL;
|
|
Py_buffer data = {NULL, NULL};
|
|
|
|
if (PyObject_GetBuffer(arg, &data, PyBUF_SIMPLE) != 0) {
|
|
goto exit;
|
|
}
|
|
if (!PyBuffer_IsContiguous(&data, 'C')) {
|
|
_PyArg_BadArgument("rledecode_hqx", "argument", "contiguous buffer", arg);
|
|
goto exit;
|
|
}
|
|
return_value = binascii_rledecode_hqx_impl(module, &data);
|
|
|
|
exit:
|
|
/* Cleanup for data */
|
|
if (data.obj) {
|
|
PyBuffer_Release(&data);
|
|
}
|
|
|
|
return return_value;
|
|
}
|
|
|
|
PyDoc_STRVAR(binascii_crc_hqx__doc__,
|
|
"crc_hqx($module, data, crc, /)\n"
|
|
"--\n"
|
|
"\n"
|
|
"Compute CRC-CCITT incrementally.");
|
|
|
|
#define BINASCII_CRC_HQX_METHODDEF \
|
|
{"crc_hqx", (PyCFunction)(void(*)(void))binascii_crc_hqx, METH_FASTCALL, binascii_crc_hqx__doc__},
|
|
|
|
static PyObject *
|
|
binascii_crc_hqx_impl(PyObject *module, Py_buffer *data, unsigned int crc);
|
|
|
|
static PyObject *
|
|
binascii_crc_hqx(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
|
|
{
|
|
PyObject *return_value = NULL;
|
|
Py_buffer data = {NULL, NULL};
|
|
unsigned int crc;
|
|
|
|
if (!_PyArg_CheckPositional("crc_hqx", nargs, 2, 2)) {
|
|
goto exit;
|
|
}
|
|
if (PyObject_GetBuffer(args[0], &data, PyBUF_SIMPLE) != 0) {
|
|
goto exit;
|
|
}
|
|
if (!PyBuffer_IsContiguous(&data, 'C')) {
|
|
_PyArg_BadArgument("crc_hqx", "argument 1", "contiguous buffer", args[0]);
|
|
goto exit;
|
|
}
|
|
crc = (unsigned int)PyLong_AsUnsignedLongMask(args[1]);
|
|
if (crc == (unsigned int)-1 && PyErr_Occurred()) {
|
|
goto exit;
|
|
}
|
|
return_value = binascii_crc_hqx_impl(module, &data, crc);
|
|
|
|
exit:
|
|
/* Cleanup for data */
|
|
if (data.obj) {
|
|
PyBuffer_Release(&data);
|
|
}
|
|
|
|
return return_value;
|
|
}
|
|
|
|
PyDoc_STRVAR(binascii_crc32__doc__,
|
|
"crc32($module, data, crc=0, /)\n"
|
|
"--\n"
|
|
"\n"
|
|
"Compute CRC-32 incrementally.");
|
|
|
|
#define BINASCII_CRC32_METHODDEF \
|
|
{"crc32", (PyCFunction)(void(*)(void))binascii_crc32, METH_FASTCALL, binascii_crc32__doc__},
|
|
|
|
static unsigned int
|
|
binascii_crc32_impl(PyObject *module, Py_buffer *data, unsigned int crc);
|
|
|
|
static PyObject *
|
|
binascii_crc32(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
|
|
{
|
|
PyObject *return_value = NULL;
|
|
Py_buffer data = {NULL, NULL};
|
|
unsigned int crc = 0;
|
|
unsigned int _return_value;
|
|
|
|
if (!_PyArg_CheckPositional("crc32", nargs, 1, 2)) {
|
|
goto exit;
|
|
}
|
|
if (PyObject_GetBuffer(args[0], &data, PyBUF_SIMPLE) != 0) {
|
|
goto exit;
|
|
}
|
|
if (!PyBuffer_IsContiguous(&data, 'C')) {
|
|
_PyArg_BadArgument("crc32", "argument 1", "contiguous buffer", args[0]);
|
|
goto exit;
|
|
}
|
|
if (nargs < 2) {
|
|
goto skip_optional;
|
|
}
|
|
crc = (unsigned int)PyLong_AsUnsignedLongMask(args[1]);
|
|
if (crc == (unsigned int)-1 && PyErr_Occurred()) {
|
|
goto exit;
|
|
}
|
|
skip_optional:
|
|
_return_value = binascii_crc32_impl(module, &data, crc);
|
|
if ((_return_value == (unsigned int)-1) && PyErr_Occurred()) {
|
|
goto exit;
|
|
}
|
|
return_value = PyLong_FromUnsignedLong((unsigned long)_return_value);
|
|
|
|
exit:
|
|
/* Cleanup for data */
|
|
if (data.obj) {
|
|
PyBuffer_Release(&data);
|
|
}
|
|
|
|
return return_value;
|
|
}
|
|
|
|
PyDoc_STRVAR(binascii_b2a_hex__doc__,
|
|
"b2a_hex($module, /, data, sep=<unrepresentable>, bytes_per_sep=1)\n"
|
|
"--\n"
|
|
"\n"
|
|
"Hexadecimal representation of binary data.\n"
|
|
"\n"
|
|
" sep\n"
|
|
" An optional single character or byte to separate hex bytes.\n"
|
|
" bytes_per_sep\n"
|
|
" How many bytes between separators. Positive values count from the\n"
|
|
" right, negative values count from the left.\n"
|
|
"\n"
|
|
"The return value is a bytes object. This function is also\n"
|
|
"available as \"hexlify()\".\n"
|
|
"\n"
|
|
"Example:\n"
|
|
">>> binascii.b2a_hex(b\'\\xb9\\x01\\xef\')\n"
|
|
"b\'b901ef\'\n"
|
|
">>> binascii.hexlify(b\'\\xb9\\x01\\xef\', \':\')\n"
|
|
"b\'b9:01:ef\'\n"
|
|
">>> binascii.b2a_hex(b\'\\xb9\\x01\\xef\', b\'_\', 2)\n"
|
|
"b\'b9_01ef\'");
|
|
|
|
#define BINASCII_B2A_HEX_METHODDEF \
|
|
{"b2a_hex", (PyCFunction)(void(*)(void))binascii_b2a_hex, METH_FASTCALL|METH_KEYWORDS, binascii_b2a_hex__doc__},
|
|
|
|
static PyObject *
|
|
binascii_b2a_hex_impl(PyObject *module, Py_buffer *data, PyObject *sep,
|
|
int bytes_per_sep);
|
|
|
|
static PyObject *
|
|
binascii_b2a_hex(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
|
|
{
|
|
PyObject *return_value = NULL;
|
|
static const char * const _keywords[] = {"data", "sep", "bytes_per_sep", NULL};
|
|
static _PyArg_Parser _parser = {NULL, _keywords, "b2a_hex", 0};
|
|
PyObject *argsbuf[3];
|
|
Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;
|
|
Py_buffer data = {NULL, NULL};
|
|
PyObject *sep = NULL;
|
|
int bytes_per_sep = 1;
|
|
|
|
args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 3, 0, argsbuf);
|
|
if (!args) {
|
|
goto exit;
|
|
}
|
|
if (PyObject_GetBuffer(args[0], &data, PyBUF_SIMPLE) != 0) {
|
|
goto exit;
|
|
}
|
|
if (!PyBuffer_IsContiguous(&data, 'C')) {
|
|
_PyArg_BadArgument("b2a_hex", "argument 'data'", "contiguous buffer", args[0]);
|
|
goto exit;
|
|
}
|
|
if (!noptargs) {
|
|
goto skip_optional_pos;
|
|
}
|
|
if (args[1]) {
|
|
sep = args[1];
|
|
if (!--noptargs) {
|
|
goto skip_optional_pos;
|
|
}
|
|
}
|
|
bytes_per_sep = _PyLong_AsInt(args[2]);
|
|
if (bytes_per_sep == -1 && PyErr_Occurred()) {
|
|
goto exit;
|
|
}
|
|
skip_optional_pos:
|
|
return_value = binascii_b2a_hex_impl(module, &data, sep, bytes_per_sep);
|
|
|
|
exit:
|
|
/* Cleanup for data */
|
|
if (data.obj) {
|
|
PyBuffer_Release(&data);
|
|
}
|
|
|
|
return return_value;
|
|
}
|
|
|
|
PyDoc_STRVAR(binascii_hexlify__doc__,
|
|
"hexlify($module, /, data, sep=<unrepresentable>, bytes_per_sep=1)\n"
|
|
"--\n"
|
|
"\n"
|
|
"Hexadecimal representation of binary data.\n"
|
|
"\n"
|
|
" sep\n"
|
|
" An optional single character or byte to separate hex bytes.\n"
|
|
" bytes_per_sep\n"
|
|
" How many bytes between separators. Positive values count from the\n"
|
|
" right, negative values count from the left.\n"
|
|
"\n"
|
|
"The return value is a bytes object. This function is also\n"
|
|
"available as \"b2a_hex()\".");
|
|
|
|
#define BINASCII_HEXLIFY_METHODDEF \
|
|
{"hexlify", (PyCFunction)(void(*)(void))binascii_hexlify, METH_FASTCALL|METH_KEYWORDS, binascii_hexlify__doc__},
|
|
|
|
static PyObject *
|
|
binascii_hexlify_impl(PyObject *module, Py_buffer *data, PyObject *sep,
|
|
int bytes_per_sep);
|
|
|
|
static PyObject *
|
|
binascii_hexlify(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
|
|
{
|
|
PyObject *return_value = NULL;
|
|
static const char * const _keywords[] = {"data", "sep", "bytes_per_sep", NULL};
|
|
static _PyArg_Parser _parser = {NULL, _keywords, "hexlify", 0};
|
|
PyObject *argsbuf[3];
|
|
Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;
|
|
Py_buffer data = {NULL, NULL};
|
|
PyObject *sep = NULL;
|
|
int bytes_per_sep = 1;
|
|
|
|
args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 3, 0, argsbuf);
|
|
if (!args) {
|
|
goto exit;
|
|
}
|
|
if (PyObject_GetBuffer(args[0], &data, PyBUF_SIMPLE) != 0) {
|
|
goto exit;
|
|
}
|
|
if (!PyBuffer_IsContiguous(&data, 'C')) {
|
|
_PyArg_BadArgument("hexlify", "argument 'data'", "contiguous buffer", args[0]);
|
|
goto exit;
|
|
}
|
|
if (!noptargs) {
|
|
goto skip_optional_pos;
|
|
}
|
|
if (args[1]) {
|
|
sep = args[1];
|
|
if (!--noptargs) {
|
|
goto skip_optional_pos;
|
|
}
|
|
}
|
|
bytes_per_sep = _PyLong_AsInt(args[2]);
|
|
if (bytes_per_sep == -1 && PyErr_Occurred()) {
|
|
goto exit;
|
|
}
|
|
skip_optional_pos:
|
|
return_value = binascii_hexlify_impl(module, &data, sep, bytes_per_sep);
|
|
|
|
exit:
|
|
/* Cleanup for data */
|
|
if (data.obj) {
|
|
PyBuffer_Release(&data);
|
|
}
|
|
|
|
return return_value;
|
|
}
|
|
|
|
PyDoc_STRVAR(binascii_a2b_hex__doc__,
|
|
"a2b_hex($module, hexstr, /)\n"
|
|
"--\n"
|
|
"\n"
|
|
"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()\".");
|
|
|
|
#define BINASCII_A2B_HEX_METHODDEF \
|
|
{"a2b_hex", (PyCFunction)binascii_a2b_hex, METH_O, binascii_a2b_hex__doc__},
|
|
|
|
static PyObject *
|
|
binascii_a2b_hex_impl(PyObject *module, Py_buffer *hexstr);
|
|
|
|
static PyObject *
|
|
binascii_a2b_hex(PyObject *module, PyObject *arg)
|
|
{
|
|
PyObject *return_value = NULL;
|
|
Py_buffer hexstr = {NULL, NULL};
|
|
|
|
if (!ascii_buffer_converter(arg, &hexstr)) {
|
|
goto exit;
|
|
}
|
|
return_value = binascii_a2b_hex_impl(module, &hexstr);
|
|
|
|
exit:
|
|
/* Cleanup for hexstr */
|
|
if (hexstr.obj)
|
|
PyBuffer_Release(&hexstr);
|
|
|
|
return return_value;
|
|
}
|
|
|
|
PyDoc_STRVAR(binascii_unhexlify__doc__,
|
|
"unhexlify($module, hexstr, /)\n"
|
|
"--\n"
|
|
"\n"
|
|
"Binary data of hexadecimal representation.\n"
|
|
"\n"
|
|
"hexstr must contain an even number of hex digits (upper or lower case).");
|
|
|
|
#define BINASCII_UNHEXLIFY_METHODDEF \
|
|
{"unhexlify", (PyCFunction)binascii_unhexlify, METH_O, binascii_unhexlify__doc__},
|
|
|
|
static PyObject *
|
|
binascii_unhexlify_impl(PyObject *module, Py_buffer *hexstr);
|
|
|
|
static PyObject *
|
|
binascii_unhexlify(PyObject *module, PyObject *arg)
|
|
{
|
|
PyObject *return_value = NULL;
|
|
Py_buffer hexstr = {NULL, NULL};
|
|
|
|
if (!ascii_buffer_converter(arg, &hexstr)) {
|
|
goto exit;
|
|
}
|
|
return_value = binascii_unhexlify_impl(module, &hexstr);
|
|
|
|
exit:
|
|
/* Cleanup for hexstr */
|
|
if (hexstr.obj)
|
|
PyBuffer_Release(&hexstr);
|
|
|
|
return return_value;
|
|
}
|
|
|
|
PyDoc_STRVAR(binascii_a2b_qp__doc__,
|
|
"a2b_qp($module, /, data, header=False)\n"
|
|
"--\n"
|
|
"\n"
|
|
"Decode a string of qp-encoded data.");
|
|
|
|
#define BINASCII_A2B_QP_METHODDEF \
|
|
{"a2b_qp", (PyCFunction)(void(*)(void))binascii_a2b_qp, METH_FASTCALL|METH_KEYWORDS, binascii_a2b_qp__doc__},
|
|
|
|
static PyObject *
|
|
binascii_a2b_qp_impl(PyObject *module, Py_buffer *data, int header);
|
|
|
|
static PyObject *
|
|
binascii_a2b_qp(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
|
|
{
|
|
PyObject *return_value = NULL;
|
|
static const char * const _keywords[] = {"data", "header", NULL};
|
|
static _PyArg_Parser _parser = {NULL, _keywords, "a2b_qp", 0};
|
|
PyObject *argsbuf[2];
|
|
Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;
|
|
Py_buffer data = {NULL, NULL};
|
|
int header = 0;
|
|
|
|
args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 2, 0, argsbuf);
|
|
if (!args) {
|
|
goto exit;
|
|
}
|
|
if (!ascii_buffer_converter(args[0], &data)) {
|
|
goto exit;
|
|
}
|
|
if (!noptargs) {
|
|
goto skip_optional_pos;
|
|
}
|
|
header = _PyLong_AsInt(args[1]);
|
|
if (header == -1 && PyErr_Occurred()) {
|
|
goto exit;
|
|
}
|
|
skip_optional_pos:
|
|
return_value = binascii_a2b_qp_impl(module, &data, header);
|
|
|
|
exit:
|
|
/* Cleanup for data */
|
|
if (data.obj)
|
|
PyBuffer_Release(&data);
|
|
|
|
return return_value;
|
|
}
|
|
|
|
PyDoc_STRVAR(binascii_b2a_qp__doc__,
|
|
"b2a_qp($module, /, data, quotetabs=False, istext=True, header=False)\n"
|
|
"--\n"
|
|
"\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)\n"
|
|
"are both encoded. When quotetabs is set, space and tabs are encoded.");
|
|
|
|
#define BINASCII_B2A_QP_METHODDEF \
|
|
{"b2a_qp", (PyCFunction)(void(*)(void))binascii_b2a_qp, METH_FASTCALL|METH_KEYWORDS, binascii_b2a_qp__doc__},
|
|
|
|
static PyObject *
|
|
binascii_b2a_qp_impl(PyObject *module, Py_buffer *data, int quotetabs,
|
|
int istext, int header);
|
|
|
|
static PyObject *
|
|
binascii_b2a_qp(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
|
|
{
|
|
PyObject *return_value = NULL;
|
|
static const char * const _keywords[] = {"data", "quotetabs", "istext", "header", NULL};
|
|
static _PyArg_Parser _parser = {NULL, _keywords, "b2a_qp", 0};
|
|
PyObject *argsbuf[4];
|
|
Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;
|
|
Py_buffer data = {NULL, NULL};
|
|
int quotetabs = 0;
|
|
int istext = 1;
|
|
int header = 0;
|
|
|
|
args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 4, 0, argsbuf);
|
|
if (!args) {
|
|
goto exit;
|
|
}
|
|
if (PyObject_GetBuffer(args[0], &data, PyBUF_SIMPLE) != 0) {
|
|
goto exit;
|
|
}
|
|
if (!PyBuffer_IsContiguous(&data, 'C')) {
|
|
_PyArg_BadArgument("b2a_qp", "argument 'data'", "contiguous buffer", args[0]);
|
|
goto exit;
|
|
}
|
|
if (!noptargs) {
|
|
goto skip_optional_pos;
|
|
}
|
|
if (args[1]) {
|
|
quotetabs = _PyLong_AsInt(args[1]);
|
|
if (quotetabs == -1 && PyErr_Occurred()) {
|
|
goto exit;
|
|
}
|
|
if (!--noptargs) {
|
|
goto skip_optional_pos;
|
|
}
|
|
}
|
|
if (args[2]) {
|
|
istext = _PyLong_AsInt(args[2]);
|
|
if (istext == -1 && PyErr_Occurred()) {
|
|
goto exit;
|
|
}
|
|
if (!--noptargs) {
|
|
goto skip_optional_pos;
|
|
}
|
|
}
|
|
header = _PyLong_AsInt(args[3]);
|
|
if (header == -1 && PyErr_Occurred()) {
|
|
goto exit;
|
|
}
|
|
skip_optional_pos:
|
|
return_value = binascii_b2a_qp_impl(module, &data, quotetabs, istext, header);
|
|
|
|
exit:
|
|
/* Cleanup for data */
|
|
if (data.obj) {
|
|
PyBuffer_Release(&data);
|
|
}
|
|
|
|
return return_value;
|
|
}
|
|
/*[clinic end generated code: output=0f261ee49971f5ca input=a9049054013a1b77]*/
|