int set_string( const char* propname, PyObject* value, char* dest, Py_ssize_t maxlen) { char* buffer; Py_ssize_t len; PyObject* ascii_obj = NULL; int result = -1; if (check_delete(propname, value)) { return -1; } if (PyUnicode_Check(value)) { ascii_obj = PyUnicode_AsASCIIString(value); if (ascii_obj == NULL) { goto end; } if (PyBytes_AsStringAndSize(ascii_obj, &buffer, &len) == -1) { goto end; } } else if (PyBytes_Check(value)) { if (PyBytes_AsStringAndSize(value, &buffer, &len) == -1) { goto end; } } else { PyErr_SetString(PyExc_TypeError, "value must be bytes or unicode"); goto end; } if (len > maxlen) { PyErr_Format( PyExc_ValueError, "'%s' must be less than %u characters", propname, (unsigned int)maxlen); goto end; } strncpy(dest, buffer, (size_t)maxlen); result = 0; end: Py_XDECREF(ascii_obj); return result; }
size_t py_hex_to_git_oid (PyObject *py_oid, git_oid *oid) { PyObject *py_hex; int err; char *hex; Py_ssize_t len; #if PY_MAJOR_VERSION == 2 /* Bytes (only supported in Python 2) */ if (PyBytes_Check(py_oid)) { err = PyBytes_AsStringAndSize(py_oid, &hex, &len); if (err) return 0; err = git_oid_fromstrn(oid, hex, len); if (err < 0) { PyErr_SetObject(Error_type(err), py_oid); return 0; } return (size_t)len; } #endif /* Unicode */ if (PyUnicode_Check(py_oid)) { py_hex = PyUnicode_AsASCIIString(py_oid); if (py_hex == NULL) return 0; err = PyBytes_AsStringAndSize(py_hex, &hex, &len); if (err) { Py_DECREF(py_hex); return 0; } err = git_oid_fromstrn(oid, hex, len); Py_DECREF(py_hex); if (err < 0) { PyErr_SetObject(Error_type(err), py_oid); return 0; } return (size_t)len; } /* Type error */ PyErr_SetObject(PyExc_TypeError, py_oid); return 0; }
static PyObject * pytrap_send(PyObject *self, PyObject *args, PyObject *keywds) { uint32_t ifcidx; PyObject *dataObj; char *data; Py_ssize_t data_size; static char *kwlist[] = {"ifcidx", "data", NULL}; if (!PyArg_ParseTupleAndKeywords(args, keywds, "IO!", kwlist, &ifcidx, &PyBytes_Type, &dataObj)) { return NULL; } PyBytes_AsStringAndSize(dataObj, &data, &data_size); if (data_size > 0xFFFF) { PyErr_SetString(TrapError, "Data length is out of range (0-65535)"); return NULL; } int ret = trap_send(ifcidx, data, (uint16_t) data_size); if (ret == TRAP_E_TIMEOUT) { PyErr_SetString(TimeoutError, "Timeout"); return NULL; } else if (ret == TRAP_E_BAD_IFC_INDEX) { PyErr_SetString(TrapError, "Bad index of IFC."); return NULL; } Py_RETURN_NONE; }
PyObject* vm_set_mem(VmMngr* self, PyObject* args) { PyObject *py_addr; PyObject *py_buffer; Py_ssize_t py_length; char * buffer; Py_ssize_t pysize; uint64_t addr; int ret; if (!PyArg_ParseTuple(args, "OO", &py_addr, &py_buffer)) RAISE(PyExc_TypeError,"Cannot parse arguments"); PyGetInt_uint64_t(py_addr, addr); if (!PyBytes_Check(py_buffer)) RAISE(PyExc_TypeError,"arg must be bytes"); pysize = PyBytes_Size(py_buffer); if (pysize < 0) { RAISE(PyExc_TypeError,"Python error"); } PyBytes_AsStringAndSize(py_buffer, &buffer, &py_length); ret = vm_write_mem(&self->vm_mngr, addr, buffer, pysize); if (ret < 0) RAISE(PyExc_TypeError, "Error in set_mem"); add_mem_write(&self->vm_mngr, addr, (size_t)pysize); check_invalid_code_blocs(&self->vm_mngr); Py_INCREF(Py_None); return Py_None; }
int libvirt_charPtrSizeUnwrap(PyObject *obj, char **str, Py_ssize_t *size) { int ret; #if PY_MAJOR_VERSION == 2 && PY_MINOR_VERSION <= 4 int isize; #endif *str = NULL; *size = 0; if (!obj) { PyErr_SetString(PyExc_TypeError, "unexpected type"); return -1; } #if PY_MAJOR_VERSION > 2 ret = PyBytes_AsStringAndSize(obj, str, size); #else # if PY_MINOR_VERSION <= 4 ret = PyString_AsStringAndSize(obj, str, &isize); *size = isize; # else ret = PyString_AsStringAndSize(obj, str, size); # endif #endif return ret; }
PyObject* WebPEncodeRGB_wrapper(PyObject* self, PyObject* args) { PyBytesObject *rgb_string; int width; int height; int stride; float quality_factor; uint8_t *rgb; uint8_t *output; Py_ssize_t size; size_t ret_size; if (!PyArg_ParseTuple(args, "Siiif", &rgb_string, &width, &height, &stride, &quality_factor)) { Py_INCREF(Py_None); return Py_None; } PyBytes_AsStringAndSize((PyObject *) rgb_string, (char**)&rgb, &size); if (stride * height > size) { Py_INCREF(Py_None); return Py_None; } ret_size = WebPEncodeRGB(rgb, width, height, stride, quality_factor, &output); if (ret_size > 0) { PyObject *ret = PyBytes_FromStringAndSize((char*)output, ret_size); free(output); return ret; } Py_INCREF(Py_None); return Py_None; }
static PyObject *py_ue_ihttp_request_set_content(ue_PyIHttpRequest *self, PyObject * args) { PyObject *py_obj; if (!PyArg_ParseTuple(args, "O:set_content", &py_obj)) { return NULL; } if (PyUnicode_Check(py_obj)) { self->http_request->SetContentAsString(UTF8_TO_TCHAR(PyUnicode_AsUTF8(py_obj))); } else if (PyBytes_Check(py_obj)) { char *buf = nullptr; Py_ssize_t len = 0; PyBytes_AsStringAndSize(py_obj, &buf, &len); TArray<uint8> data; data.Append((uint8 *)buf, len); self->http_request->SetContent(data); } Py_INCREF(Py_None); return Py_None; }
int PyString_AsStringAndSize(PyObject *obj, char **buffer, Py_ssize_t *length) { PyObject *o; int rv; if (PyUnicode_Check(obj)) { o = PyUnicode_AsEncodedString(obj, GetDatabaseEncodingName(), NULL); errorCheck(); rv = PyBytes_AsStringAndSize(o, buffer, length); Py_XDECREF(o); return rv; } return PyBytes_AsStringAndSize(obj, buffer, length); }
static void _read_png_data(PyObject* py_file_obj, png_bytep data, png_size_t length) { PyObject* read_method = PyObject_GetAttrString(py_file_obj, "read"); PyObject* result = NULL; char *buffer; Py_ssize_t bufflen; if (read_method) { result = PyObject_CallFunction(read_method, (char *)"i", length); } #if PY_MAJOR_VERSION >= 3 PyObject* utf8_result = PyUnicode_AsUTF8String(result); if (PyBytes_AsStringAndSize(utf8_result, &buffer, &bufflen) == 0) #else if (PyString_AsStringAndSize(result, &buffer, &bufflen) == 0) #endif { if (bufflen == (Py_ssize_t)length) { memcpy(data, buffer, length); } } Py_XDECREF(read_method); Py_XDECREF(result); }
static PyObject * UnicodeResultProcessor_process(UnicodeResultProcessor *self, PyObject *value) { const char *encoding, *errors; char *str; Py_ssize_t len; if (value == Py_None) Py_RETURN_NONE; #if PY_MAJOR_VERSION >= 3 if (PyBytes_AsStringAndSize(value, &str, &len)) return NULL; encoding = PyBytes_AS_STRING(self->encoding); errors = PyBytes_AS_STRING(self->errors); #else if (PyString_AsStringAndSize(value, &str, &len)) return NULL; encoding = PyString_AS_STRING(self->encoding); errors = PyString_AS_STRING(self->errors); #endif return PyUnicode_Decode(str, len, encoding, errors); }
static PyObject* is_socket_unix(PyObject *self, PyObject *args) { int r; int fd, type = 0, listening = -1; char* path = NULL; Py_ssize_t length = 0; #if PY_MAJOR_VERSION >=3 && PY_MINOR_VERSION >= 1 _cleanup_Py_DECREF_ PyObject *_path = NULL; if (!PyArg_ParseTuple(args, "i|iiO&:_is_socket_unix", &fd, &type, &listening, Unicode_FSConverter, &_path)) return NULL; if (_path) { assert(PyBytes_Check(_path)); if (PyBytes_AsStringAndSize(_path, &path, &length)) return NULL; } #else if (!PyArg_ParseTuple(args, "i|iiz#:_is_socket_unix", &fd, &type, &listening, &path, &length)) return NULL; #endif r = sd_is_socket_unix(fd, type, listening, path, length); if (set_error(r, path, NULL) < 0) return NULL; return PyBool_FromLong(r); }
static PyObject * sophia_cursor_new(SophiaDB *db, PyTypeObject *cursortype, PyObject *args, PyObject *kwargs) { SophiaCursor *pcur; int order = SPGTE; char *begin = NULL; PyObject *pbegin = NULL; Py_ssize_t bsize = 0; static char *keywords[] = {"start_key", "order", NULL}; ensure_is_opened(db, NULL); if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|Oi", keywords, &pbegin, &order) || (pbegin && pbegin != Py_None && PyBytes_AsStringAndSize(pbegin, &begin, &bsize) == -1)) return NULL; pcur = PyObject_New(SophiaCursor, cursortype); if (!pcur) return NULL; void *cursor = sp_cursor(db->db, order, begin, (size_t)bsize); if (!cursor) { PyObject_Del(pcur); PyErr_SetString(SophiaError, sp_error(db->db)); return NULL; } Py_INCREF(db); db->cursors++; pcur->db = db; pcur->cursor = cursor; return (PyObject *)pcur; }
static PyObject * sophia_db_get(SophiaDB *db, PyObject *args) { char *key; PyObject *pkey, *pvalue = NULL; void *value; Py_ssize_t ksize; size_t vsize; ensure_is_opened(db, NULL); if (!PyArg_UnpackTuple(args, "get", 1, 2, &pkey, &pvalue) || PyBytes_AsStringAndSize(pkey, &key, &ksize) == -1) return NULL; int rv = sp_get(db->db, key, (size_t)ksize, &value, &vsize); switch (rv) { case 1: pvalue = PyBytes_FromStringAndSize(value, (Py_ssize_t)vsize); free(value); return pvalue; case 0: if (pvalue) return pvalue; Py_RETURN_NONE; default: PyErr_SetString(SophiaError, sp_error(db->db)); return NULL; } }
PyObject * vm_set_mem(JitCpu *self, PyObject *args) { PyObject *py_addr; PyObject *py_buffer; Py_ssize_t py_length; char *buffer; Py_ssize_t pysize; uint64_t addr; int ret = 0x1337; if (!PyArg_ParseTuple(args, "OO", &py_addr, &py_buffer)) return NULL; PyGetInt_uint64_t(py_addr, addr); if(!PyBytes_Check(py_buffer)) RAISE(PyExc_TypeError,"arg must be bytes"); pysize = PyBytes_Size(py_buffer); if (pysize < 0) { RAISE(PyExc_TypeError,"Python error"); } PyBytes_AsStringAndSize(py_buffer, &buffer, &py_length); ret = vm_write_mem(&(((VmMngr*)self->pyvm)->vm_mngr), addr, buffer, pysize); if (ret < 0) RAISE(PyExc_TypeError,"arg must be str"); Py_INCREF(Py_None); return Py_None; }
/* exodus.codec.decode(big-endian bytes) -> list of instructions */ static PyObject *exodus_decode(PyObject *self, PyObject *args) { PyObject *arg, *insns, *insn; uint8_t *mem; Py_ssize_t sz, tsz; if (!(arg = PyTuple_GetItem(args, 0))) return NULL; if (PyBytes_AsStringAndSize(arg, (char**)&mem, &sz) < 0) return NULL; if (!(insns = PyList_New(0))) return NULL; while (sz > 0) { insn = do_decode(mem, sz, &tsz); if (insn != NULL) { if (PyList_Append(insns, insn) < 0) { Py_DECREF(insns); Py_DECREF(insn); return NULL; } } if (tsz > sz) tsz = sz; /* ??? */ sz -= tsz; mem += tsz; Py_DECREF(insn); } return insns; }
static PyObject *py_creds_set_utf16_password(PyObject *self, PyObject *args) { enum credentials_obtained obt = CRED_SPECIFIED; int _obt = obt; PyObject *newval = NULL; DATA_BLOB blob = data_blob_null; Py_ssize_t size = 0; int result; bool ok; if (!PyArg_ParseTuple(args, "O|i", &newval, &_obt)) { return NULL; } obt = _obt; result = PyBytes_AsStringAndSize(newval, (char **)&blob.data, &size); if (result != 0) { PyErr_SetString(PyExc_RuntimeError, "Failed to convert passed value to Bytes"); return NULL; } blob.length = size; ok = cli_credentials_set_utf16_password(PyCredentials_AsCliCredentials(self), &blob, obt); return PyBool_FromLong(ok); }
PyObject * Repository__from_c(Repository *py_repo, PyObject *args) { PyObject *py_pointer, *py_free; char *buffer; Py_ssize_t len; int err; py_repo->repo = NULL; py_repo->config = NULL; py_repo->index = NULL; if (!PyArg_ParseTuple(args, "OO!", &py_pointer, &PyBool_Type, &py_free)) return NULL; err = PyBytes_AsStringAndSize(py_pointer, &buffer, &len); if (err < 0) return NULL; if (len != sizeof(git_repository *)) { PyErr_SetString(PyExc_TypeError, "invalid pointer length"); return NULL; } py_repo->repo = *((git_repository **) buffer); py_repo->owned = py_free == Py_True; Py_RETURN_NONE; }
/*NUMPY_API * Convert any Python object, *obj*, to an NPY_CASTING enum. */ NPY_NO_EXPORT int PyArray_CastingConverter(PyObject *obj, NPY_CASTING *casting) { char *str = NULL; Py_ssize_t length = 0; if (PyUnicode_Check(obj)) { PyObject *str_obj; int ret; str_obj = PyUnicode_AsASCIIString(obj); if (str_obj == NULL) { return 0; } ret = PyArray_CastingConverter(str_obj, casting); Py_DECREF(str_obj); return ret; } if (PyBytes_AsStringAndSize(obj, &str, &length) == -1) { return 0; } if (length >= 2) switch (str[2]) { case 0: if (strcmp(str, "no") == 0) { *casting = NPY_NO_CASTING; return 1; } break; case 'u': if (strcmp(str, "equiv") == 0) { *casting = NPY_EQUIV_CASTING; return 1; } break; case 'f': if (strcmp(str, "safe") == 0) { *casting = NPY_SAFE_CASTING; return 1; } break; case 'm': if (strcmp(str, "same_kind") == 0) { *casting = NPY_SAME_KIND_CASTING; return 1; } break; case 's': if (strcmp(str, "unsafe") == 0) { *casting = NPY_UNSAFE_CASTING; return 1; } break; } PyErr_SetString(PyExc_ValueError, "casting must be one of 'no', 'equiv', 'safe', " "'same_kind', or 'unsafe'"); return 0; }
PyObject * Diff_from_c(Diff *dummy, PyObject *args) { PyObject *py_diff, *py_repository; git_diff *diff; char *buffer; Py_ssize_t length; if (!PyArg_ParseTuple(args, "OO!", &py_diff, &RepositoryType, &py_repository)) return NULL; /* Here we need to do the opposite conversion from the _pointer getters */ if (PyBytes_AsStringAndSize(py_diff, &buffer, &length)) return NULL; if (length != sizeof(git_diff *)) { PyErr_SetString(PyExc_TypeError, "passed value is not a pointer"); return NULL; } /* the "buffer" contains the pointer */ diff = *((git_diff **) buffer); return wrap_diff(diff, (Repository *) py_repository); }
static PyObject * decode_value(PyObject *self, PyObject *args) { PyObject *flagsobj; PyObject *vobj; char *buf; Py_ssize_t nbuf; int rv; lcb_uint32_t flags; rv = PyArg_ParseTuple(args, "OO", &vobj, &flagsobj); if (!rv) { return NULL; } rv = PyBytes_AsStringAndSize(vobj, &buf, &nbuf); if (rv < 0) { return NULL; } rv = pycbc_get_u32(flagsobj, &flags); if (rv < 0) { return NULL; } rv = pycbc_tc_simple_decode(&vobj, buf, nbuf, flags); if (rv < 0) { return NULL; } (void)self; return vobj; }
PyObject* py_halo_mass_alloc(PyObject* self, PyObject* args) { // _halo_mass_alloc(filename) PyObject* bytes; char* filename; Py_ssize_t len; if(!PyArg_ParseTuple(args, "O&", PyUnicode_FSConverter, &bytes)) { return NULL; } PyBytes_AsStringAndSize(bytes, &filename, &len); HaloMassFoF* halo_mass; try { halo_mass= new HaloMassFoF(filename); } catch(HaloMassFileError) { Py_DECREF(bytes); PyErr_SetString(PyExc_IOError, "HaloMassFileError"); return NULL; } Py_DECREF(bytes); return PyCapsule_New(halo_mass, "_HaloMass", py_halo_mass_free); }
static PyObject * decode_key(PyObject *self, PyObject *args) { int rv; char *buf; PyObject *bobj; Py_ssize_t plen; rv = PyArg_ParseTuple(args, "O", &bobj); if (!rv) { return NULL; } rv = PyBytes_AsStringAndSize(bobj, &buf, &plen); if (rv < 0) { return NULL; } rv = pycbc_tc_simple_decode(&bobj, buf, plen, PYCBC_FMT_UTF8); if (rv < 0) { return NULL; } (void)self; return bobj; }
int put_key_der(int is_public_only, PyObject *py_key_der, PyObject **py_private_key_ndn, PyObject **py_public_key_ndn, PyObject **py_public_key_digest, int *public_key_digest_len) { struct ndn_pkey *key = NULL; const unsigned char *key_der; Py_ssize_t der_len; int r; unsigned long err; r = PyBytes_AsStringAndSize(py_key_der, (char **) &key_der, &der_len); JUMP_IF_NEG(r, error); if (is_public_only) key = (struct ndn_pkey*)d2i_PUBKEY(NULL, &key_der, der_len); else key = (struct ndn_pkey*)d2i_PrivateKey(EVP_PKEY_RSA, NULL, &key_der, der_len); r = ndn_keypair(is_public_only, key, py_private_key_ndn, py_public_key_ndn); JUMP_IF_NEG(r, error); r = create_public_key_digest(key, py_public_key_digest, public_key_digest_len); JUMP_IF_NEG(r, error); return 0; error: return -1; }
PyObject* WebPGetFeatures_wrapper(PyObject* self, PyObject* args) { PyBytesObject *webp_string; const uint8_t* webp = NULL; VP8StatusCode vp8_status_code = VP8_STATUS_OK; Py_ssize_t size; WebPBitstreamFeatures* const features; if (!PyArg_ParseTuple(args, "S", &webp_string)) { Py_INCREF(Py_None); return Py_None; } PyBytes_AsStringAndSize((PyObject *) webp_string, (char**)&webp, &size); vp8_status_code = WebPGetFeatures(webp, size, features); if (vp8_status_code == VP8_STATUS_OK) { printf("%i", features->has_alpha); } else { // TODO: raise some sort of error printf("Error occured checking webp file with code: %d\n", vp8_status_code); Py_INCREF(Py_None); return Py_None; } free((void*)webp); return Py_BuildValue("b", features->has_alpha); }
static int publickey_sign_callback(LIBSSH2_SESSION *session, unsigned char **sig, size_t *sig_len, const unsigned char *data, size_t data_len, void **abstract) { PyObject *callback = (PyObject *) *abstract; PyObject *rv; PyGILState_STATE gstate = PyGILState_Ensure(); char *s; int ret = -1; #if PY_MAJOR_VERSION < 3 rv = PyObject_CallFunction(callback, "s#", data, data_len); #else rv = PyObject_CallFunction(callback, "y#", data, data_len); #endif if (rv == NULL) goto failure; ret = PyBytes_AsStringAndSize(rv, &s, (Py_ssize_t *) sig_len); Py_DECREF(rv); if (ret == 0) { *sig = (unsigned char*) strndup(s, *sig_len); goto exit; } failure: PyErr_WriteUnraisable(callback); exit: PyGILState_Release(gstate); return ret; }
//------------------------------------------------------------------------------------- std::string PyStruct::pack(PyObject* fmt, PyObject* args) { PyObject* pyRet = PyObject_CallFunction(pack_, const_cast<char*>("(OO)"), fmt, args); std::string datas; if (!pyRet) { ERROR_MSG("PyStruct::pack: is failed.\n"); SCRIPT_ERROR_CHECK(); } else { char *buffer; Py_ssize_t length; if(PyBytes_AsStringAndSize(pyRet, &buffer, &length) < 0) { SCRIPT_ERROR_CHECK(); return datas; } datas.assign(buffer, length); } return datas; }
PyObject* WebPDecode_wrapper(PyObject* self, PyObject* args) { PyBytesObject *webp_string; uint8_t *webp; Py_ssize_t size; PyObject *ret, *bytes, *pymode; WebPDecoderConfig config; VP8StatusCode vp8_status_code = VP8_STATUS_OK; char* mode = "RGB"; if (!PyArg_ParseTuple(args, "S", &webp_string)) { Py_RETURN_NONE; } if (!WebPInitDecoderConfig(&config)) { Py_RETURN_NONE; } PyBytes_AsStringAndSize((PyObject *) webp_string, (char**)&webp, &size); vp8_status_code = WebPGetFeatures(webp, size, &config.input); if (vp8_status_code == VP8_STATUS_OK) { // If we don't set it, we don't get alpha. // Initialized to MODE_RGB if (config.input.has_alpha) { config.output.colorspace = MODE_RGBA; mode = "RGBA"; } vp8_status_code = WebPDecode(webp, size, &config); } if (vp8_status_code != VP8_STATUS_OK) { WebPFreeDecBuffer(&config.output); Py_RETURN_NONE; } if (config.output.colorspace < MODE_YUV) { bytes = PyBytes_FromStringAndSize((char *)config.output.u.RGBA.rgba, config.output.u.RGBA.size); } else { // Skipping YUV for now. Need Test Images. // UNDONE -- unclear if we'll ever get here if we set mode_rgb* bytes = PyBytes_FromStringAndSize((char *)config.output.u.YUVA.y, config.output.u.YUVA.y_size); } #if PY_VERSION_HEX >= 0x03000000 pymode = PyUnicode_FromString(mode); #else pymode = PyString_FromString(mode); #endif ret = Py_BuildValue("SiiS", bytes, config.output.width, config.output.height, pymode); WebPFreeDecBuffer(&config.output); return ret; }
PyObject* vm_add_memory_page(VmMngr* self, PyObject* args) { PyObject *addr; PyObject *access; PyObject *item_str; PyObject *name=NULL; uint64_t buf_size; size_t buf_size_st; char* buf_data; Py_ssize_t length; uint64_t page_addr; uint64_t page_access; const char *name_ptr; struct memory_page_node * mpn; if (!PyArg_ParseTuple(args, "OOO|O", &addr, &access, &item_str, &name)) RAISE(PyExc_TypeError,"Cannot parse arguments"); PyGetInt_uint64_t(addr, page_addr); PyGetInt_uint64_t(access, page_access); if(!PyBytes_Check(item_str)) RAISE(PyExc_TypeError,"arg must be bytes"); buf_size = PyBytes_Size(item_str); PyBytes_AsStringAndSize(item_str, &buf_data, &length); if (name == NULL) { name_ptr = (char*)""; } else { PyGetStr(name_ptr, name); } mpn = create_memory_page_node(page_addr, (unsigned int)buf_size, (unsigned int)page_access, name_ptr); if (mpn == NULL) RAISE(PyExc_TypeError,"cannot create page"); if (is_mpn_in_tab(&self->vm_mngr, mpn)) { free(mpn->ad_hp); free(mpn); RAISE(PyExc_TypeError,"known page in memory"); } if (buf_size > SIZE_MAX) { fprintf(stderr, "Size too big\n"); exit(EXIT_FAILURE); } buf_size_st = (size_t) buf_size; memcpy(mpn->ad_hp, buf_data, buf_size_st); add_memory_page(&self->vm_mngr, mpn); Py_INCREF(Py_None); return Py_None; }
static int pyRAMStream_setBuffer(pyRAMStream* self, PyObject* value, void* closure) { if (!PyBytes_Check(value)) { PyErr_SetString(PyExc_TypeError, "buffer should be a binary string"); return -1; } char* buf; Py_ssize_t len; PyBytes_AsStringAndSize(value, &buf, &len); self->fThis->copyFrom(buf, len); return 0; }
static PyObject * sophia_db_set(SophiaDB *db, PyObject *args) { char *key, *value; PyObject *pkey, *pvalue; Py_ssize_t ksize, vsize; ensure_is_opened(db, NULL); if (!PyArg_UnpackTuple(args, "set", 2, 2, &pkey, &pvalue) || PyBytes_AsStringAndSize(pkey, &key, &ksize) == -1 || PyBytes_AsStringAndSize(pvalue, &value, &vsize) == -1) return NULL; if (sp_set(db->db, key, (size_t)ksize, value, (size_t)vsize) == -1) { PyErr_SetString(SophiaError, sp_error(db->db)); return NULL; } Py_RETURN_NONE; }