def run(self, sambaopts, versionopts, section_name=None, name=None, pid=None): lp = sambaopts.get_loadparm() logger = self.get_logger("processes") msg_ctx = Messaging() if name is not None: try: ids = msg_ctx.irpc_servers_byname(name) except KeyError: ids = [] for server_id in ids: self.outf.write("%d\n" % server_id.pid) elif pid is not None: names = msg_ctx.irpc_all_servers() for name in names: for server_id in name.ids: if server_id.pid == int(pid): self.outf.write("%s\n" % name.name) else: names = msg_ctx.irpc_all_servers() self.outf.write(" Service: PID \n") self.outf.write("-----------------------------\n") for name in names: for server_id in name.ids: self.outf.write("%-16s %6d\n" % (name.name, server_id.pid))
def dc_watcher(self): (r1, w1) = os.pipe() pid = os.fork() if pid != 0: # Parent process return the result socket to the caller. return r1 # Load the lp context for the Domain Controller, rather than the # member server. config_file = os.environ["DC_SERVERCONFFILE"] lp_ctx = LoadParm() lp_ctx.load(config_file) # # Is the message a SamLogon authentication? def is_sam_logon(m): if m is None: return False msg = json.loads(m) return (msg["type"] == "Authentication" and msg["Authentication"]["serviceDescription"] == "SamLogon") # # Handler function for received authentication messages. def message_handler(context, msgType, src, message): # Print the message to help debugging the tests. # as it's a JSON message it does not look like a sub-unit message. print(message) self.dc_msgs.append(message) # Set up a messaging context to listen for authentication events on # the domain controller. msg_ctx = Messaging((1, ), lp_ctx=lp_ctx) msg_ctx.irpc_add_name(AUTH_EVENT_NAME) msg_handler_and_context = (message_handler, None) msg_ctx.register(msg_handler_and_context, msg_type=MSG_AUTH_LOG) # Wait for the SamLogon message. # As there could be other SamLogon's in progress we need to collect # all the SamLogons and let the caller match them to the session. self.dc_msgs = [] start_time = time.time() while (time.time() - start_time < 1): msg_ctx.loop_once(0.1) # Only interested in SamLogon messages, filter out the rest msgs = list(filter(is_sam_logon, self.dc_msgs)) if msgs: for m in msgs: m += "\n" os.write(w1, get_bytes(m)) else: os.write(w1, get_bytes("None\n")) os.close(w1) msg_ctx.deregister(msg_handler_and_context, msg_type=MSG_AUTH_LOG) msg_ctx.irpc_remove_name(AUTH_EVENT_NAME) os._exit(0)
def setUp(self): super(AuthLogTestBase, self).setUp() lp_ctx = self.get_loadparm() self.msg_ctx = Messaging((1, ), lp_ctx=lp_ctx) global msg_ctxs msg_ctxs.append(self.msg_ctx) self.msg_ctx.irpc_add_name(AUTH_EVENT_NAME) def messageHandler(context, msgType, src, message): # This does not look like sub unit output and it # makes these tests much easier to debug. print(message) jsonMsg = json.loads(message) context["messages"].append(jsonMsg) self.context = {"messages": []} self.msg_handler_and_context = (messageHandler, self.context) self.msg_ctx.register(self.msg_handler_and_context, msg_type=MSG_AUTH_LOG) self.discardMessages() self.remoteAddress = None self.server = os.environ["SERVER"] self.connection = None
def run(self, sambaopts, versionopts, section_name=None, name=None, pid=None): lp = sambaopts.get_loadparm() logger = self.get_logger("processes") msg_ctx = Messaging() if name is not None: try: ids = msg_ctx.irpc_servers_byname(name) except KeyError: ids = [] for server_id in ids: self.outf.write("%d\n" % server_id.pid) elif pid is not None: names = msg_ctx.irpc_all_servers() for name in names: for server_id in name.ids: if server_id.pid == int(pid): self.outf.write("%s\n" % name.name) else: seen = {} # Service entries already printed, service names can # be registered multiple times against a process # but we should only display them once. prefork = {} # Services running in the prefork process model # want to ensure that the master process and workers # are grouped to together. (services, masters, workers) = self.get_service_data(msg_ctx) self.outf.write(" Service: PID\n") self.outf.write("--------------------------------------\n") for service in sorted(services, key=lambda x: x.name): if service.name in masters: # If this service is running in a pre-forked process we # want to print the master process followed by all the # worker processes pid = masters[service.name] if pid not in prefork: prefork[pid] = True self.outf.write("%-26s %6d\n" % (service.name, pid)) if service.name in workers: ws = workers[service.name] for w in ws: (instance, pid) = ws[w] sn = "{0}(worker {1})".format( service.name, instance) self.outf.write("%-26s %6d\n" % (sn, pid)) else: for server_id in service.ids: if (service.name, server_id.pid) not in seen: self.outf.write("%-26s %6d\n" % (service.name, server_id.pid)) seen[(service.name, server_id.pid)] = True
def setUpClass(self): # connect to the server's messaging bus (we need to explicitly load a # different smb.conf here, because in all other respects this test # wants to act as a separate remote client) server_conf = os.getenv('SERVERCONFFILE') if server_conf: lp_ctx = LoadParm(filename_for_non_global_lp=server_conf) else: samba.tests.env_loadparm() self.msg_ctx = Messaging((1,), lp_ctx=lp_ctx) self.msg_ctx.irpc_add_name(AUTH_EVENT_NAME) # Now switch back to using the client-side smb.conf. The tests will # use the first interface in the client.conf (we need to strip off # the subnet mask portion) lp_ctx = samba.tests.env_loadparm() client_ip_and_mask = lp_ctx.get('interfaces')[0] client_ip = client_ip_and_mask.split('/')[0] # the messaging ctx is the server's view of the world, so our own # client IP will be the remoteAddress when connections are logged self.remoteAddress = client_ip def messageHandler(context, msgType, src, message): # This does not look like sub unit output and it # makes these tests much easier to debug. print(message) jsonMsg = json.loads(message) context["messages"].append(jsonMsg) self.context = {"messages": []} self.msg_handler_and_context = (messageHandler, self.context) self.msg_ctx.register(self.msg_handler_and_context, msg_type=MSG_AUTH_LOG) self.remoteAddress = None self.server = os.environ["SERVER"] self.connection = None
def setUp(self): super(SmbcontrolBlockboxTests, self).setUp() lp_ctx = self.get_loadparm() self.msg_ctx = Messaging(lp_ctx=lp_ctx)
def get_context(self, *args, **kwargs): kwargs['lp_ctx'] = samba.tests.env_loadparm() return Messaging(*args, **kwargs)
def setUp(self): super(PreforkProcessRestartTests, self).setUp() lp_ctx = self.get_loadparm() self.msg_ctx = Messaging(lp_ctx=lp_ctx)
def get_context(self, *args, **kwargs): kwargs["messaging_path"] = "." return Messaging(*args, **kwargs)
def get_context(self, *args, **kwargs): return Messaging(*args, **kwargs)
def setUp(self): super(AuditLogTestBase, self).setUp() lp_ctx = self.get_loadparm() self.msg_ctx = Messaging((1, ), lp_ctx=lp_ctx) self.msg_ctx.irpc_add_name(self.event_type) # # Check the remote address of a message against the one beimg used # for the tests. # def isRemote(message): audit = getAudit(message) if audit is None: return False remote = audit["remoteAddress"] if remote is None: return False try: addr = remote.split(":") return addr[1] == self.remoteAddress except IndexError: return False def messageHandler(context, msgType, src, message): # This does not look like sub unit output and it # makes these tests much easier to debug. print(message) jsonMsg = json.loads(message) if ((jsonMsg["type"] == "passwordChange" or jsonMsg["type"] == "dsdbChange" or jsonMsg["type"] == "groupChange") and isRemote(jsonMsg)): context["messages"].append(jsonMsg) elif jsonMsg["type"] == "dsdbTransaction": context["txnMessage"] = jsonMsg self.context = {"messages": [], "txnMessage": None} self.msg_handler_and_context = (messageHandler, self.context) self.msg_ctx.register(self.msg_handler_and_context, msg_type=self.message_type) self.msg_ctx.irpc_add_name(AUTH_EVENT_NAME) def authHandler(context, msgType, src, message): jsonMsg = json.loads(message) if jsonMsg["type"] == "Authorization" and isRemote(jsonMsg): # This does not look like sub unit output and it # makes these tests much easier to debug. print(message) context["sessionId"] = jsonMsg["Authorization"]["sessionId"] context["serviceDescription"] =\ jsonMsg["Authorization"]["serviceDescription"] self.auth_context = {"sessionId": "", "serviceDescription": ""} self.auth_handler_and_context = (authHandler, self.auth_context) self.msg_ctx.register(self.auth_handler_and_context, msg_type=MSG_AUTH_LOG) self.discardMessages() self.server = os.environ["SERVER"] self.connection = None
def setUp(self): super(AuditLogTestBase, self).setUp() # connect to the server's messaging bus (we need to explicitly load a # different smb.conf here, because in all other respects this test # wants to act as a separate remote client) server_conf = os.getenv('SERVERCONFFILE') if server_conf: lp_ctx = LoadParm(filename_for_non_global_lp=server_conf) else: lp_ctx = self.get_loadparm() self.msg_ctx = Messaging((1,), lp_ctx=lp_ctx) self.msg_ctx.irpc_add_name(self.event_type) # Now switch back to using the client-side smb.conf. The tests will # use the first interface in the client.conf (we need to strip off # the subnet mask portion) lp_ctx = self.get_loadparm() client_ip_and_mask = lp_ctx.get('interfaces')[0] client_ip = client_ip_and_mask.split('/')[0] # the messaging ctx is the server's view of the world, so our own # client IP will be the remoteAddress when connections are logged self.remoteAddress = client_ip # # Check the remote address of a message against the one being used # for the tests. # def isRemote(message): audit = getAudit(message) if audit is None: return False remote = audit["remoteAddress"] if remote is None: return False try: addr = remote.split(":") return addr[1] == self.remoteAddress except IndexError: return False def messageHandler(context, msgType, src, message): # This does not look like sub unit output and it # makes these tests much easier to debug. print(message) jsonMsg = json.loads(message) if ((jsonMsg["type"] == "passwordChange" or jsonMsg["type"] == "dsdbChange" or jsonMsg["type"] == "groupChange") and isRemote(jsonMsg)): context["messages"].append(jsonMsg) elif jsonMsg["type"] == "dsdbTransaction": context["txnMessage"] = jsonMsg self.context = {"messages": [], "txnMessage": None} self.msg_handler_and_context = (messageHandler, self.context) self.msg_ctx.register(self.msg_handler_and_context, msg_type=self.message_type) self.msg_ctx.irpc_add_name(AUTH_EVENT_NAME) def authHandler(context, msgType, src, message): jsonMsg = json.loads(message) if jsonMsg["type"] == "Authorization" and isRemote(jsonMsg): # This does not look like sub unit output and it # makes these tests much easier to debug. print(message) context["sessionId"] = jsonMsg["Authorization"]["sessionId"] context["serviceDescription"] =\ jsonMsg["Authorization"]["serviceDescription"] self.auth_context = {"sessionId": "", "serviceDescription": ""} self.auth_handler_and_context = (authHandler, self.auth_context) self.msg_ctx.register(self.auth_handler_and_context, msg_type=MSG_AUTH_LOG) self.discardMessages() self.server = os.environ["SERVER"] self.connection = None