timeout and retries settings

6 files changed, 238 insertions, 269 deletions

diff --git a/src/trg-client.c b/src/trg-client.c
index 0cfd4fc..05cd148 100644
--- a/src/trg-client.c
+++ b/src/trg-client.c
@@ -56,8 +56,7 @@
 G_DEFINE_TYPE(TrgClient, trg_client, G_TYPE_OBJECT)
 
 enum {
-    TC_SESSION_UPDATED,
-    TC_SIGNAL_COUNT
+    TC_SESSION_UPDATED, TC_SIGNAL_COUNT
 };
 
 static guint signals[TC_SIGNAL_COUNT] = { 0 };
@@ -71,6 +70,8 @@ struct _TrgClientPrivate {
     char *session_id;
     gint connid;
     guint failCount;
+    guint retries;
+    guint timeout;
     gint64 updateSerial;
     JsonObject *session;
     gboolean ssl;
@@ -88,13 +89,10 @@ struct _TrgClientPrivate {
     GMutex *configMutex;
 };
 
-static void dispatch_async_threadfunc(trg_request * reqrsp,
-                                      TrgClient * client);
+static void dispatch_async_threadfunc(trg_request * reqrsp, TrgClient * client);
 
-static void
-trg_client_get_property(GObject * object, guint property_id,
-                        GValue * value, GParamSpec * pspec)
-{
+static void trg_client_get_property(GObject * object, guint property_id,
+        GValue * value, GParamSpec * pspec) {
     switch (property_id) {
     default:
         G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec);
@@ -102,10 +100,8 @@ trg_client_get_property(GObject * object, guint property_id,
     }
 }
 
-static void
-trg_client_set_property(GObject * object, guint property_id,
-                        const GValue * value, GParamSpec * pspec)
-{
+static void trg_client_set_property(GObject * object, guint property_id,
+        const GValue * value, GParamSpec * pspec) {
     switch (property_id) {
     default:
         G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec);
@@ -113,13 +109,11 @@ trg_client_set_property(GObject * object, guint property_id,
     }
 }
 
-static void trg_client_dispose(GObject * object)
-{
+static void trg_client_dispose(GObject * object) {
     G_OBJECT_CLASS(trg_client_parent_class)->dispose(object);
 }
 
-static void trg_client_class_init(TrgClientClass * klass)
-{
+static void trg_client_class_init(TrgClientClass * klass) {
     GObjectClass *object_class = G_OBJECT_CLASS(klass);
 
     g_type_class_add_private(klass, sizeof(TrgClientPrivate));
@@ -128,22 +122,17 @@ static void trg_client_class_init(TrgClientClass * klass)
     object_class->set_property = trg_client_set_property;
     object_class->dispose = trg_client_dispose;
 
-    signals[TC_SESSION_UPDATED] =
-        g_signal_new("session-updated",
-                     G_TYPE_FROM_CLASS(object_class),
-                     G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
-                     G_STRUCT_OFFSET(TrgClientClass,
-                                     session_updated), NULL,
-                     NULL, g_cclosure_marshal_VOID__POINTER,
-                     G_TYPE_NONE, 1, G_TYPE_POINTER);
+    signals[TC_SESSION_UPDATED] = g_signal_new("session-updated",
+            G_TYPE_FROM_CLASS(object_class),
+            G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION, G_STRUCT_OFFSET(TrgClientClass,
+                    session_updated), NULL, NULL,
+            g_cclosure_marshal_VOID__POINTER, G_TYPE_NONE, 1, G_TYPE_POINTER);
 }
 
-static void trg_client_init(TrgClient * self)
-{
+static void trg_client_init(TrgClient * self) {
 }
 
-TrgClient *trg_client_new(void)
-{
+TrgClient *trg_client_new(void) {
     TrgClient *tc = g_object_new(TRG_TYPE_CLIENT, NULL);
     TrgClientPrivate *priv = TRG_CLIENT_GET_PRIVATE(tc);
     TrgPrefs *prefs = priv->prefs = trg_prefs_new();
@@ -155,41 +144,37 @@ TrgClient *trg_client_new(void)
     priv->tlsKey = g_private_new(NULL);
 
     priv->pool = g_thread_pool_new((GFunc) dispatch_async_threadfunc, tc,
-                                   DISPATCH_POOL_SIZE, TRUE, NULL);
-
-    tr_formatter_size_init( disk_K, _(disk_K_str), _(disk_M_str), _(disk_G_str), _(disk_T_str) );
-    tr_formatter_speed_init( speed_K, _(speed_K_str), _(speed_M_str), _(speed_G_str), _(speed_T_str) );
+            DISPATCH_POOL_SIZE, TRUE, NULL);
 
+    tr_formatter_size_init(disk_K, _(disk_K_str), _(disk_M_str), _(disk_G_str),
+            _(disk_T_str));
+    tr_formatter_speed_init(speed_K, _(speed_K_str), _(speed_M_str),
+            _(speed_G_str), _(speed_T_str));
 
     return tc;
 }
 
-const gchar *trg_client_get_version_string(TrgClient * tc)
-{
+const gchar *trg_client_get_version_string(TrgClient * tc) {
     TrgClientPrivate *priv = TRG_CLIENT_GET_PRIVATE(tc);
     return session_get_version_string(priv->session);
 }
 
-float trg_client_get_version(TrgClient * tc)
-{
+float trg_client_get_version(TrgClient * tc) {
     TrgClientPrivate *priv = TRG_CLIENT_GET_PRIVATE(tc);
     return priv->version;
 }
 
-gint64 trg_client_get_rpc_version(TrgClient * tc)
-{
+gint64 trg_client_get_rpc_version(TrgClient * tc) {
     TrgClientPrivate *priv = TRG_CLIENT_GET_PRIVATE(tc);
     return session_get_rpc_version(priv->session);
 }
 
-void trg_client_inc_connid(TrgClient * tc)
-{
+void trg_client_inc_connid(TrgClient * tc) {
     TrgClientPrivate *priv = TRG_CLIENT_GET_PRIVATE(tc);
     g_atomic_int_inc(&priv->connid);
 }
 
-void trg_client_set_session(TrgClient * tc, JsonObject * session)
-{
+void trg_client_set_session(TrgClient * tc, JsonObject * session) {
     TrgClientPrivate *priv = TRG_CLIENT_GET_PRIVATE(tc);
 
     if (priv->session) {
@@ -204,14 +189,12 @@ void trg_client_set_session(TrgClient * tc, JsonObject * session)
     g_signal_emit(tc, signals[TC_SESSION_UPDATED], 0, session);
 }
 
-TrgPrefs *trg_client_get_prefs(TrgClient * tc)
-{
+TrgPrefs *trg_client_get_prefs(TrgClient * tc) {
     TrgClientPrivate *priv = TRG_CLIENT_GET_PRIVATE(tc);
     return priv->prefs;
 }
 
-int trg_client_populate_with_settings(TrgClient * tc)
-{
+int trg_client_populate_with_settings(TrgClient * tc) {
     TrgClientPrivate *priv = TRG_CLIENT_GET_PRIVATE(tc);
     TrgPrefs *prefs = priv->prefs;
 
@@ -234,37 +217,33 @@ int trg_client_populate_with_settings(TrgClient * tc)
     g_free(priv->password);
     priv->password = NULL;
 
-    port =
-        trg_prefs_get_int(prefs, TRG_PREFS_KEY_PORT, TRG_PREFS_CONNECTION);
+    port = trg_prefs_get_int(prefs, TRG_PREFS_KEY_PORT, TRG_PREFS_CONNECTION);
 
-    host =
-        trg_prefs_get_string(prefs, TRG_PREFS_KEY_HOSTNAME,
-                             TRG_PREFS_CONNECTION);
+    host = trg_prefs_get_string(prefs, TRG_PREFS_KEY_HOSTNAME,
+            TRG_PREFS_CONNECTION);
     if (!host || strlen(host) < 1) {
         g_free(host);
         g_mutex_unlock(priv->configMutex);
         return TRG_NO_HOSTNAME_SET;
     }
+
 #ifndef CURL_NO_SSL
-    priv->ssl =
-        trg_prefs_get_bool(prefs, TRG_PREFS_KEY_SSL, TRG_PREFS_CONNECTION);
+    priv->ssl = trg_prefs_get_bool(prefs, TRG_PREFS_KEY_SSL,
+            TRG_PREFS_CONNECTION);
 #else
     priv->ssl = FALSE;
 #endif
 
-    priv->url =
-        g_strdup_printf("%s://%s:%d/transmission/rpc",
-                        priv->ssl ? HTTPS_URI_PREFIX : HTTP_URI_PREFIX,
-                        host, port);
+    priv->url = g_strdup_printf("%s://%s:%d/transmission/rpc",
+            priv->ssl ? HTTPS_URI_PREFIX : HTTP_URI_PREFIX,
+            host, port);
     g_free(host);
 
-    priv->username =
-        trg_prefs_get_string(prefs, TRG_PREFS_KEY_USERNAME,
-                             TRG_PREFS_CONNECTION);
+    priv->username = trg_prefs_get_string(prefs, TRG_PREFS_KEY_USERNAME,
+            TRG_PREFS_CONNECTION);
 
-    priv->password =
-        trg_prefs_get_string(prefs, TRG_PREFS_KEY_PASSWORD,
-                             TRG_PREFS_CONNECTION);
+    priv->password = trg_prefs_get_string(prefs, TRG_PREFS_KEY_PASSWORD,
+            TRG_PREFS_CONNECTION);
 
     g_free(priv->proxy);
     priv->proxy = NULL;
@@ -293,32 +272,27 @@ int trg_client_populate_with_settings(TrgClient * tc)
     return 0;
 }
 
-gchar *trg_client_get_password(TrgClient * tc)
-{
+gchar *trg_client_get_password(TrgClient * tc) {
     TrgClientPrivate *priv = TRG_CLIENT_GET_PRIVATE(tc);
     return priv->password;
 }
 
-gchar *trg_client_get_username(TrgClient * tc)
-{
+gchar *trg_client_get_username(TrgClient * tc) {
     TrgClientPrivate *priv = TRG_CLIENT_GET_PRIVATE(tc);
     return priv->username;
 }
 
-gchar *trg_client_get_url(TrgClient * tc)
-{
+gchar *trg_client_get_url(TrgClient * tc) {
     TrgClientPrivate *priv = TRG_CLIENT_GET_PRIVATE(tc);
     return priv->url;
 }
 
-gchar *trg_client_get_session_id(TrgClient * tc)
-{
+gchar *trg_client_get_session_id(TrgClient * tc) {
     TrgClientPrivate *priv = TRG_CLIENT_GET_PRIVATE(tc);
     return priv->session_id ? g_strdup(priv->session_id) : NULL;
 }
 
-void trg_client_set_session_id(TrgClient * tc, gchar * session_id)
-{
+void trg_client_set_session_id(TrgClient * tc, gchar * session_id) {
     TrgClientPrivate *priv = TRG_CLIENT_GET_PRIVATE(tc);
 
     g_mutex_lock(priv->configMutex);
@@ -331,132 +305,111 @@ void trg_client_set_session_id(TrgClient * tc, gchar * session_id)
     g_mutex_unlock(priv->configMutex);
 }
 
-void trg_client_status_change(TrgClient * tc, gboolean connected)
-{
+void trg_client_status_change(TrgClient * tc, gboolean connected) {
     TrgClientPrivate *priv = TRG_CLIENT_GET_PRIVATE(tc);
 
     if (!connected) {
         if (priv->session) {
             json_object_unref(priv->session);
             priv->session = NULL;
-        }
-        g_mutex_lock(priv->configMutex);
+        }g_mutex_lock(priv->configMutex);
         trg_prefs_set_connection(priv->prefs, NULL);
         g_mutex_unlock(priv->configMutex);
     }
 }
 
-JsonObject *trg_client_get_session(TrgClient * tc)
-{
+JsonObject *trg_client_get_session(TrgClient * tc) {
     TrgClientPrivate *priv = TRG_CLIENT_GET_PRIVATE(tc);
     return priv->session;
 }
 
-void trg_client_thread_pool_push(TrgClient * tc, gpointer data,
-                                 GError ** err)
-{
+void trg_client_thread_pool_push(TrgClient * tc, gpointer data, GError ** err) {
     TrgClientPrivate *priv = TRG_CLIENT_GET_PRIVATE(tc);
     g_thread_pool_push(priv->pool, data, err);
 }
 
-void trg_client_inc_serial(TrgClient * tc)
-{
+void trg_client_inc_serial(TrgClient * tc) {
     TrgClientPrivate *priv = TRG_CLIENT_GET_PRIVATE(tc);
     priv->updateSerial++;
 }
 
-gint64 trg_client_get_serial(TrgClient * tc)
-{
+gint64 trg_client_get_serial(TrgClient * tc) {
     TrgClientPrivate *priv = TRG_CLIENT_GET_PRIVATE(tc);
     return priv->updateSerial;
 }
 
 #ifndef CURL_NO_SSL
-gboolean trg_client_get_ssl(TrgClient * tc)
-{
+gboolean trg_client_get_ssl(TrgClient * tc) {
     TrgClientPrivate *priv = TRG_CLIENT_GET_PRIVATE(tc);
     return priv->ssl;
 }
 #endif
 
-gchar *trg_client_get_proxy(TrgClient * tc)
-{
+gchar *trg_client_get_proxy(TrgClient * tc) {
     TrgClientPrivate *priv = TRG_CLIENT_GET_PRIVATE(tc);
     return priv->proxy;
 }
 
-void trg_client_set_torrent_table(TrgClient * tc, GHashTable * table)
-{
+void trg_client_set_torrent_table(TrgClient * tc, GHashTable * table) {
     TrgClientPrivate *priv = TRG_CLIENT_GET_PRIVATE(tc);
     priv->torrentTable = table;
 }
 
-GHashTable *trg_client_get_torrent_table(TrgClient * tc)
-{
+GHashTable *trg_client_get_torrent_table(TrgClient * tc) {
     TrgClientPrivate *priv = TRG_CLIENT_GET_PRIVATE(tc);
     return priv->torrentTable;
 }
 
-gboolean trg_client_is_connected(TrgClient * tc)
-{
+gboolean trg_client_is_connected(TrgClient * tc) {
     TrgClientPrivate *priv = TRG_CLIENT_GET_PRIVATE(tc);
     return priv->session != NULL;
 }
 
-void trg_client_updatelock(TrgClient * tc)
-{
+void trg_client_updatelock(TrgClient * tc) {
     TrgClientPrivate *priv = TRG_CLIENT_GET_PRIVATE(tc);
     g_mutex_lock(priv->updateMutex);
 }
 
-void trg_client_configlock(TrgClient * tc)
-{
+void trg_client_configlock(TrgClient * tc) {
     TrgClientPrivate *priv = TRG_CLIENT_GET_PRIVATE(tc);
     g_mutex_lock(priv->configMutex);
 }
 
-guint trg_client_get_failcount(TrgClient * tc)
-{
+guint trg_client_get_failcount(TrgClient * tc) {
     TrgClientPrivate *priv = TRG_CLIENT_GET_PRIVATE(tc);
     return priv->failCount;
 }
 
-guint trg_client_inc_failcount(TrgClient * tc)
-{
+guint trg_client_inc_failcount(TrgClient * tc) {
     TrgClientPrivate *priv = TRG_CLIENT_GET_PRIVATE(tc);
     return ++(priv->failCount);
 }
 
-void trg_client_reset_failcount(TrgClient * tc)
-{
+void trg_client_reset_failcount(TrgClient * tc) {
     TrgClientPrivate *priv = TRG_CLIENT_GET_PRIVATE(tc);
     priv->failCount = 0;
 }
 
-void trg_client_updateunlock(TrgClient * tc)
-{
+void trg_client_updateunlock(TrgClient * tc) {
     TrgClientPrivate *priv = TRG_CLIENT_GET_PRIVATE(tc);
     g_mutex_unlock(priv->updateMutex);
 }
 
-void trg_client_configunlock(TrgClient * tc)
-{
+void trg_client_configunlock(TrgClient * tc) {
     TrgClientPrivate *priv = TRG_CLIENT_GET_PRIVATE(tc);
     g_mutex_unlock(priv->configMutex);
 }
 
 /* formerly http.c */
 
-void trg_response_free(trg_response * response)
-{
+void trg_response_free(trg_response * response) {
     if (response->obj)
         json_object_unref(response->obj);
     g_free(response);
 }
 
-static size_t
-http_receive_callback(void *ptr, size_t size, size_t nmemb, void *data)
-{
+static size_t http_receive_callback(void *ptr, size_t size, size_t nmemb,
+        void *data) {
     size_t realsize = size * nmemb;
     trg_response *mem = (trg_response *) data;
 
@@ -470,9 +423,7 @@ http_receive_callback(void *ptr, size_t size, size_t nmemb, void *data)
     return realsize;
 }
 
-static size_t header_callback(void *ptr, size_t size, size_t nmemb,
-                              void *data)
-{
+static size_t header_callback(void *ptr, size_t size, size_t nmemb, void *data) {
     char *header = (char *) (ptr);
     TrgClient *tc = TRG_CLIENT(data);
     gchar *session_id;
@@ -491,15 +442,15 @@ static size_t header_callback(void *ptr, size_t size, size_t nmemb,
     return (nmemb * size);
 }
 
-static void trg_tls_update(TrgClient * tc, trg_tls * tls, gint serial)
-{
+static void trg_tls_update(TrgClient * tc, trg_tls * tls, gint serial) {
+    TrgPrefs *prefs = trg_client_get_prefs(tc);
     gchar *proxy;
 
-    curl_easy_setopt(tls->curl, CURLOPT_PASSWORD,
-                     trg_client_get_password(tc));
-    curl_easy_setopt(tls->curl, CURLOPT_USERNAME,
-                     trg_client_get_username(tc));
+    curl_easy_setopt(tls->curl, CURLOPT_PASSWORD, trg_client_get_password(tc));
+    curl_easy_setopt(tls->curl, CURLOPT_USERNAME, trg_client_get_username(tc));
     curl_easy_setopt(tls->curl, CURLOPT_URL, trg_client_get_url(tc));
+    curl_easy_setopt(tls->curl, CURLOPT_TIMEOUT,
+            trg_prefs_get_int(prefs, TRG_PREFS_KEY_TIMEOUT, TRG_PREFS_CONNECTION));
 
 #ifndef CURL_NO_SSL
     if (trg_client_get_ssl(tc))
@@ -515,16 +466,13 @@ static void trg_tls_update(TrgClient * tc, trg_tls * tls, gint serial)
     tls->serial = serial;
 }
 
-trg_tls *trg_tls_new(TrgClient * tc)
-{
+trg_tls *trg_tls_new(TrgClient * tc) {
     trg_tls *tls = g_new0(trg_tls, 1);
 
     tls->curl = curl_easy_init();
     curl_easy_setopt(tls->curl, CURLOPT_USERAGENT, PACKAGE_NAME);
     curl_easy_setopt(tls->curl, CURLOPT_HTTPAUTH, CURLAUTH_BASIC);
-    curl_easy_setopt(tls->curl, CURLOPT_TIMEOUT, 40);
-    curl_easy_setopt(tls->curl, CURLOPT_WRITEFUNCTION,
-                     &http_receive_callback);
+    curl_easy_setopt(tls->curl, CURLOPT_WRITEFUNCTION, &http_receive_callback);
     curl_easy_setopt(tls->curl, CURLOPT_HEADERFUNCTION, &header_callback);
     curl_easy_setopt(tls->curl, CURLOPT_WRITEHEADER, (void *) tc);
 
@@ -533,11 +481,8 @@ trg_tls *trg_tls_new(TrgClient * tc)
     return tls;
 }
 
-static int trg_http_perform_inner(TrgClient * tc,
-                                  gchar * reqstr,
-                                  trg_response * response,
-                                  gboolean recurse)
-{
+static int trg_http_perform_inner(TrgClient * tc, gchar * reqstr,
+        trg_response * response, gboolean recurse) {
     TrgClientPrivate *priv = TRG_CLIENT_GET_PRIVATE(tc);
     gpointer threadLocalStorage = g_private_get(priv->tlsKey);
     trg_tls *tls;
@@ -580,35 +525,34 @@ static int trg_http_perform_inner(TrgClient * tc,
     curl_easy_getinfo(tls->curl, CURLINFO_RESPONSE_CODE, &httpCode);
 
     if (response->status == CURLE_OK) {
-        if (httpCode == HTTP_CONFLICT && recurse == TRUE)
+        if (httpCode == HTTP_CONFLICT && recurse == TRUE
+            )
             return trg_http_perform_inner(tc, reqstr, response, FALSE);
-        else if (httpCode != HTTP_OK)
+        else if (httpCode != HTTP_OK
+            )
             response->status = (-httpCode) - 100;
     }
 
     return response->status;
 }
 
-int trg_http_perform(TrgClient * tc, gchar * reqstr, trg_response * reqrsp)
-{
+int trg_http_perform(TrgClient * tc, gchar * reqstr, trg_response * reqrsp) {
     return trg_http_perform_inner(tc, reqstr, reqrsp, TRUE);
 }
 
 /* formerly dispatch.c */
 
-trg_response *dispatch(TrgClient * client, JsonNode * req)
-{
+trg_response *dispatch(TrgClient * client, JsonNode * req) {
     gchar *serialized = trg_serialize(req);
     json_node_free(req);
 #ifdef DEBUG
     if (g_getenv("TRG_SHOW_OUTGOING"))
-        g_debug("=>(OUTgoing)=>: %s", serialized);
+    g_debug("=>(OUTgoing)=>: %s", serialized);
 #endif
     return dispatch_str(client, serialized);
 }
 
-trg_response *dispatch_str(TrgClient * client, gchar * req)
-{
+trg_response *dispatch_str(TrgClient * client, gchar * req) {
     trg_response *response = g_new0(trg_response, 1);
     GError *decode_error = NULL;
     JsonNode *result;
@@ -637,9 +581,7 @@ trg_response *dispatch_str(TrgClient * client, gchar * req)
     return response;
 }
 
-static void dispatch_async_threadfunc(trg_request * req,
-                                      TrgClient * client)
-{
+static void dispatch_async_threadfunc(trg_request * req, TrgClient * client) {
     TrgClientPrivate *priv = TRG_CLIENT_GET_PRIVATE(client);
 
     trg_response *rsp;
@@ -651,7 +593,8 @@ static void dispatch_async_threadfunc(trg_request * req,
 
     rsp->cb_data = req->cb_data;
 
-    if (req->callback && req->connid == g_atomic_int_get(&priv->connid))
+    if (req->callback && req->connid == g_atomic_int_get(&priv->connid)
+        )
         g_idle_add(req->callback, rsp);
     else
         trg_response_free(rsp);
@@ -659,10 +602,8 @@ static void dispatch_async_threadfunc(trg_request * req,
     g_free(req);
 }
 
-static gboolean dispatch_async_common(TrgClient * client,
-                                      trg_request * trg_req,
-                                      GSourceFunc callback, gpointer data)
-{
+static gboolean dispatch_async_common(TrgClient * client, trg_request * trg_req,
+        GSourceFunc callback, gpointer data) {
     TrgClientPrivate *priv = TRG_CLIENT_GET_PRIVATE(client);
     GError *error = NULL;
 
@@ -682,8 +623,7 @@ static gboolean dispatch_async_common(TrgClient * client,
 }
 
 gboolean dispatch_async(TrgClient * client, JsonNode * req,
-                        GSourceFunc callback, gpointer data)
-{
+        GSourceFunc callback, gpointer data) {
     trg_request *trg_req = g_new0(trg_request, 1);
     trg_req->node = req;
 
@@ -691,8 +631,7 @@ gboolean dispatch_async(TrgClient * client, JsonNode * req,
 }
 
 gboolean dispatch_async_str(TrgClient * client, gchar * req,
-                            GSourceFunc callback, gpointer data)
-{
+        GSourceFunc callback, gpointer data) {
     trg_request *trg_req = g_new0(trg_request, 1);
     trg_req->str = req;
 
diff --git a/src/trg-client.h b/src/trg-client.h
index 5a5e004..3609f34 100644
--- a/src/trg-client.h
+++ b/src/trg-client.h
@@ -37,7 +37,6 @@
 
 #define TRANSMISSION_MIN_SUPPORTED 2.0
 #define X_TRANSMISSION_SESSION_ID_HEADER_PREFIX "X-Transmission-Session-Id: "
-#define TRG_MAX_RETRIES 3
 
 #define TORRENT_GET_MODE_FIRST 0
 #define TORRENT_GET_MODE_ACTIVE 1
diff --git a/src/trg-main-window.c b/src/trg-main-window.c
index 4d847c0..8f5f25b 100644
--- a/src/trg-main-window.c
+++ b/src/trg-main-window.c
@@ -1026,13 +1026,14 @@ static gboolean on_torrent_get(gpointer data, int mode) {
         interval = TRG_INTERVAL_DEFAULT;
 
     if (response->status != CURLE_OK) {
-        if (trg_client_inc_failcount(client) >= TRG_MAX_RETRIES) {
+        gint64 max_retries = trg_prefs_get_int(prefs, TRG_PREFS_KEY_RETRIES, TRG_PREFS_CONNECTION);
+        if (trg_client_inc_failcount(client) >= max_retries) {
             trg_main_window_conn_changed(win, FALSE);
             trg_dialog_error_handler(win, response);
         } else {
             gchar *msg = make_error_message(response->obj, response->status);
             gchar *statusBarMsg = g_strdup_printf(_("Request %d/%d failed: %s"),
-                    trg_client_get_failcount(client), TRG_MAX_RETRIES, msg);
+                    trg_client_get_failcount(client), max_retries, msg);
             trg_status_bar_push_connection_msg(priv->statusBar, statusBarMsg);
             g_free(msg);
             g_free(statusBarMsg);
diff --git a/src/trg-preferences-dialog.c b/src/trg-preferences-dialog.c
index 53a55ea..266733c 100644
--- a/src/trg-preferences-dialog.c
+++ b/src/trg-preferences-dialog.c
@@ -371,87 +371,62 @@ static void notebook_toggled_cb(GtkToggleButton * b, gpointer data)
                                          gtk_toggle_button_get_active(b));
 }
 
+static void trgp_double_special_dependent(GtkWidget * widget,
+                                          gpointer data)
+{
+    TrgPreferencesDialogPrivate *priv =
+        TRG_PREFERENCES_DIALOG_GET_PRIVATE(gtk_widget_get_toplevel
+                                           (widget));
+    gtk_widget_set_sensitive(GTK_WIDGET(data),
+                             gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON
+                                                          (widget))
+                             &&
+                             gtk_widget_get_sensitive
+                             (priv->fullUpdateCheck)
+                             &&
+                             gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON
+                                                          (priv->fullUpdateCheck)));
+}
+
 static GtkWidget *trg_prefs_generalPage(TrgPreferencesDialog * dlg)
 {
     TrgPreferencesDialogPrivate *priv =
         TRG_PREFERENCES_DIALOG_GET_PRIVATE(dlg);
 
-    GtkWidget *tray, *w, *dep, *t;
+    GtkWidget *w, *activeOnly, *t;
     gint row = 0;
 
     t = hig_workarea_create();
 
-    hig_workarea_add_section_title(t, &row, _("View"));
-
-    dep = w = trgp_check_new(dlg, _("State selector"),
-                             TRG_PREFS_KEY_SHOW_STATE_SELECTOR,
-                             TRG_PREFS_GLOBAL, NULL);
-    g_signal_connect(G_OBJECT(w), "toggled",
-                     G_CALLBACK(view_states_toggled_cb), priv->win);
-    hig_workarea_add_wide_control(t, &row, w);
-
-    w = trgp_check_new(dlg, _("Directory filters"),
-                       TRG_PREFS_KEY_FILTER_DIRS, TRG_PREFS_GLOBAL,
-                       GTK_TOGGLE_BUTTON(dep));
-    g_signal_connect(G_OBJECT(w), "toggled",
-                     G_CALLBACK(menu_bar_toggle_filter_dirs), priv->win);
-    hig_workarea_add_wide_control(t, &row, w);
-
-    w = trgp_check_new(dlg, _("Tracker filters"),
-                       TRG_PREFS_KEY_FILTER_TRACKERS, TRG_PREFS_GLOBAL,
-                       GTK_TOGGLE_BUTTON(dep));
-    g_signal_connect(G_OBJECT(w), "toggled",
-                     G_CALLBACK(toggle_filter_trackers), priv->win);
-    hig_workarea_add_wide_control(t, &row, w);
-
-    w = trgp_check_new(dlg, _("Torrent Details"),
-                       TRG_PREFS_KEY_SHOW_NOTEBOOK, TRG_PREFS_GLOBAL,
-                       NULL);
-    g_signal_connect(G_OBJECT(w), "toggled",
-                     G_CALLBACK(notebook_toggled_cb), priv->win);
-    hig_workarea_add_wide_control(t, &row, w);
+    hig_workarea_add_section_title(t, &row, _("Updates"));
 
-#ifndef TRG_NO_GRAPH
-    w = trgp_check_new(dlg, _("Show graph"), TRG_PREFS_KEY_SHOW_GRAPH,
-                       TRG_PREFS_GLOBAL, GTK_TOGGLE_BUTTON(w));
-    g_signal_connect(G_OBJECT(w), "toggled", G_CALLBACK(toggle_graph),
-                     priv->win);
+    activeOnly = w = trgp_check_new(dlg, _("Update active torrents only"),
+                                    TRG_PREFS_KEY_UPDATE_ACTIVE_ONLY,
+                                    TRG_PREFS_PROFILE, NULL);
     hig_workarea_add_wide_control(t, &row, w);
-#endif
 
-    hig_workarea_add_section_title(t, &row, _("System Tray"));
-
-    tray = trgp_check_new(dlg, _("Show in system tray"),
-                          TRG_PREFS_KEY_SYSTEM_TRAY, TRG_PREFS_GLOBAL,
-                          NULL);
-    g_signal_connect(G_OBJECT(tray), "toggled",
-                     G_CALLBACK(toggle_tray_icon), priv->win);
-    hig_workarea_add_wide_control(t, &row, tray);
-
-#ifndef HAVE_LIBAPPINDICATOR
-    w = trgp_check_new(dlg, _("Minimise to system tray"),
-                       TRG_PREFS_KEY_SYSTEM_TRAY_MINIMISE,
-                       TRG_PREFS_GLOBAL, NULL);
-    gtk_widget_set_sensitive(w,
-                             gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON
-                                                          (tray)));
-    g_signal_connect(G_OBJECT(tray), "toggled",
-                     G_CALLBACK(toggle_active_arg_is_sensitive), w);
-    hig_workarea_add_wide_control(t, &row, w);
-#endif
+    priv->fullUpdateCheck = trgp_check_new(dlg,
+                                           _
+                                           ("Full update every (?) updates"),
+                                           TRG_PREFS_ACTIVEONLY_FULLSYNC_ENABLED,
+                                           TRG_PREFS_PROFILE,
+                                           GTK_TOGGLE_BUTTON(activeOnly));
+    w = trgp_spin_new(dlg, TRG_PREFS_ACTIVEONLY_FULLSYNC_EVERY, 2, INT_MAX,
+                      1, TRG_PREFS_PROFILE,
+                      GTK_TOGGLE_BUTTON(priv->fullUpdateCheck));
+    g_signal_connect(activeOnly, "toggled",
+                     G_CALLBACK(trgp_double_special_dependent), w);
 
-#ifdef HAVE_LIBNOTIFY
-    hig_workarea_add_section_title(t, &row, _("Notifications"));
+    hig_workarea_add_row_w(t, &row, priv->fullUpdateCheck, w, NULL);
 
-    w = trgp_check_new(dlg, _("Torrent added notifications"),
-                       TRG_PREFS_KEY_ADD_NOTIFY, TRG_PREFS_GLOBAL, NULL);
-    hig_workarea_add_wide_control(t, &row, w);
+    w = trgp_spin_new(dlg, TRG_PREFS_KEY_UPDATE_INTERVAL, 1, INT_MAX, 1,
+                      TRG_PREFS_PROFILE, NULL);
+    hig_workarea_add_row(t, &row, _("Update interval:"), w, NULL);
 
-    w = trgp_check_new(dlg, _("Torrent complete notifications"),
-                       TRG_PREFS_KEY_COMPLETE_NOTIFY, TRG_PREFS_GLOBAL,
-                       NULL);
-    hig_workarea_add_wide_control(t, &row, w);
-#endif
+    w = trgp_spin_new(dlg, TRG_PREFS_KEY_MINUPDATE_INTERVAL, 1, INT_MAX, 1,
+                      TRG_PREFS_PROFILE, NULL);
+    hig_workarea_add_row(t, &row, _("Minimised update interval:"), w,
+                         NULL);
 
     hig_workarea_add_section_title(t, &row, _("Torrents"));
 
@@ -605,23 +580,6 @@ static void add_profile_cb(GtkWidget * w, gpointer data)
     gtk_combo_box_set_active_iter(combo, &iter);
 }
 
-static void trgp_double_special_dependent(GtkWidget * widget,
-                                          gpointer data)
-{
-    TrgPreferencesDialogPrivate *priv =
-        TRG_PREFERENCES_DIALOG_GET_PRIVATE(gtk_widget_get_toplevel
-                                           (widget));
-    gtk_widget_set_sensitive(GTK_WIDGET(data),
-                             gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON
-                                                          (widget))
-                             &&
-                             gtk_widget_get_sensitive
-                             (priv->fullUpdateCheck)
-                             &&
-                             gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON
-                                                          (priv->fullUpdateCheck)));
-}
-
 static GtkWidget *trg_prefs_openExecPage(TrgPreferencesDialog * dlg)
 {
     TrgPreferencesDialogPrivate *priv =
@@ -697,13 +655,98 @@ static GtkWidget *trg_prefs_dirsPage(TrgPreferencesDialog * dlg)
     return t;
 }
 
+static GtkWidget *trg_prefs_viewPage(TrgPreferencesDialog * dlg)
+{
+    TrgPreferencesDialogPrivate *priv =
+        TRG_PREFERENCES_DIALOG_GET_PRIVATE(dlg);
+
+    GtkWidget *w, *dep, *t, *tray;
+    gint row = 0;
+
+    t = hig_workarea_create();
+
+    hig_workarea_add_section_title(t, &row, _("View"));
+
+    dep = w = trgp_check_new(dlg, _("State selector"),
+                             TRG_PREFS_KEY_SHOW_STATE_SELECTOR,
+                             TRG_PREFS_GLOBAL, NULL);
+    g_signal_connect(G_OBJECT(w), "toggled",
+                     G_CALLBACK(view_states_toggled_cb), priv->win);
+    hig_workarea_add_wide_control(t, &row, w);
+
+    w = trgp_check_new(dlg, _("Directory filters"),
+                       TRG_PREFS_KEY_FILTER_DIRS, TRG_PREFS_GLOBAL,
+                       GTK_TOGGLE_BUTTON(dep));
+    g_signal_connect(G_OBJECT(w), "toggled",
+                     G_CALLBACK(menu_bar_toggle_filter_dirs), priv->win);
+    hig_workarea_add_wide_control(t, &row, w);
+
+    w = trgp_check_new(dlg, _("Tracker filters"),
+                       TRG_PREFS_KEY_FILTER_TRACKERS, TRG_PREFS_GLOBAL,
+                       GTK_TOGGLE_BUTTON(dep));
+    g_signal_connect(G_OBJECT(w), "toggled",
+                     G_CALLBACK(toggle_filter_trackers), priv->win);
+    hig_workarea_add_wide_control(t, &row, w);
+
+    w = trgp_check_new(dlg, _("Torrent Details"),
+                       TRG_PREFS_KEY_SHOW_NOTEBOOK, TRG_PREFS_GLOBAL,
+                       NULL);
+    g_signal_connect(G_OBJECT(w), "toggled",
+                     G_CALLBACK(notebook_toggled_cb), priv->win);
+    hig_workarea_add_wide_control(t, &row, w);
+
+#ifndef TRG_NO_GRAPH
+    w = trgp_check_new(dlg, _("Show graph"), TRG_PREFS_KEY_SHOW_GRAPH,
+                       TRG_PREFS_GLOBAL, GTK_TOGGLE_BUTTON(w));
+    g_signal_connect(G_OBJECT(w), "toggled", G_CALLBACK(toggle_graph),
+                     priv->win);
+    hig_workarea_add_wide_control(t, &row, w);
+#endif
+
+    hig_workarea_add_section_title(t, &row, _("System Tray"));
+
+    tray = trgp_check_new(dlg, _("Show in system tray"),
+                          TRG_PREFS_KEY_SYSTEM_TRAY, TRG_PREFS_GLOBAL,
+                          NULL);
+    g_signal_connect(G_OBJECT(tray), "toggled",
+                     G_CALLBACK(toggle_tray_icon), priv->win);
+    hig_workarea_add_wide_control(t, &row, tray);
+
+#ifndef HAVE_LIBAPPINDICATOR
+    w = trgp_check_new(dlg, _("Minimise to system tray"),
+                       TRG_PREFS_KEY_SYSTEM_TRAY_MINIMISE,
+                       TRG_PREFS_GLOBAL, NULL);
+    gtk_widget_set_sensitive(w,
+                             gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON
+                                                          (tray)));
+    g_signal_connect(G_OBJECT(tray), "toggled",
+                     G_CALLBACK(toggle_active_arg_is_sensitive), w);
+    hig_workarea_add_wide_control(t, &row, w);
+#endif
+
+#ifdef HAVE_LIBNOTIFY
+    hig_workarea_add_section_title(t, &row, _("Notifications"));
+
+    w = trgp_check_new(dlg, _("Torrent added notifications"),
+                       TRG_PREFS_KEY_ADD_NOTIFY, TRG_PREFS_GLOBAL, NULL);
+    hig_workarea_add_wide_control(t, &row, w);
+
+    w = trgp_check_new(dlg, _("Torrent complete notifications"),
+                       TRG_PREFS_KEY_COMPLETE_NOTIFY, TRG_PREFS_GLOBAL,
+                       NULL);
+    hig_workarea_add_wide_control(t, &row, w);
+#endif
+
+    return t;
+}
+
 static GtkWidget *trg_prefs_serverPage(TrgPreferencesDialog * dlg)
 {
     TrgPreferencesDialogPrivate *priv =
         TRG_PREFERENCES_DIALOG_GET_PRIVATE(dlg);
     TrgPrefs *prefs = priv->prefs;
 
-    GtkWidget *w, *t, *frame, *frameHbox, *profileLabel, *activeOnly;
+    GtkWidget *w, *t, *frame, *frameHbox, *profileLabel;
     GtkWidget *profileButtonsHbox;
     gint row = 0;
 
@@ -776,37 +819,15 @@ static GtkWidget *trg_prefs_serverPage(TrgPreferencesDialog * dlg)
     hig_workarea_add_wide_control(t, &row, w);
 #endif
 
-    hig_workarea_add_section_title(t, &row, _("Updates"));
-
-    activeOnly = w = trgp_check_new(dlg, _("Update active torrents only"),
-                                    TRG_PREFS_KEY_UPDATE_ACTIVE_ONLY,
-                                    TRG_PREFS_PROFILE, NULL);
-    hig_workarea_add_wide_control(t, &row, w);
-
-    priv->fullUpdateCheck = trgp_check_new(dlg,
-                                           _
-                                           ("Full update every (?) updates"),
-                                           TRG_PREFS_ACTIVEONLY_FULLSYNC_ENABLED,
-                                           TRG_PREFS_PROFILE,
-                                           GTK_TOGGLE_BUTTON(activeOnly));
-    w = trgp_spin_new(dlg, TRG_PREFS_ACTIVEONLY_FULLSYNC_EVERY, 2, INT_MAX,
-                      1, TRG_PREFS_PROFILE,
-                      GTK_TOGGLE_BUTTON(priv->fullUpdateCheck));
-    g_signal_connect(activeOnly, "toggled",
-                     G_CALLBACK(trgp_double_special_dependent), w);
-
-    hig_workarea_add_row_w(t, &row, priv->fullUpdateCheck, w, NULL);
-
-    w = trgp_spin_new(dlg, TRG_PREFS_KEY_UPDATE_INTERVAL, 1, INT_MAX, 1,
+    w = trgp_spin_new(dlg, TRG_PREFS_KEY_TIMEOUT, 1, 3600, 1,
                       TRG_PREFS_PROFILE, NULL);
-    hig_workarea_add_row(t, &row, _("Update interval:"), w, NULL);
+    hig_workarea_add_row(t, &row, _("Timeout:"), w, NULL);
 
-    w = trgp_spin_new(dlg, TRG_PREFS_KEY_MINUPDATE_INTERVAL, 1, INT_MAX, 1,
+    w = trgp_spin_new(dlg, TRG_PREFS_KEY_RETRIES, 0, 3600, 1,
                       TRG_PREFS_PROFILE, NULL);
-    hig_workarea_add_row(t, &row, _("Minimised update interval:"), w,
-                         NULL);
+    hig_workarea_add_row(t, &row, _("Retries:"), w, NULL);
 
-    hig_workarea_add_section_divider(t, &row);
+    //hig_workarea_add_section_divider(t, &row);
 
     frame = gtk_frame_new(NULL);
     frameHbox = gtk_hbox_new(FALSE, 2);
@@ -866,6 +887,11 @@ static GObject *trg_preferences_dialog_constructor(GType type,
                              gtk_label_new(_("General")));
 
     gtk_notebook_append_page(GTK_NOTEBOOK(notebook),
+                             trg_prefs_viewPage(TRG_PREFERENCES_DIALOG
+                                                  (object)),
+                             gtk_label_new(_("View")));
+
+    gtk_notebook_append_page(GTK_NOTEBOOK(notebook),
                              trg_prefs_openExecPage(TRG_PREFERENCES_DIALOG
                                                     (object)),
                              gtk_label_new(_("Actions")));
diff --git a/src/trg-prefs.c b/src/trg-prefs.c
index cd7f09e..10aa2cf 100644
--- a/src/trg-prefs.c
+++ b/src/trg-prefs.c
@@ -108,6 +108,8 @@ static void trg_prefs_create_defaults(TrgPrefs * p)
                               TRG_INTERVAL_DEFAULT);
     trg_prefs_add_default_int(p, TRG_PREFS_ACTIVEONLY_FULLSYNC_EVERY, 2);
     trg_prefs_add_default_int(p, TRG_PREFS_KEY_STATES_PANED_POS, 120);
+    trg_prefs_add_default_int(p, TRG_PREFS_KEY_TIMEOUT, 40);
+    trg_prefs_add_default_int(p, TRG_PREFS_KEY_RETRIES, 3);
 
     trg_prefs_add_default_bool_true(p, TRG_PREFS_KEY_FILTER_DIRS);
     trg_prefs_add_default_bool_true(p, TRG_PREFS_KEY_FILTER_TRACKERS);
diff --git a/src/trg-prefs.h b/src/trg-prefs.h
index 1377e95..96b56b5 100644
--- a/src/trg-prefs.h
+++ b/src/trg-prefs.h
@@ -39,6 +39,8 @@
 #define TRG_PREFS_KEY_PASSWORD      "password"
 #define TRG_PREFS_KEY_AUTO_CONNECT  "auto-connect"
 #define TRG_PREFS_KEY_SSL            "ssl"
+#define TRG_PREFS_KEY_TIMEOUT            "timeout"
+#define TRG_PREFS_KEY_RETRIES            "retries"
 #define TRG_PREFS_KEY_UPDATE_INTERVAL "update-interval"
 #define TRG_PREFS_KEY_COMPLETE_NOTIFY "complete-notify"
 #define TRG_PREFS_KEY_ADD_NOTIFY    "add-notify"