Save copies of torrent files from magnet links.

This patch is meant for 1.3-stable (1.3.15 as of the commit date).

The bug is: when you add a new magnet link to download, even if you tick
the option *Copy of .torrent files to:*, deluge still fails to save a
copy of torrent. This patch adds extra code to do so.

AUTHORS

@@ -14,7 +14,7 @@ libtorrent (http://www.libtorrent.org):
 Contributors (and Past Developers):
     * Zach Tibbitts <zach@collegegeek.org>
     * Alon Zakai ('Kripken') <kripkensteiner@gmail.com>
-    * Marcos Pinto ('markybob') <markybob@gmail.com>
+    * Marcos Mobley ('markybob') <markybob@gmail.com>
     * Alex Dedul
     * Sadrul Habib Chowdhury
     * Ido Abramovich <ido.deluge@gmail.com>
@@ -457,7 +457,7 @@ Translation Contributors:
     Marco Rodrigues
     Marcos
     Marcos Escalier
-    Marcos Pinto
+    Marcos Mobley
     Marcus Ekstrom
     Marek Dębowski
     Mário Buči

ChangeLog

@@ -1,3 +1,159 @@
+=== Deluge 1.3.16 (unreleased) ===
+
+==== Core ====
+	* Fix saving copy of torrent file for magnet links.
+
+=== Deluge 1.3.15 (12 May 2017) ===
+
+==== Core ====
+	* #2991: Fix issues with displaying libtorrent single proxy.
+	* #3008: Fix libtorrent 1.2 trackers crashing Deluge UIs.
+	* #2990: Fix error in torrent priorities causing file priority mismatch in UIs.
+
+==== GtkUI ====
+	* #3012: Configure gtkrc to use consistent button ordering on Windows.
+	* Fix column sort state not saved in Thinclient mode.
+	* #2786: Fix connection manager error with malformed ip.
+	* #2866: Rename SystemTray/Indicator 'Pause/Resume All' to 'Pause/Resume Session'.
+	* #2991: Workaround lt single proxy by greying out unused proxy types.
+
+==== WebUI ====
+	* Security Fix: Check render template files exist otherwise raise 404.
+
+==== Notification Plugin ====
+	* #2913: Fix webui passing string for int port value.
+
+==== AutoAdd Plugin ====
+	* Add WebUI preferences page detailing lack of configuration via WebUI.
+
+==== Label Plugin ====
+	* Add WebUI preferences page detailing how to configure plugin.
+
+
+=== Deluge 1.3.14 (6 March 2017) ===
+
+==== Core ====
+	* #2889: Fixed 'Too many files open' errors.
+	* #2861: Added support for python-geoip for use with libtorrent 1.1.
+	* #2149: Fixed a single proxy entry being overwritten resulting in no proxy set.
+
+==== UI ====
+	* Added tracker_status translation to UIs.
+
+==== GtkUI ====
+	* #2901: Strip whitespace from infohash before checks.
+	* Add missed feature autofill infohash entry from clipboard.
+
+==== WebUI ====
+	 * #1908: Backport bind interface option for server.
+	 * Security: Fixed WebUI CSRF Vulnerability.
+
+==== ConsoleUI ====
+	*  [#2948] [Console] Fix decode error comparing non-ascii (str) torrent name.
+
+==== AutoAdd Plugin ====
+	 * Fixes for splitting magnets from file.
+	 * Remove duplicate magnet extension when splitting.
+
+
+=== Deluge 1.3.13 (20 July 2016) ===
+==== Core ====
+	* Increase RSA key size from 1024 to 2048 and use SHA256 digest.
+	* Fixed empty error message from certain trackers.
+	* Fixed torrent ending up displaying the wrong state.
+	* #1032: Force a torrent into Error state if the resume data is rejected.
+	* Workaround unwanted tracker announce when force rechecking paused torrent.
+	* #2703: Stop moving torrent files if target files exist to prevent unintended clobbering of data.
+	* #1330: Fixed the pausing and resuming of the Deluge session so torrents return to previous state.
+	* #2765: Add support for TLS SNI in httpdownloader.
+	* #2790: Ensure base32 magnet hash is uppercase to fix lowercase magnets uris.
+
+==== Daemon ====
+	* New command-line option to restict selected config key to read-only.
+	* Allow use of uppercase log level to match UIs.
+
+==== UI ====
+	* #2832: Fixed error with blank lines in auth file.
+
+==== GtkUI ====
+	* Fixed installing plugin from a non-ascii directory.
+	* Error'd torrents no longer display a progress percentage.
+	* #2753: Fixed the 'Added' column showing the wrong date.
+	* #2435: Prevent the user from changing tracker selection when editing trackers.
+	* Fixed showing the wrong connected status with hostname in the Connection Manager.
+	* #2754: Fixed the progress column to sort by progress and state correctly.
+	* #2696: Fixed incorrect Move Completed folder shown in Options tab.
+	* #2783: Sorting for name column is now case insensitive.
+	* #2795: Reduce height of Add Torrent Dialog to help with smaller screeen resoltuions.
+	* OSX: Fixed empty scrolling status (systray) menu.
+	* OSX: Fixed starting deluged from connection manager.
+	* #2093: Windows OS: Fixed opening non-ascii torrent files.
+	* #2855: Fixed adding UDP trackers to trackers dialog.
+
+==== WebUI ====
+	* #2782: Fixed HTTPS negotiating incorrect cipher.
+	* #2485: Fixed the broken Options context menu.
+	* #2705: Fixed the hostlist config file not being created.
+	* #2293: Fixed plugin's js code not loading when using the WebUI plugin.
+
+==== Console ====
+	* Fixed adding non-ascii torrent in non-interactive mode.
+	* #2796: Add time_added to info sort keys.
+	* #2815: Fixed 'add' cmd path inconsistency on Windows.
+
+==== OSX Packaging ====
+	* Source .py files no longer included in Deluge.app.
+
+==== Windows OS Packaging ====
+	* #2777: Updated MSVC SP1 check to latest release CLID.
+
+==== Blocklist Plugin ====
+	* #2729: Fixed plugin lockup with empty url.
+
+==== Scheduler Plugin ====
+	* Fixed corrupt plugin prefences page on OSX.
+	* Fixed error accidentally introduced in 1.3.12.
+
+==== Notification Plugin ====
+	* #2402: Fixed the popup to show the actual count of files finished.
+	* #2857: Fixed issue with SMTP port entry not updating in GTKUI.
+
+==== AutoAdd Plugin ====
+	* Fixed watch dir not accepting uppercase file extension.
+
+==== Extractor Plugin ====
+	* Ignore the remaining rar part files to prevent spawning useless processes.
+	* #2785: Fixed only an empty folder when extracting rar files.
+
+==== Execute Plugin ====
+	* #2784: Windows OS: Escape ampersand in torrent args.
+
+=== Deluge 1.3.12 (13 September 2015) ===
+==== GtkUI ====
+	* #2731: Fix potential AttributeError in is_on_active_workspace
+
+==== Core ====
+	* Include fix for Twisted 15.0 URI class rename
+	* #2233: Fix AttributeError in set_trackers with lt 1.0
+	* Enable lt extension bindings again for versions >=0.16.7 (this disables Tracker Exchange by default)
+	* Backport atomic fastresume and state file saving fixes as another attempt to prevent data loss on unclean exits
+
+==== WebUI ====
+	* Fixed i18n issue in Connection Manager which left users unable to connect
+	* #2295: Increase cookie lifespan for display settings
+
+==== Console ====
+	* #2333: Fixed 'set and then get' in config command
+
+==== Scheduler Plugin ====
+	* Show current speed limit in statusbar
+
+==== Win32 Packaging ====
+	* #2736: Added version info to the properties of Deluge exes
+	* #2734: Added a 256x256 to deluge.ico
+	* #2325: Fixed the uninstaller deleting non-deluge files
+	* Include pillow module to enable resizing of tracker icons
+
 === Deluge 1.3.11 (30 November 2014) ===
 ==== GtkUI ====
 	* Fixed ImportError for users with Twisted < 10

DEPENDS

@@ -12,6 +12,7 @@
  * geoip-database (optional)
  * setproctitle (optional)
  * pillow (optional)
+ * python-geoip (optional)
 
  * libtorrent (rasterbar) >= 0.14
 

deluge/common.py

@@ -36,6 +36,8 @@
 
 """Common functions for various parts of Deluge to use."""
 
+from __future__ import with_statement
+
 import os
 import time
 import subprocess
@@ -177,10 +179,11 @@ def get_default_download_dir():
     if not windows_check():
         from xdg.BaseDirectory import xdg_config_home
         try:
-            for line in open(os.path.join(xdg_config_home, 'user-dirs.dirs'), 'r'):
-                if not line.startswith('#') and line.startswith('XDG_DOWNLOAD_DIR'):
-                    download_dir = os.path.expandvars(line.partition("=")[2].rstrip().strip('"'))
-                    break
+            with open(os.path.join(xdg_config_home, 'user-dirs.dirs'), 'r') as _file:
+                for line in _file:
+                    if not line.startswith('#') and line.startswith('XDG_DOWNLOAD_DIR'):
+                        download_dir = os.path.expandvars(line.partition("=")[2].rstrip().strip('"'))
+                        break
         except IOError:
             pass
 
@@ -695,7 +698,7 @@ class VersionSplit(object):
     def __init__(self, ver):
         ver = ver.lower()
         vs = ver.replace("_", "-").split("-")
-        self.version = [int(x) for x in vs[0].split(".")]
+        self.version = [int(x) for x in vs[0].split(".") if x.isdigit()]
         self.suffix = None
         self.dev = False
         if len(vs) > 1:
@@ -718,3 +721,27 @@ class VersionSplit(object):
         v1 = [self.version, self.suffix or 'z', self.dev]
         v2 = [ver.version, ver.suffix or 'z', ver.dev]
         return cmp(v1, v2)
+
+def win32_unicode_argv():
+    """ Gets sys.argv as list of unicode objects on any platform."""
+    if windows_check():
+        # Versions 2.x of Python don't support Unicode in sys.argv on Windows, with the
+        # underlying Windows API instead replacing multi-byte characters with '?'.
+        from ctypes import POINTER, byref, cdll, c_int, windll
+        from ctypes.wintypes import LPCWSTR, LPWSTR
+
+        get_cmd_linew = cdll.kernel32.GetCommandLineW
+        get_cmd_linew.argtypes = []
+        get_cmd_linew.restype = LPCWSTR
+
+        cmdline_to_argvw = windll.shell32.CommandLineToArgvW
+        cmdline_to_argvw.argtypes = [LPCWSTR, POINTER(c_int)]
+        cmdline_to_argvw.restype = POINTER(LPWSTR)
+
+        cmd = get_cmd_linew()
+        argc = c_int(0)
+        argv = cmdline_to_argvw(cmd, byref(argc))
+        if argc.value > 0:
+            # Remove Python executable and commands if present
+            start = argc.value - len(sys.argv)
+            return [argv[i] for i in xrange(start, argc.value)]

deluge/config.py

@@ -67,6 +67,8 @@ version as this will be done internally.
 
 """
 
+from __future__ import with_statement
+
 import cPickle as pickle
 import shutil
 import os
@@ -109,8 +111,13 @@ def find_json_objects(s):
     if start < 0:
         return []
 
+    quoted = False
     for index, c in enumerate(s[offset:]):
-        if c == "{":
+        if c == '"':
+            quoted = not quoted
+        elif quoted:
+            continue
+        elif c == "{":
             opens += 1
         elif c == "}":
             opens -= 1
@@ -356,7 +363,8 @@ what is currently in the config and it could not convert the value
             filename = self.__config_file
 
         try:
-            data = open(filename, "rb").read()
+            with open(filename, "rb") as _file:
+                data = _file.read()
         except IOError, e:
             log.warning("Unable to open config file %s: %s", filename, e)
             return
@@ -404,7 +412,8 @@ what is currently in the config and it could not convert the value
         # Check to see if the current config differs from the one on disk
         # We will only write a new config file if there is a difference
         try:
-            data = open(filename, "rb").read()
+            with open(filename, "rb") as _file:
+                data = _file.read()
             objects = find_json_objects(data)
             start, end = objects[0]
             version = json.loads(data[start:end])

deluge/core/alertmanager.py

@@ -74,7 +74,8 @@ class AlertManager(component.Component):
 
     def stop(self):
         for dc in self.delayed_calls:
-            dc.cancel()
+            if dc.active():
+                dc.cancel()
         self.delayed_calls = []
 
     def register_handler(self, alert_type, handler):

deluge/core/authmanager.py

@@ -33,6 +33,8 @@
 #
 #
 
+from __future__ import with_statement
+
 import os
 import random
 import stat
@@ -118,7 +120,8 @@ class AuthManager(component.Component):
             f = [localclient]
         else:
             # Load the auth file into a dictionary: {username: password, ...}
-            f = open(auth_file, "r").readlines()
+            with open(auth_file, "r") as _file:
+                f = _file.readlines()
 
         for line in f:
             line = line.strip()
@@ -143,4 +146,5 @@ class AuthManager(component.Component):
             self.__auth[username.strip()] = (password.strip(), level)
 
         if "localclient" not in self.__auth:
-            open(auth_file, "a").write(self.__create_localclient_account())
+            with open(auth_file, "a") as _file:
+                _file.write(self.__create_localclient_account())

deluge/core/core.py

@@ -33,6 +33,8 @@
 #
 #
 
+from __future__ import with_statement
+
 from deluge._libtorrent import lt
 
 import os
@@ -72,22 +74,30 @@ from deluge.core.eventmanager import EventManager
 from deluge.core.rpcserver import export
 
 class Core(component.Component):
-    def __init__(self, listen_interface=None):
+    def __init__(self, listen_interface=None, read_only_config_keys=None):
         log.debug("Core init..")
         component.Component.__init__(self, "Core")
 
+        # These keys will be dropped from the set_config() RPC and are
+        # configurable from the command-line.
+        self.read_only_config_keys = read_only_config_keys
+        log.debug("read_only_config_keys: %s", read_only_config_keys)
+
         # Start the libtorrent session
         log.info("Starting libtorrent %s session..", lt.version)
 
         # Create the client fingerprint
-        version = [int(value.split("-")[0]) for value in deluge.common.get_version().split(".")]
+        version = deluge.common.VersionSplit(deluge.common.get_version()).version
         while len(version) < 4:
             version.append(0)
 
-        # Note: All libtorrent python bindings to set plugins/extensions need to be disabled
-        # due to  GIL issue. https://code.google.com/p/libtorrent/issues/detail?id=369
-        # Setting session flags to 1 enables all libtorrent default plugins
-        self.session = lt.session(lt.fingerprint("DE", *version), flags=1)
+        # In libtorrent versions below 0.16.7.0 disable extension bindings due to GIL issue.
+        # https://code.google.com/p/libtorrent/issues/detail?id=369
+        if deluge.common.VersionSplit(lt.version) >= deluge.common.VersionSplit("0.16.7.0"):
+            self.session = lt.session(lt.fingerprint("DE", *version), flags=0)
+        else:
+            # Setting session flags to 1 enables all libtorrent default plugins
+            self.session = lt.session(lt.fingerprint("DE", *version), flags=1)
 
         # Load the session state if available
         self.__load_session_state()
@@ -97,6 +107,8 @@ class Core(component.Component):
         self.settings.user_agent = "Deluge %s" % deluge.common.get_version()
         # Increase the alert queue size so that alerts don't get lost
         self.settings.alert_queue_size = 10000
+        # Ignore buggy resume data timestamps checking #3044.
+        self.settings.ignore_resume_timestamps = True
 
         # Set session settings
         self.settings.send_redundant_have = True
@@ -108,11 +120,12 @@ class Core(component.Component):
         self.session.set_settings(self.settings)
 
         # Load metadata extension
-        # Note: All libtorrent python bindings to set plugins/extensions need to be disabled
-        # due to  GIL issue. https://code.google.com/p/libtorrent/issues/detail?id=369
-        # self.session.add_extension(lt.create_metadata_plugin)
-        # self.session.add_extension(lt.create_ut_metadata_plugin)
-        # self.session.add_extension(lt.create_smart_ban_plugin)
+        # In libtorrent versions below 0.16.7.0 disable extension bindings due to GIL issue.
+        # https://code.google.com/p/libtorrent/issues/detail?id=369
+        if deluge.common.VersionSplit(lt.version) >= deluge.common.VersionSplit("0.16.7.0"):
+            self.session.add_extension("metadata_transfer")
+            self.session.add_extension("ut_metadata")
+            self.session.add_extension("smart_ban")
 
         # Create the components
         self.eventmanager = EventManager()
@@ -127,6 +140,9 @@ class Core(component.Component):
         # New release check information
         self.new_release = None
 
+        # GeoIP instance with db loaded
+        self.geoip_instance = None
+
         # Get the core config
         self.config = deluge.configmanager.ConfigManager("core.conf")
 
@@ -177,8 +193,8 @@ class Core(component.Component):
     def __load_session_state(self):
         """Loads the libtorrent session state"""
         try:
-            self.session.load_state(lt.bdecode(
-                open(deluge.configmanager.get_config_dir("session.state"), "rb").read()))
+            with open(deluge.configmanager.get_config_dir("session.state"), "rb") as _file:
+                self.session.load_state(lt.bdecode(_file.read()))
         except Exception, e:
             log.warning("Failed to load lt state: %s", e)
 
@@ -405,15 +421,18 @@ class Core(component.Component):
     @export
     def pause_all_torrents(self):
         """Pause all torrents in the session"""
-        for torrent in self.torrentmanager.torrents.values():
-            torrent.pause()
+        if not self.session.is_paused():
+            self.session.pause()
+            component.get("EventManager").emit(SessionPausedEvent())
 
     @export
     def resume_all_torrents(self):
         """Resume all torrents in the session"""
-        for torrent in self.torrentmanager.torrents.values():
-            torrent.resume()
-        component.get("EventManager").emit(SessionResumedEvent())
+        if self.session.is_paused():
+            self.session.resume()
+            for torrent_id in self.torrentmanager.torrents:
+                self.torrentmanager[torrent_id].update_state()
+            component.get("EventManager").emit(SessionResumedEvent())
 
     @export
     def resume_torrent(self, torrent_ids):
@@ -430,9 +449,9 @@ class Core(component.Component):
             # Torrent was probaly removed meanwhile
             return {}
 
-        # Get the leftover fields and ask the plugin manager to fill them
+        # Get any remaining keys from plugin manager or 'all' if no keys specified.
         leftover_fields = list(set(keys) - set(status.keys()))
-        if len(leftover_fields) > 0:
+        if len(leftover_fields) > 0 or len(keys) == 0:
             status.update(self.pluginmanager.get_status(torrent_id, leftover_fields))
         return status
 
@@ -495,6 +514,8 @@ class Core(component.Component):
         """Set the config with values from dictionary"""
         # Load all the values into the configuration
         for key in config.keys():
+            if self.read_only_config_keys and key in self.read_only_config_keys:
+                continue
             if isinstance(config[key], unicode) or isinstance(config[key], str):
                 config[key] = config[key].encode("utf8")
             self.config[key] = config[key]
@@ -647,7 +668,9 @@ class Core(component.Component):
         if add_to_session:
             options = {}
             options["download_location"] = os.path.split(path)[0]
-            self.add_torrent_file(os.path.split(target)[1], open(target, "rb").read(), options)
+            with open(target, "rb") as _file:
+                filedump = base64.encodestring(_file.read())
+                self.add_torrent_file(os.path.split(target)[1], filedump, options)
 
     @export
     def upload_plugin(self, filename, filedump):

deluge/core/daemon.py

@@ -32,6 +32,8 @@
 #    statement from all source files in the program, then also delete it here.
 #
 
+from __future__ import with_statement
+
 import os
 import gettext
 import locale
@@ -52,7 +54,8 @@ class Daemon(object):
         if os.path.isfile(deluge.configmanager.get_config_dir("deluged.pid")):
             # Get the PID and the port of the supposedly running daemon
             try:
-                (pid, port) = open(deluge.configmanager.get_config_dir("deluged.pid")).read().strip().split(";")
+                with open(deluge.configmanager.get_config_dir("deluged.pid")) as _file:
+                    (pid, port) = _file.read().strip().split(";")
                 pid = int(pid)
                 port = int(port)
             except ValueError:
@@ -133,9 +136,15 @@ class Daemon(object):
         else:
             listen_interface = ""
 
+        if options and options.read_only_config_keys:
+            read_only_config_keys = options.read_only_config_keys.split(",")
+        else:
+            read_only_config_keys = []
+
         from deluge.core.core import Core
         # Start the core as a thread and join it until it's done
-        self.core = Core(listen_interface=listen_interface)
+        self.core = Core(listen_interface=listen_interface,
+                         read_only_config_keys=read_only_config_keys)
 
         port = self.core.config["daemon_port"]
         if options and options.port:
@@ -163,8 +172,8 @@ class Daemon(object):
         if not classic:
             # Write out a pid file all the time, we use this to see if a deluged is running
             # We also include the running port number to do an additional test
-            open(deluge.configmanager.get_config_dir("deluged.pid"), "wb").write(
-                "%s;%s\n" % (os.getpid(), port))
+            with open(deluge.configmanager.get_config_dir("deluged.pid"), "wb") as _file:
+                _file.write("%s;%s\n" % (os.getpid(), port))
 
             component.start()
             try:

deluge/core/filtermanager.py

@@ -91,7 +91,7 @@ def tracker_error_filter(torrent_ids, values):
     # Check all the torrent's tracker_status for 'Error:' and only return torrent_ids
     # that have this substring in their tracker_status
     for torrent_id in torrent_ids:
-        if _("Error") + ":" in tm[torrent_id].get_status(["tracker_status"])["tracker_status"]:
+        if "Error:" in tm[torrent_id].get_status(["tracker_status"])["tracker_status"]:
             filtered_torrent_ids.append(torrent_id)
 
     return filtered_torrent_ids
@@ -169,7 +169,9 @@ class FilterManager(component.Component):
         for torrent_id in list(torrent_ids):
             status = status_func(torrent_id, filter_dict.keys()) #status={key:value}
             for field, values in filter_dict.iteritems():
-                if (not status[field] in values) and torrent_id in torrent_ids:
+                if field in status and status[field] in values:
+                    continue
+                elif torrent_id in torrent_ids:
                     torrent_ids.remove(torrent_id)
 
         return torrent_ids

deluge/core/pluginmanager.py

@@ -92,6 +92,8 @@ class PluginManager(deluge.pluginmanagerbase.PluginManagerBase,
     def get_status(self, torrent_id, fields):
         """Return the value of status fields for the selected torrent_id."""
         status = {}
+        if len(fields) == 0:
+            fields = self.status_fields.keys()
         for field in fields:
             try:
                 status[field] = self.status_fields[field](torrent_id)

deluge/core/preferencesmanager.py

@@ -33,6 +33,7 @@
 #
 #
 
+from __future__ import with_statement
 
 import os.path
 import threading
@@ -48,6 +49,12 @@ import deluge.common
 import deluge.component as component
 from deluge.log import LOG as log
 
+try:
+    import GeoIP
+except ImportError:
+    GeoIP = None
+
+
 DEFAULT_PREFS = {
     "send_info": False,
     "info_sent": 0.0,
@@ -144,6 +151,8 @@ DEFAULT_PREFS = {
 }
 
 class PreferencesManager(component.Component):
+    LT_SINGLE_PROXY = deluge.common.VersionSplit(lt.version) >= deluge.common.VersionSplit("0.16.0.0")
+
     def __init__(self):
         component.Component.__init__(self, "PreferencesManager")
 
@@ -298,7 +307,8 @@ class PreferencesManager(component.Component):
         if value:
             state = None
             try:
-                state = lt.bdecode(open(state_file, "rb").read())
+                with open(state_file, "rb") as _file:
+                    state = lt.bdecode(_file.read())
             except Exception, e:
                 log.warning("Unable to read DHT state file: %s", e)
 
@@ -309,6 +319,8 @@ class PreferencesManager(component.Component):
                 self.session.start_dht(None)
             self.session.add_dht_router("router.bittorrent.com", 6881)
             self.session.add_dht_router("router.utorrent.com", 6881)
+            self.session.add_dht_router("dht.transmissionbt.com", 6881)
+            self.session.add_dht_router("dht.aelitis.com", 6881)
             self.session.add_dht_router("router.bitcomet.com", 6881)
         else:
             self.core.save_dht_state()
@@ -337,11 +349,10 @@ class PreferencesManager(component.Component):
 
     def _on_set_utpex(self, key, value):
         log.debug("utpex value set to %s", value)
-        if value:
-            # Note: All libtorrent python bindings to set plugins/extensions need to be disabled
-            # due to  GIL issue. https://code.google.com/p/libtorrent/issues/detail?id=369
-            #self.session.add_extension(lt.create_ut_pex_plugin)
-            pass
+        # In libtorrent versions below 0.16.7.0 disable extension bindings due to GIL issue.
+        # https://code.google.com/p/libtorrent/issues/detail?id=369
+        if value and deluge.common.VersionSplit(lt.version) >= deluge.common.VersionSplit("0.16.7.0"):
+            self.session.add_extension("ut_pex")
 
     def _on_set_encryption(self, key, value):
         log.debug("encryption value %s set to %s..", key, value)
@@ -471,15 +482,34 @@ class PreferencesManager(component.Component):
                 self.new_release_timer.stop()
 
     def _on_set_proxies(self, key, value):
-        for k, v in value.items():
+        # Test for single proxy with lt >= 0.16
+        if self.LT_SINGLE_PROXY:
+            for proxy_type in value:
+                if proxy_type == "peer":
+                    continue
+                if self.config["proxies"][proxy_type] != value["peer"]:
+                    log.warning("This version of libtorrent only supports a single proxy setting "
+                                "based upon 'peer' which will apply to all other other types.")
+                    self.config["proxies"][proxy_type] = value["peer"]
+
             proxy_settings = lt.proxy_settings()
-            proxy_settings.type = lt.proxy_type(v["type"])
-            proxy_settings.username = str(v["username"])
-            proxy_settings.password = str(v["password"])
-            proxy_settings.hostname = str(v["hostname"])
-            proxy_settings.port = v["port"]
-            log.debug("setting %s proxy settings", k)
-            getattr(self.session, "set_%s_proxy" % k)(proxy_settings)
+            proxy_settings.type = lt.proxy_type(value["peer"]["type"])
+            proxy_settings.username = str(value["peer"]["username"])
+            proxy_settings.password = str(value["peer"]["password"])
+            proxy_settings.hostname = str(value["peer"]["hostname"])
+            proxy_settings.port = value["peer"]["port"]
+            log.debug("Setting proxy settings: %s", value["peer"])
+            self.session.set_proxy(proxy_settings)
+        else:
+            for k, v in value.items():
+                proxy_settings = lt.proxy_settings()
+                proxy_settings.type = lt.proxy_type(v["type"])
+                proxy_settings.username = str(v["username"])
+                proxy_settings.password = str(v["password"])
+                proxy_settings.hostname = str(v["hostname"])
+                proxy_settings.port = v["port"]
+                log.debug("Setting %s proxy settings: %s", k, v)
+                getattr(self.session, "set_%s_proxy" % k)(proxy_settings)
 
     def _on_rate_limit_ip_overhead(self, key, value):
         log.debug("%s: %s", key, value)
@@ -488,21 +518,19 @@ class PreferencesManager(component.Component):
     def _on_geoip_db_location(self, key, value):
         log.debug("%s: %s", key, value)
         # Load the GeoIP DB for country look-ups if available
-        geoip_db = ""
         if os.path.exists(value):
-            geoip_db = value
-        elif os.path.exists(pkg_resources.resource_filename("deluge", os.path.join("data", "GeoIP.dat"))):
-            geoip_db = pkg_resources.resource_filename("deluge", os.path.join("data", "GeoIP.dat"))
+            try:
+                self.core.geoip_instance = GeoIP.open(value, GeoIP.GEOIP_STANDARD)
+            except AttributeError:
+                try:
+                    self.session.load_country_db(value)
+                except RuntimeError, ex:
+                    log.error("Unable to load geoip database: %s", ex)
+                except AttributeError:
+                    log.warning("GeoIP Unavailable")
         else:
             log.warning("Unable to find GeoIP database file!")
 
-        if geoip_db:
-            try:
-                self.session.load_country_db(str(geoip_db))
-            except Exception, e:
-                log.error("Unable to load geoip database!")
-                log.exception(e)
-
     def _on_cache_size(self, key, value):
         log.debug("%s: %s", key, value)
         self.session_set_setting("cache_size", value)

deluge/core/rpcserver.py

@@ -35,6 +35,8 @@
 
 """RPCServer Module"""
 
+from __future__ import with_statement
+
 import sys
 import zlib
 import os
@@ -202,8 +204,8 @@ class DelugeRPCProtocol(Protocol):
         """
         peer = self.transport.getPeer()
         log.info("Deluge Client connection made from: %s:%s", peer.host, peer.port)
-        # Set the initial auth level of this session to AUTH_LEVEL_NONE
-        self.factory.authorized_sessions[self.transport.sessionno] = AUTH_LEVEL_NONE
+        # Set the initial auth level of this session to AUTH_LEVEL_NONE and empty username.
+        self.factory.authorized_sessions[self.transport.sessionno] = (AUTH_LEVEL_NONE, "")
 
     def connectionLost(self, reason):
         """
@@ -493,10 +495,10 @@ def generate_ssl_keys():
     """
     This method generates a new SSL key/cert.
     """
-    digest = "md5"
+    digest = "sha256"
     # Generate key pair
     pkey = crypto.PKey()
-    pkey.generate_key(crypto.TYPE_RSA, 1024)
+    pkey.generate_key(crypto.TYPE_RSA, 2048)
 
     # Generate cert request
     req = crypto.X509Req()
@@ -509,7 +511,7 @@ def generate_ssl_keys():
     cert = crypto.X509()
     cert.set_serial_number(0)
     cert.gmtime_adj_notBefore(0)
-    cert.gmtime_adj_notAfter(60*60*24*365*5) # Five Years
+    cert.gmtime_adj_notAfter(60 * 60 * 24 * 365 * 3)  # Three Years
     cert.set_issuer(req.get_subject())
     cert.set_subject(req.get_subject())
     cert.set_pubkey(req.get_pubkey())
@@ -517,8 +519,10 @@ def generate_ssl_keys():
 
     # Write out files
     ssl_dir = deluge.configmanager.get_config_dir("ssl")
-    open(os.path.join(ssl_dir, "daemon.pkey"), "w").write(crypto.dump_privatekey(crypto.FILETYPE_PEM, pkey))
-    open(os.path.join(ssl_dir, "daemon.cert"), "w").write(crypto.dump_certificate(crypto.FILETYPE_PEM, cert))
+    with open(os.path.join(ssl_dir, "daemon.pkey"), "w") as _file:
+        _file.write(crypto.dump_privatekey(crypto.FILETYPE_PEM, pkey))
+    with open(os.path.join(ssl_dir, "daemon.cert"), "w") as _file:
+        _file.write(crypto.dump_certificate(crypto.FILETYPE_PEM, cert))
     # Make the files only readable by this user
     for f in ("daemon.pkey", "daemon.cert"):
         os.chmod(os.path.join(ssl_dir, f), stat.S_IREAD | stat.S_IWRITE)

deluge/core/torrent.py

@@ -34,6 +34,8 @@
 
 """Internal Torrent class"""
 
+from __future__ import with_statement
+
 import os
 import time
 from urllib import unquote
@@ -98,6 +100,14 @@ class TorrentOptions(dict):
         self["file_priorities"] = []
         self["mapped_files"] = {}
 
+
+class TorrentError(object):
+    def __init__(self, error_message, was_paused=False, restart_to_resume=False):
+        self.error_message = error_message
+        self.was_paused = was_paused
+        self.restart_to_resume = restart_to_resume
+
+
 class Torrent(object):
     """Torrent holds information about torrents added to the libtorrent session.
     """
@@ -134,13 +144,16 @@ class Torrent(object):
         # We store the filename just in case we need to make a copy of the torrentfile
         if not filename:
             # If no filename was provided, then just use the infohash
-            filename = self.torrent_id
+            filename = self.torrent_id + '.torrent'
 
         self.filename = filename
 
         # Store the magnet uri used to add this torrent if available
         self.magnet = magnet
 
+        # Torrent state e.g. Paused, Downloading, etc.
+        self.state = None
+
         # Holds status info so that we don't need to keep getting it from lt
         self.status = self.handle.status()
 
@@ -170,26 +183,20 @@ class Torrent(object):
             self.filename = state.filename
             self.is_finished = state.is_finished
         else:
-            # Tracker list
-            self.trackers = []
-            # Create a list of trackers
-            for value in self.handle.trackers():
-                if lt.version_major == 0 and lt.version_minor < 15:
-                    tracker = {}
-                    tracker["url"] = value.url
-                    tracker["tier"] = value.tier
-                else:
-                    tracker = value
-                self.trackers.append(tracker)
+            # Set trackers from libtorrent
+            self.set_trackers(None)
 
         # Various torrent options
         self.handle.resolve_countries(True)
 
-        self.set_options(self.options)
+        # Details of torrent forced into error state (i.e. not by libtorrent).
+        self.forced_error = None
 
         # Status message holds error info about the torrent
         self.statusmsg = "OK"
 
+        self.set_options(self.options)
+
         # The torrents state
         self.update_state()
 
@@ -209,8 +216,6 @@ class Torrent(object):
         self.forcing_recheck = False
         self.forcing_recheck_paused = False
 
-        log.debug("Torrent object created.")
-
     ## Options methods ##
     def set_options(self, options):
         OPTIONS_FUNCS = {
@@ -235,6 +240,10 @@ class Torrent(object):
 
 
     def set_max_connections(self, max_connections):
+        if max_connections == 0:
+            max_connections = -1
+        elif max_connections == 1:
+            max_connections = 2
         self.options["max_connections"] = int(max_connections)
         self.handle.set_max_connections(max_connections)
 
@@ -292,19 +301,19 @@ class Torrent(object):
         self.options["move_completed_path"] = move_completed_path
 
     def set_file_priorities(self, file_priorities):
-        if len(file_priorities) != len(self.get_files()):
-            log.debug("file_priorities len != num_files")
-            self.options["file_priorities"] = self.handle.file_priorities()
-            return
-
-        if self.options["compact_allocation"]:
-            log.debug("setting file priority with compact allocation does not work!")
-            self.options["file_priorities"] = self.handle.file_priorities()
-            return
+        handle_file_priorities = self.handle.file_priorities()
+        # Workaround for libtorrent 1.1 changing default priorities from 1 to 4.
+        if 4 in handle_file_priorities:
+           handle_file_priorities = [1 if x == 4 else x for x in handle_file_priorities]
 
         log.debug("setting %s's file priorities: %s", self.torrent_id, file_priorities)
 
-        self.handle.prioritize_files(file_priorities)
+        if (self.handle.has_metadata() and not self.options["compact_allocation"] and
+                file_priorities and len(file_priorities) == len(self.get_files())):
+            self.handle.prioritize_files(file_priorities)
+        else:
+            log.debug("Unable to set new file priorities.")
+            file_priorities = handle_file_priorities
 
         if 0 in self.options["file_priorities"]:
             # We have previously marked a file 'Do Not Download'
@@ -323,14 +332,19 @@ class Torrent(object):
         # Set the first/last priorities if needed
         self.set_prioritize_first_last(self.options["prioritize_first_last_pieces"])
 
-    def set_trackers(self, trackers):
+    def set_trackers(self, trackers, reannounce=True):
         """Sets trackers"""
         if trackers == None:
             trackers = []
             for value in self.handle.trackers():
-                tracker = {}
-                tracker["url"] = value.url
-                tracker["tier"] = value.tier
+                if lt.version_major == 0 and lt.version_minor < 15:
+                    tracker = {}
+                    tracker["url"] = value.url
+                    tracker["tier"] = value.tier
+                else:
+                    tracker = value
+                    # These unused lt 1.1.2 tracker datetime entries need to be None for rencode.
+                    tracker["min_announce"] = tracker["next_announce"] = None
                 trackers.append(tracker)
             self.trackers = trackers
             self.tracker_host = None
@@ -339,10 +353,13 @@ class Torrent(object):
         log.debug("Setting trackers for %s: %s", self.torrent_id, trackers)
         tracker_list = []
 
-        for tracker in trackers:
+        for idx, tracker in enumerate(trackers):
             new_entry = lt.announce_entry(tracker["url"])
             new_entry.tier = tracker["tier"]
             tracker_list.append(new_entry)
+            # These unused lt 1.1.2 tracker datetime entries need to be None for rencode.
+            trackers[idx]["min_announce"] = trackers[idx]["next_announce"] = None
+
         self.handle.replace_trackers(tracker_list)
 
         # Print out the trackers
@@ -350,7 +367,7 @@ class Torrent(object):
         #    log.debug("tier: %s tracker: %s", t["tier"], t["url"])
         # Set the tracker list in the torrent object
         self.trackers = trackers
-        if len(trackers) > 0:
+        if len(trackers) > 0 and reannounce:
             # Force a reannounce if there is at least 1 tracker
             self.force_reannounce()
 
@@ -363,51 +380,56 @@ class Torrent(object):
 
     def set_tracker_status(self, status):
         """Sets the tracker status"""
+        self.tracker_host = None
         self.tracker_status = self.get_tracker_host() + ": " + status
 
     def update_state(self):
         """Updates the state based on what libtorrent's state for the torrent is"""
         # Set the initial state based on the lt state
         LTSTATE = deluge.common.LT_TORRENT_STATE
-        ltstate = int(self.handle.status().state)
+        status = self.handle.status()
+        ltstate = status.state
 
-        # Set self.state to the ltstate right away just incase we don't hit some
-        # of the logic below
-        if ltstate in LTSTATE:
-            self.state = LTSTATE[ltstate]
-        else:
-            self.state = str(ltstate)
+        # Set self.state to the ltstate right away just incase we don't hit some of the logic below
+        old_state = self.state
+        self.state = LTSTATE.get(int(ltstate), str(ltstate))
 
-        log.debug("set_state_based_on_ltstate: %s", deluge.common.LT_TORRENT_STATE[ltstate])
-        log.debug("session.is_paused: %s", component.get("Core").session.is_paused())
+        is_paused = self.handle.is_paused()
+        is_auto_managed = self.handle.is_auto_managed()
+        session_paused = component.get("Core").session.is_paused()
 
         # First we check for an error from libtorrent, and set the state to that
         # if any occurred.
-        if len(self.handle.status().error) > 0:
+        if self.forced_error:
+            self.state = "Error"
+            self.set_status_message("Error: " + self.forced_error.error_message)
+        elif status.error:
             # This is an error'd torrent
             self.state = "Error"
-            self.set_status_message(self.handle.status().error)
-            if self.handle.is_paused():
+            self.set_status_message(status.error)
+            if is_paused:
                 self.handle.auto_managed(False)
-            return
-
-        if ltstate == LTSTATE["Queued"] or ltstate == LTSTATE["Checking"]:
-            if self.handle.is_paused():
+        else:
+            if is_paused and is_auto_managed and not session_paused:
+                self.state = "Queued"
+            elif is_paused or session_paused:
                 self.state = "Paused"
-            else:
+            elif ltstate == LTSTATE["Queued"] or ltstate == LTSTATE["Checking"] or \
+                    ltstate == LTSTATE["Checking Resume Data"]:
                 self.state = "Checking"
-            return
-        elif ltstate == LTSTATE["Downloading"] or ltstate == LTSTATE["Downloading Metadata"]:
-            self.state = "Downloading"
-        elif ltstate == LTSTATE["Finished"] or ltstate == LTSTATE["Seeding"]:
-            self.state = "Seeding"
-        elif ltstate == LTSTATE["Allocating"]:
-            self.state = "Allocating"
+            elif ltstate == LTSTATE["Downloading"] or ltstate == LTSTATE["Downloading Metadata"]:
+                self.state = "Downloading"
+            elif ltstate == LTSTATE["Finished"] or ltstate == LTSTATE["Seeding"]:
+                self.state = "Seeding"
+            elif ltstate == LTSTATE["Allocating"]:
+                self.state = "Allocating"
 
-        if self.handle.is_paused() and self.handle.is_auto_managed() and not component.get("Core").session.is_paused():
-            self.state = "Queued"
-        elif component.get("Core").session.is_paused() or (self.handle.is_paused() and not self.handle.is_auto_managed()):
-            self.state = "Paused"
+        if self.state != old_state:
+            log.debug("Using torrent state from lt: %s, auto_managed: %s, paused: %s, session_paused: %s",
+                      ltstate, is_auto_managed, is_paused, session_paused)
+            log.debug("Torrent %s set from %s to %s: '%s'",
+                      self.torrent_id, old_state, self.state, self.statusmsg)
+            component.get("EventManager").emit(TorrentStateChangedEvent(self.torrent_id, self.state))
 
     def set_state(self, state):
         """Accepts state strings, ie, "Paused", "Seeding", etc."""
@@ -421,6 +443,37 @@ class Torrent(object):
     def set_status_message(self, message):
         self.statusmsg = message
 
+    def force_error_state(self, message, restart_to_resume=True):
+        """Forces the torrent into an error state.
+
+        For setting an error state not covered by libtorrent.
+
+        Args:
+            message (str): The error status message.
+            restart_to_resume (bool, optional): Prevent resuming clearing the error, only restarting
+                session can resume.
+        """
+        status = self.handle.status()
+        self.handle.auto_managed(False)
+        self.forced_error = TorrentError(message, status.paused, restart_to_resume)
+        if not status.paused:
+            self.handle.pause()
+        self.update_state()
+
+    def clear_forced_error_state(self, update_state=True):
+        if not self.forced_error:
+            return
+
+        if self.forced_error.restart_to_resume:
+            log.error("Restart deluge to clear this torrent error")
+
+        if not self.forced_error.was_paused and self.options["auto_managed"]:
+            self.handle.auto_managed(True)
+        self.forced_error = None
+        self.set_status_message("OK")
+        if update_state:
+            self.update_state()
+
     def get_eta(self):
         """Returns the ETA in seconds for this torrent"""
         if self.status == None:
@@ -499,13 +552,15 @@ class Torrent(object):
             except UnicodeDecodeError:
                 client = str(peer.client).decode("latin-1")
 
-            # Make country a proper string
-            country = str()
-            for c in peer.country:
-                if not c.isalpha():
-                    country += " "
-                else:
-                    country += c
+            try:
+                country = component.get("Core").geoip_instance.country_code_by_addr(peer.ip[0])
+            except AttributeError:
+                country = peer.country
+
+            try:
+                country = "".join([char if char.isalpha() else " " for char in country])
+            except TypeError:
+                country = ""
 
             ret.append({
                 "client": client,
@@ -523,10 +578,21 @@ class Torrent(object):
         """Returns the torrents queue position"""
         return self.handle.queue_position()
 
+    def get_file_priorities(self):
+        """Return the file priorities"""
+        if not self.handle.has_metadata():
+            return []
+
+        if not self.options["file_priorities"]:
+            # Ensure file_priorities option is populated.
+            self.set_file_priorities([])
+
+        return self.options["file_priorities"]
+
     def get_file_progress(self):
         """Returns the file progress as a list of floats.. 0.0 -> 1.0"""
         if not self.handle.has_metadata():
-            return 0.0
+            return []
 
         file_progress = self.handle.file_progress()
         ret = []
@@ -535,6 +601,8 @@ class Torrent(object):
                 ret.append(float(file_progress[i]) / float(f["size"]))
             except ZeroDivisionError:
                 ret.append(0.0)
+            except IndexError:
+                return []
 
         return ret
 
@@ -617,7 +685,6 @@ class Torrent(object):
             "compact": self.options["compact_allocation"],
             "distributed_copies": distributed_copies,
             "download_payload_rate": self.status.download_payload_rate,
-            "file_priorities": self.options["file_priorities"],
             "hash": self.torrent_id,
             "is_auto_managed": self.options["auto_managed"],
             "is_finished": self.is_finished,
@@ -716,6 +783,7 @@ class Torrent(object):
         fns = {
             "comment": ti_comment,
             "eta": self.get_eta,
+            "file_priorities": self.get_file_priorities,
             "file_progress": self.get_file_progress,
             "files": self.get_files,
             "is_seed": self.handle.is_seed,
@@ -776,6 +844,8 @@ class Torrent(object):
 
     def pause(self):
         """Pause this torrent"""
+        if self.state == "Error":
+            return False
         # Turn off auto-management so the torrent will not be unpaused by lt queueing
         self.handle.auto_managed(False)
         if self.handle.is_paused():
@@ -799,7 +869,8 @@ class Torrent(object):
 
         if self.handle.is_paused() and self.handle.is_auto_managed():
             log.debug("Torrent is being auto-managed, cannot resume!")
-            return
+        elif self.forced_error and self.forced_error.was_paused:
+            log.debug("Skip resuming Error state torrent that was originally paused.")
         else:
             # Reset the status message just in case of resuming an Error'd torrent
             self.set_status_message("OK")
@@ -823,6 +894,11 @@ class Torrent(object):
 
             return True
 
+        if self.forced_error and not self.forced_error.restart_to_resume:
+            self.clear_forced_error_state()
+        elif self.state == "Error" and not self.forced_error:
+            self.handle.clear_error()
+
     def connect_peer(self, ip, port):
         """adds manual peer"""
         try:
@@ -835,27 +911,31 @@ class Torrent(object):
     def move_storage(self, dest):
         """Move a torrent's storage location"""
         try:
-           dest = unicode(dest, "utf-8")
+            dest = unicode(dest, "utf-8")
         except TypeError:
-           # String is already unicode
-           pass
+            # String is already unicode
+            pass
 
         if not os.path.exists(dest):
             try:
                 # Try to make the destination path if it doesn't exist
                 os.makedirs(dest)
-            except IOError, e:
-                log.exception(e)
-                log.error("Could not move storage for torrent %s since %s does not exist and could not create the directory.", self.torrent_id, dest_u)
+            except OSError, ex:
+                log.error("Could not move storage for torrent %s since %s does "
+                          "not exist and could not create the directory: %s",
+                          self.torrent_id, dest, ex)
                 return False
 
+        kwargs = {}
+        if deluge.common.VersionSplit(lt.version) >= deluge.common.VersionSplit("1.0.0.0"):
+            kwargs['flags'] = 2  # dont_replace
         dest_bytes = dest.encode('utf-8')
         try:
             # libtorrent needs unicode object if wstrings are enabled, utf8 bytestring otherwise
             try:
-                self.handle.move_storage(dest)
+                self.handle.move_storage(dest, **kwargs)
             except TypeError:
-                self.handle.move_storage(dest_bytes)
+                self.handle.move_storage(dest_bytes, **kwargs)
         except Exception, e:
             log.error("Error calling libtorrent move_storage: %s" % e)
             return False
@@ -865,8 +945,12 @@ class Torrent(object):
     def save_resume_data(self):
         """Signals libtorrent to build resume data for this torrent, it gets
         returned in a libtorrent alert"""
-        self.handle.save_resume_data()
-        self.waiting_on_resume_data = True
+        # Don't generate fastresume data if torrent is in a Deluge Error state.
+        if self.forced_error:
+            log.debug("Skipped creating resume_data while in Error state")
+        else:
+            self.handle.save_resume_data()
+            self.waiting_on_resume_data = True
 
     def on_metadata_received(self):
         if self.options["prioritize_first_last_pieces"]:
@@ -886,7 +970,13 @@ class Torrent(object):
             md = lt.bdecode(self.torrent_info.metadata())
             torrent_file = {}
             torrent_file["info"] = md
-            open(path, "wb").write(lt.bencode(torrent_file))
+            with open(path, "wb") as _file:
+                _file.write(lt.bencode(torrent_file))
+            if self.config["copy_torrent_file"]:
+                config_dir = self.config['torrentfiles_location']
+                filepath = os.path.join(config_dir, self.filename)
+                with open(filepath, "wb") as _file:
+                    _file.write(lt.bencode(torrent_file))
         except Exception, e:
             log.warning("Unable to save torrent file: %s", e)
 
@@ -923,16 +1013,27 @@ class Torrent(object):
 
     def force_recheck(self):
         """Forces a recheck of the torrents pieces"""
-        paused = self.handle.is_paused()
+        self.forcing_recheck = True
+        if self.forced_error:
+            self.forcing_recheck_paused = self.forced_error.was_paused
+            self.clear_forced_error_state(update_state=False)
+        else:
+            self.forcing_recheck_paused = self.handle.is_paused()
+        # Store trackers for paused torrents to prevent unwanted announce before pausing again.
+        if self.forcing_recheck_paused:
+            self.set_trackers(None, reannounce=False)
+            self.handle.replace_trackers([])
+
         try:
             self.handle.force_recheck()
             self.handle.resume()
         except Exception, e:
             log.debug("Unable to force recheck: %s", e)
-            return False
-        self.forcing_recheck = True
-        self.forcing_recheck_paused = paused
-        return True
+            self.forcing_recheck = False
+            if self.forcing_recheck_paused:
+                self.set_trackers(torrent.trackers, reannounce=False)
+
+        return self.forcing_recheck
 
     def rename_files(self, filenames):
         """Renames files in the torrent. 'filenames' should be a list of
@@ -981,4 +1082,3 @@ class Torrent(object):
         for key in self.prev_status.keys():
             if not self.rpcserver.is_session_valid(key):
                 del self.prev_status[key]
-

deluge/core/torrentmanager.py

@@ -111,10 +111,22 @@ class TorrentState:
         self.move_completed = move_completed
         self.move_completed_path = move_completed_path
 
+    def __eq__(self, other):
+        return isinstance(other, TorrentState) and self.__dict__ == other.__dict__
+
+    def __ne__(self, other):
+        return not self == other
+
 class TorrentManagerState:
     def __init__(self):
         self.torrents = []
 
+    def __eq__(self, other):
+        return isinstance(other, TorrentManagerState) and self.torrents == other.torrents
+
+    def __ne__(self, other):
+        return not self == other
+
 class TorrentManager(component.Component):
     """
     TorrentManager contains a list of torrents in the current libtorrent
@@ -157,6 +169,9 @@ class TorrentManager(component.Component):
         # Workaround to determine if TorrentAddedEvent is from state file
         self.session_started = False
 
+        # Keep the previous saved state
+        self.prev_saved_state = None
+
         # Register set functions
         self.config.register_set_function("max_connections_per_torrent",
             self.on_set_max_connections_per_torrent)
@@ -202,6 +217,12 @@ class TorrentManager(component.Component):
             self.on_alert_file_error)
         self.alerts.register_handler("file_completed_alert",
             self.on_alert_file_completed)
+        self.alerts.register_handler("fastresume_rejected_alert",
+            self.on_alert_fastresume_rejected)
+
+        # Define timers
+        self.save_state_timer = LoopingCall(self.save_state)
+        self.save_resume_data_timer = LoopingCall(self.save_resume_data)
 
     def start(self):
         # Get the pluginmanager reference
@@ -210,14 +231,12 @@ class TorrentManager(component.Component):
         # Run the old state upgrader before loading state
         deluge.core.oldstateupgrader.OldStateUpgrader()
 
-        # Try to load the state from file
+        # Try to load the state from file.
         self.load_state()
 
-        # Save the state every 5 minutes
-        self.save_state_timer = LoopingCall(self.save_state)
+        # Save the state and resume data every ~3 minutes.
         self.save_state_timer.start(200, False)
-        self.save_resume_data_timer = LoopingCall(self.save_resume_data)
-        self.save_resume_data_timer.start(190)
+        self.save_resume_data_timer.start(190, False)
 
     def stop(self):
         # Stop timers
@@ -391,7 +410,7 @@ class TorrentManager(component.Component):
                 if add_torrent_id in self.get_torrent_list():
                     log.info("Merging trackers for torrent (%s) already in session...", add_torrent_id)
                     # Don't merge trackers if either torrent has private flag set
-                    if self[add_torrent_id].get_status(["private"])["private"]:
+                    if torrent_info.priv() or self[add_torrent_id].get_status(["private"])["private"]:
                         log.info("Merging trackers abandoned: Torrent has private flag set.")
                         return
 
@@ -467,7 +486,8 @@ class TorrentManager(component.Component):
         handle = None
         try:
             if magnet:
-                handle = lt.add_magnet_uri(self.session, utf8_encoded(magnet), add_torrent_params)
+                magnet_uri = utf8_encoded(magnet.strip())
+                handle = lt.add_magnet_uri(self.session, magnet_uri, add_torrent_params)
             else:
                 handle = self.session.add_torrent(add_torrent_params)
         except RuntimeError, e:
@@ -491,6 +511,10 @@ class TorrentManager(component.Component):
 
         component.resume("AlertManager")
 
+        # Store the orignal resume_data, in case of errors.
+        if resume_data:
+            self.resume_data[torrent.torrent_id] = resume_data
+
         # Resume the torrent if needed
         if not options["add_paused"]:
             torrent.resume()
@@ -628,21 +652,24 @@ class TorrentManager(component.Component):
 
     def load_state(self):
         """Load the state of the TorrentManager from the torrents.state file"""
-        state = TorrentManagerState()
-
-        try:
-            log.debug("Opening torrent state file for load.")
-            state_file = open(
-                os.path.join(get_config_dir(), "state", "torrents.state"), "rb")
-            state = cPickle.load(state_file)
-            state_file.close()
-        except (EOFError, IOError, Exception, cPickle.UnpicklingError), e:
-            log.warning("Unable to load state file: %s", e)
+        filepath = os.path.join(get_config_dir(), "state", "torrents.state")
+        log.debug("Opening torrent state file for load.")
+        for _filepath in (filepath, filepath + ".bak"):
+            try:
+                state_file = open(_filepath, "rb")
+                state = cPickle.load(state_file)
+                state_file.close()
+            except (EOFError, IOError, Exception, cPickle.UnpicklingError), e:
+                log.warning("Unable to load state file: %s", e)
+                state = TorrentManagerState()
+            else:
+                log.info("Successfully loaded state file: %s", _filepath)
+                break
 
         # Try to use an old state
         try:
             state_tmp = TorrentState()
-            if dir(state.torrents[0]) != dir(state_tmp):
+            if state.torrents and dir(state.torrents[0]) != dir(state_tmp):
                 for attr in (set(dir(state_tmp)) - set(dir(state.torrents[0]))):
                     for s in state.torrents:
                         setattr(s, attr, getattr(state_tmp, attr, None))
@@ -671,9 +698,14 @@ class TorrentManager(component.Component):
         state = TorrentManagerState()
         # Create the state for each Torrent and append to the list
         for torrent in self.torrents.values():
-            paused = False
-            if torrent.state == "Paused":
+            if self.session.is_paused():
+                paused = torrent.handle.is_paused()
+            elif torrent.forced_error:
+                paused = torrent.forced_error.was_paused
+            elif torrent.state == "Paused":
                 paused = True
+            else:
+                paused = False
 
             torrent_state = TorrentState(
                 torrent.torrent_id,
@@ -702,27 +734,38 @@ class TorrentManager(component.Component):
             )
             state.torrents.append(torrent_state)
 
+        # If the state hasn't changed, no need to save it
+        if self.prev_saved_state == state:
+            return
+
         # Pickle the TorrentManagerState object
+        filepath = os.path.join(get_config_dir(), "state", "torrents.state")
+        filepath_tmp = filepath + ".tmp"
+        filepath_bak = filepath + ".bak"
+
         try:
-            log.debug("Saving torrent state file.")
-            state_file = open(os.path.join(get_config_dir(),
-                              "state", "torrents.state.new"), "wb")
+            os.remove(filepath_bak)
+        except OSError:
+            pass
+        try:
+            log.debug("Creating backup of state at: %s", filepath_bak)
+            os.rename(filepath, filepath_bak)
+        except OSError, ex:
+            log.error("Unable to backup %s to %s: %s", filepath, filepath_bak, ex)
+        try:
+            log.info("Saving the state at: %s", filepath)
+            state_file = open(filepath_tmp, "wb", 0)
             cPickle.dump(state, state_file)
             state_file.flush()
             os.fsync(state_file.fileno())
             state_file.close()
-        except IOError, e:
-            log.warning("Unable to save state file: %s", e)
-            return True
-
-        # We have to move the 'torrents.state.new' file to 'torrents.state'
-        try:
-            shutil.move(
-                os.path.join(get_config_dir(), "state", "torrents.state.new"),
-                os.path.join(get_config_dir(), "state", "torrents.state"))
-        except IOError:
-            log.warning("Unable to save state file.")
-            return True
+            os.rename(filepath_tmp, filepath)
+            self.prev_saved_state = state
+        except IOError, ex:
+            log.error("Unable to save %s: %s", filepath, ex)
+            if os.path.isfile(filepath_bak):
+                log.info("Restoring backup of state from: %s", filepath_bak)
+                os.rename(filepath_bak, filepath)
 
         # We return True so that the timer thread will continue
         return True
@@ -742,15 +785,20 @@ class TorrentManager(component.Component):
         self.num_resume_data = len(torrent_ids)
 
     def load_resume_data_file(self):
-        resume_data = {}
-        try:
-            log.debug("Opening torrents fastresume file for load.")
-            fastresume_file = open(os.path.join(get_config_dir(), "state",
-                                                "torrents.fastresume"), "rb")
-            resume_data = lt.bdecode(fastresume_file.read())
-            fastresume_file.close()
-        except (EOFError, IOError, Exception), e:
-            log.warning("Unable to load fastresume file: %s", e)
+        filepath = os.path.join(get_config_dir(), "state", "torrents.fastresume")
+        log.debug("Opening torrents fastresume file for load.")
+        for _filepath in (filepath, filepath + ".bak"):
+            try:
+                fastresume_file = open(_filepath, "rb")
+                resume_data = lt.bdecode(fastresume_file.read())
+                fastresume_file.close()
+            except (EOFError, IOError, Exception), e:
+                if self.torrents:
+                    log.warning("Unable to load fastresume file: %s", e)
+                resume_data = None
+            else:
+                log.info("Successfully loaded fastresume file: %s", _filepath)
+                break
 
         # If the libtorrent bdecode doesn't happen properly, it will return None
         # so we need to make sure we return a {}
@@ -774,8 +822,9 @@ class TorrentManager(component.Component):
         if self.num_resume_data or not self.resume_data:
             return
 
-        path = os.path.join(get_config_dir(), "state", "torrents.fastresume")
-        path_tmp = path + ".tmp"
+        filepath = os.path.join(get_config_dir(), "state", "torrents.fastresume")
+        filepath_tmp = filepath + ".tmp"
+        filepath_bak = filepath + ".bak"
 
         # First step is to load the existing file and update the dictionary
         if resume_data is None:
@@ -785,15 +834,27 @@ class TorrentManager(component.Component):
         self.resume_data = {}
 
         try:
-            log.debug("Saving fastresume file: %s", path)
-            fastresume_file = open(path_tmp, "wb")
+            os.remove(filepath_bak)
+        except OSError:
+            pass
+        try:
+            log.debug("Creating backup of fastresume at: %s", filepath_bak)
+            os.rename(filepath, filepath_bak)
+        except OSError, ex:
+            log.error("Unable to backup %s to %s: %s", filepath, filepath_bak, ex)
+        try:
+            log.info("Saving the fastresume at: %s", filepath)
+            fastresume_file = open(filepath_tmp, "wb", 0)
             fastresume_file.write(lt.bencode(resume_data))
             fastresume_file.flush()
             os.fsync(fastresume_file.fileno())
             fastresume_file.close()
-            shutil.move(path_tmp, path)
-        except IOError:
-            log.warning("Error trying to save fastresume file")
+            os.rename(filepath_tmp, filepath)
+        except IOError, ex:
+            log.error("Unable to save %s: %s", filepath, ex)
+            if os.path.isfile(filepath_bak):
+                log.info("Restoring backup of fastresume from: %s", filepath_bak)
+                os.rename(filepath_bak, filepath)
 
     def remove_empty_folders(self, torrent_id, folder):
         """
@@ -936,10 +997,7 @@ class TorrentManager(component.Component):
         except:
             return
         # Set the torrent state
-        old_state = torrent.state
         torrent.update_state()
-        if torrent.state != old_state:
-            component.get("EventManager").emit(TorrentStateChangedEvent(torrent_id, torrent.state))
 
         # Don't save resume data for each torrent after self.stop() was called.
         # We save resume data in bulk in self.stop() in this case.
@@ -963,6 +1021,7 @@ class TorrentManager(component.Component):
             torrent.forcing_recheck = False
             if torrent.forcing_recheck_paused:
                 torrent.handle.pause()
+                torrent.set_trackers(torrent.trackers, reannounce=False)
 
         # Set the torrent state
         torrent.update_state()
@@ -976,7 +1035,7 @@ class TorrentManager(component.Component):
 
         # Set the tracker status for the torrent
         if alert.message() != "Got peers from DHT":
-            torrent.set_tracker_status(_("Announce OK"))
+            torrent.set_tracker_status("Announce OK")
 
         # Check to see if we got any peer information from the tracker
         if alert.handle.status().num_complete == -1 or \
@@ -992,7 +1051,7 @@ class TorrentManager(component.Component):
             return
 
         # Set the tracker status for the torrent
-        torrent.set_tracker_status(_("Announce Sent"))
+        torrent.set_tracker_status("Announce Sent")
 
     def on_alert_tracker_warning(self, alert):
         log.debug("on_alert_tracker_warning")
@@ -1000,18 +1059,24 @@ class TorrentManager(component.Component):
             torrent = self.torrents[str(alert.handle.info_hash())]
         except:
             return
-        tracker_status = '%s: %s' % (_("Warning"), decode_string(alert.message()))
+        tracker_status = '%s: %s' % ("Warning", decode_string(alert.message()))
         # Set the tracker status for the torrent
         torrent.set_tracker_status(tracker_status)
 
     def on_alert_tracker_error(self, alert):
-        log.debug("on_alert_tracker_error")
+        """Alert handler for libtorrent tracker_error_alert"""
+        error_message = decode_string(alert.msg)
+        # If alert.msg is empty then it's a '-1' code so fallback to a.e.message. Note that alert.msg
+        # cannot be replaced by a.e.message because the code is included in the string (for non-'-1').
+        if not error_message:
+            error_message = decode_string(alert.error.message())
+        log.debug("Tracker Error Alert: %s [%s]", decode_string(alert.message()), error_message)
         try:
             torrent = self.torrents[str(alert.handle.info_hash())]
-        except:
+        except (RuntimeError, KeyError):
             return
-        tracker_status = "%s: %s" % (_("Error"), alert.msg)
-        torrent.set_tracker_status(tracker_status)
+
+        torrent.set_tracker_status("Error: %s" % error_message)
 
     def on_alert_storage_moved(self, alert):
         log.debug("on_alert_storage_moved")
@@ -1037,6 +1102,7 @@ class TorrentManager(component.Component):
         except (RuntimeError, KeyError):
             return
 
+        log.error("Torrent %s, %s", torrent_id, decode_string(alert.message()))
         if torrent_id in self.waiting_on_finish_moving:
             self.waiting_on_finish_moving.remove(torrent_id)
             torrent.is_finished = True
@@ -1049,11 +1115,7 @@ class TorrentManager(component.Component):
             torrent_id = str(alert.handle.info_hash())
         except:
             return
-        old_state = torrent.state
         torrent.update_state()
-        if torrent.state != old_state:
-            # We need to emit a TorrentStateChangedEvent too
-            component.get("EventManager").emit(TorrentStateChangedEvent(torrent_id, torrent.state))
         component.get("EventManager").emit(TorrentResumedEvent(torrent_id))
 
     def on_alert_state_changed(self, alert):
@@ -1064,7 +1126,6 @@ class TorrentManager(component.Component):
         except:
             return
 
-        old_state = torrent.state
         torrent.update_state()
 
         # Torrent may need to download data after checking.
@@ -1072,10 +1133,6 @@ class TorrentManager(component.Component):
             torrent.is_finished = False
             self.queued_torrents.add(torrent_id)
 
-        # Only emit a state changed event if the state has actually changed
-        if torrent.state != old_state:
-            component.get("EventManager").emit(TorrentStateChangedEvent(torrent_id, torrent.state))
-
     def on_alert_save_resume_data(self, alert):
         log.debug("on_alert_save_resume_data")
         try:
@@ -1104,6 +1161,25 @@ class TorrentManager(component.Component):
 
         self.save_resume_data_file()
 
+    def on_alert_fastresume_rejected(self, alert):
+        """Alert handler for libtorrent fastresume_rejected_alert"""
+        alert_msg = decode_string(alert.message())
+        log.error("on_alert_fastresume_rejected: %s", alert_msg)
+        try:
+            torrent_id = str(alert.handle.info_hash())
+            torrent = self.torrents[torrent_id]
+        except (RuntimeError, KeyError):
+            return
+
+        if alert.error.value() == 134:
+            if not os.path.isdir(torrent.options["download_location"]):
+                error_msg = "Unable to locate Download Folder!"
+            else:
+                error_msg = "Missing or invalid torrent data!"
+        else:
+            error_msg = "Problem with resume data: %s" % alert_msg.split(":", 1)[1].strip()
+
+        torrent.force_error_state(error_msg, restart_to_resume=True)
 
     def on_alert_file_renamed(self, alert):
         log.debug("on_alert_file_renamed")