def fillServerApiData(self):
printDBG('EuroSportPlayer.fillServerApiData')
if self.serverApiData != {}:
return
serverApiData = {}
sts, data = self.getPage(self.getMainUrl())
if not sts: return False
jscode = ['var window={};function getStartupDeviceTypeString(){return "desktop";}\nwindow.requirejs_data={};requirejs=function(){if (2 == arguments.length) {window.requirejs_data.siteScripts=arguments[0];arguments[1]()} else {window.requirejs_data.scripts=arguments[0];}};requirejs.config=function(){window.requirejs_data.config=arguments[0];};']
markers = ['window.server_path','window.i18n_dictionary','window.locale','window.SPORTS_BY_ID','window.bamTrackingConfig','window.specialEvents','requirejs']
data = self.cm.ph.getAllItemsBeetwenNodes(data, ('<script', '>'), ('</script', '>'), False)
for item in data:
for m in markers:
if m in item:
jscode.append(item)
break
jscode.append('\nprint(JSON.stringify(window));')
ret = iptv_js_execute( '\n'.join(jscode) )
if ret['sts'] and 0 == ret['code']:
data = ret['data'].strip()
try:
serverApiData = byteify(json.loads(data))
clientId = serverApiData['server_path']['sdk']['clientId']
env = serverApiData['server_path']['sdk']['environment']
url = 'https://bam-sdk-configs.mlbam.net/v0.1/%s/browser/v2.1/windows/chrome/%s.json' % (clientId, env)
sts, data = self.getPage(url)
if not sts: return False
serverApiData['prod'] = byteify(json.loads(data))
except Exception:
printExc()
return
self.serverApiData = serverApiData
def getVideoLinks(self, videoUrl):
printDBG("TantiFilmOrg.getVideoLinks [%s]" % videoUrl)
urlTab = []
# mark requested link as used one
if len(self.cacheLinks.keys()):
key = self.cacheLinks.keys()[0]
for idx in range(len(self.cacheLinks[key])):
if videoUrl in self.cacheLinks[key][idx]['url']:
if not self.cacheLinks[key][idx]['name'].startswith('*'):
self.cacheLinks[key][idx][
'name'] = '*' + self.cacheLinks[key][idx]['name']
break
tries = 0
while tries < 4:
tries += 1
printDBG(">> tries [%d]" % tries)
if not self.cm.isValidUrl(videoUrl):
break
if 1 != self.up.checkHostSupport(videoUrl):
addParams = dict(self.defaultParams)
addParams['with_metadata'] = True
sts, data = self.getPage(videoUrl, addParams)
if sts:
videoUrl = data.meta['url']
jscode = [
'var document={},window=this;function typeOf(r){return{}.toString.call(r).match(/\s(\w+)/)[1].toLowerCase()}function jQuery(){return"function"==typeOf(arguments[0])&&arguments[0](),jQuery}jQuery.ready=jQuery,jQuery.attr=function(r,t){"src"==r&&print(t)},$=jQuery;'
]
tmp = self.cm.ph.getAllItemsBeetwenNodes(
data, ('<script', '>'), ('</script', '>'), False)
for item in tmp:
jscode.append(item)
ret = iptv_js_execute('\n'.join(jscode))
if ret['sts'] and 0 == ret['code']:
data = ret['data'].strip()
if self.cm.isValidUrl(data):
videoUrl = data
if 'hostvid.xyz' in self.up.getDomain(videoUrl):
sts, data = self.getPage(videoUrl)
if not sts: return []
videoUrl = self.cm.ph.getSearchGroups(
data,
'''<iframe[^>]+?src=['"]([^'^"]+?)['"]''',
ignoreCase=True)[0]
if self.cm.isValidUrl(videoUrl):
urlTab = self.up.getVideoLinkExt(videoUrl)
if len(urlTab):
break
try:
data = self.cm.ph.getSearchGroups(
data,
'''<iframe[^>]+?src=['"]([^'^"]+?)['"]''',
ignoreCase=True)[0]
if self.cm.isValidUrl(data):
videoUrl = data
except Exception:
printExc()
break
return urlTab
def _getSecurityData(self, data, params):
printDBG('MoonwalkParser._getSecurityData')
baseUrl = ''
sec_header = {'Referer':data.meta['url']}
post_data = {}
scriptUrl = self.cm.ph.getSearchGroups(data, '''<script[^>]+?src=['"]([^'^"]+?)['"]''')[0]
if scriptUrl.startswith('/'):
scriptUrl = self.baseUrl + scriptUrl
jscode = ['var iptv={onGetManifestSuccess:"",onGetManifestError:""},_={bind:function(){}},window=this;window._mw_adb=false,CryptoJS={AES:{},enc:{Utf8:{},Hex:{}}},CryptoJS.AES.encrypt=function(n,t,r){return JSON.stringify({data:n,password:t,salt:r})},CryptoJS.enc.Hex.parse=function(n){return{data:n,type:"hex"}},CryptoJS.enc.Utf8.parse=function(n){return{data:n,type:"utf-8"}};var $={ajax:function(n){return print(JSON.stringify(n)),{done:function(){},fail:function(){}}}},VideoBalancer=function(n){iptv.options=n};']
jscode.append('var navigator={userAgent:"%s"};' % self.HTTP_HEADER['User-Agent'])
data = self.cm.ph.getAllItemsBeetwenNodes(data, ('<script', '>'), ('</script', '>'), False)
for item in data:
jscode.append(item)
sts, data = self.cm.getPage(scriptUrl, params)
if sts:
item = "iptv.call = %s;iptv['call']();" % self._getFunctionCode(data.split('getVideoManifests:', 1)[-1])
jscode.append(item)
ret = iptv_js_execute( '\n'.join(jscode) )
if ret['sts'] and 0 == ret['code']:
printDBG(ret['data'])
try:
data = byteify( json.loads(ret['data']) )
baseUrl = data['url']
if baseUrl.startswith('/'):
baseUrl = self.baseUrl + baseUrl
for itemKey in data['data'].keys():
tmp = byteify( json.loads(data['data'][itemKey]) )
decrypted = tmp['data']['data']
key = tmp['password']['data']
iv = tmp['salt']['iv']['data']
printDBG('>>>> key: [%s]' % key)
printDBG('>>>> iv: [%s]' % iv)
if tmp['password']['type'] == 'hex':
key = unhexlify(key)
if tmp['salt']['iv']['type'] == 'hex':
iv = unhexlify(iv)
post_data[itemKey] = base64.b64encode(self.cryptoJS_AES_encrypt(decrypted, key, iv)) #.replace('+', ' ')
except Exception:
printExc()
return baseUrl, sec_header, post_data
def getLinksForVideo(self, cItem):
printDBG("MusicMp3Ru.getLinksForVideo [%s]" % cItem)
if self.jscode == []:
sts, data = self.getPage(self.getMainUrl())
if not sts: return []
scriptUrl = self.cm.ph.getSearchGroups(
data,
'''<script[^>]+?src=['"]([^'^"]*?/scripts\.js[^'^"]*?)['"]'''
)[0]
if scriptUrl == '': return []
sts, data = self.getPage(self.getFullUrl(scriptUrl))
if not sts: return []
jscode = [
'var iptvObj={%s};' %
self.cm.ph.getDataBeetwenMarkers(data, 'boo:', '},')[1]
]
jscode.append('var iptvArg="%s";')
jscode.append('print(iptvObj["boo"](iptvArg));')
self.jscode = jscode
playbackUrl = cItem['url']
rel = cItem['rel']
id = cItem['id']
cookieVal = self.cm.getCookieItem(self.COOKIE_FILE, 'SessionId')
jscode = list(self.jscode)
jscode[1] = jscode[1] % (id[5:] + cookieVal[8:])
jscode = '\n'.join(jscode)
ret = iptv_js_execute(jscode)
if ret['sts'] and 0 == ret['code']:
url = playbackUrl + '/' + ret['data'].strip() + "/" + rel
return [{
'name':
'direct',
'url':
strwithmeta(
url, {
'User-Agent': self.USER_AGENT,
'Referer': self.getMainUrl(),
'Cookie': 'SessionId=%s;' % cookieVal
}),
'need_resolve':
0
}]
return []
def uncensored(self, data):
cookieItems = {}
try:
jscode = base64.b64decode('''dmFyIGRvY3VtZW50ID0ge307DQp2YXIgd2luZG93ID0gdGhpczsNCnZhciBsb2NhdGlvbiA9ICJodHRwczovLzlhbmltZS50by8iOw0KU3RyaW5nLnByb3RvdHlwZS5pdGFsaWNzPWZ1bmN0aW9uKCl7cmV0dXJuICI8aT48L2k+Ijt9Ow0KU3RyaW5nLnByb3RvdHlwZS5saW5rPWZ1bmN0aW9uKCl7cmV0dXJuICI8YSBocmVmPVwidW5kZWZpbmVkXCI+PC9hPiI7fTsNClN0cmluZy5wcm90b3R5cGUuZm9udGNvbG9yPWZ1bmN0aW9uKCl7cmV0dXJuICI8Zm9udCBjb2xvcj1cInVuZGVmaW5lZFwiPjwvZm9udD4iO307DQpBcnJheS5wcm90b3R5cGUuZmluZD0iZnVuY3Rpb24gZmluZCgpIHsgW25hdGl2ZSBjb2RlXSB9IjsNCkFycmF5LnByb3RvdHlwZS5maWxsPSJmdW5jdGlvbiBmaWxsKCkgeyBbbmF0aXZlIGNvZGVdIH0iOw0KZnVuY3Rpb24gZmlsdGVyKCkNCnsNCiAgICBmdW4gPSBhcmd1bWVudHNbMF07DQogICAgdmFyIGxlbiA9IHRoaXMubGVuZ3RoOw0KICAgIGlmICh0eXBlb2YgZnVuICE9ICJmdW5jdGlvbiIpDQogICAgICAgIHRocm93IG5ldyBUeXBlRXJyb3IoKTsNCiAgICB2YXIgcmVzID0gbmV3IEFycmF5KCk7DQogICAgdmFyIHRoaXNwID0gYXJndW1lbnRzWzFdOw0KICAgIGZvciAodmFyIGkgPSAwOyBpIDwgbGVuOyBpKyspDQogICAgew0KICAgICAgICBpZiAoaSBpbiB0aGlzKQ0KICAgICAgICB7DQogICAgICAgICAgICB2YXIgdmFsID0gdGhpc1tpXTsNCiAgICAgICAgICAgIGlmIChmdW4uY2FsbCh0aGlzcCwgdmFsLCBpLCB0aGlzKSkNCiAgICAgICAgICAgICAgICByZXMucHVzaCh2YWwpOw0KICAgICAgICB9DQogICAgfQ0KICAgIHJldHVybiByZXM7DQp9Ow0KT2JqZWN0LmRlZmluZVByb3BlcnR5KGRvY3VtZW50LCAiY29va2llIiwgew0KICAgIGdldCA6IGZ1bmN0aW9uICgpIHsNCiAgICAgICAgcmV0dXJuIHRoaXMuX2Nvb2tpZTsNCiAgICB9LA0KICAgIHNldCA6IGZ1bmN0aW9uICh2YWwpIHsNCiAgICAgICAgcHJpbnQodmFsKTsNCiAgICAgICAgdGhpcy5fY29va2llID0gdmFsOw0KICAgIH0NCn0pOw0KQXJyYXkucHJvdG90eXBlLmZpbHRlciA9IGZpbHRlcjsNCiVzDQoNCg==''') % (data)
ret = iptv_js_execute( jscode )
if ret['sts'] and 0 == ret['code']:
printDBG(ret['data'])
data = ret['data'].split('\n')
for line in data:
line = line.strip()
if not line.endswith('=/'): continue
line = line.split(';')[0]
line = line.replace(' ', '').split('=')
if 2 != len(line): continue
cookieItems[line[0]] = line[1].split(';')[0]
except Exception:
printExc()
return cookieItems
def _fillOneConfig(self, cItem, data=None):
if data == None:
sts, data = self.getPage(cItem['url'])
if not sts: return
jscode = []
data = self.cm.ph.getAllItemsBeetwenNodes(data, ('<script', '>'),
('</script', '>'), False)
for item in data:
if '_oneconfig' in item:
jscode.append(item)
break
jscode.append('print(JSON.stringify(_oneconfig));')
ret = iptv_js_execute('\n'.join(jscode))
if ret['sts'] and 0 == ret['code']:
try:
self.oneconfig.update(
byteify(json.loads(ret['data'].strip()), '', True))
except Exception:
printExc()
def getVideoLinks(self, videoUrl):
printDBG("FilmeHD.getVideoLinks [%s]" % videoUrl)
videoUrl = strwithmeta(videoUrl)
urlTab = []
# mark requested link as used one
if len(self.cacheLinks.keys()):
for key in self.cacheLinks:
for idx in range(len(self.cacheLinks[key])):
if videoUrl in self.cacheLinks[key][idx]['url']:
if not self.cacheLinks[key][idx]['name'].startswith('*'):
self.cacheLinks[key][idx]['name'] = '*' + self.cacheLinks[key][idx]['name']
break
params = dict(self.defaultParams)
params['header'] = dict(params['header'])
params['header']['Referer'] = str(videoUrl.meta.get('Referer', self.getMainUrl()))
sts, data = self.getPage(videoUrl, params)
if not sts: return urlTab
url = self.getFullUrl(self.cm.ph.getSearchGroups(data, '''<iframe[^>]+?src=['"]([^"^']+?)['"]''', 1, True)[0])
if url == '':
jscode = ['window=this,window.outerWidth=640,window.innerWidth=640;var document=this;document.write=function(text){var startRe=new RegExp("(<script[^>]*?>)","i").exec(text),endRe=new RegExp("(</script[^>]*?>)","i").exec(text);null!=startRe&&null!=endRe?(text=text.replace(startRe[1],""),text=text.replace(endRe[1],""),text=text.replace(/var\s+/g,"this."),print(text),eval(text)):print(text)};']
data = re.compile('''<script[^>]+?src=['"]([^'^"]+?)['"]''', re.I).findall(data)
for item in data:
item = self.getFullUrl(item)
sts, item = self.getPage(item, params)
if sts: jscode.append(item)
ret = iptv_js_execute( '\n'.join(jscode) )
if ret['sts'] and 0 == ret['code']:
printDBG(ret['data'])
url = self.getFullUrl(self.cm.ph.getSearchGroups(ret['data'], '''<iframe[^>]+?src=['"]([^"^']+?)['"]''', 1, True)[0].replace('&', '&'))
if url != '':
urlTab = self.up.getVideoLinkExt(url)
return urlTab
def getVideoLinks(self, baseUrl):
printDBG("YifyTV.getVideoLinks [%s]" % baseUrl)
# mark requested link as used one
if len(self.cacheLinks.keys()):
for key in self.cacheLinks:
for idx in range(len(self.cacheLinks[key])):
if baseUrl in self.cacheLinks[key][idx]['url']:
if not self.cacheLinks[key][idx]['name'].startswith(
'*'):
self.cacheLinks[key][idx][
'name'] = '*' + self.cacheLinks[key][idx][
'name']
break
urlTab = []
baseUrl = strwithmeta(baseUrl)
imdbid = baseUrl.meta.get('imdbid', '')
sub_tracks = baseUrl.meta.get('external_sub_tracks', [])
header = dict(self.AJAX_HEADER)
#header['Referer'] = baseUrl.meta['Referer']
if 'sou' in baseUrl.meta:
souTab = [baseUrl.meta['sou']]
if souTab[0] == 'pic':
souTab.append('adr')
if souTab[0] == 'adr':
souTab.append('pic')
for sou in souTab:
post_data = {'fv': '27', 'url': baseUrl, 'sou': sou}
url = 'https://ymovies.tv/playerlite/pk/pk/plugins/player_p2.php'
sts, data = self.getPage(url, {'header': header}, post_data)
if not sts: return []
printDBG(
"+++++++++++++++++++++++ data ++++++++++++++++++++++++")
printDBG(data)
printDBG(
"+++++++++++++++++++++++++++++++++++++++++++++++++++++++")
try:
attempt = 0
while attempt < 3:
attempt += 1
printDBG(data)
if 'jscode' in data:
try:
data = byteify(json.loads(data))[0]['jscode'][
1:-1] #.replace('eval(', 'print(')
jsTab = ['']
jsTab.append(
'''var iptv_href="%s"; var iptv_domain="%s"; var iptv_video_id="%s"; var iptv_jwpath="%s";\n'''
% (self.getMainUrl(),
self.up.getDomain(
self.getMainUrl()), imdbid, url))
jsTab.append(
base64.b64decode(
'''ZnVuY3Rpb24gU2hvd0Rpdigpe31mdW5jdGlvbiBzaG93aUZyYW1lKCl7cHJpbnQoYXJndW1lbnRzWzBdKX1mdW5jdGlvbiBnZXRKd1BhdGgoKXtyZXR1cm4gaXB0dl9qd3BhdGh9ZnVuY3Rpb24gZ2V0X3BhcmFtc19ub19zb3JjZXMoKXtyZXR1cm4gaXB0dl92aWRlb19pZH1mdW5jdGlvbiBzZXRUaW1lb3V0KHQsbil7aWYoaXB0dl9kaXJlY3QpdHJ5e3QoKX1jYXRjaChlKXtwcmludCgiXG4iKX1lbHNlIHRoaXMudHJ5dXAoKX12YXIgZG9jdW1lbnQ9e30sd2luZG93PXRoaXMsbG9jYXRpb249e307bG9jYXRpb24uaHJlZj1pcHR2X2hyZWYsbG9jYXRpb24uaG9zdG5hbWU9aXB0dl9kb21haW4sbG9jYXRpb24udG9TdHJpbmc9ZnVuY3Rpb24oKXtyZXR1cm4gaXB0dl9ocmVmfSxkb2N1bWVudC5sb2NhdGlvbj1sb2NhdGlvbjt2YXIgZWxlbWVudD1mdW5jdGlvbih0KXt0aGlzLnRleHQ9ZnVuY3Rpb24oKXtyZXR1cm4ibm9uZSJ9LHRoaXMuZmlyc3Q9ZnVuY3Rpb24oKXtyZXR1cm4gbmV3IGVsZW1lbnR9fSwkPWZ1bmN0aW9uKHQpe3JldHVybiBuZXcgZWxlbWVudCh0KX0scGxheWVybW9kZT0iIixzb3VyY2VTZWxlY3RlZD0wLHNvdXJjZXM9W3tzdWJfZGVsYXk6MCxzdWJfZmFjdG9yOjF9XTskLmdldD1mdW5jdGlvbigpe3JldHVybiBwcmludChhcmd1bWVudHNbMF0pLHtkb25lOlNob3dEaXYsZXJyb3I6U2hvd0Rpdn19LCQucG9zdD1mdW5jdGlvbigpe3ByaW50KCJcbklQVFZfUE9TVF9TVEFSVFxuIikscHJpbnQoSlNPTi5zdHJpbmdpZnkoe3VybDphcmd1bWVudHNbMF0scGFyYW1zOmFyZ3VtZW50c1sxXX0pKSxwcmludCgiXG5JUFRWX1BPU1RfRU5EXG4iKX07'''
))
jsTab.append('var iptv_fun = %s; iptv_fun();' %
data)
for iptv_direct in ["false", "true"]:
jsTab[
0] = 'var iptv_direct = %s;' % iptv_direct
jscode = '\n'.join(jsTab)
printDBG(
"+++++++++++++++++++++++ CODE ++++++++++++++++++++++++"
)
printDBG(jscode)
printDBG(
"+++++++++++++++++++++++++++++++++++++++++++++++++++++++"
)
ret = iptv_js_execute(jscode)
if not ret['sts'] or 0 != ret['code']:
ret = iptv_js_execute(
jscode.replace('eval(', 'print('))
if ret['sts'] and 0 == ret['code']:
decoded = ret['data'].strip()
printDBG('DECODED DATA -> [%s]' %
decoded)
data = decoded
break
if 'jscode' in data:
data = data[data.
find("["):data.rfind("]") + 1]
data = byteify(json.loads('"%s"' % data))
continue
except Exception:
printExc()
if 'IPTV_POST_START' in data:
data = self.cm.ph.getDataBeetwenMarkers(
data, 'IPTV_POST_START', 'IPTV_POST_END',
0)[1]
try:
tmp = byteify(json.loads(data.strip()))
sts, data = self.getPage(
tmp['url'], {
'header': header,
'raw_post_data': True
}, tmp['params'])
if not sts: return []
tmp = byteify(json.loads(data))
for hostDomain in tmp['hosts']:
urlTab.append({
'name':
hostDomain,
'url':
'http://%s%s' %
(hostDomain, tmp['path'])
})
if len(urlTab): break
except Exception:
printExc()
g3 = self.cm.ph.getSearchGroups(
data + '&', '''[&\?]g3=([^&]+?)&''')[0]
emb = self.cm.ph.getSearchGroups(
data + '&', '''[&\?]emb=([^&^\*]+?)[&\*]''')[0]
if emb != '': data = urllib.unquote(emb)
if g3 != '':
post_data = {
'fv': '0',
'g3': urllib.unquote(g3)
}
url = 'https://ymovies.tv/playerlite/pk/pk/plugins/player_g3.php'
sts, data = self.getPage(
url, {'header': header}, post_data)
if not sts: return []
printDBG(data)
elif self.cm.isValidUrl(
data) and 1 == self.up.checkHostSupport(
data):
urlTab = self.up.getVideoLinkExt(data)
break
else:
if 'showiFrame(' in data:
url = urllib.unquote(
self.cm.ph.getDataBeetwenMarkers(
data, "emb='+'", "'", False)[1])
tmp = url.split('sub.file')
url = tmp[0]
subTrack = urllib.unquote(tmp[1])
if url.startswith('//'):
url = 'http:' + url
if subTrack.startswith('//'):
subTrack = 'http:' + subTrack
tmpUrlTab = self.up.getVideoLinkExt(url)
if self.cm.isValidUrl(subTrack):
format = subTrack[-3:]
for idx in range(len(tmpUrlTab)):
tmpUrlTab[idx][
'url'] = strwithmeta(
tmpUrlTab[idx]['url'], {
'external_sub_tracks':
[{
'title': '',
'url': subTrack,
'lang': 'en',
'format': format
}]
})
urlTab.extend(tmpUrlTab)
printDBG(urlTab)
break
if 'sources[sourceSelected]["paramId"]' in data:
data = data.replace('"+"',
'').replace(' ', '')
paramSite = self.cm.ph.getSearchGroups(
data,
'sources\[sourceSelected\]\["paramSite"\]="([^"]+?)"'
)[0]
data = self.cm.ph.getSearchGroups(
data,
'sources\[sourceSelected\]\["paramId"\]="([^"]+?)"'
)[0]
printDBG(
'data ------------------------- [%s]' %
data)
if data.startswith('enc'):
encrypted = base64.b64decode(data[3:])
key = unhexlify(
base64.b64decode(
'MzAzOTM4NzMzOTM3MzU0MTMxMzIzMzczMzEzMzM1NjQ2NDY2Njc3NzQ4MzczODM0MzczNTMzMzQzNjcyNjQ3Nw=='
))
iv = unhexlify(
base64.b64decode(
'NWE0MTRlMzEzNjMzNjk2NDZhNGM1MzUxMzU0YzY0MzU='
))
cipher = AES_CBC(key=key,
padding=noPadding(),
keySize=32)
data = cipher.decrypt(
encrypted, iv).split('\x00')[0]
if 'ucl' == paramSite:
urlTab.extend(
self.up.getVideoLinkExt(
"https://userscloud.com/embed-"
+ data + "-1280x534.html"))
elif 'tus' == paramSite:
urlTab.extend(
self.up.getVideoLinkExt(
"https://tusfiles.net/embed-"
+ data +
"-1280x534.html?v=34"))
elif 'up' == paramSite:
urlTab.extend(
self.up.getVideoLinkExt(
"http://uptobox.com/" +
data))
break
if '("' in data:
data = self.cm.ph.getDataBeetwenMarkers(
data, '(', ')', False)[1]
data = byteify(json.loads(data))
if isinstance(data, basestring):
data = byteify(json.loads(data))
printDBG(data)
for item in data:
#printDBG('++++++++++++++++++++++\n%s\n++++++++++++++++++++++' % item)
if (item.get('type', '').startswith('video/')
or item.get('type', '').startswith(
'application/x-shockwave-flash')
) and self.cm.isValidUrl(item.get('url', '')):
urlTab.append({
'name':
'{0}x{1}'.format(item.get('height', ''),
item.get('width', '')),
'url':
item['url'],
'need_resolve':
0
})
break
except Exception:
SetIPTVPlayerLastHostError(
'The Mirror is broken.\nIf available you can choose other source.'
)
printExc()
return []
if len(urlTab): break
elif self.cm.isValidUrl(baseUrl):
urlTab = self.up.getVideoLinkExt(baseUrl)
printDBG(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
printDBG(urlTab)
for idx in range(len(urlTab)):
subs = list(
strwithmeta(urlTab[idx]['url']).meta.get(
'external_sub_tracks', []))
subs.extend(sub_tracks)
urlTab[idx]['url'] = strwithmeta(urlTab[idx]['url'],
{'external_sub_tracks': subs})
printDBG(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
printDBG(urlTab)
return urlTab
def getLinksForVideo(self, cItem):
printDBG("YifyTV.getLinksForVideo [%s]" % cItem)
urlTab = self.cacheLinks.get(cItem['url'], [])
if len(urlTab): return urlTab
url = cItem['url']
if not url.endswith('/'): url += '/'
sts, data = self.getPage(url + 'watching/?playermode=')
if not sts: return urlTab
printDBG("+++++++++++++++++++++++ data ++++++++++++++++++++++++")
printDBG(data)
printDBG("+++++++++++++++++++++++++++++++++++++++++++++++++++++++")
trailer = self.cm.ph.getDataBeetwenReMarkers(
data, re.compile('''<a[^>]+?class=['"]video'''),
re.compile('''</a>'''))[1]
trailerUrl = self.cm.ph.getSearchGroups(
trailer, '''href=['"](https?://[^'^"]+?)['"]''')[0]
imdbid = self.cm.ph.getSearchGroups(
data, '''var\s+imdbid\s*=\s*['"]([^'^"]+?)['"]''')[0]
jscode = '$ = function(){return {ready:function(){}}};\n' + self.cm.ph.getDataBeetwenMarkers(
data, 'function autoPlay()', '</script>')[1][:-9]
try:
jscode = base64.b64decode(
'''dmFyIGRvY3VtZW50ID0ge307DQp2YXIgd2luZG93ID0gdGhpczsNCnZhciBsb2NhdGlvbiA9IHt9Ow0KbG9jYXRpb24uaG9zdG5hbWUgPSAiJXMiOw0KbG9jYXRpb24udG9TdHJpbmcgPSBmdW5jdGlvbigpew0KICAgICAgICAgICAgICAgICAgICAgIHJldHVybiAiJXMiOw0KICAgICAgICAgICAgICAgICAgICB9Ow0KJXM7DQoNCnByaW50KHdpbmRvdy5wYXJhbWV0cm9zKQ=='''
) % (self.up.getDomain(
self.getMainUrl()), self.getMainUrl(), jscode)
printDBG("+++++++++++++++++++++++ CODE ++++++++++++++++++++++++")
printDBG(jscode)
printDBG("+++++++++++++++++++++++++++++++++++++++++++++++++++++++")
ret = iptv_js_execute(jscode)
if ret['sts'] and 0 == ret['code']:
decoded = ret['data'].strip()
printDBG('DECODED DATA -> [%s]' % decoded)
data = decoded
except Exception:
printExc()
sub_tracks = []
subLangs = self.cm.ph.getSearchGroups(data, '&sub=([^&]+?)&')[0]
if subLangs == '':
tmp = re.compile("\=([^&]*?)&").findall(data)
for it in tmp:
for e in ['PT2', 'EN', 'FR', 'ES']:
if e in it:
subLangs = it
break
if '' != subLangs:
break
if subLangs != '':
subID = self.cm.ph.getSearchGroups(data, '&id=(tt[^&]+?)&')[0]
if subID == '':
subID = self.cm.ph.getSearchGroups(data, '&pic=(tt[^&]+?)&')[0]
subLangs = subLangs.split(',')
for lang in subLangs:
if subID != '':
sub_tracks.append({
'title':
lang,
'url':
'https://ymovies.tv/player/bajarsub.php?%s_%s' %
(subID, lang),
'lang':
lang,
'format':
'srt'
})
data = data.split('&')
idx = 1
for item in data:
tmp = item.split('=')
if len(tmp) != 2: continue
if tmp[1].endswith('enc'):
url = strwithmeta(
tmp[1], {
'Referer': cItem['url'],
'sou': tmp[0],
'imdbid': imdbid,
'external_sub_tracks': sub_tracks
})
urlTab.append({
'name': _('Mirror') + ' %s' % idx,
'url': url,
'need_resolve': 1
})
elif '' != self.VIDEO_HOSTINGS_MAP.get(tmp[0], ''):
url = self.VIDEO_HOSTINGS_MAP[tmp[0]].format(tmp[1])
url = strwithmeta(
url, {
'Referer': cItem['url'],
'imdbid': imdbid,
'external_sub_tracks': sub_tracks
})
urlTab.append({
'name':
_('Mirror') + ' %s [%s]' % (idx, self.up.getHostName(url)),
'url':
url,
'need_resolve':
1
})
idx += 1
if len(urlTab):
self.cacheLinks[cItem['url']] = urlTab
if self.cm.isValidUrl(trailerUrl) and 1 == self.up.checkHostSupport(
trailerUrl):
urlTab.insert(
0, {
'name': self.cleanHtmlStr(trailer),
'url': trailerUrl,
'need_resolve': 1
})
return urlTab
def getPage(self, baseUrl, addParams={}, post_data=None):
if addParams == {}:
addParams = dict(self.defaultParams)
proxy = config.plugins.iptvplayer.yify_proxy.value
if proxy != 'None':
if proxy == 'proxy_1':
proxy = config.plugins.iptvplayer.alternative_proxy1.value
else:
proxy = config.plugins.iptvplayer.alternative_proxy2.value
addParams = dict(addParams)
addParams.update({'http_proxy': proxy})
def _getFullUrl(url):
if url == '': return ''
if self.cm.isValidUrl(url):
return url
else:
return urlparse.urljoin(baseUrl, url)
addParams['cloudflare_params'] = {
'domain': self.up.getDomain(baseUrl),
'cookie_file': self.COOKIE_FILE,
'User-Agent': self.USER_AGENT,
'full_url_handle': _getFullUrl
}
url = baseUrl
urlParams = deepcopy(addParams)
urlData = deepcopy(post_data)
unloadUrl = None #
tries = 0
removeCookieItems = False
while tries < 20:
tries += 1
sts, data = self.cm.getPageCFProtection(url, urlParams, urlData)
if not sts: return sts, data
if unloadUrl != None:
self.cm.getPageCFProtection(unloadUrl, urlParams)
unloadUrl = None
if 'sucuri_cloudproxy' in data:
cookieItems = {}
jscode = self.cm.ph.getDataBeetwenNodes(
data, ('<script', '>'), ('</script', '>'), False)[1]
if 'eval' in jscode:
jscode = '%s\n%s' % (base64.b64decode(
'''dmFyIGlwdHZfY29va2llcz1bXSxkb2N1bWVudD17fTtPYmplY3QuZGVmaW5lUHJvcGVydHkoZG9jdW1lbnQsImNvb2tpZSIse2dldDpmdW5jdGlvbigpe3JldHVybiIifSxzZXQ6ZnVuY3Rpb24obyl7bz1vLnNwbGl0KCI7IiwxKVswXS5zcGxpdCgiPSIsMiksb2JqPXt9LG9ialtvWzBdXT1vWzFdLGlwdHZfY29va2llcy5wdXNoKG9iail9fSk7dmFyIHdpbmRvdz10aGlzLGxvY2F0aW9uPXt9O2xvY2F0aW9uLnJlbG9hZD1mdW5jdGlvbigpe3ByaW50KEpTT04uc3RyaW5naWZ5KGlwdHZfY29va2llcykpfTs='''
), jscode)
ret = iptv_js_execute(jscode)
if ret['sts'] and 0 == ret['code']:
try:
cookies = byteify(json.loads(ret['data'].strip()))
for cookie in cookies:
cookieItems.update(cookie)
except Exception:
printExc()
self.defaultParams['cookie_items'] = cookieItems
urlParams['cookie_items'] = cookieItems
removeCookieItems = False
sts, data = self.cm.getPageCFProtection(
url, urlParams, urlData)
# remove not needed used cookie
if removeCookieItems:
self.defaultParams.pop('cookie_items', None)
self.cm.clearCookie(self.COOKIE_FILE, removeNames=['___utmvc'])
printDBG(data)
return sts, data
return self.cm.getPageCFProtection(baseUrl, addParams, post_data)
def getLinksForVideo(self, cItem):
printDBG("ArconaitvME.getLinksForVideo [%s]" % cItem)
urlsTab = []
sts, data = self.getPage(cItem['url'])
if not sts: return urlsTab
playerUrl = self.cm.ph.getSearchGroups(
data,
'''<source[^>]*?src=['"](https?:[^"^']+?\.m3u8[^"^']*?)['"]''',
1,
ignoreCase=True)[0]
try:
playerUrl = byteify(json.loads('"%s"' % playerUrl))
except Exception:
printExc()
if not self.cm.isValidUrl(playerUrl):
playerUrl = self.cm.ph.getSearchGroups(
data,
'''"sources"\s*:\s*[^\]]*?"src"\s*:\s*"(https?:[^"]+?\.m3u8[^"]*?)"''',
1,
ignoreCase=True)[0]
try:
playerUrl = byteify(json.loads('"%s"' % playerUrl))
except Exception:
printExc()
if not self.cm.isValidUrl(playerUrl):
playerUrl = self.cm.ph.getSearchGroups(
data, '''"(https?:[^"]+?\.m3u8[^"]*?)"''', 1,
ignoreCase=True)[0]
try:
playerUrl = byteify(json.loads('"%s"' % playerUrl))
except Exception:
printExc()
if not self.cm.isValidUrl(playerUrl):
scripts = []
tmp = self.cm.ph.getAllItemsBeetwenNodes(data, ('<script', '>'),
('</script', '>'), False)
for item in tmp:
if 'eval(' not in item and 'ﾟωﾟﾉ=' not in item: continue
scripts.append(item.strip())
try:
jscode = base64.b64decode(
'''dmFyIGRvY3VtZW50PXt9LHdpbmRvdz10aGlzLGVsZW1lbnQ9ZnVuY3Rpb24oZSl7dGhpcy5fbmFtZT1lLHRoaXMuc2V0QXR0cmlidXRlPWZ1bmN0aW9uKGUsdCl7InNyYyI9PWUmJih0aGlzLnNyYz10KX0sT2JqZWN0LmRlZmluZVByb3BlcnR5KHRoaXMsInNyYyIse2dldDpmdW5jdGlvbigpe3JldHVybiB0aGlzLl9zcmN9LHNldDpmdW5jdGlvbihlKXt0aGlzLl9zcmM9ZSxwcmludChlKX19KX0sJD1mdW5jdGlvbihlKXtyZXR1cm4gbmV3IGVsZW1lbnQoZSl9O2RvY3VtZW50LmdldEVsZW1lbnRCeUlkPWZ1bmN0aW9uKGUpe3JldHVybiBuZXcgZWxlbWVudChlKX0sZG9jdW1lbnQuZ2V0RWxlbWVudHNCeVRhZ05hbWU9ZnVuY3Rpb24oZSl7cmV0dXJuW25ldyBlbGVtZW50KGUpXX07'''
)
ret = iptv_js_execute(jscode + '\n'.join(scripts))
if ret['sts'] and 0 == ret['code']:
decoded = ret['data'].strip()
if decoded.split('?', 1)[0].endswith('.m3u8'):
playerUrl = decoded
except Exception:
printExc()
playerUrl = strwithmeta(
playerUrl, {
'User-Agent': self.HEADER['User-Agent'],
'Referer': cItem['url'],
'Origin': self.getMainUrl()
})
if self.cm.isValidUrl(playerUrl):
tmp = getDirectM3U8Playlist(playerUrl, checkContent=True)
for item in tmp:
item['need_resolve'] = 0
urlsTab.append(item)
return urlsTab
def getVideoLinks(self, videoUrl):
printDBG("Altadefinizione.getVideoLinks [%s]" % videoUrl)
videoUrl = strwithmeta(videoUrl)
urlTab = []
# mark requested link as used one
if len(self.cacheLinks.keys()):
for key in self.cacheLinks:
for idx in range(len(self.cacheLinks[key])):
if videoUrl in self.cacheLinks[key][idx]['url']:
if not self.cacheLinks[key][idx]['name'].startswith('*'):
self.cacheLinks[key][idx]['name'] = '*' + self.cacheLinks[key][idx]['name']
break
urlParams = dict(self.defaultParams)
urlParams['header'] = dict(urlParams['header'])
urlParams['header']['Referer'] = str(videoUrl.meta.get('Referer', self.getMainUrl()))
sts, data = self.getPage(videoUrl, urlParams)
if not sts: return urlTab
cUrl = data.meta['url']
playerData = self.cm.ph.getDataBeetwenNodes(data, ('<input', '>', 'urlEmbed'), ('<iframe', '>'))[1]
if playerData == '':
printDBG('Missig player data')
return urlTab
playerData = self.cm.ph.getSearchGroups(playerData, '''value=['"]([^'^"]+?)['"]''')[0]
printDBG('PLAYER_DATA: %s\n' % playerData)
if self.cacheJSCode == '':
jsUrl = ''
data = re.compile('''<script[^>]+?src=['"]([^'^"]+?)['"]''', re.I).findall(data)
for item in data:
if 'filmlive' not in item: continue
jsUrl = self.cm.getFullUrl(item, self.cm.getBaseUrl(cUrl))
break
sts, data = self.getPage(jsUrl, urlParams)
if not sts: return urlTab
try:
idxS = data.find('function clearify')
num = 1
idx = data.find('{', idxS)
for idx in range(idx+1, len(data), 1):
if data[idx] == '{': num += 1
if data[idx] == '}': num -= 1
if num == 0:
printDBG("JS_CODE_IDX: [%s:%s]" % (idxS, idx))
break
jscode = data[idxS:idx+1]
printDBG('JS_CODE: %s\n' % jscode)
self.cacheJSCode = jscode
except Exception:
printExc()
jscode = ['var $={base64:function(not_used,e){e.length%4==3&&(e+="="),e.length%4==2&&(e+="=="),e=Duktape.dec("base64",e),decText="";for(var t=0;t<e.byteLength;t++)decText+=String.fromCharCode(e[t]);return decText},trim:function(e){return null==e?"":(e+"").replace(n,"")}};', self.cacheJSCode, 'print(clearify("%s"))' % playerData]
ret = iptv_js_execute( '\n'.join(jscode) )
if ret['sts'] and 0 == ret['code']:
printDBG(ret['data'])
urlTab = self.up.getVideoLinkExt(ret['data'])
return urlTab
def getVideoLinks(self, videoUrl):
printDBG("MRPiracyGQ.getVideoLinks [%s]" % videoUrl)
errorMsgTab = []
urlTab = []
# mark requested link as used one
if len(self.cacheLinks.keys()):
for key in self.cacheLinks:
for idx in range(len(self.cacheLinks[key])):
if videoUrl in self.cacheLinks[key][idx]['url']:
if not self.cacheLinks[key][idx]['name'].startswith('*'):
self.cacheLinks[key][idx]['name'] = '*' + self.cacheLinks[key][idx]['name']
break
if self.cm.isValidUrl(videoUrl):
return self.up.getVideoLinkExt(videoUrl)
playerData = strwithmeta(videoUrl).meta
linkId = ''
imdbId = ''
try:
tmp = []
for it in ['playertype', 'episodio', 'id']:
tmp.append(playerData.get(it, ''))
imdbId = self.cm.ph.getSearchGroups(playerData['ref_url'], '''imdb=(tt[0-9]+)''')[0]
tmp.insert(0, imdbId)
linkId = '_'.join(tmp)
except Exception:
printExc()
printDBG(">>> linkId[%s]" % linkId)
hostUrl = MRPiracyGQ.LINKS_CACHE.get(linkId, '')
if hostUrl == '' and config.plugins.iptvplayer.mrpiracy_linkcache.value:
hostUrl = ReadTextFile(GetCacheSubDir('mrpiracy', linkId))[1]
if hostUrl == '':
try:
jscode = playerData.pop('jscode', '')
jscode += '''var iptv_fake_element={hide:function(){},show:function(){},addClass:function(){},removeClass:function(){}};playertype="iptv_player_data";var iptv_player_data=''' + json.dumps(playerData) + ''';$=function(){return 1==arguments.length&&arguments[0].endsWith(playertype)?{data:function(a){return iptv_player_data[a]}}:iptv_fake_element},$.ajax=function(){print(JSON.stringify(arguments[0]))},''' + playerData['callback'] + '''(iptv_player_data.sitekey);'''
ret = iptv_js_execute(jscode)
data = ret['data'].strip()
data = byteify(json.loads(data))
url = self.getFullUrl(data['url'])
post_data = data['data']
urlParams = dict(self.defaultParams)
urlParams['header'] = dict(self.AJAX_HEADER)
urlParams['header']['Referer'] = playerData['ref_url']
if 'sitekey' in playerData:
errorMsgTab = [_('Link protected with google recaptcha v2.')]
recaptcha = UnCaptchaReCaptcha(lang=GetDefaultLang())
recaptcha.HTTP_HEADER['Referer'] = playerData['ref_url']
recaptcha.HTTP_HEADER['User-Agent'] = self.USER_AGENT
token = recaptcha.processCaptcha(playerData['sitekey'])
if token == '':
recaptcha = None
if config.plugins.iptvplayer.mrpiracy_bypassrecaptcha.value == '9kw.eu':
recaptcha = UnCaptchaReCaptcha_9kw()
elif config.plugins.iptvplayer.mrpiracy_bypassrecaptcha.value == '2captcha.com':
recaptcha = UnCaptchaReCaptcha_2captcha()
if recaptcha != None:
token = recaptcha.processCaptcha(playerData['sitekey'], playerData['ref_url'])
else:
errorMsgTab.append(_('You can use \"%s\" or \"%s\" services to workaround this protection.') % ("http://2captcha.com/", "https://9kw.eu/", ))
errorMsgTab.append(_('Go to the host configuration available under blue button.'))
printDBG('> token "%s" ' % token)
post_data['token'] = token
sts, data = self.getPage(url, urlParams, post_data)
printDBG("$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$")
printDBG(data)
printDBG("$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$")
tmp = re.compile('''['"](https?://[^'^"]+?)['"]''').findall(data)
for item in tmp:
if 1 == self.up.checkHostSupport(item):
hostUrl = item
if hostUrl == '':
url = self.getFullUrl(self.cm.ph.getSearchGroups(data, '<iframe[^>]+?src="([^"]+?)"', 1, ignoreCase=True)[0])
if url != '':
urlParams = dict(self.defaultParams)
urlParams['header'] = dict(urlParams['header'])
urlParams['header']['Referer'] = playerData['ref_url']
sts, data = self.getPage(url, urlParams)
hostUrl = self.cm.ph.getSearchGroups(data, '''location\.href=['"]([^'^"]+?)['"]''')[0]
except Exception:
printExc()
if self.cm.isValidUrl(hostUrl):
if linkId != '':
if config.plugins.iptvplayer.mrpiracy_linkcache.value and linkId not in MRPiracyGQ.LINKS_CACHE:
WriteTextFile(GetCacheSubDir('mrpiracy', linkId), hostUrl)
MRPiracyGQ.LINKS_CACHE[linkId] = hostUrl
urlTab = self.up.getVideoLinkExt(hostUrl)
if 0 == len(urlTab):
SetIPTVPlayerLastHostError('\n'.join(errorMsgTab))
else:
subUrl = 'https://cdn.mrpiracy.xyz/subs/%s.srt' % imdbId
sts, data = self.getPage(subUrl)
if sts and '00:'in data:
for idx in range(len(urlTab)):
urlTab[idx]['url'] = strwithmeta(urlTab[idx]['url'])
if 'external_sub_tracks' not in urlTab[idx]['url'].meta: urlTab[idx]['url'].meta['external_sub_tracks'] = []
urlTab[idx]['url'].meta['external_sub_tracks'].append({'title':'', 'url':subUrl, 'lang':'pt', 'format':'srt'})
return urlTab
def getVideoLinks(self, videoUrl):
printDBG("EFilmyTv.getVideoLinks [%s]" % videoUrl)
self.tryTologin()
videoUrl = strwithmeta(videoUrl)
urlTab = []
# mark requested link as used one
if len(self.cacheLinks.keys()):
for key in self.cacheLinks:
for idx in range(len(self.cacheLinks[key])):
if videoUrl in self.cacheLinks[key][idx]['url']:
if not self.cacheLinks[key][idx]['name'].startswith('*'):
self.cacheLinks[key][idx]['name'] = '*' + self.cacheLinks[key][idx]['name']
break
paramsUrl = dict(self.defaultParams)
paramsUrl['header'] = dict(paramsUrl['header'])
paramsUrl['header']['Referer'] = videoUrl.meta.get('Referer', self.getMainUrl())
sts, data = self.getPage(videoUrl, paramsUrl)
if not sts: return urlTab
cUrl = data.meta['url']
##############################################################################################
while sts and 'generate_captcha' in data:
captchaTitle = self.cm.ph.getAllItemsBeetwenMarkers(data, '<p', '</p>')
if len(captchaTitle):
captchaTitle = self.cleanHtmlStr(captchaTitle[-1])
# parse form data
data = self.cm.ph.getDataBeetwenMarkers(data, '<form', '</form>')[1]
imgUrl = self.getFullUrl('/mirrory.php?cmd=generate_captcha&time=%s' % time.time(), cUrl)
actionUrl = self.getFullUrl(self.cm.ph.getSearchGroups(data, 'action="([^"]+?)"')[0], cUrl)
tmp = re.compile('''<input[^>]+?>''').findall(data)
printDBG(tmp)
captcha_post_data = {}
for it in tmp:
val = self.cm.ph.getSearchGroups(it, '''\svalue=['"]?([^'^"^\s]+?)['"\s]''')[0].strip()
name = self.cm.ph.getSearchGroups(it, '''\sname=['"]([^'^"]+?)['"]''')[0]
captcha_post_data[name] = val
header = dict(self.HTTP_HEADER)
header['Accept'] = 'image/png,image/*;q=0.8,*/*;q=0.5'
params = dict(self.defaultParams)
params.update( {'maintype': 'image', 'subtypes':['jpeg', 'png'], 'check_first_bytes':['\xFF\xD8','\xFF\xD9','\x89\x50\x4E\x47'], 'header':header} )
filePath = GetTmpDir('.iptvplayer_captcha.jpg')
rm(filePath)
ret = self.cm.saveWebFile(filePath, imgUrl.replace('&', '&'), params)
if not ret.get('sts'):
SetIPTVPlayerLastHostError(_('Fail to get "%s".') % imgUrl)
return urlTab
params = deepcopy(IPTVMultipleInputBox.DEF_PARAMS)
params['accep_label'] = _('Send')
params['title'] = _('Captcha')
params['status_text'] = captchaTitle
params['with_accept_button'] = True
params['list'] = []
item = deepcopy(IPTVMultipleInputBox.DEF_INPUT_PARAMS)
item['label_size'] = (160,75)
item['input_size'] = (480,25)
item['icon_path'] = filePath
item['title'] = _('Answer')
item['input']['text'] = ''
params['list'].append(item)
ret = 0
retArg = self.sessionEx.waitForFinishOpen(IPTVMultipleInputBox, params)
printDBG(retArg)
if retArg and len(retArg) and retArg[0]:
printDBG(retArg[0])
captcha_post_data['captcha'] = retArg[0][0]
paramsUrl['header']['Referer'] = cUrl
sts, data = self.cm.getPage(actionUrl, paramsUrl, captcha_post_data)
if sts: cUrl = data.meta['url']
else: return urlTab
else:
return urlTab
##############################################################################################
jscode = []
tmp = self.cm.ph.getAllItemsBeetwenNodes(data, ('<script', '>'), ('</script', '>'), False)
for item in tmp:
if 'eval(' in item:
jscode.append(item)
if len(jscode) > 0:
jscode.insert(0, 'var document={write:function(e){print(e)}};Base64={},Base64.decode=function(e){e.length%4==3&&(e+="="),e.length%4==2&&(e+="=="),e=Duktape.dec("base64",e),decText="";for(var t=0;t<e.byteLength;t++)decText+=String.fromCharCode(e[t]);return decText};')
ret = iptv_js_execute('\n'.join(jscode))
if ret['sts'] and 0 == ret['code']:
data = ret['data'].strip()
if 'premium' in videoUrl.meta['f_type']:
printDBG(data)
errorMessage = self.cleanHtmlStr(self.cm.ph.getDataBeetwenNodes(data, ('<div', '>', 'toomany'), ('</div', '>'))[1].replace('<br>', '\n'))
SetIPTVPlayerLastHostError(errorMessage)
data = self.cm.ph.getDataBeetwenMarkers(data, 'clip:', '}')[1]
videoUrl = self.cm.ph.getSearchGroups(data, '''\surl\s*?:\s*?['"](https?://[^'^"]+?)['"]''', 1, True)[0]
if videoUrl != '': urlTab.append({'name':'direct_link', 'url':strwithmeta(videoUrl, {'Referer':cUrl})})
else:
videoUrl = self.getFullUrl(self.cm.ph.getSearchGroups(data, '''<iframe[^>]+?src=['"]([^"^']+?)['"]''', 1, True)[0], cUrl)
urlTab = self.up.getVideoLinkExt(strwithmeta(videoUrl, {'Referer':cUrl}))
return urlTab
def _findHostingLinks(data, linkTab, premium):
if premium:
jscode = [
base64.b64decode(
'''dmFyIGRvY3VtZW50PXt9LHdpbmRvdz10aGlzLGVsZW1lbnQ9ZnVuY3Rpb24obil7dGhpcy5odG1sPWZ1bmN0aW9uKG4pe3ByaW50KG4pfSx0aGlzLmhpZGU9ZnVuY3Rpb24oKXt9fSwkPWZ1bmN0aW9uKG4pe3JldHVybiBuZXcgZWxlbWVudChuKX07'''
)
]
tmp = self.cm.ph.getAllItemsBeetwenNodes(
data, ('<script', '>'), ('</script', '>'), False)
for item in tmp:
if 'function ShowPlayer(' in item:
jscode.append(item)
break
jscode = '\n'.join(jscode)
playersData = self.cm.ph.getDataBeetwenMarkers(
data, '<ul class="players"', '</ul>', False)[1]
playersData = playersData.split('</li>')
if len(playersData): del playersData[-1]
players = []
for item in playersData:
item = self.cm.ph.getDataBeetwenMarkers(
item, '<li>', '</a>', False)[1]
title = self.cleanHtmlStr(item)
id = self.cm.ph.getSearchGroups(item, 'href="#([^"]+?)"')[0]
tmp = reTitleObj.findall(item)
title += ' ' + ' '.join(tmp)
players.append({'title': title, 'id': id})
tmp = self.cm.ph.getDataBeetwenMarkers(
data, '<div class="tab-content">', '<script>', False)[1]
tmp = tmp.split('</div>')
if len(tmp): del tmp[-1]
for item in tmp:
id = self.cm.ph.getSearchGroups(item, 'id="([^"]+?)"')[0]
playerParams = self.cm.ph.getSearchGroups(
item,
'''ShowPlayer[^"^']*?['"]([^"^']+?)['"]\s*\,\s*['"]([^"^']+?)['"]''',
2)
url = ''
if premium and '' not in playerParams:
ret = iptv_js_execute(jscode +
('\nShowPlayer("%s","%s");' %
(playerParams[0], playerParams[1])))
if ret['sts'] and 0 == ret['code']:
printDBG(ret['data'])
url = self.getFullUrl(
self.cm.ph.getSearchGroups(
ret['data'],
'''<iframe[^>]+?src=['"]([^"^']+?)['"]''',
ignoreCase=True)[0])
else:
if '' not in playerParams:
url = baseVidUrl + '/'.join(playerParams)
if url == '':
url = self.cm.ph.getSearchGroups(
item, 'src="([^"]+?)"')[0]
url = self.getFullUrl(url)
if url == '' or url.split('?',
1)[0].split('.')[-1].lower() in [
'jpg', 'jepg', 'gif', 'png'
]:
continue
for p in players:
if p['id'] == id:
if premium: title = '[premium] %s' % p['title']
else: title = p['title']
linkTab.append({
'name':
title,
'url':
strwithmeta(url, {'Referer': cItem['url']}),
'need_resolve':
1
})
break
def listSearchResult(self, cItem, searchPattern, searchType):
printDBG(
"CartoonHD.listSearchResult cItem[%s], searchPattern[%s] searchType[%s]"
% (cItem, searchPattern, searchType))
sts, data = self.cm.getPage(self.MAIN_URL, self.defaultParams)
if not sts: return
vars = self.cm.ph.getDataBeetwenMarkers(data, 'var ', '</script>')[1]
if vars == '': return
vars = vars[:-9]
jsUrl = self.getFullUrl(
self.cm.ph.getSearchGroups(
data,
'''<script[^>]+?src=['"]([^'^"]*?foxycomplete.js[^'^"]*?)['"]'''
)[0])
if not self.cm.isValidUrl(jsUrl): return
sts, jsdata = self.cm.getPage(jsUrl, self.defaultParams)
if not sts: return
post_data = {
'q': searchPattern,
'limit': 100,
'timestamp': str(int(time.time() * 1000))
}
try:
jscode = base64.b64decode(
'''dmFyIGRvY3VtZW50ID0ge307DQp2YXIgd2luZG93ID0gdGhpczsNCg0KZnVuY3Rpb24gdHlwZU9mKCBvYmogKSB7DQogIHJldHVybiAoe30pLnRvU3RyaW5nLmNhbGwoIG9iaiApLm1hdGNoKC9ccyhcdyspLylbMV0udG9Mb3dlckNhc2UoKTsNCn0NCg0KZnVuY3Rpb24galF1ZXJ5UmVzdWx0T2JqKCl7DQogICAgcmV0dXJuIGpRdWVyeVJlc3VsdE9iajsNCn0NCmpRdWVyeVJlc3VsdE9iai5ibHVyID0gZnVuY3Rpb24oKXt9Ow0KDQpmdW5jdGlvbiBqUXVlcnlBdXRvY29tcGxldGVPYmooKXsNCiAgICBhcmd1bWVudHNbMV0uZXh0cmFQYXJhbXNbJ3VybCddID0gYXJndW1lbnRzWzBdOw0KICAgIHByaW50KEpTT04uc3RyaW5naWZ5KGFyZ3VtZW50c1sxXS5leHRyYVBhcmFtcykpOw0KICAgIHJldHVybiBqUXVlcnk7DQp9DQoNCmZ1bmN0aW9uIGpRdWVyeSgpew0KICAgIGlmICggdHlwZU9mKCBhcmd1bWVudHNbMF0gKSA9PSAnZnVuY3Rpb24nICkgew0KICAgICAgICBhcmd1bWVudHNbMF0oKTsNCiAgICB9IA0KICAgIA0KICAgIHJldHVybiBqUXVlcnk7DQp9DQoNCmpRdWVyeS5yZXN1bHQgPSBqUXVlcnlSZXN1bHRPYmo7DQpqUXVlcnkuaHRtbCA9IHt9Ow0KalF1ZXJ5LmJsdXIgPSBmdW5jdGlvbigpe307DQoNCmpRdWVyeS5hdXRvY29tcGxldGUgPSBqUXVlcnlBdXRvY29tcGxldGVPYmo7DQpqUXVlcnkuYWpheFNldHVwID0gZnVuY3Rpb24oKXt9Ow0KalF1ZXJ5LnJlYWR5ID0galF1ZXJ5Ow=='''
)
jscode += '%s %s' % (vars, jsdata)
printDBG("+++++++++++++++++++++++ CODE ++++++++++++++++++++++++")
printDBG(jscode)
printDBG("+++++++++++++++++++++++++++++++++++++++++++++++++++++++")
ret = iptv_js_execute(jscode)
if ret['sts'] and 0 == ret['code']:
decoded = ret['data'].strip()
printDBG('DECODED DATA -> [%s]' % decoded)
decoded = byteify(json.loads(decoded))
self.SEARCH_URL = decoded.pop('url', None)
post_data.update(decoded)
except Exception:
printExc()
httpParams = dict(self.defaultParams)
httpParams['header'] = {
'Referer': self.MAIN_URL,
'User-Agent': self.cm.HOST,
'X-Requested-With': 'XMLHttpRequest',
'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8'
}
sts, data = self.cm.getPage(self.SEARCH_URL,
httpParams,
post_data=post_data)
if not sts: return
printDBG(data)
try:
data = byteify(json.loads(data))
for item in data:
desc = item['meta']
if 'movie' in desc.lower():
category = 'video'
elif 'tv show' in desc.lower():
category = 'list_seasons'
else:
category = None
if None != category:
title = item['title']
url = item['permalink'].replace('\\/', '/')
icon = item.get('image', '').replace('\\/', '/')
if '' != url:
params = {
'name': 'category',
'title': title,
'url': self.getFullUrl(url),
'desc': desc,
'icon': self.getFullUrl(icon),
'category': category
}
if category == 'video':
self.addVideo(params)
else:
self.addDir(params)
except Exception:
printExc()
def getLinksForVideo(self, cItem):
printDBG("WRealu24TV.getLinksForVideo [%s]" % cItem)
retTab = []
hlsTab = []
sts, data = self.getPage(cItem['url'])
if not sts: return
data = re.sub("<!--[\s\S]*?-->", "", data)
cookieHeader = self.cm.getCookieHeader(self.COOKIE_FILE)
data = self.cm.ph.getDataBeetwenMarkers(data, '<video', '</video>')[1]
if 'document.write(' in data:
jscode = [
'var document = {};document.write=function(txt){print(txt);}'
]
tmp = self.cm.ph.getAllItemsBeetwenNodes(data, ('<script', '>'),
('</script', '>'), False)
for item in tmp:
jscode.append(item)
jscode = '\n'.join(jscode)
ret = iptv_js_execute(jscode)
if ret['sts'] and 0 == ret['code']:
data = ret['data'].strip()
data = self.cm.ph.getAllItemsBeetwenMarkers(data, '<source', '>')
printDBG(data)
for item in data:
url = self.getFullUrl(
self.cm.ph.getSearchGroups(item,
'''src=['"]([^'^"]+?)['"]''')[0])
if not self.cm.isValidUrl(url): continue
type = self.cm.ph.getSearchGroups(
item, '''type=['"]([^'^"]+?)['"]''')[0].lower()
label = self.cm.ph.getSearchGroups(
item, '''label=['"]([^'^"]+?)['"]''')[0]
res = self.cm.ph.getSearchGroups(item,
'''res=['"]([^'^"]+?)['"]''')[0]
if label == '': label = res
if 'mp4' in type:
url = self.up.decorateUrl(
url, {
'Cookie': cookieHeader,
'User-Agent': self.USER_AGENT,
'Referer': cItem['url']
})
retTab.append({
'name': label,
'url': url,
'res': res,
'need_resolve': 0
})
elif 'mpegurl' in type:
url = self.up.decorateUrl(
url, {
'iptv_proto': 'm3u8',
'Origin': self.up.getDomain(cItem['url'], False),
'Cookie': cookieHeader,
'User-Agent': self.USER_AGENT,
'Referer': cItem['url']
})
hlsTab.extend(
getDirectM3U8Playlist(url,
checkContent=True,
sortWithMaxBitrate=999999999))
else:
printDBG("Unknown source: [%s]" % item)
if 1 < len(retTab):
def __getLinkQuality(itemLink):
try:
return int(itemLink['res'])
except Exception:
return 0
oneLink = CSelOneLink(retTab, __getLinkQuality, 999999999)
retTab = oneLink.getSortedLinks()
retTab.extend(hlsTab)
return retTab
def getVideoLinks(self, videoUrl):
printDBG("FilmeOnlineTo.getVideoLinks [%s]" % videoUrl)
urlTab = []
subTracks = []
# mark requested link as used one
if len(self.cacheLinks.keys()):
for key in self.cacheLinks:
for idx in range(len(self.cacheLinks[key])):
if videoUrl in self.cacheLinks[key][idx]['url']:
if not self.cacheLinks[key][idx]['name'].startswith(
'*'):
self.cacheLinks[key][idx][
'name'] = '*' + self.cacheLinks[key][idx][
'name']
break
sts, data = self.getPage(videoUrl)
if not sts: return
data = self.cm.ph.getDataBeetwenReMarkers(
data, re.compile('var\s*?movie\s*?\=\s*?\{'), re.compile('}'))[1]
ret = iptv_js_execute(data + '; print(JSON.stringify(movie));')
try:
movieData = byteify(json.loads(ret['data']), '', True)
urlParams = dict(self.defaultParams)
urlParams['header'] = dict(self.AJAX_HEADER)
urlParams['header']['Referer'] = str(videoUrl)
url = self.getFullUrl('/ajax/mep.php?id=%s' % movieData['id'])
sts, data = self.getPage(url, urlParams)
if not sts: return
data = byteify(json.loads(data), '', True)
params = dict(videoUrl.meta.get('params', {}))
if params.get('tip', '') == 'embed':
url = '/ajax/movie_embed.php?eid=%s&lid=undefined&ts%s&up=0&mid=%s&gid=%s&epNr=%s&type=%s&server=NaN&epIndex=%s&so=%s&srvr=NaN' % (
params['id'], data.get('ts', ''), movieData['id'],
movieData['gid'], params['epNr'], movieData['type'],
params['index'], params['so'])
sts, data = self.getPage(self.getFullUrl(url), urlParams)
if not sts: return
data = byteify(json.loads(data), '', True)
url = data['src'].replace('&', '&')
urlParams = {
'Referer': str(videoUrl),
'User-Agent': self.HEADER['User-Agent']
}
subsLinks = re.compile(
'''c([0-9]+?)_file=(https?://[^&^$]+?\.srt)[&$]'''
).findall(url)
subsLabels = dict(
re.compile('''c([0-9]+?)_label=([^&^/]+?)[&/]''').findall(
url + '&'))
for item in subsLinks:
label = subsLabels.get(item[0], 'unk')
subTracks.append({
'title': label,
'url': strwithmeta(item[1], urlParams),
'lang': label,
'format': 'srt'
})
urlTab = self.up.getVideoLinkExt(url)
elif params.get('tip', '') == 'vip':
url = '/ajax/mtoken.php?eid=%s&mid=%s&so=%s&server=NaN&epNr=%s&srvr=NaN&_=%s' % (
params['id'], movieData['id'], params['so'],
params['epNr'], int(time.time() * 1000))
sts, data = self.getPage(self.getFullUrl(url), urlParams)
if not sts: return
data = dict(
re.compile('''_([a-z]+?)\s*?=\s*['"]([^'^"]+?)['"]''').
findall(data))
url = '/ajax/msources.php?eid=%s&x=%s&y=%s&z=%s&ip=%s&mid=%s&gid=%s&lang=rum&epIndex=%s&server=NaN&so=%s&epNr=%s&srvr=NaN' % (
params['id'], data['x'], data['y'], data['z'], data['ip'],
movieData['id'], movieData['gid'], params['index'],
params['so'], params['epNr'])
sts, data = self.getPage(self.getFullUrl(url), urlParams)
if not sts: return
urlParams = {
'Referer': str(videoUrl),
'User-Agent': self.HEADER['User-Agent']
}
data = byteify(json.loads(data), '', True)
url = self.getFullUrl(data['playlist'][0]['sources']['file'])
if 'mp4' in data['playlist'][0]['sources']['type'].lower():
urlTab.append({
'name': 'mp4',
'url': strwithmeta(url, urlParams),
'need_resolve': 0
})
for item in data['playlist'][0]['tracks']:
if item.get('kind', '').lower() != 'captions': continue
url = self.getFullUrl(item['file'])
label = self.cleanHtmlStr(item['label'])
subTracks.append({
'title': label,
'url': strwithmeta(url, urlParams),
'lang': label,
'format': 'srt'
})
printDBG(data)
except Exception:
printExc()
urlParams = {
'Referer': str(videoUrl),
'User-Agent': self.HEADER['User-Agent']
}
if len(subTracks):
urlParams.update({'external_sub_tracks': subTracks})
for idx in range(len(urlTab)):
urlTab[idx]['url'] = strwithmeta(urlTab[idx]['url'], urlParams)
return urlTab
def exploreItem(self, cItem, nextCategory):
printDBG("FilmeOnlineTo.exploreItem")
self.cacheLinks = {}
sts, data = self.getPage(cItem['url'])
if not sts: return
data = self.cm.ph.getDataBeetwenReMarkers(
data, re.compile('var\s*?movie\s*?\=\s*?\{'), re.compile('}'))[1]
ret = iptv_js_execute(data + '; print(JSON.stringify(movie));')
try:
printDBG(ret['data'])
movieData = byteify(json.loads(ret['data']), '', True)
url = movieData.get('trailer', '')
if self.cm.isValidUrl(url):
params = dict(cItem)
params.update({
'title':
'%s %s' %
(_('[trailer]'), self.cleanHtmlStr(movieData['name'])),
'url':
url
})
self.addVideo(params)
params = dict(self.defaultParams)
params['header'] = dict(self.AJAX_HEADER)
params['header']['Referer'] = cItem['url']
url = self.getFullUrl('/ajax/mep.php?id=%s' % movieData['id'])
sts, data = self.getPage(url, params)
if not sts: return
data = byteify(json.loads(data), '', True)
printDBG(
"++++++++++++++++++++++++++++++++++++++++++++++++++++++++")
printDBG(data['html'])
printDBG(
"++++++++++++++++++++++++++++++++++++++++++++++++++++++++")
serverData = re.compile('''<div[^>]+?clearfix[^>]+?>''').split(
data['html'])
if len(serverData): del serverData[-1]
linksKeys = []
linksLinks = {}
linksTiles = {}
reParamsObj = re.compile(
'''\s*?data\-([^\=^\s]+?)\s*?=['"]([^'^"]+?)['"]''')
for serverItem in serverData:
sTitle = self.cleanHtmlStr(
self.cm.ph.getDataBeetwenMarkers(serverItem, '<strong',
'</strong>')[1])
serverItem = self.cm.ph.getAllItemsBeetwenMarkers(
serverItem, '<a', '</a>')
for item in serverItem:
title = self.cleanHtmlStr(item)
if cItem['title'] not in title:
title = '%s %s' % (cItem['title'], title)
params = dict(reParamsObj.findall(item))
try:
key = int(params['epNr'])
except Exception:
key = params.get('epNr', title)
if key not in linksKeys:
linksKeys.append(key)
linksLinks[key] = []
linksTiles[key] = title
url = '%s?ep=%s' % (cItem['url'],
params.get('id',
str(key) + title))
url = strwithmeta(url, {'params': params})
linksLinks[key].append({
'name': sTitle,
'title': title,
'url': url,
'need_resolve': 1
})
if movieData.get('type', '') == 'tv':
linksKeys.sort()
for key in linksKeys:
url = '%s#ep=%s' % (cItem['url'], key)
params = dict(cItem)
params.update({
'good_for_fav': False,
'title': linksTiles[key],
'url': url
})
self.addVideo(params)
self.cacheLinks[url] = linksLinks[key]
else:
url = cItem['url']
self.cacheLinks[url] = []
for key in linksKeys:
for item in linksLinks[key]:
item.update({
'name':
'%s - %s' % (item['name'], item['title'])
})
self.cacheLinks[url].append(item)
if len(self.cacheLinks[url]):
params = dict(cItem)
params.update({'good_for_fav': False})
self.addVideo(params)
except Exception:
printExc()
return
def listSeasons(self, cItem, nextCategory):
printDBG("SerialeCO.listSeasons [%s]" % cItem)
self.playerData = {}
sts, data = self.getPage(cItem['url'])
if not sts: return
cUrl = data.meta['url']
data = self.cm.ph.getDataBeetwenNodes(data,
('<script', '>', 'player.js'),
('<header', '>'))[1]
playerUrl = self.getFullUrl(
self.cm.ph.getSearchGroups(data, '''src=['"]([^'^"]+?)['"]''')[0])
data = self.cm.ph.getAllItemsBeetwenMarkers(data, '<input', '>')
self.playerData = {}
for item in data:
id = self.cm.ph.getSearchGroups(item,
'''id=['"]([^'^"]+?)['"]''')[0]
val = self.cm.ph.getSearchGroups(item,
'''value=['"]([^'^"]+?)['"]''')[0]
self.playerData[id] = val
sts, data = self.getPage(playerUrl)
if not sts: return
# function pobierz_info_o_odcinkach
ajaxInfoData = self.cm.ph.getDataBeetwenMarkers(
data, 'function pobierz_info_o_odcinkach', '});')[1]
ajaxInfoVarName = self.cm.ph.getSearchGroups(
ajaxInfoData, '''var\s+?([A-Za-z0-9]+?)\s*?=''')[0]
ajaxInfoData = self.cm.ph.getDataBeetwenMarkers(
ajaxInfoData, '$.ajax(', ').', False)[1]
printDBG('ajaxInfoData: [%s]' % ajaxInfoData)
printDBG('ajaxInfoVarName: [%s]' % ajaxInfoVarName)
playerUrl = self.cm.ph.getDataBeetwenMarkers(
data, 'function seriale_search', 'function')[1]
playerUrl = self.cm.ph.getSearchGroups(
playerUrl, '''['"]?url['"]?\s*:\s*['"](http[^'^"]+?)['"]''')[0]
if not self.cm.isValidUrl(playerUrl):
printDBG("No valid playerUrl")
return
self.playerData['player_url'] = playerUrl
seasonUrl = self.cm.ph.getDataBeetwenMarkers(data,
'function pokaz_odcinki',
'function')[1]
seasonUrl = self.cm.ph.getSearchGroups(
seasonUrl, '''['"]?url['"]?\s*:\s*['"](http[^'^"]+?)['"]''')[0]
if not self.cm.isValidUrl(seasonUrl):
printDBG("No valid playerUrl")
return
httpParams = dict(self.defaultParams)
httpParams['header'] = dict(httpParams['header'])
httpParams['header']['Referer'] = cItem['url']
httpParams['header']['Origin'] = self.getMainUrl()[:-1]
sts, seasons = self.getPage(seasonUrl, httpParams,
{'nazwa': self.playerData.get('fid', '')})
if sts:
printDBG(">>>>>>>\n%s\n>>>>>>>" % seasons)
self.playerData['odc'] = seasons
seasons = self.playerData.get('odc', '').split(',')
for idx in range(len(seasons)):
if seasons[idx] == '': continue
sNum = str(idx + 1)
params = dict(cItem)
params.update({
'good_for_fav': False,
'category': nextCategory,
'title': _('Season %s') % sNum.zfill(2),
's_title': cItem['title'],
's_num': sNum,
'e_count': seasons[idx]
})
self.addDir(params)
if 0 == len(self.currList
) and ajaxInfoVarName != '' and ajaxInfoData != '':
ret = iptv_js_execute('{0}="{1}";\n'.format(
ajaxInfoVarName, self.playerData.get(ajaxInfoVarName, '')) +
'print(JSON.stringify({0}));\n'.format(
ajaxInfoData))
if ret['sts'] and 0 == ret['code']:
data = ret['data'].strip()
printDBG('DECODED DATA -> \n[%s]\n' % data)
try:
data = byteify(json.loads(data))
searchUrl = self.getFullUrl(data['url'], cUrl)
post_data = data['data']
sts, data = self.getPage(searchUrl, httpParams, post_data)
if not sts: return
printDBG('DATA -> \n[%s]\n' % data)
data = byteify(json.loads(data))
for sKey in data:
sNum = sKey.strip()
eItems = []
for eKey in data[sKey]:
eNum = eKey.strip()
title = _('%s s%se%s') % (
cItem['title'], sNum.zfill(2), eNum.zfill(2))
if data[sKey][eKey].get('title', '') != '':
title += ' ' + data[sKey][eKey]['title']
desc = data[sKey][eKey].get('data', '')
params = {
'good_for_fav': False,
'title': title,
'desc': desc,
's_num': sNum,
'e_num': eNum
}
eItems.append(params)
if len(eItems):
params = dict(cItem)
params.update({
'good_for_fav':
False,
'category':
nextCategory,
'title':
_('Season %s') % sNum.zfill(2),
's_title':
cItem['title'],
's_num':
sNum,
'e_items':
eItems
})
self.addDir(params)
except Exception:
printExc()
if len(self.currList) == 1:
cItem = self.currList[0]
self.currList = []
self.listEpisodes(cItem)
def getPageCFProtection(self, baseUrl, params={}, post_data=None):
cfParams = params.get('cloudflare_params', {})
def _getFullUrlEmpty(url):
return url
_getFullUrl = cfParams.get('full_url_handle', _getFullUrlEmpty)
_getFullUrl2 = cfParams.get('full_url_handle2', _getFullUrlEmpty)
url = baseUrl
header = {'Referer':url, 'User-Agent':cfParams.get('User-Agent', ''), 'Accept-Encoding':'text'}
header.update(params.get('header', {}))
params.update({'with_metadata':True, 'use_cookie': True, 'save_cookie': True, 'load_cookie': True, 'cookiefile': cfParams.get('cookie_file', ''), 'header':header})
sts, data = self.getPage(url, params, post_data)
current = 0
while current < 5:
#if True:
if not sts and None != data:
start_time = time.time()
current += 1
doRefresh = False
try:
domain = self.getBaseUrl(data.fp.geturl())
verData = data.fp.read()
if data.fp.info().get('Content-Encoding', '') == 'gzip':
verData = DecodeGzipped(verData)
printDBG("------------------")
printDBG(verData)
printDBG("------------------")
if 'sitekey' not in verData and 'challenge' not in verData: break
printDBG(">>")
printDBG(verData)
printDBG("<<")
sitekey = self.ph.getSearchGroups(verData, 'data-sitekey="([^"]+?)"')[0]
id = self.ph.getSearchGroups(verData, 'data-ray="([^"]+?)"')[0]
if sitekey != '':
from Plugins.Extensions.IPTVPlayer.libs.recaptcha_v2 import UnCaptchaReCaptcha
# google captcha
recaptcha = UnCaptchaReCaptcha(lang=GetDefaultLang())
recaptcha.HTTP_HEADER['Referer'] = baseUrl
if '' != cfParams.get('User-Agent', ''): recaptcha.HTTP_HEADER['User-Agent'] = cfParams['User-Agent']
token = recaptcha.processCaptcha(sitekey)
if token == '': return False, None
sts, tmp = self.ph.getDataBeetwenMarkers(verData, '<form', '</form>', caseSensitive=False)
if not sts: return False, None
url = self.ph.getSearchGroups(tmp, 'action="([^"]+?)"')[0]
if url != '': url = _getFullUrl( url )
else: url = data.fp.geturl()
actionType = self.ph.getSearchGroups(tmp, 'method="([^"]+?)"', 1, True)[0].lower()
post_data2 = dict(re.findall(r'<input[^>]*name="([^"]*)"[^>]*value="([^"]*)"[^>]*>', tmp))
#post_data2['id'] = id
if '' != token:
post_data2['g-recaptcha-response'] = token
else:
continue
params2 = dict(params)
params2['header']= dict(params['header'])
params2['header']['Referer'] = baseUrl
if actionType == 'get':
if '?' in url:
url += '&'
else:
url += '?'
url += urllib.urlencode(post_data2)
post_data2 = None
sts, data = self.getPage(url, params2, post_data2)
printDBG("++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++")
printDBG(sts)
printDBG("------------------------------------------------------------------")
printDBG(data)
printDBG("++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++")
else:
dat = self.ph.getAllItemsBeetwenNodes(verData, ('<script', '>'), ('</script', '>'), False)
for item in dat:
if 'setTimeout' in item and 'submit()' in item:
dat = item
break
decoded = ''
jscode = base64.b64decode('''ZnVuY3Rpb24gc2V0VGltZW91dCh0LGUpe2lwdHZfcmV0LnRpbWVvdXQ9ZSx0KCl9dmFyIGlwdHZfcmV0PXt9LGlwdHZfZnVuPW51bGwsZG9jdW1lbnQ9e30sd2luZG93PXRoaXMsZWxlbWVudD1mdW5jdGlvbih0KXt0aGlzLl9uYW1lPXQsdGhpcy5fc3JjPSIiLHRoaXMuX2lubmVySFRNTD0iIix0aGlzLl9wYXJlbnRFbGVtZW50PSIiLHRoaXMuc2hvdz1mdW5jdGlvbigpe30sdGhpcy5hdHRyPWZ1bmN0aW9uKHQsZSl7cmV0dXJuInNyYyI9PXQmJiIjdmlkZW8iPT10aGlzLl9uYW1lJiZpcHR2X3NyY2VzLnB1c2goZSksdGhpc30sdGhpcy5maXJzdENoaWxkPXtocmVmOmlwdHZfZG9tYWlufSx0aGlzLnN0eWxlPXtkaXNwbGF5OiIifSx0aGlzLnN1Ym1pdD1mdW5jdGlvbigpe3ByaW50KEpTT04uc3RyaW5naWZ5KGlwdHZfcmV0KSl9LE9iamVjdC5kZWZpbmVQcm9wZXJ0eSh0aGlzLCJzcmMiLHtnZXQ6ZnVuY3Rpb24oKXtyZXR1cm4gdGhpcy5fc3JjfSxzZXQ6ZnVuY3Rpb24odCl7dGhpcy5fc3JjPXR9fSksT2JqZWN0LmRlZmluZVByb3BlcnR5KHRoaXMsImlubmVySFRNTCIse2dldDpmdW5jdGlvbigpe3JldHVybiB0aGlzLl9pbm5lckhUTUx9LHNldDpmdW5jdGlvbih0KXt0aGlzLl9pbm5lckhUTUw9dH19KSxPYmplY3QuZGVmaW5lUHJvcGVydHkodGhpcywidmFsdWUiLHtnZXQ6ZnVuY3Rpb24oKXtyZXR1cm4iIn0sc2V0OmZ1bmN0aW9uKHQpe2lwdHZfcmV0LmFuc3dlcj10fX0pfSwkPWZ1bmN0aW9uKHQpe3JldHVybiBuZXcgZWxlbWVudCh0KX07ZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQ9ZnVuY3Rpb24odCl7cmV0dXJuIG5ldyBlbGVtZW50KHQpfSxkb2N1bWVudC5jcmVhdGVFbGVtZW50PWZ1bmN0aW9uKHQpe3JldHVybiBuZXcgZWxlbWVudCh0KX0sZG9jdW1lbnQuYXR0YWNoRXZlbnQ9ZnVuY3Rpb24oKXtpcHR2X2Z1bj1hcmd1bWVudHNbMV19Ow==''')
jscode = "var location = {hash:''}; var iptv_domain='%s';\n%s\n%s\niptv_fun();" % (domain, jscode, dat) #cfParams['domain']
printDBG("+ CODE +")
printDBG(jscode)
printDBG("++++++++")
ret = iptv_js_execute( jscode )
decoded = byteify(json.loads(ret['data'].strip()))
verData = self.ph.getDataBeetwenReMarkers(verData, re.compile('<form[^>]+?id="challenge-form"'), re.compile('</form>'), False)[1]
printDBG(">>")
printDBG(verData)
printDBG("<<")
verUrl = _getFullUrl( self.ph.getSearchGroups(verData, 'action="([^"]+?)"')[0] )
get_data = dict(re.findall(r'<input[^>]*name="([^"]*)"[^>]*value="([^"]*)"[^>]*>', verData))
get_data['jschl_answer'] = decoded['answer']
verUrl += '?'
for key in get_data:
verUrl += '%s=%s&' % (key, get_data[key])
verUrl = _getFullUrl( self.ph.getSearchGroups(verData, 'action="([^"]+?)"')[0] ) + '?jschl_vc=%s&pass=%s&jschl_answer=%s' % (get_data['jschl_vc'], get_data['pass'], get_data['jschl_answer'])
verUrl = _getFullUrl2( verUrl )
params2 = dict(params)
params2['load_cookie'] = True
params2['save_cookie'] = True
params2['header'] = dict(params.get('header', {}))
params2['header'].update({'Referer':url, 'User-Agent':cfParams.get('User-Agent', ''), 'Accept-Encoding':'text'})
printDBG("Time spent: [%s]" % (time.time() - start_time))
if current == 1:
GetIPTVSleep().Sleep(1 + (decoded['timeout'] / 1000.0)-(time.time() - start_time))
else:
GetIPTVSleep().Sleep((decoded['timeout'] / 1000.0))
printDBG("Time spent: [%s]" % (time.time() - start_time))
printDBG("Timeout: [%s]" % decoded['timeout'])
sts, data = self.getPage(verUrl, params2, post_data)
except Exception:
printExc()
break
else:
break
return sts, data
def getLinksForVideo(self, cItem):
printDBG("ForjaTN.getLinksForVideo [%s]" % cItem)
if 1 == self.up.checkHostSupport(cItem.get('url', '')):
videoUrl = cItem['url'].replace('youtu.be/',
'youtube.com/watch?v=')
return self.up.getVideoLinkExt(videoUrl)
retTab = []
subTracksTab = []
sts, data = self.getPage(cItem['url'])
if not sts: return []
cUrl = data.meta['url']
if cItem.get('f_type', '') == 'episode':
episodeId = cItem['url']
if episodeId.endswith('/'): episodeId = episodeId[-1]
episodeId = '/'.join(episodeId.split('/')[-2:])
data = self.cm.ph.getDataBeetwenReMarkers(
data, re.compile('''episodes\s*='''), re.compile('''];'''),
False)[1]
data = data.strip() + ']'
ret = iptv_js_execute('print(JSON.stringify(%s));' % data)
if ret['sts'] and 0 == ret['code']:
try:
data = byteify(json.loads(ret['data']), '', True)
for eItem in data:
if episodeId not in eItem.get('poster', ''): continue
for item in eItem['sources']:
vidType = item['type'].lower()
vidUrl = self.getFullUrl(item['src'],
cUrl).replace(' ', '%20')
name = self.cleanHtmlStr(item['label'])
tmpTab = []
if 'x-mpegurl' in vidType:
tmpTab = getDirectM3U8Playlist(
vidUrl,
checkExt=False,
checkContent=True,
cookieParams=self.defaultParams)
elif 'mp4' in vidType:
tmpTab.append({'name': 'mp4', 'url': vidUrl})
for idx in range(len(tmpTab)):
tmpTab[idx]['name'] = '[%s] %s' % (
name, tmpTab[idx]['name'])
retTab.extend(tmpTab)
for item in eItem['textTracks']:
if item.get('kind', '') != 'captions': continue
subTracksTab.append({
'title':
item['label'],
'url':
self.getFullUrl(item['src']),
'lang':
item['language'],
'format':
'vtt'
})
break
except Exception:
printExc()
else:
tmp = self.cm.ph.getDataBeetwenMarkers(data, 'player.src(', ')')[1]
if tmp == '':
tmp = self.cm.ph.getDataBeetwenNodes(data, ('[', ']', '.m3u8'),
(';', ' '))[1]
tmpTab = tmp.split('},')
for tmp in tmpTab:
vidType = self.cm.ph.getSearchGroups(
tmp, '''type['"]?\s*:\s*['"]([^'^"]+?)['"]''')[0].lower()
vidLabel = self.cm.ph.getSearchGroups(
tmp, '''label['"]?\s*:\s*['"]([^'^"]+?)['"]''')[0]
vidUrl = self.getFullUrl(
self.cm.ph.getSearchGroups(
tmp, '''src['"]?\s*:\s*['"]([^'^"]+?)['"]''')[0], cUrl)
if not self.cm.isValidUrl(vidUrl): return []
if 'x-mpegurl' in vidType:
retTab = getDirectM3U8Playlist(
vidUrl,
checkExt=False,
checkContent=True,
cookieParams=self.defaultParams)
elif 'mp4' in vidType:
retTab.append({'name': 'mp4 %s' % vidLabel, 'url': vidUrl})
data = self.cm.ph.getAllItemsBeetwenMarkers(
data, '<video', '</video>')
for tmp in data:
tmp = self.cm.ph.getAllItemsBeetwenMarkers(tmp, '<track', '>')
for item in tmp:
if 'caption' not in item: continue
url = self.getFullUrl(
self.cm.ph.getSearchGroups(
item, '''src=['"]([^'^"]+?)['"]''')[0])
if not self.cm.isValidUrl(url): continue
lang = self.cm.ph.getSearchGroups(
item, '''srclang=['"]([^'^"]+?)['"]''')[0]
title = self.cm.ph.getSearchGroups(
item, '''label=['"]([^'^"]+?)['"]''')[0]
subTracksTab.append({
'title': title,
'url': url,
'lang': lang,
'format': 'vtt'
})
cookieHeader = self.cm.getCookieHeader(self.COOKIE_FILE)
for idx in range(len(retTab)):
retTab[idx]['url'] = strwithmeta(
retTab[idx]['url'], {
'User-Agent': self.USER_AGENT,
'Referer': cItem['url'],
'Cookie': cookieHeader,
'external_sub_tracks': subTracksTab
})
return retTab
def getVideoLinks(self, videoUrl):
printDBG("Cinemay.getVideoLinks [%s]" % videoUrl)
videoUrl = strwithmeta(videoUrl)
urlTab = []
# mark requested link as used one
if len(self.cacheLinks.keys()):
for key in self.cacheLinks:
for idx in range(len(self.cacheLinks[key])):
if videoUrl in self.cacheLinks[key][idx]['url']:
if not self.cacheLinks[key][idx]['name'].startswith(
'*'):
self.cacheLinks[key][idx][
'name'] = '*' + self.cacheLinks[key][idx][
'name']
break
params = dict(self.defaultParams)
params['header'] = dict(params['header'])
params['header']['Referer'] = videoUrl.meta.get('Referer', '')
sts, data = self.getPage(self.getFullUrl('/image/logo.png'), params)
if not sts: return []
if 1 != self.up.checkHostSupport(videoUrl):
sts, data = self.getPage(videoUrl, params)
if not sts: return []
scripts = []
tmp = self.cm.ph.getAllItemsBeetwenNodes(data, ('<script', '>'),
('</script', '>'), False)
for item in tmp:
if 'eval(' not in item: continue
scripts.append(item.strip())
try:
jscode = base64.b64decode(
'''dmFyIGRvY3VtZW50PXt9LHdpbmRvdz10aGlzO3dpbmRvdy5sb2NhdGlvbj17aG9zdG5hbWU6IiVzIn0sZG9jdW1lbnQud3JpdGU9ZnVuY3Rpb24obil7cHJpbnQobil9Ow=='''
) % (self.up.getDomain(videoUrl, True))
ret = iptv_js_execute(jscode + '\n'.join(scripts))
if ret['sts'] and 0 == ret['code']:
data = ret['data'].strip()
videoUrl = self.cm.ph.getSearchGroups(
data,
'''url['"]?=['"]?([^'^"^>]+?)['">]''')[0].strip()
except Exception:
printExc()
if 0 and 1 != self.up.checkHostSupport(videoUrl):
try:
params = dict(self.defaultParams)
params['header'] = dict(params['header'])
params['header']['Referer'] = videoUrl.meta.get('Referer', '')
params['return_data'] = False
sts, response = self.getPage(videoUrl, params)
videoUrl = response.geturl()
response.close()
except Exception:
printExc()
urlTab = self.up.getVideoLinkExt(videoUrl)
return urlTab
