def authfetch(username, password, path="/", realm=realm):
server.accept(2)
import socket
socket.setdefaulttimeout(5)
uri = ("http://%s:%s" % server.server_address) + path
auth = HTTPDigestAuthHandler()
auth.add_password(realm, uri, username, password)
opener = build_opener(auth)
result = opener.open(uri)
return result.read()
def authfetch(username,password,path="/",realm=realm):
server.accept(2)
import socket
socket.setdefaulttimeout(5)
uri = ("http://%s:%s" % server.server_address) + path
auth = HTTPDigestAuthHandler()
auth.add_password(realm,uri,username,password)
opener = build_opener(auth)
result = opener.open(uri)
return result.read()
def add_authentication(self, realm, url, username, password):
"""
Set authentication credentials for the opener returned by
:meth:`opener`.
EXAMPLES::
sage: from sage.dev.digest_transport import DigestTransport
sage: dt = DigestTransport()
sage: dt.add_authentication("realm", "url", "username", "password")
sage: dt.opener
<urllib2.OpenerDirector instance at 0x...>
"""
assert self._opener is None
authhandler = HTTPDigestAuthHandler()
authhandler.add_password(realm, url, username, password)
self._opener = build_opener(authhandler)
def add_authentication(self, realm, url, username, password):
"""
Set authentication credentials for the opener returned by
:meth:`opener`.
EXAMPLES::
sage: from sage.dev.digest_transport import DigestTransport
sage: dt = DigestTransport()
sage: dt.add_authentication("realm", "url", "username", "password")
sage: dt.opener
<urllib2.OpenerDirector instance at 0x...>
"""
assert self._opener is None
authhandler = HTTPDigestAuthHandler()
authhandler.add_password(realm, url, username, password)
self._opener = build_opener(authhandler)
def openWebIF(self, part=None, reader=None):
self.proto = "http"
self.api = "oscamapi"
if config.oscaminfo.userdatafromconf.value:
udata = self.getUserData()
if isinstance(udata, str):
return False, udata
else:
self.port = udata[2]
self.username = udata[0]
self.password = udata[1]
self.ipaccess = udata[3]
self.api = udata[4]
if self.ipaccess == "yes":
self.ip = "::1"
else:
self.ip = "127.0.0.1"
else:
self.ip = ".".join("%d" % d for d in config.oscaminfo.ip.value)
self.port = str(config.oscaminfo.port.value)
self.username = str(config.oscaminfo.username.value)
self.password = str(config.oscaminfo.password.value)
if self.port.startswith('+'):
self.proto = "https"
self.port.replace("+", "")
if part is None:
self.url = "%s://%s:%s/%s.html?part=status" % (self.proto, self.ip, self.port, self.api)
else:
self.url = "%s://%s:%s/%s.html?part=%s" % (self.proto, self.ip, self.port, self.api, part)
if part is not None and reader is not None:
self.url = "%s://%s:%s/%s.html?part=%s&label=%s" % (self.proto, self.ip, self.port, self.api, part, reader)
opener = urllib.request.build_opener(HTTPHandler)
if not self.username == "":
pwman = urllib.request.HTTPPasswordMgrWithDefaultRealm()
pwman.add_password(None, self.url, self.username, self.password)
handlers = HTTPDigestAuthHandler(pwman)
opener = urllib.request.build_opener(HTTPHandler, handlers)
urllib.request.install_opener(opener)
request = urllib.request.Request(self.url)
err = False
try:
data = urllib.request.urlopen(request).read()
# print data
except urllib.error.URLError as e:
if hasattr(e, "reason"):
err = str(e.reason)
elif hasattr(e, "code"):
err = str(e.code)
if err is not False:
print("[openWebIF] error: %s" % err)
return False, err
else:
return True, data
def opener(self):
"""
Create an opener object.
By calling :meth:`add_authentication` before calling this property for
the first time, authentication credentials can be set.
EXAMPLES::
sage: from sage.dev.digest_transport import DigestTransport
sage: DigestTransport().opener
<urllib2.OpenerDirector instance at 0x...>
"""
if self._opener is None:
self._opener = build_opener(HTTPDigestAuthHandler())
return self._opener
def __init__(self,
url,
cookie_file=None,
username=None,
password=None,
api_token=None,
agent=None,
session=None,
disable_proxy=False,
auth_callback=None,
otp_token_callback=None,
verify_ssl=True,
save_cookies=True,
ext_auth_cookies=None):
if not url.endswith('/'):
url += '/'
self.url = url + 'api/'
self.save_cookies = save_cookies
self.ext_auth_cookies = ext_auth_cookies
if self.save_cookies:
self.cookie_jar, self.cookie_file = create_cookie_jar(
cookie_file=cookie_file)
try:
self.cookie_jar.load(ignore_expires=True)
except IOError:
pass
else:
self.cookie_jar = CookieJar()
self.cookie_file = None
if self.ext_auth_cookies:
try:
self.cookie_jar.load(ext_auth_cookies, ignore_expires=True)
except IOError as e:
logging.critical(
'There was an error while loading a '
'cookie file: %s', e)
pass
# Get the cookie domain from the url. If the domain
# does not contain a '.' (e.g. 'localhost'), we assume
# it is a local domain and suffix it (See RFC 2109).
parsed_url = urlparse(url)
self.domain = parsed_url[1].partition(':')[0] # Remove Port.
if self.domain.count('.') < 1:
self.domain = '%s.local' % self.domain
if session:
cookie = Cookie(version=0,
name=RB_COOKIE_NAME,
value=session,
port=None,
port_specified=False,
domain=self.domain,
domain_specified=True,
domain_initial_dot=True,
path=parsed_url[2],
path_specified=True,
secure=False,
expires=None,
discard=False,
comment=None,
comment_url=None,
rest={'HttpOnly': None})
self.cookie_jar.set_cookie(cookie)
if self.save_cookies:
self.cookie_jar.save()
if username:
# If the username parameter is given, we have to clear the session
# cookie manually or it will override the username:password
# combination retrieved from the authentication callback.
try:
self.cookie_jar.clear(self.domain, parsed_url[2],
RB_COOKIE_NAME)
except KeyError:
pass
# Set up the HTTP libraries to support all of the features we need.
password_mgr = ReviewBoardHTTPPasswordMgr(self.url, username, password,
api_token, auth_callback,
otp_token_callback)
self.preset_auth_handler = PresetHTTPAuthHandler(
self.url, password_mgr)
handlers = []
if not verify_ssl:
context = ssl._create_unverified_context()
handlers.append(HTTPSHandler(context=context))
if disable_proxy:
handlers.append(ProxyHandler({}))
handlers += [
HTTPCookieProcessor(self.cookie_jar),
ReviewBoardHTTPBasicAuthHandler(password_mgr),
HTTPDigestAuthHandler(password_mgr),
self.preset_auth_handler,
ReviewBoardHTTPErrorProcessor(),
]
if agent:
self.agent = agent
else:
self.agent = ('RBTools/' + get_package_version()).encode('utf-8')
opener = build_opener(*handlers)
opener.addheaders = [
(str('User-agent'), str(self.agent)),
]
install_opener(opener)
self._cache = None
self._urlopen = urlopen
def __init__(self,
url,
cookie_file=None,
username=None,
password=None,
api_token=None,
agent=None,
session=None,
disable_proxy=False,
auth_callback=None,
otp_token_callback=None):
self.url = url
if not self.url.endswith('/'):
self.url += '/'
self.url = self.url + 'api/'
self.cookie_jar, self.cookie_file = create_cookie_jar(
cookie_file=cookie_file)
try:
self.cookie_jar.load(ignore_expires=True)
except IOError:
pass
if session:
parsed_url = urlparse(url)
# Get the cookie domain from the url. If the domain
# does not contain a '.' (e.g. 'localhost'), we assume
# it is a local domain and suffix it (See RFC 2109).
domain = parsed_url[1].partition(':')[0] # Remove Port.
if domain.count('.') < 1:
domain = '%s.local' % domain
cookie = Cookie(version=0,
name=RB_COOKIE_NAME,
value=session,
port=None,
port_specified=False,
domain=domain,
domain_specified=True,
domain_initial_dot=True,
path=parsed_url[2],
path_specified=True,
secure=False,
expires=None,
discard=False,
comment=None,
comment_url=None,
rest={'HttpOnly': None})
self.cookie_jar.set_cookie(cookie)
self.cookie_jar.save()
# Set up the HTTP libraries to support all of the features we need.
password_mgr = ReviewBoardHTTPPasswordMgr(self.url, username, password,
api_token, auth_callback,
otp_token_callback)
self.preset_auth_handler = PresetHTTPAuthHandler(
self.url, password_mgr)
handlers = []
if disable_proxy:
handlers.append(ProxyHandler({}))
handlers += [
HTTPCookieProcessor(self.cookie_jar),
ReviewBoardHTTPBasicAuthHandler(password_mgr),
HTTPDigestAuthHandler(password_mgr),
self.preset_auth_handler,
ReviewBoardHTTPErrorProcessor(),
]
if agent:
self.agent = agent
else:
self.agent = ('RBTools/' + get_package_version()).encode('utf-8')
opener = build_opener(*handlers)
opener.addheaders = [
(b'User-agent', self.agent),
]
install_opener(opener)
self._cache = APICache()