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 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 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 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 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 putrequest(self, method, url, skip_host=0, skip_accept_encoding=0):
"""
Recover the full URL path together with host
"""
full_url = url
urlPref = "https://"
if not url.startswith(urlPref):
full_url = '%s%s:%s%s' % (urlPref, self.host, self.port, url)
HTTPSConnection.putrequest(self, method, full_url, skip_host, skip_accept_encoding)
def dorequest(self, timeout=TIMEOUT, HttpMethod="POST", parsexsams=True):
"""
Sends the request to the database node and returns a result.Result instance. The
request uses 'POST' requests by default. If the request fails or if stated in the parameter 'HttpMethod',
'GET' requests will be performed.
The returned result will be parsed by default and the model defined in 'specmodel' will be populated by default
(parseexams = True).
"""
self.xml = None
#self.get_xml(self.Source.Requesturl)
url = self.baseurl + self.querypath
urlobj = urlsplit(url)
if urlobj.scheme == 'https':
conn = HTTPSConnection(urlobj.netloc, timeout=timeout)
else:
conn = HTTPConnection(urlobj.netloc, timeout=timeout)
conn.putrequest(HttpMethod, urlobj.path + "?" + urlobj.query)
conn.endheaders()
try:
res = conn.getresponse()
except socket.timeout:
# error handling has to be included
self.status = 408
self.reason = "Socket timeout"
raise TimeOutError
self.status = res.status
self.reason = res.reason
if not parsexsams:
if res.status == 200:
result = r.Result()
result.Content = res.read()
elif res.status == 400 and HttpMethod == 'POST':
# Try to use http-method: GET
result = self.dorequest(HttpMethod='GET',
parsexsams=parsexsams)
else:
result = None
else:
if res.status == 200:
self.xml = res.read()
result = r.Result()
result.Xml = self.xml
result.populate_model()
elif res.status == 400 and HttpMethod == 'POST':
# Try to use http-method: GET
result = self.dorequest(HttpMethod='GET',
parsexsams=parsexsams)
else:
result = None
return result
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 dorequest(self, timeout = TIMEOUT, HttpMethod = "POST", parsexsams = True):
"""
Sends the request to the database node and returns a result.Result instance. The
request uses 'POST' requests by default. If the request fails or if stated in the parameter 'HttpMethod',
'GET' requests will be performed.
The returned result will be parsed by default and the model defined in 'specmodel' will be populated by default
(parseexams = True).
"""
self.xml = None
#self.get_xml(self.Source.Requesturl)
url = self.baseurl + self.querypath
urlobj = urlsplit(url)
if urlobj.scheme == 'https':
conn = HTTPSConnection(urlobj.netloc, timeout = timeout)
else:
conn = HTTPConnection(urlobj.netloc, timeout = timeout)
conn.putrequest(HttpMethod, urlobj.path+"?"+urlobj.query)
conn.endheaders()
try:
res = conn.getresponse()
except socket.timeout:
# error handling has to be included
self.status = 408
self.reason = "Socket timeout"
raise TimeOutError
self.status = res.status
self.reason = res.reason
if not parsexsams:
if res.status == 200:
result = r.Result()
result.Content = res.read()
elif res.status == 400 and HttpMethod == 'POST':
# Try to use http-method: GET
result = self.dorequest( HttpMethod = 'GET', parsexsams = parsexsams)
else:
result = None
else:
if res.status == 200:
self.xml = res.read()
result = r.Result()
result.Xml = self.xml
result.populate_model()
elif res.status == 400 and HttpMethod == 'POST':
# Try to use http-method: GET
result = self.dorequest( HttpMethod = 'GET', parsexsams = parsexsams)
else:
result = None
return result
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 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 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 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
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 getpage():
host = '%s:%s' % (self.interface(), self.PORT)
if self.scheme == 'https':
c = HTTPSConnection(host)
else:
c = HTTPConnection(host)
try:
c.putrequest('GET', '/')
c.endheaders()
response = c.getresponse()
body = response.read()
self.assertEqual(response.status, 200)
self.assertEqual(body, "Hello world!")
finally:
c.close()
success.append(True)
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 getpage():
host = '%s:%s' % (self.interface(), self.PORT)
if self.scheme == 'https':
c = HTTPSConnection(host)
else:
c = HTTPConnection(host)
try:
c.putrequest('GET', '/')
c.endheaders()
response = c.getresponse()
body = response.read()
self.assertEqual(response.status, 200)
self.assertEqual(body, "Hello world!")
finally:
c.close()
success.append(True)
def putrequest(self, method, url, skip_host=0, skip_accept_encoding=0):
import urlparse
parts = urlparse.urlparse(url)
domain, port = urllib.splitport(parts.netloc)
if not port:
port = 80
domain_len = len(domain)
data = struct.pack("!BB%dsH" % domain_len, 3, domain_len, domain, port)
self.send(data)
self.sock = self._context.wrap_socket(self.sock,
server_hostname=domain)
HTTPSConnection.putrequest(self, method, url, skip_host,
skip_accept_encoding)
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 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 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 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 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 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 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 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 doheadrequest(self, timeout=TIMEOUT):
"""
Sends a HEAD request to the database node. The header returned by the database node contains some
information on statistics. This information is stored in the headers object of the request instance.
"""
self.headers = {}
url = self.baseurl + self.querypath
urlobj = urlsplit(url)
if urlobj.scheme == 'https':
conn = HTTPSConnection(urlobj.netloc, timeout=timeout)
else:
conn = HTTPConnection(urlobj.netloc, timeout=timeout)
conn.putrequest("HEAD", urlobj.path + "?" + urlobj.query)
conn.endheaders()
try:
res = conn.getresponse()
except socket.timeout, e:
self.status = 408
self.reason = "Socket timeout"
raise TimeOutError
def doheadrequest(self, timeout = TIMEOUT):
"""
Sends a HEAD request to the database node. The header returned by the database node contains some
information on statistics. This information is stored in the headers object of the request instance.
"""
self.headers = {}
url = self.baseurl + self.querypath
urlobj = urlsplit(url)
if urlobj.scheme == 'https':
conn = HTTPSConnection(urlobj.netloc, timeout = timeout)
else:
conn = HTTPConnection(urlobj.netloc, timeout = timeout)
conn.putrequest("HEAD", urlobj.path+"?"+urlobj.query)
conn.endheaders()
try:
res = conn.getresponse()
except socket.timeout, e:
self.status = 408
self.reason = "Socket timeout"
raise TimeOutError
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
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())
print ("starting to transfer disk %s" % disk_entry.name)
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()
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
# 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)
def putrequest(self, method, url, skip_host=0, skip_accept_encoding=0):
self._method = method
self._path = url
return HTTPSConnection.putrequest(self, method, url, skip_host,
skip_accept_encoding)
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
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
first_space = find(IP, " ")
if first_space != -1:
IP = IP[:first_space]
err = 0
# ------------------------------------------------------------------------------------------------
if err == 1:
print "error determining IP"
else:
print "updating to >" + str(IP) + "< ..."
else:
print "usage: dnsflow HOSTNAME PASSWORD (IP)"
if HOST != "unknown":
params = urlencode({"id": HOST, "pw": PASS, "ip": IP, "client": "DNSflow 0.1"})
try:
conn = HTTPSConnection("www.dtdns.com")
conn.putrequest("POST", "/api/autodns.cfm?" + params)
conn.endheaders()
response = conn.getresponse()
print "dtDNS:" + response.read()
conn.close()
except ResponseNotReady:
print "Problems while connecting to dtDNS!"
except error, errordata:
print "Network problems. [" + str(errordata) + "]"
print "Please be sure you are connected to the internet/network."
except: # for things like socket.error which I couldn't catch "the usual way"...
print "Unexpected error!\nPython traceback:\n"
print_exc()
else:
print "pass them on the command-line."
print "\nomitting IP will force the script to try to determine it automatically."
#
# Not a real unit test.
# Just a test to make sure that ssl works inside your python
# Make sure to test using your Zope's python
#
from httplib import HTTPSConnection
HOSTNAME = 'mail.yahoo.com' # or any other secure server..
conn = HTTPSConnection(HOSTNAME)
conn.putrequest('GET', '/')
conn.endheaders()
response = conn.getresponse()
print response.read()
