r23344: Better error message
[sfrench/samba-autobuild/.git] / source / lib / messages_local.c
1 /* 
2    Unix SMB/CIFS implementation.
3    Samba internal messaging functions
4    Copyright (C) 2007 by Volker Lendecke
5    
6    This program is free software; you can redistribute it and/or modify
7    it under the terms of the GNU General Public License as published by
8    the Free Software Foundation; either version 2 of the License, or
9    (at your option) any later version.
10    
11    This program is distributed in the hope that it will be useful,
12    but WITHOUT ANY WARRANTY; without even the implied warranty of
13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14    GNU General Public License for more details.
15    
16    You should have received a copy of the GNU General Public License
17    along with this program; if not, write to the Free Software
18    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19 */
20
21 /**
22   @defgroup messages Internal messaging framework
23   @{
24   @file messages.c
25   
26   @brief  Module for internal messaging between Samba daemons. 
27
28    The idea is that if a part of Samba wants to do communication with
29    another Samba process then it will do a message_register() of a
30    dispatch function, and use message_send_pid() to send messages to
31    that process.
32
33    The dispatch function is given the pid of the sender, and it can
34    use that to reply by message_send_pid().  See ping_message() for a
35    simple example.
36
37    @caution Dispatch functions must be able to cope with incoming
38    messages on an *odd* byte boundary.
39
40    This system doesn't have any inherent size limitations but is not
41    very efficient for large messages or when messages are sent in very
42    quick succession.
43
44 */
45
46 #include "includes.h"
47 #include "librpc/gen_ndr/messaging.h"
48 #include "librpc/gen_ndr/ndr_messaging.h"
49
50 /* the locking database handle */
51 static int received_signal;
52
53 static NTSTATUS messaging_tdb_send(struct messaging_context *msg_ctx,
54                                    struct server_id pid, int msg_type,
55                                    const DATA_BLOB *data,
56                                    struct messaging_backend *backend);
57
58 /****************************************************************************
59  Notifications come in as signals.
60 ****************************************************************************/
61
62 static void sig_usr1(void)
63 {
64         received_signal = 1;
65         sys_select_signal(SIGUSR1);
66 }
67
68 static int messaging_tdb_destructor(struct messaging_backend *tdb_ctx)
69 {
70         TDB_CONTEXT *tdb = (TDB_CONTEXT *)tdb_ctx->private_data;
71         tdb_close(tdb);
72         return 0;
73 }
74
75 /****************************************************************************
76  Initialise the messaging functions. 
77 ****************************************************************************/
78
79 NTSTATUS messaging_tdb_init(struct messaging_context *msg_ctx,
80                             TALLOC_CTX *mem_ctx,
81                             struct messaging_backend **presult)
82 {
83         struct messaging_backend *result;
84         TDB_CONTEXT *tdb;
85
86         if (!(result = TALLOC_P(mem_ctx, struct messaging_backend))) {
87                 DEBUG(0, ("talloc failed\n"));
88                 return NT_STATUS_NO_MEMORY;
89         }
90
91         tdb = tdb_open_log(lock_path("messages.tdb"), 
92                            0, TDB_CLEAR_IF_FIRST|TDB_DEFAULT, 
93                            O_RDWR|O_CREAT,0600);
94
95         if (!tdb) {
96                 NTSTATUS status = map_nt_error_from_unix(errno);
97                 DEBUG(0, ("ERROR: Failed to initialise messages database: "
98                           "%s\n", strerror(errno)));
99                 TALLOC_FREE(result);
100                 return status;
101         }
102
103         sec_init();
104
105         /* Activate the per-hashchain freelist */
106         tdb_set_max_dead(tdb, 5);
107
108         CatchSignal(SIGUSR1, SIGNAL_CAST sig_usr1);
109
110         result->private_data = (void *)tdb;
111         result->send_fn = messaging_tdb_send;
112
113         talloc_set_destructor(result, messaging_tdb_destructor);
114
115         *presult = result;
116         return NT_STATUS_OK;
117 }
118
119 /*******************************************************************
120  Form a static tdb key from a pid.
121 ******************************************************************/
122
123 static TDB_DATA message_key_pid(struct server_id pid)
124 {
125         static char key[20];
126         TDB_DATA kbuf;
127
128         slprintf(key, sizeof(key)-1, "PID/%s", procid_str_static(&pid));
129         
130         kbuf.dptr = (uint8 *)key;
131         kbuf.dsize = strlen(key)+1;
132         return kbuf;
133 }
134
135 /*
136   Fetch the messaging array for a process
137  */
138
139 static NTSTATUS messaging_tdb_fetch(TDB_CONTEXT *msg_tdb,
140                                     TDB_DATA key,
141                                     TALLOC_CTX *mem_ctx,
142                                     struct messaging_array **presult)
143 {
144         struct messaging_array *result;
145         TDB_DATA data;
146         DATA_BLOB blob;
147         NTSTATUS status;
148
149         if (!(result = TALLOC_ZERO_P(mem_ctx, struct messaging_array))) {
150                 return NT_STATUS_NO_MEMORY;
151         }
152
153         data = tdb_fetch(msg_tdb, key);
154
155         if (data.dptr == NULL) {
156                 *presult = result;
157                 return NT_STATUS_OK;
158         }
159
160         blob = data_blob_const(data.dptr, data.dsize);
161
162         status = ndr_pull_struct_blob(
163                 &blob, result, result,
164                 (ndr_pull_flags_fn_t)ndr_pull_messaging_array);
165
166         SAFE_FREE(data.dptr);
167
168         if (!NT_STATUS_IS_OK(status)) {
169                 TALLOC_FREE(result);
170                 return status;
171         }
172
173         if (DEBUGLEVEL >= 10) {
174                 DEBUG(10, ("messaging_tdb_fetch:\n"));
175                 NDR_PRINT_DEBUG(messaging_array, result);
176         }
177
178         *presult = result;
179         return NT_STATUS_OK;
180 }
181
182 /*
183   Store a messaging array for a pid
184 */
185
186 static NTSTATUS messaging_tdb_store(TDB_CONTEXT *msg_tdb,
187                                     TDB_DATA key,
188                                     struct messaging_array *array)
189 {
190         TDB_DATA data;
191         DATA_BLOB blob;
192         NTSTATUS status;
193         TALLOC_CTX *mem_ctx;
194         int ret;
195
196         if (array->num_messages == 0) {
197                 tdb_delete(msg_tdb, key);
198                 return NT_STATUS_OK;
199         }
200
201         if (!(mem_ctx = talloc_new(array))) {
202                 return NT_STATUS_NO_MEMORY;
203         }
204
205         status = ndr_push_struct_blob(
206                 &blob, mem_ctx, array,
207                 (ndr_push_flags_fn_t)ndr_push_messaging_array);
208
209         if (!NT_STATUS_IS_OK(status)) {
210                 talloc_free(mem_ctx);
211                 return status;
212         }
213
214         if (DEBUGLEVEL >= 10) {
215                 DEBUG(10, ("messaging_tdb_store:\n"));
216                 NDR_PRINT_DEBUG(messaging_array, array);
217         }
218
219         data.dptr = blob.data;
220         data.dsize = blob.length;
221
222         ret = tdb_store(msg_tdb, key, data, TDB_REPLACE);
223         TALLOC_FREE(mem_ctx);
224
225         return (ret == 0) ? NT_STATUS_OK : NT_STATUS_INTERNAL_DB_CORRUPTION;
226 }
227
228 /****************************************************************************
229  Notify a process that it has a message. If the process doesn't exist 
230  then delete its record in the database.
231 ****************************************************************************/
232
233 static NTSTATUS message_notify(struct server_id procid)
234 {
235         pid_t pid = procid.pid;
236         int ret;
237         uid_t euid = geteuid();
238
239         /*
240          * Doing kill with a non-positive pid causes messages to be
241          * sent to places we don't want.
242          */
243
244         SMB_ASSERT(pid > 0);
245
246         if (euid != 0) {
247                 /* If we're not root become so to send the message. */
248                 save_re_uid();
249                 set_effective_uid(0);
250         }
251
252         ret = kill(pid, SIGUSR1);
253
254         if (euid != 0) {
255                 /* Go back to who we were. */
256                 int saved_errno = errno;
257                 restore_re_uid_fromroot();
258                 errno = saved_errno;
259         }
260
261         if (ret == 0) {
262                 return NT_STATUS_OK;
263         }
264
265         /*
266          * Something has gone wrong
267          */
268
269         DEBUG(2,("message to process %d failed - %s\n", (int)pid,
270                  strerror(errno)));
271
272         /*
273          * No call to map_nt_error_from_unix -- don't want to link in
274          * errormap.o into lots of utils.
275          */
276
277         if (errno == ESRCH)  return NT_STATUS_INVALID_HANDLE;
278         if (errno == EINVAL) return NT_STATUS_INVALID_PARAMETER;
279         if (errno == EPERM)  return NT_STATUS_ACCESS_DENIED;
280         return NT_STATUS_UNSUCCESSFUL;
281 }
282
283 /****************************************************************************
284  Send a message to a particular pid.
285 ****************************************************************************/
286
287 static NTSTATUS messaging_tdb_send(struct messaging_context *msg_ctx,
288                                    struct server_id pid, int msg_type,
289                                    const DATA_BLOB *data,
290                                    struct messaging_backend *backend)
291 {
292         struct messaging_array *msg_array;
293         struct messaging_rec *rec;
294         TALLOC_CTX *mem_ctx;
295         NTSTATUS status;
296         TDB_DATA key = message_key_pid(pid);
297         TDB_CONTEXT *tdb = (TDB_CONTEXT *)backend->private_data;
298
299         /* NULL pointer means implicit length zero. */
300         if (!data->data) {
301                 SMB_ASSERT(data->length == 0);
302         }
303
304         /*
305          * Doing kill with a non-positive pid causes messages to be
306          * sent to places we don't want.
307          */
308
309         SMB_ASSERT(procid_to_pid(&pid) > 0);
310
311         if (!(mem_ctx = talloc_init("message_send_pid"))) {
312                 return NT_STATUS_NO_MEMORY;
313         }
314
315         if (tdb_chainlock(tdb, key) == -1) {
316                 TALLOC_FREE(mem_ctx);
317                 return NT_STATUS_LOCK_NOT_GRANTED;
318         }
319
320         status = messaging_tdb_fetch(tdb, key, mem_ctx, &msg_array);
321
322         if (!NT_STATUS_IS_OK(status)) {
323                 goto done;
324         }
325
326         if ((msg_type & MSG_FLAG_LOWPRIORITY)
327             && (msg_array->num_messages > 1000)) {
328                 DEBUG(5, ("Dropping message for PID %s\n",
329                           procid_str_static(&pid)));
330                 status = NT_STATUS_INSUFFICIENT_RESOURCES;
331                 goto done;
332         }
333
334         if (!(rec = TALLOC_REALLOC_ARRAY(mem_ctx, msg_array->messages,
335                                          struct messaging_rec,
336                                          msg_array->num_messages+1))) {
337                 status = NT_STATUS_NO_MEMORY;
338                 goto done;
339         }
340
341         rec[msg_array->num_messages].msg_version = MESSAGE_VERSION;
342         rec[msg_array->num_messages].msg_type = msg_type & MSG_TYPE_MASK;
343         rec[msg_array->num_messages].dest = pid;
344         rec[msg_array->num_messages].src = procid_self();
345         rec[msg_array->num_messages].buf = *data;
346
347         msg_array->messages = rec;
348         msg_array->num_messages += 1;
349
350         status = messaging_tdb_store(tdb, key, msg_array);
351
352         if (!NT_STATUS_IS_OK(status)) {
353                 goto done;
354         }
355         
356         status = message_notify(pid);
357
358         if (NT_STATUS_EQUAL(status, NT_STATUS_INVALID_HANDLE)) {
359                 DEBUG(2, ("pid %s doesn't exist - deleting messages record\n",
360                           procid_str_static(&pid)));
361                 tdb_delete(tdb, message_key_pid(pid));
362         }
363
364  done:
365         tdb_chainunlock(tdb, key);
366         TALLOC_FREE(mem_ctx);
367         return status;
368 }
369
370 /****************************************************************************
371  Retrieve all messages for the current process.
372 ****************************************************************************/
373
374 static NTSTATUS retrieve_all_messages(TDB_CONTEXT *msg_tdb,
375                                       TALLOC_CTX *mem_ctx,
376                                       struct messaging_array **presult)
377 {
378         struct messaging_array *result;
379         TDB_DATA key = message_key_pid(procid_self());
380         NTSTATUS status;
381
382         if (tdb_chainlock(msg_tdb, key) == -1) {
383                 return NT_STATUS_LOCK_NOT_GRANTED;
384         }
385
386         status = messaging_tdb_fetch(msg_tdb, key, mem_ctx, &result);
387
388         /*
389          * We delete the record here, tdb_set_max_dead keeps it around
390          */
391         tdb_delete(msg_tdb, key);
392         tdb_chainunlock(msg_tdb, key);
393
394         if (NT_STATUS_IS_OK(status)) {
395                 *presult = result;
396         }
397
398         return status;
399 }
400
401 /****************************************************************************
402  Receive and dispatch any messages pending for this process.
403  JRA changed Dec 13 2006. Only one message handler now permitted per type.
404  *NOTE*: Dispatch functions must be able to cope with incoming
405  messages on an *odd* byte boundary.
406 ****************************************************************************/
407
408 void message_dispatch(struct messaging_context *msg_ctx)
409 {
410         struct messaging_array *msg_array = NULL;
411         TDB_CONTEXT *tdb = (TDB_CONTEXT *)(msg_ctx->local->private_data);
412         uint32 i;
413
414         if (!received_signal)
415                 return;
416
417         DEBUG(10, ("message_dispatch: received_signal = %d\n",
418                    received_signal));
419
420         received_signal = 0;
421
422         if (!NT_STATUS_IS_OK(retrieve_all_messages(tdb, NULL, &msg_array))) {
423                 return;
424         }
425
426         for (i=0; i<msg_array->num_messages; i++) {
427                 messaging_dispatch_rec(msg_ctx, &msg_array->messages[i]);
428         }
429
430         TALLOC_FREE(msg_array);
431 }
432
433 /** @} **/