def test_post_multipart(self):
alphabet = "abcdefghijklmnopqrstuvwxyz"
# generate file contents for a large post
contents = "".join([c * 65536 for c in alphabet])
# encode as multipart form data
files=[('file', 'file.txt', contents)]
content_type, body = encode_multipart_formdata(files)
# post file
if self.scheme == 'https':
c = HTTPSConnection('%s:%s' % (self.interface(), self.PORT))
else:
c = HTTPConnection('%s:%s' % (self.interface(), self.PORT))
c.putrequest('POST', '/post_multipart')
c.putheader('Content-Type', content_type)
c.putheader('Content-Length', str(len(body)))
c.endheaders()
c.send(body)
response = c.getresponse()
self.body = response.fp.read()
self.status = str(response.status)
self.assertStatus(200)
self.assertBody(", ".join(["%s * 65536" % c for c in alphabet]))
def Get_Domain(exchangeserver):
target_name = None
try:
HTTPREQ = HTTPSConnection(exchangeserver, context=ssl._create_unverified_context())
HTTPREQ.putrequest("GET", "/autodiscover/autodiscover.xml")
HTTPREQ.putheader("Content-length", "%d" % 0)
HTTPREQ.putheader("Connection", "Keep-Alive")
# #HTTPREQ.putheader("User-Agent", 'Python-urllib/2.6')
# #if user == "":
# # user = raw_input("[+][devalias.net][NTLM Authentication] Enter username (DOMAIN\username): ")
# #if password == "":
# # password = raw_input("[+][devalias.net][NTLM Authentication] Enter password: "******"xxx").decode('ascii')
auth = u'%s %s' % ('NTLM', negotiate_message)
HTTPREQ.putheader("Authorization", auth)
HTTPREQ.endheaders()
try:
resp = HTTPREQ.getresponse()
challenge = resp.msg.get('WWW-Authenticate').split(' ')[1]
target_name = DOMAIN_utils.parse_NTLM_CHALLENGE_MESSAGE(challenge)
except HTTPError as e:
return targetname
except URLError as e:
return target_name
except HTTPException as e:
return target_name
except Exception as e:
#print('Reason4: ', e)
return target_name
except Exception as e:
return target_name
else:
return target_name
def wrap(request, *args, **kwargs):
if 'token' not in request.GET and 'token' not in request.session:
# no token at all, request one-time-token
# next: where to redirect
# scope: what service you want to get access to
base_url='https://www.google.com/accounts/AuthSubRequest'
scope='https://docs.google.com/feeds/%20https://docs.googleusercontent.com/'
urlbase = Site.objects.get_current().domain
next_url='http://%s%s' % (urlbase, request.get_full_path())
session_val='1'
target_url="%s?next=%s&scope=%s&session=%s" % (base_url, next_url, scope, session_val)
return HttpResponseRedirect(target_url)
elif 'token' not in request.session and 'token' in request.GET:
# request session token using one-time-token
conn = HTTPSConnection("www.google.com")
conn.putrequest('GET', '/accounts/AuthSubSessionToken')
conn.putheader('Authorization', 'AuthSub token="%s"' % request.GET['token'])
conn.endheaders()
conn.send(' ')
r = conn.getresponse()
if str(r.status) == '200':
token = r.read()
token = token.split('=')[1]
token = token.replace('', '')
request.session['token'] = token
return f(request, *args, **kwargs)
def wrap(request, *args, **kwargs):
if 'token' not in request.GET and 'token' not in request.session:
# no token at all, request one-time-token
# next: where to redirect
# scope: what service you want to get access to
base_url='https://www.google.com/accounts/AuthSubRequest'
scope='https://docs.google.com/feeds/%20https://docs.googleusercontent.com/'
next_url='http://ilsgateway.com%s' % request.get_full_path()
session_val='1'
target_url="%s?next=%s&scope=%s&session=%s" % (base_url, next_url, scope, session_val)
return HttpResponseRedirect(target_url)
elif 'token' not in request.session and 'token' in request.GET:
# request session token using one-time-token
conn = HTTPSConnection("www.google.com")
conn.putrequest('GET', '/accounts/AuthSubSessionToken')
conn.putheader('Authorization', 'AuthSub token="%s"' % request.GET['token'])
conn.endheaders()
conn.send(' ')
r = conn.getresponse()
if str(r.status) == '200':
token = r.read()
token = token.split('=')[1]
token = token.replace('', '')
request.session['token'] = token
return f(request, *args, **kwargs)
def getsid():
"""Connetti al cpanel per ottenere l'id di sessione"""
# "Basic" authentication encodes userid:password in base64. Note
# that base64.encodestring adds some extra newlines/carriage-returns
# to the end of the result. string.strip is a simple way to remove
# these characters.
print " - Fetching session id from CPanel for user %s" % userid
global sid,psi
auth = 'Basic ' + strip(encodestring(userid + ':' + passwd))
conn = HTTPSConnection('cp.tophost.it')
conn.putrequest('GET', '/dnsjump.php')
conn.putheader('Authorization', auth )
conn.putheader(ua[0],ua[1])
conn.endheaders()
r=conn.getresponse()
if r.status!=200:
print 'Connessione fallita: ',r.status,r.reason
exit(1)
psi=r.getheader('Set-Cookie').replace('PHPSESSID=','').replace('; path=/','')
page=r.read()
bound='<input type="hidden" name="sid" value="'
s=page.find(bound); e=page.find('">',s)
sid=page[s+len(bound):e]
conn.close()
return sid,psi
def request(server, method, url, auth=False):
conn = None
if server.startswith('https://'):
conn = HTTPSConnection(server.strip('https://'))
else:
conn = HTTPConnection(server.strip('http://'))
conn.putrequest(method, url)
if auth:
conn.putheader("Authorization", "Basic %s" % auth)
conn.putheader("User-Agent", "situp-%s" % __version__)
conn.endheaders()
response = conn.getresponse()
conn.close()
return response
def request(server, method, url, auth=False):
conn = None
if server.startswith('https://'):
conn = HTTPSConnection(server.strip('https://'))
else:
conn = HTTPConnection(server.strip('http://'))
conn.putrequest(method, url)
if auth:
conn.putheader("Authorization", "Basic %s" % auth)
conn.putheader("User-Agent", "situp-%s" % __version__)
conn.endheaders()
response = conn.getresponse()
conn.close()
return response
def fetch_file(self, server, path):
"Fetch file using httplib module."
print("downloading https://%s%s" % (server, path))
req = HTTPSConnection(server)
req.putrequest('GET', path)
req.putheader('Host', server)
req.putheader('Accept', 'text/svg')
req.endheaders()
r1 = req.getresponse()
data = r1.read().decode('utf-8')
req.close()
return data
def fetch_file(self, server, path):
"Fetch file using httplib module."
print("downloading https://%s%s" % (server, path))
req = HTTPSConnection(server)
req.putrequest('GET', path)
req.putheader('Host', server)
req.putheader('Accept', 'text/svg')
req.endheaders()
r1 = req.getresponse()
data = r1.read().decode('utf-8')
req.close()
return data
def test_malformed_header(self):
if self.scheme == 'https':
c = HTTPSConnection('%s:%s' % (self.interface(), self.PORT))
else:
c = HTTPConnection('%s:%s' % (self.interface(), self.PORT))
c.putrequest('GET', '/')
c.putheader('Content-Type', 'text/plain')
# See http://www.cherrypy.org/ticket/941
c._output('Re, 1.2.3.4#015#012')
c.endheaders()
response = c.getresponse()
self.status = str(response.status)
self.assertStatus(400)
self.body = response.fp.read()
self.assertBody("Illegal header line.")
def request(index):
if self.scheme == 'https':
c = HTTPSConnection('%s:%s' % (self.interface(), self.PORT))
else:
c = HTTPConnection('%s:%s' % (self.interface(), self.PORT))
for i in range(request_count):
c.putrequest('GET', '/')
for k, v in cookies:
c.putheader(k, v)
c.endheaders()
response = c.getresponse()
body = response.read()
if response.status != 200 or not body.isdigit():
errors.append((response.status, body))
else:
data_dict[index] = max(data_dict[index], int(body))
def request_feed(self, user, passwd, label=''):
DOMAIN = 'mail.google.com'
ATOM_FEED = '/mail/feed/atom'
if len(label) > 0 and label[0] != '/':
label = '/' + label
b64 = base64.encodestring(user + ':' + passwd)
connection = HTTPSConnection(DOMAIN)
connection.putrequest('GET', ATOM_FEED + label)
connection.putheader('Accept', 'application/atom+xml')
connection.putheader('Authorization', 'Basic %s' % b64)
connection.endheaders()
response = connection.getresponse()
data = response.read()
response.close()
return self.parse_xml(user, data)
def request(method, url, data, headers, callback=None):
url = urlparse(url)
# Connect
if url.scheme == 'https':
request = HTTPSConnection(url.netloc)
else:
request = HTTPConnection(url.netloc)
request.connect()
# Initiate request
request.putrequest(method, url.path)
encoded_data = multipart.encode(data)
encoded_data_headers = encoded_data.get_headers()
all_headers = chain(
encoded_data_headers.iteritems(),
headers.iteritems()
)
# Send headers
for name, value in all_headers:
request.putheader(name, value)
request.endheaders()
# Send body
bytes_sent = 0
bytes_total = int(encoded_data_headers['Content-Length'])
for chunk in encoded_data:
request.send(chunk)
bytes_sent += len(chunk)
if callable(callback):
callback(bytes_sent, bytes_total)
# TODO: Wrap the response in a container to allow chunked reading.
response = request.getresponse()
response_status = response.status
response_data = response.read()
request.close()
return response_status, response_data
def test_page1(request):
"""
Simple example - list google docs documents
"""
if TOKEN_VAR in request.session:
con = HTTPSConnection("www.google.com")
con.putrequest('GET', '/m8/feeds/contacts/[email protected]/full')
con.putheader('Authorization', 'AuthSub token="%s"' % request.session[TOKEN_VAR])
con.endheaders()
con.send('')
r2 = con.getresponse()
dane = r2.read()
soup = BeautifulStoneSoup(dane)
dane = soup.prettify()
return render(request, 'pin/a.html', {'dane': dane})
else:
return render(request, 'pin/a.html', {'dane': 'bad bad'})
def test_page1(request):
"""
Simple example - list google docs documents
"""
if TOKEN_VAR in request.session:
con = HTTPSConnection("www.google.com")
con.putrequest('GET', '/m8/feeds/contacts/[email protected]/full')
con.putheader('Authorization',
'AuthSub token="%s"' % request.session[TOKEN_VAR])
con.endheaders()
con.send('')
r2 = con.getresponse()
dane = r2.read()
soup = BeautifulStoneSoup(dane)
dane = soup.prettify()
return render(request, 'pin/a.html', {'dane': dane})
else:
return render(request, 'pin/a.html', {'dane': 'bad bad'})
def wrap(request, *args, **kwargs):
if TOKEN_IN_GET not in request.GET and TOKEN_VAR not in request.session:
# no token at all, request one-time-token
# next: where to redirect
# scope: what service you want to get access to
return HttpResponseRedirect("https://www.google.com/accounts/AuthSubRequest?next=http://127.0.0.1:8000/pin/test_page&scope=https://www.google.com/m8/feeds&session=1")
elif TOKEN_VAR not in request.session and TOKEN_IN_GET in request.GET:
# request session token using one-time-token
conn = HTTPSConnection("www.google.com")
conn.putrequest('GET', '/accounts/AuthSubSessionToken')
conn.putheader('Authorization', 'AuthSub token="%s"' % request.GET[TOKEN_IN_GET])
conn.endheaders()
conn.send(' ')
r = conn.getresponse()
if str(r.status) == '200':
token = r.read()
token = token.split('=')[1]
token = token.replace('', '')
request.session[TOKEN_VAR] = token
return f(request, *args, **kwargs)
def create_token(params):
"""
Contact the specified keystone server to return the token
"""
if 'username' in params and 'password' in params and 'auth_url' in params and 'tenant' in params:
try:
keystone_uri = params['auth_url']
uri = uriparse(keystone_uri)
server = uri[1].split(":")[0]
port = int(uri[1].split(":")[1])
conn = HTTPSConnection(server, port)
conn.putrequest('POST', "/v2.0/tokens")
conn.putheader('Accept', 'application/json')
conn.putheader('Content-Type', 'application/json')
conn.putheader('Connection', 'close')
body = ('{"auth":{"passwordCredentials":{"username": "******","password": "******"},"tenantName": "' +
params['tenant'] + '"}}')
conn.putheader('Content-Length', len(body))
conn.endheaders(body)
resp = conn.getresponse()
# format: -> "{\"access\": {\"token\": {\"issued_at\":
# \"2014-12-29T17:10:49.609894\", \"expires\":
# \"2014-12-30T17:10:49Z\", \"id\":
# \"c861ab413e844d12a61d09b23dc4fb9c\"}, \"serviceCatalog\":
# [], \"user\": {\"username\":
# \"/DC=es/DC=irisgrid/O=upv/CN=miguel-caballer\",
# \"roles_links\": [], \"id\":
# \"475ce4978fb042e49ce0391de9bab49b\", \"roles\": [],
# \"name\": \"/DC=es/DC=irisgrid/O=upv/CN=miguel-caballer\"},
# \"metadata\": {\"is_admin\": 0, \"roles\": []}}}"
output = json.loads(resp.read())
token_id = output['access']['token']['id']
if conn.cert_file and os.path.isfile(conn.cert_file):
os.unlink(conn.cert_file)
return token_id
except:
return None
else:
raise Exception(
"Incorrect auth data, auth_url, username, password and tenant must be specified"
)
def getsid():
"""Connetti al cpanel per ottenere l'id di sessione"""
# "Basic" authentication encodes userid:password in base64. Note
# that base64.encodestring adds some extra newlines/carriage-returns
# to the end of the result. string.strip is a simple way to remove
# these characters.
global sid, psi
auth = 'Basic ' + strip(encodestring(userid + ':' + passwd))
conn = HTTPSConnection('cp.tophost.it')
conn.putrequest('GET', '/dnsjump.php')
conn.putheader('Authorization', auth)
conn.putheader(ua[0], ua[1])
conn.endheaders()
r = conn.getresponse()
psi = r.getheader('Set-Cookie').replace('PHPSESSID=',
'').replace('; path=/', '')
page = r.read()
bound = '<input type="hidden" name="sid" value="'
s = page.find(bound)
e = page.find('">', s)
sid = page[s + len(bound):e]
conn.close()
return sid, psi
def wrap(request, *args, **kwargs):
if TOKEN_IN_GET not in request.GET and TOKEN_VAR not in request.session:
# no token at all, request one-time-token
# next: where to redirect
# scope: what service you want to get access to
return HttpResponseRedirect(
"https://www.google.com/accounts/AuthSubRequest?next=http://127.0.0.1:8000/pin/test_page&scope=https://www.google.com/m8/feeds&session=1"
)
elif TOKEN_VAR not in request.session and TOKEN_IN_GET in request.GET:
# request session token using one-time-token
conn = HTTPSConnection("www.google.com")
conn.putrequest('GET', '/accounts/AuthSubSessionToken')
conn.putheader('Authorization',
'AuthSub token="%s"' % request.GET[TOKEN_IN_GET])
conn.endheaders()
conn.send(' ')
r = conn.getresponse()
if str(r.status) == '200':
token = r.read()
token = token.split('=')[1]
token = token.replace('', '')
request.session[TOKEN_VAR] = token
return f(request, *args, **kwargs)
def post_multipart(host, selector, fields, files):
content_type, body = encode_multipart_formdata(fields, files)
h = HTTPSConnection(host)
h.putrequest('POST', selector)
h.putheader('content-type', content_type)
h.putheader('content-length', str(len(body.encode('utf-8'))))
h.putheader('User-Agent', 'sms-python')
h.endheaders()
h.send(body.encode('utf-8'))
resp = h.getresponse()
return resp.status, resp. reason, resp.read().decode()
def post_multipart(host, selector, fields, files):
content_type, body = encode_multipart_formdata(fields, files)
h = HTTPSConnection(host)
h.putrequest('POST', selector)
h.putheader('content-type', content_type)
h.putheader('content-length', str(len(body.encode('utf-8'))))
h.putheader('User-Agent', 'sms-python')
h.endheaders()
h.send(body.encode('utf-8'))
resp = h.getresponse()
return resp.status, resp.reason, resp.read().decode()
def run(self):
self.started = time.time()
timeout = self.hostControlBackend._hostRpcTimeout
if timeout < 0:
timeout = 0
try:
query = toJson({
'id': 1,
'method': self.method,
'params': self.params
}).encode('utf-8')
connection = HTTPSConnection(host=self.address,
port=self.hostPort,
timeout=timeout)
with closingConnection(connection) as connection:
non_blocking_connect_https(connection, timeout)
connection.putrequest('POST', '/opsiclientd')
connection.putheader('User-Agent', self._USER_AGENT)
connection.putheader('content-type', 'application/json')
connection.putheader('content-length', str(len(query)))
auth = u'{0}:{1}'.format(self.username, self.password)
connection.putheader(
'Authorization',
'Basic ' + base64.b64encode(auth.encode('latin-1')))
connection.endheaders()
connection.send(query)
response = connection.getresponse()
response = response.read()
response = fromJson(unicode(response, 'utf-8'))
if response and isinstance(response, dict):
self.error = response.get('error')
self.result = response.get('result')
else:
self.error = u"Bad response from client: %s" % forceUnicode(
response)
except Exception as e:
self.error = forceUnicode(e)
finally:
self.ended = time.time()
def zopeRequest(self, method, headers={}, body=''):
"""Send a request back to Zope"""
try:
if self.ssl:
h = HTTPSConnection(self.host)
else:
h = HTTPConnection(self.host)
h.putrequest(method, self.path)
h.putheader('User-Agent', 'Zope External Editor/%s' % __version__)
h.putheader('Connection', 'close')
for header, value in headers.items():
h.putheader(header, value)
h.putheader("Content-Length", str(len(body)))
if self.metadata.get('auth','').startswith('Basic'):
h.putheader("Authorization", self.metadata['auth'])
if self.metadata.get('cookie'):
h.putheader("Cookie", self.metadata['cookie'])
h.endheaders()
h.send(body)
return h.getresponse()
except:
# On error return a null response with error info
class NullResponse:
def getheader(self, n, d=None):
return d
def read(self):
return '(No Response From Server)'
response = NullResponse()
response.reason = sys.exc_info()[1]
try:
response.status, response.reason = response.reason
except ValueError:
response.status = 0
if response.reason == 'EOF occurred in violation of protocol':
# Ignore this protocol error as a workaround for
# broken ssl server implementations
response.status = 200
return response
class THttpPersist (TTransport.TTransportBase):
"""Http (keep-alive) implementation of TTransport base."""
def __init__ (self, uri_or_host, port=None, path=None):
"""THttpPersist supports two different types constructor parameters.
THttpPersist(host, port, path) - deprecated
THttpPersist(uri)
Only the second supports https.
"""
if port is not None:
warn (
"Please use the THttpPersist('http://host:port/path') syntax",
DeprecationWarning,
stacklevel=2)
self.host = uri_or_host
self.port = port
assert path
self.path = path
self.scheme = 'http'
else:
parsed = urlparse(uri_or_host)
self.scheme = parsed.scheme
assert self.scheme in ('http', 'https')
if self.scheme == 'http':
self.port = parsed.port or HTTP_PORT
elif self.scheme == 'https':
self.port = parsed.port or HTTPS_PORT
self.host = parsed.hostname
self.path = parsed.path
if parsed.query:
self.path += '?%s' % parsed.query
self._bufr = StringIO()
self._bufw = StringIO()
self._conn = None
self._timeout = None
self._headers = None
def open (self):
if self._conn is not None:
self.close()
if self.scheme == 'http':
self._conn = HTTPConnection (
self.host, self.port, timeout=self._timeout)
else:
self._conn = HTTPSConnection (
self.host, self.port, timeout=self._timeout)
def close (self):
if self._conn is None:
return
self._conn.close ()
self._conn = None
def isOpen (self):
return self._conn is not None
def setTimeout (self, ms):
if ms is None:
self._timeout = None
else:
self._timeout = ms / 1000.0
# TODO: close connection to apply timeout
def setCustomHeaders (self, headers):
self._headers = headers
def read (self, sz):
return self._bufr.read (sz)
def write (self, buf):
self._bufw.write (buf)
def flush (self):
if not self.isOpen ():
self.open ()
# Pull data out of buffer
data = self._bufw.getvalue ()
self._bufw = StringIO ()
# HTTP request
self._conn.putrequest ('POST', self.path)
# Write headers
self._conn.putheader ('Host', self.host)
self._conn.putheader ('Content-Type', 'application/x-thrift')
self._conn.putheader ('Content-Length', str (len (data)))
if not self._headers or 'User-Agent' not in self._headers:
user_agent = 'Python/THttpClient'
script = basename (argv[0])
if script:
user_agent = '%s (%s)' % (user_agent, quote(script))
self._conn.putheader ('User-Agent', user_agent)
if self._headers:
for key, val in self._headers.iteritems ():
self._conn.putheader (key, val)
self._conn.endheaders ()
# Write payload
self._conn.send (data)
# Get reply to flush the request
response = self._conn.getresponse ()
self.code = response.status
self.message = response.reason
self.headers = response.msg
self._bufr = StringIO (response.read())
disk_file = ova_file.extractfile(disk_entry)
size = disk_entry.size
# Send the request head. Note the following:
#
# - We must send the Authorzation header with the signed ticket received
# from the transfer service.
#
# - the server requires Content-Range header even when sending the
# entire file.
#
# - the server requires also Content-Length.
#
proxy_connection.putrequest("PUT", proxy_url.path)
proxy_connection.putheader('Authorization', transfer.signed_ticket)
proxy_connection.putheader('Content-Range',
"bytes %d-%d/%d" % (0, size - 1, size))
proxy_connection.putheader('Content-Length', "%d" % (size,))
proxy_connection.endheaders()
# Send the request body. Note the following:
#
# - we must send the number of bytes we promised in the Content-Range
# header.
#
# - we must extend the session, otherwise it will expire and the upload
# will fail.
last_extend = time.time()
class HessianProxy(object):
def __init__(self, service_uri, credentials=None, key_file=None, cert_file=None, timeout=10, buffer_size=65535, error_factory=lambda x: x, overload=False):
self._headers = list()
self._headers.append(('User-Agent', 'mustaine/' + __version__,))
self._headers.append(('Content-Type', 'application/x-hessian',))
if sys.version_info < (2,6):
warn('HessianProxy timeout not enforceable before Python 2.6', RuntimeWarning, stacklevel=2)
timeout = {}
else:
timeout = {'timeout': timeout}
self._uri = urlparse(service_uri)
if self._uri.scheme == 'http':
self._client = HTTPConnection(self._uri.hostname,
self._uri.port or 80,
strict=True,
**timeout)
elif self._uri.scheme == 'https':
self._client = HTTPSConnection(self._uri.hostname,
self._uri.port or 443,
key_file=key_file,
cert_file=cert_file,
strict=True,
**timeout)
else:
raise NotImplementedError("HessianProxy only supports http:// and https:// URIs")
# autofill credentials if they were passed via url instead of kwargs
if (self._uri.username and self._uri.password) and not credentials:
credentials = (self._uri.username, self._uri.password)
if credentials:
auth = 'Basic ' + base64.b64encode(':'.join(credentials))
self._headers.append(('Authorization', auth))
self._buffer_size = buffer_size
self._error_factory = error_factory
self._overload = overload
self._parser = Parser()
class __RemoteMethod(object):
# dark magic for autoloading methods
def __init__(self, caller, method):
self.__caller = caller
self.__method = method
def __call__(self, *args):
return self.__caller(self.__method, args)
def __getattr__(self, method):
return self.__RemoteMethod(self, method)
def __repr__(self):
return "<mustaine.client.HessianProxy(\"%s\")>" % (self._uri.geturl(),)
def __str__(self):
return self.__repr__()
def __call__(self, method, args):
try:
self._client.putrequest('POST', self._uri.path)
for header in self._headers:
self._client.putheader(*header)
request = encode_object(Call(method, args, overload=self._overload))
self._client.putheader("Content-Length", str(len(request)))
self._client.endheaders()
self._client.send(str(request))
response = self._client.getresponse()
if response.status != 200:
raise ProtocolError(self._uri.geturl(), response.status, response.reason)
length = response.getheader('Content-Length', -1)
if length == '0':
raise ProtocolError(self._uri.geturl(), 'FATAL:', 'Server sent zero-length response')
reply = self._parser.parse_stream(BufferedReader(response, buffer_size=self._buffer_size))
self._client.close()
if isinstance(reply.value, Fault):
raise self._error_factory(reply.value)
else:
return reply.value
except:
self._client.close()
raise
disk_file = ova_file.extractfile(disk_entry)
image_size = disk_entry.size
# Send the request head. Note the following:
#
# - We must send the Authorzation header with the signed ticket received
# from the transfer service.
#
# - the server requires Content-Range header even when sending the
# entire file.
#
# - the server requires also Content-Length.
#
proxy_connection.putrequest("PUT", proxy_url.path)
proxy_connection.putheader('Authorization', transfer.signed_ticket)
content_range = "bytes %d-%d/%d" % (0, image_size - 1, image_size)
proxy_connection.putheader('Content-Range', content_range)
proxy_connection.putheader('Content-Length', "%d" % (image_size, ))
proxy_connection.endheaders()
# Send the request body. Note the following:
#
# - we must send the number of bytes we promised in the Content-Range
# header.
#
# - we must extend the session, otherwise it will expire and the upload
# will fail.
start = last_progress = time.time()
def zope_request(self, method, headers={}, body=''):
"""Send a request back to Zope"""
try:
if self.ssl:
h = HTTPSConnection(self.host)
else:
h = HTTPConnection(self.host)
h.putrequest(method, self.path)
#h.putheader("Host", self.host) # required by HTTP/1.1
h.putheader('User-Agent', 'Zope External Editor/%s' % __version__)
h.putheader('Connection', 'close')
for header, value in headers.items():
h.putheader(header, value)
h.putheader("Content-Length", str(len(body)))
if self.metadata.get('auth', '').startswith('Basic'):
h.putheader("Authorization", self.metadata['auth'])
if self.metadata.get('cookie'):
h.putheader("Cookie", self.metadata['cookie'])
h.endheaders()
h.send(body)
return h.getresponse()
except:
# On error return a null response with error info
class NullResponse:
def getheader(n, d):
return d
def read():
return ''
response = NullResponse()
response.reason = sys.exc_info()[1]
try:
response.status, response.reason = response.reason
except:
response.status = 0
return response
def handle_one_request(self):
try:
start_time = time.time()
try:
# noinspection PyAttributeOutsideInit
self.command, self.path, self.request_version = \
self.rfile.readline().decode().strip().split(' ', 2)
except ValueError:
return
target_netloc = self.server.proxy_target.netloc
if '@' in target_netloc:
# split authentication information from target description
target_auth, target_netloc = target_netloc.split('@', 1)
else:
target_auth, target_netloc = None, target_netloc
if ':' in target_netloc:
# split host / port information from target description
target_host, target_port = target_netloc.rsplit(':', 1)
else:
target_host, target_port = target_netloc, None # port fallback to 80 / 443
if self.server.proxy_target.scheme == 'https':
client = HTTPSConnection(target_host, target_port)
else:
client = HTTPConnection(target_host, target_port)
client.connect()
client.putrequest(self.command, self.server.proxy_target.path + self.path, skip_host=True)
request_host = ''
request_content_length = 0
request_line = self.rfile.readline()
while request_line and b':' in request_line:
# walk through the request header lines and pass them to the server connection
key, value = request_line.split(b':', 1)
unified_key = key.decode().lower()
if unified_key == 'authorization':
# if there is an authorization in the request: ignore the given information
target_auth = None
elif unified_key == 'content-length':
request_content_length = int(value.strip())
elif unified_key == 'host':
request_host = value.strip()
# replace the requested host header with the wanted one
value = self.server.host_header if self.server.host_header else target_host
client.putheader(key, value.strip())
request_line = self.rfile.readline()
if target_auth:
client.putheader('Authorization', 'Basic %s' % b64encode(target_auth))
client.endheaders()
# pass the request body to the server connection
for _ in range(request_content_length // 1024):
client.send(self.rfile.read(1024))
client.send(self.rfile.read(request_content_length % 1024))
response = client.getresponse()
self.send_response(response.status, response.reason)
for key, value in response.getheaders():
# walk through the response header lines and pass them to the client connection
unified_key = key.lower()
if unified_key == 'location':
# try to modify the location header to keep the browser requesting the proxy
redirect = list(urlparse(value))
if redirect[1]:
redirect[0], redirect[1] = 'http', request_host
logging.warning("REWRITE %s: %s -> %s", key, value, urlunparse(redirect))
self.send_header(key, urlunparse(redirect))
elif unified_key not in ('keep-alive', 'connection'):
# its hard to support persistent connections properly because we open a
# new connection for every request, so disable it completely
self.send_header(key, value)
self.end_headers()
try:
# pass the response body to the client connection
chunk = True
response_size = 0
while chunk:
chunk = response.read(1024)
response_size += len(chunk)
self.wfile.write(chunk)
self.wfile.flush()
except socket.error:
logging.debug("%s %s [connection reset, %.2fs]",
self.command, self.path,
time.time() - start_time)
else:
logging.info("%s %s [%s, %s, %.2fs]",
self.command, self.path,
response.status, human_size(response_size),
time.time() - start_time)
finally:
client.close()
except KeyboardInterrupt:
pass
# Send the request head. Note the following:
#
# - For ovirt-engine < 4.2, we must send the 'Authorization' header with
# the signed ticket received from the transfer service.
# I.e. proxy_connection.putheader('Authorization', transfer.signed_ticket)
#
# - For ovirt-engine < 4.2, the server requires 'Content-Range' header
# even when sending the entire file.
# I.e. proxy_connection.putheader('Content-Range',
# "bytes %d-%d/%d" % (0, image_size - 1, image_size))
#
# - the server requires also Content-Length.
#
proxy_connection.putrequest("PUT", destination_url.path)
proxy_connection.putheader('Content-Length', "%d" % (image_size, ))
proxy_connection.endheaders()
# Send the request body.
# Note that we must send the number of bytes we promised in the
# Content-Range header.
start = last_progress = time.time()
with open(image_path, "rb") as disk:
pos = 0
while pos < image_size:
# Send the next chunk to the proxy.
to_read = min(image_size - pos, BUF_SIZE)
chunk = disk.read(to_read)
def zope_request(self, method, headers={}, body=''):
"""Send a request back to Zope"""
try:
if self.ssl:
h = HTTPSConnection(self.host)
else:
h = HTTPConnection(self.host)
h.putrequest(method, self.path)
#h.putheader("Host", self.host) # required by HTTP/1.1
h.putheader('User-Agent', 'Zope External Editor/%s' % __version__)
h.putheader('Connection', 'close')
for header, value in headers.items():
h.putheader(header, value)
h.putheader("Content-Length", str(len(body)))
if self.metadata.get('auth','').startswith('Basic'):
h.putheader("Authorization", self.metadata['auth'])
if self.metadata.get('cookie'):
h.putheader("Cookie", self.metadata['cookie'])
h.endheaders()
h.send(body)
return h.getresponse()
except:
# On error return a null response with error info
class NullResponse:
def getheader(n,d): return d
def read(): return ''
response = NullResponse()
response.reason = sys.exc_info()[1]
try:
response.status, response.reason = response.reason
except:
response.status = 0
return response
def getter(host, url, ip=None, ssl=True, body='', force_post=False, headers={}):
'''Make HTTP request that handles cookies in an acceptable manner
Supports SSL and spoofed hostnames'''
global prev_url, cookies, useragent
ip = hostnames[host] if not ip and host in hostnames else ip
print >> sys.stderr, "[getter] ", host, url, 'ip=%s' % ip, 'ssl=%s' % ssl
origin = 'https://'+host if ssl else 'http://'+host
# Assemble the request
conn = HTTPSConnection(ip or host) if ssl else HTTPConnection(host)
conn.putrequest('POST' if len(body)>0 or force_post else 'GET', url, skip_host=True)
conn.putheader('Accept', '*/*')
conn.putheader('Origin', origin)
if prev_url != '': conn.putheader('Referer', prev_url)
conn.putheader('User-Agent', useragent)
if len(headers) > 0:
for i in headers:
conn.putheader(i, headers[i])
if len(cookies) > 0: conn.putheader('Cookie', ''.join([i+'='+cookies[i]+'; ' for i in cookies]))
if len(body) > 0 or force_post: conn.putheader('Content-Length', len(body))
conn.putheader('Host', host)
conn.endheaders(message_body=body if len(body) > 0 or force_post else None)
prev_url = origin+url
# Parse the response, determine new cookies and redirects
resp = conn.getresponse()
redirect = None
for name,value in resp.getheaders():
if name == 'set-cookie':
# Parse cookies
t_cookies = value.split(',')
for i in t_cookies:
try:
temp = i.partition(';')[0].partition('=')
if temp[2] == 'null' and temp[0].strip() in cookies:
del cookies[temp[0].strip()]
else:
cookies[temp[0].strip()] = temp[2]
except Exception:
print "Broke on cookie-string: ", i
if name == "location":
# Set up redirect for when all headers are ready
temp = value.partition('://')[2].partition('/')
temp_host = temp[0]
temp_url = '/'+temp[2]
temp_ssl = "https://" in value
redirect = True
body = resp.read()
if '<META name="GENERATOR" content="IBM WebSphere Studio">' in body[0:1000]:
start = body.find('document.location.href="')+24
end = body.find('"', start)
temp_host = host
temp_url = body[start:end]
temp_ssl = True
redirect = True
if redirect: return getter(temp_host, temp_url, ssl=temp_ssl)
return body
class HessianProxy(object):
def __init__(self, service_uri, credentials=None, key_file=None, cert_file=None, timeout=10, buffer_size=65535, error_factory=lambda x: x, overload=False):
self._headers = list()
self._headers.append(('User-Agent', 'mustaine/' + __version__,))
self._headers.append(('Content-Type', 'application/x-hessian',))
if sys.version_info < (2,6):
warn('HessianProxy timeout not enforceable before Python 2.6', RuntimeWarning, stacklevel=2)
timeout = {}
else:
timeout = {'timeout': timeout}
self._uri = urlparse(service_uri)
if self._uri.scheme == 'http':
self._client = HTTPConnection(self._uri.hostname,
self._uri.port or 80,
strict=True,
**timeout)
elif self._uri.scheme == 'https':
self._client = HTTPSConnection(self._uri.hostname,
self._uri.port or 443,
key_file=key_file,
cert_file=cert_file,
strict=True,
**timeout)
else:
raise NotImplementedError("HessianProxy only supports http:// and https:// URIs")
# autofill credentials if they were passed via url instead of kwargs
if (self._uri.username and self._uri.password) and not credentials:
credentials = (self._uri.username, self._uri.password)
if credentials:
auth = 'Basic ' + base64.b64encode(':'.join(credentials))
self._headers.append(('Authorization', auth))
self._buffer_size = buffer_size
self._error_factory = error_factory
self._overload = overload
self._parser = Parser()
class __RemoteMethod(object):
# dark magic for autoloading methods
def __init__(self, caller, method):
self.__caller = caller
self.__method = method
def __call__(self, *args):
return self.__caller(self.__method, args)
def __getattr__(self, method):
return self.__RemoteMethod(self, method)
def __repr__(self):
return "<mustaine.client.HessianProxy(\"%s\")>" % (self._uri.geturl(),)
def __str__(self):
return self.__repr__()
def __call__(self, method, args):
try:
path = self._uri.path
if self._uri.query:
path += "?" + self._uri.query
self._client.putrequest('POST', path)
for header in self._headers:
self._client.putheader(*header)
request = encode_object(Call(method, args, overload=self._overload))
self._client.putheader("Content-Length", str(len(request)))
self._client.endheaders()
self._client.send(str(request))
response = self._client.getresponse()
if response.status != 200:
raise ProtocolError(self._uri.geturl(), response.status, response.reason)
length = response.getheader('Content-Length', -1)
if length == '0':
raise ProtocolError(self._uri.geturl(), 'FATAL:', 'Server sent zero-length response')
reply = self._parser.parse_stream(BufferedReader(response, buffer_size=self._buffer_size))
self._client.close()
if isinstance(reply.value, Fault):
raise self._error_factory(reply.value)
else:
return reply.value
except:
self._client.close()
raise
