def io_cb(self, watcher, revents):
try:
while True: # Accept as much as possible
try:
client_sock, client_address = self.listen_sock.accept()
except socket.timeout as err:
break
except socket.error as err:
if err.args[0] in NONBLOCKING:
break
else:
raise
else:
logging.debug("ServerMaster[{0}]: Accepted connection from [{1}].".format(os.getpid(),client_address))
# Forward the new client socket to a worker in a simple round robin fashion
self.worker_procs[self.next_worker].in_q.put((reduce_handle(client_sock.fileno()),client_address))
client_sock.close() # Close the socket on the master side
client_sock = None
self.next_worker += 1
if self.next_worker >= self.num_server_workers:
self.next_worker = 0
except Exception:
self.handle_error("Error accepting connection")
def run(self):
logger.info('Starting connection handler thread...')
self.__bind_socket()
logger.info('Connection handler thread started!')
while True:
try:
(sock, addr) = self.sock.accept()
except Exception, err:
logger.write = logger.debug
traceback.print_exc(file=logger)
logger.error('[FriConnectionHandler.accept crash] %s'%err)
break
try:
if self.stopped.is_set():
sock.close()
break
if self.need_reduce:
sock = reduce_handle(sock.fileno())
self.queue.put(sock)
except Exception, err:
logger.write = logger.debug
traceback.print_exc(file=logger)
logger.error('[FriConnectionHandler.run] %s'%err)
def io_cb(self, watcher, revents):
try:
while True: # Accept as much as possible
try:
client_sock, client_address = self.listen_sock.accept()
except socket.timeout as err:
break
except socket.error as err:
if err.args[0] in NONBLOCKING:
break
else:
raise
else:
logging.debug("ServerMaster[{0}]: Accepted connection from [{1}].".format(os.getpid(),client_address))
# Forward the new client socket to a worker in a simple round robin fashion
self.worker_procs[self.next_worker].in_q.put((reduce_handle(client_sock.fileno()),client_address))
client_sock.close() # Close the socket on the master side
client_sock = None
self.next_worker += 1
if self.next_worker >= self.num_server_workers:
self.next_worker = 0
except Exception:
self.handle_error("Error accepting connection")
def serve_forever(self):
""" Accepts connection from multiple clients.
"""
# register SIGTERM for graceful exit.
def stop_gracefully(signum, frame):
self.stop_server()
signal.signal(signal.SIGINT, stop_gracefully)
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
sock.bind(self.addr)
log.debug('%s listening on %s' % (type(self).__name__, self.addr))
# start listening on this port
sock.listen(5)
# sock.setblocking(0)
# spawn worker processes
self.spawn_worker_processes()
try:
while True:
# start accepting connections
log.debug('Main: Waiting for incoming connections')
connection, address = sock.accept()
# connection.setblocking(0)
serialized_socket = reduce_handle(connection.fileno())
self.conn_queue.put(serialized_socket)
except socket.error:
log.warning('Interrupt: Stopping main process')
self.stop_server()
finally:
sock.close()
def process_request(self, request, address):
'''
@see: HTTPServer.process_request
'''
pipe = self.pipes[0]
self.pipes.rotate()
pipe.send((reduce_handle(request.fileno()), address))
def process_request(self, request, address):
'''
@see: HTTPServer.process_request
'''
pipe = self.pipes[0]
self.pipes.rotate()
pipe.send((reduce_handle(request.fileno()), address))
def accept_handler(fd, events):
n = open("/tmp/tTest", 'a')
n.write("socket fd: "+str(fd)+"\n")
n.flush()
while True:
try:
connection, address = sock.accept()
except socket.error as e:
if e.args[0] in (errno.EWOULDBLOCK, errno.EAGAIN):
return
raise
n.write("socket faddr:"+str(address)+"\n")
queue.put_nowait([reduce_handle(connection.fileno()), address])
def handle(self):
# self.request is the TCP socket connected to the client
#self.data = self.request.recv(1024).strip()
#print "{} wrote:".format(self.client_address[0])
#print self.data
# just send back the same data, but upper-cased
#self.request.sendall(self.data.upper())
#Either pipe it to worker directly like this
#pipe_to_worker.send(h) #instanceofmultiprocessing.Pipe
#or use a Queue :)
h = reduce_handle(self.request.fileno())
socket_queue.put(h)
def handle_users(u):
users = u
signal(SIGTERM, quit)
signal(SIGINT, quit)
sock = socket(AF_INET, SOCK_STREAM)
sock.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
sock.bind((host, port))
sock.listen(1)
while True:
clntSock, clntAddr = sock.accept()
clntFile = clntSock.makefile("r", 0)
message = clntFile.readline().strip()
action, username = message.split()
if (action == "ENTER"):
pickled_socket = reduce_handle(clntSock.fileno())
users[username] = pickled_socket
print "{"
for keys, values in users.items():
print keys + ":", values
print "}"
elif (action == "EXIT"):
fd = rebuild_handle(users[username])
quitSock = fromfd(fd, AF_INET, SOCK_STREAM)
quitSock.close()
del users[username]
clntSock.close()
print "{"
for keys, values in users.items():
print keys + ": ", values
print "}"
clntFile.close()
def start(self):
server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.server = server
server.setblocking(0)
# TODO change localhost to hostname
server_address = ('localhost', self.port)
server.bind(server_address)
print('Starting server on {0}'.format(server_address))
server.listen(5)
self.__initDispatchers()
inputs = [server]
while inputs:
#print('Waiting for next client')
readable, writable, exceptional = select.select(inputs, [], [])
for s in readable:
if s is server:
connection, client_address = s.accept()
connection.setblocking(0)
print('New connection from {0}'.format(client_address))
dispatcher = self.__getDispatcher()
print('Last dispatcher={0}'.format(dispatcher))
print('Add connection {0} to dispatcher {1}'.format(
client_address, dispatcher))
h = reduce_handle(connection.fileno())
self.client_queue[dispatcher].put(h)
#connection.close()
else:
print('Select returned {0}'.format(s))
def serve_forever(self):
""" Accepts connection from multiple clients.
"""
# register SIGTERM for graceful exit.
def stop_gracefully(signum, frame):
self.stop_server()
signal.signal(signal.SIGINT, stop_gracefully)
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
sock.bind(self.addr)
log.debug('%s listening on %s' % (type(self).__name__, self.addr))
# start listening on this port
sock.listen(5)
# sock.setblocking(0)
# spawn worker processes
self.spawn_worker_processes()
try:
while True:
# start accepting connections
log.debug('Main: Waiting for incoming connections')
connection, address = sock.accept()
# connection.setblocking(0)
serialized_socket = reduce_handle(connection.fileno())
self.conn_queue.put(serialized_socket)
except socket.error:
log.warning('Interrupt: Stopping main process')
self.stop_server()
finally:
sock.close()
def handle(self):
h = reduce_handle(self.request.fileno())
socket_queue.put(h)
def pushToWorker(self, client):
clientHandler = reduction.reduce_handle(client.fileno())
self.workerPipe[self.workerIndex].send(clientHandler)
self.workerIndex = (self.workerIndex + 1) % len(self.workerPipe)
def reduce_socket(s):
if not hasattr(socket, "fromfd"):
raise TypeError("sockets cannot be pickled on this system.")
reduced_handle = reduce_handle(s.fileno())
return _rebuild_socket, (reduced_handle, s.family, s.type, s.proto)
def serialise_socket(socket):
return reduction.reduce_handle(socket.fileno())
(client_sock, client_address) = \
self.listen_sock.accept()
except socket.timeout, err:
break
except socket.error, err:
if err.args[0] in NONBLOCKING:
break
else:
raise
else:
logging.debug('ServerMaster[{0}]: Accepted connection from [{1}].'.format(os.getpid(),
client_address))
# Forward the new client socket to a worker in a simple round robin fashion
self.worker_procs[self.next_worker].in_q.put((reduce_handle(client_sock.fileno()),
client_address))
client_sock.close() # Close the socket on the master side
client_sock = None
self.next_worker += 1
if self.next_worker >= self.num_server_workers:
self.next_worker = 0
except Exception:
self.handle_error('Error accepting connection')
return
def out_q_cb(self, watcher, revents):
try:
val = watcher.data.out_q.get()
logging.debug('ServerMaster received outQ event from [%s] data [%s]'
def authenticate(self):
"""
For the initial phase, this method gets an unique identifier from the user and uses it to map connections
TODO: Introduce password based authentication system
:return: Username => str
"""
self.send_message("Please enter your unique name to begin")
while True:
user_given_name = self.get_name()
if user_given_name == LIST_USERS_COMMAND:
self.list_online_users()
continue
if user_given_name == QUIT_COMMAND:
self.end_connection_and_clean_up()
return None
# pick only the 1st word.
user_given_name = user_given_name.split(" ")[0]
account = dao.findOne(Collection.Account.name,
params={"_id": user_given_name})
# New registration
if not account:
# Insert New Account
dao.insertOne(Collection.Account.name,
params={
"_id": user_given_name,
"last_login": datetime.datetime.now(),
"status": Collection.Account.STATUS_ONLINE
})
else:
dao.update(Collection.Account.name,
params={"_id": user_given_name},
set_params={
"status": Collection.Account.STATUS_ONLINE,
"last_login": datetime.datetime.now()
})
# User already exists, add new connection if not already present (To support login from multiple devices)
ip_address, port = self.connection.getpeername()
existing_connection = dao.findOne(Collection.Connection.name,
params={
"username": user_given_name,
"ip_address": ip_address,
"port": port
})
if not existing_connection:
# TODO: Use these reduced connection objects in a different worker process to route messages
reduced_connection = reduce_handle(self.connection.fileno())
dao.insertOne(Collection.Connection.name,
params={
"username": user_given_name,
"reduced_connection": reduced_connection,
"ip_address": ip_address,
"port": port
})
self.name = user_given_name
break
self.send_message('Welcome {}\n Usage: @username Hello World!'.format(
self.name.upper()))
# mapping connection and username in memory for some send quick prompt messages
ip_address, port = self.connection.getpeername()
self.name_and_address = "{}__{}__{}".format(self.name, ip_address,
port)
accounts[self.name_and_address] = self.connection
return self.name
#main process
from multiprocessing.reduction import reduce_handle
h = reduce_handle(client_socket.fileno())
pipe_to_worker.send(h) #instance of multiprocessing.Pipe()
# worker
from multiprocessing.reduction import reduce_handle
client_socket = socket.fromfd(fd, socket.AF_INET, socket.SOC_STREAM)
client_socket.send("hello from the worker process\r\n")
h = pipe.recv()
def pushToWorker(self, client):
clientHandler = reduction.reduce_handle(client.fileno());
self.workerPipe[self.workerIndex].send(clientHandler);
self.workerIndex = (self.workerIndex + 1) % len(self.workerPipe);
def reduce_socket(s):
if not hasattr(socket, "fromfd"):
raise TypeError("sockets cannot be pickled on this system.")
reduced_handle = reduce_handle(s.fileno())
return _rebuild_socket, (reduced_handle, s.family, s.type, s.proto)
def main():
configure_logger(log)
log.info('This is RIfSniff Collector v%s' % VERSION)
parser = argparse.ArgumentParser(description='RIfSniff Packet Collector',
epilog='Try using it with `sudo` if --list shows no available interfaces')
parser.add_argument('--version', action='version', version='%(prog)s 0.1')
parser.add_argument('-l', '--list', action='store_true',
help='List local interfaces available for packet capture')
parser.add_argument('-c', '--list-compact', action='store_true',
help='List interface names only, no description')
parser.add_argument('-a', '--address', type=str, default='0.0.0.0',
help='Address for inbound connection (default: 0.0.0.0)')
parser.add_argument('-p', '--port', type=int, default=6384,
help='Port for inbound connection (default: 6384)')
args = parser.parse_args()
signal.signal(signal.SIGINT, sighandler)
if args.list_compact or args.list:
try:
devs = pcap.findalldevs()
if not devs:
log.warn('No device available for capture')
log.warn('Try running the program with higher permissions (e.g.: sudo)')
elif args.list_compact:
log.info('Listing names of devices available for capture')
utils.print_device_list(devs)
else:
log.info('Listing devices available for capture')
for dev in devs:
utils.print_device_description(dev)
finally:
log.info('Exiting...')
sys.exit(0)
server_addr = (args.address, args.port)
server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server_socket.bind(server_addr)
server_socket.listen(10)
try:
while True:
log.info('server socket listening on <%s:%d>' % server_addr)
client, address = server_socket.accept()
pipe_r, pipe_w = multiprocessing.Pipe(duplex=False)
#proc = multiprocessing.Process(target=serve_client, args=(pipe_r,))
proc = RemoteInterfaceSniffer(pipe_r)
PROCLIST.append(proc)
proc.start()
client_handle = reduce_handle(client.fileno())
pipe_w.send(client_handle)
finally:
logging.shutdown()
sys.exit(0)
