source: branches/samba-3.5.x/source3/lib/messages.c@ 736

Last change on this file since 736 was 414, checked in by Herwig Bauernfeind, 15 years ago

Samba 3.5.0: Initial import
File size: 10.3 KB
Line 
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
52struct 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
65static 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
85struct 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
98static 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 **/
147bool 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 if (msg_type > 4000 && msg_type < 5000)
166 msg_all.msg_flag = FLAG_MSG_DBWRAP;
167 else
168 return False;
169
170 msg_all.buf = buf;
171 msg_all.len = len;
172 msg_all.n_sent = 0;
173 msg_all.msg_ctx = msg_ctx;
174
175 connections_forall(traverse_fn, &msg_all);
176 if (n_sent)
177 *n_sent = msg_all.n_sent;
178 return True;
179}
180
181struct event_context *messaging_event_context(struct messaging_context *msg_ctx)
182{
183 return msg_ctx->event_ctx;
184}
185
186struct messaging_context *messaging_init(TALLOC_CTX *mem_ctx,
187 struct server_id server_id,
188 struct event_context *ev)
189{
190 struct messaging_context *ctx;
191 NTSTATUS status;
192
193 if (!(ctx = TALLOC_ZERO_P(mem_ctx, struct messaging_context))) {
194 return NULL;
195 }
196
197 ctx->id = server_id;
198 ctx->event_ctx = ev;
199
200 status = messaging_tdb_init(ctx, ctx, &ctx->local);
201
202 if (!NT_STATUS_IS_OK(status)) {
203 DEBUG(0, ("messaging_tdb_init failed: %s\n",
204 nt_errstr(status)));
205 TALLOC_FREE(ctx);
206 return NULL;
207 }
208
209#ifdef CLUSTER_SUPPORT
210 if (lp_clustering()) {
211 status = messaging_ctdbd_init(ctx, ctx, &ctx->remote);
212
213 if (!NT_STATUS_IS_OK(status)) {
214 DEBUG(1, ("messaging_ctdb_init failed: %s\n",
215 nt_errstr(status)));
216 TALLOC_FREE(ctx);
217 return NULL;
218 }
219 }
220#endif
221
222 messaging_register(ctx, NULL, MSG_PING, ping_message);
223
224 /* Register some debugging related messages */
225
226 register_msg_pool_usage(ctx);
227 register_dmalloc_msgs(ctx);
228 debug_register_msgs(ctx);
229
230 return ctx;
231}
232
233/*
234 * re-init after a fork
235 */
236NTSTATUS messaging_reinit(struct messaging_context *msg_ctx)
237{
238 NTSTATUS status;
239
240 TALLOC_FREE(msg_ctx->local);
241
242 status = messaging_tdb_init(msg_ctx, msg_ctx, &msg_ctx->local);
243 if (!NT_STATUS_IS_OK(status)) {
244 DEBUG(0, ("messaging_tdb_init failed: %s\n",
245 nt_errstr(status)));
246 return status;
247 }
248
249#ifdef CLUSTER_SUPPORT
250 TALLOC_FREE(msg_ctx->remote);
251
252 if (lp_clustering()) {
253 status = messaging_ctdbd_init(msg_ctx, msg_ctx,
254 &msg_ctx->remote);
255
256 if (!NT_STATUS_IS_OK(status)) {
257 DEBUG(1, ("messaging_ctdb_init failed: %s\n",
258 nt_errstr(status)));
259 return status;
260 }
261 }
262
263#endif
264
265 return NT_STATUS_OK;
266}
267
268
269/*
270 * Register a dispatch function for a particular message type. Allow multiple
271 * registrants
272*/
273NTSTATUS messaging_register(struct messaging_context *msg_ctx,
274 void *private_data,
275 uint32_t msg_type,
276 void (*fn)(struct messaging_context *msg,
277 void *private_data,
278 uint32_t msg_type,
279 struct server_id server_id,
280 DATA_BLOB *data))
281{
282 struct messaging_callback *cb;
283
284 /*
285 * Only one callback per type
286 */
287
288 for (cb = msg_ctx->callbacks; cb != NULL; cb = cb->next) {
289 /* we allow a second registration of the same message
290 type if it has a different private pointer. This is
291 needed in, for example, the internal notify code,
292 which creates a new notify context for each tree
293 connect, and expects to receive messages to each of
294 them. */
295 if (cb->msg_type == msg_type && private_data == cb->private_data) {
296 DEBUG(5,("Overriding messaging pointer for type %u - private_data=%p\n",
297 (unsigned)msg_type, private_data));
298 cb->fn = fn;
299 cb->private_data = private_data;
300 return NT_STATUS_OK;
301 }
302 }
303
304 if (!(cb = talloc(msg_ctx, struct messaging_callback))) {
305 return NT_STATUS_NO_MEMORY;
306 }
307
308 cb->msg_type = msg_type;
309 cb->fn = fn;
310 cb->private_data = private_data;
311
312 DLIST_ADD(msg_ctx->callbacks, cb);
313 return NT_STATUS_OK;
314}
315
316/*
317 De-register the function for a particular message type.
318*/
319void messaging_deregister(struct messaging_context *ctx, uint32_t msg_type,
320 void *private_data)
321{
322 struct messaging_callback *cb, *next;
323
324 for (cb = ctx->callbacks; cb; cb = next) {
325 next = cb->next;
326 if ((cb->msg_type == msg_type)
327 && (cb->private_data == private_data)) {
328 DEBUG(5,("Deregistering messaging pointer for type %u - private_data=%p\n",
329 (unsigned)msg_type, private_data));
330 DLIST_REMOVE(ctx->callbacks, cb);
331 TALLOC_FREE(cb);
332 }
333 }
334}
335
336/*
337 Send a message to a particular server
338*/
339NTSTATUS messaging_send(struct messaging_context *msg_ctx,
340 struct server_id server, uint32_t msg_type,
341 const DATA_BLOB *data)
342{
343#ifdef CLUSTER_SUPPORT
344 if (!procid_is_local(&server)) {
345 return msg_ctx->remote->send_fn(msg_ctx, server,
346 msg_type, data,
347 msg_ctx->remote);
348 }
349#endif
350 return msg_ctx->local->send_fn(msg_ctx, server, msg_type, data,
351 msg_ctx->local);
352}
353
354NTSTATUS messaging_send_buf(struct messaging_context *msg_ctx,
355 struct server_id server, uint32_t msg_type,
356 const uint8 *buf, size_t len)
357{
358 DATA_BLOB blob = data_blob_const(buf, len);
359 return messaging_send(msg_ctx, server, msg_type, &blob);
360}
361
362/*
363 Dispatch one messsaging_rec
364*/
365void messaging_dispatch_rec(struct messaging_context *msg_ctx,
366 struct messaging_rec *rec)
367{
368 struct messaging_callback *cb, *next;
369
370 for (cb = msg_ctx->callbacks; cb != NULL; cb = next) {
371 next = cb->next;
372 if (cb->msg_type == rec->msg_type) {
373 cb->fn(msg_ctx, cb->private_data, rec->msg_type,
374 rec->src, &rec->buf);
375 /* we continue looking for matching messages
376 after finding one. This matters for
377 subsystems like the internal notify code
378 which register more than one handler for
379 the same message type */
380 }
381 }
382 return;
383}
384
385/** @} **/
Note: See TracBrowser for help on using the repository browser.