def send_command(self, header, body): log("Trying to send a command from the processor [header:%s, body:%s]" % (header, body), DEBUG) code = self.__get_code(header) log("Code is [%s]" % code, DEBUG) if code == self.READ_COMMAND_CODE: log("Return a read command with value FF", DEBUG) return "%s=FF" % body log("Unsupported code [%s] for now" % code, WARNING) return None
def is_valid_helo_command(self, command): log("Validating format for helo with command [%s]" % command, DEBUG) match = self.helo_cmd.match(command) if match: log("Command [%s] is a valid helo command" % command, DEBUG) return True log("Command [%s] is not a valid helo command" % command, DEBUG) return False
def is_valid_test_command(self, command): log("Validating format for test command [%s]" % command, DEBUG) match = self.test_cmd.match(command) if match: log("Match detected for test command [%s]" % command, DEBUG) return True log("Validating error for test command [%s]" % command, DEBUG) return False
def is_valid_send_command(self, command): log("Validating format for send with command [%s]" % command, DEBUG) match = self.send_cmd.match(command) if match: log("Command [%s] is a valid send command" % command, DEBUG) return True log("Command [%s] is not a valid send command" % command, DEBUG) return False
def is_valid_helo_command(self, command): log("Validating format for helo with command [%s]" % command, DEBUG) match = self.helo_cmd.match(command) if match: log("Command [%s] is a valid helo command" % command, DEBUG) return True log("Command [%s] is not a valid helo command" % command, DEBUG) return False
def is_valid_command(self, command): log("Validating generic format for command [%s]" % command, DEBUG) match = self.general_cmd.match(command) if match: log("Match detected for command [%s]" % command, DEBUG) return True log("Validating error for command [%s]" % command, DEBUG) return False
def is_valid_unwatch_command(self, command): log("Validating format for unwatch with command [%s]" % command, DEBUG) match = self.unwatch_cmd.match(command) if match: log("Command [%s] is a valid unwatch command" % command, DEBUG) return True log("Command [%s] is not a valid unwatch command" % command, DEBUG) return False
def is_valid_send_command(self, command): log("Validating format for send with command [%s]" % command, DEBUG) match = self.send_cmd.match(command) if match: log("Command [%s] is a valid send command" % command, DEBUG) return True log("Command [%s] is not a valid send command" % command, DEBUG) return False
def is_valid_test_command(self, command): log("Validating format for test command [%s]" % command, DEBUG) match = self.test_cmd.match(command) if match: log("Match detected for test command [%s]" % command, DEBUG) return True log("Validating error for test command [%s]" % command, DEBUG) return False
def is_valid_command(self, command): log("Validating generic format for command [%s]" % command, DEBUG) match = self.general_cmd.match(command) if match: log("Match detected for command [%s]" % command, DEBUG) return True log("Validating error for command [%s]" % command, DEBUG) return False
def is_valid_unwatch_command(self, command): log("Validating format for unwatch with command [%s]" % command, DEBUG) match = self.unwatch_cmd.match(command) if match: log("Command [%s] is a valid unwatch command" % command, DEBUG) return True log("Command [%s] is not a valid unwatch command" % command, DEBUG) return False
def configure_and_start_server(config, options=None): """ Configure and start the server. Command line options always take advantage over configuration read from file. The file is a way to define default command line options :param config: Configuration read from file :param options: option read from command line """ ################################################################################################ # socket init # ################################################################################################ s = socket() # Create a socket object #host = gethostname() th # Get local machine name host = gethostbyname(config['server_address']) #s.bind((host, int(config['port']))) # Bind to the port s.bind((host, int(config['port']))) buffer_size = int(config['buffer_size']) # sizing the buffer for reading from socket max_connection = int(config['max_connection']) # define the max concurrent connection supported by the server s.listen(max_connection) # Now wait for client connection. liblogging.log("Server is now waiting for connection", liblogging.INFO) ################################################################################################ # socket start # ################################################################################################ while True: c, addr = s.accept() # Establish connection with client. liblogging.log("Got connection from (%s, %s)" % addr) c.send("cE %s\n" % config['msg_banner']) client_thread = dispatcher.Dispatcher(c, addr, buffer_size, options) client_thread.setDaemon(True) client_thread.start() #thread.start_new_thread(handler, (c, addr, buffer_size)) # c.close() # Close the connection
def check_server(address, port): """ :param address: address to check :param port: port to connect to :return: true if address is ready to use false otherwise """ s = socket() liblogging.log("Checking local on port [%s:%d]" % (address, port), liblogging.INFO) try: s.connect((address, port)) # we are able to connect on this port, it means that a server already listening on it ... cannot start the server liblogging.log( "Failure port [%s:%d] is not ready [error : %s]" % (address, port, 'Already listen on the requested port'), liblogging.WARNING) return False except error, e: liblogging.log("OK local port [%s:%d] is ready to use" % (address, port), liblogging.INFO) return True
def manage_watch_stack(self, tasks): """ Add or remove a watched address / list of addresses from the stack of watched address :param tasks: list of task which define the command => addresses concerned by the current job """ self.watch_stack_lock.acquire() for task in tasks: group_address = task.group_address if group_address in self.watch_stack and task.command == libkonext.UNWATCH: liblogging.log("Removing address [%s] into the watch stack" % group_address, liblogging.DEBUG) self.watch_stack.remove(group_address) elif group_address not in self.watch_stack and task.command == libkonext.WATCH: liblogging.log("Adding address [%s] into the watch stack" % group_address, liblogging.DEBUG) self.watch_stack.append(group_address) else: liblogging.log("Nothing to do with the val [%s] into the watch stack" % group_address, liblogging.DEBUG) self.watch_stack_lock.release()
def watch(self): resp_len = self.eibd_connection.EIBGetGroup_Src(self.buff, self.src, self.dest) resp = self.buff.buffer if resp_len == -1: log("Read failed", CRITICAL) elif resp_len < 2: log("Ivalid packet", ERROR) elif resp[0] & 0x3 or (resp[1] & 0xC0) == 0xC0: log("Unknown APDU received", ERROR) else: # manage response type resp_kind = resp[1] & 0xC0 if resp_kind == self.KNX_READ_FLAG: # read ... log("Read datagram handled", INFO) elif resp_kind == self.KNX_RESPONSE_FLAG or resp_kind == self.KNX_WRITE_FLAG: if resp_kind == self.KNX_WRITE_FLAG: log("Write datagram handled", INFO) else: log("Response datagram handled", INFO) # do response processing ... physical_address = self.parser._decode_physical_addr(self.src.data) print "addr phy %s" % physical_address group_address = self.parser._decode_group_addr(self.dest.data) print "addr group %s" % group_address #response_val = None resp_str = self.parser.format_result(resp) print "Response is : %s" % resp_str else: log("Unknown datagram handled", WARNING) return resp
def init_watcher(self): log("Initialize EIBD listening process EIBOpen_GroupSocket_async", DEBUG) self.eibd_connection.EIBOpen_GroupSocket_async(0) # # Forget the cache processing for now, it was a test # #if not self.cache_ok: # self.eibd_connection.EIB_Cache_Enable() # self.cache_ok = True log("Initialize EIBD buffer", DEBUG) self.buff = EIBConnection.EIBBuffer() log("EIBD buffer initialized", DEBUG) log("Initialize EIBD src addr", DEBUG) self.src = EIBConnection.EIBAddr() log("EIBD src addr initialized", DEBUG) log("Initialize EIBD dest addr", DEBUG) self.dest = EIBConnection.EIBAddr() log("EIBD dest addr initialized", DEBUG) self.watch_initialized = True
def log(self, message, level=liblogging.INFO): liblogging.log(message, level)
def handler(client_socket, client_address, buffer_size=1024): """ This method will run for each client. It is a thread callback, It means that it is execute inside a thread. This thread should have many references to be able to dial with the client. :param clientsock: Reference to the client socket :param addr: address of the socket. """ parser = Parser() # define the parser for the thread processor = Processor() # define the process launcher for the thread ... processor.set_parser(parser) # ... and configure it name = "anonymous" # define the name of the client logged_in = False # tag user as not logged in (according to the protocol while 1: data = client_socket.recv(buffer_size) if not data or data.rstrip() == 'quit': # hang off in this case break #### command validation ... #### command = data.rstrip() liblogging.log("Receive command [%s] from %s" % (command, client_address), liblogging.DEBUG) if not parser.is_valid_command(command): msg = "nE E22, \"%s: Invalid argument\"\n" % command liblogging.log("Invalid command [%s] received from[ %s]" % (command, client_address), liblogging.WARNING) client_socket.send(msg) continue # command parsing process header = libkonext.get_header(command) liblogging.log("Receive header [%s] from %s" % (header, client_address), liblogging.DEBUG) # first, check if the login command has been sent if not logged_in and header != libkonext.HELO_PREFIX: msg = "nE E13, \"%s: Permission denied\"\n" % command liblogging.log("Permission denied for %s, client not connected" % client_address, liblogging.WARNING) client_socket.send(msg) continue # check if the command is a valid helo command if not logged_in and header == libkonext.HELO_PREFIX and not parser.is_valid_helo_command(command): msg = "nE E22, \"%s: Invalid argument\"\n" % command liblogging.log("Invalid helo command [%s] received from[ %s]" % (command, client_address), liblogging.WARNING) client_socket.send(msg) continue #### end of command validation ... #### #### command processing #### # log in client if header == libkonext.HELO_PREFIX: name = libkonext.get_client_name(command) liblogging.log("The client %s is now connected with %s" % (client_address, name), liblogging.INFO) msg = "%s\n" % (libkonext.get_ack(header) % name) client_socket.send(msg) logged_in = True else: try: # manage command case ... response = libkonext.send_command(command, processor, parser) client_socket.send(response) continue except Exception: msg = "nE E22, \"%s: Invalid argument\"\n" % command liblogging.log("Invalid command [%s] received from[ %s]" % (command, client_address), liblogging.WARNING) client_socket.send(msg) # try: # msg = "%s\n" % (libkonext.get_ack(header) % name) # except TypeError: # msg = "%s\n" % libkonext.get_ack(header) # # client_socket.send(msg) #### Connection closing #### header = libkonext.get_header(libkonext.BYE_ACK) msg = "%s %s\n" %(header, name) client_socket.send(msg) client_socket.close() liblogging.log("Connection closed from (%s,%s)." % client_address)
import liblogging from flashpolicyd import policy_server if __name__ == '__main__': print "Trying to start the flash policy daemon" server = policy_server(843, './flashpolicy.xml') server.start() config = setup_config("konext") port = int(config['port']) # Port to listening on address = config['server_address'] # Address to listening on app_name = config['app_name'] # Name of the application # initialize the logger liblogging.logger = init_logger(config['format'], app_name, config['log_file'], config['max_logfile_size'], config['nb_logfile']) # checking availability ... if not socket_engine.check_server(address, port): liblogging.log("Port or address is busy. Please refer to logs to know more about the failure", liblogging.ERROR) sys.exit(1) # exiting due to error ... mark_pid_on_fs() liblogging.log("Server starting with pid [%d]" % os.getpid()) socket_engine.configure_and_start_server(config)
import liblogging from flashpolicyd import policy_server if __name__ == '__main__': print "Trying to start the flash policy daemon" server = policy_server(843, './flashpolicy.xml') server.start() config = setup_config("konext") port = int(config['port']) # Port to listening on address = config['server_address'] # Address to listening on app_name = config['app_name'] # Name of the application # initialize the logger liblogging.logger = init_logger(config['format'], app_name, config['log_file'], config['max_logfile_size'], config['nb_logfile']) # checking availability ... if not socket_engine.check_server(address, port): liblogging.log( "Port or address is busy. Please refer to logs to know more about the failure", liblogging.ERROR) sys.exit(1) # exiting due to error ... mark_pid_on_fs() liblogging.log("Server starting with pid [%d]" % os.getpid()) socket_engine.configure_and_start_server(config)