def _configure_http_proxy(opt):
'''
Configure an HTTP proxy. Return a list of handlers to be given to
urllib2.build_opener().
'''
schemes = {}
for scheme in ('ftp', 'http', 'https'):
schemes[scheme] = opt.proxy_url
host = urlparse.urlsplit(opt.source_url)[1]
log.debug("Using '%s' as URI host for '%s'", host, opt.source_url)
log.debug("Installing handlers: %s", schemes)
proxy_handler = urllib2.ProxyHandler(schemes)
if opt.proxy_user and opt.proxy_pass:
log.debug("Configuring HTTP proxy authentication")
if not opt.proxy_pass:
log.error("HTTP proxy password ")
raise BadProxySpecificationError(
"No password given for proxy user '%s'" % opt.proxy_user)
pwmgr = InstrumentedHTTPPassManager()
pwmgr.add_password(None, host, opt.proxy_user, opt.proxy_pass)
proxy_auth_handler = urllib2.ProxyBasicAuthHandler(pwmgr)
return (proxy_handler, proxy_auth_handler)
else:
return (proxy_handler,)
def getFEED( url , postdata=None , proxy = False):
try:
print 'HULU --> common :: getFEED :: url = '+url
if proxy == True:
us_proxy = 'http://' + addoncompat.get_setting('us_proxy') + ':' + addoncompat.get_setting('us_proxy_port')
proxy_handler = urllib2.ProxyHandler({'http':us_proxy})
if addoncompat.get_setting('us_proxy_pass') <> '' and addoncompat.get_setting('us_proxy_user') <> '':
print 'Using authenticated proxy: ' + us_proxy
password_mgr = urllib2.HTTPPasswordMgrWithDefaultRealm()
password_mgr.add_password(None, us_proxy, addoncompat.get_setting('us_proxy_user'), addoncompat.get_setting('us_proxy_pass'))
proxy_auth_handler = urllib2.ProxyBasicAuthHandler(password_mgr)
opener = urllib2.build_opener(proxy_handler, proxy_auth_handler)
else:
print 'Using proxy: ' + us_proxy
opener = urllib2.build_opener(proxy_handler)
urllib2.install_opener(opener)
if postdata == None:
req = urllib2.Request(url)
else:
req = urllib2.Request(url,postdata)
req.add_header('User-Agent', 'Mozilla/4.0 (compatible; MSIE 8.0; Windows NT 6.1)')
req.add_header('Referer', 'http://download.hulu.com/hulu10.html')
#req.add_header('x-flash-version', '11,1,102,55')
response = urllib2.urlopen(req)
link=response.read()
response.close()
except urllib2.URLError, e:
print 'Error reason: ', e
heading = 'Error'
message = e
duration = 10000
xbmc.executebuiltin('XBMC.Notification("%s", "%s", %s)' % ( heading, message, duration) )
return False
def getProxyRequest(self, url):
USER_AGENT = 'Mozilla/5.0 (Windows NT 6.3; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/41.0.2272.101 Safari/537.36'
headers = {'User-Agent':USER_AGENT,
'Accept':"text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8",
'Accept-Encoding':'gzip,deflate,sdch',
'Accept-Language':'en-US,en;q=0.8'}
if (self.addon.getSetting('us_proxy_enable') == 'true'):
us_proxy = 'http://%s:%s' % (self.addon.getSetting('us_proxy'), self.addon.getSetting('us_proxy_port'))
proxy_handler = urllib2.ProxyHandler({'http':us_proxy})
if self.addon.getSetting('us_proxy_pass') <> '' and self.addon.getSetting('us_proxy_user') <> '':
password_mgr = urllib2.HTTPPasswordMgrWithDefaultRealm()
password_mgr.add_password(None, us_proxy, self.addon.getSetting('us_proxy_user'), self.addon.getSetting('us_proxy_pass'))
proxy_auth_handler = urllib2.ProxyBasicAuthHandler(password_mgr)
opener = urllib2.build_opener(proxy_handler, proxy_auth_handler)
else:
opener = urllib2.build_opener(proxy_handler)
else:
opener = urllib2.build_opener()
urllib2.install_opener(opener)
req = urllib2.Request(url.encode(UTF8), None, headers)
try:
response = urllib2.urlopen(req, timeout=120)
page = response.read()
if response.info().getheader('Content-Encoding') == 'gzip':
page = zlib.decompress(page, zlib.MAX_WBITS + 16)
except urllib2.URLError, e:
xbmc.executebuiltin('XBMC.Notification("%s", "%s", %s)' % (self.addonName, e , 5000) )
page = ""
def SHOWS(url):
if __settings__.getSetting('proxy_use') == 'true':
proxy_server = None
proxy_type_id = 0
proxy_port = 8080
proxy_user = None
proxy_pass = None
try:
proxy_server = __settings__.getSetting('proxy_server')
proxy_type_id = __settings__.getSetting('proxy_type')
proxy_port = __settings__.getSetting('proxy_port')
proxy_user = __settings__.getSetting('proxy_user')
proxy_pass = __settings__.getSetting('proxy_pass')
except:
pass
passmgr = urllib2.HTTPPasswordMgrWithDefaultRealm()
proxy_details = 'http://' + proxy_server + ':' + proxy_port
passmgr.add_password(None, proxy_details, proxy_user, proxy_pass)
authinfo = urllib2.ProxyBasicAuthHandler(passmgr)
proxy_support = urllib2.ProxyHandler({"http": proxy_details})
opener = urllib2.build_opener(proxy_support, authinfo)
urllib2.install_opener(opener)
f = urllib2.urlopen('http://www.itv.com/hub/shows')
buf = f.read()
buf = re.sub('&', '&', buf)
buf = re.sub('·', '', buf)
#print "BUF %s" % buf
f.close()
buf = buf.split(
'grid-list__item width--one-half width--custard--one-third')
for p in buf:
try:
linkurl = re.compile('href="(.+?)"').findall(p)[0]
#print linkurl
image = re.compile('srcset="(.+?)"').findall(p)[0].replace(
'w=304&h=174', 'w=800&h=450')
#print image
name = re.compile(
'"tout__title complex-link__target theme__target">(.+?)</h3',
re.DOTALL).findall(p)[0].strip()
#print name
episodes = re.compile('"tout__meta theme__meta">(.+?)</p',
re.DOTALL).findall(p)[0].strip()
#print episodes
if episodes == '1 episode':
addDir2(name + ' - ' + episodes,
linkurl,
3,
'',
'',
image,
'',
isFolder=False)
else:
if not 'no episodes' in episodes.lower():
addDir(name + ' - ' + episodes, linkurl, 2, image)
except:
pass
setView('tvshows', 'show')
def _prepare_proxy(self, ip, port, username='', password='', socks5=True):
if (socks5 == True):
if ((password is not '') and (username is not '')):
print 'Using socks5 authenticated proxy: ' + ip + ':' + port
opener = urllib2.build_opener(
SocksiPyHandler(socks.PROXY_TYPE_SOCKS5, ip, int(port),
True, username, password))
else:
print 'Using socks5 proxy: ' + ip + ':' + port
opener = urllib2.build_opener(
SocksiPyHandler(socks.PROXY_TYPE_SOCKS5, ip, int(port)))
elif (socks5 == False):
us_proxy = 'http://' + ip + ':' + port
proxy_handler = urllib2.ProxyHandler({'http': us_proxy})
if ((password is not '') and (username is not '')):
print 'Using authenticated proxy: ' + us_proxy
password_mgr = urllib2.HTTPPasswordMgrWithDefaultRealm()
password_mgr.add_password(None, us_proxy, username, password)
proxy_auth_handler = urllib2.ProxyBasicAuthHandler(
password_mgr)
opener = urllib2.build_opener(
proxy_handler, proxy_auth_handler,
urllib2.HTTPCookieProcessor(self._cj))
else:
print 'Using proxy: ' + us_proxy
opener = urllib2.build_opener(
proxy_handler, urllib2.HTTPCookieProcessor(self._cj))
return opener
def get_urlopen():
proxy_type = get_prefs('proxy_type')
if proxy_type == 'http':
scheme = 'http'
host = str(get_prefs('proxy_host'))
port = str(get_prefs('proxy_port'))
url = scheme + '://' + host + ':' + port
if get_prefs('proxy_auth'):
proxy_support = urllib2.ProxyHandler({'http': url, 'https': url})
username = str(get_prefs('proxy_auth_name'))
password = str(get_prefs('proxy_auth_password'))
auth_handler = urllib2.ProxyBasicAuthHandler()
auth_handler.add_password(None, url, username, password)
return urllib2.build_opener(proxy_support, auth_handler).open
else:
proxy_support = urllib2.ProxyHandler({'http': url, 'https': url})
return urllib2.build_opener(proxy_support).open
elif proxy_type == 'system':
if 'http_proxy' in os.environ and os.environ["http_proxy"]:
url = os.environ["http_proxy"]
elif 'HTTP_PROXY' in os.environ and os.environ["HTTP_PROXY"]:
url = os.environ["HTTP_PROXY"]
else:
url = None
if not url:
return urllib2.urlopen
else:
proxy_support = urllib2.ProxyHandler({'http': url, 'https': url})
return urllib2.build_opener(proxy_support).open
else:
return urllib2.urlopen
def POST(url, params, headers=None, proxy=None, proxyauth=None, debug=0):
try:
proxy_handler = urllib2.ProxyHandler()
proxy_auth_handler = urllib2.ProxyBasicAuthHandler()
if proxy != None:
proxy_handler = urllib2.ProxyHandler(proxy)
if proxyauth != None:
proxy_auth_handler.add_password(proxyauth)
cj = cookielib.CookieJar()
opener = urllib2.build_opener(urllib2.HTTPCookieProcessor(cj),
urllib2.HTTPHandler(debuglevel=debug),
proxy_handler, proxy_auth_handler)
urllib2.install_opener(opener)
encodedparams = urllib.urlencode(params)
if headers == None:
req = urllib2.Request(url, encodedparams)
else:
req = urllib2.Request(url, encodedparams, headers=headers)
resp = urllib2.urlopen(req)
data = {"HEADERS": resp.info(), "RESPONSE": resp.read()}
resp.close()
return data
except urllib2.HTTPError as e:
print e.code
print e.read()
def scrapeIntel(url, regex):
try:
if proxyEnabled == "yes":
proxy_url = "http://%s:%s" % (options.proxy, options.proxy_port)
https_url = "https://%s:%s" % (options.proxy, options.proxy_port)
proxy_support = urllib2.ProxyHandler({
'http': proxy_url,
'https': https_url
})
if options.proxy_user:
password_mgr = urllib2.HTTPPasswordMgrWithDefaultRealm()
password_mgr.add_password(None, proxy_url, options.proxy_user,
options.proxy_pass)
proxy_auth_handler = urllib2.ProxyBasicAuthHandler(
password_mgr)
opener = urllib2.build_opener(proxy_support,
proxy_auth_handler)
urllib2.install_opener(opener)
else:
opener = urllib2.build_opener(proxy_support)
urllib2.install_opener(opener)
print "Grabbing data from: " + url
webSite = urllib2.urlopen(url).read()
return compileOutput(webSite, regex)
except:
import traceback
traceback.print_exc()
print 'Connection Failed: ' + url
return "false"
def urlopen(url, proxies=None, data=None):
global _opener
if not proxies:
proxies = urllib.getproxies()
headers = {
'User-Agent': UA_STR,
'Accept-Encoding': 'gzip;q=1.0, deflate;q=0.9, identity;q=0.5'
}
req = urllib2.Request(url, data, headers)
proxy_support = urllib2.ProxyHandler(proxies)
if _opener is None:
pwd_manager = handlepasswd()
handlers = [
proxy_support,
urllib2.UnknownHandler,
HttpWithGzipHandler,
urllib2.HTTPBasicAuthHandler(pwd_manager),
urllib2.ProxyBasicAuthHandler(pwd_manager),
urllib2.HTTPDigestAuthHandler(pwd_manager),
urllib2.ProxyDigestAuthHandler(pwd_manager),
urllib2.HTTPDefaultErrorHandler,
urllib2.HTTPRedirectHandler,
]
if hasattr(httplib, 'HTTPS'):
handlers.append(HttpsWithGzipHandler)
_opener = urllib2.build_opener(*handlers)
# print _opener.handlers
urllib2.install_opener(_opener)
return _opener.open(req)
def _handle_proxy(self, *args):
"""Handle the connection to weather site through a proxy."""
# Delete the args parameter cause we don't use it
del args
# Get authentication info
user, password = self.proxy_auth_dialog.get_auth_data()
# Clear user name and password for security
self.proxy_auth_dialog.user_text.text = u''
self.proxy_auth_dialog.password_text.text = u''
# TODO: Fix the problem with scape characters in passwords
http_proxy_uri = ''.join([u'http://',
user,
u':',
r'%s' % password,
u'@',
self.prognos_app.host,
u':',
self.prognos_app.port])
proxy_handler = urllib2.ProxyHandler({'http': http_proxy_uri})
proxy_auth_handler = urllib2.ProxyBasicAuthHandler()
# Build and install an opener for using it globally
proxy_opener = urllib2.build_opener(proxy_handler,
proxy_auth_handler)
urllib2.install_opener(opener=proxy_opener)
# Connect to weather site through the proxy
self.fetch_weather()
def init():
global proxyenable
proxyenable = False
global proxy_username
global proxy_password
global proxy_host
global proxy_port
global status
status = ''
global DownloadedFolder
DownloadedFolder = 'downloaded'
global templist
templist = []
global download_counter
download_counter = 0
global no_thread_link
global no_thread_per_file
no_thread_link = 4
no_thread_per_file = 4
global shared_bytes_var
##############################################Init Methods ########################################
shared_bytes_var = multiprocessing.Value(
c_int, 0) # a ctypes var that counts the bytes already downloaded
if proxyenable:
proxy_handler = urllib2.ProxyHandler(
{'http': proxy_host + ':' + proxy_port + '/'})
proxy_auth_handler = urllib2.ProxyBasicAuthHandler()
proxy_auth_handler.add_password('realm', proxy_host, proxy_username,
proxy_password)
opener = urllib2.build_opener(proxy_handler)
urllib2.install_opener(opener)
def _opener(self):
build = [urllib2.HTTPHandler()]
if self.request.redirect:
build.append(urllib2.HTTPRedirectHandler())
if self.request.proxy_host and self.request.proxy_port:
build.append(urllib2.ProxyHandler(
{self.request.proxy_protocol: self.request.proxy_host + ':' + str(self.request.proxy_port)}))
if self.request.proxy_username:
proxy_auth_handler = urllib2.ProxyBasicAuthHandler()
proxy_auth_handler.add_password('realm', 'uri', self.request.proxy_username,
self.request.proxy_password)
build.append(proxy_auth_handler)
if self.request.cookies:
self.request.cookies = os.path.join(self._dirname, self.request.cookies)
self.cookies = cookielib.MozillaCookieJar()
if os.path.isfile(self.request.cookies):
self.cookies.load(self.request.cookies)
build.append(urllib2.HTTPCookieProcessor(self.cookies))
urllib2.install_opener(urllib2.build_opener(*build))
def TVNPlayerItem(type, id):
if __settings__.getSetting(
'checkClientip') == 'False' and __settings__.getSetting(
'pl_proxy') == '':
__settings__.openSettings()
else:
if __settings__.getSetting('checkClientip') == 'False':
pl_proxy = 'http://' + __settings__.getSetting(
'pl_proxy') + ':' + __settings__.getSetting('pl_proxy_port')
proxy_handler = urllib2.ProxyHandler({'http': pl_proxy})
if __settings__.getSetting(
'pl_proxy_pass') <> '' and __settings__.getSetting(
'pl_proxy_user') <> '':
password_mgr = urllib2.HTTPPasswordMgrWithDefaultRealm()
password_mgr.add_password(
None, pl_proxy, __settings__.getSetting('pl_proxy_user'),
__settings__.getSetting('pl_proxy_pass'))
proxy_auth_handler = urllib2.ProxyBasicAuthHandler(
password_mgr)
opener = urllib2.build_opener(proxy_handler,
proxy_auth_handler)
else:
opener = urllib2.build_opener(proxy_handler)
urlQuery = '&type=%s&id=%s&sort=newest&m=getItem&deviceScreenHeight=1080&deviceScreenWidth=1920' % (
type, id)
if __settings__.getSetting('checkClientip') == 'False':
try:
getItem = opener.open(base_url + urlQuery)
except Exception, ex:
ok = xbmcgui.Dialog().ok('TVNPlayer',
'Coś nie tak z Twoim proxy',
'error message', str(ex))
return ok
else:
def add_proxy(self, proxy):
if proxy is None:
return
if type(proxy) is not dict:
raise Exception('proxy parameter type must be dict')
proxy_address = proxy.get('address', None)
proxy_account = proxy.get('account', None)
if proxy_address is None and proxy_account is None:
return
protocol = proxy_address.split(':')[0]
ip_port = proxy_address.split('//')[1]
if proxy_account is None:
print str({protocol: ''.join([protocol + '://', ip_port])})
proxy_handler = urllib2.ProxyHandler(
{protocol: ''.join([protocol + '://', ip_port])})
opener = urllib2.build_opener(proxy_handler, urllib2.HTTPHandler)
else:
print str({
protocol:
''.join([protocol + '://', proxy_account, '@', ip_port])
})
proxy_handler = urllib2.ProxyHandler({
protocol:
''.join([protocol + '://', proxy_account, '@', ip_port])
})
proxy_auth_handler = urllib2.ProxyBasicAuthHandler()
opener = urllib2.build_opener(proxy_handler, proxy_auth_handler,
urllib2.HTTPHandler)
urllib2.install_opener(opener)
def _GrabWebWithProxy():
# 1>.构建一个密码管理对象，用于保存需要处理的用户名和密码
passwdmgr=urllib2.HTTPPasswordMgrWithDefaultRealm()
# 2>.添加账户信息，第一个参数realm是与远程服务器相关的域信息，默认None，后面三个参数分别是 代理服务器、用户名、密码
passwdmgr.add_password(None, PROXY_SERVER, USER, PWD)
# 3>.构建一个代理基础用户名／密码验证的ProxyBasicAuthHandler处理器对象，参数是创建的密码管理器对象
# 注意此处不在使用普通ProxyHandler类了
proxyauth_handler = urllib2.ProxyBasicAuthHandler(passwdmgr)
# 4. 通过 build_opener()方法使用这些代理Handler对象，创建自定义opener对象，参数包括构建的 proxy_handler 和 proxyauth_handler
opener = urllib2.build_opener(proxyauth_handler)
# 5. 构造Request 请求
request = urllib2.Request(URL_1)
# 6. 使用自定义opener发送请求
response = opener.open(request)
# 7. 打印响应内容
# print response.read()
# 8. 保存文件内容
# print "FILE_SAVE_PATH:",FILE_SAVE_PATH
if not os.path.exists(FILE_SAVE_PATH):
os.makedirs(FILE_SAVE_PATH)
with open(FILE_SAVE_NAME, 'w')as f:
f.write(response.read())
def __init__(self, email, password):
SGMLParser.__init__(self)
self.h3 = False
self.h3_is_ready = False
self.div = False
self.h3_and_div = False
self.a = False
self.depth = 0
self.names = ""
self.dic = {}
self.email = email
self.password = password
self.domain = 'renren.com'
try:
cookie = cookielib.CookieJar()
cookieProc = urllib2.HTTPCookieProcessor(cookie)
except:
raise
else:
proxy_handler = urllib2.ProxyHandler(
{'http': 'http://10.17.75.253:3128'})
proxy_auth_handler = urllib2.ProxyBasicAuthHandler()
# opener = urllib2.build_opener(proxy_handler, proxy_auth_handler)
opener = urllib2.build_opener(cookieProc, proxy_handler,
proxy_auth_handler)
urllib2.install_opener(opener)
def ProxyBasicAuthHandlerFunc():
# 私密代理授权的账户
user = "******"
# 私密代理授权的密码
passwd = "sffqry9r"
# 私密代理 IP
proxyserver = "61.158.163.130:16816"
# 1. 构建一个密码管理对象，用来保存需要处理的用户名和密码
passwdmgr = urllib2.HTTPPasswordMgrWithDefaultRealm()
# 2. 添加账户信息，第一个参数realm是与远程服务器相关的域信息，一般没人管它都是写None，后面三个参数分别是 代理服务器、用户名、密码
passwdmgr.add_password(None, proxyserver, user, passwd)
# 3. 构建一个代理基础用户名/密码验证的ProxyBasicAuthHandler处理器对象，参数是创建的密码管理对象
# 注意，这里不再使用普通ProxyHandler类了
proxyauth_handler = urllib2.ProxyBasicAuthHandler(passwdmgr)
# 4. 通过 build_opener()方法使用这些代理Handler对象，创建自定义opener对象，参数包括构建的 proxy_handler 和 proxyauth_handler
opener = urllib2.build_opener(proxyauth_handler)
# 5. 构造Request 请求
request = urllib2.Request("http://www.baidu.com/")
# 6. 使用自定义opener发送请求
response = opener.open(request)
# 7. 打印响应内容
print response.read()
def get_opener():
default_opener = urllib2.build_opener()
if not exists(YUM_CONF):
return default_opener
config = RawConfigParser()
config.read(YUM_CONF)
if not config.has_section('main'):
return default_opener
if not config.has_option('main', 'proxy'):
return default_opener
proxy = {}
url = config.get('main', 'proxy').strip()
if not url:
return default_opener
http_proxy_handler = urllib2.ProxyHandler({'http': url, 'https': url})
# urllib2 can open HTTPS ressources through a proxy since python 2.6.3
# should be OK on Centos OS (Python 2.6.6)
if config.has_option('main', 'proxy_username') and config.has_option(
'main', 'proxy_password'):
username = config.get('main', 'proxy_username').strip()
password = config.get('main', 'proxy_password').strip()
password_manager = urllib2.HTTPPasswordMgrWithDefaultRealm()
password_manager.add_password(None, url, username, password)
proxy_auth_handler = urllib2.ProxyBasicAuthHandler(password_manager)
return urllib2.build_opener(http_proxy_handler, proxy_auth_handler)
return urllib2.build_opener(http_proxy_handler)
def get_opener(user=None, password=None, proxy=None, debuglevel=0):
"""Construct an URL opener object. It considers the given credentials
and proxy.
@return: URL opener
@rtype: urllib2.OpenerDirector
"""
from . import httputil
pwd_manager = PasswordManager(user, password)
handlers = [
urllib2.UnknownHandler,
httputil.HttpWithGzipHandler(debuglevel=debuglevel),
urllib2.HTTPBasicAuthHandler(pwd_manager),
urllib2.HTTPDigestAuthHandler(pwd_manager),
]
if proxy:
handlers.insert(0, urllib2.ProxyHandler({
"http": proxy,
"https": proxy
}))
handlers.extend([
urllib2.ProxyBasicAuthHandler(pwd_manager),
urllib2.ProxyDigestAuthHandler(pwd_manager),
])
if hasattr(httplib, 'HTTPS'):
handlers.append(httputil.HttpsWithGzipHandler(debuglevel=debuglevel))
return urllib2.build_opener(*handlers)
def checkIPs(ip, port):
socket.setdefaulttimeout(3)
url = 'http://ip.chinaz.com/getip.aspx'
userAgent = 'Mozilla/5.0 (Windows NT 6.3; WOW64; rv:43.0) Gecko/20100101 Firefox/43.0'
proxy_host = str(ip) + ':' + str(port)
req = urllib2.Request(url)
req.add_header('User-Agent', userAgent)
proxy_handler = urllib2.ProxyHandler({'http': proxy_host})
proxy_auth_handler = urllib2.ProxyBasicAuthHandler()
opener = urllib2.build_opener(proxy_handler, proxy_auth_handler)
opener.addheaders = [('User-Agent', userAgent)]
print(proxy_host)
try:
response = opener.open(url)
response_data = response.read().decode('utf8')
soup = BeautifulSoup.BeautifulSoup(response_data)
content = soup.findAll('body')
f = open("./ips.txt", "a")
f.write(proxy_host + '\n')
print(content)
return True
except Exception, e:
# print('ip:' + str(ip) + '不可用')
# print(e)
return False
def getRequest(url, user_data=None, headers = defaultHeaders , alert=True, donotuseproxy=True):
log("getRequest URL:"+str(url))
if (donotuseproxy==False) and (addon.getSetting('us_proxy_enable') == 'true'):
us_proxy = 'http://%s:%s' % (addon.getSetting('us_proxy'), addon.getSetting('us_proxy_port'))
proxy_handler = urllib2.ProxyHandler({'http':us_proxy})
if addon.getSetting('us_proxy_pass') <> '' and addon.getSetting('us_proxy_user') <> '':
log('Using authenticated proxy: ' + us_proxy)
password_mgr = urllib2.HTTPPasswordMgrWithDefaultRealm()
password_mgr.add_password(None, us_proxy, addon.getSetting('us_proxy_user'), addon.getSetting('us_proxy_pass'))
proxy_auth_handler = urllib2.ProxyBasicAuthHandler(password_mgr)
opener = urllib2.build_opener(proxy_handler, proxy_auth_handler)
else:
log('Using proxy: ' + us_proxy)
opener = urllib2.build_opener(proxy_handler)
else:
opener = urllib2.build_opener()
urllib2.install_opener(opener)
log("getRequest URL:"+str(url))
req = urllib2.Request(url.encode(UTF8), user_data, headers)
try:
response = urllib2.urlopen(req)
page = response.read()
if response.info().getheader('Content-Encoding') == 'gzip':
log("Content Encoding == gzip")
page = zlib.decompress(page, zlib.MAX_WBITS + 16)
except urllib2.URLError, e:
if alert:
xbmc.executebuiltin('XBMC.Notification("%s", "%s", %s)' % ( __addonname__, e , 10000) )
page = ""
def urlOpen(url):
if __settings__.getSetting(
'checkClientip') == 'False' and __settings__.getSetting(
'pl_proxy') == '':
__settings__.openSettings()
if __settings__.getSetting('checkClientip') == 'False':
pl_proxy = 'http://' + __settings__.getSetting(
'pl_proxy') + ':' + __settings__.getSetting('pl_proxy_port')
proxy_handler = urllib2.ProxyHandler({'http': pl_proxy})
if __settings__.getSetting(
'pl_proxy_pass') <> '' and __settings__.getSetting(
'pl_proxy_user') <> '':
password_mgr = urllib2.HTTPPasswordMgrWithDefaultRealm()
password_mgr.add_password(None, pl_proxy,
__settings__.getSetting('pl_proxy_user'),
__settings__.getSetting('pl_proxy_pass'))
proxy_auth_handler = urllib2.ProxyBasicAuthHandler(password_mgr)
opener = urllib2.build_opener(proxy_handler, proxy_auth_handler)
else:
opener = urllib2.build_opener(proxy_handler)
if __settings__.getSetting('checkClientip') == 'False':
try:
getItem = opener.open(url)
except Exception, ex:
ok = xbmcgui.Dialog().ok('TVNPlayer', 'Coś nie tak z Twoim proxy',
'error message', str(ex))
return ok
def getRequest(url, user_data=None, headers=defaultHeaders, alert=True):
log("getRequest URL:" + str(url))
if addon.getSetting('us_proxy_enable') == 'true':
us_proxy = 'http://%s:%s' % (addon.getSetting('us_proxy'),
addon.getSetting('us_proxy_port'))
proxy_handler = urllib2.ProxyHandler({'http': us_proxy})
if addon.getSetting('us_proxy_pass') <> '' and addon.getSetting(
'us_proxy_user') <> '':
log('Using authenticated proxy: ' + us_proxy)
password_mgr = urllib2.HTTPPasswordMgrWithDefaultRealm()
password_mgr.add_password(None, us_proxy,
addon.getSetting('us_proxy_user'),
addon.getSetting('us_proxy_pass'))
proxy_auth_handler = urllib2.ProxyBasicAuthHandler(password_mgr)
opener = urllib2.build_opener(proxy_handler, proxy_auth_handler)
else:
log('Using proxy: ' + us_proxy)
opener = urllib2.build_opener(proxy_handler)
else:
opener = urllib2.build_opener()
urllib2.install_opener(opener)
log("getRequest URL:" + str(url))
req = urllib2.Request(url.encode(UTF8), user_data, headers)
retries = 2
while (retries > 0):
try:
response = urllib2.urlopen(req, timeout=30)
retries = 0
except urllib2.URLError, e:
retries -= 1
except socket.timeout:
retries -= 1
def getMovieLinkFromXML(self, typ, id):
#TODO:Proxy
if ptv.getSetting('checkClientip') == 'False':
pl_proxy = 'http://' + ptv.getSetting(
'pl_proxy') + ':' + ptv.getSetting('pl_proxy_port')
proxy_handler = urllib2.ProxyHandler({'http': pl_proxy})
if ptv.getSetting('pl_proxy_pass') <> '' and ptv.getSetting(
'pl_proxy_user') <> '':
password_mgr = urllib2.HTTPPasswordMgrWithDefaultRealm()
password_mgr.add_password(None, pl_proxy,
ptv.getSetting('pl_proxy_user'),
ptv.getSetting('pl_proxy_pass'))
proxy_auth_handler = urllib2.ProxyBasicAuthHandler(
password_mgr)
opener = urllib2.build_opener(proxy_handler,
proxy_auth_handler)
else:
opener = urllib2.build_opener(proxy_handler)
urlQuery = '&type=%s&id=%s&sort=newest&m=getItem&deviceScreenHeight=1080&deviceScreenWidth=1920' % (
typ, id)
#urlQuery2 = '&m=getItem&id=%s&deviceType=Tablet&os=4.4.2' % (id)
urlQuery2 = '&m=getItem&id=%s' % (id)
if ptv.getSetting('checkClientip') == 'False':
try:
getItem = opener.open(mainUrl + urlQuery)
except Exception, ex:
ok = xbmcgui.Dialog().ok('TVNPlayer',
'Coś nie tak z Twoim proxy',
'error message', str(ex))
return ok
def get_html(page_url):
if addon.get_setting('proxy_enable') == 'true':
proxy = 'http://' + addon.get_setting(
'proxy') + ':' + addon.get_setting('proxy_port')
proxy_handler = urllib2.ProxyHandler({'http': proxy})
username = addon.get_setting('proxy_user')
password = addon.get_setting('proxy_pass')
if username <> '' and password <> '':
print 'Using authenticated proxy: %s' % proxy
password_mgr = urllib2.HTTPPasswordMgrWithDefaultRealm()
password_mgr.add_password(None, proxy, username, password)
proxy_auth_handler = urllib2.ProxyBasicAuthHandler(password_mgr)
opener = urllib2.build_opener(proxy_handler, proxy_auth_handler)
else:
print 'Using proxy: %s' % proxy
opener = urllib2.build_opener(proxy_handler)
urllib2.install_opener(opener)
html = net.http_GET(page_url).content
import HTMLParser
h = HTMLParser.HTMLParser()
html = h.unescape(html)
return html.encode('utf-8')
def installAuthProxy(self, auth, proxy):
http_proxy = {"http": "http://{0}/".format(proxy[1])}
proxy_handler = urllib2.ProxyHandler(http_proxy)
auth_handler = urllib2.ProxyBasicAuthHandler()
auth_handler.add_password(user=auth[0], passwd=auth[1])
self.opener = urllib2.build_opener(proxy_handler, auth_handler)
def _fetchUrl(self, url, headers):
if isinstance(url, str):
url = laUrl(url)
retries = 3
if self.cfg.proxy and not self.noproxyFilter.bypassProxy(url.host):
retries = 7
inFile = None
for i in range(retries):
try:
# set up a handler that tracks cookies to handle
# sites like Colabnet that want to set a session cookie
cj = cookielib.LWPCookieJar()
opener = urllib2.build_opener(urllib2.HTTPCookieProcessor(cj))
# add password handler if needed
if url.user:
url.passwd = url.passwd or ''
passwdMgr = self.BasicPasswordManager()
passwdMgr.add_password(url.user, url.passwd)
opener.add_handler(urllib2.HTTPBasicAuthHandler(passwdMgr))
# add proxy and proxy password handler if needed
if self.cfg.proxy and \
not self.noproxyFilter.bypassProxy(url.host):
proxyPasswdMgr = urllib2.HTTPPasswordMgr()
for v in self.cfg.proxy.values():
pUrl = laUrl(v[1])
if pUrl.user:
pUrl.passwd = pUrl.passwd or ''
proxyPasswdMgr.add_password(
None, pUrl.asStr(noAuth=True, quoted=True),
url.user, url.passwd)
opener.add_handler(
urllib2.ProxyBasicAuthHandler(proxyPasswdMgr))
opener.add_handler(urllib2.ProxyHandler(self.cfg.proxy))
if url.scheme == 'ftp':
urlStr = url.asStr(noAuth=False, quoted=True)
else:
urlStr = url.asStr(noAuth=True, quoted=True)
req = urllib2.Request(urlStr, headers=headers)
inFile = opener.open(req)
if not urlStr.startswith('ftp://'):
content_type = inFile.info()['content-type']
if not url.explicit() and 'text/html' in content_type:
raise urllib2.URLError('"%s" not found' % urlStr)
log.info('Downloading %s...', urlStr)
break
except urllib2.HTTPError, msg:
if msg.code == 404:
return None
else:
log.error('error downloading %s: %s', urlStr, str(msg))
return None
except urllib2.URLError:
return None
def get_proxy_opener(proxyurl, proxyuser, proxypass, proxyscheme="http"):
password_mgr = urllib2.HTTPPasswordMgrWithDefaultRealm()
password_mgr.add_password(None, proxyurl, proxyuser, proxypass)
proxy_handler = urllib2.ProxyHandler({proxyscheme: proxyurl})
proxy_auth_handler = urllib2.ProxyBasicAuthHandler(password_mgr)
return urllib2.build_opener(proxy_handler, proxy_auth_handler)
def proxy_opener():
if settings_local.PROXY:
password_mgr = urllib2.HTTPPasswordMgrWithDefaultRealm()
password_mgr.add_password(None, PROXY_URL, settings_local.username, settings_local.password)
proxy_handler = urllib2.ProxyHandler({"http":PROXY_URL, "https":settings_local.username+":"+settings_local.password+"@"+PROXY_URL})
proxy_auth_handler = urllib2.ProxyBasicAuthHandler(password_mgr)
return urllib2.build_opener(proxy_handler, proxy_auth_handler)
else:
return urllib2.build_opener()
def build_handlers(self, handlers):
proxy_handler = urllib2.ProxyHandler(
{'http': 'http://%s:%s/' % (self.host, self.port)})
handlers.append(proxy_handler)
if self.need_login():
proxy_auth_handler = urllib2.ProxyBasicAuthHandler()
proxy_auth_handler.add_password('realm', 'host', self.proxyUser,
self.proxyPassword)
handlers.append(proxy_auth_handler)
