Merge branch 'stable' into 0.4.10

Conflicts:
	module/plugins/container/LinkList.py
	module/plugins/container/TXT.py
	module/plugins/hoster/HundredEightyUploadCom.py
	pyload/plugin/Extractor.py
	pyload/plugin/addon/ClickAndLoad.py
	pyload/plugin/addon/ExtractArchive.py
	pyload/plugin/addon/HotFolder.py
	pyload/plugin/container/TXT.py
	pyload/plugin/extractor/SevenZip.py
	pyload/plugin/extractor/UnRar.py
	pyload/plugin/extractor/UnZip.py
	pyload/plugin/hook/XFileSharingPro.py
	pyload/plugin/hoster/ZippyshareCom.py

11 files changed, 216 insertions, 204 deletions

diff --git a/pyload/plugin/Extractor.py b/pyload/plugin/Extractor.py
index 2582e4ad2..b1188fe13 100644
--- a/pyload/plugin/Extractor.py
+++ b/pyload/plugin/Extractor.py
@@ -20,7 +20,8 @@ class PasswordError(Exception):
 
 class Extractor(Base):
     __name    = "Extractor"
-    __version = "0.20"
+    __type    = "extractor"
+    __version = "0.21"
 
     __description = """Base extractor plugin"""
     __license     = "GPLv3"
@@ -31,6 +32,7 @@ class Extractor(Base):
 
     EXTENSIONS = []
     VERSION    = ""
+    REPAIR     = False
 
 
     @classmethod
@@ -91,23 +93,24 @@ class Extractor(Base):
 
 
     def check(self):
-        """Check if password if needed. Raise ArchiveError if integrity is
-        questionable.
+        """Quick Check by listing content of archive.
+        Raises error if password is needed, integrity is questionable or else.
 
-        :return: boolean
+        :raises PasswordError
+        :raises CRCError
         :raises ArchiveError
         """
-        raise PasswordError
-
-
-    def isPassword(self, password):
-        """ Check if the given password is/might be correct.
-        If it can not be decided at this point return true.
-
-        :param password:
-        :return: boolean
+        raise NotImplementedError
+        
+    def test(self):
+        """Testing with Extractors buildt-in method
+        Raises error if password is needed, integrity is questionable or else.
+        
+        :raises PasswordError
+        :raises CRCError
+        :raises ArchiveError
         """
-        return None
+        raise NotImplementedError
 
 
     def repair(self):
diff --git a/pyload/plugin/addon/ClickAndLoad.py b/pyload/plugin/addon/ClickAndLoad.py
index 98e650d15..c5042ede6 100644
--- a/pyload/plugin/addon/ClickAndLoad.py
+++ b/pyload/plugin/addon/ClickAndLoad.py
@@ -1,6 +1,7 @@
 # -*- coding: utf-8 -*-
 
 import socket
+import time
 
 from threading import Lock
 
@@ -18,48 +19,15 @@ def forward(source, destination):
         destination.shutdown(socket.SHUT_WR)
 
 
-#: create_connection wrapper for python 2.5 socket module
-def create_connection(address, timeout=object(), source_address=None):
-    if hasattr(socket, 'create_connection'):
-        if type(timeout) == object:
-            timeout = socket._GLOBAL_DEFAULT_TIMEOUT
-
-        return socket.create_connection(address, timeout, source_address)
-
-    else:
-        host, port = address
-        err = None
-        for res in getaddrinfo(host, port, 0, SOCK_STREAM):
-            af, socktype, proto, canonname, sa = res
-            sock = None
-            try:
-                sock = socket(af, socktype, proto)
-                if type(timeout) != object:
-                    sock.settimeout(timeout)
-                if source_address:
-                    sock.bind(source_address)
-                sock.connect(sa)
-                return sock
-
-            except socket.error, _:
-                err = _
-                if sock is not None:
-                    sock.close()
-
-        if err is not None:
-            raise err
-        else:
-            raise socket.error("getaddrinfo returns an empty list")
-
-
+#@TODO: IPv6 support
 class ClickAndLoad(Addon):
     __name    = "ClickAndLoad"
     __type    = "addon"
-    __version = "0.35"
+    __version = "0.37"
 
     __config = [("activated", "bool", "Activated"                             , True),
-                  ("port"     , "int" , "Port"                                  , 9666),
-                  ("extern"   , "bool", "Listen on the public network interface", True)]
+                ("port"     , "int" , "Port"                                  , 9666),
+                ("extern"   , "bool", "Listen on the public network interface", True)]
 
     __description = """Click'N'Load addon plugin"""
     __license     = "GPLv3"
@@ -71,7 +39,7 @@ class ClickAndLoad(Addon):
         if not self.config['webinterface']['activated']:
             return
 
-        ip      = socket.gethostbyname(socket.gethostname()) if self.getConfig("extern") else "127.0.0.1"
+        ip      = "" if self.getConfig("extern") else "127.0.0.1"
         webport = int(self.config['webinterface']['port'])
         cnlport = self.getConfig('port')
 
@@ -80,6 +48,7 @@ class ClickAndLoad(Addon):
 
     @threaded
     def proxy(self, ip, webport, cnlport):
+        self.logInfo(_("Proxy listening on %s:%s") % (ip, cnlport))
         self.manager.startThread(self._server, ip, webport, cnlport)
         lock = Lock()
         lock.acquire()
@@ -88,32 +57,31 @@ class ClickAndLoad(Addon):
 
     def _server(self, ip, webport, cnlport, thread):
         try:
-            server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-            server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
-            server_socket.bind((ip, cnlport))
-            server_socket.listen(5)
+            try:
+                server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
 
-            while True:
-                client_socket = server_socket.accept()[0]
-                dock_socket   = create_connection(("127.0.0.1", webport))
+                server_socket.bind((ip, cnlport))
+                server_socket.listen(5)
 
-                self.manager.startThread(forward, dock_socket, client_socket)
-                self.manager.startThread(forward, client_socket, dock_socket)
+                while True:
+                    client_socket = server_socket.accept()[0]
+                    dock_socket   = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
 
-        except socket.error, e:
-            self.logDebug(e)
-            self._server(ip, webport, cnlport, thread)
+                    dock_socket.connect(("127.0.0.1", webport))
 
-        except Exception, e:
-            self.logError(e)
+                    self.manager.startThread(forward, dock_socket, client_socket)
+                    self.manager.startThread(forward, client_socket, dock_socket)
 
-            try:
+            except socket.timeout:
+                self.logDebug("Connection timed out, retrying...")
+                return self._server(ip, webport, cnlport, thread)
+
+            finally:
+                server_socket.close()
                 client_socket.close()
                 dock_socket.close()
-            except Exception:
-                pass
 
-            try:
-                server_socket.close()
-            except Exception:
-                pass
+        except socket.error, e:
+            self.logError(e)
+            time.sleep(120)
+            self._server(ip, webport, cnlport, thread)
diff --git a/pyload/plugin/addon/ExtractArchive.py b/pyload/plugin/addon/ExtractArchive.py
index 9cd8fad62..29b2165ca 100644
--- a/pyload/plugin/addon/ExtractArchive.py
+++ b/pyload/plugin/addon/ExtractArchive.py
@@ -104,13 +104,14 @@ class ArchiveQueue(object):
 class ExtractArchive(Addon):
     __name    = "ExtractArchive"
     __type    = "addon"
-    __version = "1.29"
+    __version = "1.30"
 
     __config = [("activated"       , "bool"  , "Activated"                                 , True                                                                     ),
                   ("fullpath"        , "bool"  , "Extract with full paths"                   , True                                                                     ),
                   ("overwrite"       , "bool"  , "Overwrite files"                           , False                                                                    ),
                   ("keepbroken"      , "bool"  , "Try to extract broken archives"            , False                                                                    ),
-                  ("repair"          , "bool"  , "Repair broken archives"                    , True                                                                     ),
+                  ("repair"          , "bool"  , "Repair broken archives (rar required)"     , False                                                                    ),
+                  ("test"            , "bool"  , "Test archive before extracting"            , False                                                                    ),
                   ("usepasswordfile" , "bool"  , "Use password file"                         , True                                                                     ),
                   ("passwordfile"    , "file"  , "Password file"                             , "archive_password.txt"                                                   ),
                   ("delete"          , "bool"  , "Delete archive when successfully extracted", False                                                                    ),
@@ -128,7 +129,7 @@ class ExtractArchive(Addon):
                        ("Immenz"        , "immenz@gmx.net"   )]
 
 
-    event_list = ["allDownloadsProcessed"]
+    event_list = ["allDownloadsProcessed","packageDeleted"]
 
     NAME_REPLACEMENTS = [(r'\.part\d+\.rar$', ".part.rar")]
 
@@ -137,21 +138,23 @@ class ExtractArchive(Addon):
         self.queue  = ArchiveQueue(self, "Queue")
         self.failed = ArchiveQueue(self, "Failed")
 
-        self.interval   = 60
-        self.extracting = False
-        self.extractors = []
-        self.passwords  = []
+        self.interval    = 60
+        self.extracting  = False
+        self.lastPackage = False
+        self.extractors  = []
+        self.passwords   = []
+        self.repair      = False
 
 
     def activate(self):
-        # self.extracting = False
-
         for p in ("UnRar", "SevenZip", "UnZip"):
             try:
                 module = self.core.pluginManager.loadModule("extractor", p)
                 klass  = getattr(module, p)
                 if klass.isUsable():
                     self.extractors.append(klass)
+                if klass.REPAIR:
+                    self.repair = self.getConfig("repair")
 
             except OSError, e:
                 if e.errno == 2:
@@ -168,37 +171,49 @@ class ExtractArchive(Addon):
 
         if self.extractors:
             self.logInfo(_("Activated") + " " + "|".join("%s %s" % (Extractor.__name,Extractor.VERSION) for Extractor in self.extractors))
-
-            if self.getConfig("waitall"):
-                self.extractPackage(*self.queue.get())  #: Resume unfinished extractions
-            else:
-                super(ExtractArchive, self).initPeriodical()
-
+            self.extractQueued()  #: Resume unfinished extractions
         else:
             self.logInfo(_("No Extract plugins activated"))
 
+    @threaded
+    def extractQueued(self,thread):
+        packages = self.queue.get()
+        while packages:
+            if self.lastPackage: # called from allDownloadsProcessed
+                self.lastPackage = False
+                if self.extract(packages, thread):  #@NOTE: check only if all gone fine, no failed reporting for now
+                    self.manager.dispatchEvent("all_archives_extracted")
+                self.manager.dispatchEvent("all_archives_processed")
+            else:
+                if self.extract(packages, thread):  #@NOTE: check only if all gone fine, no failed reporting for now
+                    pass
 
-    def periodical(self):
-        if not self.extracting:
-            self.extractPackage(*self.queue.get())
+            packages = self.queue.get() # check for packages added during extraction
 
 
     @Expose
     def extractPackage(self, *ids):
         """ Extract packages with given id"""
-        self.manager.startThread(self.extract, ids)
+        for id in ids:
+            self.queue.add(id)
+        if not self.getConfig("waitall") and not self.extracting:
+            self.extractQueued()
+
+
+    def packageDeleted(self, pid):
+        self.queue.remove(pid)
 
 
     def packageFinished(self, pypack):
         self.queue.add(pypack.id)
+        if not self.getConfig("waitall") and not self.extracting:
+            self.extractQueued()
 
 
-    @threaded
-    def allDownloadsProcessed(self, thread):
-        if self.extract(self.queue.get(), thread):  #@NOTE: check only if all gone fine, no failed reporting for now
-            self.manager.dispatchEvent("all_archives_extracted")
-
-        self.manager.dispatchEvent("all_archives_processed")
+    def allDownloadsProcessed(self):
+        self.lastPackage = True
+        if not self.extracting:
+            self.extractQueued()
 
 
     def extract(self, ids, thread=None):
@@ -311,12 +326,16 @@ class ExtractArchive(Addon):
                             if recursive and os.path.isfile(file):
                                 new_files_ids.append((filename, fid, os.path.dirname(filename)))  # append as new target
 
+                        pyfile = self.core.files.getFile(fid)
+                        self.manager.dispatchEvent("archive_extracted", pyfile, archive.out, archive.filename, new_files)
+
                 files_ids = new_files_ids  # also check extracted files
 
             if matched:
                 if success:
                     extracted.append(pid)
                     self.manager.dispatchEvent("package_extracted", pypack)
+
                 else:
                     failed.append(pid)
                     self.manager.dispatchEvent("package_extract_failed", pypack)
@@ -347,50 +366,65 @@ class ExtractArchive(Addon):
 
         encrypted = False
         try:
-            try:
-                archive.check()
+            self.logDebug("Password: %s" % (password or "None provided"))
+            passwords = uniqify([password] + self.getPasswords(False)) if self.getConfig("usepasswordfile") else [password]
+            for pw in passwords:
+                try:
+                    if self.getConfig("test") or self.repair:
+                        pyfile.setCustomStatus(_("testing"))
+                        if pw:
+                            self.logDebug("Testing with password: %s" % pw)
+                        pyfile.setProgress(0)
+                        archive.test(pw)
+                        pyfile.setProgress(100)
+                    else:
+                        archive.check(pw)
 
-            except CRCError, e:
-                self.logDebug(name, e)
-                self.logInfo(name, _("Header protected"))
+                    self.addPassword(pw)
+                    break
 
-                if self.getConfig("repair"):
-                    self.logWarning(name, _("Repairing..."))
+                except PasswordError:
+                    if not encrypted:
+                        self.logInfo(name, _("Password protected"))
+                        encrypted = True
 
-                    pyfile.setCustomStatus(_("repairing"))
-                    pyfile.setProgress(0)
+                except CRCError, e:
+                    self.logDebug(name, e)
+                    self.logInfo(name, _("CRC Error"))
 
-                    repaired = archive.repair()
+                    if self.repair:
+                        self.logWarning(name, _("Repairing..."))
 
-                    pyfile.setProgress(100)
+                        pyfile.setCustomStatus(_("repairing"))
+                        pyfile.setProgress(0)
+                        repaired = archive.repair()
+                        pyfile.setProgress(100)
 
-                    if not repaired and not self.getConfig("keepbroken"):
-                        raise CRCError("Archive damaged")
+                        if not repaired and not self.getConfig("keepbroken"):
+                            raise CRCError("Archive damaged")
 
-            except PasswordError:
-                self.logInfo(name, _("Password protected"))
-                encrypted = True
+                        self.addPassword(pw)
+                        break
 
-            except ArchiveError, e:
-                raise ArchiveError(e)
+                    raise CRCError("Archive damaged")
 
-            self.logDebug("Password: %s" % (password or "No provided"))
+                except ArchiveError, e:
+                    raise ArchiveError(e)
 
             pyfile.setCustomStatus(_("extracting"))
             pyfile.setProgress(0)
 
             if not encrypted or not self.getConfig("usepasswordfile"):
+                self.logDebug("Extracting using password: %s" % (password or "None"))
                 archive.extract(password)
             else:
                 for pw in filter(None, uniqify([password] + self.getPasswords(False))):
                     try:
-                        self.logDebug("Try password: %s" % pw)
+                        self.logDebug("Extracting using password: %s" % pw)
 
-                        ispw = archive.isPassword(pw)
-                        if ispw or ispw is None:
-                            archive.extract(pw)
-                            self.addPassword(pw)
-                            break
+                        archive.extract(pw)
+                        self.addPassword(pw)
+                        break
 
                     except PasswordError:
                         self.logDebug("Password was wrong")
@@ -414,9 +448,7 @@ class ExtractArchive(Addon):
                         self.logDebug("%s does not exists" % f)
 
             self.logInfo(name, _("Extracting finished"))
-
             extracted_files = archive.files or archive.list()
-            self.manager.dispatchEvent("archive_extracted", pyfile, archive.out, archive.filename, extracted_files)
 
             return extracted_files
 
diff --git a/pyload/plugin/addon/HotFolder.py b/pyload/plugin/addon/HotFolder.py
index 6b1f6c02e..f2c8a96a4 100644
--- a/pyload/plugin/addon/HotFolder.py
+++ b/pyload/plugin/addon/HotFolder.py
@@ -2,10 +2,9 @@
 
 from __future__ import with_statement
 
+import os
 import time
 
-from os import listdir, makedirs
-from os.path import exists, isfile, join
 from shutil import move
 
 from pyload.plugin.Addon import Addon
@@ -15,7 +14,7 @@ from pyload.utils import fs_encode, safe_join
 class HotFolder(Addon):
     __name    = "HotFolder"
     __type    = "addon"
-    __version = "0.12"
+    __version = "0.13"
 
     __config = [("folder"    , "str" , "Folder to observe"    , "container"),
                 ("watch_file", "bool", "Observe link file"    , False      ),
@@ -28,7 +27,7 @@ class HotFolder(Addon):
 
 
     def setup(self):
-        self.interval = 10
+        self.interval = 30
 
 
     def activate(self):
@@ -37,31 +36,35 @@ class HotFolder(Addon):
 
     def periodical(self):
         folder = fs_encode(self.getConfig("folder"))
+        file   = fs_encode(self.getConfig("file"))
 
         try:
-            if not exists(join(folder, "finished")):
-                makedirs(join(folder, "finished"))
+            if not os.path.isdir(os.path.join(folder, "finished")):
+                os.makedirs(os.path.join(folder, "finished"))
 
             if self.getConfig("watch_file"):
-                file = fs_encode(self.getConfig("file"))
                 with open(file, "a+") as f:
+                    f.seek(0)
                     content = f.read().strip()
 
                 if content:
-                    name = "%s_%s.txt" % (self.getConfig("file"), time.strftime("%H-%M-%S_%d%b%Y"))
+                    f = open(file, "wb")
+                    f.close()
+
+                    name = "%s_%s.txt" % (file, time.strftime("%H-%M-%S_%d%b%Y"))
 
                     with open(safe_join(folder, "finished", name), "wb") as f:
                         f.write(content)
 
                     self.core.api.addPackage(f.name, [f.name], 1)
 
-            for f in listdir(folder):
-                path = join(folder, f)
+            for f in os.listdir(folder):
+                path = os.path.join(folder, f)
 
-                if not isfile(path) or f.endswith("~") or f.startswith("#") or f.startswith("."):
+                if not os.path.isfile(path) or f.endswith("~") or f.startswith("#") or f.startswith("."):
                     continue
 
-                newpath = join(folder, "finished", f if self.getConfig("keep") else "tmp_" + f)
+                newpath = os.path.join(folder, "finished", f if self.getConfig("keep") else "tmp_" + f)
                 move(path, newpath)
 
                 self.logInfo(_("Added %s from HotFolder") % f)
diff --git a/pyload/plugin/container/TXT.py b/pyload/plugin/container/TXT.py
index 0f90f6b5a..31560f165 100644
--- a/pyload/plugin/container/TXT.py
+++ b/pyload/plugin/container/TXT.py
@@ -12,13 +12,13 @@ class TXT(Container):
     __version = "0.15"
 
     __pattern = r'.+\.(txt|text)$'
-    __config = [("flush"   , "bool"  , "Flush list after adding", False  ),
-                  ("encoding", "string", "File encoding"          , "utf-8")]
+    __config  = [("flush"   , "bool"  , "Flush list after adding", False  ),
+                 ("encoding", "string", "File encoding"          , "utf-8")]
 
     __description = """Read link lists in plain text formats"""
     __license     = "GPLv3"
     __authors     = [("spoob", "spoob@pyload.org"),
-                       ("jeix", "jeix@hasnomail.com")]
+                     ("jeix", "jeix@hasnomail.com")]
 
 
     def decrypt(self, pyfile):
diff --git a/pyload/plugin/extractor/SevenZip.py b/pyload/plugin/extractor/SevenZip.py
index 74eb4c855..1d7d57886 100644
--- a/pyload/plugin/extractor/SevenZip.py
+++ b/pyload/plugin/extractor/SevenZip.py
@@ -12,7 +12,7 @@ from pyload.utils import fs_encode, safe_join
 class SevenZip(UnRar):
     __name    = "SevenZip"
     __type    = "extractor"
-    __version = "0.08"
+    __version = "0.09"
 
     __description = """7-Zip extractor plugin"""
     __license     = "GPLv3"
@@ -33,9 +33,9 @@ class SevenZip(UnRar):
 
     #@NOTE: there are some more uncovered 7z formats
     re_filelist = re.compile(r'([\d\:]+)\s+([\d\:]+)\s+([\w\.]+)\s+(\d+)\s+(\d+)\s+(.+)')
-    re_wrongpwd = re.compile(r'(Can not open encrypted archive|Wrong password)', re.I)
-    re_wrongcrc = re.compile(r'Encrypted\s+\=\s+\+', re.I)
-    re_version   = re.compile(r'7-Zip\s(?:\[64\]\s)?(\d+\.\d+)', re.I)
+    re_wrongpwd = re.compile(r'(Can not open encrypted archive|Wrong password|Encrypted\s+\=\s+\+)', re.I)
+    re_wrongcrc = re.compile(r'CRC Failed|Can not open file', re.I)
+    re_version  = re.compile(r'7-Zip\s(?:\[64\]\s)?(\d+\.\d+)', re.I)
 
 
     @classmethod
@@ -53,36 +53,38 @@ class SevenZip(UnRar):
         return True
 
 
-    def check(self):
+    def test(self, password):
         file = fs_encode(self.filename)
 
-        p = self.call_cmd("t", file)
+        # 7z can't distinguish crc and pw error in test
+        p = self.call_cmd("l", "-slt", file)
         out, err = p.communicate()
 
-        if p.returncode > 1:
+        if self.re_wrongpwd.search(out):
+            raise PasswordError
+
+        if self.re_wrongpwd.search(err):
+            raise PasswordError
+
+        if self.re_wrongcrc.search(err):
             raise CRCError(err)
 
+
+
+    def check(self, password):
+        file = fs_encode(self.filename)
+
         p = self.call_cmd("l", "-slt", file)
         out, err = p.communicate()
 
-        if p.returncode > 1:
-            raise ArchiveError(_("Process return code: %d") % p.returncode)
-
         # check if output or error macthes the 'wrong password'-Regexp
         if self.re_wrongpwd.search(out):
             raise PasswordError
 
-        # check if output matches 'Encrypted = +'
         if self.re_wrongcrc.search(out):
             raise CRCError(_("Header protected"))
 
 
-    def isPassword(self, password):
-        p = self.call_cmd("l", fs_encode(self.filename), password=password)
-        p.communicate()
-        return p.returncode == 0
-
-
     def repair(self):
         return False
 
@@ -143,7 +145,7 @@ class SevenZip(UnRar):
 
         #set a password
         if "password" in kwargs and kwargs["password"]:
-            args.append("-p'%s'" % kwargs["password"])
+            args.append("-p%s" % kwargs["password"])
         else:
             args.append("-p-")
 
diff --git a/pyload/plugin/extractor/UnRar.py b/pyload/plugin/extractor/UnRar.py
index 0ff815597..a8279bfa9 100644
--- a/pyload/plugin/extractor/UnRar.py
+++ b/pyload/plugin/extractor/UnRar.py
@@ -23,7 +23,7 @@ def renice(pid, value):
 class UnRar(Extractor):
     __name    = "UnRar"
     __type    = "extractor"
-    __version = "1.13"
+    __version = "1.14"
 
     __description = """Rar extractor plugin"""
     __license     = "GPLv3"
@@ -34,34 +34,40 @@ class UnRar(Extractor):
 
     CMD = "unrar"
     VERSION = ""
-
     EXTENSIONS = [".rar"]
 
 
-    re_multipart = re.compile(r'\.(part|r)(\d+)(?:\.rar)?',re.I)
+    re_multipart = re.compile(r'\.(part|r)(\d+)(?:\.rar)?(\.rev|\.bad)?',re.I)
 
     re_filefixed = re.compile(r'Building (.+)')
     re_filelist  = re.compile(r'^(.)(\s*[\w\.\-]+)\s+(\d+\s+)+(?:\d+\%\s+)?[\d\-]{8}\s+[\d\:]{5}', re.M|re.I)
 
     re_wrongpwd  = re.compile(r'password', re.I)
-    re_wrongcrc  = re.compile(r'encrypted|damaged|CRC failed|checksum error', re.I)
+    re_wrongcrc  = re.compile(r'encrypted|damaged|CRC failed|checksum error|corrupt', re.I)
 
-    re_version   = re.compile(r'UNRAR\s(\d+\.\d+)', re.I)
+    re_version   = re.compile(r'(?:UN)?RAR\s(\d+\.\d+)', re.I)
 
 
     @classmethod
     def isUsable(cls):
         if os.name == "nt":
-            cls.CMD = os.path.join(pypath, "UnRAR.exe")
-            p = Popen([cls.CMD], stdout=PIPE, stderr=PIPE)
-            out, err = p.communicate()
-        else:
             try:
+                cls.CMD = os.path.join(pypath, "RAR.exe")
                 p = Popen([cls.CMD], stdout=PIPE, stderr=PIPE)
                 out, err = p.communicate()
-
-            except OSError:  #: fallback to rar
-                cls.CMD = "rar"
+                cls.__name__ = "RAR"
+                cls.REPAIR = True
+            except OSError:
+                cls.CMD = os.path.join(pypath, "UnRAR.exe")
+                p = Popen([cls.CMD], stdout=PIPE, stderr=PIPE)
+                out, err = p.communicate()
+        else:
+            try:
+                p = Popen(["rar"], stdout=PIPE, stderr=PIPE)
+                out, err = p.communicate()
+                cls.__name__ = "RAR"
+                cls.REPAIR = True
+            except OSError:  #: fallback to unrar
                 p = Popen([cls.CMD], stdout=PIPE, stderr=PIPE)
                 out, err = p.communicate()
 
@@ -75,13 +81,25 @@ class UnRar(Extractor):
         multipart = cls.re_multipart.search(filename)
         if multipart:
             # First Multipart file (part1.rar for *.part1-9.rar format or *.rar for .r1-9 format) handled as normal Archive
-            return False if (multipart.group(1) == "part" and int(multipart.group(2)) == 1) else True
+            return False if (multipart.group(1) == "part" and int(multipart.group(2)) == 1 and not multipart.group(3)) else True
 
         return False
 
 
-    def check(self):
-        p = self.call_cmd("l", "-v", fs_encode(self.filename))
+    def test(self, password):
+        p = self.call_cmd("t", "-v", fs_encode(self.filename), password=password)
+        self._progress(p)
+        err = p.stderr.read().strip()
+
+        if self.re_wrongpwd.search(err):
+            raise PasswordError
+
+        if self.re_wrongcrc.search(err):
+            raise CRCError(err)
+
+
+    def check(self, password):
+        p = self.call_cmd("l", "-v", fs_encode(self.filename), password=password)
         out, err = p.communicate()
 
         if self.re_wrongpwd.search(err):
@@ -96,35 +114,14 @@ class UnRar(Extractor):
                 raise PasswordError
 
 
-    def isPassword(self, password):
-        # at this point we can only verify header protected files
-        p = self.call_cmd("l", "-v", fs_encode(self.filename), password=password)
-        out, err = p.communicate()
-        return False if self.re_wrongpwd.search(err) else True
-
-
     def repair(self):
         p = self.call_cmd("rc", fs_encode(self.filename))
 
         # communicate and retrieve stderr
         self._progress(p)
         err = p.stderr.read().strip()
-
         if err or p.returncode:
-            p = self.call_cmd("r", fs_encode(self.filename))
-
-            # communicate and retrieve stderr
-            self._progress(p)
-            err = p.stderr.read().strip()
-
-            if err or p.returncode:
-                return False
-            else:
-                dir  = os.path.dirname(filename)
-                name = re_filefixed.search(out).group(1)
-
-                self.filename = os.path.join(dir, name)
-
+            return False
         return True
 
 
diff --git a/pyload/plugin/extractor/UnZip.py b/pyload/plugin/extractor/UnZip.py
index 68dea3a1d..811ca7700 100644
--- a/pyload/plugin/extractor/UnZip.py
+++ b/pyload/plugin/extractor/UnZip.py
@@ -13,7 +13,7 @@ from pyload.utils import fs_encode
 class UnZip(Extractor):
     __name    = "UnZip"
     __type    = "extractor"
-    __version = "1.10"
+    __version = "1.11"
 
     __description = """Zip extractor plugin"""
     __license     = "GPLv3"
@@ -35,7 +35,11 @@ class UnZip(Extractor):
             return z.namelist()
 
 
-    def check(self):
+    def check(self, password):
+        pass
+
+
+    def test(self):
         with zipfile.ZipFile(fs_encode(self.filename), 'r', allowZip64=True) as z:
             badfile = z.testzip()
 
diff --git a/pyload/plugin/hook/XFileSharingPro.py b/pyload/plugin/hook/XFileSharingPro.py
index 65ef816b8..653e53d1e 100644
--- a/pyload/plugin/hook/XFileSharingPro.py
+++ b/pyload/plugin/hook/XFileSharingPro.py
@@ -8,7 +8,7 @@ from pyload.plugin.Hook import Hook
 class XFileSharingPro(Hook):
     __name    = "XFileSharingPro"
     __type    = "hook"
-    __version = "0.31"
+    __version = "0.32"
 
     __config = [("activated"       , "bool", "Activated"                     , True ),
                   ("use_hoster_list" , "bool", "Load listed hosters only"      , False),
@@ -29,7 +29,7 @@ class XFileSharingPro(Hook):
                           r'https?://(?:[^/]+\.)?(?P<DOMAIN>%s)/(?:user|folder)s?/\w+')}
 
     HOSTER_BUILTIN  = [#WORKING HOSTERS:
-                       "180upload.com", "backin.net", "eyesfile.ca", "file4safe.com", "fileband.com", "filedwon.com",
+                       "backin.net", "eyesfile.ca", "file4safe.com", "fileband.com", "filedwon.com",
                        "fileparadox.in", "filevice.com", "hostingbulk.com", "junkyvideo.com", "linestorage.com", "ravishare.com",
                        "ryushare.com", "salefiles.com", "sendmyway.com", "sharesix.com", "thefile.me", "verzend.be", "xvidstage.com",
                        #NOT TESTED:
diff --git a/pyload/plugin/hoster/HundredEightyUploadCom.py b/pyload/plugin/hoster/HundredEightyUploadCom.py
index 1cea5f4c5..de312245e 100644
--- a/pyload/plugin/hoster/HundredEightyUploadCom.py
+++ b/pyload/plugin/hoster/HundredEightyUploadCom.py
@@ -6,10 +6,13 @@ from pyload.plugin.internal.XFSHoster import XFSHoster
 class HundredEightyUploadCom(XFSHoster):
     __name    = "HundredEightyUploadCom"
     __type    = "hoster"
-    __version = "0.04"
+    __version = "0.05"
 
     __pattern = r'http://(?:www\.)?180upload\.com/\w{12}'
 
     __description = """180upload.com hoster plugin"""
     __license     = "GPLv3"
     __authors     = [("stickell", "l.stickell@yahoo.it")]
+
+
+    OFFLINE_PATTERN = r'>File Not Found'
diff --git a/pyload/plugin/hoster/ZippyshareCom.py b/pyload/plugin/hoster/ZippyshareCom.py
index 9ba673c39..91e88466a 100644
--- a/pyload/plugin/hoster/ZippyshareCom.py
+++ b/pyload/plugin/hoster/ZippyshareCom.py
@@ -9,7 +9,7 @@ from pyload.plugin.internal.SimpleHoster import SimpleHoster
 class ZippyshareCom(SimpleHoster):
     __name    = "ZippyshareCom"
     __type    = "hoster"
-    __version = "0.72"
+    __version = "0.73"
 
     __pattern = r'http://www\d{0,2}\.zippyshare\.com/v(/|iew\.jsp.*key=)(?P<KEY>[\w^_]+)'
 
@@ -51,9 +51,9 @@ class ZippyshareCom(SimpleHoster):
 
     def get_checksum(self):
         try:
-            n = 2
-            b = int(re.search(r'var b = (\d+)', self.html).group(1))
-            checksum = int("%d3" % (n + n * 2 + b))
+            b1 = eval(re.search(r'\.omg = (.+?);', self.html).group(1))
+            b2 = eval(re.search(r'\* \((.+?)\)', self.html).group(1))
+            checksum = b1 * b2 + 18
 
         except Exception:
             self.error(_("Unable to calculate checksum"))