RIP BOOL. Convert BOOL -> bool. I found a few interesting
[nivanova/samba-autobuild/.git] / source3 / lib / messages.c
1 /* 
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
8    
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.
13    
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.
18    
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/>.
21 */
22
23 /**
24   @defgroup messages Internal messaging framework
25   @{
26   @file messages.c
27   
28   @brief  Module for internal messaging between Samba daemons. 
29
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
33    that process.
34
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
37    simple example.
38
39    @caution Dispatch functions must be able to cope with incoming
40    messages on an *odd* byte boundary.
41
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
44    quick succession.
45
46 */
47
48 #include "includes.h"
49 #include "librpc/gen_ndr/messaging.h"
50 #include "librpc/gen_ndr/ndr_messaging.h"
51
52 struct messaging_callback {
53         struct messaging_callback *prev, *next;
54         uint32 msg_type;
55         void (*fn)(struct messaging_context *msg, void *private_data, 
56                    uint32_t msg_type, 
57                    struct server_id server_id, DATA_BLOB *data);
58         void *private_data;
59 };
60
61 /****************************************************************************
62  A useful function for testing the message system.
63 ****************************************************************************/
64
65 static void ping_message(struct messaging_context *msg_ctx,
66                          void *private_data,
67                          uint32_t msg_type,
68                          struct server_id src,
69                          DATA_BLOB *data)
70 {
71         const char *msg = data->data ? (const char *)data->data : "none";
72
73         DEBUG(1,("INFO: Received PING message from PID %s [%s]\n",
74                  procid_str_static(&src), msg));
75         messaging_send(msg_ctx, src, MSG_PONG, data);
76 }
77
78 /****************************************************************************
79  Register/replace a dispatch function for a particular message type.
80  JRA changed Dec 13 2006. Only one message handler now permitted per type.
81  *NOTE*: Dispatch functions must be able to cope with incoming
82  messages on an *odd* byte boundary.
83 ****************************************************************************/
84
85 struct msg_all {
86         struct messaging_context *msg_ctx;
87         int msg_type;
88         uint32 msg_flag;
89         const void *buf;
90         size_t len;
91         int n_sent;
92 };
93
94 /****************************************************************************
95  Send one of the messages for the broadcast.
96 ****************************************************************************/
97
98 static int traverse_fn(struct db_record *rec,
99                        const struct connections_key *ckey,
100                        const struct connections_data *crec,
101                        void *state)
102 {
103         struct msg_all *msg_all = (struct msg_all *)state;
104         NTSTATUS status;
105
106         if (crec->cnum != -1)
107                 return 0;
108
109         /* Don't send if the receiver hasn't registered an interest. */
110
111         if(!(crec->bcast_msg_flags & msg_all->msg_flag))
112                 return 0;
113
114         /* If the msg send fails because the pid was not found (i.e. smbd died), 
115          * the msg has already been deleted from the messages.tdb.*/
116
117         status = messaging_send_buf(msg_all->msg_ctx,
118                                     crec->pid, msg_all->msg_type,
119                                     (uint8 *)msg_all->buf, msg_all->len);
120
121         if (NT_STATUS_EQUAL(status, NT_STATUS_INVALID_HANDLE)) {
122                 
123                 /* If the pid was not found delete the entry from connections.tdb */
124
125                 DEBUG(2,("pid %s doesn't exist - deleting connections %d [%s]\n",
126                          procid_str_static(&crec->pid), crec->cnum,
127                          crec->servicename));
128
129                 rec->delete_rec(rec);
130         }
131         msg_all->n_sent++;
132         return 0;
133 }
134
135 /**
136  * Send a message to all smbd processes.
137  *
138  * It isn't very efficient, but should be OK for the sorts of
139  * applications that use it. When we need efficient broadcast we can add
140  * it.
141  *
142  * @param n_sent Set to the number of messages sent.  This should be
143  * equal to the number of processes, but be careful for races.
144  *
145  * @retval True for success.
146  **/
147 bool message_send_all(struct messaging_context *msg_ctx,
148                       int msg_type,
149                       const void *buf, size_t len,
150                       int *n_sent)
151 {
152         struct msg_all msg_all;
153
154         msg_all.msg_type = msg_type;
155         if (msg_type < 1000)
156                 msg_all.msg_flag = FLAG_MSG_GENERAL;
157         else if (msg_type > 1000 && msg_type < 2000)
158                 msg_all.msg_flag = FLAG_MSG_NMBD;
159         else if (msg_type > 2000 && msg_type < 2100)
160                 msg_all.msg_flag = FLAG_MSG_PRINT_NOTIFY;
161         else if (msg_type > 2100 && msg_type < 3000)
162                 msg_all.msg_flag = FLAG_MSG_PRINT_GENERAL;
163         else if (msg_type > 3000 && msg_type < 4000)
164                 msg_all.msg_flag = FLAG_MSG_SMBD;
165         else
166                 return False;
167
168         msg_all.buf = buf;
169         msg_all.len = len;
170         msg_all.n_sent = 0;
171         msg_all.msg_ctx = msg_ctx;
172
173         connections_forall(traverse_fn, &msg_all);
174         if (n_sent)
175                 *n_sent = msg_all.n_sent;
176         return True;
177 }
178
179 struct event_context *messaging_event_context(struct messaging_context *msg_ctx)
180 {
181         return msg_ctx->event_ctx;
182 }
183
184 struct messaging_context *messaging_init(TALLOC_CTX *mem_ctx, 
185                                          struct server_id server_id, 
186                                          struct event_context *ev)
187 {
188         struct messaging_context *ctx;
189         NTSTATUS status;
190
191         if (!(ctx = TALLOC_ZERO_P(mem_ctx, struct messaging_context))) {
192                 return NULL;
193         }
194
195         ctx->id = server_id;
196         ctx->event_ctx = ev;
197
198         status = messaging_tdb_init(ctx, ctx, &ctx->local);
199
200         if (!NT_STATUS_IS_OK(status)) {
201                 DEBUG(0, ("messaging_tdb_init failed: %s\n",
202                           nt_errstr(status)));
203                 TALLOC_FREE(ctx);
204                 return NULL;
205         }
206
207 #ifdef CLUSTER_SUPPORT
208         if (lp_clustering()) {
209                 status = messaging_ctdbd_init(ctx, ctx, &ctx->remote);
210
211                 if (!NT_STATUS_IS_OK(status)) {
212                         DEBUG(0, ("messaging_ctdb_init failed: %s\n",
213                                   nt_errstr(status)));
214                         TALLOC_FREE(ctx);
215                         return NULL;
216                 }
217         }
218 #endif
219
220         messaging_register(ctx, NULL, MSG_PING, ping_message);
221
222         /* Register some debugging related messages */
223
224         register_msg_pool_usage(ctx);
225         register_dmalloc_msgs(ctx);
226         debug_register_msgs(ctx);
227
228         return ctx;
229 }
230
231 /*
232  * re-init after a fork
233  */
234 NTSTATUS messaging_reinit(struct messaging_context *msg_ctx)
235 {
236 #ifdef CLUSTER_SUPPORT
237
238         TALLOC_FREE(msg_ctx->remote);
239
240         if (lp_clustering()) {
241                 NTSTATUS status;
242
243                 status = messaging_ctdbd_init(msg_ctx, msg_ctx,
244                                               &msg_ctx->remote);
245
246                 if (!NT_STATUS_IS_OK(status)) {
247                         DEBUG(0, ("messaging_ctdb_init failed: %s\n",
248                                   nt_errstr(status)));
249                         return status;
250                 }
251         }
252
253 #endif
254
255         return NT_STATUS_OK;
256 }
257
258
259 /*
260  * Register a dispatch function for a particular message type. Allow multiple
261  * registrants
262 */
263 NTSTATUS messaging_register(struct messaging_context *msg_ctx,
264                             void *private_data,
265                             uint32_t msg_type,
266                             void (*fn)(struct messaging_context *msg,
267                                        void *private_data, 
268                                        uint32_t msg_type, 
269                                        struct server_id server_id,
270                                        DATA_BLOB *data))
271 {
272         struct messaging_callback *cb;
273
274         /*
275          * Only one callback per type
276          */
277
278         for (cb = msg_ctx->callbacks; cb != NULL; cb = cb->next) {
279                 if (cb->msg_type == msg_type) {
280                         cb->fn = fn;
281                         cb->private_data = private_data;
282                         return NT_STATUS_OK;
283                 }
284         }
285
286         if (!(cb = talloc(msg_ctx, struct messaging_callback))) {
287                 return NT_STATUS_NO_MEMORY;
288         }
289
290         cb->msg_type = msg_type;
291         cb->fn = fn;
292         cb->private_data = private_data;
293
294         DLIST_ADD(msg_ctx->callbacks, cb);
295         return NT_STATUS_OK;
296 }
297
298 /*
299   De-register the function for a particular message type.
300 */
301 void messaging_deregister(struct messaging_context *ctx, uint32_t msg_type,
302                           void *private_data)
303 {
304         struct messaging_callback *cb, *next;
305
306         for (cb = ctx->callbacks; cb; cb = next) {
307                 next = cb->next;
308                 if ((cb->msg_type == msg_type)
309                     && (cb->private_data == private_data)) {
310                         DLIST_REMOVE(ctx->callbacks, cb);
311                         TALLOC_FREE(cb);
312                 }
313         }
314 }
315
316 /*
317   Send a message to a particular server
318 */
319 NTSTATUS messaging_send(struct messaging_context *msg_ctx,
320                         struct server_id server, uint32_t msg_type,
321                         const DATA_BLOB *data)
322 {
323 #ifdef CLUSTER_SUPPORT
324         if (!procid_is_local(&server)) {
325                 return msg_ctx->remote->send_fn(msg_ctx, server,
326                                                 msg_type, data,
327                                                 msg_ctx->remote);
328         }
329 #endif
330         return msg_ctx->local->send_fn(msg_ctx, server, msg_type, data,
331                                        msg_ctx->local);
332 }
333
334 NTSTATUS messaging_send_buf(struct messaging_context *msg_ctx,
335                             struct server_id server, uint32_t msg_type,
336                             const uint8 *buf, size_t len)
337 {
338         DATA_BLOB blob = data_blob_const(buf, len);
339         return messaging_send(msg_ctx, server, msg_type, &blob);
340 }
341
342 /*
343   Dispatch one messsaging_rec
344 */
345 void messaging_dispatch_rec(struct messaging_context *msg_ctx,
346                             struct messaging_rec *rec)
347 {
348         struct messaging_callback *cb, *next;
349
350         for (cb = msg_ctx->callbacks; cb != NULL; cb = next) {
351                 next = cb->next;
352                 if (cb->msg_type == rec->msg_type) {
353                         cb->fn(msg_ctx, cb->private_data, rec->msg_type,
354                                rec->src, &rec->buf);
355                         return;
356                 }
357         }
358         return;
359 }
360
361 /** @} **/