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
)) {
119 /* If the pid was not found delete the entry from connections.tdb */
121 DEBUG(2, ("pid %s doesn't exist\n", procid_str_static(id
)));
123 rec
->delete_rec(rec
);
130 * Send a message to all smbd processes.
132 * It isn't very efficient, but should be OK for the sorts of
133 * applications that use it. When we need efficient broadcast we can add
136 * @param n_sent Set to the number of messages sent. This should be
137 * equal to the number of processes, but be careful for races.
139 * @retval True for success.
141 bool message_send_all(struct messaging_context
*msg_ctx
,
143 const void *buf
, size_t len
,
146 struct msg_all msg_all
;
148 msg_all
.msg_type
= msg_type
;
149 if (msg_type
< 0x100) {
150 msg_all
.msg_flag
= FLAG_MSG_GENERAL
;
151 } else if (msg_type
> 0x100 && msg_type
< 0x200) {
152 msg_all
.msg_flag
= FLAG_MSG_NMBD
;
153 } else if (msg_type
> 0x200 && msg_type
< 0x300) {
154 msg_all
.msg_flag
= FLAG_MSG_PRINT_GENERAL
;
155 } else if (msg_type
> 0x300 && msg_type
< 0x400) {
156 msg_all
.msg_flag
= FLAG_MSG_SMBD
;
157 } else if (msg_type
> 0x400 && msg_type
< 0x600) {
158 msg_all
.msg_flag
= FLAG_MSG_WINBIND
;
159 } else if (msg_type
> 4000 && msg_type
< 5000) {
160 msg_all
.msg_flag
= FLAG_MSG_DBWRAP
;
168 msg_all
.msg_ctx
= msg_ctx
;
170 serverid_traverse(traverse_fn
, &msg_all
);
172 *n_sent
= msg_all
.n_sent
;
176 struct event_context
*messaging_event_context(struct messaging_context
*msg_ctx
)
178 return msg_ctx
->event_ctx
;
181 struct messaging_context
*messaging_init(TALLOC_CTX
*mem_ctx
,
182 struct server_id server_id
,
183 struct event_context
*ev
)
185 struct messaging_context
*ctx
;
188 if (!(ctx
= talloc_zero(mem_ctx
, struct messaging_context
))) {
195 status
= messaging_tdb_init(ctx
, ctx
, &ctx
->local
);
197 if (!NT_STATUS_IS_OK(status
)) {
198 DEBUG(2, ("messaging_tdb_init failed: %s\n",
204 #ifdef CLUSTER_SUPPORT
205 if (lp_clustering()) {
206 status
= messaging_ctdbd_init(ctx
, ctx
, &ctx
->remote
);
208 if (!NT_STATUS_IS_OK(status
)) {
209 DEBUG(2, ("messaging_ctdbd_init failed: %s\n",
215 ctx
->id
.vnn
= get_my_vnn();
218 messaging_register(ctx
, NULL
, MSG_PING
, ping_message
);
220 /* Register some debugging related messages */
222 register_msg_pool_usage(ctx
);
223 register_dmalloc_msgs(ctx
);
224 debug_register_msgs(ctx
);
229 struct server_id
messaging_server_id(const struct messaging_context
*msg_ctx
)
235 * re-init after a fork
237 NTSTATUS
messaging_reinit(struct messaging_context
*msg_ctx
,
242 TALLOC_FREE(msg_ctx
->local
);
246 status
= messaging_tdb_init(msg_ctx
, msg_ctx
, &msg_ctx
->local
);
247 if (!NT_STATUS_IS_OK(status
)) {
248 DEBUG(0, ("messaging_tdb_init failed: %s\n",
253 #ifdef CLUSTER_SUPPORT
254 TALLOC_FREE(msg_ctx
->remote
);
256 if (lp_clustering()) {
257 status
= messaging_ctdbd_init(msg_ctx
, msg_ctx
,
260 if (!NT_STATUS_IS_OK(status
)) {
261 DEBUG(1, ("messaging_ctdbd_init failed: %s\n",
274 * Register a dispatch function for a particular message type. Allow multiple
277 NTSTATUS
messaging_register(struct messaging_context
*msg_ctx
,
280 void (*fn
)(struct messaging_context
*msg
,
283 struct server_id server_id
,
286 struct messaging_callback
*cb
;
289 * Only one callback per type
292 for (cb
= msg_ctx
->callbacks
; cb
!= NULL
; cb
= cb
->next
) {
293 /* we allow a second registration of the same message
294 type if it has a different private pointer. This is
295 needed in, for example, the internal notify code,
296 which creates a new notify context for each tree
297 connect, and expects to receive messages to each of
299 if (cb
->msg_type
== msg_type
&& private_data
== cb
->private_data
) {
300 DEBUG(5,("Overriding messaging pointer for type %u - private_data=%p\n",
301 (unsigned)msg_type
, private_data
));
303 cb
->private_data
= private_data
;
308 if (!(cb
= talloc(msg_ctx
, struct messaging_callback
))) {
309 return NT_STATUS_NO_MEMORY
;
312 cb
->msg_type
= msg_type
;
314 cb
->private_data
= private_data
;
316 DLIST_ADD(msg_ctx
->callbacks
, cb
);
321 De-register the function for a particular message type.
323 void messaging_deregister(struct messaging_context
*ctx
, uint32_t msg_type
,
326 struct messaging_callback
*cb
, *next
;
328 for (cb
= ctx
->callbacks
; cb
; cb
= next
) {
330 if ((cb
->msg_type
== msg_type
)
331 && (cb
->private_data
== private_data
)) {
332 DEBUG(5,("Deregistering messaging pointer for type %u - private_data=%p\n",
333 (unsigned)msg_type
, private_data
));
334 DLIST_REMOVE(ctx
->callbacks
, cb
);
341 Send a message to a particular server
343 NTSTATUS
messaging_send(struct messaging_context
*msg_ctx
,
344 struct server_id server
, uint32_t msg_type
,
345 const DATA_BLOB
*data
)
347 #ifdef CLUSTER_SUPPORT
348 if (!procid_is_local(&server
)) {
349 return msg_ctx
->remote
->send_fn(msg_ctx
, server
,
354 return msg_ctx
->local
->send_fn(msg_ctx
, server
, msg_type
, data
,
358 NTSTATUS
messaging_send_buf(struct messaging_context
*msg_ctx
,
359 struct server_id server
, uint32_t msg_type
,
360 const uint8
*buf
, size_t len
)
362 DATA_BLOB blob
= data_blob_const(buf
, len
);
363 return messaging_send(msg_ctx
, server
, msg_type
, &blob
);
367 Dispatch one messaging_rec
369 void messaging_dispatch_rec(struct messaging_context
*msg_ctx
,
370 struct messaging_rec
*rec
)
372 struct messaging_callback
*cb
, *next
;
374 for (cb
= msg_ctx
->callbacks
; cb
!= NULL
; cb
= next
) {
376 if (cb
->msg_type
== rec
->msg_type
) {
377 cb
->fn(msg_ctx
, cb
->private_data
, rec
->msg_type
,
378 rec
->src
, &rec
->buf
);
379 /* we continue looking for matching messages
380 after finding one. This matters for
381 subsystems like the internal notify code
382 which register more than one handler for
383 the same message type */