void function::argument_error(PyObject* args, PyObject* /*keywords*/) const
{
static handle<> exception(
PyErr_NewException(const_cast<char*>("Boost.Python.ArgumentError"), PyExc_TypeError, 0));
object message = "Python argument types in\n %s.%s("
% make_tuple(this->m_namespace, this->m_name);
list actual_args;
for (ssize_t i = 0; i < PyTuple_Size(args); ++i)
{
char const* name = PyTuple_GetItem(args, i)->ob_type->tp_name;
actual_args.append(str(name));
}
message += str(", ").join(actual_args);
message += ")\ndid not match C++ signature:\n ";
message += str("\n ").join(signatures());
#if BOOST_PYTHON_DEBUG_ERROR_MESSAGES
std::printf("\n--------\n%s\n--------\n", extract<const char*>(message)());
#endif
PyErr_SetObject(exception.get(), message.ptr());
throw_error_already_set();
}
PyObject * AerospikeClient_HasGeo(AerospikeClient * self, PyObject * args, PyObject * kwds)
{
// Initialize error
as_error err;
as_error_init(&err);
if (!self || !self->as) {
as_error_update(&err, AEROSPIKE_ERR_PARAM, "Invalid aerospike object");
goto CLEANUP;
}
if (!self->is_conn_16) {
as_error_update(&err, AEROSPIKE_ERR_CLUSTER, "No connection to aerospike cluster");
goto CLEANUP;
}
if (aerospike_has_geo(self->as)) {
Py_INCREF(Py_True);
return Py_True;
}
Py_INCREF(Py_False);
return Py_False;
CLEANUP:
if ( err.code != AEROSPIKE_OK ) {
PyObject * py_err = NULL;
error_to_pyobject(&err, &py_err);
PyObject *exception_type = raise_exception(&err);
PyErr_SetObject(exception_type, py_err);
Py_DECREF(py_err);
return NULL;
}
return NULL;
}
static char *__config_gen_config(PyObject *indent, yajl_gen_config *config)
{
long indentLevel = -1;
char *spaces = NULL;
if (!indent)
return NULL;
if ((indent != Py_None) && (!PyLong_Check(indent))
#ifndef IS_PYTHON3
&& (!PyInt_Check(indent))
#endif
) {
PyErr_SetObject(PyExc_TypeError,
PyUnicode_FromString("`indent` must be int or None"));
return NULL;
}
if (indent != Py_None) {
indentLevel = PyLong_AsLong(indent);
if (indentLevel >= 0) {
config->beautify = 1;
if (indentLevel == 0) {
config->indentString = "";
}
else {
spaces = (char *)(malloc(sizeof(char) * (indentLevel + 1)));
memset((void *)(spaces), (int)' ', indentLevel);
spaces[indentLevel] = '\0';
config->indentString = spaces;
}
}
}
return spaces;
}
TreeEntry *
Tree_getitem_by_index(Tree *self, PyObject *py_index)
{
int index;
const git_tree_entry *entry;
index = Tree_fix_index(self, py_index);
if (PyErr_Occurred())
return NULL;
entry = git_tree_entry_byindex(self->tree, index);
if (!entry) {
PyErr_SetObject(PyExc_IndexError, py_index);
return NULL;
}
entry = git_tree_entry_dup(entry);
if (entry == NULL) {
PyErr_SetNone(PyExc_MemoryError);
return NULL;
}
return wrap_tree_entry(entry);
}
static void set_gss_error(OM_uint32 err_maj, OM_uint32 err_min)
{
OM_uint32 maj_stat, min_stat;
OM_uint32 msg_ctx = 0;
gss_buffer_desc status_string;
char buf_maj[512];
char buf_min[512];
do
{
maj_stat = gss_display_status (&min_stat,
err_maj,
GSS_C_GSS_CODE,
GSS_C_NO_OID,
&msg_ctx,
&status_string);
if (GSS_ERROR(maj_stat))
break;
strncpy(buf_maj, (char*) status_string.value, sizeof(buf_maj));
gss_release_buffer(&min_stat, &status_string);
maj_stat = gss_display_status (&min_stat,
err_min,
GSS_C_MECH_CODE,
GSS_C_NULL_OID,
&msg_ctx,
&status_string);
if (!GSS_ERROR(maj_stat))
{
strncpy(buf_min, (char*) status_string.value, sizeof(buf_min));
gss_release_buffer(&min_stat, &status_string);
}
} while (!GSS_ERROR(maj_stat) && msg_ctx != 0);
PyErr_SetObject(GssException_class, Py_BuildValue("((s:i)(s:i))", buf_maj, err_maj, buf_min, err_min));
}
/**
*******************************************************************************************************
* Sends an info request to all the nodes in a cluster.
*
* @param self AerospikeClient object
* @param args The args is a tuple object containing an argument
* list passed from Python to a C function
* @param kwds Dictionary of keywords
*
* Returns a server response for the particular request string.
* In case of error,appropriate exceptions will be raised.
*******************************************************************************************************
*/
PyObject * AerospikeClient_Info(AerospikeClient * self, PyObject * args, PyObject * kwds)
{
PyObject * py_req = NULL;
PyObject * py_policy = NULL;
PyObject * py_hosts = NULL;
PyObject * py_nodes = NULL;
PyObject * py_ustr = NULL;
foreach_callback_info_udata info_callback_udata;
static char * kwlist[] = {"command", "hosts", "policy", NULL};
if ( PyArg_ParseTupleAndKeywords(args, kwds, "O|OO:info", kwlist, &py_req, &py_hosts, &py_policy) == false ) {
return NULL;
}
as_error err;
as_error_init(&err);
as_policy_info info_policy;
as_policy_info* info_policy_p = NULL;
py_nodes = PyDict_New();
info_callback_udata.udata_p = py_nodes;
info_callback_udata.host_lookup_p = py_hosts;
as_error_init(&info_callback_udata.error);
if (!self || !self->as) {
as_error_update(&err, AEROSPIKE_ERR_PARAM, "Invalid aerospike object");
goto CLEANUP;
}
if (!self->is_conn_16) {
as_error_update(&err, AEROSPIKE_ERR_CLUSTER, "No connection to aerospike cluster");
goto CLEANUP;
}
// Convert python policy object to as_policy_info
pyobject_to_policy_info(&err, py_policy, &info_policy, &info_policy_p,
&self->as->config.policies.info);
if ( err.code != AEROSPIKE_OK ) {
goto CLEANUP;
}
char * req = NULL;
if ( PyUnicode_Check(py_req)) {
py_ustr = PyUnicode_AsUTF8String(py_req);
req = PyStr_AsString(py_ustr);
} else if( PyStr_Check(py_req) ) {
req = PyStr_AsString(py_req);
} else {
as_error_update(&err, AEROSPIKE_ERR_PARAM, "Request must be a string");
goto CLEANUP;
}
aerospike_info_foreach(self->as, &err, info_policy_p, req,
(aerospike_info_foreach_callback)AerospikeClient_Info_each,
&info_callback_udata);
if (&info_callback_udata.error.code != AEROSPIKE_OK) {
as_error_update(&err, err.code, NULL);
goto CLEANUP;
}
CLEANUP:
if (py_ustr) {
Py_DECREF(py_ustr);
}
if ( info_callback_udata.error.code != AEROSPIKE_OK ) {
PyObject * py_err = NULL;
error_to_pyobject(&info_callback_udata.error, &py_err);
PyObject *exception_type = raise_exception(&info_callback_udata.error);
PyErr_SetObject(exception_type, py_err);
Py_DECREF(py_err);
if (py_nodes) {
Py_DECREF(py_nodes);
}
return NULL;
}
if ( err.code != AEROSPIKE_OK ) {
PyObject * py_err = NULL;
error_to_pyobject(&err, &py_err);
PyObject *exception_type = raise_exception(&err);
PyErr_SetObject(exception_type, py_err);
Py_DECREF(py_err);
if (py_nodes) {
Py_DECREF(py_nodes);
}
return NULL;
}
return info_callback_udata.udata_p;
}
static PyObject *
warn_explicit(PyObject *category, PyObject *message,
PyObject *filename, int lineno,
PyObject *module, PyObject *registry, PyObject *sourceline,
PyObject *source)
{
PyObject *key = NULL, *text = NULL, *result = NULL, *lineno_obj = NULL;
PyObject *item = NULL;
PyObject *action;
int rc;
/* module can be None if a warning is emitted late during Python shutdown.
In this case, the Python warnings module was probably unloaded, filters
are no more available to choose as action. It is safer to ignore the
warning and do nothing. */
if (module == Py_None)
Py_RETURN_NONE;
if (registry && !PyDict_Check(registry) && (registry != Py_None)) {
PyErr_SetString(PyExc_TypeError, "'registry' must be a dict");
return NULL;
}
/* Normalize module. */
if (module == NULL) {
module = normalize_module(filename);
if (module == NULL)
return NULL;
}
else
Py_INCREF(module);
/* Normalize message. */
Py_INCREF(message); /* DECREF'ed in cleanup. */
rc = PyObject_IsInstance(message, PyExc_Warning);
if (rc == -1) {
goto cleanup;
}
if (rc == 1) {
text = PyObject_Str(message);
if (text == NULL)
goto cleanup;
category = (PyObject*)message->ob_type;
}
else {
text = message;
message = PyObject_CallFunction(category, "O", message);
if (message == NULL)
goto cleanup;
}
lineno_obj = PyLong_FromLong(lineno);
if (lineno_obj == NULL)
goto cleanup;
/* Create key. */
key = PyTuple_Pack(3, text, category, lineno_obj);
if (key == NULL)
goto cleanup;
if ((registry != NULL) && (registry != Py_None)) {
rc = already_warned(registry, key, 0);
if (rc == -1)
goto cleanup;
else if (rc == 1)
goto return_none;
/* Else this warning hasn't been generated before. */
}
action = get_filter(category, text, lineno, module, &item);
if (action == NULL)
goto cleanup;
if (PyUnicode_CompareWithASCIIString(action, "error") == 0) {
PyErr_SetObject(category, message);
goto cleanup;
}
/* Store in the registry that we've been here, *except* when the action
is "always". */
rc = 0;
if (PyUnicode_CompareWithASCIIString(action, "always") != 0) {
if (registry != NULL && registry != Py_None &&
PyDict_SetItem(registry, key, Py_True) < 0)
goto cleanup;
else if (PyUnicode_CompareWithASCIIString(action, "ignore") == 0)
goto return_none;
else if (PyUnicode_CompareWithASCIIString(action, "once") == 0) {
if (registry == NULL || registry == Py_None) {
registry = get_once_registry();
if (registry == NULL)
goto cleanup;
}
/* _once_registry[(text, category)] = 1 */
rc = update_registry(registry, text, category, 0);
}
else if (PyUnicode_CompareWithASCIIString(action, "module") == 0) {
/* registry[(text, category, 0)] = 1 */
if (registry != NULL && registry != Py_None)
rc = update_registry(registry, text, category, 0);
}
else if (PyUnicode_CompareWithASCIIString(action, "default") != 0) {
PyErr_Format(PyExc_RuntimeError,
"Unrecognized action (%R) in warnings.filters:\n %R",
action, item);
goto cleanup;
}
}
if (rc == 1) /* Already warned for this module. */
goto return_none;
if (rc == 0) {
if (call_show_warning(category, text, message, filename, lineno,
lineno_obj, sourceline, source) < 0)
goto cleanup;
}
else /* if (rc == -1) */
goto cleanup;
return_none:
result = Py_None;
Py_INCREF(result);
cleanup:
Py_XDECREF(item);
Py_XDECREF(key);
Py_XDECREF(text);
Py_XDECREF(lineno_obj);
Py_DECREF(module);
Py_XDECREF(message);
return result; /* Py_None or NULL. */
}
PyObject *spoolss_openprinter(PyObject *self, PyObject *args, PyObject *kw)
{
char *unc_name, *server, *errstr;
TALLOC_CTX *mem_ctx = NULL;
POLICY_HND hnd;
WERROR werror;
PyObject *result = NULL, *creds = NULL;
static char *kwlist[] = { "printername", "creds", "access", NULL };
uint32 desired_access = MAXIMUM_ALLOWED_ACCESS;
struct cli_state *cli;
if (!PyArg_ParseTupleAndKeywords(
args, kw, "s|Oi", kwlist, &unc_name, &creds,
&desired_access))
return NULL;
if (unc_name[0] != '\\' || unc_name[1] != '\\') {
PyErr_SetString(PyExc_ValueError, "UNC name required");
return NULL;
}
server = strdup(unc_name + 2);
if (strchr(server, '\\')) {
char *c = strchr(server, '\\');
*c = 0;
}
if (creds && creds != Py_None && !PyDict_Check(creds)) {
PyErr_SetString(PyExc_TypeError,
"credentials must be dictionary or None");
return NULL;
}
if (!(cli = open_pipe_creds(server, creds, PI_SPOOLSS, &errstr))) {
PyErr_SetString(spoolss_error, errstr);
free(errstr);
goto done;
}
if (!(mem_ctx = talloc_init("spoolss_openprinter"))) {
PyErr_SetString(spoolss_error,
"unable to init talloc context\n");
goto done;
}
werror = cli_spoolss_open_printer_ex(
cli, mem_ctx, unc_name, "", desired_access, server,
"", &hnd);
if (!W_ERROR_IS_OK(werror)) {
PyErr_SetObject(spoolss_werror, py_werror_tuple(werror));
goto done;
}
result = new_spoolss_policy_hnd_object(cli, mem_ctx, &hnd);
done:
if (!result) {
if (cli)
cli_shutdown(cli);
if (mem_ctx)
talloc_destroy(mem_ctx);
}
SAFE_FREE(server);
return result;
}
PyObject *PyErr_SetExcFromWindowsErrWithFilenameObjects(
PyObject *exc,
int ierr,
PyObject *filenameObject,
PyObject *filenameObject2)
{
int len;
WCHAR *s_buf = NULL; /* Free via LocalFree */
PyObject *message;
PyObject *args, *v;
DWORD err = (DWORD)ierr;
if (err==0) err = GetLastError();
len = FormatMessageW(
/* Error API error */
FORMAT_MESSAGE_ALLOCATE_BUFFER |
FORMAT_MESSAGE_FROM_SYSTEM |
FORMAT_MESSAGE_IGNORE_INSERTS,
NULL, /* no message source */
err,
MAKELANGID(LANG_NEUTRAL,
SUBLANG_DEFAULT), /* Default language */
(LPWSTR) &s_buf,
0, /* size not used */
NULL); /* no args */
if (len==0) {
/* Only seen this in out of mem situations */
message = PyUnicode_FromFormat("Windows Error 0x%x", err);
s_buf = NULL;
} else {
/* remove trailing cr/lf and dots */
while (len > 0 && (s_buf[len-1] <= L' ' || s_buf[len-1] == L'.'))
s_buf[--len] = L'\0';
message = PyUnicode_FromWideChar(s_buf, len);
}
if (message == NULL)
{
LocalFree(s_buf);
return NULL;
}
if (filenameObject == NULL) {
assert(filenameObject2 == NULL);
filenameObject = filenameObject2 = Py_None;
}
else if (filenameObject2 == NULL)
filenameObject2 = Py_None;
/* This is the constructor signature for OSError.
The POSIX translation will be figured out by the constructor. */
args = Py_BuildValue("(iOOiO)", 0, message, filenameObject, err, filenameObject2);
Py_DECREF(message);
if (args != NULL) {
v = PyObject_Call(exc, args, NULL);
Py_DECREF(args);
if (v != NULL) {
PyErr_SetObject((PyObject *) Py_TYPE(v), v);
Py_DECREF(v);
}
}
LocalFree(s_buf);
return NULL;
}
void
PyErr_SetNone(PyObject *exception)
{
PyErr_SetObject(exception, (PyObject *)NULL);
}
static PyObject *
Util_func_interface_addresses(PyObject *obj)
{
static char buf[INET6_ADDRSTRLEN+1];
int i, count;
uv_interface_address_t* interfaces;
int err;
PyObject *result, *item, *exc_data;
UNUSED_ARG(obj);
err = uv_interface_addresses(&interfaces, &count);
if (err < 0) {
exc_data = Py_BuildValue("(is)", err, uv_strerror(err));
if (exc_data != NULL) {
PyErr_SetObject(PyExc_UVError, exc_data);
Py_DECREF(exc_data);
}
return NULL;
}
result = PyList_New(count);
if (!result) {
uv_free_interface_addresses(interfaces, count);
return NULL;
}
for (i = 0; i < count; i++) {
item = PyStructSequence_New(&InterfaceAddressesResultType);
if (!item) {
Py_DECREF(result);
uv_free_interface_addresses(interfaces, count);
return NULL;
}
PyStructSequence_SET_ITEM(item, 0, Py_BuildValue("s", interfaces[i].name));
PyStructSequence_SET_ITEM(item, 1, PyBool_FromLong((long)interfaces[i].is_internal));
if (interfaces[i].address.address4.sin_family == AF_INET) {
uv_ip4_name(&interfaces[i].address.address4, buf, sizeof(buf));
} else if (interfaces[i].address.address4.sin_family == AF_INET6) {
uv_ip6_name(&interfaces[i].address.address6, buf, sizeof(buf));
}
PyStructSequence_SET_ITEM(item, 2, Py_BuildValue("s", buf));
if (interfaces[i].netmask.netmask4.sin_family == AF_INET) {
uv_ip4_name(&interfaces[i].netmask.netmask4, buf, sizeof(buf));
} else if (interfaces[i].netmask.netmask4.sin_family == AF_INET6) {
uv_ip6_name(&interfaces[i].netmask.netmask6, buf, sizeof(buf));
}
PyStructSequence_SET_ITEM(item, 3, Py_BuildValue("s", buf));
PyOS_snprintf(buf, sizeof(buf), "%02x:%02x:%02x:%02x:%02x:%02x",
(unsigned char)interfaces[i].phys_addr[0],
(unsigned char)interfaces[i].phys_addr[1],
(unsigned char)interfaces[i].phys_addr[2],
(unsigned char)interfaces[i].phys_addr[3],
(unsigned char)interfaces[i].phys_addr[4],
(unsigned char)interfaces[i].phys_addr[5]);
PyStructSequence_SET_ITEM(item, 4, Py_BuildValue("s", buf));
PyList_SET_ITEM(result, i, item);
}
uv_free_interface_addresses(interfaces, count);
return result;
}
int AppendEscapedArg (Connection *self, char *start, char *end, PyObject *obj)
{
int ret;
PyObject *strobj;
/*
FIXME: Surround strings with '' could be performed in this function to avoid extra logic in AppendAndEscapeString */
PRINTMARK();
if (PyString_Check(obj))
{
PRINTMARK();
return AppendAndEscapeString(start, end, PyString_AS_STRING(obj), PyString_AS_STRING(obj) + PyString_GET_SIZE(obj), TRUE);
}
else
if (PyUnicode_Check(obj))
{
PRINTMARK();
strobj = self->PFN_PyUnicode_Encode(PyUnicode_AS_UNICODE(obj), PyUnicode_GET_SIZE(obj), NULL);
if (strobj == NULL)
{
if (PyErr_Occurred())
{
return -1;
}
PyErr_SetObject (PyExc_ValueError, obj);
return -1;
}
ret = AppendAndEscapeString(start, end, PyString_AS_STRING(strobj), PyString_AS_STRING(strobj) + PyString_GET_SIZE(strobj), TRUE);
Py_DECREF(strobj);
return ret;
}
else
if (obj == Py_None)
{
(*start++) = 'n';
(*start++) = 'u';
(*start++) = 'l';
(*start++) = 'l';
return 4;
}
else
if (PyDateTime_Check(obj))
{
int len = sprintf (start, "'%04d-%02d-%02d %02d:%02d:%02d'",
PyDateTime_GET_YEAR(obj),
PyDateTime_GET_MONTH(obj),
PyDateTime_GET_DAY(obj),
PyDateTime_DATE_GET_HOUR(obj),
PyDateTime_DATE_GET_MINUTE(obj),
PyDateTime_DATE_GET_SECOND(obj));
return len;
}
else
if (PyDate_Check(obj))
{
int len = sprintf (start, "'%04d:%02d:%02d'",
PyDateTime_GET_YEAR(obj),
PyDateTime_GET_MONTH(obj),
PyDateTime_GET_DAY(obj));
return len;
}
//FIXME: Might possible to avoid this?
PRINTMARK();
strobj = PyObject_Str(obj);
ret = AppendAndEscapeString(start, end, PyString_AS_STRING(strobj), PyString_AS_STRING(strobj) + PyString_GET_SIZE(strobj), FALSE);
Py_DECREF(strobj);
return ret;
}
PyObject *Connection_query(Connection *self, PyObject *args)
{
void *ret;
PyObject *inQuery = NULL;
PyObject *query = NULL;
PyObject *iterable = NULL;
PyObject *escapedQuery = NULL;
if (!UMConnection_IsConnected(self->conn))
{
return PyErr_Format(PyExc_RuntimeError, "Not connected");
}
if (!PyArg_ParseTuple (args, "O|O", &inQuery, &iterable))
{
return NULL;
}
if (iterable)
{
PyObject *iterator = PyObject_GetIter(iterable);
if (iterator == NULL)
{
PyErr_Clear();
return PyErr_Format(PyExc_TypeError, "Expected iterable");
}
Py_DECREF(iterator);
}
if (!PyString_Check(inQuery))
{
if (!PyUnicode_Check(inQuery))
{
PRINTMARK();
return PyErr_Format(PyExc_TypeError, "Query argument must be either String or Unicode");
}
query = self->PFN_PyUnicode_Encode(PyUnicode_AS_UNICODE(inQuery), PyUnicode_GET_SIZE(inQuery), NULL);
if (query == NULL)
{
if (!PyErr_Occurred())
{
PyErr_SetObject(PyExc_ValueError, query);
return NULL;
}
return NULL;
}
}
else
{
query = inQuery;
Py_INCREF(query);
}
if (iterable)
{
PRINTMARK();
escapedQuery = EscapeQueryArguments(self, query, iterable);
Py_DECREF(query);
if (escapedQuery == NULL)
{
if (!PyErr_Occurred())
{
return PyErr_Format(PyExc_RuntimeError, "Exception not set in EscapeQueryArguments chain");
}
return NULL;
}
}
else
{
escapedQuery = query;
}
ret = UMConnection_Query(self->conn, PyString_AS_STRING(escapedQuery), PyString_GET_SIZE(escapedQuery));
Py_DECREF(escapedQuery);
PRINTMARK();
if (ret == NULL)
{
return HandleError(self, "query");
}
PRINTMARK();
return (PyObject *) ret;
}
static PyObject *Stream_iternext(StreamObject *self)
{
PyObject *attribute = NULL;
PyObject *method = NULL;
PyObject *args = NULL;
PyObject *result = NULL;
attribute = PyObject_GetAttrString((PyObject *)self, "filelike");
if (!attribute) {
PyErr_SetString(PyExc_KeyError,
"file wrapper no filelike attribute");
return 0;
}
method = PyObject_GetAttrString(attribute, "read");
if (!method) {
PyErr_SetString(PyExc_KeyError,
"file like object has no read() method");
Py_DECREF(attribute);
return 0;
}
Py_DECREF(attribute);
attribute = PyObject_GetAttrString((PyObject *)self, "blksize");
if (!attribute) {
PyErr_SetString(PyExc_KeyError,
"file wrapper has no blksize attribute");
Py_DECREF(method);
return 0;
}
if (!PyLong_Check(attribute)) {
PyErr_SetString(PyExc_KeyError,
"file wrapper blksize attribute not integer");
Py_DECREF(method);
Py_DECREF(attribute);
return 0;
}
args = Py_BuildValue("(O)", attribute);
result = PyEval_CallObject(method, args);
Py_DECREF(args);
Py_DECREF(method);
Py_DECREF(attribute);
if (!result)
return 0;
if (PyString_Check(result)) {
if (PyString_Size(result) == 0) {
PyErr_SetObject(PyExc_StopIteration, Py_None);
Py_DECREF(result);
return 0;
}
return result;
}
Py_DECREF(result);
PyErr_SetString(PyExc_TypeError,
"file like object yielded non string type");
return 0;
}
/**
*******************************************************************************************************
* This function applies a registered udf module on a particular record.
*
* @param self AerospikeClient object
* @param py_key The key under which to store the record.
* @param py_module The module name.
* @param py_function The UDF function to be applied on a record.
* @param py_arglist The arguments to the UDF function
* @param py_policy The optional policy parameters
*
* Returns the result of UDF function.
*******************************************************************************************************
*/
PyObject * AerospikeClient_Apply_Invoke(
AerospikeClient * self,
PyObject * py_key, PyObject * py_module, PyObject * py_function,
PyObject * py_arglist, PyObject * py_policy)
{
// Python Return Value
PyObject * py_result = NULL;
// Aerospike Client Arguments
as_error err;
as_policy_apply apply_policy;
as_policy_apply * apply_policy_p = NULL;
as_key key;
char * module = NULL;
char * function = NULL;
as_list * arglist = NULL;
as_val * result = NULL;
PyObject * py_umodule = NULL;
PyObject * py_ufunction = NULL;
// Initialisation flags
bool key_initialised = false;
// Initialize error
as_error_init(&err);
if( !PyList_Check(py_arglist) ) {
PyErr_SetString(PyExc_TypeError, "expected UDF method arguments in a 'list'");
return NULL;
}
if (!self || !self->as) {
as_error_update(&err, AEROSPIKE_ERR_PARAM, "Invalid aerospike object");
goto CLEANUP;
}
if (!self->is_conn_16) {
as_error_update(&err, AEROSPIKE_ERR_CLUSTER, "No connection to aerospike cluster");
goto CLEANUP;
}
// Convert python key object to as_key
pyobject_to_key(&err, py_key, &key);
if ( err.code != AEROSPIKE_OK ) {
goto CLEANUP;
}
// Key is initialiased successfully
key_initialised = true;
// Convert python list to as_list
pyobject_to_list(self, &err, py_arglist, &arglist, NULL, -1);
if ( err.code != AEROSPIKE_OK ) {
goto CLEANUP;
}
// Convert python policy object to as_policy_apply
pyobject_to_policy_apply(&err, py_policy, &apply_policy, &apply_policy_p,
&self->as->config.policies.apply);
if ( err.code != AEROSPIKE_OK ) {
goto CLEANUP;
}
if ( PyUnicode_Check(py_module) ) {
py_umodule = PyUnicode_AsUTF8String(py_module);
module = PyStr_AsString(py_umodule);
}
else if ( PyStr_Check(py_module) ) {
module = PyStr_AsString(py_module);
}
else {
as_error_update(&err, AEROSPIKE_ERR_CLIENT, "udf module argument must be a string or unicode string");
goto CLEANUP;
}
if ( PyUnicode_Check(py_function) ) {
py_ufunction = PyUnicode_AsUTF8String(py_function);
function = PyStr_AsString(py_ufunction);
}
else if ( PyStr_Check(py_function) ) {
function = PyStr_AsString(py_function);
}
else {
as_error_update(&err, AEROSPIKE_ERR_CLIENT, "function name must be a string or unicode string");
goto CLEANUP;
}
// Invoke operation
aerospike_key_apply(self->as, &err, apply_policy_p, &key, module, function, arglist, &result);
if ( err.code == AEROSPIKE_OK ) {
val_to_pyobject(&err, result, &py_result);
} else {
as_error_update(&err, err.code, NULL);
}
CLEANUP:
if (py_umodule) {
Py_DECREF(py_umodule);
}
if (py_ufunction) {
Py_DECREF(py_ufunction);
}
if (key_initialised == true) {
// Destroy the key if it is initialised successfully.
as_key_destroy(&key);
}
as_list_destroy(arglist);
as_val_destroy(result);
if ( err.code != AEROSPIKE_OK ) {
PyObject * py_err = NULL;
error_to_pyobject(&err, &py_err);
PyObject *exception_type = raise_exception(&err);
if(PyObject_HasAttrString(exception_type, "key")) {
PyObject_SetAttrString(exception_type, "key", py_key);
}
if(PyObject_HasAttrString(exception_type, "bin")) {
PyObject_SetAttrString(exception_type, "bin", Py_None);
}
if(PyObject_HasAttrString(exception_type, "module")) {
PyObject_SetAttrString(exception_type, "module", py_module);
}
if(PyObject_HasAttrString(exception_type, "func")) {
PyObject_SetAttrString(exception_type, "func", py_function);
}
PyErr_SetObject(exception_type, py_err);
Py_DECREF(py_err);
return NULL;
}
return py_result;
}
/**
*******************************************************************************************************
* Increments a numeric value in a bin.
*
* @param self AerospikeClient object
* @param args The args is a tuple object containing an argument
* list passed from Python to a C function
* @param kwds Dictionary of keywords
*
* Returns an integer status. 0(Zero) is success value.
* In case of error,appropriate exceptions will be raised.
*******************************************************************************************************
*/
PyObject * AerospikeClient_Increment(AerospikeClient * self, PyObject * args, PyObject * kwds)
{
// Initialize error
as_error err;
as_error_init(&err);
// Python Function Arguments
PyObject * py_key = NULL;
PyObject * py_policy = NULL;
PyObject * py_result = NULL;
PyObject * py_bin = NULL;
PyObject * py_meta = NULL;
PyObject * py_offset_value = 0;
as_key key;
as_policy_operate operate_policy;
as_policy_operate *operate_policy_p = NULL;
// Python Function Keyword Arguments
static char * kwlist[] = {"key", "bin", "offset", "meta",
"policy", NULL};
// Python Function Argument Parsing
if ( PyArg_ParseTupleAndKeywords(args, kwds, "OOO|OO:increment", kwlist,
&py_key, &py_bin, &py_offset_value, &py_meta,
&py_policy) == false ) {
return NULL;
}
if (!self || !self->as) {
as_error_update(&err, AEROSPIKE_ERR_PARAM, "Invalid aerospike object");
goto CLEANUP;
}
if (!self->is_conn_16) {
as_error_update(&err, AEROSPIKE_ERR_CLUSTER, "No connection to aerospike cluster");
goto CLEANUP;
}
py_result = AerospikeClient_convert_pythonObj_to_asType(self, &err,
py_key, py_policy, &key, &operate_policy, &operate_policy_p);
if (!py_result) {
goto CLEANUP;
} else {
Py_DECREF(py_result);
}
PyObject * py_list = NULL;
py_list = create_pylist(py_list, AS_OPERATOR_INCR, py_bin, py_offset_value);
py_result = AerospikeClient_Operate_Invoke(self, &err, &key, py_list,
py_meta, operate_policy_p);
if (py_list) {
Py_DECREF(py_list);
}
if (err.code != AEROSPIKE_OK) {
as_error_update(&err, err.code, NULL);
goto CLEANUP;
} else if (py_result == NULL) {
return NULL;
} else {
Py_DECREF(py_result);
}
CLEANUP:
if ( err.code != AEROSPIKE_OK ) {
PyObject * py_err = NULL;
error_to_pyobject(&err, &py_err);
PyObject *exception_type = raise_exception(&err);
if(PyObject_HasAttrString(exception_type, "key")) {
PyObject_SetAttrString(exception_type, "key", py_key);
}
if(PyObject_HasAttrString(exception_type, "bin")) {
PyObject_SetAttrString(exception_type, "bin", py_bin);
}
PyErr_SetObject(exception_type, py_err);
Py_DECREF(py_err);
return NULL;
}
return PyLong_FromLong(0);
}
/**
*******************************************************************************************************
* Multiple operations on a single record
*
* @param self AerospikeClient object
* @param args The args is a tuple object containing an argument
* list passed from Python to a C function
* @param kwds Dictionary of keywords
*
* Returns tuple of bins on success if read operation is given.
* Otherwise returns 0 on success for other operations.
*******************************************************************************************************
*/
PyObject * AerospikeClient_Operate(AerospikeClient * self, PyObject * args, PyObject * kwds)
{
// Initialize error
as_error err;
as_error_init(&err);
// Python Function Arguments
PyObject * py_key = NULL;
PyObject * py_list = NULL;
PyObject * py_policy = NULL;
PyObject * py_result = NULL;
PyObject * py_meta = NULL;
as_key key;
as_policy_operate operate_policy;
as_policy_operate *operate_policy_p = NULL;
// Python Function Keyword Arguments
static char * kwlist[] = {"key", "list", "meta", "policy", NULL};
// Python Function Argument Parsing
if ( PyArg_ParseTupleAndKeywords(args, kwds, "OO|OO:operate", kwlist,
&py_key, &py_list, &py_meta, &py_policy) == false ) {
return NULL;
}
if (!self || !self->as) {
as_error_update(&err, AEROSPIKE_ERR_PARAM, "Invalid aerospike object");
goto CLEANUP;
}
if (!self->is_conn_16) {
as_error_update(&err, AEROSPIKE_ERR_CLUSTER, "No connection to aerospike cluster");
goto CLEANUP;
}
py_result = AerospikeClient_convert_pythonObj_to_asType(self, &err,
py_key, py_policy, &key, &operate_policy, &operate_policy_p);
if (!py_result) {
goto CLEANUP;
} else {
Py_DECREF(py_result);
}
if ( py_list != NULL && PyList_Check(py_list) ) {
py_result = AerospikeClient_Operate_Invoke(self, &err, &key, py_list, py_meta, operate_policy_p);
} else {
as_error_update(&err, AEROSPIKE_ERR_PARAM, "Operations should be of type list");
goto CLEANUP;
}
CLEANUP:
if ( err.code != AEROSPIKE_OK ) {
PyObject * py_err = NULL;
error_to_pyobject(&err, &py_err);
PyObject *exception_type = raise_exception(&err);
if(PyObject_HasAttrString(exception_type, "key")) {
PyObject_SetAttrString(exception_type, "key", py_key);
}
PyErr_SetObject(exception_type, py_err);
Py_DECREF(py_err);
return NULL;
}
return py_result;
}
/* Convert an LDAP error into an informative python exception */
PyObject*
LDAPerror( LDAP*l, char*msg )
{
if (l == NULL) {
PyErr_SetFromErrno( LDAPexception_class );
return NULL;
}
else {
int errnum;
PyObject *errobj;
PyObject *info;
PyObject *str;
char *matched, *error;
if (ldap_get_option(l, LDAP_OPT_ERROR_NUMBER, &errnum) < 0)
errobj = LDAPexception_class; /* unknown error XXX */
else
errobj = errobjects[errnum+LDAP_ERROR_OFFSET];
if (errnum == LDAP_NO_MEMORY)
return PyErr_NoMemory();
info = PyDict_New();
if (info == NULL)
return NULL;
str = PyBytes_FromString(ldap_err2string(errnum));
if (str)
PyDict_SetItemString( info, "desc", str );
Py_XDECREF(str);
if (ldap_get_option(l, LDAP_OPT_MATCHED_DN, &matched) >= 0
&& matched != NULL) {
if (*matched != '\0') {
str = PyBytes_FromString(matched);
if (str)
PyDict_SetItemString( info, "matched", str );
Py_XDECREF(str);
}
ldap_memfree(matched);
}
if (errnum == LDAP_REFERRAL) {
str = PyBytes_FromString(msg);
if (str)
PyDict_SetItemString( info, "info", str );
Py_XDECREF(str);
} else if (ldap_get_option(l, LDAP_OPT_ERROR_STRING, &error) >= 0
&& error != NULL) {
if (error != '\0') {
str = PyBytes_FromString(error);
if (str)
PyDict_SetItemString( info, "info", str );
Py_XDECREF(str);
}
ldap_memfree(error);
}
PyErr_SetObject( errobj, info );
Py_DECREF(info);
return NULL;
}
}
PyObject *
Base_getattro(PyObject *obj, PyObject *name)
{
/* This is a modified copy of PyObject_GenericGetAttr.
See the change note below. */
PyTypeObject *tp = obj->ob_type;
PyObject *descr = NULL;
PyObject *res = NULL;
descrgetfunc f;
long dictoffset;
PyObject **dictptr;
if (!PyString_Check(name)){
#ifdef Py_USING_UNICODE
/* The Unicode to string conversion is done here because the
existing tp_setattro slots expect a string object as name
and we wouldn't want to break those. */
if (PyUnicode_Check(name)) {
name = PyUnicode_AsEncodedString(name, NULL, NULL);
if (name == NULL)
return NULL;
}
else
#endif
{
PyErr_SetString(PyExc_TypeError,
"attribute name must be string");
return NULL;
}
}
else
Py_INCREF(name);
if (tp->tp_dict == NULL) {
if (PyType_Ready(tp) < 0)
goto done;
}
#if !defined(Py_TPFLAGS_HAVE_VERSION_TAG)
/* Inline _PyType_Lookup */
/* this is not quite _PyType_Lookup anymore */
{
int i, n;
PyObject *mro, *base, *dict;
/* Look in tp_dict of types in MRO */
mro = tp->tp_mro;
assert(mro != NULL);
assert(PyTuple_Check(mro));
n = PyTuple_GET_SIZE(mro);
for (i = 0; i < n; i++) {
base = PyTuple_GET_ITEM(mro, i);
if (PyClass_Check(base))
dict = ((PyClassObject *)base)->cl_dict;
else {
assert(PyType_Check(base));
dict = ((PyTypeObject *)base)->tp_dict;
}
assert(dict && PyDict_Check(dict));
descr = PyDict_GetItem(dict, name);
if (descr != NULL)
break;
}
}
#else
descr = _PyType_Lookup(tp, name);
#endif
Py_XINCREF(descr);
f = NULL;
if (descr != NULL &&
PyType_HasFeature(descr->ob_type, Py_TPFLAGS_HAVE_CLASS)) {
f = descr->ob_type->tp_descr_get;
if (f != NULL && PyDescr_IsData(descr)) {
res = f(descr, obj, (PyObject *)obj->ob_type);
Py_DECREF(descr);
goto done;
}
}
/* Inline _PyObject_GetDictPtr */
dictoffset = tp->tp_dictoffset;
if (dictoffset != 0) {
PyObject *dict;
if (dictoffset < 0) {
int tsize;
size_t size;
tsize = ((PyVarObject *)obj)->ob_size;
if (tsize < 0)
tsize = -tsize;
size = _PyObject_VAR_SIZE(tp, tsize);
dictoffset += (long)size;
assert(dictoffset > 0);
assert(dictoffset % SIZEOF_VOID_P == 0);
}
dictptr = (PyObject **) ((char *)obj + dictoffset);
dict = *dictptr;
if (dict != NULL) {
Py_INCREF(dict);
res = PyDict_GetItem(dict, name);
if (res != NULL) {
Py_INCREF(res);
Py_XDECREF(descr);
Py_DECREF(dict);
/* CHANGED!
If the tp_descr_get of res is of_get,
then call it. */
if ((strcmp(PyString_AsString(name), "__parent__") != 0) &&
PyObject_TypeCheck(res->ob_type,
&ExtensionClassType)
&& res->ob_type->tp_descr_get != NULL) {
PyObject *tres;
tres = res->ob_type->tp_descr_get(
res, obj,
OBJECT(obj->ob_type));
Py_DECREF(res);
res = tres;
}
goto done;
}
Py_DECREF(dict);
}
}
if (f != NULL) {
res = f(descr, obj, (PyObject *)obj->ob_type);
Py_DECREF(descr);
goto done;
}
if (descr != NULL) {
res = descr;
/* descr was already increfed above */
goto done;
}
/* CHANGED: Just use the name. Don't format. */
PyErr_SetObject(PyExc_AttributeError, name);
done:
Py_DECREF(name);
return res;
}
AerospikeQuery * AerospikeQuery_Apply(AerospikeQuery * self, PyObject * args, PyObject * kwds)
{
// Python function arguments
PyObject * py_module = NULL;
PyObject * py_function = NULL;
PyObject * py_args = NULL;
PyObject * py_policy = NULL;
PyObject * py_umodule = NULL;
PyObject * py_ufunction = NULL;
// Python function keyword arguments
static char * kwlist[] = {"module", "function", "arguments", "policy", NULL};
if ( PyArg_ParseTupleAndKeywords(args, kwds, "OO|OO:apply", kwlist, &py_module, &py_function, &py_args, &py_policy) == false ){
return NULL;
}
// Aerospike error object
as_error err;
// Initialize error object
as_error_init(&err);
if ( !self || !self->client->as ){
as_error_update(&err, AEROSPIKE_ERR_PARAM, "Invalid query object");
goto CLEANUP;
}
if (!self->client->is_conn_16) {
as_error_update(&err, AEROSPIKE_ERR_CLUSTER, "No connection to aerospike cluster");
goto CLEANUP;
}
// Aerospike API Arguments
char * module = NULL;
char * function = NULL;
as_arraylist * arglist = NULL;
if ( PyUnicode_Check(py_module) ){
py_umodule = PyUnicode_AsUTF8String(py_module);
module = PyStr_AsString(py_umodule);
}
else if ( PyStr_Check(py_module) ) {
module = PyStr_AsString(py_module);
}
else {
as_error_update(&err, AEROSPIKE_ERR_CLIENT, "udf module argument must be a string or unicode string");
goto CLEANUP;
}
if ( PyUnicode_Check(py_function) ){
py_ufunction = PyUnicode_AsUTF8String(py_function);
function = PyStr_AsString(py_ufunction);
}
else if ( PyStr_Check(py_function) ) {
function = PyStr_AsString(py_function);
}
else {
as_error_update(&err, AEROSPIKE_ERR_CLIENT, "udf function argument must be a string or unicode string");
goto CLEANUP;
}
if ( py_args && PyList_Check(py_args) ){
Py_ssize_t size = PyList_Size(py_args);
arglist = as_arraylist_new(size, 0);
for ( int i = 0; i < size; i++ ) {
PyObject * py_val = PyList_GetItem(py_args, (Py_ssize_t)i);
as_val * val = NULL;
pyobject_to_val(self->client, &err, py_val, &val, &self->static_pool, SERIALIZER_PYTHON);
if ( err.code != AEROSPIKE_OK ) {
as_error_update(&err, err.code, NULL);
goto CLEANUP;
}
else {
as_arraylist_append(arglist, val);
}
}
}
as_query_apply(&self->query, module, function, (as_list *) arglist);
CLEANUP:
if (py_ufunction) {
Py_DECREF(py_ufunction);
}
if (py_umodule) {
Py_DECREF(py_umodule);
}
if ( err.code != AEROSPIKE_OK ) {
PyObject * py_err = NULL;
error_to_pyobject(&err, &py_err);
PyObject *exception_type = raise_exception(&err);
if(PyObject_HasAttrString(exception_type, "module")) {
PyObject_SetAttrString(exception_type, "module", py_module);
}
if(PyObject_HasAttrString(exception_type, "func")) {
PyObject_SetAttrString(exception_type, "func", py_function);
}
PyErr_SetObject(exception_type, py_err);
Py_DECREF(py_err);
return NULL;
}
Py_INCREF(self);
return self;
}
PyObject *
PyErr_SetFromErrnoWithFilenameObjects(PyObject *exc, PyObject *filenameObject, PyObject *filenameObject2)
{
PyObject *message;
PyObject *v, *args;
int i = errno;
#ifdef MS_WINDOWS
WCHAR *s_buf = NULL;
#endif /* Unix/Windows */
#ifdef EINTR
if (i == EINTR && PyErr_CheckSignals())
return NULL;
#endif
#ifndef MS_WINDOWS
if (i != 0) {
char *s = strerror(i);
message = PyUnicode_DecodeLocale(s, "surrogateescape");
}
else {
/* Sometimes errno didn't get set */
message = PyUnicode_FromString("Error");
}
#else
if (i == 0)
message = PyUnicode_FromString("Error"); /* Sometimes errno didn't get set */
else
{
/* Note that the Win32 errors do not lineup with the
errno error. So if the error is in the MSVC error
table, we use it, otherwise we assume it really _is_
a Win32 error code
*/
if (i > 0 && i < _sys_nerr) {
message = PyUnicode_FromString(_sys_errlist[i]);
}
else {
int len = FormatMessageW(
FORMAT_MESSAGE_ALLOCATE_BUFFER |
FORMAT_MESSAGE_FROM_SYSTEM |
FORMAT_MESSAGE_IGNORE_INSERTS,
NULL, /* no message source */
i,
MAKELANGID(LANG_NEUTRAL,
SUBLANG_DEFAULT),
/* Default language */
(LPWSTR) &s_buf,
0, /* size not used */
NULL); /* no args */
if (len==0) {
/* Only ever seen this in out-of-mem
situations */
s_buf = NULL;
message = PyUnicode_FromFormat("Windows Error 0x%x", i);
} else {
/* remove trailing cr/lf and dots */
while (len > 0 && (s_buf[len-1] <= L' ' || s_buf[len-1] == L'.'))
s_buf[--len] = L'\0';
message = PyUnicode_FromWideChar(s_buf, len);
}
}
}
#endif /* Unix/Windows */
if (message == NULL)
{
#ifdef MS_WINDOWS
LocalFree(s_buf);
#endif
return NULL;
}
if (filenameObject != NULL) {
if (filenameObject2 != NULL)
args = Py_BuildValue("(iOOiO)", i, message, filenameObject, 0, filenameObject2);
else
args = Py_BuildValue("(iOO)", i, message, filenameObject);
} else {
assert(filenameObject2 == NULL);
args = Py_BuildValue("(iO)", i, message);
}
Py_DECREF(message);
if (args != NULL) {
v = PyObject_Call(exc, args, NULL);
Py_DECREF(args);
if (v != NULL) {
PyErr_SetObject((PyObject *) Py_TYPE(v), v);
Py_DECREF(v);
}
}
#ifdef MS_WINDOWS
LocalFree(s_buf);
#endif
return NULL;
}
/**
*******************************************************************************************************
* This function invokes csdk's API to remove particular record.
*
* @param self AerospikeClient object
* @param py_key The key under which to store the record
* @param generation The generation value
* @param py_policy The optional policy parameters
*
* Returns 0 on success.
* In case of error,appropriate exceptions will be raised.
*******************************************************************************************************
*/
PyObject * AerospikeClient_Remove_Invoke(
AerospikeClient * self,
PyObject * py_key, PyObject * py_meta, PyObject * py_policy)
{
// Aerospike Client Arguments
as_error err;
as_policy_remove remove_policy;
as_policy_remove * remove_policy_p = NULL;
as_key key;
// Initialisation flags
bool key_initialised = false;
// Initialize error
as_error_init(&err);
if (!self || !self->as) {
as_error_update(&err, AEROSPIKE_ERR_PARAM, "Invalid aerospike object");
goto CLEANUP;
}
if (!self->is_conn_16) {
as_error_update(&err, AEROSPIKE_ERR_CLUSTER, "No connection to aerospike cluster");
goto CLEANUP;
}
// Convert python key object to as_key
pyobject_to_key(&err, py_key, &key);
if ( err.code != AEROSPIKE_OK ) {
goto CLEANUP;
}
// Key is initialised successfully
key_initialised = true;
// Convert python policy object to as_policy_exists
if (py_policy) {
pyobject_to_policy_remove(&err, py_policy, &remove_policy, &remove_policy_p,
&self->as->config.policies.remove);
if ( err.code != AEROSPIKE_OK ) {
goto CLEANUP;
} else {
if ( py_meta && PyDict_Check(py_meta) ) {
PyObject * py_gen = PyDict_GetItemString(py_meta, "gen");
if( py_gen != NULL ){
if ( PyInt_Check(py_gen) ) {
remove_policy_p->generation = (uint16_t) PyInt_AsLong(py_gen);
} else if ( PyLong_Check(py_gen) ) {
remove_policy_p->generation = (uint16_t) PyLong_AsLongLong(py_gen);
if((uint16_t)-1 == remove_policy_p->generation) {
as_error_update(&err, AEROSPIKE_ERR_PARAM, "integer value for gen exceeds sys.maxsize");
goto CLEANUP;
}
} else {
as_error_update(&err, AEROSPIKE_ERR_PARAM, "Generation should be an int or long");
}
}
}
}
}
// Invoke operation
Py_BEGIN_ALLOW_THREADS
aerospike_key_remove(self->as, &err, remove_policy_p, &key);
Py_END_ALLOW_THREADS
if(err.code != AEROSPIKE_OK) {
as_error_update(&err, err.code, NULL);
}
CLEANUP:
if (key_initialised == true){
// Destroy the key if it is initialised successfully.
as_key_destroy(&key);
}
if ( err.code != AEROSPIKE_OK ) {
PyObject * py_err = NULL;
error_to_pyobject(&err, &py_err);
PyObject *exception_type = raise_exception(&err);
if(PyObject_HasAttrString(exception_type, "key")) {
PyObject_SetAttrString(exception_type, "key", py_key);
}
if(PyObject_HasAttrString(exception_type, "bin")) {
PyObject_SetAttrString(exception_type, "bin", Py_None);
}
PyErr_SetObject(exception_type, py_err);
Py_DECREF(py_err);
return NULL;
}
return PyLong_FromLong(0);
}
PyObject *spoolss_hnd_setprinter(PyObject *self, PyObject *args, PyObject *kw)
{
spoolss_policy_hnd_object *hnd = (spoolss_policy_hnd_object *)self;
WERROR werror;
PyObject *info;
PRINTER_INFO_CTR ctr;
uint32 level;
static char *kwlist[] = {"dict", NULL};
union {
PRINTER_INFO_1 printers_1;
PRINTER_INFO_2 printers_2;
PRINTER_INFO_3 printers_3;
} pinfo;
/* Parse parameters */
if (!PyArg_ParseTupleAndKeywords(
args, kw, "O!", kwlist, &PyDict_Type, &info))
return NULL;
if (!get_level_value(info, &level)) {
PyErr_SetString(spoolss_error, "invalid info level");
return NULL;
}
if (level < 1 && level > 3) {
PyErr_SetString(spoolss_error, "unsupported info level");
return NULL;
}
/* Fill in printer info */
ZERO_STRUCT(ctr);
switch (level) {
case 1:
ctr.printers_1 = &pinfo.printers_1;
if (!py_to_PRINTER_INFO_1(ctr.printers_1, info)){
PyErr_SetString(spoolss_error,
"error converting printer to info 1");
return NULL;
}
break;
case 2:
ctr.printers_2 = &pinfo.printers_2;
if (!py_to_PRINTER_INFO_2(ctr.printers_2, info,
hnd->mem_ctx)){
PyErr_SetString(spoolss_error,
"error converting printer to info 2");
return NULL;
}
break;
case 3:
ctr.printers_3 = &pinfo.printers_3;
if (!py_to_PRINTER_INFO_3(ctr.printers_3, info,
hnd->mem_ctx)) {
PyErr_SetString(spoolss_error,
"error converting to printer info 3");
return NULL;
}
break;
default:
PyErr_SetString(spoolss_error, "unsupported info level");
return NULL;
}
/* Call rpc function */
werror = cli_spoolss_setprinter(hnd->cli, hnd->mem_ctx, &hnd->pol,
level, &ctr, 0);
/* Return value */
if (!W_ERROR_IS_OK(werror)) {
PyErr_SetObject(spoolss_werror, py_werror_tuple(werror));
return NULL;
}
Py_INCREF(Py_None);
return Py_None;
}
static void
err_input(perrdetail *err)
{
PyObject *v, *w, *errtype;
char *msg = NULL;
errtype = PyExc_SyntaxError;
v = Py_BuildValue("(ziiz)", err->filename,
err->lineno, err->offset, err->text);
if (err->text != NULL) {
PyMem_DEL(err->text);
err->text = NULL;
}
switch (err->error) {
case E_SYNTAX:
errtype = PyExc_IndentationError;
if (err->expected == INDENT)
msg = "expected an indented block";
else if (err->token == INDENT)
msg = "unexpected indent";
else if (err->token == DEDENT)
msg = "unexpected unindent";
else {
errtype = PyExc_SyntaxError;
msg = "invalid syntax";
}
break;
case E_TOKEN:
msg = "invalid token";
break;
case E_INTR:
PyErr_SetNone(PyExc_KeyboardInterrupt);
Py_XDECREF(v);
return;
case E_NOMEM:
PyErr_NoMemory();
Py_XDECREF(v);
return;
case E_EOF:
msg = "unexpected EOF while parsing";
break;
case E_TABSPACE:
errtype = PyExc_TabError;
msg = "inconsistent use of tabs and spaces in indentation";
break;
case E_OVERFLOW:
msg = "expression too long";
break;
case E_DEDENT:
errtype = PyExc_IndentationError;
msg = "unindent does not match any outer indentation level";
break;
case E_TOODEEP:
errtype = PyExc_IndentationError;
msg = "too many levels of indentation";
break;
default:
fprintf(stderr, "error=%d\n", err->error);
msg = "unknown parsing error";
break;
}
w = Py_BuildValue("(sO)", msg, v);
PyErr_SetObject(errtype, w);
Py_XDECREF(w);
if (v != NULL) {
PyObject *exc, *tb;
PyErr_Fetch(&errtype, &exc, &tb);
PyErr_NormalizeException(&errtype, &exc, &tb);
if (PyObject_SetAttrString(exc, "filename",
PyTuple_GET_ITEM(v, 0)))
PyErr_Clear();
if (PyObject_SetAttrString(exc, "lineno",
PyTuple_GET_ITEM(v, 1)))
PyErr_Clear();
if (PyObject_SetAttrString(exc, "offset",
PyTuple_GET_ITEM(v, 2)))
PyErr_Clear();
Py_DECREF(v);
PyErr_Restore(errtype, exc, tb);
}
}
PyObject *spoolss_enumprinters(PyObject *self, PyObject *args, PyObject *kw)
{
WERROR werror;
PyObject *result = NULL, *creds = NULL;
PRINTER_INFO_CTR ctr;
int level = 1, flags = PRINTER_ENUM_LOCAL, i;
uint32 needed, num_printers;
static char *kwlist[] = {"server", "name", "level", "flags",
"creds", NULL};
TALLOC_CTX *mem_ctx = NULL;
struct cli_state *cli = NULL;
char *server, *errstr, *name = NULL;
/* Parse parameters */
if (!PyArg_ParseTupleAndKeywords(
args, kw, "s|siiO", kwlist, &server, &name, &level,
&flags, &creds))
return NULL;
if (server[0] != '\\' || server[1] != '\\') {
PyErr_SetString(PyExc_ValueError, "UNC name required");
return NULL;
}
server += 2;
if (creds && creds != Py_None && !PyDict_Check(creds)) {
PyErr_SetString(PyExc_TypeError,
"credentials must be dictionary or None");
return NULL;
}
if (!(cli = open_pipe_creds(server, creds, PI_SPOOLSS, &errstr))) {
PyErr_SetString(spoolss_error, errstr);
free(errstr);
goto done;
}
if (!(mem_ctx = talloc_init("spoolss_enumprinters"))) {
PyErr_SetString(
spoolss_error, "unable to init talloc context\n");
goto done;
}
/* This RPC is weird. By setting the server name to different
values we can get different behaviour. If however the server
name is not specified, we default it to being the full server
name as this is probably what the caller intended. To pass a
NULL name, pass a value of "" */
if (!name)
name = server;
else {
if (!name[0])
name = NULL;
}
/* Call rpc function */
werror = cli_spoolss_enum_printers(
cli, mem_ctx, 0, &needed, name, flags, level,
&num_printers, &ctr);
if (W_ERROR_V(werror) == ERRinsufficientbuffer)
werror = cli_spoolss_enum_printers(
cli, mem_ctx, needed, NULL, name, flags,
level, &num_printers, &ctr);
if (!W_ERROR_IS_OK(werror)) {
PyErr_SetObject(spoolss_werror, py_werror_tuple(werror));
goto done;
}
/* Return value */
switch (level) {
case 0:
result = PyDict_New();
for (i = 0; i < num_printers; i++) {
PyObject *value;
fstring s;
rpcstr_pull(s, ctr.printers_0[i].printername.buffer,
sizeof(fstring), -1, STR_TERMINATE);
py_from_PRINTER_INFO_0(&value, &ctr.printers_0[i]);
PyDict_SetItemString(
value, "level", PyInt_FromLong(0));
PyDict_SetItemString(result, s, value);
}
break;
case 1:
result = PyDict_New();
for(i = 0; i < num_printers; i++) {
PyObject *value;
fstring s;
rpcstr_pull(s, ctr.printers_1[i].name.buffer,
sizeof(fstring), -1, STR_TERMINATE);
py_from_PRINTER_INFO_1(&value, &ctr.printers_1[i]);
PyDict_SetItemString(
value, "level", PyInt_FromLong(1));
PyDict_SetItemString(result, s, value);
}
break;
case 2:
result = PyDict_New();
for(i = 0; i < num_printers; i++) {
PyObject *value;
fstring s;
rpcstr_pull(s, ctr.printers_2[i].printername.buffer,
sizeof(fstring), -1, STR_TERMINATE);
py_from_PRINTER_INFO_2(&value, &ctr.printers_2[i]);
PyDict_SetItemString(
value, "level", PyInt_FromLong(2));
PyDict_SetItemString(result, s, value);
}
break;
default:
PyErr_SetString(spoolss_error, "unknown info level");
goto done;
}
done:
if (cli)
cli_shutdown(cli);
if (mem_ctx)
talloc_destroy(mem_ctx);
return result;
}
// here we do some extra thinking about whether we want to call into the
// python layer of dbgp
static int
_adbobj_trace_dispatch(AdbObject* self, PyFrameObject *frame,
int what, PyObject *arg)
{
int result = 0;
#ifdef DEBUG_PRINT
fprintf(stderr, "_adbobj_trace_dispatch...\n");
#endif
if (self->quitting != 0) {
#ifdef DEBUG_PRINT
fprintf(stderr, "..._adbobj_trace_dispatch quiting\n");
#endif
PyErr_SetObject(PyExc_DBGPQuit, 0);
return -1;
}
if (_adbobj_trace_skip(self, frame) == 1) {
#ifdef DEBUG_PRINT
fprintf(stderr, "..._adbobj_trace_dispatch skip\n");
#endif
return 0;
}
// have we been flagged to do an interraction? If so, then interact
// XXX one logic flaw here is that we used to call poll(), which would
// check more than just having a command waiting in queue, it would also
// check to see what our run state was, and whether we support async.
// this only matters on startup, after which it is fine to handle interact
// here, so we're taking a shortcut and relying on breakOnFirstCall
// to bypass interact until after the first 'call' into our script.
if (self->interrupt != 0 && !self->breakOnFirstCall) {
PyObject *r;
self->interrupt = 0;
#ifdef DEBUG_PRINT
fprintf(stderr, " _adbobj_trace_dispatch calling interraction\n");
#endif
r = PyObject_CallMethod((PyObject *)self, "interaction",
"OOi", (PyObject *)frame, Py_None, 1);
// discard the result
Py_DECREF(r);
#ifdef DEBUG_PRINT
fprintf(stderr, "..._adbobj_trace_dispatch called interraction\n");
#endif
return 0;
}
switch (what) {
case PyTrace_LINE:
result = _adbobj_dispatch_line(self, frame, arg);
break;
case PyTrace_CALL:
result = _adbobj_dispatch_call(self, frame, arg);
if (self->breakOnFirstCall) {
self->breakOnFirstCall = 0;
result = _adbobj_dispatch_line(self, frame, arg);
}
break;
case PyTrace_RETURN:
result = _adbobj_dispatch_return(self, frame, arg);
break;
case PyTrace_EXCEPTION:
result = _adbobj_dispatch_exception(self, frame, arg);
break;
}
#ifdef DEBUG_PRINT
fprintf(stderr, "..._adbobj_trace_dispatch return %d\n", result);
#endif
return result;
}
AerospikeQuery * AerospikeQuery_Apply(AerospikeQuery * self, PyObject * args, PyObject * kwds)
{
as_error err;
// Initialize error
as_error_init(&err);
int nargs = (int) PyTuple_Size(args);
// Aerospike API Arguments
char * module = NULL;
char * function = NULL;
as_arraylist * arglist = NULL;
// too few args
if ( nargs < 2 ) {
// some error
}
// Python Arguments
PyObject * py_module = PyTuple_GetItem(args, 0);
PyObject * py_function = PyTuple_GetItem(args, 1);
if ( PyString_Check(py_module) ) {
module = PyString_AsString(py_module);
}
else {
as_error_update(&err, AEROSPIKE_ERR_CLIENT, "udf module argument must be a string");
goto CLEANUP;
}
if ( PyString_Check(py_function) ) {
function = PyString_AsString(py_function);
}
else {
as_error_update(&err, AEROSPIKE_ERR_CLIENT, "udf function argument must be a string");
goto CLEANUP;
}
if ( nargs > 2 ) {
arglist = as_arraylist_new(nargs, 0);
for ( int i = 2; i < nargs; i++ ) {
PyObject * py_val = PyTuple_GetItem(args, i);
as_val * val = NULL;
pyobject_to_val(&err, py_val, &val);
if ( err.code != AEROSPIKE_OK ) {
goto CLEANUP;
}
}
}
as_query_apply(&self->query, module, function, (as_list *) arglist);
CLEANUP:
if ( err.code != AEROSPIKE_OK ) {
PyObject * py_err = NULL;
error_to_pyobject(&err, &py_err);
PyErr_SetObject(PyExc_Exception, py_err);
return NULL;
}
Py_INCREF(self);
return self;
}
/**
******************************************************************************************************
* Removes a bin from a record.
*
* @param self AerospikeClient object
* @prama py_key The key for the record.
* @pram py_binList The name of the bins to be removed from the record.
* @param py_policy The optional policies.
* @param err The C client's as_error to be set to the encountered error.
*
* Returns an integer status. 0(Zero) is success value.
* In case of error,appropriate exceptions will be raised.
*******************************************************************************************************
*/
static
PyObject * AerospikeClient_RemoveBin_Invoke(
AerospikeClient * self,
PyObject * py_key,PyObject* py_binList ,PyObject * py_policy, PyObject * py_meta, as_error *err)
{
// Aerospike Client Arguments
as_policy_write write_policy;
as_policy_write * write_policy_p = NULL;
as_key key;
as_record rec;
char* binName = NULL;
int count = 0;
PyObject * py_ustr = NULL;
// Get the bin list size;
Py_ssize_t size = PyList_Size(py_binList);
// Initialize record
as_record_inita(&rec, size);
// Convert python key object to as_key
pyobject_to_key(err, py_key, &key);
if ( err->code != AEROSPIKE_OK ) {
goto CLEANUP;
}
// Convert python policy object to as_policy_write
pyobject_to_policy_write(err, py_policy, &write_policy, &write_policy_p,
&self->as->config.policies.write);
if ( err->code != AEROSPIKE_OK ) {
as_error_update(err, AEROSPIKE_ERR_CLIENT, "Incorrect policy");
goto CLEANUP;
}
// Invoke operation
for ( count = 0; count < size; count++ ) {
PyObject * py_val = PyList_GetItem(py_binList, count);
if( PyUnicode_Check(py_val) ){
py_ustr = PyUnicode_AsUTF8String(py_val);
binName = PyStr_AsString(py_ustr);
}
else if( PyStr_Check(py_val) ) {
binName = PyStr_AsString(py_val);
}
else
{
as_error_update(err, AEROSPIKE_ERR_CLIENT, "Invalid bin name, bin name should be a string or unicode string")
goto CLEANUP;
}
if (!as_record_set_nil(&rec, binName)){
goto CLEANUP;
}
if (py_ustr) {
Py_DECREF(py_ustr);
py_ustr = NULL;
}
}
if ( py_meta && PyDict_Check(py_meta) ) {
PyObject * py_gen = PyDict_GetItemString(py_meta, "gen");
PyObject * py_ttl = PyDict_GetItemString(py_meta, "ttl");
if( py_ttl != NULL ){
if ( PyInt_Check(py_ttl) ) {
rec.ttl = (uint32_t) PyInt_AsLong(py_ttl);
}
else if ( PyLong_Check(py_ttl) ) {
rec.ttl = (uint32_t) PyLong_AsLongLong(py_ttl);
if((uint32_t)-1 == rec.ttl) {
as_error_update(err, AEROSPIKE_ERR_PARAM, "integer value for ttl exceeds sys.maxsize");
goto CLEANUP;
}
}
else
{
as_error_update(err, AEROSPIKE_ERR_PARAM, "Ttl should be an int or long");
goto CLEANUP;
}
}
if( py_gen != NULL ){
if ( PyInt_Check(py_gen) ) {
rec.gen = (uint16_t) PyInt_AsLong(py_gen);
}
else if ( PyLong_Check(py_gen) ) {
rec.gen = (uint16_t) PyLong_AsLongLong(py_gen);
if((uint16_t)-1 == rec.gen) {
as_error_update(err, AEROSPIKE_ERR_PARAM, "integer value for gen exceeds sys.maxsize");
goto CLEANUP;
}
}
else
{
as_error_update(err, AEROSPIKE_ERR_PARAM, "Generation should be an int or long");
goto CLEANUP;
}
}
}
Py_BEGIN_ALLOW_THREADS
aerospike_key_put(self->as, err, write_policy_p, &key, &rec);
Py_END_ALLOW_THREADS
if (err->code != AEROSPIKE_OK)
{
as_error_update(err, err->code, NULL);
goto CLEANUP;
}
CLEANUP:
as_record_destroy(&rec);
if ( err->code != AEROSPIKE_OK ) {
PyObject * py_err = NULL;
error_to_pyobject(err, &py_err);
PyObject *exception_type = raise_exception(err);
if(PyObject_HasAttrString(exception_type, "key")) {
PyObject_SetAttrString(exception_type, "key", py_key);
}
if(PyObject_HasAttrString(exception_type, "bin")) {
PyObject_SetAttrString(exception_type, "bin", Py_None);
}
PyErr_SetObject(exception_type, py_err);
Py_DECREF(py_err);
return NULL;
}
return PyLong_FromLong(0);
}
/**
*******************************************************************************************************
* Callback for as_info_foreach().
*
* @param err The as_error to be populated by the function
* with the encountered error if any.
* @param node The current as_node object for which the
* callback is fired by c client.
* @param req The info request string.
* @param res The info response string for current node.
* @pram udata The callback udata containing the host_lookup
* array and the return zval to be populated with
* an entry for current node's info response with
* the node's ID as the key.
*
* Returns true if callback is successful, Otherwise false.
*******************************************************************************************************
*/
static bool AerospikeClient_Info_each(as_error * err, const as_node * node, const char * req, char * res, void * udata)
{
PyObject * py_err = NULL;
PyObject * py_ustr = NULL;
PyObject * py_out = NULL;
foreach_callback_info_udata* udata_ptr = (foreach_callback_info_udata *) udata;
struct sockaddr_in* addr = NULL;
if ( err && err->code != AEROSPIKE_OK ) {
as_error_update(err, err->code, NULL);
goto CLEANUP;
}
else if ( res != NULL ) {
char * out = strchr(res,'\t');
if ( out != NULL ) {
out++;
py_out = PyStr_FromString(out);
}
else {
py_out = PyStr_FromString(res);
}
}
if ( py_err == NULL ) {
Py_INCREF(Py_None);
py_err = Py_None;
}
if ( py_out == NULL ) {
Py_INCREF(Py_None);
py_out = Py_None;
}
PyObject * py_res = PyTuple_New(2);
PyTuple_SetItem(py_res, 0, py_err);
PyTuple_SetItem(py_res, 1, py_out);
if(udata_ptr->host_lookup_p) {
PyObject * py_hosts = (PyObject *)udata_ptr->host_lookup_p;
if ( py_hosts && PyList_Check(py_hosts) ) {
addr = as_node_get_address((as_node *)node);
int size = (int) PyList_Size(py_hosts);
for ( int i = 0; i < size && i < AS_CONFIG_HOSTS_SIZE; i++ ) {
char * host_addr = NULL;
int port = -1;
PyObject * py_host = PyList_GetItem(py_hosts, i);
if ( PyTuple_Check(py_host) && PyTuple_Size(py_host) == 2 ) {
PyObject * py_addr = PyTuple_GetItem(py_host,0);
PyObject * py_port = PyTuple_GetItem(py_host,1);
if ( PyStr_Check(py_addr) ) {
host_addr = PyStr_AsString(py_addr);
}
else if (PyUnicode_Check(py_addr)) {
py_ustr = PyUnicode_AsUTF8String(py_addr);
host_addr = PyStr_AsString(py_ustr);
} else {
as_error_update(&udata_ptr->error, AEROSPIKE_ERR_PARAM, "Host address is of type incorrect");
if (py_res) {
Py_DECREF(py_res);
}
return false;
}
if ( PyInt_Check(py_port) ) {
port = (uint16_t) PyInt_AsLong(py_port);
}
else if ( PyLong_Check(py_port) ) {
port = (uint16_t) PyLong_AsLong(py_port);
} else {
break;
}
char ip_port[IP_PORT_MAX_LEN];
inet_ntop(addr->sin_family, &(addr->sin_addr), ip_port, INET_ADDRSTRLEN);
if( (!strcmp(host_addr,ip_port)) && (port
== ntohs(addr->sin_port))) {
PyObject * py_nodes = (PyObject *) udata_ptr->udata_p;
PyDict_SetItemString(py_nodes, node->name, py_res);
}
}
}
} else if ( !PyList_Check( py_hosts )){
as_error_update(&udata_ptr->error, AEROSPIKE_ERR_PARAM, "Hosts should be specified in a list.");
goto CLEANUP;
}
} else {
PyObject * py_nodes = (PyObject *) udata_ptr->udata_p;
PyDict_SetItemString(py_nodes, node->name, py_res);
}
Py_DECREF(py_res);
CLEANUP:
if ( udata_ptr->error.code != AEROSPIKE_OK ) {
PyObject * py_err = NULL;
error_to_pyobject( &udata_ptr->error, &py_err);
PyObject *exception_type = raise_exception(&udata_ptr->error);
PyErr_SetObject(exception_type, py_err);
Py_DECREF(py_err);
return NULL;
}
if ( err->code != AEROSPIKE_OK ) {
PyObject * py_err = NULL;
error_to_pyobject(err, &py_err);
PyObject *exception_type = raise_exception(err);
PyErr_SetObject(exception_type, py_err);
Py_DECREF(py_err);
return NULL;
}
return true;
}
/**
*******************************************************************************************************
* This function invokes csdk's API's.
*
* @param self AerospikeClient object
* @param err The as_error to be populated by the function
* with the encountered error if any.
* @param key The C client's as_key that identifies the record.
* @param py_list The list containing op, bin and value.
* @param py_meta The metadata for the operation.
* @param operate_policy_p The value for operate policy.
*******************************************************************************************************
*/
static
PyObject * AerospikeClient_Operate_Invoke(
AerospikeClient * self, as_error *err,
as_key * key, PyObject * py_list, PyObject * py_meta,
as_policy_operate * operate_policy_p)
{
as_val* put_val = NULL;
char* bin = NULL;
char* val = NULL;
long offset = 0;
double double_offset = 0.0;
uint32_t ttl = 0;
long operation = 0;
int i = 0;
PyObject * py_rec = NULL;
PyObject * py_ustr = NULL;
PyObject * py_ustr1 = NULL;
PyObject * py_bin = NULL;
as_record * rec = NULL;
as_static_pool static_pool;
memset(&static_pool, 0, sizeof(static_pool));
as_operations ops;
Py_ssize_t size = PyList_Size(py_list);
as_operations_inita(&ops, size);
if (!self || !self->as) {
as_error_update(err, AEROSPIKE_ERR_PARAM, "Invalid aerospike object");
goto CLEANUP;
}
if(py_meta) {
AerospikeClient_CheckForMeta(py_meta, &ops, err);
}
if (err->code != AEROSPIKE_OK) {
goto CLEANUP;
}
for ( i = 0; i < size; i++) {
PyObject * py_val = PyList_GetItem(py_list, i);
operation = -1;
offset = 0;
double_offset = 0.0;
if ( PyDict_Check(py_val) ) {
PyObject *key_op = NULL, *value = NULL;
PyObject * py_value = NULL;
Py_ssize_t pos = 0;
while (PyDict_Next(py_val, &pos, &key_op, &value)) {
if ( ! PyString_Check(key_op) ) {
as_error_update(err, AEROSPIKE_ERR_CLIENT, "A operation key must be a string.");
goto CLEANUP;
} else {
char * name = PyString_AsString(key_op);
if(!strcmp(name,"op") && (PyInt_Check(value) || PyLong_Check(value))) {
operation = PyInt_AsLong(value);
} else if (!strcmp(name, "bin")) {
py_bin = value;
} else if(!strcmp(name, "val")) {
py_value = value;
} else {
as_error_update(err, AEROSPIKE_ERR_PARAM, "operation can contain only op, bin and val keys");
goto CLEANUP;
}
}
}
if (py_bin) {
if (PyUnicode_Check(py_bin)) {
py_ustr = PyUnicode_AsUTF8String(py_bin);
bin = PyString_AsString(py_ustr);
} else if (PyString_Check(py_bin)) {
bin = PyString_AsString(py_bin);
} else {
as_error_update(err, AEROSPIKE_ERR_PARAM, "Bin name should be of type string");
goto CLEANUP;
}
} else if (!py_bin && operation != AS_OPERATOR_TOUCH) {
as_error_update(err, AEROSPIKE_ERR_PARAM, "Bin is not given");
goto CLEANUP;
}
if (py_value) {
if (check_type(self, py_value, operation, err)) {
goto CLEANUP;
} else if (PyString_Check(py_value) && (operation == AS_OPERATOR_INCR)) {
char * incr_string = PyString_AsString(py_value);
int incr_value = 0, sign = 1;
if (strlen(incr_string) > 15) {
as_error_update(err, AEROSPIKE_ERR_PARAM, "Unsupported string length for increment operation");
goto CLEANUP;
}
if (*incr_string == '-') {
incr_string = incr_string + 1;
sign = -1;
} else if (*incr_string == '+') {
incr_string = incr_string + 1;
sign = 1;
}
while (*incr_string != '\0') {
if (*incr_string >= 48 && *incr_string <= 57) {
incr_value = (incr_value * 10) + (*incr_string ^ 0x30);
} else {
as_error_update(err, AEROSPIKE_ERR_PARAM, "Unsupported operand type(s) for +: 'int' and 'str'");
goto CLEANUP;
}
incr_string = incr_string + 1;
}
incr_value = incr_value * sign;
py_value = PyInt_FromLong(incr_value);
}
} else if ((!py_value) && (operation != AS_OPERATOR_READ)) {
as_error_update(err, AEROSPIKE_ERR_PARAM, "Value should be given");
goto CLEANUP;
}
switch(operation) {
case AS_OPERATOR_APPEND:
if (PyUnicode_Check(py_value)) {
py_ustr1 = PyUnicode_AsUTF8String(py_value);
val = PyString_AsString(py_ustr1);
} else {
val = PyString_AsString(py_value);
}
as_operations_add_append_str(&ops, bin, val);
break;
case AS_OPERATOR_PREPEND:
if (PyUnicode_Check(py_value)) {
py_ustr1 = PyUnicode_AsUTF8String(py_value);
val = PyString_AsString(py_ustr1);
} else {
val = PyString_AsString(py_value);
}
as_operations_add_prepend_str(&ops, bin, val);
break;
case AS_OPERATOR_INCR:
if (PyInt_Check(py_value)) {
offset = PyInt_AsLong(py_value);
as_operations_add_incr(&ops, bin, offset);
} else if ( PyLong_Check(py_value) ) {
offset = PyLong_AsLong(py_value);
if(-1 == offset) {
as_error_update(err, AEROSPIKE_ERR_PARAM, "integer value exceeds sys.maxsize");
goto CLEANUP;
}
as_operations_add_incr(&ops, bin, offset);
} else if (PyFloat_Check(py_value)) {
double_offset = PyFloat_AsDouble(py_value);
as_operations_add_incr_double(&ops, bin, double_offset);
}
break;
case AS_OPERATOR_TOUCH:
if (PyInt_Check(py_value)) {
ops.ttl = PyInt_AsLong(py_value);
} else if ( PyLong_Check(py_value) ) {
ttl = PyLong_AsLong(py_value);
if((uint32_t)-1 == ttl) {
as_error_update(err, AEROSPIKE_ERR_PARAM, "integer value for ttl exceeds sys.maxsize");
goto CLEANUP;
}
ops.ttl = ttl;
}
as_operations_add_touch(&ops);
break;
case AS_OPERATOR_READ:
as_operations_add_read(&ops, bin);
break;
case AS_OPERATOR_WRITE:
pyobject_to_astype_write(self, err, bin, py_value, &put_val, &ops,
&static_pool, SERIALIZER_PYTHON);
if (err->code != AEROSPIKE_OK) {
goto CLEANUP;
}
as_operations_add_write(&ops, bin, (as_bin_value *) put_val);
break;
default:
as_error_update(err, AEROSPIKE_ERR_PARAM, "Invalid operation given");
}
}
}
// Initialize record
as_record_init(rec, 0);
aerospike_key_operate(self->as, err, operate_policy_p, key, &ops, &rec);
if (err->code != AEROSPIKE_OK) {
as_error_update(err, err->code, NULL);
goto CLEANUP;
}
if(rec) {
record_to_pyobject(err, rec, key, &py_rec);
}
CLEANUP:
if (py_ustr) {
Py_DECREF(py_ustr);
}
if (py_ustr1) {
Py_DECREF(py_ustr1);
}
if (rec) {
as_record_destroy(rec);
}
if (key->valuep) {
as_key_destroy(key);
}
if (put_val) {
as_val_destroy(put_val);
}
if ( err->code != AEROSPIKE_OK ) {
PyObject * py_err = NULL;
error_to_pyobject(err, &py_err);
PyObject *exception_type = raise_exception(err);
PyErr_SetObject(exception_type, py_err);
Py_DECREF(py_err);
return NULL;
}
if (py_rec) {
return py_rec;
} else {
return PyLong_FromLong(0);
}
}
