int CompactBlockCompleteMessage::parse(char* data, int32_t len)
{
if (get_int32(&data, &len, reinterpret_cast<int32_t*> (&block_id_)) == TFS_ERROR)
{
return TFS_ERROR;
}
if (get_int32(&data, &len, reinterpret_cast<int32_t*> (&success_)) == TFS_ERROR)
{
return TFS_ERROR;
}
if (get_int64(&data, &len, reinterpret_cast<int64_t*> (&server_id_)) == TFS_ERROR)
{
return TFS_ERROR;
}
if ((len < static_cast<int32_t> (sizeof(uint8_t))) || (len > TFS_MALLOC_MAX_SIZE))
{
return TFS_ERROR;
}
if (get_int32(&data, &len, reinterpret_cast<int32_t*> (&flag_)) == TFS_ERROR)
{
return TFS_ERROR;
}
if (get_vint64(&data, &len, ds_list_) == TFS_ERROR)
{
return TFS_ERROR;
}
if (get_object(&data, &len, reinterpret_cast<void**> (&block_info_), BLOCKINFO_SIZE) == TFS_ERROR)
{
return TFS_ERROR;
}
return TFS_SUCCESS;
}
T get( const field_desc_type *fld ) const
{
switch(fld->cpp_type( )) {
case field_desc_type::CPPTYPE_INT32:
return boost::lexical_cast<T>(get_int32(fld));
case field_desc_type::CPPTYPE_INT64:
return boost::lexical_cast<T>(get_int64(fld));
case field_desc_type::CPPTYPE_UINT32:
return boost::lexical_cast<T>(get_uint32(fld));
case field_desc_type::CPPTYPE_UINT64:
return boost::lexical_cast<T>(get_uint64(fld));
case field_desc_type::CPPTYPE_FLOAT:
return boost::lexical_cast<T>(get_float(fld));
case field_desc_type::CPPTYPE_DOUBLE:
return boost::lexical_cast<T>(get_double(fld));
case field_desc_type::CPPTYPE_ENUM:
return boost::lexical_cast<T>(get_enum(fld)->number());
case field_desc_type::CPPTYPE_STRING:
return boost::lexical_cast<T>(get_string(fld));
case field_desc_type::CPPTYPE_BOOL:
return boost::lexical_cast<T>(get_bool(fld));
case field_desc_type::CPPTYPE_MESSAGE:
throw std::bad_cast( );
default:
return T( );
}
}
int ReplicateInfoMessage::get_counter_map(char** data, int32_t* len, COUNTER_TYPE & m)
{
int32_t i = 0;
int32_t size = 0;
uint64_t server_id = 0;
uint32_t count = 0;
if (get_int32(data, len, &size) == TFS_ERROR)
{
return TFS_ERROR;
}
for (i = 0; i < size; ++i)
{
if (get_int64(data, len, reinterpret_cast<int64_t*> (&server_id)) == TFS_ERROR)
{
return TFS_ERROR;
}
if (get_int32(data, len, reinterpret_cast<int32_t*> (&count)) == TFS_ERROR)
{
return TFS_ERROR;
}
m.insert(COUNTER_TYPE::value_type(server_id, count));
}
return TFS_SUCCESS;
}
int SuspectDataserverMessage::parse(char* data, int32_t len)
{
if (get_int64(&data, &len, reinterpret_cast<int64_t*> (&server_id_)) == TFS_ERROR)
{
return TFS_ERROR;
}
return TFS_SUCCESS;
}
static void sendfile_drv_output(ErlDrvData handle, char* buf,
ErlDrvSizeT buflen)
{
int fd, socket_fd;
Desc* d = (Desc*)handle;
Buffer b;
b.buffer = buf;
socket_fd = get_int32(&(b.args->out_fd));
fd = open(b.args->filename, O_RDONLY | O_NONBLOCK);
if (fd < 0) {
ErlDrvSizeT out_buflen = set_error_buffer(&b, socket_fd, errno);
driver_output(d->port, buf, out_buflen);
} else {
Transfer* xfer;
SocketFd sfd;
sfd.socket_fd = socket_fd;
xfer = (Transfer*)hashtable_search(d->xfer_table, sfd.hashkey);
if (xfer == NULL) {
/* Transfer objects are intentionally not freed until the
driver stops, or if an insertion error occurs below. */
xfer = (Transfer*)malloc(sizeof(Transfer));
if (xfer == NULL) {
ErlDrvSizeT out_buflen = set_error_buffer(&b, socket_fd,
ENOMEM);
driver_output(d->port, buf, out_buflen);
return;
}
if (!hashtable_insert(d->xfer_table, sfd.hashkey, xfer)) {
ErlDrvSizeT out_buflen = set_error_buffer(&b, socket_fd,
ENOMEM);
driver_output(d->port, buf, out_buflen);
free(xfer);
return;
}
}
xfer->file_fd = fd;
xfer->offset = get_int64(&(b.args->offset.offset));
xfer->count = get_int64(&(b.args->count.size));
xfer->total = 0;
#if defined(ERL_DRV_USE) && defined(ERL_DRV_WRITE)
driver_select(d->port, sfd.ev_data, ERL_DRV_USE|ERL_DRV_WRITE, 1);
#else
driver_select(d->port, sfd.ev_data, DO_WRITE, 1);
#endif
}
}
void SFTP::process_write(void)
{
u_int32_t id;
u_int64_t off;
u_int len;
int handle, status = SSH2_FX_FAILURE;
char *data;
id = get_int();
handle = get_handle();
off = get_int64();
data = (char*) get_string(&len);
#ifdef SLOW_DEBUG
debug("request %u: write \"%s\" (handle %d) off %llu len %d",
id,
toUTF8 (handle_to_name(handle)).c_str (),
handle, (unsigned long long)off, len);
#endif
HANDLE fh = handle_to_fh(handle);
if (fh != INVALID_HANDLE_VALUE) {
LARGE_INTEGER largeOffset;
largeOffset.QuadPart = off;
if (!::SetFilePointerEx
(fh, largeOffset, NULL, FILE_BEGIN)
)
{
status = errno_to_portable(::GetLastError ());
error("process_write: seek failed");
}
else
{
/* XXX ATOMICIO ? */
DWORD nBytesWritten;
if (!::WriteFile (fh, data, len, &nBytesWritten, 0))
{
error("process_write: write failed");
int err = ::GetLastError ();
if (err != 0)
status = errno_to_portable(err);
else
status = SSH2_FX_FAILURE; //TODO reason?
}
else if ((size_t) nBytesWritten == len)
{
status = SSH2_FX_OK;
handle_update_write(handle, (ssize_t) nBytesWritten);
}
else
{
debug2("nothing at all written");
}
}
}
send_status(id, status);
xfree(data);
}
void mpfx_manager::set(mpfx & n, int v) {
if (v == 0) {
reset(n);
}
else {
if (v < 0) {
set(n, static_cast<unsigned>(-v));
n.m_sign = 1;
}
else {
set(n, static_cast<unsigned>(v));
}
}
SASSERT(get_int64(n) == v);
SASSERT(check(n));
}
static void dict_to_struct (GHashTable *dict,
const DictFieldMapping *mapping,
void *struct_ptr)
{
const DictFieldMapping *it = mapping;
g_return_if_fail (it != NULL);
while (it->name != NULL) {
switch (it->type) {
case G_TYPE_INT64: {
gint *field;
field = G_STRUCT_MEMBER_P (struct_ptr, it->offset);
*field = get_int64 (dict, it->name);
break;
}
case G_TYPE_BOOLEAN: {
gboolean *field;
field = G_STRUCT_MEMBER_P (struct_ptr, it->offset);
*field = get_boolean (dict, it->name);
break;
}
case G_TYPE_STRING: {
gchar **field;
field = G_STRUCT_MEMBER_P (struct_ptr, it->offset);
*field = get_string (dict, it->name);
break;
}
case G_TYPE_DOUBLE: {
gdouble *field;
field = G_STRUCT_MEMBER_P (struct_ptr, it->offset);
*field = get_double (dict, it->name);
break;
}
}
g_hash_table_remove (dict, it->name);
++it;
}
#ifdef DEBUG_PARSING
if (g_hash_table_size (dict) != 0) {
g_print ("Unused keys:\n");
g_hash_table_foreach (dict, dump_key_name, NULL);
g_print ("\n");
}
#endif
}
static void
process_write(void)
{
u_int32_t id;
u_int64_t off;
u_int len;
int handle, fd, ret, status;
char *data;
id = get_int();
handle = get_handle();
off = get_int64();
data = get_string(&len);
debug("request %u: write \"%s\" (handle %d) off %llu len %d",
id, handle_to_name(handle), handle, (unsigned long long)off, len);
fd = handle_to_fd(handle);
if (fd < 0)
status = SSH2_FX_FAILURE;
else if (readonly)
status = SSH2_FX_PERMISSION_DENIED;
else {
if (lseek(fd, off, SEEK_SET) < 0) {
status = errno_to_portable(errno);
error("process_write: seek failed");
} else {
/* XXX ATOMICIO ? */
ret = write(fd, data, len);
if (ret < 0) {
error("process_write: write failed");
status = errno_to_portable(errno);
} else if ((size_t)ret == len) {
status = SSH2_FX_OK;
handle_update_write(handle, ret);
} else {
debug2("nothing at all written");
status = SSH2_FX_FAILURE;
}
}
}
send_status(id, status);
xfree(data);
}
int UpdateBlockInfoMessage::parse(char* data, int32_t len)
{
if (get_int32(&data, &len, reinterpret_cast<int32_t*> (&block_id_)) == TFS_ERROR)
{
return TFS_ERROR;
}
if (get_int64(&data, &len, reinterpret_cast<int64_t*> (&server_id_)) == TFS_ERROR)
{
return TFS_ERROR;
}
int32_t have_block = 0;
if (get_int32(&data, &len, &have_block) == TFS_ERROR)
{
have_block = 0;
}
if (have_block)
{
if (get_object(&data, &len, reinterpret_cast<void**> (&block_info_), BLOCKINFO_SIZE) == TFS_ERROR)
{
return TFS_ERROR;
}
}
if (get_int32(&data, &len, &repair_) == TFS_ERROR)
{
return TFS_ERROR;
}
int32_t have_sdbm = 0;
if (get_int32(&data, &len, &have_sdbm) == TFS_ERROR)
{
have_sdbm = 0;
}
if (have_sdbm > 0)
{
if (get_object(&data, &len, reinterpret_cast<void**> (&db_stat_), sizeof(SdbmStat)) == TFS_ERROR)
{
return TFS_ERROR;
}
}
return TFS_SUCCESS;
}
static void
process_read(void)
{
char buf[64*1024];
u_int32_t id, len;
int handle, fd, ret, status = SSH2_FX_FAILURE;
u_int64_t off;
id = get_int();
handle = get_handle();
off = get_int64();
len = get_int();
debug("request %u: read \"%s\" (handle %d) off %llu len %d",
id, handle_to_name(handle), handle, (unsigned long long)off, len);
if (len > sizeof buf) {
len = sizeof buf;
debug2("read change len %d", len);
}
fd = handle_to_fd(handle);
if (fd >= 0) {
if (lseek(fd, off, SEEK_SET) < 0) {
error("process_read: seek failed");
status = errno_to_portable(errno);
} else {
ret = read(fd, buf, len);
if (ret < 0) {
status = errno_to_portable(errno);
} else if (ret == 0) {
status = SSH2_FX_EOF;
} else {
send_data(id, buf, ret);
status = SSH2_FX_OK;
handle_update_read(handle, ret);
}
}
}
if (status != SSH2_FX_OK)
send_status(id, status);
}
void mpfx_manager::set(mpfx & n, int64 v) {
if (m_int_part_sz == 1) {
if (v < -static_cast<int64>(static_cast<uint64>(UINT_MAX)) ||
v > static_cast<int64>(static_cast<uint64>(UINT_MAX)))
throw overflow_exception();
}
if (v == 0) {
reset(n);
}
else {
if (v < 0) {
set(n, static_cast<uint64>(-v));
n.m_sign = 1;
}
else {
set(n, static_cast<uint64>(v));
}
}
SASSERT(is_int(n));
SASSERT(get_int64(n) == v);
SASSERT(check(n));
}
static void
process_read(void)
{
char buf[64*1024];
u_int32_t id, len;
int handle, fd, ret, status = SSH2_FX_FAILURE;
u_int64_t off;
id = get_int();
handle = get_handle();
off = get_int64();
len = get_int();
TRACE("read id %u handle %d off %llu len %d", id, handle,
(u_int64_t)off, len);
if (len > sizeof buf) {
len = sizeof buf;
log("read change len %d", len);
}
fd = handle_to_fd(handle);
if (fd >= 0) {
if (lseek(fd, off, SEEK_SET) < 0) {
error("process_read: seek failed");
status = errno_to_portable(errno);
} else {
ret = read(fd, buf, len);
if (ret < 0) {
status = errno_to_portable(errno);
} else if (ret == 0) {
status = SSH2_FX_EOF;
} else {
send_data(id, buf, ret);
status = SSH2_FX_OK;
}
}
}
if (status != SSH2_FX_OK)
send_status(id, status);
}
static void
process_write(void)
{
u_int32_t id;
u_int64_t off;
u_int len;
int handle, fd, ret, status = SSH2_FX_FAILURE;
char *data;
id = get_int();
handle = get_handle();
off = get_int64();
data = get_string(&len);
TRACE("write id %u handle %d off %llu len %d", id, handle,
(u_int64_t)off, len);
fd = handle_to_fd(handle);
if (fd >= 0) {
if (lseek(fd, off, SEEK_SET) < 0) {
status = errno_to_portable(errno);
error("process_write: seek failed");
} else {
/* XXX ATOMICIO ? */
ret = write(fd, data, len);
if (ret == -1) {
error("process_write: write failed");
status = errno_to_portable(errno);
} else if (ret == len) {
status = SSH2_FX_OK;
} else {
log("nothing at all written");
}
}
}
send_status(id, status);
xfree(data);
}
int BlockWriteCompleteMessage::parse(char* data, int32_t len)
{
if (get_int64(&data, &len, reinterpret_cast<int64_t*> (&server_id_)) == TFS_ERROR)
{
return TFS_ERROR;
}
if (get_object(&data, &len, reinterpret_cast<void**> (&block_info_), BLOCKINFO_SIZE) == TFS_ERROR)
{
return TFS_ERROR;
}
if (get_int32(&data, &len, reinterpret_cast<int32_t*> (&lease_id_)) == TFS_ERROR)
{
return TFS_ERROR;
} if (get_int32(&data, &len, reinterpret_cast<int32_t*> (&write_complete_status_)) == TFS_ERROR)
{
return TFS_ERROR;
}
if (get_int32(&data, &len, reinterpret_cast<int32_t*> (&unlink_flag_)) == TFS_ERROR)
{
return TFS_ERROR;
}
return TFS_SUCCESS;
}
void SFTP::process_read(void)
{
char buf[64*1024];
u_int32_t id, len;
int handle, status = SSH2_FX_FAILURE;
u_int64_t off;
id = get_int();
handle = get_handle();
off = get_int64();
len = get_int();
#ifdef SLOW_DEBUG
debug("request %u: read \"%s\" (handle %d) off %llu len %d",
id, toUTF8(handle_to_name(handle)).c_str (),
handle, (unsigned long long)off, len);
#endif
if (len > sizeof buf) {
len = sizeof buf;
debug2("read change len %d", len);
}
HANDLE fh = handle_to_fh(handle);
if (fh != INVALID_HANDLE_VALUE) {
LARGE_INTEGER largeOffset;
largeOffset.QuadPart = off;
if (!::SetFilePointerEx
(fh, largeOffset, NULL, FILE_BEGIN))
{
int err = ::GetLastError ();
if (!err)
status = SSH2_FX_EOF;
else
{
error("process_read: seek failed");
status = errno_to_portable(err);
}
}
else
{
DWORD nBytesRed = 0;
if (!::ReadFile (fh, buf, len, &nBytesRed, 0))
{
status = errno_to_portable(::GetLastError ());
}
else if (nBytesRed == 0)
{
status = SSH2_FX_EOF;
}
else
{
if (nBytesRed < len)
debug ("process_read: requested %u, "
"%u was red",
(unsigned) len,
(unsigned) nBytesRed);
send_data(id, buf, (u_int) nBytesRed);
status = SSH2_FX_OK;
handle_update_read(handle, (u_int) nBytesRed);
}
}
}
if (status != SSH2_FX_OK)
send_status(id, status);
}
int Hash::anonymizeValue(Value* v) {
unsigned char* mac;
unsigned int macLen;
// @@@
// cerr << "3333333" << endl;
switch (Hash::hashType) {
case HASHTYPE_MD2: // 16
case HASHTYPE_MD5:
mac = new unsigned char[17];
memset(mac, 0, 17);
macLen = 16;
break;
case HASHTYPE_SHA:
case HASHTYPE_SHA1:
case HASHTYPE_RIPEMD160:
mac = new unsigned char[21];
memset(mac, 0, 21);
macLen = 20;
break;
case HASHTYPE_SHA224:
mac = new unsigned char[29];
memset(mac, 0, 29);
macLen = 28;
break;
case HASHTYPE_SHA256:
mac = new unsigned char[33];
memset(mac, 0, 33);
macLen = 32;
break;
case HASHTYPE_SHA384:
mac = new unsigned char[49];
memset(mac, 0, 49);
macLen = 48;
break;
case HASHTYPE_SHA512:
mac = new unsigned char[65];
memset(mac, 0, 65);
macLen = 64;
}
// @@@
// cerr << "44444" << endl;
switch (v->Type()) {
case VAL_TYPE_UINT8:
case VAL_TYPE_UINT16:
case VAL_TYPE_UINT32:
case VAL_TYPE_INT8:
case VAL_TYPE_INT16:
case VAL_TYPE_INT32: {
int64_t num = 0;
get_int64(v, num);
if (pwd.empty()) {
(*hashFunc)((const unsigned char*)&num, 8, mac);
} else {
HMAC((*evpHashFunc)(), Hash::pwd.c_str(), Hash::pwd.size(),
(const unsigned char*)&num, 8, mac, &macLen);
}
set_int64(v, num);
break;
}
case VAL_TYPE_CHAR_PTR: {
char* c = Value::to_char_ptr(v);
if (pwd.empty()) {
(*hashFunc)((const unsigned char*)c, v->Bytes(), mac);
} else {
HMAC((*evpHashFunc)(), Hash::pwd.c_str(), Hash::pwd.size(),
(const unsigned char*)c, v->Bytes(), mac, &macLen);
}
memcpy(v->Ptr(), ((void*)(mac)), v->Bytes());
break;
}
case VAL_TYPE_STRING: {
string *s = Value::to_string(v);
if (pwd.empty()) {
(*hashFunc)((const unsigned char*)s->c_str(), s->size(), mac);
} else {
HMAC((*evpHashFunc)(), Hash::pwd.c_str(), Hash::pwd.size(),
(const unsigned char*)s->c_str(), s->size(), mac, &macLen);
}
int32_t tmpSize = 2 * macLen + 1;
char* temp = new char[tmpSize];
memset(temp, 0, tmpSize);
to_hexstr(mac, temp);
*s = string(temp);
delete[] temp;
break;
}
default:
cerr << "flaim Hashmac: Unsupported data type" <<endl;
delete[] mac;
exit(1);
}
delete[] mac;
// @@@
// cerr << "555555" << endl;
return 0;
}
/* given a return value in OCaml land, translate it to
the return_val_t C structure
*/
return_val_t translate_return_value(value ocaml_result) {
CAMLparam1(ocaml_result);
CAMLlocal5(ocaml_shape, ocaml_strides, ocaml_data, ocaml_cur, ocaml_type);
CAMLlocal1(v);
return_val_t ret;
if (Is_long(ocaml_result)) {
// In this case, we know that the return code must have been Pass,
// since the other two return codes have data.
ret.return_code = RET_PASS;
ret.results_len = 0;
} else if (Tag_val(ocaml_result) == RET_FAIL) {
ret.return_code = RET_FAIL;
ret.results_len = caml_string_length(Field(ocaml_result, 0));
ret.error_msg = malloc(ret.results_len + 1);
strcpy(ret.error_msg, String_val(Field(ocaml_result, 0)));
} else if (Tag_val(ocaml_result) == RET_SUCCESS) {
ocaml_cur = Field(ocaml_result, 0);
ret.return_code = RET_SUCCESS;
ret.results_len = ocaml_list_length(ocaml_cur);
ret.results = (ret_t*)malloc(sizeof(ret_t) * ret.results_len);
int i, j;
host_val h;
for (i = 0; i < ret.results_len; ++i) {
v = Field(ocaml_cur, 0);
h = create_host_val(v);
ocaml_cur = Field(ocaml_cur, 1);
// returning a scalar
if (value_is_scalar(h)) {
ret.results[i].is_scalar = 1;
ocaml_type = (scalar_type)value_type_of(h);
ret.results[i].data.scalar.ret_type =
get_scalar_element_type(ocaml_type);
// WARNING:
// Tiny Memory Leak Ahead
// -----------------------
// When scalar data is returned to the host language
// on the heap, it should be manually deleted by the
// host frontend
if (type_is_bool(ocaml_type)) {
ret.results[i].data.scalar.ret_scalar_value.boolean = get_bool(h);
} else if (type_is_int32(ocaml_type)) {
ret.results[i].data.scalar.ret_scalar_value.int32 = get_int32(h);
} else if (type_is_int64(ocaml_type)) {
ret.results[i].data.scalar.ret_scalar_value.int64 = get_int64(h);
} else if (type_is_float32(ocaml_type)) {
ret.results[i].data.scalar.ret_scalar_value.float32 = get_float64(h);
} else if (type_is_float64(ocaml_type)) {
ret.results[i].data.scalar.ret_scalar_value.float64 = get_float64(h);
} else {
caml_failwith("Unable to return scalar of this type\n");
}
} else {
// Pass the type
ret.results[i].is_scalar = 0;
ret.results[i].data.array.ret_type = array_type_of(h);
// Pass the data
ret.results[i].data.array.data = get_array_data(h);
// Build the shape array
ocaml_shape = value_get_shape(h);
int shape_len = Wosize_val(ocaml_shape);
ret.results[i].data.array.shape =
(int*)malloc(shape_len * sizeof(int));
ret.results[i].data.array.shape_len = shape_len;
for (j = 0; j < shape_len; ++j) {
ret.results[i].data.array.shape[j] = Int_val(Field(ocaml_shape, j));
}
// Build the strides array
ocaml_strides = value_get_strides(h);
int strides_len = Wosize_val(ocaml_strides);
ret.results[i].data.array.strides_len = strides_len;
ret.results[i].data.array.strides =
(int*)malloc(strides_len * sizeof(int));
for (j = 0; j < strides_len; ++j) {
ret.results[i].data.array.strides[j] =
Int_val(Field(ocaml_strides, j));
}
}
}
}
CAMLreturnT(return_val_t, ret);
}
static void get_torrent_list(torrent_array **result) {
size_t size;
xmlrpc_value *xml_array, *params;
params = xmlrpc_array_new(&env);
xmlrpc_array_append_item(&env, params, xmlrpc_string_new(&env, "main"));
xmlrpc_array_append_item(&env, params, xmlrpc_string_new(&env, "d.hash="));
xmlrpc_array_append_item(&env, params, xmlrpc_string_new(&env, "d.name="));
xmlrpc_array_append_item(&env, params, xmlrpc_string_new(&env, "d.is_active="));
xmlrpc_array_append_item(&env, params, xmlrpc_string_new(&env, "d.state="));
xmlrpc_array_append_item(&env, params, xmlrpc_string_new(&env, "d.bytes_done="));
xmlrpc_array_append_item(&env, params, xmlrpc_string_new(&env, "d.size_bytes="));
xmlrpc_array_append_item(&env, params, xmlrpc_string_new(&env, "d.up.rate="));
xmlrpc_array_append_item(&env, params, xmlrpc_string_new(&env, "d.down.rate="));
xmlrpc_array_append_item(&env, params, xmlrpc_string_new(&env, "d.down.total="));
xmlrpc_array_append_item(&env, params, xmlrpc_string_new(&env, "d.ratio="));
check_fault();
execute_proxy_method(&xml_array, "d.multicall", params);
check_fault(&env);
assert(xmlrpc_value_type(xml_array) == XMLRPC_TYPE_ARRAY);
XMLRPC_ASSERT_ARRAY_OK(xml_array);
size = xmlrpc_array_size(&env, xml_array);
check_fault(&env);
if (size <= 0)
goto finish;
*result = torrent_array_new(size);
for (size_t i = 0; i < size; ++i) {
size_t tarray_size;
xmlrpc_value *tarray = NULL;
xmlrpc_array_read_item(&env, xml_array, i, &tarray);
check_fault(&env);
assert(xmlrpc_value_type(tarray) == XMLRPC_TYPE_ARRAY);
XMLRPC_ASSERT_ARRAY_OK(tarray);
tarray_size = xmlrpc_array_size(&env, tarray);
for (size_t j = 0; j < tarray_size; ++j) {
xmlrpc_value *item = NULL;
xmlrpc_array_read_item(&env, tarray, j, &item);
check_fault(&env);
switch (j) {
case 0:
get_string(item, &(*result)->torrents[i]->hash);
break;
case 1:
get_string(item, &(*result)->torrents[i]->name);
break;
case 2:
get_bool_from_int64(item, &(*result)->torrents[i]->active);
break;
case 3:
get_bool_from_int64(item, &(*result)->torrents[i]->started);
break;
case 4:
get_int64(item, &(*result)->torrents[i]->done_bytes);
break;
case 5:
get_int64(item, &(*result)->torrents[i]->size_bytes);
break;
case 6:
get_int64(item, &(*result)->torrents[i]->up_rate);
break;
case 7:
get_int64(item, &(*result)->torrents[i]->down_rate);
break;
case 8:
get_int64(item, &(*result)->torrents[i]->down_total);
break;
case 9:
get_int64(item, &(*result)->torrents[i]->ratio);
break;
default:
;
}
xmlrpc_DECREF(item);
}
xmlrpc_DECREF(tarray);
}
finish:
xmlrpc_DECREF(xml_array);
}
static void get_bool_from_int64(xmlrpc_value *value, bool *result) {
int64_t tmp;
get_int64(value, &tmp);
*result = tmp == 1 ? true : false;
}
