def handle_free(self, pyfile): if "You need Premium membership to download this file." in self.data: self.fail(_("You need Premium membership to download this file")) for _i in xrange(5): m = re.search(self.CAPTCHA_PATTERN, self.data) if m is not None: url = urlparse.urljoin("http://crocko.com/", m.group(1)) self.wait(m.group(2)) self.data = self.load(url) else: break m = re.search(self.FORM_PATTERN, self.data, re.S) if m is None: self.error(_("FORM_PATTERN not found")) action, form = m.groups() inputs = dict(re.findall(self.FORM_INPUT_PATTERN, form)) recaptcha = ReCaptcha(self) inputs['recaptcha_response_field'], inputs['recaptcha_challenge_field'] = recaptcha.challenge() self.download(action, post=inputs) if self.check_file({'captcha': recaptcha.KEY_AJAX_PATTERN}): self.retry_captcha()
def handle_free(self, pyfile): #: Click the "free user" button and wait a = self.load(pyfile.url, post={'downloadLink': "wait"}) self.log_debug(a) self.wait(30) #: Make the recaptcha appear and show it the pyload interface b = self.load(pyfile.url, post={'checkDownload': "check"}) self.log_debug(b) #: Expected output: {'success': "showCaptcha"} recaptcha = ReCaptcha(self) response, challenge = recaptcha.challenge(self.RECAPTCHA_KEY) #: Submit the captcha solution self.load("http://www.uploadable.ch/checkReCaptcha.php", post={'recaptcha_challenge_field' : challenge, 'recaptcha_response_field' : response, 'recaptcha_shortencode_field': self.info['pattern']['ID']}) self.wait(3) #: Get ready for downloading self.load(pyfile.url, post={'downloadLink': "show"}) self.wait(3) #: Download the file self.download(pyfile.url, post={'download': "normal"}, disposition=True)
def handle_free(self, pyfile): inputs = self.parse_html_form(input_names={'token': re.compile(r'.+')})[1] if 'token' not in inputs: self.error(_("Unable to detect token")) self.html = self.load(pyfile.url, post={'token': inputs['token']}) inputs = self.parse_html_form(input_names={'hash': re.compile(r'.+')})[1] if 'hash' not in inputs: self.error(_("Unable to detect hash")) recaptcha = ReCaptcha(self) response, challenge = recaptcha.challenge() #@NOTE: Work-around for v0.4.9 just_header issue #@TODO: Check for v0.4.10 self.req.http.c.setopt(pycurl.FOLLOWLOCATION, 0) self.load(pyfile.url, post={'recaptcha_challenge_field': challenge, 'recaptcha_response_field' : response, 'hash' : inputs['hash']}) self.req.http.c.setopt(pycurl.FOLLOWLOCATION, 1) if 'location' in self.req.http.header.lower(): self.link = re.search(r'location: (\S+)', self.req.http.header, re.I).group(1) self.captcha.correct() else: self.captcha.invalid()
def handle_free(self, pyfile): rep = self.load(r"http://luckyshare.net/download/request/type/time/file/" + self.info['pattern']['ID']) self.log_debug("JSON: " + rep) json = self.parse_json(rep) self.wait(json['time']) recaptcha = ReCaptcha(self) for _i in xrange(5): response, challenge = recaptcha.challenge() rep = self.load(r"http://luckyshare.net/download/verify/challenge/%s/response/%s/hash/%s" % (challenge, response, json['hash'])) self.log_debug("JSON: " + rep) if 'link' in rep: json.update(self.parse_json(rep)) self.captcha.correct() break elif 'Verification failed' in rep: self.captcha.invalid() else: self.error(_("Unable to get downlaod link")) if not json['link']: self.fail(_("No Download url retrieved/all captcha attempts failed")) self.link = json['link']
def handle_captcha(self): solvemedia = SolveMedia(self.pyfile) captcha_key = solvemedia.detect_key() if captcha_key: self.captcha = solvemedia response, challenge = solvemedia.challenge(captcha_key) self.data = self.load("http://www.mediafire.com/?" + self.info['pattern']['ID'], post={'adcopy_challenge': challenge, 'adcopy_response' : response}) return recaptcha = ReCaptcha(self.pyfile) captcha_key = recaptcha.detect_key() if captcha_key: url, inputs = self.parse_html_form('name="form_captcha"') self.log_debug(("form_captcha url:%s inputs:%s") % (url, inputs)) if url: self.captcha = recaptcha response, challenge = recaptcha.challenge(captcha_key) inputs['g-recaptcha-response'] = response self.data = self.load(self.fixurl(url), post=inputs) else: self.fail("ReCaptcha form not found")
def handle_free(self, pyfile): #: Used here to load the cookies which will be required later self.load(pyfile.url, post={'goToFreePage': ""}) self.load("http://nitroflare.com/ajax/setCookie.php", post={'fileId': self.info['pattern']['ID']}) self.data = self.load("http://nitroflare.com/ajax/freeDownload.php", post={'method': "startTimer", 'fileId': self.info['pattern']['ID']}) self.check_errors() try: js_file = self.load("http://nitroflare.com/js/downloadFree.js?v=1.0.1") var_time = re.search("var time = (\\d+);", js_file) wait_time = int(var_time.groups()[0]) except Exception: wait_time = 60 self.wait(wait_time) recaptcha = ReCaptcha(self) response, challenge = recaptcha.challenge(self.RECAPTCHA_KEY) self.data = self.load("http://nitroflare.com/ajax/freeDownload.php", post={'method' : "fetchDownload", 'recaptcha_challenge_field': challenge, 'recaptcha_response_field' : response}) return super(NitroflareCom, self).handle_free(pyfile)
def handle_free(self, pyfile): self.html = self.load(pyfile.url, post={'gateway_result': "1"}) self.check_errors() m = re.search(r"var fid = '(\w+)';", self.html) if m is None: self.retry(wait_time=5) params = {'fid': m.group(1)} self.log_debug("FID: %s" % params['fid']) self.check_errors() recaptcha = ReCaptcha(self) captcha_key = recaptcha.detect_key() if captcha_key is None: return self.html = self.load("https://dfiles.eu/get_file.php", get=params) if '<input type=button value="Continue" onclick="check_recaptcha' in self.html: params['response'], params['challenge'] = recaptcha.challenge(captcha_key) self.html = self.load("https://dfiles.eu/get_file.php", get=params) m = re.search(self.LINK_FREE_PATTERN, self.html) if m: self.link = urllib.unquote(m.group(1))
def handle_free(self, pyfile): self.req.http.lastURL = pyfile.url self.req.http.c.setopt(pycurl.HTTPHEADER, ["X-Requested-With: XMLHttpRequest"]) jsvars = self.get_json_response("https://rapidu.net/ajax.php", get={'a': "getLoadTimeToDownload"}, post={'_go': ""}) if str(jsvars['timeToDownload']) == "stop": t = (24 * 60 * 60) - (int(time.time()) % (24 * 60 * 60)) + time.altzone self.log_info(_("You've reach your daily download transfer")) self.retry(10, 10 if t < 1 else None, _("Try tomorrow again")) #@NOTE: check t in case of not synchronised clock else: self.wait(int(jsvars['timeToDownload']) - int(time.time())) recaptcha = ReCaptcha(self) response, challenge = recaptcha.challenge(self.RECAPTCHA_KEY) jsvars = self.get_json_response("https://rapidu.net/ajax.php", get={'a': "getCheckCaptcha"}, post={'_go' : "", 'captcha1': challenge, 'captcha2': response, 'fileId' : self.info['pattern']['ID']}) if jsvars['message'] == "success": self.link = jsvars['url']
def handle_captcha(self): post_data = {'free' : 1, 'freeDownloadRequest': 1, 'uniqueId' : self.fid, 'yt0' : ''} m = re.search(r'id="(captcha\-form)"', self.html) self.log_debug("captcha-form found %s" % m) m = re.search(self.CAPTCHA_PATTERN, self.html) self.log_debug("CAPTCHA_PATTERN found %s" % m) if m: captcha_url = urlparse.urljoin("http://keep2s.cc/", m.group(1)) post_data['CaptchaForm[code]'] = self.captcha.decrypt(captcha_url) else: recaptcha = ReCaptcha(self) response, challenge = recaptcha.challenge() post_data.update({'recaptcha_challenge_field': challenge, 'recaptcha_response_field' : response}) self.html = self.load(self.pyfile.url, post=post_data) if 'verification code is incorrect' not in self.html: self.captcha.correct() else: self.captcha.invalid()
def solve_captcha(self): recaptcha = ReCaptcha(self) response, challenge = recaptcha.challenge(self.RECAPTCHA_KEY) apiUrl = "http://www.oboom.com/1.0/download/ticket" params = { "recaptcha_challenge_field": challenge, "recaptcha_response_field": response, "download_id": self.file_id, "token": self.session_token, } result = self.load_url(apiUrl, params) if result[0] == 200: self.download_token = result[1] self.download_auth = result[2] self.captcha.correct() self.wait(30) else: if result[0] == 403: if result[1] == -1: #: Another download is running self.set_wait(15 * 60) else: self.set_wait(result[1]) self.set_reconnect(True) self.wait() self.retry(5) elif result[0] == 400 and result[1] == "forbidden": self.retry(5, 15 * 60, _("Service unavailable")) self.retry_captcha()
def handle_free(self, pyfile): data = {'ukey': self.info['pattern']['ID']} m = re.search(self.AB1_PATTERN, self.data) if m is None: self.error(_("__AB1")) data['__ab1'] = m.group(1) recaptcha = ReCaptcha(self) m = re.search(self.RECAPTCHA_PATTERN, self.data) captcha_key = m.group(1) if m else recaptcha.detect_key() if captcha_key is None: self.error(_("ReCaptcha key not found")) response, challenge = recaptcha.challenge(captcha_key) self.account.form_data = {'recaptcha_challenge_field': challenge, 'recaptcha_response_field' : response} self.account.relogin() self.retry(2) json_url = "http://filecloud.io/download-request.json" res = self.load(json_url, post=data) self.log_debug(res) res = json.loads(res) if "error" in res and res['error']: self.fail(res) self.log_debug(res) if res['captcha']: data['ctype'] = "recaptcha" data['recaptcha_response'], data['recaptcha_challenge'] = recaptcha.challenge(captcha_key) json_url = "http://filecloud.io/download-request.json" res = self.load(json_url, post=data) self.log_debug(res) res = json.loads(res) if "retry" in res and res['retry']: self.retry_captcha() else: self.captcha.correct() if res['dl']: self.data = self.load('http://filecloud.io/download.html') m = re.search(self.LINK_FREE_PATTERN % self.info['pattern']['ID'], self.data) if m is None: self.error(_("LINK_FREE_PATTERN not found")) if "size" in self.info and self.info['size']: self.check_data = {'size': int(self.info['size'])} self.link = m.group(1) else: self.fail(_("Unexpected server response"))
def get_download_url(self): #: Return location if direct download is active if self.premium: header = self.load(self.pyfile.url, just_header=True) if 'location' in header: return header.get('location') #: Get download info self.log_debug("Getting download info") res = self.load("http://bitshare.com/files-ajax/" + self.file_id + "/request.html", post={'request': "generateID", 'ajaxid': self.ajaxid}) self.handle_errors(res, ':') parts = res.split(":") filetype = parts[0] wait = int(parts[1]) captcha = int(parts[2]) self.log_debug("Download info [type: '%s', waiting: %d, captcha: %d]" % (filetype, wait, captcha)) #: Waiting if wait > 0: self.log_debug("Waiting %d seconds." % wait) if wait < 120: self.wait(wait, False) else: self.wait(wait - 55, True) self.retry() #: Resolve captcha if captcha == 1: self.log_debug("File is captcha protected") recaptcha = ReCaptcha(self) response, challenge = recaptcha.challenge() res = self.load("http://bitshare.com/files-ajax/" + self.file_id + "/request.html", post={'request' : "validateCaptcha", 'ajaxid' : self.ajaxid, 'recaptcha_challenge_field': challenge, 'recaptcha_response_field' : response}) self.handle_captcha_errors(res) #: Get download URL self.log_debug("Getting download url") res = self.load("http://bitshare.com/files-ajax/" + self.file_id + "/request.html", post={'request': "getDownloadURL", 'ajaxid': self.ajaxid}) self.handle_errors(res, '#') url = res.split("#")[-1] return url
def handle_free(self, pyfile): recaptcha = ReCaptcha(self) captcha_key = recaptcha.detect_key() if captcha_key: try: self.link = re.search(self.LINK_PREMIUM_PATTERN, self.data) recaptcha.challenge() except Exception, e: self.error(e)
def handle_free(self, pyfile): recaptcha = ReCaptcha(self) response, challenge = recaptcha.challenge() self.data = self.load(pyfile.url, post={'recaptcha_challenge_field': challenge, 'recaptcha_response_field' : response}) m = re.search(self.LINK_FREE_PATTERN, self.data) if m is not None: self.link = m.group(1)
def do_captcha(self): captcha_key = re.search(self.CAPTCHA_KEY_PATTERN, self.data).group(1) recaptcha = ReCaptcha(self) response, challenge = recaptcha.challenge(captcha_key) res = json.loads(self.load(self.URLS[2], post={'recaptcha_challenge_field' : challenge, 'recaptcha_response_field' : response, 'recaptcha_shortencode_field': self.file_id})) if res['success']: self.captcha.correct() else: self.retry_captcha()
def handle_free(self, pyfile): self.load("http://uploaded.net/language/en", just_header=True) self.html = self.load("http://uploaded.net/js/download.js") recaptcha = ReCaptcha(self) response, challenge = recaptcha.challenge() self.html = self.load("http://uploaded.net/io/ticket/captcha/%s" % self.info['pattern']['ID'], post={'recaptcha_challenge_field': challenge, 'recaptcha_response_field' : response}) super(UploadedTo, self).handle_free(pyfile) self.check_errors()
def handle_free(self, pyfile): self.load("http://uploaded.net/language/en", just_header=True) self.data = self.load("http://uploaded.net/js/download.js") recaptcha = ReCaptcha(self) response, challenge = recaptcha.challenge() self.data = self.load( "http://uploaded.net/io/ticket/captcha/%s" % self.info["pattern"]["ID"], post={"recaptcha_challenge_field": challenge, "recaptcha_response_field": response}, ) self.check_errors() super(UploadedTo, self).handle_free(pyfile) self.check_errors()
def solve_captcha(self): m = re.search(self.LIMIT_WAIT_PATTERN, self.data) if m is not None: wait_time = int(m.group(1)) self.wait(wait_time, wait_time > 60) self.retry() action, inputs = self.parse_html_form("action='#'") if not inputs: self.error(_("Captcha form not found")) self.log_debug(inputs) if inputs["captcha_type"] == "recaptcha": recaptcha = ReCaptcha(self) inputs["recaptcha_response_field"], inputs["recaptcha_challenge_field"] = recaptcha.challenge() else: m = re.search(self.CAPTCHA_PATTERN, self.data) if m is None: self.error(_("Captcha pattern not found")) captcha_url = m.group(1) inputs["captcha_response"] = self.captcha.decrypt(captcha_url) self.log_debug(inputs) self.data = self.load(self.url, post=inputs) if '<div class="captcha-error">Incorrect, try again' in self.data: self.retry_captcha() else: self.captcha.correct()
def handle_captcha(self): recaptcha = ReCaptcha(self) response, challenge = recaptcha.challenge(self.RECAPTCHA_KEY) m = re.search(r'var wait=(\d+);', self.data) self.set_wait(int(m.group(1)) if m else 30) res = self.load("%s/free/captcha/%d" % (self.pyfile.url, int(time.time() * 1000)), post={'dl_free' : "1", 'recaptcha_challenge_field': challenge, 'recaptcha_response_field' : response}) if res != "0": self.captcha.correct() return res else: self.retry_captcha()
def handle_free(self, pyfile): if self.req.code == 404: self.offline() self.check_errors() m = re.search(self.LINK_FREE_PATTERN, self.data) if m: recaptcha = ReCaptcha(self) response, challenge = recaptcha.challenge(self.RECAPTCHA_KEY) self.download(m.group(1), post={'recaptcha_challenge_field': challenge, 'recaptcha_response_field': response, 'submit': "Submit", 'submitted': "1", 'd': "1"})
def handle_free(self, pyfile): url = 'http://datei.to/ajax/download.php' data = {'P': 'I', 'ID': self.info['pattern']['ID']} recaptcha = ReCaptcha(self) for _i in xrange(10): self.log_debug("URL", url, "POST", data) self.html = self.load(url, post=data) self.check_errors() if url.endswith('download.php') and 'P' in data: if data['P'] == "I": self.do_wait() elif data['P'] == "IV": break m = re.search(self.DATA_PATTERN, self.html) if m is None: self.error(_("data")) url = 'http://datei.to/' + m.group(1) data = dict(x.split('=') for x in m.group(2).split('&')) if url.endswith('recaptcha.php'): data['recaptcha_response_field'], data['recaptcha_challenge_field'] = recaptcha.challenge() else: self.fail(_("Too bad...")) self.link = self.html
def handle_captcha(self, inputs): m = re.search(self.CAPTCHA_PATTERN, self.data) if m is not None: captcha_url = m.group(1) inputs['code'] = self.captcha.decrypt(captcha_url) return m = re.search(self.CAPTCHA_BLOCK_PATTERN, self.data, re.S) if m is not None: captcha_div = m.group(1) numerals = re.findall(r'<span.*?padding-left\s*:\s*(\d+).*?>(\d)</span>', html_unescape(captcha_div)) self.log_debug(captcha_div) inputs['code'] = "".join(a[1] for a in sorted(numerals, key=operator.itemgetter(0))) self.log_debug("Captcha code: %s" % inputs['code'], numerals) return recaptcha = ReCaptcha(self.pyfile) try: captcha_key = re.search(self.RECAPTCHA_PATTERN, self.data).group(1) except Exception: captcha_key = recaptcha.detect_key() else: self.log_debug("ReCaptcha key: %s" % captcha_key) if captcha_key: self.captcha = recaptcha inputs['recaptcha_response_field'], inputs['recaptcha_challenge_field'] = recaptcha.challenge(captcha_key) return solvemedia = SolveMedia(self.pyfile) try: captcha_key = re.search(self.SOLVEMEDIA_PATTERN, self.data).group(1) except Exception: captcha_key = solvemedia.detect_key() else: self.log_debug("SolveMedia key: %s" % captcha_key) if captcha_key: self.captcha = solvemedia inputs['adcopy_response'], inputs['adcopy_challenge'] = solvemedia.challenge(captcha_key)
def handle_free(self, pyfile): action, inputs = self.parse_html_form('id="ifree_form"') if not action: self.error(_("Form not found")) pyfile.size = float(inputs['sssize']) self.log_debug(action, inputs) inputs['desc'] = "" self.data = self.load(urlparse.urljoin("http://letitbit.net/", action), post=inputs) m = re.search(self.SECONDS_PATTERN, self.data) seconds = int(m.group(1)) if m else 60 self.log_debug("Seconds found", seconds) m = re.search(self.CAPTCHA_CONTROL_FIELD, self.data) recaptcha_control_field = m.group(1) self.log_debug("ReCaptcha control field found", recaptcha_control_field) self.wait(seconds) res = self.load("http://letitbit.net/ajax/download3.php", post=" ") if res != '1': self.error(_("Unknown response - ajax_check_url")) self.log_debug(res) self.captcha = ReCaptcha(pyfile) response, challenge = self.captcha.challenge() post_data = {'recaptcha_challenge_field': challenge, 'recaptcha_response_field': response, 'recaptcha_control_field': recaptcha_control_field} self.log_debug("Post data to send", post_data) res = self.load("http://letitbit.net/ajax/check_recaptcha.php", post=post_data) self.log_debug(res) if not res or res == "error_wrong_captcha": self.retry_captcha() elif res == "error_free_download_blocked": self.log_warning(_("Daily limit reached")) self.wait(seconds_to_midnight(), True) elif res.startswith('['): urls = json.loads(res) elif res.startswith('http://'): urls = [res] else: self.error(_("Unknown response - captcha check")) self.link = urls[0]
def do_captcha(self): captcha_key = re.search(self.CAPTCHA_KEY_PATTERN, self.html).group(1) recaptcha = ReCaptcha(self) for _i in xrange(5): response, challenge = recaptcha.challenge(captcha_key) res = json_loads(self.load(self.URLS[2], post={'recaptcha_challenge_field' : challenge, 'recaptcha_response_field' : response, 'recaptcha_shortencode_field': self.file_id})) if not res['success']: self.captcha.invalid() else: self.captcha.correct() break else: self.fail(_("Invalid captcha"))
def handle_captcha(self): solvemedia = SolveMedia(self) captcha_key = solvemedia.detect_key() if captcha_key: response, challenge = solvemedia.challenge(captcha_key) self.html = self.load("http://www.mediafire.com/?" + self.info['pattern']['ID'], post={'adcopy_challenge': challenge, 'adcopy_response' : response}) return recaptcha = ReCaptcha(self) captcha_key = recaptcha.detect_key() if captcha_key: response, challenge = recaptcha.challenge(captcha_key) self.html = self.load(self.pyfile.url, post={'g-recaptcha-response': response})
def handle_free(self, pyfile): if r">Only premium users can download this file" in self.html: self.fail(_("Only premium users can download this file")) m = re.search(r"Next free download from your ip will be available in <b>(\d+)\s*minutes", self.html) if m: self.wait(int(m.group(1)) * 60, True) elif "The daily downloads limit from your IP is exceeded" in self.html: self.log_warning(_("You have reached your daily downloads limit for today")) self.wait(seconds_to_midnight(gmt=2), True) self.log_debug("URL: " + self.req.http.lastEffectiveURL) m = re.match(self.__pattern__, self.req.http.lastEffectiveURL) fileID = m.group('ID') if m else self.info['pattern']['ID'] m = re.search(r'recaptcha/api/challenge\?k=(\w+)', self.html) if m: recaptcha = ReCaptcha(self) captcha_key = m.group(1) for _i in xrange(5): get_data = {'type': "recaptcha"} get_data['capture'], get_data['challenge'] = recaptcha.challenge(captcha_key) res = json_loads(self.load("http://extabit.com/file/%s/" % fileID, get=get_data)) if "ok" in res: self.captcha.correct() break else: self.captcha.invalid() else: self.fail(_("Invalid captcha")) else: self.error(_("Captcha")) if not "href" in res: self.error(_("Bad JSON response")) self.html = self.load("http://extabit.com/file/%s%s" % (fileID, res['href'])) m = re.search(self.LINK_FREE_PATTERN, self.html) if m is None: self.error(_("LINK_FREE_PATTERN not found")) self.link = m.group(1)
def get_download_options(self): re_envelope = re.search(r".*?value=\"Free\sDownload\".*?\n*?(.*?<.*?>\n*)*?\n*\s*?</form>", self.data).group(0) #: Get the whole request to_sort = re.findall(r"<input\stype=\"hidden\"\svalue=\"(.*?)\"\sname=\"(.*?)\"\s\/>", re_envelope) request_options = dict((n, v) for (v, n) in to_sort) herewego = self.load(self.pyfile.url, None, request_options) #: The actual download-Page to_sort = re.findall(r"<input\stype=\".*?\"\svalue=\"(\S*?)\".*?name=\"(\S*?)\"\s.*?\/>", herewego) request_options = dict((n, v) for (v, n) in to_sort) challenge = re.search(r"http://api\.recaptcha\.net/challenge\?k=(\w+)", herewego) if challenge: re_captcha = ReCaptcha(self) (request_options['recaptcha_challenge_field'], request_options['recaptcha_response_field']) = re_captcha.challenge(challenge.group(1)) return request_options
def handle_free(self, pyfile): #: STAGE 1: get link to continue m = re.search(self.CHASH_PATTERN, self.data) if m is None: self.error(_("CHASH_PATTERN not found")) chash = m.group(1) self.log_debug("Read hash " + chash) #: Continue to stage2 post_data = {'hash': chash, 'free': 'Slow download'} self.data = self.load(pyfile.url, post=post_data) self.check_errors() #: STAGE 2: solv captcha and wait #: First get the infos we need: self.captcha key and wait time self.captcha = ReCaptcha(pyfile) #: Try the captcha 5 times for i in xrange(5): m = re.search(self.WAIT_PATTERN, self.data) if m is None: self.error(_("Wait pattern not found")) wait_time = int(m.group(1)) #: then, do the waiting self.wait(wait_time) #: then, handle the captcha response, challenge = self.captcha.challenge() post_data.update({'recaptcha_challenge_field': challenge, 'recaptcha_response_field' : response}) self.data = self.load(pyfile.url, post=post_data) # check whether the captcha was wrong m = re.search(self.WRONG_CAPTCHA_PATTERN, self.data, re.S) if m is not None: continue # STAGE 3: get direct link or wait time m = re.search(self.LONG_WAIT_PATTERN, self.data, re.S) if m is not None: wait_time = 60* int(m.group(1)) self.wantReconnect = True self.retry(wait=wait_time, reason=_("Please wait to download this file")) m = re.search(self.LINK_FREE_PATTERN, self.data, re.S) if m is not None: self.link = m.group(1) break # sometimes, upstore just restarts the countdown without saying anything... # in this case we'll just wait 1h and retry self.wantReconnect = True self.retry(wait_time=3600, reason=_("Upstore doesn't like us today"))
def handle_free(self, pyfile): m = re.search(self.FLP_TOKEN_PATTERN, self.html) if m is None: self.error(_("Token")) flp_token = m.group(1) m = re.search(self.RECAPTCHA_PATTERN, self.html) if m is None: self.error(_("Captcha key")) captcha_key = m.group(1) #: Get wait time get_dict = {'SID': self.req.cj.getCookie('SID'), 'JsHttpRequest': str(int(time.time() * 10000)) + '-xml'} post_dict = {'action': 'set_download', 'token': flp_token, 'code': self.info['pattern']['ID']} wait_time = int(self.get_json_response(get_dict, post_dict, 'wait_time')) if wait_time > 0: self.wait(wait_time) post_dict = {'token': flp_token, 'code': self.info['pattern']['ID'], 'file_pass': ''} if 'var is_pass_exists = true;' in self.html: #: Solve password password = self.get_password() if password: self.log_info(_("Password protected link, trying ") + file_pass) get_dict['JsHttpRequest'] = str(int(time.time() * 10000)) + '-xml' post_dict['file_pass'] = file_pass self.link = self.get_json_response(get_dict, post_dict, 'link') if not self.link: self.fail(_("Incorrect password")) else: self.fail(_("No password found")) else: #: Solve recaptcha recaptcha = ReCaptcha(self) for i in xrange(5): get_dict['JsHttpRequest'] = str(int(time.time() * 10000)) + '-xml' if i: post_dict['recaptcha_response_field'], post_dict['recaptcha_challenge_field'] = recaptcha.challenge( captcha_key) self.log_debug(u"RECAPTCHA: %s : %s : %s" % ( captcha_key, post_dict['recaptcha_challenge_field'], post_dict['recaptcha_response_field'])) self.link = self.get_json_response(get_dict, post_dict, 'link') else: self.fail(_("Invalid captcha"))
def handle_free(self, pyfile): #: STAGE 1: get link to continue m = re.search(self.CHASH_PATTERN, self.html) if m is None: self.error(_("CHASH_PATTERN not found")) chash = m.group(1) self.log_debug("Read hash " + chash) #: Continue to stage2 post_data = {'hash': chash, 'free': 'Slow download'} self.html = self.load(pyfile.url, post=post_data) #: STAGE 2: solv captcha and wait #: First get the infos we need: recaptcha key and wait time recaptcha = ReCaptcha(self) #: Try the captcha 5 times for i in xrange(5): m = re.search(self.WAIT_PATTERN, self.html) if m is None: self.error(_("Wait pattern not found")) wait_time = int(m.group(1)) #: then, do the waiting self.wait(wait_time) #: then, handle the captcha response, challenge = recaptcha.challenge() post_data.update({'recaptcha_challenge_field': challenge, 'recaptcha_response_field' : response}) self.html = self.load(pyfile.url, post=post_data) #: STAGE 3: get direct link m = re.search(self.LINK_FREE_PATTERN, self.html, re.S) if m: break if m is None: self.error(_("Download link not found")) self.link = m.group(1)