1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
|
'''
This is derived from https://github.com/sjp/GOMstreamer
and carries the following licence
Copyright 2010 Simon Potter, Tomas Herman
Copyright 2011 Simon Potter
Copyright 2011 Fj (fj.mail@gmail.com)
Copyright 2012 Niall McAndrew (niallm90@gmail.com)
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
'''
from livestreamer.compat import str, bytes, urlencode
from livestreamer.plugins import Plugin, PluginError, NoStreamsError
from livestreamer.stream import HTTPStream
from livestreamer.utils import urlget, urllib
from livestreamer.options import Options
import xml.dom.minidom, re
import cookielib
import Cookie
class GomTV(Plugin):
options = Options({
"cookie": None,
"username": None,
"password": None,
})
@classmethod
def can_handle_url(self, url):
return "gomtv.net" in url
def _get_streams(self):
options = self.options
# Setting urllib up so that we can store cookies
self.cookiejar = cookielib.LWPCookieJar()
self.opener = urllib.build_opener(urllib.HTTPCookieProcessor(self.cookiejar))
if options.get("cookie"):
self.authenticate(cookie=options.get("cookie"))
else:
self.authenticate(options.get("username"), options.get("password"))
streams = {}
qualities = ["HQ", "SQ", "HQTest", "SQTest"]
streamChoice = "both"
response = self.grabLivePage(self.url)
goxUrls = []
validGoxFound = False
failedGoxAll = False
for quality in qualities:
urls = self.parseHTML(response, quality)
for url in urls:
# Grab the response of the URL listed on the Live page for a stream
goxFile = urlget(url, opener=self.opener)
# The response for the GOX XML if an incorrect stream quality is chosen is 1002.
if (goxFile != '1002' and goxFile != ''):
streamUrl = self.parseStreamURL(goxFile)
req = urllib.Request(streamUrl, headers={"User-Agent": "KPeerClient"})
streams[quality] = HTTPStream(self.session, req)
validGoxFound = True
return streams
def authenticate(self, username=None, password=None, cookie=None):
if (username is None or password is None) and cookie is None:
raise PluginError("GOMTV.net Requires a username and password or cookie")
if cookie is not None:
name,value = cookie.split("=")
c = cookielib.Cookie(version=0, name=name, value=value,
port=None, port_specified=False, domain='gomtv.net',
domain_specified=False, domain_initial_dot=False, path='/',
path_specified=True, secure=False, expires=None, discard=True,
comment=None, comment_url=None, rest={'HttpOnly': None},
rfc2109=False)
self.cookiejar.set_cookie(c)
else:
values = {
'cmd': 'login',
'rememberme': '1',
'mb_username': username,
'mb_password': password
}
data = urlencode(values)
# Now expects to log in only via the website. Thanks chrippa.
headers = {'Referer': 'http://www.gomtv.net/'}
request = urllib.Request('https://ssl.gomtv.net/userinfo/loginProcess.gom', data, headers)
urlget(request, opener=self.opener)
req = urllib.Request('http://www.gomtv.net/forum/list.gom?m=my')
if 'Please need login' in urlget(req, opener=self.opener):
raise PluginError("Authentication failed")
# The real response that we want are the cookies, so returning None is fine.
return
def getEventLivePageURL(self, gomtvLiveURL, response):
match = re.search(' \"(.*)\";', response)
assert match, 'Event Live Page URL not found'
return urljoin(gomtvLiveURL, match.group(1))
def getSeasonURL(self, gomtvURL):
# Getting season url from the 'Go Live!' button on the main page.
match = re.search('.*liveicon"><a href="([^"]*)"', urlget(gomtvURL, opener=self.opener))
assert match, 'golive_btn href not found'
return match.group(1)
def grabLivePage(self, gomtvLiveURL):
response = urlget(gomtvLiveURL, opener=self.opener)
# If a special event occurs, we know that the live page response
# will just be some JavaScript that redirects the browser to the
# real live page. We assume that the entireity of this JavaScript
# is less than 200 characters long, and that real live pages are
# more than that.
if len(response) < 200:
# Grabbing the real live page URL
gomtvLiveURL = self.getEventLivePageURL(gomtvLiveURL, response)
response = urlget(gomtvLiveURL, opener=self.opener)
return response
def parseHTML(self, response, quality):
urlFromHTML = None
# Parsing through the live page for a link to the gox XML file.
# Quality is simply passed as a URL parameter e.g. HQ, SQ, SQTest
try:
patternHTML = r'[^/]+var.+(http://www.gomtv.net/gox[^;]+;)'
urlFromHTML = re.search(patternHTML, response).group(1)
urlFromHTML = re.sub(r'\" \+ playType \+ \"', quality, urlFromHTML)
except AttributeError:
pass
# Finding the title of the stream, probably not necessary but
# done for completeness
try:
patternTitle = r'this\.title[^;]+;'
titleFromHTML = re.search(patternTitle, response).group(0)
titleFromHTML = re.search(r'\"(.*)\"', titleFromHTML).group(0)
titleFromHTML = re.sub(r'"', '', titleFromHTML)
urlFromHTML = re.sub(r'"\+ tmpThis.title[^;]+;', titleFromHTML, urlFromHTML)
except AttributeError:
pass
# Check for multiple streams going at the same time, and extract the conid and the title
# Those streams have the class "live_now"
patternLive = r'<a\shref=\"/live/index.gom\?conid=(?P<conid>\d+)\"\sclass=\"live_now\"\stitle=\"(?P<title>[^\"]+)'
live_streams = re.findall(patternLive, response)
if len(live_streams) > 1:
liveUrls = []
options = range(len(live_streams))
for i in options:
# Modify the urlFromHTML according to the user
singleUrlFromHTML = re.sub(r'conid=\d+', 'conid=' + live_streams[i][0], urlFromHTML)
singleTitleHTML = '+'.join(live_streams[i][1].split(' '))
singleUrlFromHTML = re.sub(r'title=[\w|.|+]*', 'title=' + singleTitleHTML, singleUrlFromHTML)
liveUrls.append(singleUrlFromHTML)
return liveUrls
else:
if urlFromHTML is None:
return []
else:
return [urlFromHTML]
def parseStreamURL(self, response):
# Grabbing the gomcmd URL
try:
streamPattern = r'<REF href="([^"]*)"\s*/>'
regexResult = re.search(streamPattern, response).group(1)
except AttributeError:
return None
regexResult = urllib.unquote(regexResult)
regexResult = re.sub(r'&', '&', regexResult)
# SQ and SQTest streams can be gomp2p links, with actual stream address passed as a parameter.
if regexResult.startswith('gomp2p://'):
regexResult, n = re.subn(r'^.*LiveAddr=', '', regexResult)
# Cosmetics, getting rid of the HTML entity, we don't
# need either of the " character or "
regexResult = regexResult.replace('"', '')
return regexResult
__plugin__ = GomTV
|
