def __init__(self, conn_id, host, port, timeout=60):
if (STORAGE_METHOD == 'AmazonSQS'):
self.storage = AmazonSQS()
else:
self.storage = BoxDotNet()
self.host = host
self.port = int(port)
self.conn_id = conn_id
self.timeout = timeout
self.client_buffer = ''
tries = 0
while (1):
self.requests = self.storage.get_requests_loc(self.conn_id)
self.responses = self.storage.get_responses_loc(self.conn_id)
print "requests loc: %s, responses loc: %s" % (self.requests,
self.responses)
if (self.requests == False or self.responses == False):
time.sleep(1)
tries += 1
if (tries >= 10):
return
else:
break
data = self.get_base_header()
if (not data):
return
self.method, self.path, self.protocol = data
if (not self.method or not self.path or not self.protocol):
return
if self.method == 'CONNECT':
self.method_CONNECT()
elif self.method in ('OPTIONS', 'GET', 'HEAD', 'POST', 'PUT', 'DELETE',
'TRACE'):
self.method_others()
self.target.close
def __init__(self, conn_id, host, port, timeout=60):
if STORAGE_METHOD == "AmazonSQS":
self.storage = AmazonSQS()
else:
self.storage = BoxDotNet()
self.host = host
self.port = int(port)
self.conn_id = conn_id
self.timeout = timeout
self.client_buffer = ""
tries = 0
while 1:
self.requests = self.storage.get_requests_loc(self.conn_id)
self.responses = self.storage.get_responses_loc(self.conn_id)
print "requests loc: %s, responses loc: %s" % (self.requests, self.responses)
if self.requests == False or self.responses == False:
time.sleep(1)
tries += 1
if tries >= 10:
return
else:
break
data = self.get_base_header()
if not data:
return
self.method, self.path, self.protocol = data
if not self.method or not self.path or not self.protocol:
return
if self.method == "CONNECT":
self.method_CONNECT()
elif self.method in ("OPTIONS", "GET", "HEAD", "POST", "PUT", "DELETE", "TRACE"):
self.method_others()
self.target.close
def start_server(host='localhost', port=8081, IPv6=False, timeout=60):
if IPv6 == True:
soc_type = socket.AF_INET6
else:
soc_type = socket.AF_INET
soc = socket.socket(soc_type)
soc.bind((host, port))
print "Serving on %s:%d." % (host, port) #debug
soc.listen(0)
if (STORAGE_METHOD == 'AmazonSQS'):
storage = AmazonSQS()
else:
storage = BoxDotNet()
while 1:
check_for_requests(storage)
class ConnectionHandler:
def __init__(self, connection, address, timeout):
self.client = connection
self.client_buffer = ''
self.timeout = timeout
self.method, self.path, self.protocol = self.get_base_header()
if (USE_STORAGE and self.method != "CONNECT"):
self.set_up_storage()
if self.method=='CONNECT':
self.method_CONNECT(USE_STORAGE)
elif self.method in ('OPTIONS', 'GET', 'HEAD', 'POST', 'PUT',
'DELETE', 'TRACE'):
self.method_others(USE_STORAGE)
self.client.close()
if (not USE_STORAGE):
self.target.close()
def set_up_storage(self):
self.conn_name = "%d"%random.uniform(0, 1000000)
if (STORAGE_METHOD == 'AmazonSQS'):
self.storage = AmazonSQS()
else:
self.storage = BoxDotNet()
#self.requests = self.storage.get_requests_loc(self.conn_name)
#self.responses = self.storage.get_responses_loc(self.conn_name)
def get_base_header(self):
while 1:
self.client_buffer += self.client.recv(BUFLEN)
end = self.client_buffer.find('\n')
if end!=-1:
break
print '%s'%self.client_buffer[:end]#debug
self.connect = self.client_buffer[:end] + "\n"
data = (self.client_buffer[:end+1]).split()
self.client_buffer = self.client_buffer[end+1:]
return data
def method_CONNECT(self, use_storage = False):
self.client.send(HTTPVER+' 200 Connection established\n'+
'Proxy-agent: %s\n\n'%VERSION)
if (use_storage):
self.set_up_storage()
self._connect_target(self.path, use_storage)
if (use_storage):
self.storage.put(self.requests, self.connect, True)
self.client_buffer = ''
self._read_write(use_storage)
def method_others(self, use_storage = False):
self.path = self.path[7:]
i = self.path.find('/')
host = self.path[:i]
path = self.path[i:]
self._connect_target(host, use_storage)
data = '%s %s %s\n'%(self.method, path, self.protocol)+ self.client_buffer
if (use_storage):
self.storage.put(self.requests, data, True)
else:
self.target.send(data)
self.client_buffer = ''
self._read_write(use_storage)
def _connect_target(self, host, use_storage = False):
i = host.find(':')
if i!=-1:
port = int(host[i+1:])
host = host[:i]
else:
port = 80
if (not use_storage):
(soc_family, _, _, _, address) = socket.getaddrinfo(host, port)[0]
self.target = socket.socket(soc_family)
self.target.connect(address)
else:
self.requests, self.responses = self.storage.new_connection(self.conn_name, "%s %s %d"%(self.conn_name, host, port))
print "Requests loc: %s, Responses loc: %s"%(self.requests, self.responses)
def _read_write(self, use_storage = False):
msg_num = -1
buffered = []
time_out_max = self.timeout/3
if (use_storage):
socs = [self.client]
else:
socs = [self.client, self.target]
count = 0
while 1:
count += 1
(recv, _, error) = select.select(socs, [], socs, 3)
if error:
break
if recv:
for in_ in recv:
data = in_.recv(BUFLEN)
if in_ is self.client and not use_storage:
out = self.target
else:
out = self.client
if data:
if in_ is self.client and use_storage:
self.storage.put(self.requests, data, True)
else:
out.send(data)
count = 0
if count == time_out_max:
break
if (use_storage):
print "Checking for messages in responses folder: %s"%self.responses
msg = self.storage.get(self.responses, True)
if (msg):
self.client.send(msg)
def set_up_storage(self):
self.conn_name = "%d"%random.uniform(0, 1000000)
if (STORAGE_METHOD == 'AmazonSQS'):
self.storage = AmazonSQS()
else:
self.storage = BoxDotNet()
class ConnectionHandler:
def __init__(self, conn_id, host, port, timeout=60):
if STORAGE_METHOD == "AmazonSQS":
self.storage = AmazonSQS()
else:
self.storage = BoxDotNet()
self.host = host
self.port = int(port)
self.conn_id = conn_id
self.timeout = timeout
self.client_buffer = ""
tries = 0
while 1:
self.requests = self.storage.get_requests_loc(self.conn_id)
self.responses = self.storage.get_responses_loc(self.conn_id)
print "requests loc: %s, responses loc: %s" % (self.requests, self.responses)
if self.requests == False or self.responses == False:
time.sleep(1)
tries += 1
if tries >= 10:
return
else:
break
data = self.get_base_header()
if not data:
return
self.method, self.path, self.protocol = data
if not self.method or not self.path or not self.protocol:
return
if self.method == "CONNECT":
self.method_CONNECT()
elif self.method in ("OPTIONS", "GET", "HEAD", "POST", "PUT", "DELETE", "TRACE"):
self.method_others()
self.target.close
def get_base_header(self):
count = 0
while 1:
data = self.storage.get(self.requests, True)
if data:
self.client_buffer += data
end = self.client_buffer.find("\n")
if end != -1:
break
count += 1
if count > self.timeout:
return False
print "%s" % self.client_buffer[:end] # debug
data = (self.client_buffer[: end + 1]).split()
self.client_buffer = self.client_buffer[end + 1 :]
return data
def method_CONNECT(self):
self._connect_target(self.path)
self.client_buffer = ""
self._read_write()
def method_others(self):
print "Path: %s, host: %s" % (self.path, self.host)
path = self.path
self._connect_target(self.host)
data = "%s %s %s\n" % (self.method, path, self.protocol) + self.client_buffer
self.target.send(data)
self.client_buffer = ""
self._read_write()
def _connect_target(self, host):
i = host.find(":")
if i != -1:
port = int(host[i + 1 :])
host = host[:i]
else:
port = self.port
print "Host: %s, port: %s" % (host, port)
(soc_family, _, _, _, address) = socket.getaddrinfo(host, port)[0]
self.target = socket.socket(soc_family)
self.target.connect(address)
def _read_write(self):
time_out_max = self.timeout / 3
socs = [self.target]
count = 0
while 1:
count += 1
(recv, _, error) = select.select(socs, [], socs, 3)
if error:
break
out = self.target
if recv:
for in_ in recv:
data = in_.recv(BUFLEN)
if data:
if in_ is self.target:
self.storage.put(self.responses, data, True)
else:
out.send(data)
count = 0
print "Getting messages from requests folder %s" % self.requests
resp = self.storage.get(self.requests, True)
if resp:
print "Got data: %s" % resp
out.send(resp)
if count == time_out_max:
break
class ConnectionHandler:
def __init__(self, conn_id, host, port, timeout=60):
if (STORAGE_METHOD == 'AmazonSQS'):
self.storage = AmazonSQS()
else:
self.storage = BoxDotNet()
self.host = host
self.port = int(port)
self.conn_id = conn_id
self.timeout = timeout
self.client_buffer = ''
tries = 0
while (1):
self.requests = self.storage.get_requests_loc(self.conn_id)
self.responses = self.storage.get_responses_loc(self.conn_id)
print "requests loc: %s, responses loc: %s" % (self.requests,
self.responses)
if (self.requests == False or self.responses == False):
time.sleep(1)
tries += 1
if (tries >= 10):
return
else:
break
data = self.get_base_header()
if (not data):
return
self.method, self.path, self.protocol = data
if (not self.method or not self.path or not self.protocol):
return
if self.method == 'CONNECT':
self.method_CONNECT()
elif self.method in ('OPTIONS', 'GET', 'HEAD', 'POST', 'PUT', 'DELETE',
'TRACE'):
self.method_others()
self.target.close
def get_base_header(self):
count = 0
while 1:
data = self.storage.get(self.requests, True)
if (data):
self.client_buffer += data
end = self.client_buffer.find('\n')
if end != -1:
break
count += 1
if (count > self.timeout):
return False
print '%s' % self.client_buffer[:end] #debug
data = (self.client_buffer[:end + 1]).split()
self.client_buffer = self.client_buffer[end + 1:]
return data
def method_CONNECT(self):
self._connect_target(self.path)
self.client_buffer = ''
self._read_write()
def method_others(self):
print "Path: %s, host: %s" % (self.path, self.host)
path = self.path
self._connect_target(self.host)
data = '%s %s %s\n' % (self.method, path,
self.protocol) + self.client_buffer
self.target.send(data)
self.client_buffer = ''
self._read_write()
def _connect_target(self, host):
i = host.find(':')
if i != -1:
port = int(host[i + 1:])
host = host[:i]
else:
port = self.port
print "Host: %s, port: %s" % (host, port)
(soc_family, _, _, _, address) = socket.getaddrinfo(host, port)[0]
self.target = socket.socket(soc_family)
self.target.connect(address)
def _read_write(self):
time_out_max = self.timeout / 3
socs = [self.target]
count = 0
while 1:
count += 1
(recv, _, error) = select.select(socs, [], socs, 3)
if error:
break
out = self.target
if recv:
for in_ in recv:
data = in_.recv(BUFLEN)
if data:
if in_ is self.target:
self.storage.put(self.responses, data, True)
else:
out.send(data)
count = 0
print "Getting messages from requests folder %s" % self.requests
resp = self.storage.get(self.requests, True)
if (resp):
print "Got data: %s" % resp
out.send(resp)
if count == time_out_max:
break
class ConnectionHandler:
def __init__(self, connection, address, timeout):
self.client = connection
self.client_buffer = ''
self.timeout = timeout
self.method, self.path, self.protocol = self.get_base_header()
if (USE_STORAGE and self.method != "CONNECT"):
self.set_up_storage()
if self.method == 'CONNECT':
self.method_CONNECT(USE_STORAGE)
elif self.method in ('OPTIONS', 'GET', 'HEAD', 'POST', 'PUT', 'DELETE',
'TRACE'):
self.method_others(USE_STORAGE)
self.client.close()
if (not USE_STORAGE):
self.target.close()
def set_up_storage(self):
self.conn_name = "%d" % random.uniform(0, 1000000)
if (STORAGE_METHOD == 'AmazonSQS'):
self.storage = AmazonSQS()
else:
self.storage = BoxDotNet()
#self.requests = self.storage.get_requests_loc(self.conn_name)
#self.responses = self.storage.get_responses_loc(self.conn_name)
def get_base_header(self):
while 1:
self.client_buffer += self.client.recv(BUFLEN)
end = self.client_buffer.find('\n')
if end != -1:
break
print '%s' % self.client_buffer[:end] #debug
self.connect = self.client_buffer[:end] + "\n"
data = (self.client_buffer[:end + 1]).split()
self.client_buffer = self.client_buffer[end + 1:]
return data
def method_CONNECT(self, use_storage=False):
self.client.send(HTTPVER + ' 200 Connection established\n' +
'Proxy-agent: %s\n\n' % VERSION)
if (use_storage):
self.set_up_storage()
self._connect_target(self.path, use_storage)
if (use_storage):
self.storage.put(self.requests, self.connect, True)
self.client_buffer = ''
self._read_write(use_storage)
def method_others(self, use_storage=False):
self.path = self.path[7:]
i = self.path.find('/')
host = self.path[:i]
path = self.path[i:]
self._connect_target(host, use_storage)
data = '%s %s %s\n' % (self.method, path,
self.protocol) + self.client_buffer
if (use_storage):
self.storage.put(self.requests, data, True)
else:
self.target.send(data)
self.client_buffer = ''
self._read_write(use_storage)
def _connect_target(self, host, use_storage=False):
i = host.find(':')
if i != -1:
port = int(host[i + 1:])
host = host[:i]
else:
port = 80
if (not use_storage):
(soc_family, _, _, _, address) = socket.getaddrinfo(host, port)[0]
self.target = socket.socket(soc_family)
self.target.connect(address)
else:
self.requests, self.responses = self.storage.new_connection(
self.conn_name, "%s %s %d" % (self.conn_name, host, port))
print "Requests loc: %s, Responses loc: %s" % (self.requests,
self.responses)
def _read_write(self, use_storage=False):
msg_num = -1
buffered = []
time_out_max = self.timeout / 3
if (use_storage):
socs = [self.client]
else:
socs = [self.client, self.target]
count = 0
while 1:
count += 1
(recv, _, error) = select.select(socs, [], socs, 3)
if error:
break
if recv:
for in_ in recv:
data = in_.recv(BUFLEN)
if in_ is self.client and not use_storage:
out = self.target
else:
out = self.client
if data:
if in_ is self.client and use_storage:
self.storage.put(self.requests, data, True)
else:
out.send(data)
count = 0
if count == time_out_max:
break
if (use_storage):
print "Checking for messages in responses folder: %s" % self.responses
msg = self.storage.get(self.responses, True)
if (msg):
self.client.send(msg)
def set_up_storage(self):
self.conn_name = "%d" % random.uniform(0, 1000000)
if (STORAGE_METHOD == 'AmazonSQS'):
self.storage = AmazonSQS()
else:
self.storage = BoxDotNet()
