PyObject* xcsoar_encode(PyObject *self, PyObject *args, PyObject *kwargs) {
PyObject *py_list,
*py_method = nullptr;
double floor_to = 1;
bool delta = true;
static char *kwlist[] = {"list", "delta", "floor", "method", nullptr};
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|idO", kwlist,
&py_list, &delta, &floor_to, &py_method)) {
PyErr_SetString(PyExc_AttributeError, "Can't parse argument list.");
return nullptr;
}
if (!PySequence_Check(py_list)) {
PyErr_SetString(PyExc_TypeError, "Expected a list.");
return nullptr;
}
Py_ssize_t num_items = PySequence_Fast_GET_SIZE(py_list);
// return empty string if list has no elements
if (num_items == 0)
return PyString_FromString("");
unsigned dimension;
if (PySequence_Check(PySequence_Fast_GET_ITEM(py_list, 0))) {
dimension = PySequence_Size(PySequence_Fast_GET_ITEM(py_list, 0));
} else {
dimension = 1;
}
enum Method { UNSIGNED, SIGNED, DOUBLE } method;
if (py_method == nullptr)
method = UNSIGNED;
else if (PyString_Check(py_method) && strcmp(PyString_AsString(py_method), "unsigned") == 0)
method = UNSIGNED;
else if (PyString_Check(py_method) && strcmp(PyString_AsString(py_method), "signed") == 0)
method = SIGNED;
else if (PyString_Check(py_method) && strcmp(PyString_AsString(py_method), "double") == 0)
method = DOUBLE;
else {
PyErr_SetString(PyExc_TypeError, "Can't parse method.");
return nullptr;
}
GoogleEncode encoded(dimension, delta, floor_to);
for (Py_ssize_t i = 0; i < num_items; ++i) {
PyObject *py_item = PySequence_Fast_GET_ITEM(py_list, i);
if (dimension > 1) {
for (unsigned j = 0; j < dimension; ++j) {
if (method == UNSIGNED) {
if (!PyNumber_Check(PySequence_Fast_GET_ITEM(py_item, j))) {
PyErr_SetString(PyExc_TypeError, "Expected numeric value.");
return nullptr;
}
encoded.addUnsignedNumber(PyInt_AsLong(PySequence_Fast_GET_ITEM(py_item, j)));
} else if (method == SIGNED) {
if (!PyNumber_Check(PySequence_Fast_GET_ITEM(py_item, j))) {
PyErr_SetString(PyExc_TypeError, "Expected numeric value.");
return nullptr;
}
encoded.addSignedNumber(PyInt_AsLong(PySequence_Fast_GET_ITEM(py_item, j)));
} else if (method == DOUBLE) {
if (!PyNumber_Check(PySequence_Fast_GET_ITEM(py_item, j))) {
PyErr_SetString(PyExc_TypeError, "Expected numeric value.");
return nullptr;
}
encoded.addDouble(PyFloat_AsDouble(PySequence_Fast_GET_ITEM(py_item, j)));
}
}
} else {
if (method == UNSIGNED) {
if (!PyNumber_Check(py_item)) {
PyErr_SetString(PyExc_TypeError, "Expected numeric value.");
return nullptr;
}
encoded.addUnsignedNumber(PyInt_AsLong(py_item));
} else if (method == SIGNED) {
if (!PyNumber_Check(py_item)) {
PyErr_SetString(PyExc_TypeError, "Expected numeric value.");
return nullptr;
}
encoded.addSignedNumber(PyInt_AsLong(py_item));
} else if (method == DOUBLE) {
if (!PyNumber_Check(py_item)) {
PyErr_SetString(PyExc_TypeError, "Expected numeric value.");
return nullptr;
}
encoded.addDouble(PyFloat_AsDouble(py_item));
}
}
}
// prepare output
PyObject *py_result = PyString_FromString(encoded.asString()->c_str());
return py_result;
}
bool ec_private::operator<(const ec_private& other) const
{
return encoded() < other.encoded();
}
void ManageSieveCommand::execute()
{
if ( d->done )
return;
bool ok = true;
switch ( d->cmd ) {
case Logout:
log( "Received LOGOUT command", Log::Debug );
d->sieve->Connection::setState( Connection::Closing );
break;
case Capability:
end();
if ( d->no.isEmpty() )
d->sieve->capabilities();
break;
case StartTls:
ok = startTls();
break;
case Authenticate:
ok = authenticate();
break;
case HaveSpace:
ok = haveSpace();
break;
case PutScript:
ok = putScript();
break;
case ListScripts:
ok = listScripts();
break;
case SetActive:
ok = setActive();
break;
case GetScript:
ok = getScript();
break;
case DeleteScript:
ok = deleteScript();
break;
case RenameScript:
ok = renameScript();
break;
case Noop:
ok = noop();
break;
case XAoxExplain:
ok = explain();
break;
case Unknown:
no( "Unknown command" );
break;
}
if ( d->query && d->query->failed() && d->no.isEmpty() )
no( "Database failed: " + d->query->error() );
else if ( d->t && d->t->failed() && d->no.isEmpty() )
no( "Database failed: " + d->t->error() ); // XXX need to rollback?
if ( !d->no.isEmpty() )
ok = true;
if ( !ok )
return;
d->done = true;
if ( d->no.isEmpty() ) {
d->sieve->enqueue( "OK" );
if ( !d->ok.isEmpty() ) {
d->sieve->enqueue( " " );
d->sieve->enqueue( encoded( d->ok ) );
}
d->sieve->enqueue( "\r\n" );
}
else {
d->sieve->enqueue( "NO" );
if ( !d->no.isEmpty() ) {
d->sieve->enqueue( " " );
d->sieve->enqueue( encoded( d->no ) );
}
d->sieve->enqueue( "\r\n" );
};
d->sieve->runCommands();
}
bool LLSDNotationParser::parseBinary(std::istream& istr, LLSD& data) const
{
// binary: b##"ff3120ab1"
// or: b(len)"..."
// I want to manually control those values here to make sure the
// parser doesn't break when someone changes a constant somewhere
// else.
const U32 BINARY_BUFFER_SIZE = 256;
const U32 STREAM_GET_COUNT = 255;
// need to read the base out.
char buf[BINARY_BUFFER_SIZE]; /* Flawfinder: ignore */
get(istr, buf, STREAM_GET_COUNT, '"');
char c = get(istr);
if(c != '"') return false;
if(0 == strncmp("b(", buf, 2))
{
// We probably have a valid raw binary stream. determine
// the size, and read it.
S32 len = strtol(buf + 2, NULL, 0);
if(mCheckLimits && (len > mMaxBytesLeft)) return false;
std::vector<U8> value;
if(len)
{
value.resize(len);
account(fullread(istr, (char *)&value[0], len));
}
c = get(istr); // strip off the trailing double-quote
data = value;
}
else if(0 == strncmp("b64", buf, 3))
{
// *FIX: A bit inefficient, but works for now. To make the
// format better, I would need to add a hint into the
// serialization format that indicated how long it was.
std::stringstream coded_stream;
get(istr, *(coded_stream.rdbuf()), '\"');
c = get(istr);
std::string encoded(coded_stream.str());
S32 len = apr_base64_decode_len(encoded.c_str());
std::vector<U8> value;
if(len)
{
value.resize(len);
len = apr_base64_decode_binary(&value[0], encoded.c_str());
value.resize(len);
}
data = value;
}
else if(0 == strncmp("b16", buf, 3))
{
// yay, base 16. We pop the next character which is either a
// double quote or base 16 data. If it's a double quote, we're
// done parsing. If it's not, put the data back, and read the
// stream until the next double quote.
char* read; /*Flawfinder: ignore*/
U8 byte;
U8 byte_buffer[BINARY_BUFFER_SIZE];
U8* write;
std::vector<U8> value;
c = get(istr);
while(c != '"')
{
putback(istr, c);
read = buf;
write = byte_buffer;
get(istr, buf, STREAM_GET_COUNT, '"');
c = get(istr);
while(*read != '\0') /*Flawfinder: ignore*/
{
byte = hex_as_nybble(*read++);
byte = byte << 4;
byte |= hex_as_nybble(*read++);
*write++ = byte;
}
// copy the data out of the byte buffer
value.insert(value.end(), byte_buffer, write);
}
data = value;
}
else
{
return false;
}
return true;
}
