-static void ping_message(int msg_type, pid_t src, void *buf, size_t len)
-{
- char *msg = buf ? buf : "none";
- DEBUG(1,("INFO: Received PING message from PID %u [%s]\n",(unsigned int)src, msg));
- message_send_pid(src, MSG_PONG, buf, len, True);
-}
-
-/****************************************************************************
- Initialise the messaging functions.
-****************************************************************************/
-
-BOOL message_init(void)
-{
- if (tdb) return True;
-
- tdb = tdb_open_log(lock_path("messages.tdb"),
- 0, TDB_CLEAR_IF_FIRST|TDB_DEFAULT,
- O_RDWR|O_CREAT,0600);
-
- if (!tdb) {
- DEBUG(0,("ERROR: Failed to initialise messages database\n"));
- return False;
- }
-
- CatchSignal(SIGUSR1, SIGNAL_CAST sig_usr1);
-
- message_register(MSG_PING, ping_message);
-
- return True;
-}
-
-/*******************************************************************
- Form a static tdb key from a pid.
-******************************************************************/
-
-static TDB_DATA message_key_pid(pid_t pid)
-{
- static char key[20];
- TDB_DATA kbuf;
-
- slprintf(key, sizeof(key)-1, "PID/%d", (int)pid);
-
- kbuf.dptr = (char *)key;
- kbuf.dsize = strlen(key)+1;
- return kbuf;
-}
-
-/****************************************************************************
- Notify a process that it has a message. If the process doesn't exist
- then delete its record in the database.
-****************************************************************************/
-
-static BOOL message_notify(pid_t pid)
-{
- /* Doing kill with a non-positive pid causes messages to be
- * sent to places we don't want. */
- SMB_ASSERT(pid > 0);
- if (kill(pid, SIGUSR1) == -1) {
- if (errno == ESRCH) {
- DEBUG(2,("pid %d doesn't exist - deleting messages record\n", (int)pid));
- tdb_delete(tdb, message_key_pid(pid));
- } else {
- DEBUG(2,("message to process %d failed - %s\n", (int)pid, strerror(errno)));
- }
- return False;
- }
- return True;
-}
-
-/****************************************************************************
- Send a message to a particular pid.
-****************************************************************************/
-
-BOOL message_send_pid(pid_t pid, int msg_type, const void *buf, size_t len,
- BOOL duplicates_allowed)
-{
- TDB_DATA kbuf;
- TDB_DATA dbuf;
- struct message_rec rec;
- void *p;
-
- rec.msg_version = MESSAGE_VERSION;
- rec.msg_type = msg_type;
- rec.dest = pid;
- rec.src = sys_getpid();
- rec.len = len;
-
- /* Doing kill with a non-positive pid causes messages to be
- * sent to places we don't want. */
- SMB_ASSERT(pid > 0);
-
- kbuf = message_key_pid(pid);
-
- /* lock the record for the destination */
- tdb_chainlock(tdb, kbuf);
-
- dbuf = tdb_fetch(tdb, kbuf);
-
- if (!dbuf.dptr) {
- /* its a new record */
- p = (void *)malloc(len + sizeof(rec));
- if (!p)
- goto failed;
-
- memcpy(p, &rec, sizeof(rec));
- if (len > 0)
- memcpy((void *)((char*)p+sizeof(rec)), buf, len);
-
- dbuf.dptr = p;
- dbuf.dsize = len + sizeof(rec);
- tdb_store(tdb, kbuf, dbuf, TDB_REPLACE);
- SAFE_FREE(p);
- goto ok;
- }
-
- if (!duplicates_allowed) {
- char *ptr;
- struct message_rec prec;
-
- for(ptr = (char *)dbuf.dptr; ptr < dbuf.dptr + dbuf.dsize; ) {
- /*
- * First check if the message header matches, then, if it's a non-zero
- * sized message, check if the data matches. If so it's a duplicate and
- * we can discard it. JRA.
- */
-
- if (!memcmp(ptr, &rec, sizeof(rec))) {
- if (!len || (len && !memcmp( ptr + sizeof(rec), buf, len))) {
- DEBUG(10,("message_send_pid: discarding duplicate message.\n"));
- SAFE_FREE(dbuf.dptr);
- tdb_chainunlock(tdb, kbuf);
- return True;
- }
- }
- memcpy(&prec, ptr, sizeof(prec));
- ptr += sizeof(rec) + prec.len;
- }
- }
-
- /* we're adding to an existing entry */
- p = (void *)malloc(dbuf.dsize + len + sizeof(rec));
- if (!p)
- goto failed;
-
- memcpy(p, dbuf.dptr, dbuf.dsize);
- memcpy((void *)((char*)p+dbuf.dsize), &rec, sizeof(rec));
- if (len > 0)
- memcpy((void *)((char*)p+dbuf.dsize+sizeof(rec)), buf, len);
-
- SAFE_FREE(dbuf.dptr);
- dbuf.dptr = p;
- dbuf.dsize += len + sizeof(rec);
- tdb_store(tdb, kbuf, dbuf, TDB_REPLACE);
- SAFE_FREE(dbuf.dptr);
-
- ok:
- tdb_chainunlock(tdb, kbuf);
- errno = 0; /* paranoia */
- return message_notify(pid);
-
- failed:
- tdb_chainunlock(tdb, kbuf);
- errno = 0; /* paranoia */
- return False;
-}
-
-/****************************************************************************
- Retrieve the next message for the current process.
-****************************************************************************/
-
-static BOOL message_recv(int *msg_type, pid_t *src, void **buf, size_t *len)
-{
- TDB_DATA kbuf;
- TDB_DATA dbuf;
- struct message_rec rec;
-
- kbuf = message_key_pid(sys_getpid());
-
- tdb_chainlock(tdb, kbuf);
-
- dbuf = tdb_fetch(tdb, kbuf);
- if (dbuf.dptr == NULL || dbuf.dsize == 0)
- goto failed;
-
- memcpy(&rec, dbuf.dptr, sizeof(rec));
-
- if (rec.msg_version != MESSAGE_VERSION) {
- DEBUG(0,("message version %d received (expected %d)\n", rec.msg_version, MESSAGE_VERSION));
- goto failed;
- }
-
- if (rec.len > 0) {
- (*buf) = (void *)malloc(rec.len);
- if (!(*buf))
- goto failed;
-
- memcpy(*buf, dbuf.dptr+sizeof(rec), rec.len);
- } else {
- *buf = NULL;
- }
-
- *len = rec.len;
- *msg_type = rec.msg_type;
- *src = rec.src;
-
- if (dbuf.dsize - (sizeof(rec)+rec.len) > 0)
- memmove(dbuf.dptr, dbuf.dptr+sizeof(rec)+rec.len, dbuf.dsize - (sizeof(rec)+rec.len));
- dbuf.dsize -= sizeof(rec)+rec.len;
-
- if (dbuf.dsize == 0)
- tdb_delete(tdb, kbuf);
- else
- tdb_store(tdb, kbuf, dbuf, TDB_REPLACE);
-
- SAFE_FREE(dbuf.dptr);
- tdb_chainunlock(tdb, kbuf);
- return True;
-
- failed:
- tdb_chainunlock(tdb, kbuf);
- SAFE_FREE(dbuf.dptr);
- return False;
-}
-
-/****************************************************************************
- Receive and dispatch any messages pending for this process.
- Notice that all dispatch handlers for a particular msg_type get called,
- so you can register multiple handlers for a message.
-****************************************************************************/
-
-void message_dispatch(void)
-{
- int msg_type;
- pid_t src;
- void *buf;
- size_t len;
- struct dispatch_fns *dfn;
- int n_handled;
-
- if (!received_signal) return;
-
- DEBUG(10,("message_dispatch: received_signal = %d\n", received_signal));
-
- received_signal = 0;
-
- while (message_recv(&msg_type, &src, &buf, &len)) {
- DEBUG(10,("message_dispatch: received msg_type=%d src_pid=%d\n",
- msg_type, (int) src));
- n_handled = 0;
- for (dfn = dispatch_fns; dfn; dfn = dfn->next) {
- if (dfn->msg_type == msg_type) {
- DEBUG(10,("message_dispatch: processing message of type %d.\n", msg_type));
- dfn->fn(msg_type, src, buf, len);
- n_handled++;
- }
- }
- if (!n_handled) {
- DEBUG(5,("message_dispatch: warning: no handlers registered for "
- "msg_type %d in pid %d\n",
- msg_type, sys_getpid()));
- }
- SAFE_FREE(buf);
- }
-}
-
-/****************************************************************************
- Register a dispatch function for a particular message type.
-****************************************************************************/
-
-void message_register(int msg_type,
- void (*fn)(int msg_type, pid_t pid, void *buf, size_t len))