lib/messages.c

Module for internal messaging between Samba daemons. [詳細]

ソースコードを見る。

データ構造
struct	message_rec
struct	dispatch_fns
struct	msg_all
struct	messaging_callback
struct	messaging_context
関数
void	gfree_messages (void)
static void	sig_usr1 (void)
static void	ping_message (int msg_type, struct process_id src, void *buf, size_t len, void *private_data)
BOOL	message_init (void)
static TDB_DATA	message_key_pid (struct process_id pid)
static NTSTATUS	message_notify (struct process_id procid)
static NTSTATUS	message_send_pid_internal (struct process_id pid, int msg_type, const void *buf, size_t len, BOOL duplicates_allowed, unsigned int timeout)
NTSTATUS	message_send_pid (struct process_id pid, int msg_type, const void *buf, size_t len, BOOL duplicates_allowed)
NTSTATUS	message_send_pid_with_timeout (struct process_id pid, int msg_type, const void *buf, size_t len, BOOL duplicates_allowed, unsigned int timeout)
unsigned int	messages_pending_for_pid (struct process_id pid)
static BOOL	retrieve_all_messages (char **msgs_buf, size_t *total_len)
static BOOL	message_recv (char *msgs_buf, size_t total_len, int *msg_type, struct process_id *src, char **buf, size_t *len)
void	message_dispatch (void)
void	message_register (int msg_type, void(*fn)(int msg_type, struct process_id pid, void *buf, size_t len, void *private_data), void *private_data)
void	message_deregister (int msg_type)
static int	traverse_fn (TDB_CONTEXT *the_tdb, TDB_DATA kbuf, TDB_DATA dbuf, void *state)
BOOL	message_send_all (TDB_CONTEXT *conn_tdb, int msg_type, const void *buf, size_t len, BOOL duplicates_allowed, int *n_sent)
	Send a message to all smbd processes.
void	message_block (void)
void	message_unblock (void)
static int	messaging_context_destructor (struct messaging_context *ctx)
messaging_context *	messaging_init (TALLOC_CTX *mem_ctx, struct server_id server_id, struct event_context *ev)
static void	messaging_callback (int msg_type, struct process_id pid, void *buf, size_t len, void *private_data)
NTSTATUS	messaging_register (struct messaging_context *ctx, void *private_data, uint32_t msg_type, void(*fn)(struct messaging_context *msg, void *private_data, uint32_t msg_type, struct server_id server_id, DATA_BLOB *data))
void	messaging_deregister (struct messaging_context *ctx, uint32_t msg_type, void *private_data)
NTSTATUS	messaging_send (struct messaging_context *msg, struct server_id server, uint32_t msg_type, DATA_BLOB *data)
変数
static TDB_CONTEXT *	tdb
static int	received_signal

---

説明

Module for internal messaging between Samba daemons.

The idea is that if a part of Samba wants to do communication with another Samba process then it will do a message_register() of a dispatch function, and use message_send_pid() to send messages to that process.

The dispatch function is given the pid of the sender, and it can use that to reply by message_send_pid(). See ping_message() for a simple example.

Dispatch functions must be able to cope with incoming messages on an *odd* byte boundary.

This system doesn't have any inherent size limitations but is not very efficient for large messages or when messages are sent in very quick succession.

messages.c で定義されています。

---

関数

void gfree_messages

(

void

)

messages.c の 78 行で定義されています。

参照先 dispatch_fns::next.

参照元 gfree_all().

{
        struct dispatch_fns *dfn, *next;

        /* delete the dispatch_fns list */
        dfn = dispatch_fns;
        while( dfn ) {
                next = dfn->next;
                DLIST_REMOVE(dispatch_fns, dfn);
                SAFE_FREE(dfn);
                dfn = next;
        }
}

static void sig_usr1

(

void

)

[static]

messages.c の 96 行で定義されています。

参照先 received_signal・sys_select_signal().

参照元 main()・message_init().

{
        received_signal = 1;
        sys_select_signal(SIGUSR1);
}

static void ping_message	(	int	msg_type,
		struct process_id	src,
		void *	buf,
		size_t	len,
		void *	private_data
	)			[static]

messages.c の 106 行で定義されています。

参照先 message_send_pid()・procid_str_static().

参照元 message_init().

{
        const char *msg = buf ? (const char *)buf : "none";

        DEBUG(1,("INFO: Received PING message from PID %s [%s]\n",
                 procid_str_static(&src), msg));
        message_send_pid(src, MSG_PONG, buf, len, True);
}

BOOL message_init

(

void

)

messages.c の 120 行で定義されています。

参照先 CatchSignal()・lock_path()・message_register()・ping_message()・register_dmalloc_msgs()・register_msg_pool_usage()・sec_init()・sig_usr1()・tdb・tdb_open_log()・tdb_set_max_dead().

参照元 cli_send_mailslot()・main()・send_message().

{
        sec_init();

        if (tdb)
                return True;

        tdb = tdb_open_log(lock_path("messages.tdb"), 
                       0, TDB_CLEAR_IF_FIRST|TDB_DEFAULT, 
                       O_RDWR|O_CREAT,0600);

        if (!tdb) {
                DEBUG(0,("ERROR: Failed to initialise messages database\n"));
                return False;
        }

        /* Activate the per-hashchain freelist */
        tdb_set_max_dead(tdb, 5);

        CatchSignal(SIGUSR1, SIGNAL_CAST sig_usr1);

        message_register(MSG_PING, ping_message, NULL);

        /* Register some debugging related messages */

        register_msg_pool_usage();
        register_dmalloc_msgs();

        return True;
}

static TDB_DATA message_key_pid

(

struct process_id

pid

)

[static]

messages.c の 155 行で定義されています。

参照先 TDB_DATA::dptr・TDB_DATA::dsize・procid_str_static().

参照元 message_notify()・message_send_pid_internal()・messages_pending_for_pid()・retrieve_all_messages().

{
        static char key[20];
        TDB_DATA kbuf;

        slprintf(key, sizeof(key)-1, "PID/%s", procid_str_static(&pid));
        
        kbuf.dptr = (char *)key;
        kbuf.dsize = strlen(key)+1;
        return kbuf;
}

static NTSTATUS message_notify

(

struct process_id

procid

)

[static]

messages.c の 172 行で定義されています。

参照先 errno・message_key_pid()・process_id::pid・restore_re_uid_fromroot()・save_re_uid()・set_effective_uid()・strerror()・tdb・tdb_delete().

参照元 message_send_pid_internal().

{
        pid_t pid = procid.pid;
        int ret;
        uid_t euid = geteuid();

        /*
         * Doing kill with a non-positive pid causes messages to be
         * sent to places we don't want.
         */

        SMB_ASSERT(pid > 0);

        if (euid != 0) {
                /* If we're not root become so to send the message. */
                save_re_uid();
                set_effective_uid(0);
        }

        ret = kill(pid, SIGUSR1);

        if (euid != 0) {
                /* Go back to who we were. */
                int saved_errno = errno;
                restore_re_uid_fromroot();
                errno = saved_errno;
        }

        if (ret == -1) {
                if (errno == ESRCH) {
                        DEBUG(2,("pid %d doesn't exist - deleting messages record\n",
                                 (int)pid));
                        tdb_delete(tdb, message_key_pid(procid));

                        /*
                         * INVALID_HANDLE is the closest I can think of -- vl
                         */
                        return NT_STATUS_INVALID_HANDLE;
                }

                DEBUG(2,("message to process %d failed - %s\n", (int)pid,
                         strerror(errno)));

                /*
                 * No call to map_nt_error_from_unix -- don't want to link in
                 * errormap.o into lots of utils.
                 */

                if (errno == EINVAL) return NT_STATUS_INVALID_PARAMETER;
                if (errno == EPERM)  return NT_STATUS_ACCESS_DENIED;
                return NT_STATUS_UNSUCCESSFUL;
        }

        return NT_STATUS_OK;
}

static NTSTATUS message_send_pid_internal	(	struct process_id	pid,
		int	msg_type,
		const void *	buf,
		size_t	len,
		BOOL	duplicates_allowed,
		unsigned int	timeout
	)			[static]

messages.c の 232 行で定義されています。

参照先 message_rec::dest・TDB_DATA::dptr・TDB_DATA::dsize・errno・message_rec::len・message_key_pid()・message_notify()・message_rec::msg_type・message_rec::msg_version・procid_self()・procid_to_pid()・message_rec::src・tdb・tdb_append()・tdb_chainlock()・tdb_chainlock_with_timeout()・tdb_chainunlock()・tdb_fetch()・tdb_store().

参照元 message_send_pid()・message_send_pid_with_timeout()・messaging_send().

{
        TDB_DATA kbuf;
        TDB_DATA dbuf;
        TDB_DATA old_dbuf;
        struct message_rec rec;
        char *ptr;
        struct message_rec prec;

        /* NULL pointer means implicit length zero. */
        if (!buf) {
                SMB_ASSERT(len == 0);
        }

        /*
         * Doing kill with a non-positive pid causes messages to be
         * sent to places we don't want.
         */

        SMB_ASSERT(procid_to_pid(&pid) > 0);

        rec.msg_version = MESSAGE_VERSION;
        rec.msg_type = msg_type;
        rec.dest = pid;
        rec.src = procid_self();
        rec.len = buf ? len : 0;

        kbuf = message_key_pid(pid);

        dbuf.dptr = (char *)SMB_MALLOC(len + sizeof(rec));
        if (!dbuf.dptr) {
                return NT_STATUS_NO_MEMORY;
        }

        memcpy(dbuf.dptr, &rec, sizeof(rec));
        if (len > 0 && buf)
                memcpy((void *)((char*)dbuf.dptr+sizeof(rec)), buf, len);

        dbuf.dsize = len + sizeof(rec);

        if (duplicates_allowed) {

                /* If duplicates are allowed we can just append the message and return. */

                /* lock the record for the destination */
                if (timeout) {
                        if (tdb_chainlock_with_timeout(tdb, kbuf, timeout) == -1) {
                                DEBUG(0,("message_send_pid_internal: failed to get "
                                         "chainlock with timeout %ul.\n", timeout));
                                SAFE_FREE(dbuf.dptr);
                                return NT_STATUS_IO_TIMEOUT;
                        }
                } else {
                        if (tdb_chainlock(tdb, kbuf) == -1) {
                                DEBUG(0,("message_send_pid_internal: failed to get "
                                         "chainlock.\n"));
                                SAFE_FREE(dbuf.dptr);
                                return NT_STATUS_LOCK_NOT_GRANTED;
                        }
                }       
                tdb_append(tdb, kbuf, dbuf);
                tdb_chainunlock(tdb, kbuf);

                SAFE_FREE(dbuf.dptr);
                errno = 0;                    /* paranoia */
                return message_notify(pid);
        }

        /* lock the record for the destination */
        if (timeout) {
                if (tdb_chainlock_with_timeout(tdb, kbuf, timeout) == -1) {
                        DEBUG(0,("message_send_pid_internal: failed to get chainlock "
                                 "with timeout %ul.\n", timeout));
                        SAFE_FREE(dbuf.dptr);
                        return NT_STATUS_IO_TIMEOUT;
                }
        } else {
                if (tdb_chainlock(tdb, kbuf) == -1) {
                        DEBUG(0,("message_send_pid_internal: failed to get "
                                 "chainlock.\n"));
                        SAFE_FREE(dbuf.dptr);
                        return NT_STATUS_LOCK_NOT_GRANTED;
                }
        }       

        old_dbuf = tdb_fetch(tdb, kbuf);

        if (!old_dbuf.dptr) {
                /* its a new record */

                tdb_store(tdb, kbuf, dbuf, TDB_REPLACE);
                tdb_chainunlock(tdb, kbuf);

                SAFE_FREE(dbuf.dptr);
                errno = 0;                    /* paranoia */
                return message_notify(pid);
        }

        /* Not a new record. Check for duplicates. */

        for(ptr = (char *)old_dbuf.dptr; ptr < old_dbuf.dptr + old_dbuf.dsize; ) {
                /*
                 * First check if the message header matches, then, if it's a non-zero
                 * sized message, check if the data matches. If so it's a duplicate and
                 * we can discard it. JRA.
                 */

                if (!memcmp(ptr, &rec, sizeof(rec))) {
                        if (!len || (len && !memcmp( ptr + sizeof(rec), buf, len))) {
                                tdb_chainunlock(tdb, kbuf);
                                DEBUG(10,("message_send_pid_internal: discarding "
                                          "duplicate message.\n"));
                                SAFE_FREE(dbuf.dptr);
                                SAFE_FREE(old_dbuf.dptr);
                                return NT_STATUS_OK;
                        }
                }
                memcpy(&prec, ptr, sizeof(prec));
                ptr += sizeof(rec) + prec.len;
        }

        /* we're adding to an existing entry */

        tdb_append(tdb, kbuf, dbuf);
        tdb_chainunlock(tdb, kbuf);

        SAFE_FREE(old_dbuf.dptr);
        SAFE_FREE(dbuf.dptr);

        errno = 0;                    /* paranoia */
        return message_notify(pid);
}

NTSTATUS message_send_pid	(	struct process_id	pid,
		int	msg_type,
		const void *	buf,
		size_t	len,
		BOOL	duplicates_allowed
	)

messages.c の 372 行で定義されています。

参照先 message_send_pid_internal().

参照元 _srv_net_sess_del()・child_msg_onlinestatus()・cli_send_mailslot()・debug_message_send()・debuglevel_message()・fork_child_dc_connect()・main()・msg_pool_usage()・notify_deferred_opens()・ping_message()・print_queue_update()・process_kernel_oplocks()・process_oplock_break_message()・release_level_2_oplocks_on_change()・rename_share_filename()・reply_to_oplock_break_requests()・reqprofile_message()・send_message()・shutdown_other_smbds()・srv_spoolss_drv_upgrade_printer()・srv_spoolss_reset_printerdata()・traverse_fn()・winbind_msg_offline()・winbind_msg_online()・winbind_msg_onlinestatus().

{
        return message_send_pid_internal(pid, msg_type, buf, len,
                                         duplicates_allowed, 0);
}

NTSTATUS message_send_pid_with_timeout	(	struct process_id	pid,
		int	msg_type,
		const void *	buf,
		size_t	len,
		BOOL	duplicates_allowed,
		unsigned int	timeout
	)

messages.c の 383 行で定義されています。

参照先 message_send_pid_internal().

{
        return message_send_pid_internal(pid, msg_type, buf, len, duplicates_allowed,
                                         timeout);
}

unsigned int messages_pending_for_pid

(

struct process_id

pid

)

messages.c の 395 行で定義されています。

参照先 buf・TDB_DATA::dptr・TDB_DATA::dsize・message_key_pid()・tdb・tdb_fetch().

{
        TDB_DATA kbuf;
        TDB_DATA dbuf;
        char *buf;
        unsigned int message_count = 0;

        kbuf = message_key_pid(pid);

        dbuf = tdb_fetch(tdb, kbuf);
        if (dbuf.dptr == NULL || dbuf.dsize == 0) {
                SAFE_FREE(dbuf.dptr);
                return 0;
        }

        for (buf = dbuf.dptr; dbuf.dsize > sizeof(struct message_rec);) {
                struct message_rec rec;
                memcpy(&rec, buf, sizeof(rec));
                buf += (sizeof(rec) + rec.len);
                dbuf.dsize -= (sizeof(rec) + rec.len);
                message_count++;
        }

        SAFE_FREE(dbuf.dptr);
        return message_count;
}

static BOOL retrieve_all_messages	(	char **	msgs_buf,
		size_t *	total_len
	)			[static]

messages.c の 426 行で定義されています。

参照先 TDB_DATA::dptr・TDB_DATA::dsize・message_key_pid()・pid_to_procid()・sys_getpid()・tdb・tdb_chainlock()・tdb_chainunlock()・tdb_fetch()・tdb_store().

参照元 message_dispatch().

{
        TDB_DATA kbuf;
        TDB_DATA dbuf;
        TDB_DATA null_dbuf;

        ZERO_STRUCT(null_dbuf);

        *msgs_buf = NULL;
        *total_len = 0;

        kbuf = message_key_pid(pid_to_procid(sys_getpid()));

        if (tdb_chainlock(tdb, kbuf) == -1)
                return False;

        dbuf = tdb_fetch(tdb, kbuf);
        /*
         * Replace with an empty record to keep the allocated
         * space in the tdb.
         */
        tdb_store(tdb, kbuf, null_dbuf, TDB_REPLACE);
        tdb_chainunlock(tdb, kbuf);

        if (dbuf.dptr == NULL || dbuf.dsize == 0) {
                SAFE_FREE(dbuf.dptr);
                return False;
        }

        *msgs_buf = dbuf.dptr;
        *total_len = dbuf.dsize;

        return True;
}

static BOOL message_recv	(	char *	msgs_buf,
		size_t	total_len,
		int *	msg_type,
		struct process_id *	src,
		char **	buf,
		size_t *	len
	)			[static]

messages.c の 465 行で定義されています。

参照先 message_rec::src.

参照元 message_dispatch().

{
        struct message_rec rec;
        char *ret_buf = *buf;

        *buf = NULL;
        *len = 0;

        if (total_len - (ret_buf - msgs_buf) < sizeof(rec))
                return False;

        memcpy(&rec, ret_buf, sizeof(rec));
        ret_buf += sizeof(rec);

        if (rec.msg_version != MESSAGE_VERSION) {
                DEBUG(0,("message version %d received (expected %d)\n", rec.msg_version, MESSAGE_VERSION));
                return False;
        }

        if (rec.len > 0) {
                if (total_len - (ret_buf - msgs_buf) < rec.len)
                        return False;
        }

        *len = rec.len;
        *msg_type = rec.msg_type;
        *src = rec.src;
        *buf = ret_buf;

        return True;
}

void message_dispatch

(

void

)

messages.c の 505 行で定義されています。

参照先 buf・dispatch_fns::fn・len・message_recv()・dispatch_fns::msg_type・message_rec::msg_type・dispatch_fns::next・dispatch_fns::private_data・procid_to_pid()・received_signal・retrieve_all_messages()・sys_getpid().

参照元 main()・open_sockets_smbd()・process()・process_loop()・receive_message_or_smb()・start_background_queue()・wait_replies().

{
        int msg_type;
        struct process_id src;
        char *buf;
        char *msgs_buf;
        size_t len, total_len;
        int n_handled;

        if (!received_signal)
                return;

        DEBUG(10,("message_dispatch: received_signal = %d\n", received_signal));

        received_signal = 0;

        if (!retrieve_all_messages(&msgs_buf, &total_len))
                return;

        for (buf = msgs_buf; message_recv(msgs_buf, total_len, &msg_type, &src, &buf, &len); buf += len) {
                struct dispatch_fns *dfn;

                DEBUG(10,("message_dispatch: received msg_type=%d "
                          "src_pid=%u\n", msg_type,
                          (unsigned int) procid_to_pid(&src)));

                n_handled = 0;
                for (dfn = dispatch_fns; dfn; dfn = dfn->next) {
                        if (dfn->msg_type == msg_type) {
                                DEBUG(10,("message_dispatch: processing message of type %d.\n", msg_type));
                                dfn->fn(msg_type, src,
                                        len ? (void *)buf : NULL, len,
                                        dfn->private_data);
                                n_handled++;
                                break;
                        }
                }
                if (!n_handled) {
                        DEBUG(5,("message_dispatch: warning: no handler registed for "
                                 "msg_type %d in pid %u\n",
                                 msg_type, (unsigned int)sys_getpid()));
                }
        }
        SAFE_FREE(msgs_buf);
}

void message_register	(	int	msg_type,
		void(*)(int msg_type, struct process_id pid, void *buf, size_t len, void *private_data)	fn,
		void *	private_data
	)

messages.c の 558 行で定義されています。

参照先 dispatch_fns::fn・dispatch_fns::msg_type・dispatch_fns::next.

参照元 blocking_lock_cancel()・debug_init()・do_debuglevel()・do_ping()・do_poolusage()・do_profilelevel()・do_winbind_onlinestatus()・fork_child_dc_connect()・fork_domain_child()・init_oplocks()・main()・message_init()・messaging_register()・nt_printing_init()・open_sockets_smbd()・profile_setup()・push_blocking_lock_request()・register_dmalloc_msgs()・register_msg_pool_usage()・srv_spoolss_replyopenprinter()・start_background_queue().

{
        struct dispatch_fns *dfn;

        for (dfn = dispatch_fns; dfn; dfn = dfn->next) {
                if (dfn->msg_type == msg_type) {
                        dfn->fn = fn;
                        return;
                }
        }

        dfn = SMB_MALLOC_P(struct dispatch_fns);

        if (dfn != NULL) {

                ZERO_STRUCTPN(dfn);

                dfn->msg_type = msg_type;
                dfn->fn = fn;
                dfn->private_data = private_data;

                DLIST_ADD(dispatch_fns, dfn);
        }
        else {
        
                DEBUG(0,("message_register: Not enough memory. malloc failed!\n"));
        }
}

void message_deregister

(

int

msg_type

)

messages.c の 595 行で定義されています。

参照先 dispatch_fns::msg_type・dispatch_fns::next.

参照元 do_debuglevel()・do_ping()・do_poolusage()・do_profilelevel()・do_winbind_onlinestatus()・fork_domain_child()・messaging_context_destructor()・set_domain_online()・srv_spoolss_replycloseprinter().

{
        struct dispatch_fns *dfn, *next;

        for (dfn = dispatch_fns; dfn; dfn = next) {
                next = dfn->next;
                if (dfn->msg_type == msg_type) {
                        DLIST_REMOVE(dispatch_fns, dfn);
                        SAFE_FREE(dfn);
                        return;
                }
        }       
}

static int traverse_fn	(	TDB_CONTEXT *	the_tdb,
		TDB_DATA	kbuf,
		TDB_DATA	dbuf,
		void *	state
	)			[static]

messages.c の 622 行で定義されています。

参照先 msg_all::buf・TDB_DATA::dptr・TDB_DATA::dsize・msg_all::duplicates・msg_all::len・message_send_pid()・msg_all::msg_flag・msg_all::msg_type・msg_all::n_sent・procid_str_static()・status・tdb_delete().

参照元 brl_forall()・clear_unexpected()・dump_tdb()・dump_wins_subnet_namelist()・info_tdb()・main()・message_send_all()・share_mode_forall()・wcache_invalidate_cache().

{
        struct connections_data crec;
        struct msg_all *msg_all = (struct msg_all *)state;
        NTSTATUS status;

        if (dbuf.dsize != sizeof(crec))
                return 0;

        memcpy(&crec, dbuf.dptr, sizeof(crec));

        if (crec.cnum != -1)
                return 0;

        /* Don't send if the receiver hasn't registered an interest. */

        if(!(crec.bcast_msg_flags & msg_all->msg_flag))
                return 0;

        /* If the msg send fails because the pid was not found (i.e. smbd died), 
         * the msg has already been deleted from the messages.tdb.*/

        status = message_send_pid(crec.pid, msg_all->msg_type,
                                  msg_all->buf, msg_all->len,
                                  msg_all->duplicates);

        if (NT_STATUS_EQUAL(status, NT_STATUS_INVALID_HANDLE)) {
                
                /* If the pid was not found delete the entry from connections.tdb */

                DEBUG(2,("pid %s doesn't exist - deleting connections %d [%s]\n",
                         procid_str_static(&crec.pid), crec.cnum, crec.servicename));
                tdb_delete(the_tdb, kbuf);
        }
        msg_all->n_sent++;
        return 0;
}

BOOL message_send_all	(	TDB_CONTEXT *	conn_tdb,
		int	msg_type,
		const void *	buf,
		size_t	len,
		BOOL	duplicates_allowed,
		int *	n_sent
	)

Send a message to all smbd processes.

It isn't very efficient, but should be OK for the sorts of applications that use it. When we need efficient broadcast we can add it.

引数:

n_sent

Set to the number of messages sent. This should be equal to the number of processes, but be careful for races.

戻り値:

True

for success.

messages.c の 672 行で定義されています。

参照先 msg_all::buf・msg_all::duplicates・msg_all::len・msg_all::msg_flag・msg_all::msg_type・msg_all::n_sent・tdb_traverse()・traverse_fn().

参照元 _srv_net_share_add()・_srv_net_share_del()・_srv_net_share_set_info()・add_printer_hook()・api_RNetShareAdd()・delete_printer_hook()・send_message()・send_repl_message()・send_stat_cache_delete_message()・send_sync_message().

{
        struct msg_all msg_all;

        msg_all.msg_type = msg_type;
        if (msg_type < 1000)
                msg_all.msg_flag = FLAG_MSG_GENERAL;
        else if (msg_type > 1000 && msg_type < 2000)
                msg_all.msg_flag = FLAG_MSG_NMBD;
        else if (msg_type > 2000 && msg_type < 2100)
                msg_all.msg_flag = FLAG_MSG_PRINT_NOTIFY;
        else if (msg_type > 2100 && msg_type < 3000)
                msg_all.msg_flag = FLAG_MSG_PRINT_GENERAL;
        else if (msg_type > 3000 && msg_type < 4000)
                msg_all.msg_flag = FLAG_MSG_SMBD;
        else
                return False;

        msg_all.buf = buf;
        msg_all.len = len;
        msg_all.duplicates = duplicates_allowed;
        msg_all.n_sent = 0;

        tdb_traverse(conn_tdb, traverse_fn, &msg_all);
        if (n_sent)
                *n_sent = msg_all.n_sent;
        return True;
}

void message_block

(

void

)

messages.c の 709 行で定義されています。

参照先 BlockSignals().

参照元 fork_child_dc_connect()・fork_domain_child().

{
        BlockSignals(True, SIGUSR1);
}

void message_unblock

(

void

)

messages.c の 714 行で定義されています。

参照先 BlockSignals().

参照元 fork_child_dc_connect()・fork_domain_child().

{
        BlockSignals(False, SIGUSR1);
}

static int messaging_context_destructor

(

struct messaging_context *

ctx

)

[static]

messages.c の 738 行で定義されています。

参照先 ctx・message_deregister()・messaging_callback::msg_type・messaging_callback::next.

参照元 messaging_init().

{
        struct messaging_callback *cb;

        for (cb = ctx->callbacks; cb; cb = cb->next) {
                /*
                 * We unconditionally remove all instances of our callback
                 * from the tdb basis.
                 */
                message_deregister(cb->msg_type);
        }
        return 0;
}

struct messaging_context* messaging_init	(	TALLOC_CTX *	mem_ctx,
		struct server_id	server_id,
		struct event_context *	ev
	)

messages.c の 752 行で定義されています。

参照先 ctx・messaging_context_destructor().

参照元 smbd_messaging_context().

{
        struct messaging_context *ctx;

        if (!(ctx = TALLOC_ZERO_P(mem_ctx, struct messaging_context))) {
                return NULL;
        }

        ctx->id = server_id;
        talloc_set_destructor(ctx, messaging_context_destructor);
        return ctx;
}

static void messaging_callback	(	int	msg_type,
		struct process_id	pid,
		void *	buf,
		size_t	len,
		void *	private_data
	)			[static]

messages.c の 767 行で定義されています。

参照先 ctx・data_blob_::data・messaging_callback::fn・id・data_blob_::length・messaging_callback::msg_type・messaging_callback::next・messaging_callback::private_data.

{
        struct messaging_context *ctx = talloc_get_type_abort(
                private_data, struct messaging_context);
        struct messaging_callback *cb, *next;

        for (cb = ctx->callbacks; cb; cb = next) {
                /*
                 * Allow a callback to remove itself
                 */
                next = cb->next;

                if (msg_type == cb->msg_type) {
                        DATA_BLOB blob;
                        struct server_id id;

                        blob.data = (uint8 *)buf;
                        blob.length = len;
                        id.id = pid;

                        cb->fn(ctx, cb->private_data, msg_type, id, &blob);
                }
        }
}

NTSTATUS messaging_register	(	struct messaging_context *	ctx,
		void *	private_data,
		uint32_t	msg_type,
		void(*)(struct messaging_context *msg, void *private_data, uint32_t msg_type, struct server_id server_id, DATA_BLOB *data)	fn
	)

messages.c の 797 行で定義されています。

参照先 ctx・messaging_callback::fn・message_register()・messaging_callback::msg_type・messaging_callback::private_data.

参照元 notify_init().

{
        struct messaging_callback *cb;

        if (!(cb = talloc(ctx, struct messaging_callback))) {
                return NT_STATUS_NO_MEMORY;
        }

        cb->msg_type = msg_type;
        cb->fn = fn;
        cb->private_data = private_data;

        DLIST_ADD(ctx->callbacks, cb);
        message_register(msg_type, messaging_callback, ctx);
        return NT_STATUS_OK;
}

void messaging_deregister	(	struct messaging_context *	ctx,
		uint32_t	msg_type,
		void *	private_data
	)

messages.c の 823 行で定義されています。

参照先 ctx・messaging_callback::msg_type・messaging_callback::next・messaging_callback::private_data.

参照元 notify_destructor().

{
        struct messaging_callback *cb, *next;

        for (cb = ctx->callbacks; cb; cb = next) {
                next = cb->next;
                if ((cb->msg_type == msg_type)
                    && (cb->private_data == private_data)) {
                        DLIST_REMOVE(ctx->callbacks, cb);
                        TALLOC_FREE(cb);
                }
        }
}

NTSTATUS messaging_send	(	struct messaging_context *	msg,
		struct server_id	server,
		uint32_t	msg_type,
		DATA_BLOB *	data
	)

messages.c の 841 行で定義されています。

参照先 data_blob_::data・data_blob_::length・message_send_pid_internal()・server.

参照元 notify_send().

{
        return message_send_pid_internal(server.id, msg_type, data->data,
                                         data->length, True, 0);
}

---

変数

TDB_CONTEXT* tdb [static]

messages.c の 51 行で定義されています。

int received_signal [static]

messages.c の 52 行で定義されています。

参照元 message_dispatch()・sig_usr1().

---