struct smbd_server_connection *msg_ctx_to_sconn(struct messaging_context *msg_ctx)
{
struct server_id my_id, msg_id;
my_id = messaging_server_id(smbd_server_conn->msg_ctx);
msg_id = messaging_server_id(msg_ctx);
if (!procid_equal(&my_id, &msg_id)) {
return NULL;
}
return smbd_server_conn;
}
static void generic_blocking_lock_error(struct blocking_lock_record *blr, NTSTATUS status)
{
/* whenever a timeout is given w2k maps LOCK_NOT_GRANTED to
FILE_LOCK_CONFLICT! (tridge) */
if (NT_STATUS_EQUAL(status, NT_STATUS_LOCK_NOT_GRANTED)) {
status = NT_STATUS_FILE_LOCK_CONFLICT;
}
if (NT_STATUS_EQUAL(status, NT_STATUS_FILE_LOCK_CONFLICT)) {
/* Store the last lock error. */
files_struct *fsp = blr->fsp;
if (fsp) {
fsp->last_lock_failure.context.smblctx = blr->smblctx;
fsp->last_lock_failure.context.tid = fsp->conn->cnum;
fsp->last_lock_failure.context.pid =
messaging_server_id(fsp->conn->sconn->msg_ctx);
fsp->last_lock_failure.start = blr->offset;
fsp->last_lock_failure.size = blr->count;
fsp->last_lock_failure.fnum = fsp->fnum;
fsp->last_lock_failure.lock_type = READ_LOCK; /* Don't care. */
fsp->last_lock_failure.lock_flav = blr->lock_flav;
}
}
reply_nterror(blr->req, status);
if (!srv_send_smb(blr->req->sconn, (char *)blr->req->outbuf,
true, blr->req->seqnum+1,
blr->req->encrypted, NULL)) {
exit_server_cleanly("generic_blocking_lock_error: srv_send_smb failed.");
}
TALLOC_FREE(blr->req->outbuf);
}
static bool do_winbind_onlinestatus(struct tevent_context *ev_ctx,
struct messaging_context *msg_ctx,
const struct server_id pid,
const int argc, const char **argv)
{
struct server_id myid;
myid = messaging_server_id(msg_ctx);
if (argc != 1) {
fprintf(stderr, "Usage: smbcontrol winbindd onlinestatus\n");
return False;
}
messaging_register(msg_ctx, NULL, MSG_WINBIND_ONLINESTATUS,
print_pid_string_cb);
if (!send_message(msg_ctx, pid, MSG_WINBIND_ONLINESTATUS, &myid,
sizeof(myid)))
return False;
wait_replies(ev_ctx, msg_ctx, procid_to_pid(&pid) == 0);
/* No replies were received within the timeout period */
if (num_replies == 0)
printf("No replies received\n");
messaging_deregister(msg_ctx, MSG_WINBIND_ONLINESTATUS, NULL);
return num_replies;
}
NTSTATUS query_lock(files_struct *fsp,
uint64_t *psmblctx,
uint64_t *pcount,
uint64_t *poffset,
enum brl_type *plock_type,
enum brl_flavour lock_flav)
{
struct byte_range_lock *br_lck = NULL;
if (!fsp->can_lock) {
return fsp->is_directory ? NT_STATUS_INVALID_DEVICE_REQUEST : NT_STATUS_INVALID_HANDLE;
}
if (!lp_locking(fsp->conn->params)) {
return NT_STATUS_OK;
}
br_lck = brl_get_locks_readonly(fsp);
if (!br_lck) {
return NT_STATUS_NO_MEMORY;
}
return brl_lockquery(br_lck,
psmblctx,
messaging_server_id(fsp->conn->sconn->msg_ctx),
poffset,
pcount,
plock_type,
lock_flav);
}
static bool do_winbind_validate_cache(struct tevent_context *ev_ctx,
struct messaging_context *msg_ctx,
const struct server_id pid,
const int argc, const char **argv)
{
struct server_id myid;
myid = messaging_server_id(msg_ctx);
if (argc != 1) {
fprintf(stderr, "Usage: smbcontrol winbindd validate-cache\n");
return False;
}
messaging_register(msg_ctx, NULL, MSG_WINBIND_VALIDATE_CACHE,
winbind_validate_cache_cb);
if (!send_message(msg_ctx, pid, MSG_WINBIND_VALIDATE_CACHE, &myid,
sizeof(myid))) {
return False;
}
wait_replies(ev_ctx, msg_ctx, procid_to_pid(&pid) == 0);
if (num_replies == 0) {
printf("No replies received\n");
}
messaging_deregister(msg_ctx, MSG_WINBIND_VALIDATE_CACHE, NULL);
return num_replies;
}
struct imessaging_context *winbind_imessaging_context(void)
{
static struct imessaging_context *msg = NULL;
struct messaging_context *msg_ctx;
struct server_id myself;
struct loadparm_context *lp_ctx;
if (msg != NULL) {
return msg;
}
msg_ctx = server_messaging_context();
if (msg_ctx == NULL) {
smb_panic("server_messaging_context failed\n");
}
myself = messaging_server_id(msg_ctx);
lp_ctx = loadparm_init_s3(NULL, loadparm_s3_helpers());
if (lp_ctx == NULL) {
smb_panic("Could not load smb.conf to init winbindd's imessaging context.\n");
}
/*
* Note we MUST use the NULL context here, not the autofree context,
* to avoid side effects in forked children exiting.
*/
msg = imessaging_init(NULL, lp_ctx, myself, winbind_event_context());
talloc_unlink(NULL, lp_ctx);
if (msg == NULL) {
smb_panic("Could not init winbindd's messaging context.\n");
}
return msg;
}
static bool lsasd_child_init(struct tevent_context *ev_ctx,
int child_id,
struct pf_worker_data *pf)
{
NTSTATUS status;
struct messaging_context *msg_ctx = server_messaging_context();
bool ok;
status = reinit_after_fork(msg_ctx, ev_ctx,
true);
if (!NT_STATUS_IS_OK(status)) {
DEBUG(0,("reinit_after_fork() failed\n"));
smb_panic("reinit_after_fork() failed");
}
prctl_set_comment("lsasd-child");
lsasd_child_id = child_id;
lsasd_reopen_logs(child_id);
ok = lsasd_setup_chld_hup_handler(ev_ctx);
if (!ok) {
return false;
}
if (!serverid_register(messaging_server_id(msg_ctx),
FLAG_MSG_GENERAL)) {
return false;
}
messaging_register(msg_ctx, ev_ctx,
MSG_SMB_CONF_UPDATED, lsasd_smb_conf_updated);
messaging_register(msg_ctx, ev_ctx,
MSG_PREFORK_PARENT_EVENT, parent_ping);
id_cache_register_msgs(msg_ctx);
status = rpc_lsarpc_init(NULL);
if (!NT_STATUS_IS_OK(status)) {
DEBUG(0, ("Failed to register lsarpc rpc inteface! (%s)\n",
nt_errstr(status)));
return false;
}
status = rpc_samr_init(NULL);
if (!NT_STATUS_IS_OK(status)) {
DEBUG(0, ("Failed to register samr rpc inteface! (%s)\n",
nt_errstr(status)));
return false;
}
status = rpc_netlogon_init(NULL);
if (!NT_STATUS_IS_OK(status)) {
DEBUG(0, ("Failed to register netlogon rpc inteface! (%s)\n",
nt_errstr(status)));
return false;
}
return true;
}
struct blocking_lock_record *blocking_lock_cancel_smb1(files_struct *fsp,
uint64_t smblctx,
uint64_t offset,
uint64_t count,
enum brl_flavour lock_flav,
unsigned char locktype,
NTSTATUS err)
{
struct smbd_server_connection *sconn = fsp->conn->sconn;
char msg[MSG_BLOCKING_LOCK_CANCEL_SIZE];
struct blocking_lock_record *blr;
if (!sconn->smb1.locks.blocking_lock_cancel_state) {
/* Register our message. */
messaging_register(sconn->msg_ctx, sconn,
MSG_SMB_BLOCKING_LOCK_CANCEL,
process_blocking_lock_cancel_message);
sconn->smb1.locks.blocking_lock_cancel_state = True;
}
for (blr = sconn->smb1.locks.blocking_lock_queue; blr; blr = blr->next) {
if (fsp == blr->fsp &&
smblctx == blr->smblctx &&
offset == blr->offset &&
count == blr->count &&
lock_flav == blr->lock_flav) {
break;
}
}
if (!blr) {
return NULL;
}
/* Check the flags are right. */
if (blr->req->cmd == SMBlockingX &&
(locktype & LOCKING_ANDX_LARGE_FILES) !=
(CVAL(blr->req->vwv+3, 0) & LOCKING_ANDX_LARGE_FILES)) {
return NULL;
}
/* Move to cancelled queue. */
DLIST_REMOVE(sconn->smb1.locks.blocking_lock_queue, blr);
DLIST_ADD(sconn->smb1.locks.blocking_lock_cancelled_queue, blr);
/* Create the message. */
memcpy(msg, &blr, sizeof(blr));
memcpy(&msg[sizeof(blr)], &err, sizeof(NTSTATUS));
messaging_send_buf(sconn->msg_ctx, messaging_server_id(sconn->msg_ctx),
MSG_SMB_BLOCKING_LOCK_CANCEL,
(uint8 *)&msg, sizeof(msg));
return blr;
}
static bool do_winbind_dump_domain_list(struct tevent_context *ev_ctx,
struct messaging_context *msg_ctx,
const struct server_id pid,
const int argc, const char **argv)
{
const char *domain = NULL;
int domain_len = 0;
struct server_id myid;
uint8_t *buf = NULL;
int buf_len = 0;
myid = messaging_server_id(msg_ctx);
if (argc < 1 || argc > 2) {
fprintf(stderr, "Usage: smbcontrol <dest> dump-domain-list "
"<domain>\n");
return false;
}
if (argc == 2) {
domain = argv[1];
domain_len = strlen(argv[1]) + 1;
}
messaging_register(msg_ctx, NULL, MSG_WINBIND_DUMP_DOMAIN_LIST,
print_pid_string_cb);
buf_len = sizeof(myid)+domain_len;
buf = SMB_MALLOC_ARRAY(uint8_t, buf_len);
if (!buf) {
return false;
}
memcpy(buf, &myid, sizeof(myid));
memcpy(&buf[sizeof(myid)], domain, domain_len);
if (!send_message(msg_ctx, pid, MSG_WINBIND_DUMP_DOMAIN_LIST,
buf, buf_len))
{
SAFE_FREE(buf);
return false;
}
wait_replies(ev_ctx, msg_ctx, procid_to_pid(&pid) == 0);
/* No replies were received within the timeout period */
SAFE_FREE(buf);
if (num_replies == 0) {
printf("No replies received\n");
}
messaging_deregister(msg_ctx, MSG_WINBIND_DUMP_DOMAIN_LIST, NULL);
return num_replies;
}
NTSTATUS smb1srv_tcon_create(struct smbXsrv_connection *conn,
NTTIME now,
struct smbXsrv_tcon **_tcon)
{
struct server_id id = messaging_server_id(conn->msg_ctx);
return smbXsrv_tcon_create(conn->client->tcon_table,
conn->protocol,
id, now, _tcon);
}
static void smbd_scavenger_msg(struct messaging_context *msg_ctx,
void *private_data,
uint32_t msg_type,
struct server_id src,
DATA_BLOB *data)
{
struct smbd_scavenger_state *state =
talloc_get_type_abort(private_data,
struct smbd_scavenger_state);
TALLOC_CTX *frame = talloc_stackframe();
struct server_id self = messaging_server_id(msg_ctx);
struct scavenger_message *msg = NULL;
struct server_id_buf tmp1, tmp2;
DEBUG(10, ("smbd_scavenger_msg: %s got message from %s\n",
server_id_str_buf(self, &tmp1),
server_id_str_buf(src, &tmp2)));
if (server_id_equal(&state->parent_id, &self)) {
NTSTATUS status;
if (!smbd_scavenger_running(state) &&
!smbd_scavenger_start(state))
{
DEBUG(2, ("Failed to start scavenger\n"));
goto done;
}
DEBUG(10, ("forwarding message to scavenger\n"));
status = messaging_send(msg_ctx,
*state->scavenger_id, msg_type, data);
if (!NT_STATUS_IS_OK(status)) {
DEBUG(2, ("forwarding message to scavenger failed: "
"%s\n", nt_errstr(status)));
goto done;
}
goto done;
}
if (!state->am_scavenger) {
DEBUG(10, ("im not the scavenger: ignore message\n"));
goto done;
}
if (!server_id_equal(&state->parent_id, &src)) {
DEBUG(10, ("scavenger: ignore spurious message\n"));
goto done;
}
DEBUG(10, ("scavenger: got a message\n"));
msg = (struct scavenger_message*)data->data;
scavenger_add_timer(state, msg);
done:
talloc_free(frame);
}
void scavenger_schedule_disconnected(struct files_struct *fsp)
{
NTSTATUS status;
struct server_id self = messaging_server_id(fsp->conn->sconn->msg_ctx);
struct timeval disconnect_time, until;
uint64_t timeout_usec;
struct scavenger_message msg;
DATA_BLOB msg_blob;
struct server_id_buf tmp;
if (fsp->op == NULL) {
return;
}
nttime_to_timeval(&disconnect_time, fsp->op->global->disconnect_time);
timeout_usec = 1000 * fsp->op->global->durable_timeout_msec;
until = timeval_add(&disconnect_time,
timeout_usec / 1000000,
timeout_usec % 1000000);
ZERO_STRUCT(msg);
msg.file_id = fsp->file_id;
msg.open_persistent_id = fsp->op->global->open_persistent_id;
msg.until = timeval_to_nttime(&until);
DEBUG(10, ("smbd: %s mark file %s as disconnected at %s with timeout "
"at %s in %fs\n",
server_id_str_buf(self, &tmp),
file_id_string_tos(&fsp->file_id),
timeval_string(talloc_tos(), &disconnect_time, true),
timeval_string(talloc_tos(), &until, true),
fsp->op->global->durable_timeout_msec/1000.0));
SMB_ASSERT(server_id_is_disconnected(&fsp->op->global->server_id));
SMB_ASSERT(!server_id_equal(&self, &smbd_scavenger_state->parent_id));
SMB_ASSERT(!smbd_scavenger_state->am_scavenger);
msg_blob = data_blob_const(&msg, sizeof(msg));
DEBUG(10, ("send message to scavenger\n"));
status = messaging_send(smbd_scavenger_state->msg,
smbd_scavenger_state->parent_id,
MSG_SMB_SCAVENGER,
&msg_blob);
if (!NT_STATUS_IS_OK(status)) {
struct server_id_buf tmp1, tmp2;
DEBUG(2, ("Failed to send message to parent smbd %s "
"from %s: %s\n",
server_id_str_buf(smbd_scavenger_state->parent_id,
&tmp1),
server_id_str_buf(self, &tmp2),
nt_errstr(status)));
}
}
void smbd_cancel_pending_lock_requests_by_fid(files_struct *fsp,
struct byte_range_lock *br_lck,
enum file_close_type close_type)
{
struct smbd_server_connection *sconn = fsp->conn->sconn;
struct blocking_lock_record *blr, *blr_cancelled, *next = NULL;
if (sconn->using_smb2) {
cancel_pending_lock_requests_by_fid_smb2(fsp,
br_lck,
close_type);
return;
}
for(blr = sconn->smb1.locks.blocking_lock_queue; blr; blr = next) {
unsigned char locktype = 0;
next = blr->next;
if (blr->fsp->fnum != fsp->fnum) {
continue;
}
if (blr->req->cmd == SMBlockingX) {
locktype = CVAL(blr->req->vwv+3, 0);
}
DEBUG(10, ("remove_pending_lock_requests_by_fid - removing "
"request type %d for file %s, %s\n",
blr->req->cmd, fsp_str_dbg(fsp), fsp_fnum_dbg(fsp)));
blr_cancelled = blocking_lock_cancel_smb1(fsp,
blr->smblctx,
blr->offset,
blr->count,
blr->lock_flav,
locktype,
NT_STATUS_RANGE_NOT_LOCKED);
SMB_ASSERT(blr_cancelled == blr);
brl_lock_cancel(br_lck,
blr->smblctx,
messaging_server_id(sconn->msg_ctx),
blr->offset,
blr->count,
blr->lock_flav,
blr);
/* We're closing the file fsp here, so ensure
* we don't have a dangling pointer. */
blr->fsp = NULL;
}
}
static void nmbd_sig_hup_handler(struct tevent_context *ev,
struct tevent_signal *se,
int signum,
int count,
void *siginfo,
void *private_data)
{
struct messaging_context *msg = talloc_get_type_abort(
private_data, struct messaging_context);
DEBUG(0,("Got SIGHUP dumping debug info.\n"));
msg_reload_nmbd_services(msg, NULL, MSG_SMB_CONF_UPDATED,
messaging_server_id(msg), NULL);
}
/*
* helper function used by the kernel oplock backends to post the break message
*/
void break_kernel_oplock(struct messaging_context *msg_ctx, files_struct *fsp)
{
uint8_t msg[MSG_SMB_KERNEL_BREAK_SIZE];
/* Put the kernel break info into the message. */
push_file_id_24((char *)msg, &fsp->file_id);
SIVAL(msg,24,fsp->fh->gen_id);
/* Don't need to be root here as we're only ever
sending to ourselves. */
messaging_send_buf(msg_ctx, messaging_server_id(msg_ctx),
MSG_SMB_KERNEL_BREAK,
msg, MSG_SMB_KERNEL_BREAK_SIZE);
}
static bool do_dump_event_list(struct tevent_context *ev_ctx,
struct messaging_context *msg_ctx,
const struct server_id pid,
const int argc, const char **argv)
{
struct server_id myid;
myid = messaging_server_id(msg_ctx);
if (argc != 1) {
fprintf(stderr, "Usage: smbcontrol <dest> dump-event-list\n");
return False;
}
return send_message(msg_ctx, pid, MSG_DUMP_EVENT_LIST, NULL, 0);
}
/**
* test fdpass1:
*
* Try to pass an fd to the sending process - fails.
*/
bool run_messaging_fdpass1(int dummy)
{
struct tevent_context *ev = NULL;
struct messaging_context *msg_ctx = NULL;
bool retval = false;
int pipe_fds[2];
int pass_fds[1] = { 0 };
int ret;
NTSTATUS status;
struct server_id dst;
TALLOC_CTX *frame = talloc_stackframe();
ev = samba_tevent_context_init(frame);
if (ev == NULL) {
fprintf(stderr, "tevent_context_init failed\n");
goto fail;
}
msg_ctx = messaging_init(ev, ev);
if (msg_ctx == NULL) {
fprintf(stderr, "messaging_init failed\n");
goto fail;
}
dst = messaging_server_id(msg_ctx);
ret = pipe(pipe_fds);
if (ret != 0) {
perror("pipe failed");
goto fail;
}
pass_fds[0] = pipe_fds[0];
status = messaging_send_iov(msg_ctx, dst, MSG_PING, NULL, 0,
pass_fds, 1);
if (!NT_STATUS_EQUAL(status, NT_STATUS_NOT_SUPPORTED)) {
fprintf(stderr,
"messaging_send_iov gave: %s\n", nt_errstr(status));
goto fail;
}
retval = true;
fail:
TALLOC_FREE(frame);
return retval;
}
struct db_record *connections_fetch_entry(TALLOC_CTX *mem_ctx,
connection_struct *conn,
const char *name)
{
struct connections_key ckey;
TDB_DATA key;
ZERO_STRUCT(ckey);
ckey.pid = messaging_server_id(conn->sconn->msg_ctx);
ckey.cnum = conn->cnum;
strlcpy(ckey.name, name, sizeof(ckey.name));
key.dsize = sizeof(ckey);
key.dptr = (uint8 *)&ckey;
return connections_fetch_record(mem_ctx, key);
}
static void cleanup_timeout_fn(struct tevent_context *event_ctx,
struct tevent_timer *te,
struct timeval now,
void *private_data)
{
struct smbd_parent_context *parent =
talloc_get_type_abort(private_data,
struct smbd_parent_context);
parent->cleanup_te = NULL;
DEBUG(1,("Cleaning up brl and lock database after unclean shutdown\n"));
message_send_all(parent->msg_ctx, MSG_SMB_UNLOCK, NULL, 0, NULL);
messaging_send_buf(parent->msg_ctx,
messaging_server_id(parent->msg_ctx),
MSG_SMB_BRL_VALIDATE, NULL, 0);
}
NTSTATUS do_lock_cancel(files_struct *fsp,
uint64 smblctx,
uint64_t count,
uint64_t offset,
enum brl_flavour lock_flav,
struct blocking_lock_record *blr)
{
bool ok = False;
struct byte_range_lock *br_lck = NULL;
if (!fsp->can_lock) {
return fsp->is_directory ?
NT_STATUS_INVALID_DEVICE_REQUEST : NT_STATUS_INVALID_HANDLE;
}
if (!lp_locking(fsp->conn->params)) {
return NT_STATUS_DOS(ERRDOS, ERRcancelviolation);
}
DEBUG(10,("do_lock_cancel: cancel start=%.0f len=%.0f requested for %s file %s\n",
(double)offset, (double)count, fsp_fnum_dbg(fsp),
fsp_str_dbg(fsp)));
br_lck = brl_get_locks(talloc_tos(), fsp);
if (!br_lck) {
return NT_STATUS_NO_MEMORY;
}
ok = brl_lock_cancel(br_lck,
smblctx,
messaging_server_id(fsp->conn->sconn->msg_ctx),
offset,
count,
lock_flav,
blr);
TALLOC_FREE(br_lck);
if (!ok) {
DEBUG(10,("do_lock_cancel: returning ERRcancelviolation.\n" ));
return NT_STATUS_DOS(ERRDOS, ERRcancelviolation);
}
decrement_current_lock_count(fsp, lock_flav);
return NT_STATUS_OK;
}
NTSTATUS do_unlock(struct messaging_context *msg_ctx,
files_struct *fsp,
uint64_t smblctx,
uint64_t count,
uint64_t offset,
enum brl_flavour lock_flav)
{
bool ok = False;
struct byte_range_lock *br_lck = NULL;
if (!fsp->can_lock) {
return fsp->is_directory ? NT_STATUS_INVALID_DEVICE_REQUEST : NT_STATUS_INVALID_HANDLE;
}
if (!lp_locking(fsp->conn->params)) {
return NT_STATUS_OK;
}
DEBUG(10,("do_unlock: unlock start=%.0f len=%.0f requested for %s file %s\n",
(double)offset, (double)count, fsp_fnum_dbg(fsp),
fsp_str_dbg(fsp)));
br_lck = brl_get_locks(talloc_tos(), fsp);
if (!br_lck) {
return NT_STATUS_NO_MEMORY;
}
ok = brl_unlock(msg_ctx,
br_lck,
smblctx,
messaging_server_id(fsp->conn->sconn->msg_ctx),
offset,
count,
lock_flav);
TALLOC_FREE(br_lck);
if (!ok) {
DEBUG(10,("do_unlock: returning ERRlock.\n" ));
return NT_STATUS_RANGE_NOT_LOCKED;
}
decrement_current_lock_count(fsp, lock_flav);
return NT_STATUS_OK;
}
void init_strict_lock_struct(files_struct *fsp,
uint64_t smblctx,
br_off start,
br_off size,
enum brl_type lock_type,
struct lock_struct *plock)
{
SMB_ASSERT(lock_type == READ_LOCK || lock_type == WRITE_LOCK);
plock->context.smblctx = smblctx;
plock->context.tid = fsp->conn->cnum;
plock->context.pid = messaging_server_id(fsp->conn->sconn->msg_ctx);
plock->start = start;
plock->size = size;
plock->fnum = fsp->fnum;
plock->lock_type = lock_type;
plock->lock_flav = lp_posix_cifsu_locktype(fsp);
}
static void fill_share_mode_entry(struct share_mode_entry *e,
files_struct *fsp,
uid_t uid, uint64_t mid, uint16 op_type)
{
ZERO_STRUCTP(e);
e->pid = messaging_server_id(fsp->conn->sconn->msg_ctx);
e->share_access = fsp->share_access;
e->private_options = fsp->fh->private_options;
e->access_mask = fsp->access_mask;
e->op_mid = mid;
e->op_type = op_type;
e->time.tv_sec = fsp->open_time.tv_sec;
e->time.tv_usec = fsp->open_time.tv_usec;
e->id = fsp->file_id;
e->share_file_id = fsp->fh->gen_id;
e->uid = (uint32)uid;
e->flags = fsp->posix_open ? SHARE_MODE_FLAG_POSIX_OPEN : 0;
e->name_hash = fsp->name_hash;
}
static int smbd_parent_ctdb_reconfigured(
uint32_t src_vnn, uint32_t dst_vnn, uint64_t dst_srvid,
const uint8_t *msg, size_t msglen, void *private_data)
{
struct messaging_context *msg_ctx = talloc_get_type_abort(
private_data, struct messaging_context);
DEBUG(10, ("Got %s message\n", (dst_srvid == CTDB_SRVID_RECONFIGURE)
? "cluster reconfigure" : "SAMBA_NOTIFY"));
/*
* Someone from the family died, validate our locks
*/
messaging_send_buf(msg_ctx, messaging_server_id(msg_ctx),
MSG_SMB_BRL_VALIDATE, NULL, 0);
return 0;
}
static bool mdssd_child_init(struct tevent_context *ev_ctx,
int child_id,
struct pf_worker_data *pf)
{
NTSTATUS status;
struct messaging_context *msg_ctx = server_messaging_context();
bool ok;
status = reinit_after_fork(msg_ctx, ev_ctx,
true, "mdssd-child");
if (!NT_STATUS_IS_OK(status)) {
DEBUG(0,("reinit_after_fork() failed\n"));
smb_panic("reinit_after_fork() failed");
}
mdssd_child_id = child_id;
reopen_logs();
ok = mdssd_setup_chld_hup_handler(ev_ctx);
if (!ok) {
return false;
}
if (!serverid_register(messaging_server_id(msg_ctx),
FLAG_MSG_GENERAL)) {
return false;
}
messaging_register(msg_ctx, ev_ctx,
MSG_SMB_CONF_UPDATED, mdssd_smb_conf_updated);
messaging_register(msg_ctx, ev_ctx,
MSG_PREFORK_PARENT_EVENT, parent_ping);
status = rpc_mdssvc_init(NULL);
if (!NT_STATUS_IS_OK(status)) {
DEBUG(0, ("Failed to intialize RPC: %s\n",
nt_errstr(status)));
return false;
}
return true;
}
static void terminate(bool is_parent)
{
if (is_parent) {
/* When parent goes away we should
* remove the socket file. Not so
* when children terminate.
*/
char *path = NULL;
if (asprintf(&path, "%s/%s",
get_winbind_pipe_dir(), WINBINDD_SOCKET_NAME) > 0) {
unlink(path);
SAFE_FREE(path);
}
}
idmap_close();
trustdom_cache_shutdown();
gencache_stabilize();
#if 0
if (interactive) {
TALLOC_CTX *mem_ctx = talloc_init("end_description");
char *description = talloc_describe_all(mem_ctx);
DEBUG(3, ("tallocs left:\n%s\n", description));
talloc_destroy(mem_ctx);
}
#endif
if (is_parent) {
struct messaging_context *msg = winbind_messaging_context();
struct server_id self = messaging_server_id(msg);
serverid_deregister(self);
pidfile_unlink(lp_piddir(), "winbindd");
}
exit(0);
}
static struct server_id parse_dest(struct messaging_context *msg,
const char *dest)
{
struct server_id result = {-1};
pid_t pid;
/* Zero is a special return value for broadcast to all processes */
if (strequal(dest, "all")) {
return interpret_pid(MSG_BROADCAST_PID_STR);
}
/* Try self - useful for testing */
if (strequal(dest, "self")) {
return messaging_server_id(msg);
}
/* Fix winbind typo. */
if (strequal(dest, "winbind")) {
dest = "winbindd";
}
/* Check for numeric pid number */
result = interpret_pid(dest);
/* Zero isn't valid if not "all". */
if (result.pid && procid_valid(&result)) {
return result;
}
/* Look up other destinations in pidfile directory */
if ((pid = pidfile_pid(dest)) != 0) {
return pid_to_procid(pid);
}
fprintf(stderr,"Can't find pid for destination '%s'\n", dest);
return result;
}
void remove_pending_lock_requests_by_mid_smb1(
struct smbd_server_connection *sconn, uint64_t mid)
{
struct blocking_lock_record *blr, *next = NULL;
for(blr = sconn->smb1.locks.blocking_lock_queue; blr; blr = next) {
files_struct *fsp;
struct byte_range_lock *br_lck;
next = blr->next;
if (blr->req->mid != mid) {
continue;
}
fsp = blr->fsp;
br_lck = brl_get_locks(talloc_tos(), fsp);
if (br_lck) {
DEBUG(10, ("remove_pending_lock_requests_by_mid_smb1 - "
"removing request type %d for file %s, %s\n",
blr->req->cmd, fsp_str_dbg(fsp),
fsp_fnum_dbg(fsp)));
brl_lock_cancel(br_lck,
blr->smblctx,
messaging_server_id(sconn->msg_ctx),
blr->offset,
blr->count,
blr->lock_flav,
blr);
TALLOC_FREE(br_lck);
}
blocking_lock_reply_error(blr,NT_STATUS_FILE_LOCK_CONFLICT);
DLIST_REMOVE(sconn->smb1.locks.blocking_lock_queue, blr);
TALLOC_FREE(blr);
}
}
static void terminate(struct messaging_context *msg)
{
DEBUG(0,("Got SIGTERM: going down...\n"));
/* Write out wins.dat file if samba is a WINS server */
wins_write_database(0,False);
/* Remove all SELF registered names from WINS */
release_wins_names();
/* Announce all server entries as 0 time-to-live, 0 type. */
announce_my_servers_removed();
/* If there was an async dns child - kill it. */
kill_async_dns_child();
gencache_stabilize();
serverid_deregister(messaging_server_id(msg));
pidfile_unlink();
exit(0);
}
bool smbd_scavenger_init(TALLOC_CTX *mem_ctx,
struct messaging_context *msg,
struct tevent_context *ev)
{
struct smbd_scavenger_state *state;
NTSTATUS status;
if (smbd_scavenger_state) {
DEBUG(10, ("smbd_scavenger_init called again\n"));
return true;
}
state = talloc_zero(mem_ctx, struct smbd_scavenger_state);
if (state == NULL) {
DEBUG(2, ("Out of memory\n"));
return false;
}
state->msg = msg;
state->ev = ev;
state->parent_id = messaging_server_id(msg);
status = messaging_register(msg, state, MSG_SMB_SCAVENGER,
smbd_scavenger_msg);
if (!NT_STATUS_IS_OK(status)) {
DEBUG(2, ("failed to register message handler: %s\n",
nt_errstr(status)));
goto fail;
}
smbd_scavenger_state = state;
return true;
fail:
talloc_free(state);
return false;
}
