* Respond to a POOL_USAGE message by sending back string form of memory
* usage stats.
**/
-static void msg_req_dmalloc_mark(int UNUSED(msg_type),
- struct server_id UNUSED(src_pid),
- void *UNUSED(buf), size_t UNUSED(len),
- void *private_data)
+static void msg_req_dmalloc_mark(struct messaging_context *msg,
+ void *private_data,
+ uint32_t msg_type,
+ struct server_id server_id,
+ DATA_BLOB *data)
{
#ifdef ENABLE_DMALLOC
our_dm_mark = dmalloc_mark();
-static void msg_req_dmalloc_log_changed(int UNUSED(msg_type),
- struct server_id UNUSED(src_pid),
- void *UNUSED(buf), size_t UNUSED(len),
- void *private_data)
+static void msg_req_dmalloc_log_changed(struct messaging_context *msg,
+ void *private_data,
+ uint32_t msg_type,
+ struct server_id server_id,
+ DATA_BLOB *data)
{
#ifdef ENABLE_DMALLOC
dmalloc_log_changed(our_dm_mark, True, True, True);
/**
* Register handler for MSG_REQ_POOL_USAGE
**/
-void register_dmalloc_msgs(void)
+void register_dmalloc_msgs(struct messaging_context *msg_ctx)
{
- message_register(MSG_REQ_DMALLOC_MARK, msg_req_dmalloc_mark, NULL);
- message_register(MSG_REQ_DMALLOC_LOG_CHANGED,
- msg_req_dmalloc_log_changed, NULL);
+ messaging_register(msg_ctx, NULL, MSG_REQ_DMALLOC_MARK,
+ msg_req_dmalloc_mark);
+ messaging_register(msg_ctx, NULL, MSG_REQ_DMALLOC_LOG_CHANGED,
+ msg_req_dmalloc_log_changed);
DEBUG(2, ("Registered MSG_REQ_DMALLOC_MARK and LOG_CHANGED\n"));
}
return True;
}
+BOOL events_pending(struct event_context *event_ctx)
+{
+ struct fd_event *fde;
+
+ if (event_ctx->timed_events != NULL) {
+ return True;
+ }
+ for (fde = event_ctx->fd_events; fde; fde = fde->next) {
+ if (fde->flags & (EVENT_FD_READ|EVENT_FD_WRITE)) {
+ return True;
+ }
+ }
+ return False;
+}
+
BOOL run_events(struct event_context *event_ctx,
int selrtn, fd_set *read_fds, fd_set *write_fds)
{
void *private_data;
} *dispatch_fns;
+static void message_register(int msg_type,
+ void (*fn)(int msg_type, struct server_id pid,
+ void *buf, size_t len,
+ void *private_data),
+ void *private_data);
+
/****************************************************************************
Free global objects.
****************************************************************************/
/* Register some debugging related messages */
register_msg_pool_usage(msg_ctx);
- register_dmalloc_msgs();
+ register_dmalloc_msgs(msg_ctx);
debug_register_msgs(msg_ctx);
return True;
messages on an *odd* byte boundary.
****************************************************************************/
-void message_register(int msg_type,
- void (*fn)(int msg_type, struct server_id pid,
- void *buf, size_t len,
- void *private_data),
- void *private_data)
+static void message_register(int msg_type,
+ void (*fn)(int msg_type, struct server_id pid,
+ void *buf, size_t len,
+ void *private_data),
+ void *private_data)
{
struct dispatch_fns *dfn;
De-register the function for a particular message type.
****************************************************************************/
-void message_deregister(int msg_type)
+static void message_deregister(int msg_type)
{
struct dispatch_fns *dfn, *next;
Handle a SHUTDOWN message from smbcontrol.
**************************************************************************** */
-static void nmbd_terminate(int msg_type, struct server_id src,
- void *buf, size_t len, void *private_data)
+static void nmbd_terminate(struct messaging_context *msg,
+ void *private_data,
+ uint32_t msg_type,
+ struct server_id server_id,
+ DATA_BLOB *data)
{
terminate();
}
* detects that there are no subnets.
**************************************************************************** */
-static void msg_reload_nmbd_services(int msg_type, struct server_id src,
- void *buf, size_t len, void *private_data)
+static void msg_reload_nmbd_services(struct messaging_context *msg,
+ void *private_data,
+ uint32_t msg_type,
+ struct server_id server_id,
+ DATA_BLOB *data)
{
write_browse_list( 0, True );
dump_all_namelists();
reload_nmbd_services( True );
reopen_logs();
- if(buf) {
+ if (data->data) {
/* We were called from process() */
/* If reload_interfaces() returned True */
/* we need to shutdown if there are no subnets... */
/* pass this info back to process() */
- *((BOOL*)buf) = reload_interfaces(0);
+ *((BOOL*)data->data) = reload_interfaces(0);
}
}
-static void msg_nmbd_send_packet(int msg_type, struct server_id src,
- void *buf, size_t len, void *private_data)
+static void msg_nmbd_send_packet(struct messaging_context *msg,
+ void *private_data,
+ uint32_t msg_type,
+ struct server_id src,
+ DATA_BLOB *data)
{
- struct packet_struct *p = (struct packet_struct *)buf;
+ struct packet_struct *p = (struct packet_struct *)data->data;
struct subnet_record *subrec;
struct in_addr *local_ip;
DEBUG(10, ("Received send_packet from %d\n", procid_to_pid(&src)));
- if (len != sizeof(struct packet_struct)) {
+ if (data->length != sizeof(struct packet_struct)) {
DEBUG(2, ("Discarding invalid packet length from %d\n",
procid_to_pid(&src)));
return;
*/
if(reload_after_sighup) {
+ DATA_BLOB blob = data_blob_const(&no_subnets,
+ sizeof(no_subnets));
DEBUG( 0, ( "Got SIGHUP dumping debug info.\n" ) );
- msg_reload_nmbd_services(MSG_SMB_CONF_UPDATED,
- pid_to_procid(0), (void*) &no_subnets, 0, NULL);
+ msg_reload_nmbd_services(nmbd_messaging_context(),
+ NULL, MSG_SMB_CONF_UPDATED,
+ procid_self(), &blob);
+
if(no_subnets)
return;
reload_after_sighup = 0;
}
pidfile_create("nmbd");
- message_register(MSG_FORCE_ELECTION, nmbd_message_election, NULL);
+ messaging_register(nmbd_messaging_context(), NULL,
+ MSG_FORCE_ELECTION, nmbd_message_election);
#if 0
/* Until winsrepl is done. */
- message_register(MSG_WINS_NEW_ENTRY, nmbd_wins_new_entry, NULL);
+ messaging_register(nmbd_messaging_context(), NULL,
+ MSG_WINS_NEW_ENTRY, nmbd_wins_new_entry);
#endif
- message_register(MSG_SHUTDOWN, nmbd_terminate, NULL);
- message_register(MSG_SMB_CONF_UPDATED, msg_reload_nmbd_services, NULL);
- message_register(MSG_SEND_PACKET, msg_nmbd_send_packet, NULL);
+ messaging_register(nmbd_messaging_context(), NULL,
+ MSG_SHUTDOWN, nmbd_terminate);
+ messaging_register(nmbd_messaging_context(), NULL,
+ MSG_SMB_CONF_UPDATED, msg_reload_nmbd_services);
+ messaging_register(nmbd_messaging_context(), NULL,
+ MSG_SEND_PACKET, msg_nmbd_send_packet);
TimeInit();
Process a internal Samba message forcing an election.
***************************************************************************/
-void nmbd_message_election(int msg_type, struct server_id src,
- void *buf, size_t len, void *private_data)
+void nmbd_message_election(struct messaging_context *msg,
+ void *private_data,
+ uint32_t msg_type,
+ struct server_id server_id,
+ DATA_BLOB *data)
{
struct subnet_record *subrec;
Process a internal Samba message receiving a wins record.
***************************************************************************/
-void nmbd_wins_new_entry(int msg_type, struct server_id src,
- void *buf, size_t len, void *private_data)
+void nmbd_wins_new_entry(struct messaging_context *msg,
+ void *private_data,
+ uint32_t msg_type,
+ struct server_id server_id,
+ DATA_BLOB *data)
{
WINS_RECORD *record;
struct name_record *namerec = NULL;
}
/* Ensure we ignore any pending child messages. */
- message_deregister(MSG_WINBIND_TRY_TO_GO_ONLINE);
- message_deregister(MSG_WINBIND_FAILED_TO_GO_ONLINE);
+ messaging_deregister(winbind_messaging_context(),
+ MSG_WINBIND_TRY_TO_GO_ONLINE, NULL);
+ messaging_deregister(winbind_messaging_context(),
+ MSG_WINBIND_FAILED_TO_GO_ONLINE, NULL);
domain->online = True;
cli_shutdown( notify_cli_pipe->cli );
notify_cli_pipe = NULL; /* The above call shuts downn the pipe also. */
- message_deregister(MSG_PRINTER_NOTIFY2);
+ messaging_deregister(smbd_messaging_context(),
+ MSG_PRINTER_NOTIFY2, NULL);
/* Tell the connections db we're no longer interested in
* printer notify messages. */
Receive a notify2 message list
********************************************************************/
-static void receive_notify2_message_list(int msg_type, struct server_id src,
- void *msg, size_t len,
- void *private_data)
+static void receive_notify2_message_list(struct messaging_context *msg,
+ void *private_data,
+ uint32_t msg_type,
+ struct server_id server_id,
+ DATA_BLOB *data)
{
size_t msg_count, i;
- char *buf = (char *)msg;
+ char *buf = (char *)data->data;
char *msg_ptr;
size_t msg_len;
SPOOLSS_NOTIFY_MSG notify;
SPOOLSS_NOTIFY_MSG_CTR messages;
int num_groups;
- if (len < 4) {
+ if (data->length < 4) {
DEBUG(0,("receive_notify2_message_list: bad message format (len < 4)!\n"));
return;
}
for ( i=0; i<msg_count; i++ ) {
struct timeval msg_tv;
- if (msg_ptr + 4 - buf > len) {
+ if (msg_ptr + 4 - buf > data->length) {
DEBUG(0,("receive_notify2_message_list: bad message format (len > buf_size) !\n"));
return;
}
msg_len = IVAL(msg_ptr,0);
msg_ptr += 4;
- if (msg_ptr + msg_len - buf > len) {
+ if (msg_ptr + msg_len - buf > data->length) {
DEBUG(0,("receive_notify2_message_list: bad message format (bad len) !\n"));
return;
}
if ( !spoolss_connect_to_client( ¬ify_cli_pipe, client_ip, unix_printer ))
return False;
- message_register(MSG_PRINTER_NOTIFY2,
- receive_notify2_message_list, NULL);
+ messaging_register(smbd_messaging_context(), NULL,
+ MSG_PRINTER_NOTIFY2,
+ receive_notify2_message_list);
/* Tell the connections db we're now interested in printer
* notify messages. */
register_message_flags( True, FLAG_MSG_PRINT_NOTIFY );
return (chain_size != 0);
}
-static void received_unlock_msg(int msg_type, struct server_id src,
- void *buf, size_t len,
- void *private_data);
+static void received_unlock_msg(struct messaging_context *msg,
+ void *private_data,
+ uint32_t msg_type,
+ struct server_id server_id,
+ DATA_BLOB *data);
static void process_blocking_lock_queue(void);
static void brl_timeout_fn(struct event_context *event_ctx,
/* Ensure we'll receive messages when this is unlocked. */
if (!set_lock_msg) {
- message_register(MSG_SMB_UNLOCK, received_unlock_msg,
- NULL);
+ messaging_register(smbd_messaging_context(), NULL,
+ MSG_SMB_UNLOCK, received_unlock_msg);
set_lock_msg = True;
}
Set a flag as an unlock request affects one of our pending locks.
*****************************************************************************/
-static void received_unlock_msg(int msg_type, struct server_id src,
- void *buf, size_t len,
- void *private_data)
+static void received_unlock_msg(struct messaging_context *msg,
+ void *private_data,
+ uint32_t msg_type,
+ struct server_id server_id,
+ DATA_BLOB *data)
{
DEBUG(10,("received_unlock_msg\n"));
process_blocking_lock_queue();
#define MSG_BLOCKING_LOCK_CANCEL_SIZE (sizeof(blocking_lock_record *) + sizeof(NTSTATUS))
-static void process_blocking_lock_cancel_message(int msg_type,
- struct server_id src,
- void *buf, size_t len,
- void *private_data)
+static void process_blocking_lock_cancel_message(struct messaging_context *ctx,
+ void *private_data,
+ uint32_t msg_type,
+ struct server_id server_id,
+ DATA_BLOB *data)
{
NTSTATUS err;
- const char *msg = (const char *)buf;
+ const char *msg = (const char *)data->data;
blocking_lock_record *blr;
- if (buf == NULL) {
+ if (data->data == NULL) {
smb_panic("process_blocking_lock_cancel_message: null msg\n");
}
- if (len != MSG_BLOCKING_LOCK_CANCEL_SIZE) {
+ if (data->length != MSG_BLOCKING_LOCK_CANCEL_SIZE) {
DEBUG(0, ("process_blocking_lock_cancel_message: "
- "Got invalid msg len %d\n", (int)len));
+ "Got invalid msg len %d\n", (int)data->length));
smb_panic("process_blocking_lock_cancel_message: bad msg\n");
}
if (!initialized) {
/* Register our message. */
- message_register(MSG_SMB_BLOCKING_LOCK_CANCEL,
- process_blocking_lock_cancel_message,
- NULL);
+ messaging_register(smbd_messaging_context(), NULL,
+ MSG_SMB_BLOCKING_LOCK_CANCEL,
+ process_blocking_lock_cancel_message);
initialized = True;
}