示例#1
0
文件: pyutil.c 项目: rajul/astropy
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;
}
示例#2
0
文件: oid.c 项目: EdgarChen/pygit2
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;
}
示例#3
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;
}
示例#4
0
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;
}
示例#5
0
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;
}
示例#6
0
文件: _webp.c 项目: ZyX-I/Pillow
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;
}
示例#8
0
文件: python.c 项目: ergo70/Multicorn
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);
}
示例#9
0
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);
}
示例#10
0
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);
}
示例#11
0
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);
}
示例#12
0
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;
}
示例#13
0
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;
    }
}
示例#14
0
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;
}
示例#15
0
文件: codec.c 项目: aji/nursery
/* 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;
}
示例#16
0
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);
}
示例#17
0
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;
}
示例#18
0
/*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;
}
示例#19
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);
}
示例#20
0
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;
}
示例#21
0
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);
}
示例#22
0
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;
}
示例#23
0
文件: key_utils.c 项目: cawka/PyNDN
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;
}
示例#24
0
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);
}
示例#25
0
文件: session.c 项目: vianney/ssh4py
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;
}
示例#26
0
//-------------------------------------------------------------------------------------
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;	
}
示例#27
0
文件: _webp.c 项目: Iadgarov/Pillow
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;
}
示例#28
0
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;
}
示例#29
0
 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;
 }
示例#30
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;
}