from module.plugins.internal.SimpleHoster import SimpleHoster, create_getInfo class XdadevelopersCom(SimpleHoster): __name__ = "XdadevelopersCom" __type__ = "hoster" __version__ = "0.03" __pattern__ = r'https?://(?:www\.)?forum\.xda-developers\.com/devdb/project/dl/\?id=\d+' __config__ = [("use_premium", "bool", "Use premium account if available", True)] __description__ = """Xda-developers.com hoster plugin""" __license__ = "GPLv3" __authors__ = [("zapp-brannigan", "*****@*****.**")] NAME_PATTERN = r'<label>Filename:</label>\s*<div>\s*(?P<N>.*?)\n' SIZE_PATTERN = r'<label>Size:</label>\s*<div>\s*(?P<S>[\d.,]+)(?P<U>[\w^_]+)' OFFLINE_PATTERN = r'</i> Device Filter</h3>' def setup(self): self.multiDL = True self.resumeDownload = True self.chunkLimit = 1 def handleFree(self, pyfile): self.link = pyfile.url + "&task=get" #@TODO: Revert to `get={'task': "get"}` in 0.4.10 getInfo = create_getInfo(XdadevelopersCom)
# -*- coding: utf-8 -*- from module.plugins.hoster.UnibytesCom import UnibytesCom from module.plugins.internal.SimpleHoster import create_getInfo class Share4webCom(UnibytesCom): __name__ = "Share4webCom" __type__ = "hoster" __pattern__ = r"http://(www\.)?share4web\.com/get/\w+" __version__ = "0.1" __description__ = """Share4web.com""" __author_name__ = ("zoidberg") DOMAIN = 'http://www.share4web.com' getInfo = create_getInfo(UnibytesCom)
self.logDebug(" > Rand " + rand_val) self.logDebug(" > Referer " + re_val) # Create post data post_data = { "op": op_val, "id": id_val, "rand": rand_val, "referer": re_val, "method_free": "+Free+Download", "method_premium": "", "down_direct": "1" } # Post and get new HTML source self.logDebug("Getting third HTML source") html = self.load(self.pyfile.url, post=post_data, decode=True) self.logDebug(" > Done") # Get link value if re.search(link_pattern, html) is not None: link_val = re.search(link_pattern, html).group(1) self.logDebug(" > Link " + link_val) self.download(link_val) else: self.logDebug("No link found!!") self.retry(3, 10, "No link found!!") getInfo = create_getInfo(MovReelCom)
SH_COOKIES = [("http://www.wrzuc.to", "language", "en")] FILE_SIZE_PATTERN = r'class="info">\s*<tr>\s*<td>(?P<S>.*?)</td>' FILE_NAME_PATTERN = r'id="file_info">\s*<strong>(?P<N>.*?)</strong>' def setup(self): self.multiDL = True def handleFree(self): data = dict(re.findall(r'(md5|file): "(.*?)"', self.html)) if len(data) != 2: self.parseError('File ID') self.req.http.c.setopt(HTTPHEADER, ["X-Requested-With: XMLHttpRequest"]) self.req.http.lastURL = self.pyfile.url self.load("http://www.wrzuc.to/ajax/server/prepair", post={"md5": data['md5']}) self.req.http.lastURL = self.pyfile.url self.html = self.load("http://www.wrzuc.to/ajax/server/download_link", post={"file": data['file']}) data.update(re.findall(r'"(download_link|server_id)":"(.*?)"', self.html)) if len(data) != 4: self.parseError('Download URL') download_url = "http://%s.wrzuc.to/pobierz/%s" % (data['server_id'], data['download_link']) self.logDebug("Download URL: %s" % download_url) self.download(download_url) getInfo = create_getInfo(WrzucTo)
json = self.parseJson(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']), decode=True) self.logDebug("JSON: " + rep) if 'link' in rep: json.update(self.parseJson(rep)) self.correctCaptcha() break elif 'Verification failed' in rep: self.invalidCaptcha() 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'] getInfo = create_getInfo(LuckyShareNet)
self.fail("Cookie error") location = headers.get("location") self.req.setCookieJar(cj) self.download(location, disposition=True) else: self.fail("Invalid response") def getLastHeaders(self): #parse header header = {"code": self.req.code} for line in self.req.http.header.splitlines(): line = line.strip() if not line or ":" not in line: continue key, none, value = line.partition(":") key = key.lower().strip() value = value.strip() if key in header: if type(header[key]) == list: header[key].append(value) else: header[key] = [header[key], value] else: header[key] = value return header getInfo = create_getInfo(DlFreeFr)
__type__ = "hoster" __version__ = "0.04" __pattern__ = r'https?://(?:www\.)?dropbox\.com/.+' __config__ = [("use_premium", "bool", "Use premium account if available", True)] __description__ = """Dropbox.com hoster plugin""" __license__ = "GPLv3" __authors__ = [("zapp-brannigan", "*****@*****.**")] NAME_PATTERN = r'<title>Dropbox - (?P<N>.+?)<' SIZE_PATTERN = r' · (?P<S>[\d.,]+) (?P<U>[\w^_]+)' OFFLINE_PATTERN = r'<title>Dropbox - (404|Shared link error)<' COOKIES = [("dropbox.com", "lang", "en")] def setup(self): self.multiDL = True self.chunkLimit = 1 self.resumeDownload = True def handleFree(self, pyfile): self.download(pyfile.url, get={'dl': "1"}) getInfo = create_getInfo(DropboxCom)
captcha_url = "http://ints.rusfolder.com/random/images/?session=%s" % session_id for _ in xrange(5): self.html = self.load(url, cookies=True) action, inputs = self.parseHtmlForm('ID="Form1"') inputs['ints_session'] = re.search(self.INTS_SESSION_PATTERN, self.html).group(1) inputs[re.search(self.HIDDEN_INPUT_PATTERN, self.html).group(1)] = '1' inputs['confirmed_number'] = self.decryptCaptcha(captcha_url, cookies=True) inputs['action'] = '1' self.logDebug(inputs) self.html = self.load(url, decode=True, cookies=True, post=inputs) if self.WRONG_CAPTCHA_PATTERN in self.html: self.invalidCaptcha() else: break else: self.fail("Invalid captcha") download_url = re.search(self.DOWNLOAD_LINK_PATTERN, self.html).group(1) self.correctCaptcha() self.logDebug("Download URL: %s" % download_url) self.download(download_url) getInfo = create_getInfo(IfolderRu)
self.html = self.load(pyfile.url, decode=True) self.getFileInfo() # parse the name from the site and set attribute in pyfile parsed_vars = re.search(self.VAR_PATTERN, self.html) if parsed_vars is None: self.parseError("VARs") pyfile.name = parsed_vars.group('ID3') # download the file, destination is determined by pyLoad download_url = parsed_vars.group('Server') + "/download.php" self.log.debug("File:" + pyfile.name) self.log.debug("URL:" + download_url) self.download(download_url, post={ "ID1": parsed_vars.group('ID1'), "ID2": parsed_vars.group('ID2'), "ID3": parsed_vars.group('ID3'), "ID4": parsed_vars.group('ID4') }) # check download check = self.checkDownload({ "no_slots": "obsazen na 100 %" }) if check == "no_slots": self.retry(5, 600, "No free slots") create_getInfo(QuickshareCz)
'KB': 1, 'MB': 2, 'GB': 3 }[found.group(3)] self.logInfo( "Data left: %s %s (%d MB needed)" % (found.group(2), found.group(3), self.pyfile.size / 1048576)) if not data_left: found = re.search(self.PASSPORT_RENEW_PATTERN, self.html) renew = (found.group(1) + 60 * (found.group(2) + 60 * found.group(3))) if found else 600 self.retry(renew, 15, "Unable to get passport") self.handleDownload(False) def handleDownload(self, premium=False): # Find download link; found = re.search(self.DOWNLOAD_URL_PATTERN % (1 if premium else 2), self.html) msg = '%s download URL' % ('Premium' if premium else 'Free') if not found: self.parseError(msg) download_url = found.group(1) self.logDebug("%s: %s" % (msg, download_url)) self.download(download_url) getInfo = create_getInfo(MegasharesCom)
the Free Software Foundation; either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, see <http://www.gnu.org/licenses/>. @author: zoidberg """ import re from module.plugins.hoster.CoolshareCz import CoolshareCz from module.plugins.internal.SimpleHoster import create_getInfo class WarserverCz(CoolshareCz): __name__ = "WarserverCz" __type__ = "hoster" __pattern__ = r"http://(?:\w*\.)?warserver.cz/stahnout/(?P<ID>\d+)/.+" __version__ = "0.11" __description__ = """Warserver.cz""" __author_name__ = ("zoidberg") FILE_NAME_PATTERN = r'<h1.*?>(?P<N>[^<]+)</h1>' DOMAIN = "http://s01.warserver.cz" getInfo = create_getInfo(WarserverCz)
__authors__ = [("zapp-brannigan", "*****@*****.**"), ("Walter Purcaro", "*****@*****.**"), ("sraedler", "*****@*****.**")] INFO_PATTERN = r'title=\'.+?\'>(?P<N>.+?)</span><span class=\'light2\'> \((?P<S>\d+) (?P<U>[\w^_]+)\)<' HASHSUM_PATTERN = r'>(?P<T>MD5): (?P<H>\w+)' OFFLINE_PATTERN = r'<h1>Ooops!' LINK_PATTERN = r'var uri = "(.+?)"' TOKEN_PATTERN = r'var acc = (\d+)' WAIT_PATTERN = r'var XYZ = "(\d+)"' def setup(self): self.multiDL = True self.chunkLimit = 1 def handleFree(self, pyfile): b = re.search(self.LINK_PATTERN, self.html) if not b: self.error(_("File url")) c = re.search(self.TOKEN_PATTERN, self.html) if not c: self.error(_("File token")) self.link = b.group(1) + "/zzz/" + c.group(1) getInfo = create_getInfo(RemixshareCom)
recaptcha_key = unquote(found.group(1)) self.logDebug("RECAPTCHA KEY: %s" % recaptcha_key) recaptcha = ReCaptcha(self) inputs['recaptcha_challenge_field'], inputs['recaptcha_response_field'] = recaptcha.challenge(recaptcha_key) return 1 else: found = re.search(self.CAPTCHA_URL_PATTERN, self.html) if found: captcha_url = found.group(1) inputs['code'] = self.decryptCaptcha(captcha_url) return 2 else: found = re.search(self.CAPTCHA_DIV_PATTERN, self.html, re.S) if found: captcha_div = found.group(1) self.logDebug(captcha_div) numerals = re.findall('<span.*?padding-left\s*:\s*(\d+).*?>(\d)</span>', html_unescape(captcha_div)) inputs['code'] = "".join([a[1] for a in sorted(numerals, key = lambda num: int(num[0]))]) self.logDebug("CAPTCHA", inputs['code'], numerals) return 3 else: found = re.search(self.SOLVEMEDIA_PATTERN, self.html) if found: captcha_key = found.group(1) captcha = SolveMedia(self) inputs['adcopy_challenge'], inputs['adcopy_response'] = captcha.challenge(captcha_key) return 4 return 0 getInfo = create_getInfo(XFileSharingPro)
for _i in xrange(5): m = re.search(self.CAPTCHA_PATTERN, self.html) if m: url = urlparse.urljoin("http://crocko.com", m.group(1)) self.wait(m.group(2)) self.html = self.load(url) else: break m = re.search(self.FORM_PATTERN, self.html, 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) for _i in xrange(5): inputs['recaptcha_response_field'], inputs['recaptcha_challenge_field'] = recaptcha.challenge() self.download(action, post=inputs) if self.check_download({'captcha': recaptcha.KEY_AJAX_PATTERN}): self.captcha.invalid() else: break else: self.fail(_("No valid captcha solution received")) getInfo = create_getInfo(CrockoCom)
__type__ = "hoster" __pattern__ = r"http://(www\.)?catshare.net/\w{16}.*" __version__ = "0.01" __description__ = """CatShare.net Download Hoster""" __author_name__ = ("z00nx") __author_mail__ = ("*****@*****.**") FILE_INFO_PATTERN = r'<h3 class="pull-left"[^>]+>(?P<N>.*)</h3>\s+<h3 class="pull-right"[^>]+>(?P<S>.*)</h3>' FILE_OFFLINE_PATTERN = r'Podany plik zosta' SECONDS_PATTERN = 'var\s+count\s+=\s+(\d+);' RECAPTCHA_KEY = "6Lfln9kSAAAAANZ9JtHSOgxUPB9qfDFeLUI_QMEy" def handleFree(self): found = re.search(self.SECONDS_PATTERN, self.html) seconds = int(found.group(1)) self.logDebug("Seconds found", seconds) self.setWait(seconds + 1) self.wait() recaptcha = ReCaptcha(self) challenge, code = recaptcha.challenge(self.RECAPTCHA_KEY) post_data = {"recaptcha_challenge_field": challenge, "recaptcha_response_field": code} self.download(self.pyfile.url, post=post_data) check = self.checkDownload({"html": re.compile("\A<!DOCTYPE html PUBLIC")}) if check == "html": self.logDebug("Wrong captcha entered") self.invalidCaptcha() self.retry() getInfo = create_getInfo(CatShareNet)
r"(?:Delay between downloads must be not less than|Try again in)\s*(\d+)\s*(hour|min)", self.html) if found: wait_time = int(found.group(1)) * { "hour": 60, "min": 1 }[found.group(2)] else: found = re.search( r"You have reached your (daily|hourly) downloads limit", self.html) if found: wait_time = 60 else: return self.logDebug("Waiting %d minutes" % wait_time) self.setWait(wait_time * 60, True) self.wait() self.retry(max_tries=24) def getJsonResponse(self, url): response = self.load(url, decode=True) if not response.startswith('{'): self.retry() self.logDebug(url, response) return json_loads(response) getInfo = create_getInfo(RapidgatorNet)
if check: a = int(re.search(r'<script type="text/javascript">([^<]*?)(var a = (\d*);)', self.html).group(3)) k = int(re.search(r'<script type="text/javascript">([^<]*?)(\d*%(\d*))', self.html).group(3)) checksum = ((a + 3) % k) * ((a + 3) % 3) + 18 else: # This might work but is insecure # checksum = eval(re.search("((\d*)\s\%\s(\d*)\s\+\s(\d*)\s\%\s(\d*))", self.html).group(0)) m = re.search(r"((?P<a>\d*)\s%\s(?P<b>\d*)\s\+\s(?P<c>\d*)\s%\s(?P<k>\d*))", self.html) if not m: self.parseError("Unable to detect values to calculate direct link") a = int(m.group("a")) b = int(m.group("b")) c = int(m.group("c")) k = int(m.group("k")) if a == c: checksum = ((a % b) + (a % k)) else: checksum = ((a % b) + (c % k)) self.logInfo('Checksum: %s' % checksum) filename = re.search(r'>Name:</font>\s*<font [^>]*>(?P<N>[^<]+)</font><br />', self.html).group('N') url = "/d/%s/%s/%s" % (number, checksum, filename) self.logInfo(self.file_info['HOST'] + url) return self.file_info['HOST'] + url getInfo = create_getInfo(ZippyshareCom)
return swfdump def do_recaptcha(self): self.logDebug('Trying to solve captcha') captcha_key = re.search(self.CAPTCHA_KEY_PATTERN, self.html).group(1) shortencode = re.search(self.CAPTCHA_SHORTENCODE_PATTERN, self.html).group(1) url = re.search(self.CAPTCHA_DOWNLOAD_PATTERN, self.html).group(1) recaptcha = ReCaptcha(self) for i in range(5): challenge, code = recaptcha.challenge(captcha_key) response = json_loads(self.load(self.file_info['HOST'] + '/rest/captcha/test', post={'challenge': challenge, 'response': code, 'shortencode': shortencode})) self.logDebug("reCaptcha response : %s" % response) if response == True: self.correctCaptcha() break else: self.invalidCaptcha() else: self.fail("Invalid captcha") return url getInfo = create_getInfo(ZippyshareCom)
self.wantReconnect = False self.multiDL = True self.chunkLimit = -1 self.resumeDownload = True def handleFree(self): tokenlink = re.search(self.FILE_TOKEN_PATTERN, self.html) continuelink = re.search(self.FILE_CONTINUE_PATTERN, self.html) if (not tokenlink) or (not continuelink): self.fail('Plugin out of Date') wait = 60 found = re.search(self.FILE_WAIT_PATTERN, self.html) if found: wait = int(found.group(1)) self.html = self.load("http://www.nowdownload.eu" + str(tokenlink.group(1))) self.setWait(wait) self.wait() self.html = self.load("http://www.nowdownload.eu" + str(continuelink.group(1))) url = re.search(self.FILE_DOWNLOAD_LINK, self.html) if not url: self.fail('Download Link not Found (Plugin out of Date?)') self.logDebug('Download link: ' + str(url.group(1))) self.download(str(url.group(1))) getInfo = create_getInfo(NowDownloadEu)
self.wait() def check_file(self): #: Check download check = self.check_download({ "temp offline" : re.compile(r"^Soubor je do.*asn.* nedostupn.*$"), 'credit' : re.compile(r"^Nem.*te dostate.*n.* kredit.$"), "multi-dl" : re.compile(self.MULTIDL_PATTERN), 'captcha' : "<li>Zadaný ověřovací kód nesouhlasí!</li>" }) if check == "temp offline": self.fail(_("File not available - try later")) elif check == "credit": self.restart(nopremium=True) elif check == "multi-dl": self.wait(5 * 60, 12, _("Download limit reached")) elif check == "captcha": self.captcha.invalid() self.retry() return super(CzshareCom, self).check_file() getInfo = create_getInfo(CzshareCom)
out = self.js.eval(self.jscode) self.logDebug("URL", self.js.engine, out) if out.startswith('/download/'): return "http://turbobit.net%s" % out.strip() except Exception, e: self.logError(e) else: if self.retries >= 2: # retry with updated js self.delStorage("rtUpdate") else: self.retry() self.wait() def decrypt(self, data): cipher = ARC4.new( binascii.hexlify( 'E\x15\xa1\x9e\xa3M\xa0\xc6\xa0\x84\xb6H\x83\xa8o\xa0')) return binascii.unhexlify(cipher.encrypt(binascii.unhexlify(data))) def getLocalTimeString(self): lt = time.localtime() tz = time.altzone if lt.tm_isdst else time.timezone return "%s GMT%+03d%02d" % (time.strftime("%a %b %d %Y %H:%M:%S", lt), -tz // 3600, tz % 3600) getInfo = create_getInfo(TurbobitNet)
def handle_free(self, pyfile): m = re.search(self.CAPTCHA_PATTERN, self.html) if m is None: self.error(_("Captcha not found")) captcha = self.captcha.decrypt(urlparse.urljoin("http://uploadhero.co", m.group(1))) self.html = self.load(pyfile.url, get={'code': captcha}) m = re.search(self.LINK_FREE_PATTERN, self.html) if m: self.link = m.group(1) or m.group(2) self.wait(50) def check_errors(self): m = re.search(self.IP_BLOCKED_PATTERN, self.html) if m: self.html = self.load(urlparse.urljoin("http://uploadhero.co", m.group(1))) m = re.search(self.IP_WAIT_PATTERN, self.html) wait_time = (int(m.group(1)) * 60 + int(m.group(2))) if m else 5 * 60 self.wait(wait_time, True) self.retry() return super(UploadheroCom, self).check_errors() getInfo = create_getInfo(UploadheroCom)
get_data = {"type": "recaptcha"} get_data["challenge"], get_data[ "capture"] = recaptcha.challenge(captcha_key) response = json_loads( self.load("http://extabit.com/file/%s/" % fileID, get=get_data)) if "ok" in response: self.correctCaptcha() break else: self.invalidCaptcha() else: self.fail("Invalid captcha") else: self.parseError('Captcha') if not "href" in response: self.parseError('JSON') self.html = self.load("http://extabit.com/file/%s%s" % (fileID, response['href'])) m = re.search(self.DOWNLOAD_LINK_PATTERN, self.html) if not m: self.parseError('Download URL') url = m.group(1) self.logDebug("Download URL: " + url) self.download(url) getInfo = create_getInfo(ExtabitCom)
return "http://turbobit.net%s" % out.strip() except Exception, e: self.logError(e) else: if self.retries >= 2: # retry with updated js self.delStorage("rtUpdate") self.retry() def decrypt(self, data): cipher = ARC4.new(hexlify('E\x15\xa1\x9e\xa3M\xa0\xc6\xa0\x84\xb6H\x83\xa8o\xa0')) return unhexlify(cipher.encrypt(unhexlify(data))) def getLocalTimeString(self): lt = time.localtime() tz = time.altzone if lt.tm_isdst else time.timezone return "%s GMT%+03d%02d" % (time.strftime("%a %b %d %Y %H:%M:%S", lt), -tz // 3600, tz % 3600) def handlePremium(self): self.logDebug("Premium download as user %s" % self.user) self.downloadFile() def downloadFile(self): found = re.search(self.DOWNLOAD_URL_PATTERN, self.html) if not found: self.parseError("download link") self.url = "http://turbobit.net" + found.group('url') self.logDebug(self.url) self.download(self.url) getInfo = create_getInfo(TurbobitNet)
elif hasattr(m, 'group'): downloadURL = m.group('link') self.correctCaptcha() break else: self.fail('Unknown error - Plugin may be out of date') if not downloadURL: self.fail("No Download url retrieved/all captcha attempts failed") self.download(downloadURL, disposition=True) def handlePremium(self): header = self.load(self.pyfile.url, just_header=True) if header.has_key('location'): self.logDebug('DIRECT LINK from header: ' + header['location']) self.download(header['location']) else: self.html = self.load(self.pyfile.url, decode=True) self.getFileInfo() m = re.search(r'<a href="(?P<link>[^"]+)">Download ></a>', self.html) if not m: self.parseError('Unable to detect direct download url') else: self.logDebug('DIRECT URL from html: ' + m.group('link')) self.download(m.group('link'), disposition=True) getInfo = create_getInfo(EgoFilesCom)
self.header = self.req.http.header self.req.http.c.setopt(FOLLOWLOCATION, 1) m = re.search(r'Location\s*:\s*(.+)', self.header, re.I) if m is None: self.fail(_("File not found")) download_url = m.group(1).rstrip() #@TODO: Remove .rstrip() in 0.4.10 self.logDebug("FREE URL2:" + download_url) # check errors m = re.search(r'/chyba/(\d+)', download_url) if m: if m.group(1) == '1': self.retry(60, 2 * 60, "This IP is already downloading") elif m.group(1) == '2': self.retry(60, 60, "No free slots available") else: self.fail(_("Error %d") % m.group(1)) # download file self.download(download_url) def handlePremium(self, pyfile): download_url = '%s/download_premium.php' % self.jsvars['server'] data = dict((x, self.jsvars[x]) for x in self.jsvars if x in ("ID1", "ID2", "ID4", "ID5")) self.download(download_url, get=data) getInfo = create_getInfo(QuickshareCz)
NAME_PATTERN = r'(?:<title>|class="uc-name-size".*>)(?P<N>.+?)(?: - Google Drive</title>|</a> \()' OFFLINE_PATTERN = r'align="center"><p class="errorMessage"' LINK_FREE_PATTERN = r'"([^"]+uc\?.*?)"' def setup(self): self.multiDL = True self.resume_download = True self.chunk_limit = 1 def handle_free(self, pyfile): for _i in xrange(2): m = re.search(self.LINK_FREE_PATTERN, self.data) if m is None: return link = self.fixurl(link, "https://docs.google.com/") dl = self.isdownload(link, redirect=False) if not dl: self.data = self.load(link) else: self.link = dl break getInfo = create_getInfo(GoogledriveCom)
else: self.fail("No valid captcha code entered") #download url self.html = self.load("http://bezvadata.cz%s" % action, post=inputs) self.checkErrors() found = re.search(r'<a class="stahnoutSoubor2" href="(.*?)">', self.html) if not found: self.parseError("page2 URL") url = "http://bezvadata.cz%s" % found.group(1) self.logDebug("DL URL %s" % url) #countdown found = re.search(r'id="countdown">(\d\d):(\d\d)<', self.html) wait_time = (int(found.group(1)) * 60 + int(found.group(2)) + 1) if found else 120 self.wait(wait_time, False) self.download(url) def checkErrors(self): if 'images/button-download-disable.png' in self.html: self.longWait(5 * 60, 24) # parallel dl limit elif '<div class="infobox' in self.html: self.tempOffline() def loadcaptcha(self, data, *args, **kwargs): return data.decode("base64") getInfo = create_getInfo(BezvadataCz)
("chk_filesize", "bool", "Check file size" , True), ("max_wait" , "int" , "Reconnect if waiting time is greater than minutes", 10 )] __description__ = """Filepup.net hoster plugin""" __license__ = "GPLv3" __authors__ = [("zapp-brannigan", "*****@*****.**"), ("Walter Purcaro", "*****@*****.**")] NAME_PATTERN = r'>(?P<N>.+?)</h1>' SIZE_PATTERN = r'class="fa fa-archive"></i> \((?P<S>[\d.,]+) (?P<U>[\w^_]+)' OFFLINE_PATTERN = r'>This file has been deleted' LINK_FREE_PATTERN = r'(http://www\.filepup\.net/get/.+?)\'' def setup(self): self.multiDL = False self.chunk_limit = 1 def handle_free(self, pyfile): m = re.search(self.LINK_FREE_PATTERN, self.data) if m is not None: dl_link = m.group(1) self.download(dl_link, post={'task': "download"}) getInfo = create_getInfo(FilepupNet)
FILE_INFO_PATTERN = r'<span style="[^"]*" title="[^"]*">(?P<N>.*?) \((?P<S>[\d.]+) (?P<U>\w+)\)</span>' FILE_OFFLINE_PATTERN = r'<span style="[^"]*" title="File Not Found">File Not Found</span>' CHASH_PATTERN = r'<input type="hidden" name="chash" value="([^"]*)" />' DIRECT_LINK_PATTERN = r"clip: {\s*url: '(https?://(?:www\.)promptfile[^']*)'," def handleFree(self): # STAGE 1: get link to continue m = re.search(self.CHASH_PATTERN, self.html) if not m: self.parseError("Unable to detect chash") chash = m.group(1) self.logDebug("read chash %s" % chash) # continue to stage2 self.html = self.load(self.pyfile.url, decode=True, post={'chash': chash}) # STAGE 2: get the direct link m = re.search(self.DIRECT_LINK_PATTERN, self.html, re.MULTILINE | re.DOTALL) if not m: self.parseError("Unable to detect direct link") direct = m.group(1) self.logDebug('found direct link: ' + direct) self.download(direct, disposition=True) getInfo = create_getInfo(PromptfileCom)
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() getInfo = create_getInfo(Keep2ShareCc)
else: self.parseError("FORM: %s" % (inputs["op"] if "op" in inputs else "UNKNOWN")) def handleCaptcha(self, inputs): found = re.search(self.RECAPTCHA_URL_PATTERN, self.html) if found: recaptcha_key = unquote(found.group(1)) self.logDebug("RECAPTCHA KEY: %s" % recaptcha_key) recaptcha = ReCaptcha(self) inputs["recaptcha_challenge_field"], inputs["recaptcha_response_field"] = recaptcha.challenge(recaptcha_key) return 1 else: found = re.search(self.CAPTCHA_URL_PATTERN, self.html) if found: captcha_url = found.group(1) inputs["code"] = self.decryptCaptcha(captcha_url) return 2 else: found = re.search(self.CAPTCHA_DIV_PATTERN, self.html, re.S) if found: captcha_div = found.group(1) self.logDebug(captcha_div) numerals = re.findall("<span.*?padding-left\s*:\s*(\d+).*?>(\d)</span>", html_unescape(captcha_div)) inputs["code"] = "".join([a[1] for a in sorted(numerals, key=lambda num: int(num[0]))]) self.logDebug("CAPTCHA", inputs["code"], numerals) return 3 return 0 getInfo = create_getInfo(XFileSharingPro)
if m is None: self.error(_("LINK_FREE_PATTERN not found")) url = m.group(1) self.log_debug(('FREEUSER' if m.group(2) == "download" else 'GUEST') + ' URL', url) res = json.loads(self.load(urlparse.urljoin("http://115.com/", url), decode=False)) if "urls" in res: mirrors = res['urls'] elif "data" in res: mirrors = res['data'] else: mirrors = None for mr in mirrors: try: self.link = mr['url'].replace("\\", "") self.log_debug("Trying URL: " + self.link) break except Exception: pass else: self.fail(_("No working link found")) getInfo = create_getInfo(YibaishiwuCom)
download_url = found.group(1) self.logDebug(download_url) self.download(download_url) def checkWait(self): found = re.search(r"(?:Delay between downloads must be not less than|Try again in)\s*(\d+)\s*(hour|min)", self.html) if found: wait_time = int(found.group(1)) * {"hour": 60, "min": 1}[found.group(2)] else: found = re.search(r"You have reached your (daily|hourly) downloads limit", self.html) if found: wait_time = 60 else: return self.logDebug("Waiting %d minutes" % wait_time) self.setWait(wait_time * 60, True) self.wait() self.retry(max_tries=24) def getJsonResponse(self, url): response = self.load(url, decode=True) if not response.startswith('{'): self.retry() self.logDebug(url, response) return json_loads(response) getInfo = create_getInfo(RapidgatorNet)
INFO_PATTERN = r'<title>(?P<N>.+) \((?P<S>[\d.,]+) (?P<U>[\w^_]+)\)<' OFFLINE_PATTERN = r'<div class="alert alert-error"' IP_BLOCKED_PATTERN = ur'>Nasz serwis wykrył że Twój adres IP nie pochodzi z Polski.<' WAIT_PATTERN = r'var\scount\s=\s(\d+);' LINK_FREE_PATTERN = r'<form action="(.+?)" method="GET">' LINK_PREMIUM_PATTERN = r'<form action="(.+?)" method="GET">' def setup(self): self.multiDL = self.premium self.resume_download = True 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) getInfo = create_getInfo(CatShareNet)
self.account.relogin() self.retry(msg=_("User not logged in")) self.link = pyfile.url.rstrip('/') + "/download/" check = self.check_file({ 'login': re.compile(self.ERROR_PATTERN), 'json' : re.compile(r'\{"status":"error".*?"message":"(.*?)"') }) if check == "login" or (check == "json" and self.last_check.group(1) == "Access token expired"): self.account.relogin() self.retry(msg=_("Access token expired")) elif check == "json": self.fail(self.last_check.group(1)) def handle_free(self, pyfile): if re.search(self.DL_LIMIT_PATTERN, self.data): self.wait(5 * 60, 12, _("Download limit reached")) m = re.search(self.LINK_FREE_PATTERN, self.data) if m is None: self.error(_("LINK_FREE_PATTERN not found")) self.link = m.group(1) getInfo = create_getInfo(EuroshareEu)
class DataHu(SimpleHoster): __name__ = "DataHu" __type__ = "hoster" __version__ = "0.06" __status__ = "testing" __pattern__ = r'http://(?:www\.)?data\.hu/get/\w+' __config__ = [("activated" , "bool", "Activated" , True), ("use_premium" , "bool", "Use premium account if available" , True), ("fallback" , "bool", "Fallback to free download if premium fails" , True), ("chk_filesize", "bool", "Check file size" , True), ("max_wait" , "int" , "Reconnect if waiting time is greater than minutes", 10 )] __description__ = """Data.hu hoster plugin""" __license__ = "GPLv3" __authors__ = [("crash", None), ("stickell", "*****@*****.**")] INFO_PATTERN = ur'<title>(?P<N>.*) \((?P<S>[^)]+)\) let\xf6lt\xe9se</title>' OFFLINE_PATTERN = ur'Az adott f\xe1jl nem l\xe9tezik' LINK_FREE_PATTERN = r'<div class="download_box_button"><a href="(.+?)">' def setup(self): self.resume_download = True self.multiDL = self.premium getInfo = create_getInfo(DataHu)
if 'response' in params: self.correctCaptcha() link = unquote(found.group(1)) self.logDebug("LINK: %s" % link) break else: self.parseError('Download link') else: self.fail('No valid captcha response received') try: self.download(link, disposition=True) except: self.retry(wait_time=60) def handlePremium(self): if '<span class="html_download_api-gold_traffic_limit">' in self.html: self.logWarning("Download limit reached") self.retry(25, 60 * 60, "Download limit reached") elif 'onClick="show_gold_offer' in self.html: self.account.relogin(self.user) self.retry() link = unquote( re.search( '<div id="download_url">\s*<a href="(http://.+?\.depositfiles.com/.+?)"', self.html).group(1)) self.download(link, disposition=True) getInfo = create_getInfo(DepositfilesCom)
found = re.search(self.DOWNLOAD_URL_PATTERN, self.html) if found: if 'captcha_hash' in params: self.correctCaptcha() download_url = found.group(1) break found = re.search(self.CAPTCHA_PATTERN, self.html) if found: if 'captcha_hash' in params: self.invalidCaptcha() captcha_url1 = "http://www.sendspace.com/" + found.group(1) found = re.search(self.USER_CAPTCHA_PATTERN, self.html) captcha_url2 = "http://www.sendspace.com/" + found.group(1) params = {'captcha_hash': found.group(2), 'captcha_submit': 'Verify', 'captcha_answer': self.decryptCaptcha(captcha_url1) + " " + self.decryptCaptcha(captcha_url2)} else: params = {'download': "Regular Download"} self.logDebug(params) self.html = self.load(self.pyfile.url, post=params) else: self.fail("Download link not found") self.logDebug("Download URL: %s" % download_url) self.download(download_url) create_getInfo(SendspaceCom)
'error' : e.message} else: info = {'status' : 8, 'error' : _("Too many redirects")} return info def handle_free(self, pyfile): self.check_errors() url, inputs = self.parse_html_form('action="https://1fichier.com/\?[\w^_]+') if not url: return if "pass" in inputs: inputs['pass'] = self.get_password() inputs['submit'] = "Download" self.download(url, post=inputs) def handle_premium(self, pyfile): self.download(pyfile.url, post={'did': 0, 'dl_no_ssl': "on"}) getInfo = create_getInfo(OneFichierCom)
__description__ = """Veoh.com hoster plugin""" __author_name__ = "Walter Purcaro" __author_mail__ = "*****@*****.**" FILE_NAME_PATTERN = r'<meta name="title" content="(?P<N>.*?)"' FILE_OFFLINE_PATTERN = r'>Sorry, we couldn\'t find the video you were looking for' FILE_URL_REPLACEMENTS = [(__pattern__, r'http://www.veoh.com/watch/\g<ID>') ] SH_COOKIES = [(".veoh.com", "lassieLocale", "en")] def setup(self): self.resumeDownload = self.multiDL = True self.chunkLimit = -1 def handleFree(self): q = self.getConfig("quality") pattern = r'"fullPreviewHash%sPath":"(.+?)"' % q found = re.search(pattern, self.html) if found: self.pyfile.name += ".mp4" link = found.group(1).replace("\\", "") self.logDebug("Download link: " + link) self.download(link) else: self.fail("No %s quality video found" % q.lower()) getInfo = create_getInfo(VeohCom)
if found: if 'response' in params: self.correctCaptcha() link = unquote(found.group(1)) self.logDebug("LINK: %s" % link) break else: self.parseError('Download link') else: self.fail('No valid captcha response received') try: self.download(link, disposition=True) except: self.retry(wait_time=60) def handlePremium(self): if '<span class="html_download_api-gold_traffic_limit">' in self.html: self.logWarning("Download limit reached") self.retry(25, 3600, "Download limit reached") elif 'onClick="show_gold_offer' in self.html: self.account.relogin(self.user) self.retry() link = unquote( re.search('<div id="download_url">\s*<a href="(http://.+?\.depositfiles.com/.+?)"', self.html).group(1)) self.multiDL = True self.download(link, disposition=True) getInfo = create_getInfo(DepositfilesCom)
if 'location' in self.req.http.header: location = re.search(r'location: (\S+)', self.req.http.header).group(1) downloadURL = 'http://filer.net' + location self.correctCaptcha() break else: self.logInfo('Wrong captcha') self.invalidCaptcha() if not downloadURL: self.fail("No Download url retrieved/all captcha attempts failed") self.download(downloadURL, disposition=True) def handlePremium(self): header = self.load(self.pyfile.url, just_header=True) if 'location' in header: # Direct Download ON dl = self.pyfile.url else: # Direct Download OFF html = self.load(self.pyfile.url) m = re.search(self.DIRECT_LINK_PATTERN, html) if not m: self.parseError("Unable to detect direct link, try to enable 'Direct download' in your user settings") dl = 'http://filer.net' + m.group(1) self.logDebug('Direct link: ' + dl) self.download(dl, disposition=True) getInfo = create_getInfo(FilerNet)
for i in xrange(5): challenge, response = recaptcha.challenge(self.RECAPTCHA_KEY) post_data = { 'recaptcha_challenge_field': challenge, 'recaptcha_response_field': response, 'hash': hash_data } # Workaround for 0.4.9 just_header issue. In 0.5 clean the code using just_header self.req.http.c.setopt(pycurl.FOLLOWLOCATION, 0) self.load(self.pyfile.url, post=post_data) self.req.http.c.setopt(pycurl.FOLLOWLOCATION, 1) if 'location' in self.req.http.header: location = re.search(r'location: (\S+)', self.req.http.header).group(1) downloadURL = 'http://filer.net' + location self.correctCaptcha() break else: self.logInfo('Wrong captcha') self.invalidCaptcha() if not downloadURL: self.fail("No Download url retrieved/all captcha attempts failed") self.download(downloadURL, disposition=True) getInfo = create_getInfo(FilerNet)
1) if found else "6LdBbL8SAAAAAI0vKUo58XRwDd5Tu_Ze1DA7qTao" data['recaptcha_challenge_field'], data[ 'recaptcha_response_field'] = recaptcha.challenge( recaptcha_key) else: self.fail('Too bad...') download_url = self.html self.logDebug('Download URL', download_url) self.download(download_url) def checkErrors(self): found = re.search(self.PARALELL_PATTERN, self.html) if found: self.setWait(wait_time + 1, False) self.wait(300) self.retry() def doWait(self): found = re.search(self.WAIT_PATTERN, self.html) wait_time = int(found.group(1)) if found else 30 self.setWait(wait_time + 1, False) self.load('http://datei.to/ajax/download.php', post={'P': 'Ads'}) self.wait() getInfo = create_getInfo(DateiTo)
self.retry(max_tries=5, reason="Wrong captcha") def handlePremium(self): header = self.load(self.pyfile.url, just_header=True) if "location" in header: url = header["location"] else: self.html = self.load(self.pyfile.url) self.getFileInfo() # if self.CREDIT_PATTERN in self.html: self.logWarning("Not enough traffic left") self.resetAccount() else: found = re.search(self.PREMIUM_URL_PATTERN, self.html) if found: url = found.group(1) else: self.parseError("Premium URL") self.logDebug("PREMIUM URL: " + url) self.download(url, disposition=True) check = self.checkDownload({"credit": re.compile(self.CREDIT_PATTERN)}) if check == "credit": self.resetAccount() getInfo = create_getInfo(FastshareCz)
'wst' : ""}) if not re.search(r'<status>OK', api): info['status'] = 1 else: info['status'] = 2 info['name'] = re.search(r'<name>(.+?)<', api).group(1) info['size'] = re.search(r'<size>(.+?)<', api).group(1) return info def handle_free(self, pyfile): wst = self.account.get_data('wst') if self.account else None api_data = get_url("https://webshare.cz/api/file_link/", post={'ident': self.info['pattern']['ID'], 'wst': wst}) self.log_debug("API data: " + api_data) m = re.search('<link>(.+)</link>', api_data) if m is not None: self.link = m.group(1) def handle_premium(self, pyfile): return self.handle_free(pyfile) getInfo = create_getInfo(WebshareCz)
URL_REPLACEMENTS = [(__pattern__ + ".*", r'http://www.veoh.com/watch/\g<ID>')] COOKIES = [("veoh.com", "lassieLocale", "en")] def setup(self): self.resume_download = True self.multiDL = True self.chunk_limit = -1 def handle_free(self, pyfile): quality = self.get_config('quality') if quality == "Auto": quality = ("High", "Low") for q in quality: pattern = r'"fullPreviewHash%sPath":"(.+?)"' % q m = re.search(pattern, self.html) if m: pyfile.name += ".mp4" self.link = m.group(1).replace("\\", "") return else: self.log_info(_("No %s quality video found") % q.upper()) else: self.fail(_("No video found!")) getInfo = create_getInfo(VeohCom)
self.handle_errors(res, '#') url = res.split("#")[-1] return url def handle_errors(self, res, separator): self.log_debug("Checking response [%s]" % res) if "ERROR:Session timed out" in res: self.retry() elif "ERROR" in res: msg = res.split(separator)[-1] self.fail(msg) def handle_captcha_errors(self, res): self.log_debug("Result of captcha resolving [%s]" % res) if "SUCCESS" in res: self.captcha.correct() elif "ERROR:SESSION ERROR" in res: self.retry() else: self.retry_captcha() getInfo = create_getInfo(BitshareCom)
if response["dl"]: self.html = self.load('http://filecloud.io/download.html') found = re.search(self.DOWNLOAD_LINK_PATTERN % self.file_info['ID'], self.html) if not found: raise PluginParseError("Download URL") download_url = found.group(1) self.logDebug("Download URL: %s" % download_url) if "size" in self.file_info and self.file_info['size']: self.check_data = {"size": int(self.file_info['size'])} self.download(download_url) else: self.fail("Unexpected server response") def handlePremium(self): akey = self.account.getAccountData(self.user)['akey'] ukey = self.file_info['ID'] self.logDebug("Akey: %s | Ukey: %s" % (akey, ukey)) rep = self.load("http://api.filecloud.io/api-fetch_download_url.api", post={"akey": akey, "ukey": ukey}) self.logDebug("FetchDownloadUrl: " + rep) rep = json_loads(rep) if rep['status'] == 'ok': self.download(rep['download_url'], disposition=True) else: self.fail(rep['message']) getInfo = create_getInfo(FilecloudIo)
__author_name__ = ("zoidberg") FILE_NAME_PATTERN = r'<h1 id="filename"[^>]*>(?P<N>[^<]+)</h1>' FILE_SIZE_PATTERN = r'<strong id="FileSize_master">(?P<S>[0-9.]*) (?P<U>[kKMG])i?B</strong>' FILE_OFFLINE_PATTERN = r'<h1>File not found.</h1>' SHOW_WINDOW_PATTERN = r'<a href="([^?]+/(\d+)/\?do=(fileDownloadButton|relatedFileDownloadButton-\2)-showDownloadWindow)"' def setup(self): self.resumeDownload = self.multiDL = True if self.account else False self.chunkLimit = 1 def process(self, pyfile): if not self.account: self.fail("User not logged in") pyfile.url = re.search(self.__pattern__, pyfile.url).group(1) self.html = self.load(pyfile.url, decode=True) self.getFileInfo() if not self.checkTrafficLeft(): self.fail("Not enough traffic left for user %s." % self.user) found = re.search(self.SHOW_WINDOW_PATTERN, self.html) if not found: self.parseError('SHOW WINDOW') self.url = "http://www.hellshare.com" + found.group(1) self.logDebug("DOWNLOAD URL: " + self.url) self.download(self.url) getInfo = create_getInfo(HellshareCz)
self.correctCaptcha() self.link = m.group(1) break m = re.search(self.CAPTCHA_PATTERN, self.html) if m: if 'captcha_hash' in params: self.invalidCaptcha() captcha_url1 = "http://www.sendspace.com/" + m.group(1) m = re.search(self.USER_CAPTCHA_PATTERN, self.html) captcha_url2 = "http://www.sendspace.com/" + m.group(1) params = { 'captcha_hash': m.group(2), 'captcha_submit': 'Verify', 'captcha_answer': self.decryptCaptcha(captcha_url1) + " " + self.decryptCaptcha(captcha_url2) } else: params = {'download': "Regular Download"} self.logDebug(params) self.html = self.load(pyfile.url, post=params) else: self.fail(_("Download link not found")) getInfo = create_getInfo(SendspaceCom)
__name__ = "TwoSharedCom" __type__ = "hoster" __version__ = "0.17" __status__ = "testing" __pattern__ = r'http://(?:www\.)?2shared\.com/(account/)?(download|get|file|document|photo|video|audio)/.+' __config__ = [("activated" , "bool", "Activated" , True), ("use_premium" , "bool", "Use premium account if available" , True), ("fallback" , "bool", "Fallback to free download if premium fails" , True), ("chk_filesize", "bool", "Check file size" , True), ("max_wait" , "int" , "Reconnect if waiting time is greater than minutes", 10 )] __description__ = """2Shared.com hoster plugin""" __license__ = "GPLv3" __authors__ = [("zoidberg", "*****@*****.**")] NAME_PATTERN = r'<h1>(?P<N>.*)</h1>' SIZE_PATTERN = r'<span class="dtitle">File size:</span>\s*(?P<S>[\d.,]+) (?P<U>[\w^_]+)' OFFLINE_PATTERN = r'The file link that you requested is not valid\.|This file was deleted\.' LINK_FREE_PATTERN = r'window.location =\'(.+?)\';' def setup(self): self.resume_download = True self.multiDL = True getInfo = create_getInfo(TwoSharedCom)
"offline": re.compile(self.FILE_OFFLINE_PATTERN), "passwd": self.PASSWD_PATTERN, "server_error": 'src="http://img.ulozto.cz/error403/vykricnik.jpg"', #paralell dl, server overload etc. "not_found": "<title>Ulož.to</title>" }) if check == "wrong_captcha": self.delStorage("captcha_id") self.delStorage("captcha_text") self.invalidCaptcha() self.retry(reason="Wrong captcha code") elif check == "offline": self.offline() elif check == "passwd": self.fail("Wrong password") elif check == "server_error": self.logError("Server error, try downloading later") self.multiDL = False self.setWait(3600, True) self.wait() self.retry() elif check == "not_found": self.fail("Server error - file not downloadable") getInfo = create_getInfo(UlozTo)
NAME_PATTERN = r'<input type="hidden" name="name" value="(?P<N>.+?)">' SIZE_PATTERN = r'<b>Rozmiar:</b> (?P<S>[\d.,]+) (?P<U>[\w^_]+)<br>' OFFLINE_PATTERN = ur'Podany plik nie został odnaleziony\.\.\.' def setup(self): self.multiDL = True self.chunkLimit = 1 def handleFree(self, pyfile): m = re.search(r'<script src="([\w^_]+.php)"></script>', self.html) if m: jscript = self.load("http://hostuje.net/" + m.group(1)) m = re.search(r"\('(\w+\.php\?i=\w+)'\);", jscript) if m: self.load("http://hostuje.net/" + m.group(1)) else: self.error(_("unexpected javascript format")) else: self.error(_("script not found")) action, inputs = self.parseHtmlForm( pyfile.url.replace(".", "\.").replace("?", "\?")) if not action: self.error(_("form not found")) self.download(action, post=inputs) getInfo = create_getInfo(HostujeNet)