423 lines
12 KiB
C
423 lines
12 KiB
C
#define PY_SSIZE_T_CLEAN
|
|
|
|
#include <Python.h>
|
|
#include <stdint.h>
|
|
|
|
#define MODULE_NAME "aioquic._buffer"
|
|
|
|
static PyObject *BufferReadError;
|
|
static PyObject *BufferWriteError;
|
|
|
|
typedef struct {
|
|
PyObject_HEAD
|
|
uint8_t *base;
|
|
uint8_t *end;
|
|
uint8_t *pos;
|
|
} BufferObject;
|
|
|
|
static PyObject *BufferType;
|
|
|
|
#define CHECK_READ_BOUNDS(self, len) \
|
|
if (len < 0 || self->pos + len > self->end) { \
|
|
PyErr_SetString(BufferReadError, "Read out of bounds"); \
|
|
return NULL; \
|
|
}
|
|
|
|
#define CHECK_WRITE_BOUNDS(self, len) \
|
|
if (self->pos + len > self->end) { \
|
|
PyErr_SetString(BufferWriteError, "Write out of bounds"); \
|
|
return NULL; \
|
|
}
|
|
|
|
static int
|
|
Buffer_init(BufferObject *self, PyObject *args, PyObject *kwargs)
|
|
{
|
|
const char *kwlist[] = {"capacity", "data", NULL};
|
|
Py_ssize_t capacity = 0;
|
|
const unsigned char *data = NULL;
|
|
Py_ssize_t data_len = 0;
|
|
|
|
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|ny#", (char**)kwlist, &capacity, &data, &data_len))
|
|
return -1;
|
|
|
|
if (data != NULL) {
|
|
self->base = malloc(data_len);
|
|
self->end = self->base + data_len;
|
|
memcpy(self->base, data, data_len);
|
|
} else {
|
|
self->base = malloc(capacity);
|
|
self->end = self->base + capacity;
|
|
}
|
|
self->pos = self->base;
|
|
return 0;
|
|
}
|
|
|
|
static void
|
|
Buffer_dealloc(BufferObject *self)
|
|
{
|
|
free(self->base);
|
|
PyTypeObject *tp = Py_TYPE(self);
|
|
freefunc free = PyType_GetSlot(tp, Py_tp_free);
|
|
free(self);
|
|
Py_DECREF(tp);
|
|
}
|
|
|
|
static PyObject *
|
|
Buffer_data_slice(BufferObject *self, PyObject *args)
|
|
{
|
|
Py_ssize_t start, stop;
|
|
if (!PyArg_ParseTuple(args, "nn", &start, &stop))
|
|
return NULL;
|
|
|
|
if (start < 0 || self->base + start > self->end ||
|
|
stop < 0 || self->base + stop > self->end ||
|
|
stop < start) {
|
|
PyErr_SetString(BufferReadError, "Read out of bounds");
|
|
return NULL;
|
|
}
|
|
|
|
return PyBytes_FromStringAndSize((const char*)(self->base + start), (stop - start));
|
|
}
|
|
|
|
static PyObject *
|
|
Buffer_eof(BufferObject *self, PyObject *args)
|
|
{
|
|
if (self->pos == self->end)
|
|
Py_RETURN_TRUE;
|
|
Py_RETURN_FALSE;
|
|
}
|
|
|
|
static PyObject *
|
|
Buffer_pull_bytes(BufferObject *self, PyObject *args)
|
|
{
|
|
Py_ssize_t len;
|
|
if (!PyArg_ParseTuple(args, "n", &len))
|
|
return NULL;
|
|
|
|
CHECK_READ_BOUNDS(self, len);
|
|
|
|
PyObject *o = PyBytes_FromStringAndSize((const char*)self->pos, len);
|
|
self->pos += len;
|
|
return o;
|
|
}
|
|
|
|
static PyObject *
|
|
Buffer_pull_uint8(BufferObject *self, PyObject *args)
|
|
{
|
|
CHECK_READ_BOUNDS(self, 1)
|
|
|
|
return PyLong_FromUnsignedLong(
|
|
(uint8_t)(*(self->pos++))
|
|
);
|
|
}
|
|
|
|
static PyObject *
|
|
Buffer_pull_uint16(BufferObject *self, PyObject *args)
|
|
{
|
|
CHECK_READ_BOUNDS(self, 2)
|
|
|
|
uint16_t value = (uint16_t)(*(self->pos)) << 8 |
|
|
(uint16_t)(*(self->pos + 1));
|
|
self->pos += 2;
|
|
return PyLong_FromUnsignedLong(value);
|
|
}
|
|
|
|
static PyObject *
|
|
Buffer_pull_uint32(BufferObject *self, PyObject *args)
|
|
{
|
|
CHECK_READ_BOUNDS(self, 4)
|
|
|
|
uint32_t value = (uint32_t)(*(self->pos)) << 24 |
|
|
(uint32_t)(*(self->pos + 1)) << 16 |
|
|
(uint32_t)(*(self->pos + 2)) << 8 |
|
|
(uint32_t)(*(self->pos + 3));
|
|
self->pos += 4;
|
|
return PyLong_FromUnsignedLong(value);
|
|
}
|
|
|
|
static PyObject *
|
|
Buffer_pull_uint64(BufferObject *self, PyObject *args)
|
|
{
|
|
CHECK_READ_BOUNDS(self, 8)
|
|
|
|
uint64_t value = (uint64_t)(*(self->pos)) << 56 |
|
|
(uint64_t)(*(self->pos + 1)) << 48 |
|
|
(uint64_t)(*(self->pos + 2)) << 40 |
|
|
(uint64_t)(*(self->pos + 3)) << 32 |
|
|
(uint64_t)(*(self->pos + 4)) << 24 |
|
|
(uint64_t)(*(self->pos + 5)) << 16 |
|
|
(uint64_t)(*(self->pos + 6)) << 8 |
|
|
(uint64_t)(*(self->pos + 7));
|
|
self->pos += 8;
|
|
return PyLong_FromUnsignedLongLong(value);
|
|
}
|
|
|
|
static PyObject *
|
|
Buffer_pull_uint_var(BufferObject *self, PyObject *args)
|
|
{
|
|
uint64_t value;
|
|
CHECK_READ_BOUNDS(self, 1)
|
|
switch (*(self->pos) >> 6) {
|
|
case 0:
|
|
value = *(self->pos++) & 0x3F;
|
|
break;
|
|
case 1:
|
|
CHECK_READ_BOUNDS(self, 2)
|
|
value = (uint16_t)(*(self->pos) & 0x3F) << 8 |
|
|
(uint16_t)(*(self->pos + 1));
|
|
self->pos += 2;
|
|
break;
|
|
case 2:
|
|
CHECK_READ_BOUNDS(self, 4)
|
|
value = (uint32_t)(*(self->pos) & 0x3F) << 24 |
|
|
(uint32_t)(*(self->pos + 1)) << 16 |
|
|
(uint32_t)(*(self->pos + 2)) << 8 |
|
|
(uint32_t)(*(self->pos + 3));
|
|
self->pos += 4;
|
|
break;
|
|
default:
|
|
CHECK_READ_BOUNDS(self, 8)
|
|
value = (uint64_t)(*(self->pos) & 0x3F) << 56 |
|
|
(uint64_t)(*(self->pos + 1)) << 48 |
|
|
(uint64_t)(*(self->pos + 2)) << 40 |
|
|
(uint64_t)(*(self->pos + 3)) << 32 |
|
|
(uint64_t)(*(self->pos + 4)) << 24 |
|
|
(uint64_t)(*(self->pos + 5)) << 16 |
|
|
(uint64_t)(*(self->pos + 6)) << 8 |
|
|
(uint64_t)(*(self->pos + 7));
|
|
self->pos += 8;
|
|
break;
|
|
}
|
|
return PyLong_FromUnsignedLongLong(value);
|
|
}
|
|
|
|
static PyObject *
|
|
Buffer_push_bytes(BufferObject *self, PyObject *args)
|
|
{
|
|
const unsigned char *data;
|
|
Py_ssize_t data_len;
|
|
if (!PyArg_ParseTuple(args, "y#", &data, &data_len))
|
|
return NULL;
|
|
|
|
CHECK_WRITE_BOUNDS(self, data_len)
|
|
|
|
memcpy(self->pos, data, data_len);
|
|
self->pos += data_len;
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
static PyObject *
|
|
Buffer_push_uint8(BufferObject *self, PyObject *args)
|
|
{
|
|
uint8_t value;
|
|
if (!PyArg_ParseTuple(args, "B", &value))
|
|
return NULL;
|
|
|
|
CHECK_WRITE_BOUNDS(self, 1)
|
|
|
|
*(self->pos++) = value;
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
static PyObject *
|
|
Buffer_push_uint16(BufferObject *self, PyObject *args)
|
|
{
|
|
uint16_t value;
|
|
if (!PyArg_ParseTuple(args, "H", &value))
|
|
return NULL;
|
|
|
|
CHECK_WRITE_BOUNDS(self, 2)
|
|
|
|
*(self->pos++) = (value >> 8);
|
|
*(self->pos++) = value;
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
static PyObject *
|
|
Buffer_push_uint32(BufferObject *self, PyObject *args)
|
|
{
|
|
uint32_t value;
|
|
if (!PyArg_ParseTuple(args, "I", &value))
|
|
return NULL;
|
|
|
|
CHECK_WRITE_BOUNDS(self, 4)
|
|
*(self->pos++) = (value >> 24);
|
|
*(self->pos++) = (value >> 16);
|
|
*(self->pos++) = (value >> 8);
|
|
*(self->pos++) = value;
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
static PyObject *
|
|
Buffer_push_uint64(BufferObject *self, PyObject *args)
|
|
{
|
|
uint64_t value;
|
|
if (!PyArg_ParseTuple(args, "K", &value))
|
|
return NULL;
|
|
|
|
CHECK_WRITE_BOUNDS(self, 8)
|
|
*(self->pos++) = (value >> 56);
|
|
*(self->pos++) = (value >> 48);
|
|
*(self->pos++) = (value >> 40);
|
|
*(self->pos++) = (value >> 32);
|
|
*(self->pos++) = (value >> 24);
|
|
*(self->pos++) = (value >> 16);
|
|
*(self->pos++) = (value >> 8);
|
|
*(self->pos++) = value;
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
static PyObject *
|
|
Buffer_push_uint_var(BufferObject *self, PyObject *args)
|
|
{
|
|
uint64_t value;
|
|
if (!PyArg_ParseTuple(args, "K", &value))
|
|
return NULL;
|
|
|
|
if (value <= 0x3F) {
|
|
CHECK_WRITE_BOUNDS(self, 1)
|
|
*(self->pos++) = value;
|
|
Py_RETURN_NONE;
|
|
} else if (value <= 0x3FFF) {
|
|
CHECK_WRITE_BOUNDS(self, 2)
|
|
*(self->pos++) = (value >> 8) | 0x40;
|
|
*(self->pos++) = value;
|
|
Py_RETURN_NONE;
|
|
} else if (value <= 0x3FFFFFFF) {
|
|
CHECK_WRITE_BOUNDS(self, 4)
|
|
*(self->pos++) = (value >> 24) | 0x80;
|
|
*(self->pos++) = (value >> 16);
|
|
*(self->pos++) = (value >> 8);
|
|
*(self->pos++) = value;
|
|
Py_RETURN_NONE;
|
|
} else if (value <= 0x3FFFFFFFFFFFFFFF) {
|
|
CHECK_WRITE_BOUNDS(self, 8)
|
|
*(self->pos++) = (value >> 56) | 0xC0;
|
|
*(self->pos++) = (value >> 48);
|
|
*(self->pos++) = (value >> 40);
|
|
*(self->pos++) = (value >> 32);
|
|
*(self->pos++) = (value >> 24);
|
|
*(self->pos++) = (value >> 16);
|
|
*(self->pos++) = (value >> 8);
|
|
*(self->pos++) = value;
|
|
Py_RETURN_NONE;
|
|
} else {
|
|
PyErr_SetString(PyExc_ValueError, "Integer is too big for a variable-length integer");
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
static PyObject *
|
|
Buffer_seek(BufferObject *self, PyObject *args)
|
|
{
|
|
Py_ssize_t pos;
|
|
if (!PyArg_ParseTuple(args, "n", &pos))
|
|
return NULL;
|
|
|
|
if (pos < 0 || self->base + pos > self->end) {
|
|
PyErr_SetString(BufferReadError, "Seek out of bounds");
|
|
return NULL;
|
|
}
|
|
|
|
self->pos = self->base + pos;
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
static PyObject *
|
|
Buffer_tell(BufferObject *self, PyObject *args)
|
|
{
|
|
return PyLong_FromSsize_t(self->pos - self->base);
|
|
}
|
|
|
|
static PyMethodDef Buffer_methods[] = {
|
|
{"data_slice", (PyCFunction)Buffer_data_slice, METH_VARARGS, ""},
|
|
{"eof", (PyCFunction)Buffer_eof, METH_VARARGS, ""},
|
|
{"pull_bytes", (PyCFunction)Buffer_pull_bytes, METH_VARARGS, "Pull bytes."},
|
|
{"pull_uint8", (PyCFunction)Buffer_pull_uint8, METH_VARARGS, "Pull an 8-bit unsigned integer."},
|
|
{"pull_uint16", (PyCFunction)Buffer_pull_uint16, METH_VARARGS, "Pull a 16-bit unsigned integer."},
|
|
{"pull_uint32", (PyCFunction)Buffer_pull_uint32, METH_VARARGS, "Pull a 32-bit unsigned integer."},
|
|
{"pull_uint64", (PyCFunction)Buffer_pull_uint64, METH_VARARGS, "Pull a 64-bit unsigned integer."},
|
|
{"pull_uint_var", (PyCFunction)Buffer_pull_uint_var, METH_VARARGS, "Pull a QUIC variable-length unsigned integer."},
|
|
{"push_bytes", (PyCFunction)Buffer_push_bytes, METH_VARARGS, "Push bytes."},
|
|
{"push_uint8", (PyCFunction)Buffer_push_uint8, METH_VARARGS, "Push an 8-bit unsigned integer."},
|
|
{"push_uint16", (PyCFunction)Buffer_push_uint16, METH_VARARGS, "Push a 16-bit unsigned integer."},
|
|
{"push_uint32", (PyCFunction)Buffer_push_uint32, METH_VARARGS, "Push a 32-bit unsigned integer."},
|
|
{"push_uint64", (PyCFunction)Buffer_push_uint64, METH_VARARGS, "Push a 64-bit unsigned integer."},
|
|
{"push_uint_var", (PyCFunction)Buffer_push_uint_var, METH_VARARGS, "Push a QUIC variable-length unsigned integer."},
|
|
{"seek", (PyCFunction)Buffer_seek, METH_VARARGS, ""},
|
|
{"tell", (PyCFunction)Buffer_tell, METH_VARARGS, ""},
|
|
{NULL}
|
|
};
|
|
|
|
static PyObject*
|
|
Buffer_capacity_getter(BufferObject* self, void *closure) {
|
|
return PyLong_FromSsize_t(self->end - self->base);
|
|
}
|
|
|
|
static PyObject*
|
|
Buffer_data_getter(BufferObject* self, void *closure) {
|
|
return PyBytes_FromStringAndSize((const char*)self->base, self->pos - self->base);
|
|
}
|
|
|
|
static PyGetSetDef Buffer_getset[] = {
|
|
{"capacity", (getter) Buffer_capacity_getter, NULL, "", NULL },
|
|
{"data", (getter) Buffer_data_getter, NULL, "", NULL },
|
|
{NULL}
|
|
};
|
|
|
|
static PyType_Slot BufferType_slots[] = {
|
|
{Py_tp_dealloc, Buffer_dealloc},
|
|
{Py_tp_methods, Buffer_methods},
|
|
{Py_tp_doc, "Buffer objects"},
|
|
{Py_tp_getset, Buffer_getset},
|
|
{Py_tp_init, Buffer_init},
|
|
{0, 0},
|
|
};
|
|
|
|
static PyType_Spec BufferType_spec = {
|
|
MODULE_NAME ".Buffer",
|
|
sizeof(BufferObject),
|
|
0,
|
|
Py_TPFLAGS_DEFAULT,
|
|
BufferType_slots
|
|
};
|
|
|
|
|
|
static struct PyModuleDef moduledef = {
|
|
PyModuleDef_HEAD_INIT,
|
|
MODULE_NAME, /* m_name */
|
|
"Serialization utilities.", /* m_doc */
|
|
-1, /* m_size */
|
|
NULL, /* m_methods */
|
|
NULL, /* m_reload */
|
|
NULL, /* m_traverse */
|
|
NULL, /* m_clear */
|
|
NULL, /* m_free */
|
|
};
|
|
|
|
|
|
PyMODINIT_FUNC
|
|
PyInit__buffer(void)
|
|
{
|
|
PyObject* m;
|
|
|
|
m = PyModule_Create(&moduledef);
|
|
if (m == NULL)
|
|
return NULL;
|
|
|
|
BufferReadError = PyErr_NewException(MODULE_NAME ".BufferReadError", PyExc_ValueError, NULL);
|
|
Py_INCREF(BufferReadError);
|
|
PyModule_AddObject(m, "BufferReadError", BufferReadError);
|
|
|
|
BufferWriteError = PyErr_NewException(MODULE_NAME ".BufferWriteError", PyExc_ValueError, NULL);
|
|
Py_INCREF(BufferWriteError);
|
|
PyModule_AddObject(m, "BufferWriteError", BufferWriteError);
|
|
|
|
BufferType = PyType_FromSpec(&BufferType_spec);
|
|
if (BufferType == NULL)
|
|
return NULL;
|
|
PyModule_AddObject(m, "Buffer", BufferType);
|
|
|
|
return m;
|
|
}
|