2 Unix SMB/CIFS implementation.
3 Samba internal messaging functions
4 Copyright (C) Andrew Tridgell 2000
5 Copyright (C) 2001 by Martin Pool
6 Copyright (C) 2002 by Jeremy Allison
7 Copyright (C) 2007 by Volker Lendecke
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>.
24 @defgroup messages Internal messaging framework
28 @brief Module for internal messaging between Samba daemons.
30 The idea is that if a part of Samba wants to do communication with
31 another Samba process then it will do a message_register() of a
32 dispatch function, and use message_send_pid() to send messages to
35 The dispatch function is given the pid of the sender, and it can
36 use that to reply by message_send_pid(). See ping_message() for a
39 @caution Dispatch functions must be able to cope with incoming
40 messages on an *odd* byte boundary.
42 This system doesn't have any inherent size limitations but is not
43 very efficient for large messages or when messages are sent in very
49 #include "dbwrap/dbwrap.h"
53 struct messaging_callback
{
54 struct messaging_callback
*prev
, *next
;
56 void (*fn
)(struct messaging_context
*msg
, void *private_data
,
58 struct server_id server_id
, DATA_BLOB
*data
);
62 /****************************************************************************
63 A useful function for testing the message system.
64 ****************************************************************************/
66 static void ping_message(struct messaging_context
*msg_ctx
,
72 const char *msg
= data
->data
? (const char *)data
->data
: "none";
74 DEBUG(1,("INFO: Received PING message from PID %s [%s]\n",
75 procid_str_static(&src
), msg
));
76 messaging_send(msg_ctx
, src
, MSG_PONG
, data
);
79 /****************************************************************************
80 Register/replace a dispatch function for a particular message type.
81 JRA changed Dec 13 2006. Only one message handler now permitted per type.
82 *NOTE*: Dispatch functions must be able to cope with incoming
83 messages on an *odd* byte boundary.
84 ****************************************************************************/
87 struct messaging_context
*msg_ctx
;
95 /****************************************************************************
96 Send one of the messages for the broadcast.
97 ****************************************************************************/
99 static int traverse_fn(struct db_record
*rec
, const struct server_id
*id
,
100 uint32_t msg_flags
, void *state
)
102 struct msg_all
*msg_all
= (struct msg_all
*)state
;
105 /* Don't send if the receiver hasn't registered an interest. */
107 if((msg_flags
& msg_all
->msg_flag
) == 0) {
111 /* If the msg send fails because the pid was not found (i.e. smbd died),
112 * the msg has already been deleted from the messages.tdb.*/
114 status
= messaging_send_buf(msg_all
->msg_ctx
, *id
, msg_all
->msg_type
,
115 (const uint8
*)msg_all
->buf
, msg_all
->len
);
117 if (NT_STATUS_EQUAL(status
, NT_STATUS_INVALID_HANDLE
)) {
120 * If the pid was not found delete the entry from
124 DEBUG(2, ("pid %s doesn't exist\n", procid_str_static(id
)));
126 dbwrap_record_delete(rec
);
133 * Send a message to all smbd processes.
135 * It isn't very efficient, but should be OK for the sorts of
136 * applications that use it. When we need efficient broadcast we can add
139 * @param n_sent Set to the number of messages sent. This should be
140 * equal to the number of processes, but be careful for races.
142 * @retval True for success.
144 bool message_send_all(struct messaging_context
*msg_ctx
,
146 const void *buf
, size_t len
,
149 struct msg_all msg_all
;
151 msg_all
.msg_type
= msg_type
;
152 if (msg_type
< 0x100) {
153 msg_all
.msg_flag
= FLAG_MSG_GENERAL
;
154 } else if (msg_type
> 0x100 && msg_type
< 0x200) {
155 msg_all
.msg_flag
= FLAG_MSG_NMBD
;
156 } else if (msg_type
> 0x200 && msg_type
< 0x300) {
157 msg_all
.msg_flag
= FLAG_MSG_PRINT_GENERAL
;
158 } else if (msg_type
> 0x300 && msg_type
< 0x400) {
159 msg_all
.msg_flag
= FLAG_MSG_SMBD
;
160 } else if (msg_type
> 0x400 && msg_type
< 0x600) {
161 msg_all
.msg_flag
= FLAG_MSG_WINBIND
;
162 } else if (msg_type
> 4000 && msg_type
< 5000) {
163 msg_all
.msg_flag
= FLAG_MSG_DBWRAP
;
171 msg_all
.msg_ctx
= msg_ctx
;
173 serverid_traverse(traverse_fn
, &msg_all
);
175 *n_sent
= msg_all
.n_sent
;
179 struct event_context
*messaging_event_context(struct messaging_context
*msg_ctx
)
181 return msg_ctx
->event_ctx
;
184 struct messaging_context
*messaging_init(TALLOC_CTX
*mem_ctx
,
185 struct event_context
*ev
)
187 struct messaging_context
*ctx
;
190 if (!(ctx
= talloc_zero(mem_ctx
, struct messaging_context
))) {
194 ctx
->id
= procid_self();
197 status
= messaging_tdb_init(ctx
, ctx
, &ctx
->local
);
199 if (!NT_STATUS_IS_OK(status
)) {
200 DEBUG(2, ("messaging_tdb_init failed: %s\n",
206 #ifdef CLUSTER_SUPPORT
207 if (lp_clustering()) {
208 status
= messaging_ctdbd_init(ctx
, ctx
, &ctx
->remote
);
210 if (!NT_STATUS_IS_OK(status
)) {
211 DEBUG(2, ("messaging_ctdbd_init failed: %s\n",
217 ctx
->id
.vnn
= get_my_vnn();
220 messaging_register(ctx
, NULL
, MSG_PING
, ping_message
);
222 /* Register some debugging related messages */
224 register_msg_pool_usage(ctx
);
225 register_dmalloc_msgs(ctx
);
226 debug_register_msgs(ctx
);
231 struct server_id
messaging_server_id(const struct messaging_context
*msg_ctx
)
237 * re-init after a fork
239 NTSTATUS
messaging_reinit(struct messaging_context
*msg_ctx
)
243 TALLOC_FREE(msg_ctx
->local
);
245 msg_ctx
->id
= procid_self();
247 status
= messaging_tdb_init(msg_ctx
, msg_ctx
, &msg_ctx
->local
);
248 if (!NT_STATUS_IS_OK(status
)) {
249 DEBUG(0, ("messaging_tdb_init failed: %s\n",
254 #ifdef CLUSTER_SUPPORT
255 TALLOC_FREE(msg_ctx
->remote
);
257 if (lp_clustering()) {
258 status
= messaging_ctdbd_init(msg_ctx
, msg_ctx
,
261 if (!NT_STATUS_IS_OK(status
)) {
262 DEBUG(1, ("messaging_ctdbd_init failed: %s\n",
275 * Register a dispatch function for a particular message type. Allow multiple
278 NTSTATUS
messaging_register(struct messaging_context
*msg_ctx
,
281 void (*fn
)(struct messaging_context
*msg
,
284 struct server_id server_id
,
287 struct messaging_callback
*cb
;
290 * Only one callback per type
293 for (cb
= msg_ctx
->callbacks
; cb
!= NULL
; cb
= cb
->next
) {
294 /* we allow a second registration of the same message
295 type if it has a different private pointer. This is
296 needed in, for example, the internal notify code,
297 which creates a new notify context for each tree
298 connect, and expects to receive messages to each of
300 if (cb
->msg_type
== msg_type
&& private_data
== cb
->private_data
) {
301 DEBUG(5,("Overriding messaging pointer for type %u - private_data=%p\n",
302 (unsigned)msg_type
, private_data
));
304 cb
->private_data
= private_data
;
309 if (!(cb
= talloc(msg_ctx
, struct messaging_callback
))) {
310 return NT_STATUS_NO_MEMORY
;
313 cb
->msg_type
= msg_type
;
315 cb
->private_data
= private_data
;
317 DLIST_ADD(msg_ctx
->callbacks
, cb
);
322 De-register the function for a particular message type.
324 void messaging_deregister(struct messaging_context
*ctx
, uint32_t msg_type
,
327 struct messaging_callback
*cb
, *next
;
329 for (cb
= ctx
->callbacks
; cb
; cb
= next
) {
331 if ((cb
->msg_type
== msg_type
)
332 && (cb
->private_data
== private_data
)) {
333 DEBUG(5,("Deregistering messaging pointer for type %u - private_data=%p\n",
334 (unsigned)msg_type
, private_data
));
335 DLIST_REMOVE(ctx
->callbacks
, cb
);
342 Send a message to a particular server
344 NTSTATUS
messaging_send(struct messaging_context
*msg_ctx
,
345 struct server_id server
, uint32_t msg_type
,
346 const DATA_BLOB
*data
)
348 #ifdef CLUSTER_SUPPORT
349 if (!procid_is_local(&server
)) {
350 return msg_ctx
->remote
->send_fn(msg_ctx
, server
,
355 return msg_ctx
->local
->send_fn(msg_ctx
, server
, msg_type
, data
,
359 NTSTATUS
messaging_send_buf(struct messaging_context
*msg_ctx
,
360 struct server_id server
, uint32_t msg_type
,
361 const uint8
*buf
, size_t len
)
363 DATA_BLOB blob
= data_blob_const(buf
, len
);
364 return messaging_send(msg_ctx
, server
, msg_type
, &blob
);
368 Dispatch one messaging_rec
370 void messaging_dispatch_rec(struct messaging_context
*msg_ctx
,
371 struct messaging_rec
*rec
)
373 struct messaging_callback
*cb
, *next
;
375 for (cb
= msg_ctx
->callbacks
; cb
!= NULL
; cb
= next
) {
377 if (cb
->msg_type
== rec
->msg_type
) {
378 cb
->fn(msg_ctx
, cb
->private_data
, rec
->msg_type
,
379 rec
->src
, &rec
->buf
);
380 /* we continue looking for matching messages
381 after finding one. This matters for
382 subsystems like the internal notify code
383 which register more than one handler for
384 the same message type */