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 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 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 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 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)