static void
test_nc_rpc_delete(void **state)
{
(void)state;
struct nc_rpc *rpc = NULL;
/* create delete rpc with NC_PARAMTYPE_CONST */
rpc = nc_rpc_delete(NC_DATASTORE_RUNNING, "target-url", NC_PARAMTYPE_CONST);
assert_non_null(rpc);
check_delete(rpc, NC_DATASTORE_RUNNING, "target-url");
nc_rpc_free(rpc);
/* create delete rpc with NC_PARAMTYPE_FREE */
char *url = strdup("url");
rpc = nc_rpc_delete(NC_DATASTORE_CANDIDATE, url, NC_PARAMTYPE_FREE);
assert_non_null(rpc);
check_delete(rpc, NC_DATASTORE_CANDIDATE, url);
nc_rpc_free(rpc);
/* create delete rpc with NC_PARAMTYPE_DUP_AND_FREE */
rpc = nc_rpc_delete(NC_DATASTORE_CONFIG, "target", NC_PARAMTYPE_DUP_AND_FREE);
assert_non_null(rpc);
check_delete(rpc, NC_DATASTORE_CONFIG, "target");
nc_rpc_free(rpc);
}
int
set_int(
const char* propname,
PyObject* value,
int* dest) {
long value_int;
if (check_delete(propname, value)) {
return -1;
}
#if PY3K
value_int = PyLong_AsLong(value);
#else
value_int = PyInt_AsLong(value);
#endif
if (value_int == -1 && PyErr_Occurred()) {
return -1;
}
if ((unsigned long)value_int > 0x7fffffff) {
PyErr_SetString(PyExc_OverflowError, "integer value too large");
return -1;
}
*dest = (int)value_int;
return 0;
}
int
set_int(
const char* propname,
PyObject* value,
int* dest) {
long value_int;
if (check_delete(propname, value)) {
return -1;
}
#if PY3K
value_int = PyLong_AsLong(value);
#else
value_int = PyInt_AsLong(value);
#endif
if (value_int == -1 && PyErr_Occurred()) {
return -1;
}
if ((unsigned long)value_int > 0x7fffffff) {
return -1;
}
*dest = (int)value_int;
return 0;
}
Array::~Array()
{
if (m_imp)
{
clear();
check_delete(m_imp);
}
}
int
set_unit_list(
PyObject* owner,
const char* propname,
PyObject* value,
Py_ssize_t len,
char (*dest)[72]) {
PyObject* unit = NULL;
PyObject* proxy = NULL;
Py_ssize_t i = 0;
if (check_delete(propname, value)) {
return -1;
}
if (!PySequence_Check(value)) {
PyErr_Format(
PyExc_TypeError,
"'%s' must be a sequence of strings",
propname);
return -1;
}
if (PySequence_Size(value) != len) {
PyErr_Format(
PyExc_ValueError,
"len(%s) must be %u",
propname,
(unsigned int)len);
return -1;
}
proxy = PyUnitListProxy_New(owner, len, dest);
if (proxy == NULL) {
return -1;
}
for (i = 0; i < len; ++i) {
unit = PySequence_GetItem(value, i);
if (unit == NULL) {
Py_DECREF(proxy);
return -1;
}
if (PySequence_SetItem(proxy, i, unit) == -1) {
Py_DECREF(proxy);
Py_DECREF(unit);
return -1;
}
Py_DECREF(unit);
}
Py_DECREF(proxy);
return 0;
}
/**
* generic acl checking for different methods (basic set of methods supported)
* returns null if no err
*/
static dav_error *check_methods(request_rec *r, const dav_resource *resource,
davacl_dir_cfg *conf)
{
const dav_hooks_repository *repos = REPOS(conf);
if (repos == NULL || resource == NULL)
return dav_acl_privilege_error(r, "unknown", NULL);
switch (r->method_number) {
default:
if (r->method_number == iM_ACL) {
return check_acl(r, resource, conf, repos);
}
else if (r->method_number == iM_HEAD) {
return check_get(r, resource, conf, repos);
}
else {
TRACE(r, "Unknown methdod:%d", r->method_number);
return NULL;
}
break;
case M_PUT:
return check_put(r, resource, conf, repos);
case M_PROPPATCH:
return check_proppatch(r, resource, conf, repos);
case M_MKCOL:
return check_mkcol(r, resource, conf, repos);
case M_PROPFIND:
/* done with individual properties within dav_get_props() and
* dav_get_allprops */
return NULL;
case M_DELETE:
return check_delete(r, resource, conf, repos);
case M_OPTIONS:
case M_GET:
return check_get(r, resource, conf, repos);
case M_COPY:
return check_copy(r, resource, conf, repos);
case M_MOVE:
return check_move(r, resource, conf, repos);
case M_LOCK:
return check_lock(r, resource, conf, repos);
case M_UNLOCK:
return check_unlock(r, resource, conf, repos);
}
}
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;
}
int
set_bool(
const char* propname,
PyObject* value,
int* dest) {
if (check_delete(propname, value)) {
return -1;
}
*dest = PyObject_IsTrue(value);
return 0;
}
int
set_double(
const char* propname,
PyObject* value,
double* dest) {
if (check_delete(propname, value)) {
return -1;
}
*dest = PyFloat_AsDouble(value);
if (PyErr_Occurred()) {
return -1;
} else {
return 0;
}
}
int
set_double_array(
const char* propname,
PyObject* value,
int ndims,
const npy_intp* dims,
double* dest) {
PyArrayObject* value_array = NULL;
npy_int i = 0;
char shape_str[SHAPE_STR_LEN];
if (check_delete(propname, value)) {
return -1;
}
value_array = (PyArrayObject*)PyArray_ContiguousFromAny(value, PyArray_DOUBLE,
ndims, ndims);
if (value_array == NULL) {
return -1;
}
if (dims != NULL) {
for (i = 0; i < ndims; ++i) {
if (PyArray_DIM(value_array, i) != dims[i]) {
shape_to_string(ndims, dims, shape_str);
PyErr_Format(
PyExc_ValueError,
"'%s' array is the wrong shape, must be %s",
propname, shape_str);
Py_DECREF(value_array);
return -1;
}
}
}
copy_array_to_c_double(value_array, dest);
Py_DECREF(value_array);
return 0;
}
int battle_roll_data::timer_roll_result()
{
////////////自动帮忙roll点////////////////////
for( uint32_t i =0; i <roll_datas.size(); i++)
{
for( uint32_t j = 0; j < MAX_ROLL_PLAYER_COUNT; j++)
{
if( player_ids[j] == 0)continue;
if( roll_datas[i].roll_points[j] == 0){
int32_t roll_point = 0;
uint32_t roll_id = roll_datas[i].roll_id;
player_roll_point(roll_datas[i].roll_id, player_ids[j], roll_point);
btl->notify_team_roll_point(roll_id, player_ids[j], roll_point);
if(is_roll_finish(roll_id))
{
check_delete();
}
}
}
}
return 0;
}
int
set_string(
const char* propname,
PyObject* value,
char* dest,
Py_ssize_t maxlen) {
char* buffer;
Py_ssize_t len;
if (check_delete(propname, value)) {
return -1;
}
#if PY3K
if (PyBytes_AsStringAndSize(value, &buffer, &len) == -1) {
return -1;
}
#else
if (PyString_AsStringAndSize(value, &buffer, &len) == -1) {
return -1;
}
#endif
if (len > maxlen) {
PyErr_Format(
PyExc_ValueError,
"'%s' must be less than %u characters",
propname,
(unsigned int)maxlen);
return -1;
}
strncpy(dest, buffer, (size_t)maxlen);
return 0;
}
int
set_str_list(
const char* propname,
PyObject* value,
Py_ssize_t len,
Py_ssize_t maxlen,
char (*dest)[72]) {
PyObject* str = NULL;
Py_ssize_t input_len;
Py_ssize_t i = 0;
if (check_delete(propname, value)) {
return -1;
}
if (maxlen == 0) {
maxlen = 68;
}
if (!PySequence_Check(value)) {
PyErr_Format(
PyExc_TypeError,
"'%s' must be a sequence of strings",
propname);
return -1;
}
if (PySequence_Size(value) != len) {
PyErr_Format(
PyExc_ValueError,
"len(%s) must be %u",
propname,
(unsigned int)len);
return -1;
}
/* We go through the list twice, once to verify that the list is
in the correct format, and then again to do the data copy. This
way, we won't partially copy the contents and then throw an
exception. */
for (i = 0; i < len; ++i) {
str = PySequence_GetItem(value, i);
if (str == NULL) {
return -1;
}
if (!(PyBytes_CheckExact(str) || PyUnicode_CheckExact(str))) {
PyErr_Format(
PyExc_TypeError,
"'%s' must be a sequence of bytes or strings",
propname);
Py_DECREF(str);
return -1;
}
input_len = PySequence_Size(str);
if (input_len > maxlen) {
PyErr_Format(
PyExc_ValueError,
"Each entry in '%s' must be less than %u characters",
propname, (unsigned int)maxlen);
Py_DECREF(str);
return -1;
} else if (input_len == -1) {
Py_DECREF(str);
return -1;
}
Py_DECREF(str);
}
for (i = 0; i < len; ++i) {
str = PySequence_GetItem(value, i);
if (str == NULL) {
/* Theoretically, something has gone really wrong here, since
we've already verified the list. */
PyErr_Clear();
PyErr_Format(
PyExc_RuntimeError,
"Input values have changed underneath us. Something is seriously wrong.");
return -1;
}
if (set_string(propname, str, dest[i], maxlen)) {
PyErr_Clear();
PyErr_Format(
PyExc_RuntimeError,
"Input values have changed underneath us. Something is seriously wrong.");
Py_DECREF(str);
return -1;
}
Py_DECREF(str);
}
return 0;
}
int
set_str_list(
const char* propname,
PyObject* value,
Py_ssize_t len,
Py_ssize_t maxlen,
char (*dest)[72]) {
PyObject* str = NULL;
char* str_char = NULL;
Py_ssize_t str_len = 0;
Py_ssize_t i = 0;
if (check_delete(propname, value)) {
return -1;
}
if (maxlen == 0) {
maxlen = 68;
}
if (!PySequence_Check(value)) {
PyErr_Format(
PyExc_TypeError,
"'%s' must be a sequence of strings",
propname);
return -1;
}
if (PySequence_Size(value) != len) {
PyErr_Format(
PyExc_ValueError,
"len(%s) must be %u",
propname,
(unsigned int)len);
return -1;
}
/* We go through the list twice, once to verify that the list is
in the correct format, and then again to do the data copy. This
way, we won't partially copy the contents and then throw an
exception. */
for (i = 0; i < len; ++i) {
str = PySequence_GetItem(value, i);
if (str == NULL) {
return -1;
}
#if PY3K
if (!PyBytes_CheckExact(str)) {
#else
if (!PyString_CheckExact(str)) {
#endif
PyErr_Format(
PyExc_TypeError,
#if PY3K
"'%s' must be a sequence of bytes",
#else
"'%s' must be a sequence of strings",
#endif
propname);
Py_DECREF(str);
return -1;
}
#if PY3K
if (PyBytes_Size(str) > maxlen) {
#else
if (PyString_Size(str) > maxlen) {
#endif
PyErr_Format(
PyExc_TypeError,
#if PY3K
"Each bytes in '%s' must be less than %u characters",
#else
"Each string in '%s' must be less than %u characters",
#endif
propname, (unsigned int)maxlen);
Py_DECREF(str);
return -1;
}
Py_DECREF(str);
}
for (i = 0; i < len; ++i) {
str = PySequence_GetItem(value, i);
if (str == NULL) {
/* Theoretically, something has gone really wrong here, since
we've already verified the list. */
PyErr_Format(
PyExc_RuntimeError,
"Input values have changed underneath us. Something is seriously wrong.");
return -1;
}
/* We already know its a string of the correct length */
#if PY3K
if (PyBytes_AsStringAndSize(str, &str_char, &str_len)) {
#else
if (PyString_AsStringAndSize(str, &str_char, &str_len)) {
#endif
/* Theoretically, something has gone really wrong here, since
we've already verified the list. */
PyErr_Format(
PyExc_RuntimeError,
"Input values have changed underneath us. Something is seriously wrong.");
Py_DECREF(str);
return -1;
}
strncpy(dest[i], str_char, (size_t)maxlen);
Py_DECREF(str);
}
return 0;
}
/*@null@*/ PyObject*
get_pscards(
/*@unused@*/ const char* propname,
struct pscard* ps,
int nps) {
PyObject* result = NULL;
PyObject* subresult = NULL;
Py_ssize_t i = 0;
if (nps < 0) {
PyErr_SetString(PyExc_ValueError, "Object has no pscards");
return NULL;
}
result = PyList_New((Py_ssize_t)nps);
if (result == NULL) {
return NULL;
}
for (i = 0; i < (Py_ssize_t)nps; ++i) {
subresult = Py_BuildValue("iis", ps[i].i, ps[i].m, ps[i].value);
if (subresult == NULL) {
Py_DECREF(result);
return NULL;
}
if (PyList_SetItem(result, i, subresult)) {
Py_DECREF(subresult);
Py_DECREF(result);
return NULL;
}
}
return result;
}
int
set_pscards(
/*@unused@*/ const char* propname,
PyObject* value,
struct pscard** ps,
int *nps,
int *npsmax) {
PyObject* subvalue = NULL;
Py_ssize_t i = 0;
Py_ssize_t size = 0;
int ival = 0;
int mval = 0;
const char* strvalue = 0;
void* newmem = NULL;
if (!PySequence_Check(value))
return -1;
size = PySequence_Size(value);
if (size > 0x7fffffff) {
/* Must be a 32-bit size */
return -1;
}
if (size > (Py_ssize_t)*npsmax) {
newmem = malloc(sizeof(struct pscard) * size);
if (newmem == NULL) {
PyErr_SetString(PyExc_MemoryError, "Could not allocate memory.");
return -1;
}
free(*ps);
*ps = newmem;
*npsmax = (int)size;
}
/* Verify the entire list for correct types first, so we don't have
to undo anything copied into the canonical array. */
for (i = 0; i < size; ++i) {
subvalue = PySequence_GetItem(value, i);
if (subvalue == NULL) {
return -1;
}
if (!PyArg_ParseTuple(subvalue, "iis", &ival, &mval, &strvalue)) {
Py_DECREF(subvalue);
return -1;
}
Py_DECREF(subvalue);
}
for (i = 0; i < size; ++i) {
subvalue = PySequence_GetItem(value, i);
if (subvalue == NULL) {
return -1;
}
if (!PyArg_ParseTuple(subvalue, "iis", &ival, &mval, &strvalue)) {
Py_DECREF(subvalue);
return -1;
}
Py_DECREF(subvalue);
(*ps)[i].i = ival;
(*ps)[i].m = mval;
strncpy((*ps)[i].value, strvalue, 72);
(*ps)[i].value[71] = '\0';
(*nps) = (int)(i + 1);
}
return 0;
}
/*@null@*/ PyObject*
get_pvcards(
/*@unused@*/ const char* propname,
struct pvcard* pv,
int npv) {
PyObject* result = NULL;
PyObject* subresult = NULL;
Py_ssize_t i = 0;
if (npv < 0) {
PyErr_SetString(PyExc_ValueError, "Object has no pvcards");
return NULL;
}
result = PyList_New((Py_ssize_t)npv);
if (result == NULL) {
return NULL;
}
for (i = 0; i < (Py_ssize_t)npv; ++i) {
subresult = Py_BuildValue("iid", pv[i].i, pv[i].m, pv[i].value);
if (subresult == NULL) {
Py_DECREF(result);
return NULL;
}
if (PyList_SetItem(result, i, subresult)) {
Py_DECREF(subresult);
Py_DECREF(result);
return NULL;
}
}
return result;
}