diff options
| -rw-r--r-- | src/main.c | 692 |
1 files changed, 389 insertions, 303 deletions
@@ -34,6 +34,7 @@ typedef enum typedef struct { + const gchar* hash; state_t state; gchar* title; gfloat downloaded; /* percent */ @@ -49,9 +50,8 @@ typedef struct GtkTreeIter iter; } torrent_t; -static void torrent_update(const gchar* hash, - torrent_t* torrent, torrent_data_t* data); -static void torrent_data_init(torrent_data_t* data); +static void torrent_update(torrent_t* torrent, const torrent_data_t* data); +static void torrent_data_init(torrent_data_t* data, const gchar* hash); static void torrent_data_free(torrent_data_t* data); typedef struct @@ -79,8 +79,6 @@ typedef struct guint config_try; GHashTable* torrents; - guint64 last_sync_time; - guint last_sync_count; guint sync_timeout; const gchar* item_lock; @@ -118,18 +116,20 @@ typedef enum /* Tell worker to update the list of torrents. * Will generate a MSG_SYNCLIST response */ MSG_UPDATELIST, - /* Worker responding to a MSG_UPDATELIST with added and removed torrents */ + /* Worker responding to a MSG_UPDATELIST with added and removed torrents + * and torrent data for all (except removed) */ MSG_SYNCLIST, - /* Tell worker to update a torrent. - * Will generate a MSG_SYNC response */ - MSG_UPDATE, - /* Worker responding to a MSG_UPDATE with uptodate torrent data */ - MSG_SYNC, - /* Tell worker to send a start command for torrent */ + /* Worker responding to a MSG_START/MSG_STOP/MSG_REHASH with uptodate + * torrent state */ + MSG_SYNCSTATE, + /* Tell worker to send a start command for torrent. + * Generates a MSG_SYNCSTATE as response if no error */ MSG_START, - /* Tell worker to send a stop command for torrent */ + /* Tell worker to send a stop command for torrent. + * Generates a MSG_SYNCSTATE as response if no error */ MSG_STOP, - /* Tell worker to send a rehash command for torrent */ + /* Tell worker to send a rehash command for torrent. + * Generates a MSG_SYNCSTATE as response if no error */ MSG_REHASH, } msg_type_t; @@ -184,54 +184,45 @@ typedef struct typedef struct { msg_t base; - const gchar** added; /* NULL terminated list */ - const gchar** removed; /* NULL terminated list */ + const torrent_data_t* data; /* .hash NULL terminated list */ + const torrent_data_t* added; /* .hash NULL terminated list */ + const gchar** removed; /* NULL terminated list */ } msg_synclist_t; typedef struct { msg_t base; const gchar* hash; - torrent_t torrent; -} msg_update_t; - -typedef struct -{ - msg_t base; - const gchar* hash; - torrent_t torrent; - torrent_data_t data; -} msg_sync_t; + state_t state; +} msg_syncstate_t; typedef struct { msg_t base; gchar* hash; - torrent_t torrent; } msg_start_t; typedef struct { msg_t base; gchar* hash; - torrent_t torrent; } msg_stop_t; typedef struct { msg_t base; gchar* hash; - torrent_t torrent; } msg_rehash_t; typedef struct _hashlist_t { - gchar** data; + torrent_data_t* data; gboolean* mark; gsize size, fill; - const gchar** added; + torrent_data_t* added; const gchar** removed; + gsize removed_size; } hashlist_t; static void msg_free(msg_t* msg); @@ -245,19 +236,12 @@ static msg_t* msg_status(const gchar* format, ...); static msg_t* msg_disconnect(void); static msg_t* msg_quit(void); static msg_t* msg_updatelist(void); -static msg_t* msg_synclist(const gchar** added, const gchar** removed); -static msg_t* msg_update(const gchar* hash, torrent_t* torrent); -static msg_t* msg_sync(const gchar* hash, torrent_t* torrent, - torrent_data_t* data); -static msg_t* msg_start(const gchar* hash, torrent_t* torrent); -static msg_t* msg_stop(const gchar* hash, torrent_t* torrent); -static msg_t* msg_rehash(const gchar* hash, torrent_t* torrent); - -static void hashlist_init(hashlist_t* hlist); -static void hashlist_clear(hashlist_t* hlist); -static void hashlist_free(hashlist_t* hlist); -static gboolean hashlist_sync(hashlist_t* hlist, xmlrpc_env * const env, - const xmlrpc_value * const result, gsize count); +static msg_t* msg_synclist(torrent_data_t* data, torrent_data_t* added, + const gchar** removed); +static msg_t* msg_syncstate(const gchar* hash, state_t state); +static msg_t* msg_start(const gchar* hash); +static msg_t* msg_stop(const gchar* hash); +static msg_t* msg_rehash(const gchar* hash); static void do_connect(GtkAction* action, gpointer data); static void do_disconnect(GtkAction* action, gpointer data); @@ -565,15 +549,6 @@ gboolean sync_config(gpointer _data) return FALSE; } -static void update_torrent(gpointer _hash, gpointer _torrent, gpointer _master) -{ - master_t* master = _master; - const gchar* hash = _hash; - torrent_t* torrent = _torrent; - - g_async_queue_push(master->queue, msg_update(hash, torrent)); -} - static gboolean update_list(gpointer _master) { master_t* master = _master; @@ -650,78 +625,65 @@ gboolean incoming_msg(gpointer data) case MSG_SYNCLIST: { msg_synclist_t* m = (msg_synclist_t*)msg; - const gchar** x = m->removed; - for (; *x != NULL; ++x) + const torrent_data_t* data; + const gchar** del = m->removed; + for (; *del != NULL; ++del) { - if (msg->master->item_lock == *x) + if (msg->master->item_lock == *del) { msg->master->item_lock = NULL; listselection_changed(msg->master->listselection, msg->master); } - g_hash_table_remove(msg->master->torrents, *x); + g_hash_table_remove(msg->master->torrents, *del); } - x = m->added; - for (; *x != NULL; ++x) + data = m->data; + for (; data->hash != NULL; ++data) + { + torrent_t* t = g_hash_table_lookup(msg->master->torrents, + data->hash); + if (t != NULL) + { + torrent_update(t, data); + } + if (msg->master->item_lock == data->hash) + { + msg->master->item_lock = NULL; + listselection_changed(msg->master->listselection, msg->master); + } + } + data = m->added; + for (; data->hash != NULL; ++data) { torrent_t* t = g_slice_new(torrent_t); t->store = msg->master->liststore; gtk_list_store_append(t->store, &t->iter); - g_hash_table_insert(msg->master->torrents, (gpointer)*x, t); + g_hash_table_insert(msg->master->torrents, (gpointer)data->hash, t); + torrent_update(t, data); } - msg->master->last_sync_time = g_get_monotonic_time(); - msg->master->last_sync_count = - g_hash_table_size(msg->master->torrents); - g_hash_table_foreach(msg->master->torrents, - update_torrent, msg->master); + msg->master->sync_timeout = g_timeout_add(UPDATE_INTERVAL_MS, + update_list, + msg->master); break; } - case MSG_SYNC: + case MSG_SYNCSTATE: { - msg_sync_t* m = (msg_sync_t*)msg; - g_assert(msg->master->last_sync_count > 0); - - torrent_update(m->hash, &m->torrent, &m->data); + msg_syncstate_t* m = (msg_syncstate_t*)msg; + torrent_t* t = g_hash_table_lookup(msg->master->torrents, m->hash); + if (t != NULL) + { + gtk_list_store_set(t->store, &t->iter, COLUMN_STATE, m->state, -1); + } if (msg->master->item_lock == m->hash) { msg->master->item_lock = NULL; listselection_changed(msg->master->listselection, msg->master); } - - if (--msg->master->last_sync_count == 0) - { - if (msg->master->sync_timeout == 0) - { - guint64 now = g_get_monotonic_time(); - msg->master->last_sync_time += UPDATE_INTERVAL_MS * 1000; - if (now >= msg->master->last_sync_time) - { - g_async_queue_push(msg->master->queue, msg_updatelist()); - } - else - { - now = msg->master->last_sync_time - now; - if (now >= UPDATE_INTERVAL_MS * 1000) - { - g_async_queue_push(msg->master->queue, - msg_updatelist()); - } - else - { - msg->master->sync_timeout = - g_timeout_add((guint)(now / 1000), - update_list, - msg->master); - } - } - } - } break; } case MSG_CONNECT: case MSG_DISCONNECT: case MSG_QUIT: - case MSG_UPDATE: case MSG_UPDATELIST: case MSG_START: case MSG_STOP: @@ -817,38 +779,35 @@ void do_disconnect(GtkAction* action, gpointer data) listselection_changed(master->listselection, master); } -static gboolean get_selected_torrent(master_t* master, const gchar** hash, - torrent_t* torrent) +static const gchar* get_selected_torrent(master_t* master) { GValue value = G_VALUE_INIT; GtkTreeModel* model; + GtkTreeIter iter; + const gchar* hash; if (!master->connected || master->item_lock) { return FALSE; } - if (!gtk_tree_selection_get_selected(master->listselection, &model, - &torrent->iter)) + if (!gtk_tree_selection_get_selected(master->listselection, &model, &iter)) { return FALSE; } - torrent->store = master->liststore; - gtk_tree_model_get_value(model, &torrent->iter, - COLUMN_HASH, &value); - *hash = g_value_get_pointer(&value); + gtk_tree_model_get_value(model, &iter, COLUMN_HASH, &value); + hash = g_value_get_pointer(&value); g_value_unset(&value); - return TRUE; + return hash; } void do_start(GtkAction* action, gpointer data) { master_t* master = data; - torrent_t torrent; const gchar* hash; - if (!get_selected_torrent(master, &hash, &torrent)) + if ((hash = get_selected_torrent(master)) == NULL) { return; } - g_async_queue_push(master->queue, msg_start(hash, &torrent)); + g_async_queue_push(master->queue, msg_start(hash)); master->item_lock = hash; gtk_action_set_sensitive(master->startaction, FALSE); gtk_action_set_sensitive(master->stopaction, FALSE); @@ -858,13 +817,12 @@ void do_start(GtkAction* action, gpointer data) void do_stop(GtkAction* action, gpointer data) { master_t* master = data; - torrent_t torrent; const gchar* hash; - if (!get_selected_torrent(master, &hash, &torrent)) + if ((hash = get_selected_torrent(master)) == NULL) { return; } - g_async_queue_push(master->queue, msg_stop(hash, &torrent)); + g_async_queue_push(master->queue, msg_stop(hash)); master->item_lock = hash; gtk_action_set_sensitive(master->startaction, FALSE); gtk_action_set_sensitive(master->stopaction, FALSE); @@ -874,13 +832,12 @@ void do_stop(GtkAction* action, gpointer data) void do_rehash(GtkAction* action, gpointer data) { master_t* master = data; - torrent_t torrent; const gchar* hash; - if (!get_selected_torrent(master, &hash, &torrent)) + if ((hash = get_selected_torrent(master)) == NULL) { return; } - g_async_queue_push(master->queue, msg_rehash(hash, &torrent)); + g_async_queue_push(master->queue, msg_rehash(hash)); master->item_lock = hash; gtk_action_set_sensitive(master->startaction, FALSE); gtk_action_set_sensitive(master->stopaction, FALSE); @@ -909,7 +866,7 @@ void status(master_t* master, const char* format, ...) g_free(tmp); } -void torrent_update(const gchar* hash, torrent_t* torrent, torrent_data_t* data) +void torrent_update(torrent_t* torrent, const torrent_data_t* data) { gtk_list_store_set(torrent->store, &torrent->iter, COLUMN_STATE, data->state, @@ -922,7 +879,7 @@ void torrent_update(const gchar* hash, torrent_t* torrent, torrent_data_t* data) COLUMN_PROGRESSSORT, data->downloaded < 100.0f ? data->downloaded : 1000.0f + data->seeded, - COLUMN_HASH, hash, + COLUMN_HASH, data->hash, -1); } @@ -931,9 +888,17 @@ static void worker_respond(worker_data_t* data, msg_t* msg); static gint64 get_i64_xmlrpc(xmlrpc_env* env, xmlrpc_value* value); static gboolean get_bool_xmlrpc(xmlrpc_env* env, xmlrpc_value* value); -static void sync_torrent_data(worker_data_t* data, xmlrpc_env* env, - xmlrpc_client* client, xmlrpc_server_info* server, - const gchar* hash, torrent_t* torrent); +static void sync_torrent_state(worker_data_t* data, xmlrpc_env* env, + xmlrpc_client* client, + xmlrpc_server_info* server, + const gchar* hash); + +static void hashlist_init(hashlist_t* hlist); +static void hashlist_clear(hashlist_t* hlist); +static void hashlist_free(hashlist_t* hlist); +static gboolean hashlist_sync(hashlist_t* hlist, worker_data_t* data, + xmlrpc_env * const env, + const xmlrpc_value * const result, gsize count); gpointer worker_main(gpointer _data) { @@ -1053,18 +1018,51 @@ gpointer worker_main(gpointer _data) } case MSG_UPDATELIST: { - xmlrpc_value* params, * result = NULL; + xmlrpc_value* params, * item, * result = NULL; int count; params = xmlrpc_array_new(&env); - xmlrpc_client_call2(&env, client, server, "download_list", + item = xmlrpc_string_new(&env, ""); /* default view */ + xmlrpc_array_append_item(&env, params, item); + xmlrpc_DECREF(item); + item = xmlrpc_string_new(&env, "d.hash="); + xmlrpc_array_append_item(&env, params, item); + xmlrpc_DECREF(item); + item = xmlrpc_string_new(&env, "d.is_active="); + xmlrpc_array_append_item(&env, params, item); + xmlrpc_DECREF(item); + item = xmlrpc_string_new(&env, "d.hashing_failed="); + xmlrpc_array_append_item(&env, params, item); + xmlrpc_DECREF(item); + item = xmlrpc_string_new(&env, "d.is_hash_checking="); + xmlrpc_array_append_item(&env, params, item); + xmlrpc_DECREF(item); + item = xmlrpc_string_new(&env, "d.name="); + xmlrpc_array_append_item(&env, params, item); + xmlrpc_DECREF(item); + item = xmlrpc_string_new(&env, "d.size_bytes="); + xmlrpc_array_append_item(&env, params, item); + xmlrpc_DECREF(item); + item = xmlrpc_string_new(&env, "d.bytes_done="); + xmlrpc_array_append_item(&env, params, item); + xmlrpc_DECREF(item); + item = xmlrpc_string_new(&env, "d.ratio="); + xmlrpc_array_append_item(&env, params, item); + xmlrpc_DECREF(item); + item = xmlrpc_string_new(&env, "d.down.rate="); + xmlrpc_array_append_item(&env, params, item); + xmlrpc_DECREF(item); + item = xmlrpc_string_new(&env, "d.up.rate="); + xmlrpc_array_append_item(&env, params, item); + xmlrpc_DECREF(item); + xmlrpc_client_call2(&env, client, server, "d.multicall", params, &result); + xmlrpc_DECREF(params); if (!env.fault_occurred) { count = xmlrpc_array_size(&env, result); } if (env.fault_occurred) { - xmlrpc_DECREF(params); if (result) xmlrpc_DECREF(result); worker_respond(data, msg_status("Failed to update list (%d): %s", @@ -1073,10 +1071,9 @@ gpointer worker_main(gpointer _data) msg_free(msg); continue; } - if (!hashlist_sync(&hashlist, &env, + if (!hashlist_sync(&hashlist, data, &env, result, count > 0 ? (gsize)count : 0)) { - xmlrpc_DECREF(params); xmlrpc_DECREF(result); if (env.fault_occurred) { @@ -1094,9 +1091,11 @@ gpointer worker_main(gpointer _data) continue; } xmlrpc_DECREF(result); - worker_respond(data, msg_synclist(hashlist.added, + worker_respond(data, msg_synclist(hashlist.data, + hashlist.added, hashlist.removed)); + params = xmlrpc_array_new(&env); xmlrpc_client_call2(&env, client, server, "ratio.min", params, &result); data->ratio_min = get_i64_xmlrpc(&env, result) * 10; @@ -1123,14 +1122,6 @@ gpointer worker_main(gpointer _data) msg_free(msg); break; } - case MSG_UPDATE: - { - msg_update_t* m = (msg_update_t*)msg; - sync_torrent_data(data, &env, client, server, m->hash, - &m->torrent); - msg_free(msg); - break; - } case MSG_QUIT: quit = TRUE; msg_free(msg); @@ -1156,8 +1147,7 @@ gpointer worker_main(gpointer _data) } else { - sync_torrent_data(data, &env, client, server, m->hash, - &m->torrent); + sync_torrent_state(data, &env, client, server, m->hash); } msg_free(msg); break; @@ -1198,8 +1188,7 @@ gpointer worker_main(gpointer _data) } else { - sync_torrent_data(data, &env, client, server, m->hash, - &m->torrent); + sync_torrent_state(data, &env, client, server, m->hash); } } msg_free(msg); @@ -1226,8 +1215,7 @@ gpointer worker_main(gpointer _data) } else { - sync_torrent_data(data, &env, client, server, m->hash, - &m->torrent); + sync_torrent_state(data, &env, client, server, m->hash); } msg_free(msg); break; @@ -1236,7 +1224,7 @@ gpointer worker_main(gpointer _data) case MSG_ERROR: case MSG_STATUS: case MSG_SYNCLIST: - case MSG_SYNC: + case MSG_SYNCSTATE: g_assert(FALSE); break; } @@ -1321,17 +1309,10 @@ void msg_free(msg_t* msg) g_slice_free(msg_synclist_t, m); break; } - case MSG_UPDATE: - { - msg_update_t* m = (msg_update_t*)msg; - g_slice_free(msg_update_t, m); - break; - } - case MSG_SYNC: + case MSG_SYNCSTATE: { - msg_sync_t* m = (msg_sync_t*)msg; - torrent_data_free(&m->data); - g_slice_free(msg_sync_t, m); + msg_syncstate_t* m = (msg_syncstate_t*)msg; + g_slice_free(msg_syncstate_t, m); break; } case MSG_START: @@ -1433,58 +1414,47 @@ msg_t* msg_updatelist(void) return &msg->base; } -msg_t* msg_synclist(const gchar** added, const gchar** removed) +msg_t* msg_synclist(torrent_data_t* data, torrent_data_t* added, + const gchar** removed) { msg_synclist_t* msg = g_slice_new(msg_synclist_t); msg->base.type = MSG_SYNCLIST; + msg->data = data; msg->added = added; msg->removed = removed; return &msg->base; } -msg_t* msg_update(const gchar* hash, torrent_t* torrent) +msg_t* msg_syncstate(const gchar* hash, state_t state) { - msg_update_t* msg = g_slice_new(msg_update_t); - msg->base.type = MSG_UPDATE; + msg_syncstate_t* msg = g_slice_new(msg_syncstate_t); + msg->base.type = MSG_SYNCSTATE; msg->hash = hash; - msg->torrent = *torrent; + msg->state = state; return &msg->base; } -msg_t* msg_sync(const gchar* hash, torrent_t* torrent, torrent_data_t* data) -{ - msg_sync_t* msg = g_slice_new(msg_sync_t); - msg->base.type = MSG_SYNC; - msg->hash = hash; - msg->torrent = *torrent; - msg->data = *data; - return &msg->base; -} - -msg_t* msg_start(const gchar* hash, torrent_t* torrent) +msg_t* msg_start(const gchar* hash) { msg_start_t* msg = g_slice_new(msg_start_t); msg->base.type = MSG_START; msg->hash = g_strdup(hash); - msg->torrent = *torrent; return &msg->base; } -msg_t* msg_stop(const gchar* hash, torrent_t* torrent) +msg_t* msg_stop(const gchar* hash) { msg_stop_t* msg = g_slice_new(msg_stop_t); msg->base.type = MSG_STOP; msg->hash = g_strdup(hash); - msg->torrent = *torrent; return &msg->base; } -msg_t* msg_rehash(const gchar* hash, torrent_t* torrent) +msg_t* msg_rehash(const gchar* hash) { msg_rehash_t* msg = g_slice_new(msg_rehash_t); msg->base.type = MSG_REHASH; msg->hash = g_strdup(hash); - msg->torrent = *torrent; return &msg->base; } @@ -1492,29 +1462,30 @@ void hashlist_init(hashlist_t* hlist) { hlist->fill = 0; hlist->size = 10; - hlist->data = g_new0(gchar*, hlist->size); + hlist->data = g_new0(torrent_data_t, hlist->size); hlist->mark = g_new0(gboolean, hlist->size); - hlist->added = (const gchar**)hlist->data; - hlist->removed = (const gchar**)hlist->data + hlist->size - 1; + hlist->added = hlist->data; + hlist->removed_size = 5; + hlist->removed = g_new0(const gchar*, hlist->removed_size); } void hashlist_clear(hashlist_t* hlist) { - gsize i, a, r; - for (a = hlist->added - (const gchar**)hlist->data; hlist->data[a]; ++a); - r = hlist->removed - (const gchar**)hlist->data; - for (i = 0; i < a; ++i) + torrent_data_t* d = hlist->data; + const gchar** r; + for (; d->hash != NULL; d++) { - g_free(hlist->data[i]); + g_free((gchar*)d->hash); + torrent_data_free(d); } - for (i = r; hlist->data[i]; ++i) + for (r = hlist->removed; *r != NULL; r++) { - g_free(hlist->data[i]); + g_free((gchar*)*r); } - hlist->data[0] = NULL; + hlist->data[0].hash = NULL; hlist->fill = 0; - hlist->added = (const gchar**)hlist->data; - hlist->removed = (const gchar**)hlist->data + hlist->size - 1; + hlist->added = hlist->data; + hlist->removed[0] = NULL; } void hashlist_free(hashlist_t* hlist) @@ -1522,97 +1493,120 @@ void hashlist_free(hashlist_t* hlist) hashlist_clear(hlist); g_free(hlist->data); g_free(hlist->mark); + g_free(hlist->removed); } -gboolean hashlist_resize(hashlist_t* hlist, G_GNUC_UNUSED gsize* a, gsize* r) +static gboolean hashlist_data_resize(hashlist_t* hlist) { gsize ns = hlist->size * 2; - gchar** tmp1; + torrent_data_t* tmp1; gboolean* tmp2; - g_assert(*r == hlist->size - 1); if (ns < 10) ns = 10; - tmp1 = realloc(hlist->data, ns * sizeof(gchar**)); + tmp1 = realloc(hlist->data, ns * sizeof(torrent_data_t)); tmp2 = realloc(hlist->mark, ns * sizeof(gboolean)); if (tmp1 == NULL || tmp2 == NULL) { if (tmp1) hlist->data = tmp1; if (tmp2) hlist->mark = tmp2; - hlist->added = (const gchar**)hlist->data + hlist->fill; - hlist->removed = (const gchar**)hlist->data + *r; + hlist->added = hlist->data + hlist->fill; return FALSE; } - memset(tmp1 + hlist->size, 0, (ns - hlist->size) * sizeof(gchar*)); hlist->data = tmp1; hlist->mark = tmp2; hlist->size = ns; - *r = hlist->size - 1; return TRUE; } -gboolean hashlist_sync(hashlist_t* hlist, xmlrpc_env * const env, +static gboolean hashlist_removed_resize(hashlist_t* hlist, gsize need) +{ + gsize ns; + const gchar** tmp; + if (hlist->removed_size > need) + { + return TRUE; + } + ns = hlist->removed_size * 2; + if (ns < need + 1) ns = need + 1; + tmp = realloc(hlist->data, ns * sizeof(const gchar*)); + if (tmp == NULL) + { + hlist->added = hlist->data + hlist->fill; + return FALSE; + } + hlist->removed = tmp; + hlist->removed_size = ns; + return TRUE; +} + +static gboolean hashlist_item_sync(worker_data_t* data, + xmlrpc_env * const env, + const xmlrpc_value * const line, + torrent_data_t* torrent_data); + +gboolean hashlist_sync(hashlist_t* hlist, worker_data_t* data, + xmlrpc_env * const env, const xmlrpc_value * const result, gsize count) { gsize i, j, a, r; gsize found = 0; - g_assert((const gchar**)hlist->data + hlist->fill == hlist->added); - for (a = hlist->added - (const gchar**)hlist->data; hlist->data[a]; ++a); + g_assert(hlist->data + hlist->fill == hlist->added); + for (a = hlist->added - hlist->data; hlist->data[a].hash; ++a); hlist->fill = a; - hlist->added = (const gchar**)hlist->data + a; - for (r = hlist->removed - (const gchar**)hlist->data; hlist->data[r]; ++r) + hlist->added = hlist->data + a; + for (r = 0; hlist->removed[r]; ++r) { - g_free(hlist->data[r]); - } - g_assert(r == hlist->size - 1); - if (a + 5 > r) - { - gsize ns = a + 10; - gchar** tmp1 = realloc(hlist->data, ns * sizeof(gchar*)); - if (tmp1 != NULL) - { - gboolean* tmp2 = realloc(hlist->mark, ns * sizeof(gboolean)); - hlist->data = tmp1; - if (tmp2 != NULL) - { - hlist->mark = tmp2; - memset(hlist->data + hlist->size, 0, - (ns - hlist->size) * sizeof(gchar*)); - hlist->size = ns; - r = hlist->size - 1; - } - } + g_free((gchar*)hlist->removed[r]); } + hlist->removed[0] = NULL; memset(hlist->mark, 0, hlist->fill * sizeof(gboolean)); for (i = 0; i < count; ++i) { - xmlrpc_value* item; + xmlrpc_value* line, *item; const gchar* hash; - xmlrpc_array_read_item(env, result, i, &item); + xmlrpc_array_read_item(env, result, i, &line); + xmlrpc_array_read_item(env, line, 0, &item); xmlrpc_read_string(env, item, &hash); - xmlrpc_DECREF(item); + if (item) xmlrpc_DECREF(item); if (env->fault_occurred) { - hlist->added = (const gchar**)hlist->data + hlist->fill; - hlist->removed = (const gchar**)hlist->data + r; + hlist->added = hlist->data + hlist->fill; + if (line) xmlrpc_DECREF(line); return FALSE; } if (found == hlist->fill) { - if (a + 1 == r && - !hashlist_resize(hlist, &a, &r)) + if (a == hlist->size && !hashlist_data_resize(hlist)) { free((void*)hash); + xmlrpc_DECREF(line); return FALSE; } - hlist->data[a++] = (gchar*)hash; + torrent_data_init(hlist->data + a, hash); + if (!hashlist_item_sync(data, env, line, hlist->data + a++)) + { + hlist->added = hlist->data + hlist->fill; + hlist->data[a].hash = NULL; + xmlrpc_DECREF(line); + return FALSE; + } + hlist->data[a].hash = NULL; + xmlrpc_DECREF(line); continue; } /* Quick path */ if (i < hlist->fill && !hlist->mark[i] && - strcmp(hlist->data[i], hash) == 0) + strcmp(hlist->data[i].hash, hash) == 0) { + if (!hashlist_item_sync(data, env, line, hlist->data + i)) + { + hlist->added = hlist->data + hlist->fill; + xmlrpc_DECREF(line); + return FALSE; + } hlist->mark[i] = TRUE; found++; free((void*)hash); + xmlrpc_DECREF(line); continue; } for (j = i + 1; j != i; ++j) @@ -1629,13 +1623,19 @@ gboolean hashlist_sync(hashlist_t* hlist, xmlrpc_env * const env, { continue; } - if (strcmp(hlist->data[j], hash) == 0) + if (strcmp(hlist->data[j].hash, hash) == 0) { break; } } if (j != i) { + if (!hashlist_item_sync(data, env, line, hlist->data + j)) + { + hlist->added = hlist->data + hlist->fill; + xmlrpc_DECREF(line); + return FALSE; + } hlist->mark[j] = TRUE; found++; free((void*)hash); @@ -1643,34 +1643,49 @@ gboolean hashlist_sync(hashlist_t* hlist, xmlrpc_env * const env, else { /* New */ - if (a + 1 == r && - !hashlist_resize(hlist, &a, &r)) + if (a == hlist->size && !hashlist_data_resize(hlist)) { free((void*)hash); + xmlrpc_DECREF(line); return FALSE; } - hlist->data[a++] = (gchar*)hash; + torrent_data_init(hlist->data + a, hash); + if (!hashlist_item_sync(data, env, line, hlist->data + a++)) + { + hlist->data[a].hash = NULL; + hlist->added = hlist->data + hlist->fill; + xmlrpc_DECREF(line); + return FALSE; + } + hlist->data[a].hash = NULL; } + xmlrpc_DECREF(line); } if (found < hlist->fill) { gsize n = hlist->fill - found; - for (j = hlist->fill - 1; n > 0; --j) + if (!hashlist_removed_resize(hlist, n)) + { + hlist->added = hlist->data + hlist->fill; + return FALSE; + } + r = 0; + for (j = hlist->fill - 1; r < n; --j) { if (!hlist->mark[j]) { - hlist->data[--r] = hlist->data[j]; + hlist->removed[r++] = hlist->data[j].hash; + torrent_data_free(hlist->data + j); a--; hlist->fill--; memmove(hlist->data + j, hlist->data + j + 1, - (a - j) * sizeof(gchar*)); - hlist->data[a] = NULL; - n--; + (a - j) * sizeof(torrent_data_t)); + hlist->data[a].hash = NULL; } } + hlist->removed[r] = NULL; } - hlist->added = (const gchar**)hlist->data + hlist->fill; - hlist->removed = (const gchar**)hlist->data + r; + hlist->added = hlist->data + hlist->fill; return TRUE; } @@ -1685,9 +1700,10 @@ void torrent_destroy(gpointer value) g_slice_free(torrent_t, torrent); } -void torrent_data_init(torrent_data_t* data) +void torrent_data_init(torrent_data_t* data, const gchar* hash) { memset(data, 0, sizeof(torrent_data_t)); + data->hash = hash; data->left = -1; } @@ -1851,145 +1867,142 @@ gint liststore_default_compare_func(GtkTreeModel* model, } } -void sync_torrent_data(worker_data_t* data, xmlrpc_env* env, - xmlrpc_client* client, xmlrpc_server_info* server, - const gchar* hash, torrent_t* torrent) +gboolean hashlist_item_sync(worker_data_t* data, xmlrpc_env * const env, + const xmlrpc_value * const line, + torrent_data_t* torrent_data) { - xmlrpc_value* params; - torrent_data_t torrent_data; do { - xmlrpc_value* result = NULL, * item; + xmlrpc_value* item; const gchar* tmpstr; gint64 tmpi64; gboolean tmpb; guint64 done, up_rate, down_rate, ratio; - torrent_data_init(&torrent_data); - params = xmlrpc_array_new(env); - item = xmlrpc_string_new(env, hash); - xmlrpc_array_append_item(env, params, item); - xmlrpc_DECREF(item); - - xmlrpc_client_call2(env, client, server, "d.is_active", params, - &result); - tmpb = get_bool_xmlrpc(env, result); + g_assert(torrent_data->hash != NULL); + /* d.active */ + xmlrpc_array_read_item(env, line, 1, &item); + tmpb = get_bool_xmlrpc(env, item); if (env->fault_occurred) { break; } if (!tmpb) { - xmlrpc_client_call2(env, client, server, "d.hashing_failed", - params, &result); - tmpb = get_bool_xmlrpc(env, result); + /* d.hashing_failed */ + xmlrpc_array_read_item(env, line, 2, &item); + tmpb = get_bool_xmlrpc(env, item); if (env->fault_occurred) { break; } if (tmpb) { - torrent_data.state = STATE_HASHFAILED; + torrent_data->state = STATE_HASHFAILED; } else { - torrent_data.state = STATE_DEAD; + torrent_data->state = STATE_DEAD; } } else { - xmlrpc_client_call2(env, client, server, "d.is_hash_checking", - params, &result); - tmpb = get_bool_xmlrpc(env, result); + /* d.is_hash_checking */ + xmlrpc_array_read_item(env, line, 3, &item); + tmpb = get_bool_xmlrpc(env, item); if (env->fault_occurred) { break; } if (tmpb) { - torrent_data.state = STATE_REHASH; + torrent_data->state = STATE_REHASH; } else { - torrent_data.state = STATE_ACTIVE; + torrent_data->state = STATE_ACTIVE; } } - xmlrpc_client_call2(env, client, server, "d.name", params, &result); + /* d.name */ + xmlrpc_array_read_item(env, line, 4, &item); if (!env->fault_occurred) { - xmlrpc_read_string(env, result, &tmpstr); + xmlrpc_read_string(env, item, &tmpstr); } - if (result) xmlrpc_DECREF(result); + if (item) xmlrpc_DECREF(item); if (env->fault_occurred) { break; } - torrent_data.title = (gchar*)tmpstr; + g_free(torrent_data->title); + torrent_data->title = (gchar*)tmpstr; - xmlrpc_client_call2(env, client, server, "d.size_bytes", params, - &result); - tmpi64 = get_i64_xmlrpc(env, result); + /* d.size_bytes */ + xmlrpc_array_read_item(env, line, 5, &item); + tmpi64 = get_i64_xmlrpc(env, item); if (env->fault_occurred) { break; } - torrent_data.size = (guint64)tmpi64; + torrent_data->size = (guint64)tmpi64; - xmlrpc_client_call2(env, client, server, "d.bytes_done", params, - &result); - tmpi64 = get_i64_xmlrpc(env, result); + /* d.bytes_done */ + xmlrpc_array_read_item(env, line, 6, &item); + tmpi64 = get_i64_xmlrpc(env, item); if (env->fault_occurred) { break; } done = (guint64)tmpi64; - if (done >= torrent_data.size) + if (done >= torrent_data->size) { - torrent_data.downloaded = 100.0f; + torrent_data->downloaded = 100.0f; } - else if (torrent_data.size > 0) + else if (torrent_data->size > 0) { - torrent_data.downloaded = ((gfloat)done * 100.0f) / - (gfloat)torrent_data.size; + torrent_data->downloaded = ((gfloat)done * 100.0f) / + (gfloat)torrent_data->size; } else { - torrent_data.downloaded = 0.0f; + torrent_data->downloaded = 0.0f; } - xmlrpc_client_call2(env, client, server, "d.ratio", params, &result); - tmpi64 = get_i64_xmlrpc(env, result); + /* d.ratio */ + xmlrpc_array_read_item(env, line, 7, &item); + tmpi64 = get_i64_xmlrpc(env, item); if (env->fault_occurred) { break; } ratio = (guint64)tmpi64; - torrent_data.seeded = (gfloat)ratio / 1000.0f; + torrent_data->seeded = (gfloat)ratio / 1000.0f; - xmlrpc_client_call2(env, client, server, "d.down.rate", params, - &result); - tmpi64 = get_i64_xmlrpc(env, result); + /* d.down.rate */ + xmlrpc_array_read_item(env, line, 8, &item); + tmpi64 = get_i64_xmlrpc(env, item); if (env->fault_occurred) { break; } down_rate = (guint64)tmpi64; - torrent_data.down = (gfloat)down_rate / 1000.0f; + torrent_data->down = (gfloat)down_rate / 1000.0f; - xmlrpc_client_call2(env, client, server, "d.up.rate", params, &result); - tmpi64 = get_i64_xmlrpc(env, result); + /* d.up.rate */ + xmlrpc_array_read_item(env, line, 9, &item); + tmpi64 = get_i64_xmlrpc(env, item); if (env->fault_occurred) { break; } up_rate = (guint64)tmpi64; - torrent_data.up = (gfloat)up_rate / 1000.0f; + torrent_data->up = (gfloat)up_rate / 1000.0f; - if (torrent_data.downloaded < 100.0f) + if (torrent_data->downloaded < 100.0f) { if (down_rate >= 512) { - torrent_data.left = (torrent_data.size - done) / + torrent_data->left = (torrent_data->size - done) / (down_rate & ~(guint32)511); } } @@ -2000,7 +2013,7 @@ void sync_torrent_data(worker_data_t* data, xmlrpc_env* env, { if (ratio < data->ratio_max) { - upload_left = (torrent_data.size * + upload_left = (torrent_data->size * (data->ratio_max - ratio)) / 1000; } else @@ -2011,12 +2024,12 @@ void sync_torrent_data(worker_data_t* data, xmlrpc_env* env, if (data->ratio_min > 0) { /* Inexact but good enough */ - guint64 uploaded_bytes = (torrent_data.size * ratio) / 1000; + guint64 uploaded_bytes = (torrent_data->size * ratio) / 1000; if (uploaded_bytes >= data->ratio_upload) { if (ratio < data->ratio_min) { - gint64 tmp = (torrent_data.size * + gint64 tmp = (torrent_data->size * (data->ratio_min - ratio)) / 1000; if (upload_left < 0 || tmp < upload_left) { @@ -2041,24 +2054,97 @@ void sync_torrent_data(worker_data_t* data, xmlrpc_env* env, { if (up_rate >= 512) { - torrent_data.left = (guint64)upload_left / + torrent_data->left = (guint64)upload_left / (up_rate & ~(guint32)511); } } } } while (FALSE); + if (env->fault_occurred) + { + worker_respond(data, + msg_status("Failed to sync torrent %s (%d): %s", + torrent_data->hash, + env->fault_code, env->fault_string)); + env->fault_occurred = FALSE; + torrent_data->state = STATE_DEAD; + return FALSE; + } + return TRUE; +} + +void sync_torrent_state(worker_data_t* data, xmlrpc_env* env, + xmlrpc_client* client, xmlrpc_server_info* server, + const gchar* hash) +{ + xmlrpc_value* params; + state_t state = STATE_DEAD; + do + { + xmlrpc_value* result = NULL, * item; + gboolean tmpb; + params = xmlrpc_array_new(env); + item = xmlrpc_string_new(env, hash); + xmlrpc_array_append_item(env, params, item); + xmlrpc_DECREF(item); + + xmlrpc_client_call2(env, client, server, "d.is_active", params, + &result); + tmpb = get_bool_xmlrpc(env, result); + if (env->fault_occurred) + { + break; + } + if (!tmpb) + { + xmlrpc_client_call2(env, client, server, "d.hashing_failed", + params, &result); + tmpb = get_bool_xmlrpc(env, result); + if (env->fault_occurred) + { + break; + } + if (tmpb) + { + state = STATE_HASHFAILED; + } + else + { + state = STATE_DEAD; + } + } + else + { + xmlrpc_client_call2(env, client, server, "d.is_hash_checking", + params, &result); + tmpb = get_bool_xmlrpc(env, result); + if (env->fault_occurred) + { + break; + } + if (tmpb) + { + state = STATE_REHASH; + } + else + { + state = STATE_ACTIVE; + } + } + } + while (FALSE); xmlrpc_DECREF(params); if (env->fault_occurred) { worker_respond(data, - msg_status("Failed to update torrent %s (%d): %s", + msg_status("Failed to sync torrent %s (%d): %s", hash, env->fault_code, env->fault_string)); env->fault_occurred = FALSE; - torrent_data.state = STATE_DEAD; + state = STATE_DEAD; } - worker_respond(data, msg_sync(hash, torrent, &torrent_data)); + worker_respond(data, msg_syncstate(hash, state)); } void listselection_changed(GtkTreeSelection* selection, |