def downloadAndUnpack(self, url, params={}, post_data=None, unpackToSubDir=False):
data, fileName = self.downloadFileData(url, params, post_data)
if data == None:
return None
ext = fileName.rsplit('.', 1)[-1].lower()
printDBG("fileName[%s] ext[%s]" % (fileName, ext))
if ext not in ['zip', 'rar']:
SetIPTVPlayerLastHostError(_('Unknown file extension "%s".') % ext)
return None
tmpFile = GetTmpDir( self.TMP_FILE_NAME )
tmpArchFile = tmpFile + '.' + ext
tmpDIR = ''
if unpackToSubDir:
dirName = fileName.rsplit('.', 1)[0].split('filename=', 1)[-1]
if dirName != '':
tmpDIR = GetSubtitlesDir(dirName)
if tmpDIR == '':
tmpDIR = GetTmpDir(self.TMP_DIR_NAME)
printDBG(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
printDBG(fileName)
printDBG(tmpFile)
printDBG(tmpArchFile)
printDBG(tmpDIR)
printDBG(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
if not self.writeFile(tmpArchFile, data):
return None
if not self.unpackArchive(tmpArchFile, tmpDIR):
rm(tmpArchFile)
return None
return tmpDIR
def _startDownloader(self, sts, reason):
if sts:
self.downloader.subscribeFor_Finish(self.downloadFinished)
url,downloaderParams = DMHelper.getDownloaderParamFromUrl(self.currItem.get('url', ''))
self.downloader.start(url, GetTmpDir(self._TMP_FILE_NAME), downloaderParams)
else:
self["console"].setText(_("Download can not be started.\nDownloader %s not working correctly.\nStatus[%s]"))
def processCaptcha(self, key):
post_data = None
token = ''
iteration = 0
reCaptchaUrl = 'https://www.google.com/recaptcha/api/noscript?k=%s' % (key)
while iteration < 20:
sts, data = self.cm.getPage(reCaptchaUrl, {'header':self.HTTP_HEADER, 'raw_post_data':True}, post_data=post_data)
if not sts:
SetIPTVPlayerLastHostError(_('Fail to get "%s".') % reCaptchaUrl)
return ''
imgUrl = self.cm.ph.getSearchGroups(data, 'src="(image[^"]+?)"')[0]
iteration += 1
message = self.cm.ph.getSearchGroups(data, '<p[^>]*>([^<]+?)</p>')[0]
token = self.cm.ph.getSearchGroups(data, '<textarea[^>]*>([^<]+?)</textarea>')[0]
if '' != token:
printDBG('>>>>>>>> Captcha token[%s]' % (token))
break
elif message == '':
printDBG('>>>>>>>> Captcha Failed')
break
recaptcha_challenge_field = self.cm.ph.getSearchGroups(data, 'name="recaptcha_challenge_field"[^>]+?value="([^"]+)"')[0]
imgUrl = 'https://www.google.com/recaptcha/api/%s' % (imgUrl.replace('&', '&'))
message = clean_html(message)
accepLabel = clean_html(self.cm.ph.getSearchGroups(data, 'type="submit"[^>]+?value="([^"]+)"')[0])
filePath = GetTmpDir('.iptvplayer_captcha.jpg')
printDBG(">>>>>>>> Captcha message[%s]" % (message))
printDBG(">>>>>>>> Captcha accep label[%s]" % (accepLabel))
printDBG(">>>>>>>> Captcha imgUrl[%s] filePath[%s]" % (imgUrl, filePath))
params = {'maintype': 'image', 'subtypes':['jpeg'], 'check_first_bytes':['\xFF\xD8','\xFF\xD9']}
ret = self.cm.saveWebFile(filePath, imgUrl, params)
if not ret.get('sts'):
SetIPTVPlayerLastHostError(_('Fail to get "%s".') % imgUrl)
break
params = deepcopy(IPTVMultipleInputBox.DEF_PARAMS)
params['accep_label'] = _('Send')
params['title'] = accepLabel
params['list'] = []
item = deepcopy(IPTVMultipleInputBox.DEF_INPUT_PARAMS)
item['label_size'] = (300,57)
item['input_size'] = (300,25)
item['icon_path'] = filePath
item['input']['text'] = ''
params['list'].append(item)
ret = 0
retArg = self.sessionEx.waitForFinishOpen(IPTVMultipleInputBox, params)
printDBG('>>>>>>>> Captcha response[%s]' % (retArg))
if retArg is not None and len(retArg) and retArg[0]:
recaptcha_response_field = retArg[0]
printDBG('>>>>>>>> Captcha recaptcha_response_field[%s]' % (recaptcha_response_field))
post_data = urllib.urlencode({'recaptcha_challenge_field': recaptcha_challenge_field, 'recaptcha_response_field':recaptcha_response_field, 'submit':accepLabel}, doseq=True)
else:
break
return token
def tryTologin(self):
printDBG('tryTologin start')
if PlusDEDE.login == None and PlusDEDE.password == None:
if self.readLoginMarker() == self.calcLoginMarker(config.plugins.iptvplayer.plusdede_login.value, config.plugins.iptvplayer.plusdede_password.value):
PlusDEDE.login = config.plugins.iptvplayer.plusdede_login.value
PlusDEDE.password = config.plugins.iptvplayer.plusdede_password.value
else:
PlusDEDE.password = ''
PlusDEDE.login = ''
rm(self.COOKIE_FILE)
if True != self.loggedIn or PlusDEDE.login != config.plugins.iptvplayer.plusdede_login.value or\
PlusDEDE.password != config.plugins.iptvplayer.plusdede_password.value:
if True != self.loggedIn and PlusDEDE.login == config.plugins.iptvplayer.plusdede_login.value and\
PlusDEDE.password == config.plugins.iptvplayer.plusdede_password.value:
sts, data = self.getPage(self.getMainUrl())
if sts:
token = self.cm.ph.getSearchGroups(data, '''(<meta[^>]+?_token[^>]+?/>)''')[0]
token = self.cm.ph.getSearchGroups(token, '''content=['"]([^"^']+?)['"]''')[0]
if '' != token and '/logout' in data:
self.HTTP_HEADER['X-CSRF-TOKEN'] = token
self.AJAX_HEADER['X-CSRF-TOKEN'] = token
self.loggedIn = True
return True
PlusDEDE.login = config.plugins.iptvplayer.plusdede_login.value
PlusDEDE.password = config.plugins.iptvplayer.plusdede_password.value
self.saveLoginMarker()
rm(self.COOKIE_FILE)
self.loggedIn = False
if '' == PlusDEDE.login.strip() or '' == PlusDEDE.password.strip():
self.sessionEx.open(MessageBox, _('The host %s requires registration. \nPlease fill your login and password in the host configuration. Available under blue button.' % self.getMainUrl()), type = MessageBox.TYPE_ERROR, timeout = 10 )
return False
url = self.getFullUrl('/login?popup=1')
sts, data = self.getPage(url)
if not sts: return False
sts, tmp = self.cm.ph.getDataBeetwenNodes(data, ('<form', '>'), ('</form', '>'))
if not sts: return False
actionUrl = self.getFullUrl(self.cm.ph.getSearchGroups(tmp, '''action=['"]([^'^"]+?)['"]''')[0])
tmp = self.cm.ph.getAllItemsBeetwenMarkers(tmp, '<input', '>')
post_data = {}
for item in tmp:
name = self.cm.ph.getSearchGroups(item, '''name=['"]([^'^"]+?)['"]''')[0]
value = self.cm.ph.getSearchGroups(item, '''value=['"]([^'^"]+?)['"]''')[0]
post_data[name] = value
post_data.update({'email':PlusDEDE.login, 'password':PlusDEDE.password})
# fill captcha
#############################################################################################
imgUrl = self.getFullUrl(self.cm.ph.getSearchGroups(data, '''<img[^>]+?src=['"]([^"^']+?)['"]''')[0])
if self.cm.isValidUrl(imgUrl):
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')
ret = self.cm.saveWebFile(filePath, imgUrl.replace('&', '&'), params)
if not ret.get('sts'):
SetIPTVPlayerLastHostError(_('Fail to get "%s".') % imgUrl)
return False
params = deepcopy(IPTVMultipleInputBox.DEF_PARAMS)
params['accep_label'] = self.cleanHtmlStr(self.cm.ph.getDataBeetwenNodes(data, ('<button', '>', 'submit'), ('</button', '>'))[1])
params['title'] = _('Captcha')
params['status_text'] = self.cleanHtmlStr(self.cm.ph.getDataBeetwenNodes(data, ('<label', '>', 'captcha'), ('</label', '>'))[1])
params['with_accept_button'] = True
params['list'] = []
item = deepcopy(IPTVMultipleInputBox.DEF_INPUT_PARAMS)
item['label_size'] = (300,80)
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])
name = self.cm.ph.getDataBeetwenNodes(data, ('<input', '>', 'captcha'), ('</input', '>'))[1]
printDBG(name)
name = self.cm.ph.getSearchGroups(name, '''name=['"]([^"^']+?)['"]''')[0]
printDBG(name)
post_data['captcha'] = retArg[0][0]
#############################################################################################
httpParams = dict(self.defaultParams)
httpParams['header'] = dict(self.AJAX_HEADER)
httpParams['header']['Referer'] = url
httpParams['header']['X-CSRF-TOKEN'] = self.cm.ph.getSearchGroups(data, '''(<meta[^>]+?_token[^>]+?/>)''')[0]
httpParams['header']['X-CSRF-TOKEN'] = self.cm.ph.getSearchGroups(httpParams['header']['X-CSRF-TOKEN'], '''content=['"]([^"^']+?)['"]''')[0]
error = ''
sts, data = self.cm.getPage(actionUrl, httpParams, post_data)
try:
tmp = byteify(json.loads(data))['content']
printDBG(tmp)
tmp = self.cm.ph.getAllItemsBeetwenNodes(tmp, ('<div', '>', 'alert'), ('</div', '>'))
tab = []
for t in tmp:
t = self.cleanHtmlStr(t)
if t == '': continue
tab.append(t)
error = ', '.join(tab)
except Exception:
printExc()
sts, data = self.getPage(self.getMainUrl())
if sts and '/logout' in data:
self.HTTP_HEADER['X-CSRF-TOKEN'] = httpParams['header']['X-CSRF-TOKEN']
self.AJAX_HEADER['X-CSRF-TOKEN'] = httpParams['header']['X-CSRF-TOKEN']
self.loggedIn = True
else:
if error == '': error = _('Login failed.')
SetIPTVPlayerLastHostError(error)
printDBG('tryTologin failed')
return self.loggedIn
def getVideoLinks(self, videoUrl):
printDBG("FilmezzEU.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
url = videoUrl
post_data = None
while True:
try:
httpParams = dict(self.defaultParams)
httpParams['return_data'] = False
sts, response = self.cm.getPage(url, httpParams, post_data)
videoUrl = response.geturl()
response.close()
except Exception:
printExc()
return []
if self.up.getDomain(self.getMainUrl()) in videoUrl:
sts, data = self.getPage(videoUrl)
if not sts: return []
if 'captcha' in data:
data = re.sub("<!--[\s\S]*?-->", "", data)
if 'google.com/recaptcha/' in data and 'sitekey' in data:
message = _('Link protected with google recaptcha v2.')
if True != self.loggedIn:
message += '\n' + _(
'Please fill your login and password in the host configuration (available under blue button) and try again.'
)
SetIPTVPlayerLastHostError(message)
break
elif '<input name="captcha"' in data:
data = self.cm.ph.getDataBeetwenMarkers(
data, '<div align="center">', '</form>')[1]
captchaTitle = self.cleanHtmlStr(
self.cm.ph.getDataBeetwenMarkers(data, '<h3',
'</h3>')[1])
captchaDesc = self.cleanHtmlStr(
self.cm.ph.getDataBeetwenMarkers(
data, '</h3>', '</span>')[1])
# parse form data
data = self.cm.ph.getDataBeetwenMarkers(
data, '<form', '</form>')[1]
imgUrl = self.cm.ph.getSearchGroups(
data, 'src="([^"]+?)"')[0]
if imgUrl != '': imgUrl = '/' + imgUrl
if imgUrl.startswith('/'):
imgUrl = urlparse.urljoin(videoUrl, imgUrl)
printDBG("img URL [%s]" % imgUrl)
actionUrl = self.cm.ph.getSearchGroups(
data, 'action="([^"]+?)"')[0]
if actionUrl != '': actionUrl = '/' + actionUrl
if actionUrl.startswith('/'):
actionUrl = urlparse.urljoin(videoUrl, actionUrl)
elif actionUrl == '':
actionUrl = videoUrl
captcha_post_data = dict(
re.findall(
r'''<input[^>]+?name=["']([^"^']*)["'][^>]+?value=["']([^"^']*)["'][^>]*>''',
data))
if self.cm.isValidUrl(imgUrl):
params = dict(self.defaultParams)
params['header'] = dict(params['header'])
params['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':
params['header']
})
filePath = GetTmpDir('.iptvplayer_captcha.jpg')
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'] = captchaTitle
params['status_text'] = captchaDesc
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]
post_data = captcha_post_data
url = actionUrl
if not sts:
return urlTab
else:
continue
tmp = re.compile('''<iframe[^>]+?src=['"]([^"^']+?)['"]''',
re.IGNORECASE).findall(data)
for url in tmp:
if 1 == self.up.checkHostSupport(url):
videoUrl = url
break
break
if self.cm.isValidUrl(videoUrl):
urlTab = self.up.getVideoLinkExt(videoUrl)
return urlTab
def getVideoLinks(self, videoUrl):
printDBG("KinomanCO.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
url = self.getFullUrl('/api/link/embed?width=500&height=500', 'api')
post_data = '{"code":"%s","secure": 1}' % (videoUrl)
videoUrl = ''
try:
while True:
httpParams = dict(self.defaultParams)
httpParams.update({'raw_post_data':True, 'ignore_http_code_ranges':[(401,401), (500,500)]})
httpParams['header'] = dict(httpParams['header'])
httpParams['header']['Content-Type'] = 'application/json; charset=UTF-8'
sts, data = self.getPage(url, httpParams, post_data)
printDBG(data)
if sts:
data = byteify(json.loads(data), '', True)
if not isinstance(data, str):
videoUrl = data['link']
elif 'captcha' in data.lower():
sts, data = self.getPage(self.getFullUrl('/api/captcha', 'api'))
if not sts:
SetIPTVPlayerLastHostError(_('Network connection failed.'))
break
data = byteify(json.loads(data), '', True)
captchaTitle = self._('Fill captcha')
imgUrl = data['image']
KinomanCO.CAPTCHA_HASHKEY = data['key']
self.defaultParams['header']['x-captcha-hashkey'] = KinomanCO.CAPTCHA_HASHKEY
if self.cm.isValidUrl(imgUrl):
header = dict(self.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, params)
if not ret.get('sts'):
SetIPTVPlayerLastHostError(_('Fail to get "%s".') % imgUrl)
return []
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)
params['vk_params'] = {'invert_letters_case':True}
ret = 0
retArg = self.sessionEx.waitForFinishOpen(IPTVMultipleInputBox, params)
printDBG(retArg)
if retArg and len(retArg) and retArg[0]:
printDBG(retArg[0])
KinomanCO.CAPTCHA_CHALLENGE = retArg[0][0]
self.defaultParams['header']['x-captcha-challenge'] = KinomanCO.CAPTCHA_CHALLENGE
continue
break
elif 'x-user-token' not in httpParams['header'] and '_user_token' in data:
msg = _('The host %s requires registration. \nPlease fill your login and password in the host configuration. Available under blue button.' % self.getMainUrl())
SetIPTVPlayerLastHostError(msg)
else:
SetIPTVPlayerLastHostError(_('Unknown server response: "%s"') % data)
else:
SetIPTVPlayerLastHostError(_('Network connection failed.'))
break
except Exception:
SetIPTVPlayerLastHostError(_('Unknown server response.'))
printExc()
directLink = False
if self.cm.isValidUrl(videoUrl):
if 0 == self.up.checkHostSupport(videoUrl):
params = dict(self.defaultParams)
params.update({'return_data':False})
try:
sts, response = self.cm.getPage(videoUrl, params)
videoUrl = response.geturl()
type = response.info().type.lower()
printDBG("type [%s]" % type)
if 'video' in type:
directLink = True
response.close()
except Exception:
printExc()
if directLink:
urlTab.append({'name':'direct_link', 'url':strwithmeta(videoUrl, {})})
else:
urlTab = self.up.getVideoLinkExt(videoUrl)
return urlTab
def listGetFreeCredits(self):
printDBG("StreamLiveTo.listGetFreeCredits")
baseUrl = self._getFullUrl('get_free_credits')
httpParams = dict(self.defaultParams)
httpParams['header'] = dict(self.HTTP_HEADER)
httpParams['header']['Referer'] = baseUrl
sts, data = self.getPage(baseUrl, httpParams)
if not sts:
SetIPTVPlayerLastHostError(_('Fail to get "%s".') % baseUrl)
return 0
sts, data = self.cm.ph.getDataBeetwenMarkers(data,
'<form method="post">',
'</form>')
m1 = 'recaptcha_challenge_field'
m2 = 'recaptcha_response_field'
errMsg1 = _('Fail to get captcha data.')
if sts:
captchaUrl = self.cm.ph.getSearchGroups(
data, '''['"](http[^"']+?recaptcha/api[^"']*?)["']''')[0]
if not sts or '' == captchaUrl or m1 not in data or m2 not in data:
SetIPTVPlayerLastHostError(errMsg1)
return 0
sts, data = self.getPage(captchaUrl, httpParams)
if not sts:
SetIPTVPlayerLastHostError(_('Fail to get "%s".') % captchaUrl)
return 0
challenge = self.cm.ph.getSearchGroups(
data, '''challenge\s*:\s*['"]([^'^"]+?)['"]''')[0]
lang = self.cm.ph.getSearchGroups(
data, '''lang\s*:\s*['"]([^'^"]+?)['"]''')[0]
server = self.cm.ph.getSearchGroups(
data, '''server\s*:\s*['"]([^'^"]+?)['"]''')[0]
site = self.cm.ph.getSearchGroups(
data, '''site\s*:\s*['"]([^'^"]+?)['"]''')[0]
if '' == challenge or '' == lang or '' == server or '' == site:
SetIPTVPlayerLastHostError(errMsg1)
return 0
captchaUrl = server + 'reload?c=%s&k=%s&reason=i&type=image&lang=%s&th=' % (
challenge, site, lang)
sts, data = self.getPage(captchaUrl, httpParams)
if not sts:
SetIPTVPlayerLastHostError(_('Fail to get "%s".') % captchaUrl)
return 0
sts, challenge = self.cm.ph.getDataBeetwenMarkers(
data, "finish_reload('", "'", False)
if not sts:
SetIPTVPlayerLastHostError(errMsg1)
return 0
imgUrl = 'http://www.google.com/recaptcha/api/image?c=' + challenge
#return
params = {
'maintype': 'image',
'subtypes': ['jpeg'],
'check_first_bytes': ['\xFF\xD8', '\xFF\xD9']
}
filePath = GetTmpDir('.iptvplayer_captcha.jpg')
ret = self.cm.saveWebFile(filePath, imgUrl, params)
if not ret.get('sts'):
SetIPTVPlayerLastHostError(_('Fail to get "%s".') % imgUrl)
return 0
from copy import deepcopy
params = deepcopy(IPTVMultipleInputBox.DEF_PARAMS)
params['accep_label'] = _('Send')
params['title'] = _('Answer')
params['list'] = []
item = deepcopy(IPTVMultipleInputBox.DEF_INPUT_PARAMS)
item['label_size'] = (300, 57)
item['input_size'] = (300, 25)
item['icon_path'] = filePath
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])
sts, data = self.cm.getPage(
baseUrl, httpParams, {
'recaptcha_challenge_field': challenge,
'recaptcha_response_field': retArg[0],
'submit': 'Get Free 10 Credits'
})
printDBG(data)
if 'got free' in data:
ret = 1
elif 'incorrect' in data:
ret = -1
if sts:
msg = self.cm.ph.getDataBeetwenMarkers(data,
'<div style="color:',
'</div>')[1]
SetIPTVPlayerLastHostError(self.cleanHtmlStr(msg))
else:
SetIPTVPlayerLastHostError(_('Fail to get "%s".') % baseUrl)
else:
SetIPTVPlayerLastHostError(_('Wrong answer.'))
return ret
def getLinksForVideo(self, cItem):
printDBG("NaszeKinoTv.getLinksForVideo [%s]" % cItem)
self.tryTologin()
if 1 == self.up.checkHostSupport(cItem.get('url', '')):
videoUrl = cItem['url'].replace('youtu.be/',
'youtube.com/watch?v=')
return self.up.getVideoLinkExt(videoUrl)
cacheKey = cItem['url']
cacheTab = self.cacheLinks.get(cacheKey, [])
if len(cacheTab): return cacheTab
self.cacheLinks = {}
sts, data = self.getPage(cItem['url'])
if not sts: return
cUrl = data.meta['url']
self.setMainUrl(cUrl)
paramsUrl = dict(self.defaultParams)
paramsUrl['header'] = dict(paramsUrl['header'])
##############################################################################################
while sts and 'captcha-info' in data:
# parse form data
data = self.cm.ph.getDataBeetwenMarkers(data, 'captcha-info',
'</form>')[1]
captchaTitle = self.cm.ph.getAllItemsBeetwenMarkers(
data, '<p', '</p>')
if len(captchaTitle):
captchaTitle = self.cleanHtmlStr(captchaTitle[-1])
else:
captchaTitle = ''
sendLabel = self.cleanHtmlStr(
self.cm.ph.getDataBeetwenMarkers(data, '<button',
'</button>')[1])
captchaLabel = self.cleanHtmlStr(
self.cm.ph.getSearchGroups(
data, '''\splaceholder=['"]([^'^"]+?)['"]''')[0])
captchaLabel = '%s %s' % (sendLabel, captchaLabel)
if captchaLabel.strip() == '': captchaLabel = _('Captcha')
if captchaTitle == '': captchaTitle = captchaLabel
sendLabel = _('Send')
imgUrl = self.getFullIconUrl(
self.cm.ph.getSearchGroups(
data,
'<img[^>]+?src="([^"]+?\.(:?jpe?g|png)(:?\?[^"]+?)?)"')[0],
cUrl)
actionUrl = self.getFullUrl(
self.cm.ph.getSearchGroups(data, 'action="([^"]+?)"')[0], cUrl)
if actionUrl == '': actionUrl = 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 []
params = deepcopy(IPTVMultipleInputBox.DEF_PARAMS)
params['accep_label'] = sendLabel
params['title'] = captchaLabel
params['status_text'] = captchaTitle
params['status_text_hight'] = 200
params['with_accept_button'] = True
params['list'] = []
item = deepcopy(IPTVMultipleInputBox.DEF_INPUT_PARAMS)
item['label_size'] = (660, 110)
item['input_size'] = (680, 25)
item['icon_path'] = filePath
item['title'] = _('Answer')
item['input']['text'] = ''
params['list'].append(item)
params['vk_params'] = {'invert_letters_case': True}
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 []
else:
return []
##############################################################################################
msg = self.cm.ph.getDataBeetwenNodes(data, ('', '>', 'alert-info'),
('</div', '>'), False)[1]
SetIPTVPlayerLastHostError(msg)
retTab = []
data = self.cm.ph.getDataBeetwenNodes(data, ('<tbody', '>'),
('</tbody', '>'), False)[1]
data = self.cm.ph.getAllItemsBeetwenMarkers(data, '<tr', '</tr>',
False)
for item in data:
url = self.getFullUrl(
self.cm.ph.getSearchGroups(item, '''href=['"]([^"^']+?)['"]''',
1, True)[0])
if url == '': continue
item = self.cm.ph.getAllItemsBeetwenMarkers(item, '<td', '</td>')
name = []
for t in item:
t = self.cleanHtmlStr(t)
if t != '': name.append(t)
name = ' | '.join(name)
retTab.append({
'name': name,
'url': strwithmeta(url, {'Referer': cUrl}),
'need_resolve': 1
})
if len(retTab):
self.cacheLinks[cacheKey] = retTab
return retTab
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 getSweetCaptchaRespond(self, data):
printDBG("FiliserTv.getSweetCaptchaRespond")
def _getFullUrl(url):
urlPrefix = 'http:'
if url.startswith('//'): url = urlPrefix + url
return url
def n(e, n):
a = ""
n = urllib.unquote(n)
for r in range(len(n) - 1, -1, -1):
t = n[r]
if (t >= "a" and "z" >= t) or (t >= "A" and "Z" >= t):
a += chr(65 + e.find(t) % 26)
else:
a += t
return a.lower()
retData = {}
printDBG(data)
url = _getFullUrl(
self.cm.ph.getSearchGroups(
data, '''['"]([^'^"]*?/captcha/[^'^"]*?)['"]''')[0])
url += 'mobile=1&_=' + str(int(time() * 1000))
sts, data = self.getPage(url)
if not sts: return retData
printDBG(data)
thumbFileTab = []
try:
data = byteify(json.loads(data))
imgUrlTab = []
for item in data["a"]:
imgUrlTab.append(
_getFullUrl(n(data['simple_key'], item['src'])))
imgUrlTab.append(_getFullUrl(n(data['simple_key'], data['q'])))
printDBG(imgUrlTab)
errorOccurred = False
params = {
'maintype': 'image',
'subtypes': ['png'],
'check_first_bytes': ['\x89\x50\x4E\x47']
}
for idx in range(len(imgUrlTab)):
imgUrl = imgUrlTab[idx]
filePath = GetTmpDir('.iptvplayer_captcha_%s.png' % idx)
ret = self.cm.saveWebFile(filePath, imgUrl, params)
if not ret.get('sts'):
SetIPTVPlayerLastHostError(_('Fail to get "%s".') % imgUrl)
errorOccurred = True
break
thumbFileTab.append(filePath)
if not errorOccurred:
verify = data['drag']['verify']
challenge = data['drag']['challenge']
printDBG(thumbFileTab)
printDBG("OK")
printDBG(verify)
printDBG(challenge)
retArg = self.sessionEx.waitForFinishOpen(
UnCaptchaSweetCaptchaWidget,
params={
'icon_list': thumbFileTab,
'title': verify,
'challenge': challenge
})
printDBG('>>>>>>>> Captcha response %r' % (retArg))
if retArg is not None and len(retArg) and retArg[0]:
answer = retArg[0]['resp_idx']
printDBG('>>>>>>>> Captcha answer[%s]' % (answer))
retData = {
'sckey': data['k'],
'scvalue': data['a'][answer]['hash'][5:15],
'scvalue2': 0
}
else:
retData = None
except Exception:
printExc()
for file in thumbFileTab:
rm(file)
return retData
def processCaptcha(self, key):
post_data = None
token = ''
iteration = 0
reCaptchaUrl = 'http://www.google.com/recaptcha/api/fallback?k=%s' % (
key)
while iteration < 20:
#,'cookiefile':self.COOKIE_FILE, 'use_cookie': True, 'load_cookie': True, 'save_cookie':True
sts, data = self.cm.getPage(reCaptchaUrl, {
'header': self.HTTP_HEADER,
'raw_post_data': True
},
post_data=post_data)
if not sts:
SetIPTVPlayerLastHostError(
_('Fail to get "%s".') % reCaptchaUrl)
return ''
imgUrl = self.cm.ph.getSearchGroups(
data, '"(/recaptcha/api2/payload[^"]+?)"')[0]
iteration += 1
message = self.cm.ph.getSearchGroups(
data,
'<label[^>]+class="fbc-imageselect-message-text"[^>]*>(.*?)</label>'
)[0]
if '' == message:
message = self.cm.ph.getSearchGroups(
data,
'<div[^>]+class="fbc-imageselect-message-error">(.*?)</div>'
)[0]
if '' == message:
token = self.cm.ph.getDataBeetwenNodes(
data, ('<div', '>', 'verification-token'), ('</div', '>'),
False)[1]
token = self.cm.ph.getDataBeetwenNodes(data,
('<textarea', '>'),
('</textarea', '>'),
False)[1].strip()
if token == '':
token = self.cm.ph.getSearchGroups(
data, '"this\.select\(\)">(.*?)</textarea>')[0]
if token == '':
token = self.cm.ph.getDataBeetwenNodes(
data, ('<textarea', '>'), ('</textarea', '>'),
False)[1].strip()
if '' != token:
printDBG('>>>>>>>> Captcha token[%s]' % (token))
else:
printDBG('>>>>>>>> Captcha Failed\n\n%s\n\n' % data)
break
cval = self.cm.ph.getSearchGroups(data,
'name="c"\s+value="([^"]+)')[0]
imgUrl = 'https://www.google.com%s' % (imgUrl.replace(
'&', '&'))
message = clean_html(message)
accepLabel = clean_html(
self.cm.ph.getSearchGroups(
data, 'type="submit"\s+value="([^"]+)')[0])
filePath = GetTmpDir('.iptvplayer_captcha.jpg')
printDBG(">>>>>>>> Captcha message[%s]" % (message))
printDBG(">>>>>>>> Captcha accep label[%s]" % (accepLabel))
printDBG(">>>>>>>> Captcha imgUrl[%s] filePath[%s]" %
(imgUrl, filePath))
params = {
'maintype': 'image',
'subtypes': ['jpeg'],
'check_first_bytes': ['\xFF\xD8', '\xFF\xD9']
}
ret = self.cm.saveWebFile(filePath, imgUrl, params)
if not ret.get('sts'):
SetIPTVPlayerLastHostError(_('Fail to get "%s".') % imgUrl)
break
retArg = self.sessionEx.waitForFinishOpen(
UnCaptchaReCaptchaWidget,
imgFilePath=filePath,
message=message,
title="reCAPTCHA v2",
additionalParams={'accep_label': accepLabel})
printDBG('>>>>>>>> Captcha response[%s]' % (retArg))
if retArg is not None and len(retArg) and retArg[0]:
answer = retArg[0]
printDBG('>>>>>>>> Captcha answer[%s]' % (answer))
post_data = urllib.urlencode({
'c': cval,
'response': answer
},
doseq=True)
else:
break
return token