int pycbc_tc_simple_encode(PyObject **p, void *buf, size_t *nbuf, lcb_uint32_t flags) { return encode_common(p, buf, nbuf, flags); }
int pycbc_tc_encode_key(pycbc_Bucket *conn, PyObject **key, void **buf, size_t *nbuf) { int rv; Py_ssize_t plen; PyObject *orig_key; PyObject *new_key = NULL; if (!conn->tc) { return encode_common(key, buf, nbuf, PYCBC_FMT_UTF8); } orig_key = *key; pycbc_assert(orig_key); rv = do_call_tc(conn, orig_key, NULL, &new_key, ENCODE_KEY); if (new_key == NULL || rv < 0) { return -1; } rv = PyBytes_AsStringAndSize(new_key, (char**)buf, &plen); if (rv == -1) { PYCBC_EXC_WRAP_KEY(PYCBC_EXC_ENCODING, 0, "Couldn't convert encoded key to bytes. It is " "possible that the Transcoder.encode_key method " "returned an unexpected value", new_key); Py_XDECREF(new_key); return -1; } if (plen == 0) { PYCBC_EXC_WRAP_KEY(PYCBC_EXC_ENCODING, 0, "Transcoder.encode_key returned an empty string", new_key); Py_XDECREF(new_key); return -1; } *nbuf = plen; *key = new_key; return 0; }
int pycbc_tc_encode_key(pycbc_Bucket *conn, PyObject *src, pycbc_pybuffer *dst) { int rv; Py_ssize_t plen; if (!conn->tc) { rv = encode_common(src, dst, PYCBC_FMT_UTF8); if (rv == 0 && dst->length == 0) { PYCBC_EXCTHROW_EMPTYKEY(); rv = -1; } return rv; } /* Swap out key and new key. Assign back later on */ rv = do_call_tc(conn, src, NULL, &dst->pyobj, ENCODE_KEY); if (dst->pyobj == NULL || rv < 0) { dst->pyobj = NULL; return -1; } rv = PyBytes_AsStringAndSize(dst->pyobj, (char**)&dst->buffer, &plen); if (rv == -1) { PYCBC_EXC_WRAP_KEY(PYCBC_EXC_ENCODING, 0, "Couldn't convert encoded key to bytes. It is " "possible that the Transcoder.encode_key method " "returned an unexpected value", dst->pyobj); PYCBC_PYBUF_RELEASE(dst); return -1; } if (plen == 0) { PYCBC_EXC_WRAP_KEY(PYCBC_EXC_ENCODING, 0, "Transcoder.encode_key returned an empty string", dst->pyobj); PYCBC_PYBUF_RELEASE(dst); return -1; } dst->length = plen; return 0; }
/** lebf_encode_resp() * * encodes a response structure * * returns 0 on success, -errno on failure */ static int lebf_encode_resp( struct PVFS_server_resp *resp, struct PINT_encoded_msg *target_msg) { int ret; char **p; ret = encode_common(target_msg, max_size_array[resp->op].resp); if (ret) goto out; gossip_debug(GOSSIP_ENDECODE_DEBUG,"lebf_encode_resp\n"); /** every response has these fields */ p = &target_msg->ptr_current; encode_PVFS_server_resp(p, resp); #define CASE(tag,var) \ case tag: encode_PVFS_servresp_##var(p,&resp->u.var); break /** we stand a good chance of segfaulting if we try to encode the response * after something bad happened reading data from disk. */ if (resp->status == 0) { /** extra encoding rules for particular responses */ switch (resp->op) { /** call standard function defined in headers */ CASE(PVFS_SERV_GETCONFIG, getconfig); CASE(PVFS_SERV_LOOKUP_PATH, lookup_path); CASE(PVFS_SERV_CREATE, create); CASE(PVFS_SERV_MIRROR, mirror); CASE(PVFS_SERV_UNSTUFF, unstuff); CASE(PVFS_SERV_BATCH_CREATE, batch_create); CASE(PVFS_SERV_IO, io); CASE(PVFS_SERV_SMALL_IO, small_io); CASE(PVFS_SERV_GETATTR, getattr); CASE(PVFS_SERV_RMDIRENT, rmdirent); CASE(PVFS_SERV_CHDIRENT, chdirent); CASE(PVFS_SERV_MKDIR, mkdir); CASE(PVFS_SERV_READDIR, readdir); CASE(PVFS_SERV_STATFS, statfs); CASE(PVFS_SERV_MGMT_PERF_MON, mgmt_perf_mon); CASE(PVFS_SERV_MGMT_ITERATE_HANDLES, mgmt_iterate_handles); CASE(PVFS_SERV_MGMT_DSPACE_INFO_LIST, mgmt_dspace_info_list); CASE(PVFS_SERV_MGMT_EVENT_MON, mgmt_event_mon); CASE(PVFS_SERV_WRITE_COMPLETION, write_completion); CASE(PVFS_SERV_MGMT_GET_DIRDATA_HANDLE, mgmt_get_dirdata_handle); CASE(PVFS_SERV_GETEATTR, geteattr); CASE(PVFS_SERV_LISTEATTR, listeattr); CASE(PVFS_SERV_LISTATTR, listattr); CASE(PVFS_SERV_TREE_GET_FILE_SIZE, tree_get_file_size); CASE(PVFS_SERV_MGMT_GET_UID, mgmt_get_uid); case PVFS_SERV_REMOVE: case PVFS_SERV_MGMT_REMOVE_OBJECT: case PVFS_SERV_MGMT_REMOVE_DIRENT: case PVFS_SERV_TREE_REMOVE: case PVFS_SERV_SETATTR: case PVFS_SERV_SETEATTR: case PVFS_SERV_DELEATTR: case PVFS_SERV_CRDIRENT: case PVFS_SERV_TRUNCATE: case PVFS_SERV_FLUSH: case PVFS_SERV_MGMT_NOOP: case PVFS_SERV_BATCH_REMOVE: case PVFS_SERV_PROTO_ERROR: case PVFS_SERV_IMM_COPIES: case PVFS_SERV_MGMT_SETPARAM: /** nothing else */ break; case PVFS_SERV_INVALID: case PVFS_SERV_PERF_UPDATE: case PVFS_SERV_PRECREATE_POOL_REFILLER: case PVFS_SERV_JOB_TIMER: case PVFS_SERV_NUM_OPS: /** sentinel */ gossip_err("%s: invalid operation %d\n", __func__, resp->op); ret = -PVFS_ENOSYS; break; } } #undef CASE /** although much more may have been allocated */ target_msg->total_size = target_msg->ptr_current - (char *) target_msg->buffer_list[0]; target_msg->size_list[0] = target_msg->total_size; if (target_msg->total_size > max_size_array[resp->op].resp) { ret = -PVFS_ENOMEM; gossip_err("%s: op %d needed %lld bytes but alloced only %d\n", __func__, resp->op, lld(target_msg->total_size), max_size_array[resp->op].resp); } out: return ret; }
/** lebf_encode_req() * * encodes a request structure * * returns 0 on success, -errno on failure */ static int lebf_encode_req( struct PVFS_server_req *req, struct PINT_encoded_msg *target_msg) { int ret = 0; char **p; gossip_debug(GOSSIP_ENDECODE_DEBUG,"Executing lebf_encode_req...\n"); gossip_debug(GOSSIP_ENDECODE_DEBUG,"\treq->op:%d\n",req->op); ret = encode_common(target_msg, max_size_array[req->op].req); if (ret) goto out; gossip_debug(GOSSIP_ENDECODE_DEBUG,"lebf_encode_req\n"); /** every request has these fields */ p = &target_msg->ptr_current; encode_PVFS_server_req(p, req); #define CASE(tag,var) \ case tag: encode_PVFS_servreq_##var(p,&req->u.var); break switch (req->op) { /** call standard function defined in headers */ CASE(PVFS_SERV_LOOKUP_PATH, lookup_path); CASE(PVFS_SERV_CREATE, create); CASE(PVFS_SERV_MIRROR, mirror); CASE(PVFS_SERV_UNSTUFF, unstuff); CASE(PVFS_SERV_BATCH_CREATE, batch_create); CASE(PVFS_SERV_BATCH_REMOVE, batch_remove); CASE(PVFS_SERV_REMOVE, remove); CASE(PVFS_SERV_MGMT_REMOVE_OBJECT, mgmt_remove_object); CASE(PVFS_SERV_MGMT_REMOVE_DIRENT, mgmt_remove_dirent); CASE(PVFS_SERV_TREE_REMOVE, tree_remove); CASE(PVFS_SERV_TREE_GET_FILE_SIZE, tree_get_file_size); CASE(PVFS_SERV_MGMT_GET_DIRDATA_HANDLE, mgmt_get_dirdata_handle); CASE(PVFS_SERV_IO, io); CASE(PVFS_SERV_SMALL_IO, small_io); CASE(PVFS_SERV_GETATTR, getattr); CASE(PVFS_SERV_SETATTR, setattr); CASE(PVFS_SERV_CRDIRENT, crdirent); CASE(PVFS_SERV_RMDIRENT, rmdirent); CASE(PVFS_SERV_CHDIRENT, chdirent); CASE(PVFS_SERV_TRUNCATE, truncate); CASE(PVFS_SERV_MKDIR, mkdir); CASE(PVFS_SERV_READDIR, readdir); CASE(PVFS_SERV_FLUSH, flush); CASE(PVFS_SERV_STATFS, statfs); CASE(PVFS_SERV_MGMT_SETPARAM, mgmt_setparam); CASE(PVFS_SERV_MGMT_PERF_MON, mgmt_perf_mon); CASE(PVFS_SERV_MGMT_ITERATE_HANDLES, mgmt_iterate_handles); CASE(PVFS_SERV_MGMT_DSPACE_INFO_LIST, mgmt_dspace_info_list); CASE(PVFS_SERV_MGMT_EVENT_MON, mgmt_event_mon); CASE(PVFS_SERV_GETEATTR, geteattr); CASE(PVFS_SERV_SETEATTR, seteattr); CASE(PVFS_SERV_DELEATTR, deleattr); CASE(PVFS_SERV_LISTEATTR, listeattr); CASE(PVFS_SERV_LISTATTR, listattr); CASE(PVFS_SERV_MGMT_GET_UID, mgmt_get_uid); case PVFS_SERV_GETCONFIG: case PVFS_SERV_MGMT_NOOP: case PVFS_SERV_PROTO_ERROR: case PVFS_SERV_IMM_COPIES: /** nothing else */ break; case PVFS_SERV_INVALID: case PVFS_SERV_WRITE_COMPLETION: case PVFS_SERV_PERF_UPDATE: case PVFS_SERV_PRECREATE_POOL_REFILLER: case PVFS_SERV_JOB_TIMER: case PVFS_SERV_NUM_OPS: /** sentinel */ gossip_err("%s: invalid operation %d\n", __func__, req->op); ret = -PVFS_ENOSYS; break; } #undef CASE /** although much more may have been allocated */ target_msg->total_size = target_msg->ptr_current - (char *) target_msg->buffer_list[0]; target_msg->size_list[0] = target_msg->total_size; if (target_msg->total_size > max_size_array[req->op].req) { ret = -PVFS_ENOMEM; gossip_err("%s: op %d needed %lld bytes but alloced only %d\n", __func__, req->op, lld(target_msg->total_size), max_size_array[req->op].req); } out: return ret; }
int pycbc_tc_encode_value(pycbc_Bucket *conn, PyObject **value, PyObject *flag_v, void **buf, size_t *nbuf, lcb_uint32_t *flags) { PyObject *flags_obj; PyObject *orig_value; PyObject *new_value = NULL; PyObject *result_tuple = NULL; lcb_uint32_t flags_stackval; int rv; Py_ssize_t plen; orig_value = *value; if (!flag_v) { flag_v = conn->dfl_fmt; } if (!conn->tc) { if (flag_v == pycbc_helpers.fmt_auto) { flag_v = pycbc_tc_determine_format(*value); } rv = pycbc_get_u32(flag_v, &flags_stackval); if (rv < 0) { PYCBC_EXC_WRAP_OBJ(PYCBC_EXC_ARGUMENTS, 0, "Bad value for flags", flag_v); return -1; } *flags = flags_stackval; return encode_common(value, buf, nbuf, flags_stackval); } /** * Calling into Transcoder */ rv = do_call_tc(conn, orig_value, flag_v, &result_tuple, ENCODE_VALUE); if (rv < 0) { return -1; } if (!PyTuple_Check(result_tuple) || PyTuple_GET_SIZE(result_tuple) != 2) { PYCBC_EXC_WRAP_EX(PYCBC_EXC_ENCODING, 0, "Expected return of (bytes, flags)", orig_value, result_tuple); Py_XDECREF(result_tuple); return -1; } new_value = PyTuple_GET_ITEM(result_tuple, 0); flags_obj = PyTuple_GET_ITEM(result_tuple, 1); if (new_value == NULL || flags_obj == NULL) { PYCBC_EXC_WRAP_OBJ(PYCBC_EXC_INTERNAL, 0, "Tuple GET_ITEM had NULL", result_tuple); Py_XDECREF(result_tuple); return -1; } rv = pycbc_get_u32(flags_obj, &flags_stackval); if (rv < 0) { Py_XDECREF(result_tuple); PYCBC_EXC_WRAP_VALUE(PYCBC_EXC_ENCODING, 0, "Transcoder.encode_value() returned a bad " "value for flags", orig_value); return -1; } *flags = flags_stackval; rv = PyBytes_AsStringAndSize(new_value, (char**)buf, &plen); if (rv == -1) { Py_XDECREF(result_tuple); PYCBC_EXC_WRAP_VALUE(PYCBC_EXC_ENCODING, 0, "Value returned by Transcoder.encode_value() " "could not be converted to bytes", orig_value); return -1; } *value = new_value; *nbuf = plen; Py_INCREF(new_value); Py_XDECREF(result_tuple); return 0; }
int pycbc_tc_encode_value(pycbc_Bucket *conn, PyObject *srcbuf, PyObject *srcflags, pycbc_pybuffer *dstbuf, lcb_U32 *dstflags) { PyObject *flags_obj; PyObject *new_value = NULL; PyObject *result_tuple = NULL; lcb_U32 flags_stackval; int rv; Py_ssize_t plen; if (!srcflags) { srcflags = conn->dfl_fmt; } if (!conn->tc) { if (srcflags == pycbc_helpers.fmt_auto) { srcflags = pycbc_tc_determine_format(srcbuf); } rv = pycbc_get_u32(srcflags, &flags_stackval); if (rv < 0) { PYCBC_EXC_WRAP_OBJ(PYCBC_EXC_ARGUMENTS, 0, "Bad value for flags", srcflags); return -1; } *dstflags = flags_stackval; return encode_common(srcbuf, dstbuf, flags_stackval); } /** * Calling into Transcoder */ rv = do_call_tc(conn, srcbuf, srcflags, &result_tuple, ENCODE_VALUE); if (rv < 0) { return -1; } if (!PyTuple_Check(result_tuple) || PyTuple_GET_SIZE(result_tuple) != 2) { PYCBC_EXC_WRAP_EX(PYCBC_EXC_ENCODING, 0, "Expected return of (bytes, flags)", srcbuf, result_tuple); Py_XDECREF(result_tuple); return -1; } new_value = PyTuple_GET_ITEM(result_tuple, 0); flags_obj = PyTuple_GET_ITEM(result_tuple, 1); if (new_value == NULL || flags_obj == NULL) { PYCBC_EXC_WRAP_OBJ(PYCBC_EXC_INTERNAL, 0, "Tuple GET_ITEM had NULL", result_tuple); Py_XDECREF(result_tuple); return -1; } rv = pycbc_get_u32(flags_obj, &flags_stackval); if (rv < 0) { Py_XDECREF(result_tuple); PYCBC_EXC_WRAP_VALUE(PYCBC_EXC_ENCODING, 0, "Transcoder.encode_value() returned a bad " "value for flags", srcbuf); return -1; } *dstflags = flags_stackval; rv = PyBytes_AsStringAndSize(new_value, (char**)&dstbuf->buffer, &plen); if (rv == -1) { Py_XDECREF(result_tuple); PYCBC_EXC_WRAP_VALUE(PYCBC_EXC_ENCODING, 0, "Value returned by Transcoder.encode_value() " "could not be converted to bytes", srcbuf); return -1; } dstbuf->pyobj = new_value; dstbuf->length = plen; Py_INCREF(new_value); Py_XDECREF(result_tuple); return 0; }
int pycbc_tc_simple_encode(PyObject *src, pycbc_pybuffer *dst, lcb_U32 flags) { return encode_common(src, dst, flags); }