_ Git - youtube-dl/blob - youtube_dl/extractor/adobepass.py

   1 # -*- coding: utf-8 -*-
   2 from __future__ import unicode_literals
   3
   4 import re
   5 import time
   6 import xml.etree.ElementTree as etree
   7
   8 from .common import InfoExtractor
   9 from ..compat import compat_urlparse
  10 from ..utils import (
  11     unescapeHTML,
  12     urlencode_postdata,
  13     unified_timestamp,
  14     ExtractorError,
  15 )
  16
  17
  18 class AdobePassIE(InfoExtractor):
  19     _SERVICE_PROVIDER_TEMPLATE = 'https://sp.auth.adobe.com/adobe-services/%s'
  20     _USER_AGENT = 'Mozilla/5.0 (X11; Linux i686; rv:47.0) Gecko/20100101 Firefox/47.0'
  21
  22     @staticmethod
  23     def _get_mvpd_resource(provider_id, title, guid, rating):
  24         channel = etree.Element('channel')
  25         channel_title = etree.SubElement(channel, 'title')
  26         channel_title.text = provider_id
  27         item = etree.SubElement(channel, 'item')
  28         resource_title = etree.SubElement(item, 'title')
  29         resource_title.text = title
  30         resource_guid = etree.SubElement(item, 'guid')
  31         resource_guid.text = guid
  32         resource_rating = etree.SubElement(item, 'media:rating')
  33         resource_rating.attrib = {'scheme': 'urn:v-chip'}
  34         resource_rating.text = rating
  35         return '<rss version="2.0" xmlns:media="http://search.yahoo.com/mrss/">' + etree.tostring(channel).decode() + '</rss>'
  36
  37     def _extract_mvpd_auth(self, url, video_id, requestor_id, resource):
  38         def xml_text(xml_str, tag):
  39             return self._search_regex(
  40                 '<%s>(.+?)</%s>' % (tag, tag), xml_str, tag)
  41
  42         def is_expired(token, date_ele):
  43             token_expires = unified_timestamp(re.sub(r'[_ ]GMT', '', xml_text(token, date_ele)))
  44             return token_expires and token_expires <= int(time.time())
  45
  46         def raise_mvpd_required():
  47             raise ExtractorError(
  48                 'This video is only available for users of participating TV providers. '
  49                 'Use --ap-mso-id to specify Adobe Pass Multiple-system operator Identifier '
  50                 'and --netrc to provide account credentials.', expected=True)
  51
  52         mvpd_headers = {
  53             'ap_42': 'anonymous',
  54             'ap_11': 'Linux i686',
  55             'ap_z': self._USER_AGENT,
  56             'User-Agent': self._USER_AGENT,
  57         }
  58
  59         guid = xml_text(resource, 'guid')
  60         requestor_info = self._downloader.cache.load('mvpd', requestor_id) or {}
  61         authn_token = requestor_info.get('authn_token')
  62         if authn_token and is_expired(authn_token, 'simpleTokenExpires'):
  63             authn_token = None
  64         if not authn_token:
  65             # TODO add support for other TV Providers
  66             mso_id = self._downloader.params.get('ap_mso_id')
  67             if not mso_id:
  68                 raise_mvpd_required()
  69             username, password = self._get_netrc_login_info(mso_id)
  70             if not username or not password:
  71                 return raise_mvpd_required()
  72
  73             def post_form(form_page_res, note, data={}):
  74                 form_page, urlh = form_page_res
  75                 post_url = self._html_search_regex(r'<form[^>]+action=(["\'])(?P<url>.+?)\1', form_page, 'post url', group='url')
  76                 if not re.match(r'https?://', post_url):
  77                     post_url = compat_urlparse.urljoin(urlh.geturl(), post_url)
  78                 form_data = self._hidden_inputs(form_page)
  79                 form_data.update(data)
  80                 return self._download_webpage_handle(
  81                     post_url, video_id, note, data=urlencode_postdata(form_data), headers={
  82                         'Content-Type': 'application/x-www-form-urlencoded',
  83                     })
  84
  85             provider_redirect_page_res = self._download_webpage_handle(
  86                 self._SERVICE_PROVIDER_TEMPLATE % 'authenticate/saml', video_id,
  87                 'Downloading Provider Redirect Page', query={
  88                     'noflash': 'true',
  89                     'mso_id': mso_id,
  90                     'requestor_id': requestor_id,
  91                     'no_iframe': 'false',
  92                     'domain_name': 'adobe.com',
  93                     'redirect_url': url,
  94                 })
  95             provider_login_page_res = post_form(
  96                 provider_redirect_page_res, 'Downloading Provider Login Page')
  97             login_data = {}
  98             if mso_id == 'DTV':
  99                 login_data = {
 100                     'username': username,
 101                     'password': password,
 102                 }
 103             elif mso_id == 'Rogers':
 104                 login_data = {
 105                     'UserName': username,
 106                     'UserPassword': password,
 107                 }
 108             mvpd_confirm_page_res = post_form(provider_login_page_res, 'Logging in', login_data)
 109             if mso_id == 'DTV':
 110                 post_form(mvpd_confirm_page_res, 'Confirming Login')
 111
 112             session = self._download_webpage(
 113                 self._SERVICE_PROVIDER_TEMPLATE % 'session', video_id,
 114                 'Retrieving Session', data=urlencode_postdata({
 115                     '_method': 'GET',
 116                     'requestor_id': requestor_id,
 117                 }), headers=mvpd_headers)
 118             if '<pendingLogout' in session:
 119                 self._downloader.cache.store('mvpd', requestor_id, {})
 120                 return self._extract_mvpd_auth(url, video_id, requestor_id, resource)
 121             authn_token = unescapeHTML(xml_text(session, 'authnToken'))
 122             requestor_info['authn_token'] = authn_token
 123             self._downloader.cache.store('mvpd', requestor_id, requestor_info)
 124
 125         authz_token = requestor_info.get(guid)
 126         if authz_token and is_expired(authz_token, 'simpleTokenTTL'):
 127             authz_token = None
 128         if not authz_token:
 129             authorize = self._download_webpage(
 130                 self._SERVICE_PROVIDER_TEMPLATE % 'authorize', video_id,
 131                 'Retrieving Authorization Token', data=urlencode_postdata({
 132                     'resource_id': resource,
 133                     'requestor_id': requestor_id,
 134                     'authentication_token': authn_token,
 135                     'mso_id': xml_text(authn_token, 'simpleTokenMsoID'),
 136                     'userMeta': '1',
 137                 }), headers=mvpd_headers)
 138             if '<pendingLogout' in authorize:
 139                 self._downloader.cache.store('mvpd', requestor_id, {})
 140                 return self._extract_mvpd_auth(url, video_id, requestor_id, resource)
 141             authz_token = unescapeHTML(xml_text(authorize, 'authzToken'))
 142             requestor_info[guid] = authz_token
 143             self._downloader.cache.store('mvpd', requestor_id, requestor_info)
 144
 145         mvpd_headers.update({
 146             'ap_19': xml_text(authn_token, 'simpleSamlNameID'),
 147             'ap_23': xml_text(authn_token, 'simpleSamlSessionIndex'),
 148         })
 149
 150         short_authorize = self._download_webpage(
 151             self._SERVICE_PROVIDER_TEMPLATE % 'shortAuthorize',
 152             video_id, 'Retrieving Media Token', data=urlencode_postdata({
 153                 'authz_token': authz_token,
 154                 'requestor_id': requestor_id,
 155                 'session_guid': xml_text(authn_token, 'simpleTokenAuthenticationGuid'),
 156                 'hashed_guid': 'false',
 157             }), headers=mvpd_headers)
 158         if '<pendingLogout' in short_authorize:
 159             self._downloader.cache.store('mvpd', requestor_id, {})
 160             return self._extract_mvpd_auth(url, video_id, requestor_id, resource)
 161         return short_authorize