struct lock_context {
uint32 smbpid;
uint16 tid;
- struct process_id pid;
+ struct server_id pid;
};
/* The key used in the brlock database. */
};
#define BRLOCK_FN_CAST() \
- void (*)(SMB_DEV_T dev, SMB_INO_T ino, struct process_id pid, \
+ void (*)(SMB_DEV_T dev, SMB_INO_T ino, struct server_id pid, \
enum brl_type lock_type, \
enum brl_flavour lock_flav, \
br_off start, br_off size)
#define BRLOCK_FN(fn) \
- void (*fn)(SMB_DEV_T dev, SMB_INO_T ino, struct process_id pid, \
+ void (*fn)(SMB_DEV_T dev, SMB_INO_T ino, struct server_id pid, \
enum brl_type lock_type, \
enum brl_flavour lock_flav, \
br_off start, br_off size)
#define FLAG_MSG_PRINT_NOTIFY 0x0008
#define FLAG_MSG_PRINT_GENERAL 0x0010
-struct process_id {
- pid_t pid;
-};
-
-/*
- * Samba4 API compatibility layer
- */
-
struct server_id {
- struct process_id id;
+ pid_t pid;
};
#endif
/* struct returned by get_share_modes */
struct share_mode_entry {
- struct process_id pid;
+ struct server_id pid;
uint16 op_mid;
uint16 op_type;
uint32 access_mask; /* NTCreateX access bits (FILE_READ_DATA etc.) */
/* oplock break message definition - linearization of share_mode_entry.
Offset Data length.
-0 struct process_id pid 4
+0 struct server_id pid 4
4 uint16 op_mid 2
6 uint16 op_type 2
8 uint32 access_mask 4
/* Used to store pipe open records for NetFileEnum() */
struct pipe_open_rec {
- struct process_id pid;
+ struct server_id pid;
uid_t uid;
int pnum;
fstring name;
/* key and data in the connections database - used in smbstatus and smbd */
struct connections_key {
- struct process_id pid;
+ struct server_id pid;
int cnum;
fstring name;
};
struct connections_data {
int magic;
- struct process_id pid;
+ struct server_id pid;
int cnum;
uid_t uid;
gid_t gid;
uint32_t access_mask;
struct timeval open_time;
uint32_t file_id;
- struct process_id pid;
+ struct server_id pid;
};
/*
Receive a "set debug level" message.
****************************************************************************/
-static void debug_message(int msg_type, struct process_id src,
+static void debug_message(int msg_type, struct server_id src,
void *buf, size_t len, void *private_data)
{
const char *params_str = (const char *)buf;
Return current debug level.
****************************************************************************/
-static void debuglevel_message(int msg_type, struct process_id src,
+static void debuglevel_message(int msg_type, struct server_id src,
void *buf, size_t len, void *private_data)
{
char *message = debug_list_class_names_and_levels();
* usage stats.
**/
static void msg_req_dmalloc_mark(int UNUSED(msg_type),
- struct process_id UNUSED(src_pid),
+ struct server_id UNUSED(src_pid),
void *UNUSED(buf), size_t UNUSED(len),
void *private_data)
{
static void msg_req_dmalloc_log_changed(int UNUSED(msg_type),
- struct process_id UNUSED(src_pid),
+ struct server_id UNUSED(src_pid),
void *UNUSED(buf), size_t UNUSED(len),
void *private_data)
{
struct message_rec {
int msg_version;
int msg_type;
- struct process_id dest;
- struct process_id src;
+ struct server_id dest;
+ struct server_id src;
size_t len;
};
static struct dispatch_fns {
struct dispatch_fns *next, *prev;
int msg_type;
- void (*fn)(int msg_type, struct process_id pid, void *buf, size_t len,
+ void (*fn)(int msg_type, struct server_id pid, void *buf, size_t len,
void *private_data);
void *private_data;
} *dispatch_fns;
A useful function for testing the message system.
****************************************************************************/
-static void ping_message(int msg_type, struct process_id src,
+static void ping_message(int msg_type, struct server_id src,
void *buf, size_t len, void *private_data)
{
const char *msg = buf ? (const char *)buf : "none";
Form a static tdb key from a pid.
******************************************************************/
-static TDB_DATA message_key_pid(struct process_id pid)
+static TDB_DATA message_key_pid(struct server_id pid)
{
static char key[20];
TDB_DATA kbuf;
then delete its record in the database.
****************************************************************************/
-static NTSTATUS message_notify(struct process_id procid)
+static NTSTATUS message_notify(struct server_id procid)
{
pid_t pid = procid.pid;
int ret;
Send a message to a particular pid.
****************************************************************************/
-static NTSTATUS message_send_pid_internal(struct process_id pid, int msg_type,
+static NTSTATUS message_send_pid_internal(struct server_id pid, int msg_type,
const void *buf, size_t len,
BOOL duplicates_allowed,
unsigned int timeout)
Send a message to a particular pid - no timeout.
****************************************************************************/
-NTSTATUS message_send_pid(struct process_id pid, int msg_type, const void *buf,
+NTSTATUS message_send_pid(struct server_id pid, int msg_type, const void *buf,
size_t len, BOOL duplicates_allowed)
{
return message_send_pid_internal(pid, msg_type, buf, len,
Send a message to a particular pid, with timeout in seconds.
****************************************************************************/
-NTSTATUS message_send_pid_with_timeout(struct process_id pid, int msg_type,
+NTSTATUS message_send_pid_with_timeout(struct server_id pid, int msg_type,
const void *buf, size_t len,
BOOL duplicates_allowed, unsigned int timeout)
{
Count the messages pending for a particular pid. Expensive....
****************************************************************************/
-unsigned int messages_pending_for_pid(struct process_id pid)
+unsigned int messages_pending_for_pid(struct server_id pid)
{
TDB_DATA kbuf;
TDB_DATA dbuf;
****************************************************************************/
static BOOL message_recv(char *msgs_buf, size_t total_len, int *msg_type,
- struct process_id *src, char **buf, size_t *len)
+ struct server_id *src, char **buf, size_t *len)
{
struct message_rec rec;
char *ret_buf = *buf;
void message_dispatch(void)
{
int msg_type;
- struct process_id src;
+ struct server_id src;
char *buf;
char *msgs_buf;
size_t len, total_len;
****************************************************************************/
void message_register(int msg_type,
- void (*fn)(int msg_type, struct process_id pid,
+ void (*fn)(int msg_type, struct server_id pid,
void *buf, size_t len,
void *private_data),
void *private_data)
return ctx;
}
-static void messaging_callback(int msg_type, struct process_id pid,
+static void messaging_callback(int msg_type, struct server_id pid,
void *buf, size_t len, void *private_data)
{
struct messaging_context *ctx = talloc_get_type_abort(
if (msg_type == cb->msg_type) {
DATA_BLOB blob;
- struct server_id id;
blob.data = (uint8 *)buf;
blob.length = len;
- id.id = pid;
- cb->fn(ctx, cb->private_data, msg_type, id, &blob);
+ cb->fn(ctx, cb->private_data, msg_type, pid, &blob);
}
}
}
struct server_id server,
uint32_t msg_type, DATA_BLOB *data)
{
- return message_send_pid_internal(server.id, msg_type, data->data,
+ return message_send_pid_internal(server, msg_type, data->data,
data->length, True, 0);
}
* Respond to a POOL_USAGE message by sending back string form of memory
* usage stats.
**/
-void msg_pool_usage(int msg_type, struct process_id src_pid,
+void msg_pool_usage(int msg_type, struct server_id src_pid,
void *UNUSED(buf), size_t UNUSED(len),
void *private_data)
{
Check if a process exists. Does this work on all unixes?
****************************************************************************/
-BOOL process_exists(const struct process_id pid)
+BOOL process_exists(const struct server_id pid)
{
if (procid_is_me(&pid)) {
return True;
return (uint32)-1;
}
-pid_t procid_to_pid(const struct process_id *proc)
+pid_t procid_to_pid(const struct server_id *proc)
{
return proc->pid;
}
-struct process_id pid_to_procid(pid_t pid)
+struct server_id pid_to_procid(pid_t pid)
{
- struct process_id result;
+ struct server_id result;
result.pid = pid;
return result;
}
-struct process_id procid_self(void)
+struct server_id procid_self(void)
{
return pid_to_procid(sys_getpid());
}
struct server_id server_id_self(void)
{
- struct server_id id;
- id.id = procid_self();
- return id;
+ return procid_self();
}
-BOOL procid_equal(const struct process_id *p1, const struct process_id *p2)
+BOOL procid_equal(const struct server_id *p1, const struct server_id *p2)
{
return (p1->pid == p2->pid);
}
BOOL cluster_id_equal(const struct server_id *id1,
const struct server_id *id2)
{
- return procid_equal(&id1->id, &id2->id);
+ return procid_equal(id1, id2);
}
-BOOL procid_is_me(const struct process_id *pid)
+BOOL procid_is_me(const struct server_id *pid)
{
return (pid->pid == sys_getpid());
}
-struct process_id interpret_pid(const char *pid_string)
+struct server_id interpret_pid(const char *pid_string)
{
return pid_to_procid(atoi(pid_string));
}
-char *procid_str_static(const struct process_id *pid)
+char *procid_str_static(const struct server_id *pid)
{
static fstring str;
fstr_sprintf(str, "%d", pid->pid);
return str;
}
-char *procid_str(TALLOC_CTX *mem_ctx, const struct process_id *pid)
+char *procid_str(TALLOC_CTX *mem_ctx, const struct server_id *pid)
{
return talloc_strdup(mem_ctx, procid_str_static(pid));
}
-BOOL procid_valid(const struct process_id *pid)
+BOOL procid_valid(const struct server_id *pid)
{
return (pid->pid != -1);
}
-BOOL procid_is_local(const struct process_id *pid)
+BOOL procid_is_local(const struct server_id *pid)
{
return True;
}
if (ndr_flags & NDR_SCALARS) {
NDR_CHECK(ndr_push_align(ndr, 4));
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS,
- (uint32_t)r->id.pid));
+ (uint32_t)r->pid));
}
if (ndr_flags & NDR_BUFFERS) {
}
uint32_t pid;
NDR_CHECK(ndr_pull_align(ndr, 4));
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &pid));
- r->id.pid = (pid_t)pid;
+ r->pid = (pid_t)pid;
}
if (ndr_flags & NDR_BUFFERS) {
}
{
ndr_print_struct(ndr, name, "server_id");
ndr->depth++;
- ndr_print_uint32(ndr, "id", (uint32_t)r->id.pid);
+ ndr_print_uint32(ndr, "id", (uint32_t)r->pid);
ndr->depth--;
}
uint64_t ino, const struct smb_share_mode_entry *new_entry,
const char *sharepath, const char *filename);
-static BOOL sharemodes_procid_equal(const struct process_id *p1, const struct process_id *p2)
+static BOOL sharemodes_procid_equal(const struct server_id *p1, const struct server_id *p2)
{
return (p1->pid == p2->pid);
}
-static pid_t sharemodes_procid_to_pid(const struct process_id *proc)
+static pid_t sharemodes_procid_to_pid(const struct server_id *proc)
{
return proc->pid;
}
for (i = 0; i < num_share_modes; i++) {
struct share_mode_entry *share = &shares[i];
struct smb_share_mode_entry *sme = &list[list_num];
- struct process_id pid = share->pid;
+ struct server_id pid = share->pid;
/* Check this process really exists. */
if (kill(sharemodes_procid_to_pid(&pid), 0) == -1 && (errno == ESRCH)) {
num_share_modes = 0;
for (i = 0; i < orig_num_share_modes; i++) {
struct share_mode_entry *share = &shares[i];
- struct process_id pid = share->pid;
+ struct server_id pid = share->pid;
/* Check this process really exists. */
if (kill(sharemodes_procid_to_pid(&pid), 0) == -1 && (errno == ESRCH)) {
for (i = 0; i < num_share_modes; i++) {
struct share_mode_entry *share = &shares[i];
- struct process_id pid = share->pid;
+ struct server_id pid = share->pid;
/* Check this process really exists. */
if (kill(sharemodes_procid_to_pid(&pid), 0) == -1 && (errno == ESRCH)) {
NTSTATUS brl_lock(struct byte_range_lock *br_lck,
uint32 smbpid,
- struct process_id pid,
+ struct server_id pid,
br_off start,
br_off size,
enum brl_type lock_type,
BOOL brl_unlock(struct byte_range_lock *br_lck,
uint32 smbpid,
- struct process_id pid,
+ struct server_id pid,
br_off start,
br_off size,
enum brl_flavour lock_flav)
BOOL brl_locktest(struct byte_range_lock *br_lck,
uint32 smbpid,
- struct process_id pid,
+ struct server_id pid,
br_off start,
br_off size,
enum brl_type lock_type,
NTSTATUS brl_lockquery(struct byte_range_lock *br_lck,
uint32 *psmbpid,
- struct process_id pid,
+ struct server_id pid,
br_off *pstart,
br_off *psize,
enum brl_type *plock_type,
BOOL brl_lock_cancel(struct byte_range_lock *br_lck,
uint32 smbpid,
- struct process_id pid,
+ struct server_id pid,
br_off start,
br_off size,
enum brl_flavour lock_flav)
unsigned int i, j, dcount=0;
int num_deleted_windows_locks = 0;
struct lock_struct *locks = br_lck->lock_data;
- struct process_id pid = procid_self();
+ struct server_id pid = procid_self();
BOOL unlock_individually = False;
if(lp_posix_locking(fsp->conn->params)) {
Handle a SHUTDOWN message from smbcontrol.
**************************************************************************** */
-static void nmbd_terminate(int msg_type, struct process_id src,
+static void nmbd_terminate(int msg_type, struct server_id src,
void *buf, size_t len, void *private_data)
{
terminate();
* detects that there are no subnets.
**************************************************************************** */
-static void msg_reload_nmbd_services(int msg_type, struct process_id src,
+static void msg_reload_nmbd_services(int msg_type, struct server_id src,
void *buf, size_t len, void *private_data)
{
write_browse_list( 0, True );
}
}
-static void msg_nmbd_send_packet(int msg_type, struct process_id src,
+static void msg_nmbd_send_packet(int msg_type, struct server_id src,
void *buf, size_t len, void *private_data)
{
struct packet_struct *p = (struct packet_struct *)buf;
Process a internal Samba message forcing an election.
***************************************************************************/
-void nmbd_message_election(int msg_type, struct process_id src,
+void nmbd_message_election(int msg_type, struct server_id src,
void *buf, size_t len, void *private_data)
{
struct subnet_record *subrec;
Process a internal Samba message receiving a wins record.
***************************************************************************/
-void nmbd_wins_new_entry(int msg_type, struct process_id src,
+void nmbd_wins_new_entry(int msg_type, struct server_id src,
void *buf, size_t len, void *private_data)
{
WINS_RECORD *record;
}
/* React on 'smbcontrol winbindd reload-config' in the same way as on SIGHUP*/
-static void msg_reload_services(int msg_type, struct process_id src,
+static void msg_reload_services(int msg_type, struct server_id src,
void *buf, size_t len, void *private_data)
{
/* Flush various caches */
}
/* React on 'smbcontrol winbindd shutdown' in the same way as on SIGTERM*/
-static void msg_shutdown(int msg_type, struct process_id src,
+static void msg_shutdown(int msg_type, struct server_id src,
void *buf, size_t len, void *private_data)
{
do_sigterm = True;
Child failed to find DC's. Reschedule check.
****************************************************************/
-static void msg_failed_to_go_online(int msg_type, struct process_id src,
+static void msg_failed_to_go_online(int msg_type, struct server_id src,
void *buf, size_t len, void *private_data)
{
struct winbindd_domain *domain;
Actually cause a reconnect from a message.
****************************************************************/
-static void msg_try_to_go_online(int msg_type, struct process_id src,
+static void msg_try_to_go_online(int msg_type, struct server_id src,
void *buf, size_t len, void *private_data)
{
struct winbindd_domain *domain;
/* Set our domains as offline and forward the offline message to our children. */
-void winbind_msg_offline(int msg_type, struct process_id src,
+void winbind_msg_offline(int msg_type, struct server_id src,
void *buf, size_t len, void *private_data)
{
struct winbindd_child *child;
/* Set our domains as online and forward the online message to our children. */
-void winbind_msg_online(int msg_type, struct process_id src,
+void winbind_msg_online(int msg_type, struct server_id src,
void *buf, size_t len, void *private_data)
{
struct winbindd_child *child;
}
/* Forward the online/offline messages to our children. */
-void winbind_msg_onlinestatus(int msg_type, struct process_id src,
+void winbind_msg_onlinestatus(int msg_type, struct server_id src,
void *buf, size_t len, void *private_data)
{
struct winbindd_child *child;
/* Deal with a request to go offline. */
-static void child_msg_offline(int msg_type, struct process_id src,
+static void child_msg_offline(int msg_type, struct server_id src,
void *buf, size_t len, void *private_data)
{
struct winbindd_domain *domain;
/* Deal with a request to go online. */
-static void child_msg_online(int msg_type, struct process_id src,
+static void child_msg_online(int msg_type, struct server_id src,
void *buf, size_t len, void *private_data)
{
struct winbindd_domain *domain;
return buf;
}
-static void child_msg_onlinestatus(int msg_type, struct process_id src,
+static void child_msg_onlinestatus(int msg_type, struct server_id src,
void *buf, size_t len, void *private_data)
{
TALLOC_CTX *mem_ctx;
const char *message;
- struct process_id *sender;
+ struct server_id *sender;
DEBUG(5,("winbind_msg_onlinestatus received.\n"));
return;
}
- sender = (struct process_id *)buf;
+ sender = (struct server_id *)buf;
mem_ctx = talloc_init("winbind_msg_onlinestatus");
if (mem_ctx == NULL) {
/****************************************************************************
this is the receive function of the background lpq updater
****************************************************************************/
-static void print_queue_receive(int msg_type, struct process_id src,
+static void print_queue_receive(int msg_type, struct server_id src,
void *buf, size_t msglen,
void *private_data)
{
/****************************************************************************
Set a profiling level.
****************************************************************************/
-void set_profile_level(int level, struct process_id src)
+void set_profile_level(int level, struct server_id src)
{
#ifdef WITH_PROFILE
switch (level) {
/****************************************************************************
receive a set profile level message
****************************************************************************/
-void profile_message(int msg_type, struct process_id src, void *buf, size_t len, void *private_data)
+void profile_message(int msg_type, struct server_id src, void *buf, size_t len,
+ void *private_data)
{
int level;
/****************************************************************************
receive a request profile level message
****************************************************************************/
-void reqprofile_message(int msg_type, struct process_id src,
+void reqprofile_message(int msg_type, struct server_id src,
void *buf, size_t len, void *private_data)
{
int level;
Receive a notify2 message list
********************************************************************/
-static void receive_notify2_message_list(int msg_type, struct process_id src,
+static void receive_notify2_message_list(int msg_type, struct server_id src,
void *msg, size_t len,
void *private_data)
{
over all printers, upgrading ones as necessary
**********************************************************************/
-void do_drv_upgrade_printer(int msg_type, struct process_id src,
+void do_drv_upgrade_printer(int msg_type, struct server_id src,
void *buf, size_t len, void *private_data)
{
fstring drivername;
over all printers, resetting printer data as neessary
**********************************************************************/
-void reset_all_printerdata(int msg_type, struct process_id src,
+void reset_all_printerdata(int msg_type, struct server_id src,
void *buf, size_t len, void *private_data)
{
fstring drivername;
return (chain_size != 0);
}
-static void received_unlock_msg(int msg_type, struct process_id src,
+static void received_unlock_msg(int msg_type, struct server_id src,
void *buf, size_t len,
void *private_data);
static void process_blocking_lock_queue(void);
Set a flag as an unlock request affects one of our pending locks.
*****************************************************************************/
-static void received_unlock_msg(int msg_type, struct process_id src,
+static void received_unlock_msg(int msg_type, struct server_id src,
void *buf, size_t len,
void *private_data)
{
#define MSG_BLOCKING_LOCK_CANCEL_SIZE (sizeof(blocking_lock_record *) + sizeof(NTSTATUS))
static void process_blocking_lock_cancel_message(int msg_type,
- struct process_id src,
+ struct server_id src,
void *buf, size_t len,
void *private_data)
{
share are unmounted
the special sharename '*' forces unmount of all shares
****************************************************************************/
-void msg_force_tdis(int msg_type, struct process_id pid, void *buf, size_t len,
+void msg_force_tdis(int msg_type, struct server_id pid, void *buf, size_t len,
void *private_data)
{
connection_struct *conn, *next;
DEBUG(10, ("Deleting notify entries for "
"process %s because it's gone\n",
- procid_str_static(&e->server.id)));
+ procid_str_static(&e->server)));
notify_remove_all(notify, &server);
goto again;
}
smbd process.
****************************************************************************/
-void msg_file_was_renamed(int msg_type, struct process_id src,
+void msg_file_was_renamed(int msg_type, struct server_id src,
void *buf, size_t len, void *private_data)
{
files_struct *fsp;
the client for LEVEL2.
*******************************************************************/
-static void process_oplock_async_level2_break_message(int msg_type, struct process_id src,
+static void process_oplock_async_level2_break_message(int msg_type, struct server_id src,
void *buf, size_t len,
void *private_data)
{
This handles the generic oplock break message from another smbd.
*******************************************************************/
-static void process_oplock_break_message(int msg_type, struct process_id src,
+static void process_oplock_break_message(int msg_type, struct server_id src,
void *buf, size_t len,
void *private_data)
{
This handles the kernel oplock break message.
*******************************************************************/
-static void process_kernel_oplock_break(int msg_type, struct process_id src,
+static void process_kernel_oplock_break(int msg_type, struct server_id src,
void *buf, size_t len,
void *private_data)
{
return;
}
-static void process_oplock_break_response(int msg_type, struct process_id src,
+static void process_oplock_break_response(int msg_type, struct server_id src,
void *buf, size_t len,
void *private_data)
{
schedule_deferred_open_smb_message(msg.op_mid);
}
-static void process_open_retry_message(int msg_type, struct process_id src,
+static void process_open_retry_message(int msg_type, struct server_id src,
void *buf, size_t len,
void *private_data)
{
#define PIPEDB_KEY_FORMAT "PIPE/%s/%u/%d"
struct pipe_dbrec {
- struct process_id pid;
+ struct server_id pid;
int pnum;
uid_t uid;
What to do when smb.conf is updated.
********************************************************************/
-static void smb_conf_updated(int msg_type, struct process_id src,
+static void smb_conf_updated(int msg_type, struct server_id src,
void *buf, size_t len, void *private_data)
{
DEBUG(10,("smb_conf_updated: Got message saying smb.conf was updated. Reloading.\n"));
Delete a statcache entry.
********************************************************************/
-static void smb_stat_cache_delete(int msg_type, struct process_id src,
+static void smb_stat_cache_delete(int msg_type, struct server_id src,
void *buf, size_t len, void *private_data)
{
const char *name = (const char *)buf;
somewhere else.
****************************************************************************/
-static void msg_sam_sync(int UNUSED(msg_type), struct process_id UNUSED(pid),
+static void msg_sam_sync(int UNUSED(msg_type), struct server_id UNUSED(pid),
void *UNUSED(buf), size_t UNUSED(len),
void *private_data)
{
somewhere else.
****************************************************************************/
-static void msg_sam_repl(int msg_type, struct process_id pid,
+static void msg_sam_repl(int msg_type, struct server_id pid,
void *buf, size_t len, void *private_data)
{
uint32 low_serial;
return True;
}
-static void msg_exit_server(int msg_type, struct process_id src,
+static void msg_exit_server(int msg_type, struct server_id src,
void *buf, size_t len, void *private_data)
{
DEBUG(3, ("got a SHUTDOWN message\n"));
}
#ifdef DEVELOPER
-static void msg_inject_fault(int msg_type, struct process_id src,
+static void msg_inject_fault(int msg_type, struct server_id src,
void *buf, size_t len, void *private_data)
{
int sig;
}
if (profile_level != NULL) {
int pl = atoi(profile_level);
- struct process_id src;
+ struct server_id src;
DEBUG(1, ("setting profiling level: %s\n",profile_level));
src.pid = getpid();
static void print_brl(SMB_DEV_T dev,
SMB_INO_T ino,
- struct process_id pid,
+ struct server_id pid,
enum brl_type lock_type,
enum brl_flavour lock_flav,
br_off start,
return False;
}
-static void print_brl(SMB_DEV_T dev, SMB_INO_T ino, struct process_id pid,
+static void print_brl(SMB_DEV_T dev, SMB_INO_T ino, struct server_id pid,
enum brl_type lock_type,
enum brl_flavour lock_flav,
br_off start, br_off size)
/****************************************************************************
a useful function for testing the message system
****************************************************************************/
-static void pong_message(int msg_type, struct process_id src,
+static void pong_message(int msg_type, struct server_id src,
void *buf, size_t len, void *private_data)
{
pong_count++;
return 0;
}
-void do_drv_upgrade_printer(int msg_type, struct process_id src,
+void do_drv_upgrade_printer(int msg_type, struct server_id src,
void *buf, size_t len, void *private_data)
{
return;
}
for (i=0; i<ids->num_entries; i++) {
- struct process_id id = pid_to_procid(ids->entries[i].pid);
+ struct server_id id = pid_to_procid(ids->entries[i].pid);
if (procid_equal(&id, &crec.pid)) {
guest = False;
break;
/* Send a message to a destination pid. Zero means broadcast smbd. */
-static BOOL send_message(struct process_id pid, int msg_type,
+static BOOL send_message(struct server_id pid, int msg_type,
const void *buf, int len,
BOOL duplicates)
{
/* Message handler callback that displays the PID and a string on stdout */
-static void print_pid_string_cb(int msg_type, struct process_id pid, void *buf,
+static void print_pid_string_cb(int msg_type, struct server_id pid, void *buf,
size_t len, void *private_data)
{
printf("PID %u: %.*s", (unsigned int)procid_to_pid(&pid),
/* Message handler callback that displays a string on stdout */
-static void print_string_cb(int msg_type, struct process_id pid,
+static void print_string_cb(int msg_type, struct server_id pid,
void *buf, size_t len, void *private_data)
{
printf("%.*s", (int)len, (const char *)buf);
/* Send no message. Useful for testing. */
-static BOOL do_noop(const struct process_id pid,
+static BOOL do_noop(const struct server_id pid,
const int argc, const char **argv)
{
if (argc != 1) {
/* Send a debug string */
-static BOOL do_debug(const struct process_id pid,
+static BOOL do_debug(const struct server_id pid,
const int argc, const char **argv)
{
if (argc != 2) {
return 0;
}
-static BOOL do_daemon_stack_trace(const struct process_id pid,
+static BOOL do_daemon_stack_trace(const struct server_id pid,
const int argc, const char **argv)
{
fprintf(stderr,
#else /* defined(HAVE_LIBUNWIND_PTRACE) && defined(HAVE_LINUX_PTRACE) */
-static BOOL do_daemon_stack_trace(const struct process_id pid,
+static BOOL do_daemon_stack_trace(const struct server_id pid,
const int argc, const char **argv)
{
fprintf(stderr,
/* Inject a fault (fatal signal) into a running smbd */
-static BOOL do_inject_fault(const struct process_id pid,
+static BOOL do_inject_fault(const struct server_id pid,
const int argc, const char **argv)
{
if (argc != 2) {
/* Force a browser election */
-static BOOL do_election(const struct process_id pid,
+static BOOL do_election(const struct server_id pid,
const int argc, const char **argv)
{
if (argc != 1) {
/* Ping a samba daemon process */
-static void pong_cb(int msg_type, struct process_id pid, void *buf,
+static void pong_cb(int msg_type, struct server_id pid, void *buf,
size_t len, void *private_data)
{
char *src_string = procid_str(NULL, &pid);
num_replies++;
}
-static BOOL do_ping(const struct process_id pid, const int argc, const char **argv)
+static BOOL do_ping(const struct server_id pid, const int argc, const char **argv)
{
if (argc != 1) {
fprintf(stderr, "Usage: smbcontrol <dest> ping\n");
/* Set profiling options */
-static BOOL do_profile(const struct process_id pid,
+static BOOL do_profile(const struct server_id pid,
const int argc, const char **argv)
{
int v;
/* Return the profiling level */
-static void profilelevel_cb(int msg_type, struct process_id pid, void *buf,
+static void profilelevel_cb(int msg_type, struct server_id pid, void *buf,
size_t len, void *private_data)
{
int level;
printf("Profiling %s on pid %u\n",s,(unsigned int)procid_to_pid(&pid));
}
-static void profilelevel_rqst(int msg_type, struct process_id pid,
+static void profilelevel_rqst(int msg_type, struct server_id pid,
void *buf, size_t len, void *private_data)
{
int v = 0;
send_message(pid, MSG_PROFILELEVEL, &v, sizeof(int), False);
}
-static BOOL do_profilelevel(const struct process_id pid,
+static BOOL do_profilelevel(const struct server_id pid,
const int argc, const char **argv)
{
if (argc != 1) {
/* Display debug level settings */
-static BOOL do_debuglevel(const struct process_id pid,
+static BOOL do_debuglevel(const struct server_id pid,
const int argc, const char **argv)
{
if (argc != 1) {
/* Send a print notify message */
-static BOOL do_printnotify(const struct process_id pid,
+static BOOL do_printnotify(const struct server_id pid,
const int argc, const char **argv)
{
const char *cmd;
/* Close a share */
-static BOOL do_closeshare(const struct process_id pid,
+static BOOL do_closeshare(const struct server_id pid,
const int argc, const char **argv)
{
if (argc != 2) {
/* Force a SAM synchronisation */
-static BOOL do_samsync(const struct process_id pid,
+static BOOL do_samsync(const struct server_id pid,
const int argc, const char **argv)
{
if (argc != 1) {
/* Force a SAM replication */
-static BOOL do_samrepl(const struct process_id pid,
+static BOOL do_samrepl(const struct server_id pid,
const int argc, const char **argv)
{
if (argc != 1) {
/* Display talloc pool usage */
-static BOOL do_poolusage(const struct process_id pid,
+static BOOL do_poolusage(const struct server_id pid,
const int argc, const char **argv)
{
if (argc != 1) {
/* Perform a dmalloc mark */
-static BOOL do_dmalloc_mark(const struct process_id pid,
+static BOOL do_dmalloc_mark(const struct server_id pid,
const int argc, const char **argv)
{
if (argc != 1) {
/* Perform a dmalloc changed */
-static BOOL do_dmalloc_changed(const struct process_id pid,
+static BOOL do_dmalloc_changed(const struct server_id pid,
const int argc, const char **argv)
{
if (argc != 1) {
/* Shutdown a server process */
-static BOOL do_shutdown(const struct process_id pid,
+static BOOL do_shutdown(const struct server_id pid,
const int argc, const char **argv)
{
if (argc != 1) {
/* Notify a driver upgrade */
-static BOOL do_drvupgrade(const struct process_id pid,
+static BOOL do_drvupgrade(const struct server_id pid,
const int argc, const char **argv)
{
if (argc != 2) {
pid, MSG_DEBUG, argv[1], strlen(argv[1]) + 1, False);
}
-static BOOL do_winbind_online(const struct process_id pid,
+static BOOL do_winbind_online(const struct server_id pid,
const int argc, const char **argv)
{
TDB_CONTEXT *tdb;
return send_message(pid, MSG_WINBIND_ONLINE, NULL, 0, False);
}
-static BOOL do_winbind_offline(const struct process_id pid,
+static BOOL do_winbind_offline(const struct server_id pid,
const int argc, const char **argv)
{
TDB_CONTEXT *tdb;
return ret;
}
-static BOOL do_winbind_onlinestatus(const struct process_id pid,
+static BOOL do_winbind_onlinestatus(const struct server_id pid,
const int argc, const char **argv)
{
- struct process_id myid;
+ struct server_id myid;
myid = pid_to_procid(sys_getpid());
}
-static BOOL do_reload_config(const struct process_id pid,
+static BOOL do_reload_config(const struct server_id pid,
const int argc, const char **argv)
{
if (argc != 1) {
push_ascii(n->scope, global_scope(), 64, STR_TERMINATE);
}
-static BOOL do_nodestatus(const struct process_id pid,
+static BOOL do_nodestatus(const struct server_id pid,
const int argc, const char **argv)
{
struct packet_struct p;
static const struct {
const char *name; /* Option name */
- BOOL (*fn)(const struct process_id pid,
+ BOOL (*fn)(const struct server_id pid,
const int argc, const char **argv);
const char *help; /* Short help text */
} msg_types[] = {
/* Return the pid number for a string destination */
-static struct process_id parse_dest(const char *dest)
+static struct server_id parse_dest(const char *dest)
{
- struct process_id result = {-1};
+ struct server_id result = {-1};
pid_t pid;
/* Zero is a special return value for broadcast smbd */
static BOOL do_command(int argc, const char **argv)
{
const char *dest = argv[0], *command = argv[1];
- struct process_id pid;
+ struct server_id pid;
int i;
/* Check destination */
static void print_brl(SMB_DEV_T dev,
SMB_INO_T ino,
- struct process_id pid,
+ struct server_id pid,
enum brl_type lock_type,
enum brl_flavour lock_flav,
br_off start,
}
#endif
/* kill a specified process */
-void kill_pid(struct process_id pid)
+void kill_pid(struct server_id pid)
{
if (geteuid() != 0) return;
PIDMAP {
PIDMAP *next, *prev;
- struct process_id pid;
+ struct server_id pid;
char *machine;
};
static PIDMAP *pidmap;
static int PID_or_Machine; /* 0 = show PID, else show Machine name */
-static struct process_id smbd_pid;
+static struct server_id smbd_pid;
/* from 2nd call on, remove old list */
static void initPid2Machine (void)
}
/* add new PID <-> Machine name mapping */
-static void addPid2Machine (struct process_id pid, char *machine)
+static void addPid2Machine (struct server_id pid, char *machine)
{
/* show machine name rather PID on table "Open Files"? */
if (PID_or_Machine) {
}
/* lookup PID <-> Machine name mapping */
-static char *mapPid2Machine (struct process_id pid)
+static char *mapPid2Machine (struct server_id pid)
{
static char pidbuf [64];
PIDMAP *map;