*/
#include "includes.h"
+#include "smbd/smbd.h"
#include "smbd/globals.h"
#include "librpc/gen_ndr/messaging.h"
change_to_root_user(); /* TODO: Possibly run all timed events as
* root */
- process_blocking_lock_queue();
+ process_blocking_lock_queue(sconn);
}
/****************************************************************************
next processing.
****************************************************************************/
-static bool recalc_brl_timeout(void)
+static bool recalc_brl_timeout(struct smbd_server_connection *sconn)
{
- struct smbd_server_connection *sconn = smbd_server_conn;
struct blocking_lock_record *blr;
struct timeval next_timeout;
int max_brl_timeout = lp_parm_int(-1, "brl", "recalctime", 5);
blr->blr_private = NULL;
/* Add a pending lock record for this. */
- status = brl_lock(smbd_messaging_context(),
+ status = brl_lock(req->sconn->msg_ctx,
br_lck,
smblctx,
- procid_self(),
+ sconn_server_id(req->sconn),
offset,
count,
lock_type == READ_LOCK ? PENDING_READ_LOCK : PENDING_WRITE_LOCK,
blr->req = talloc_move(blr, &req);
DLIST_ADD_END(sconn->smb1.locks.blocking_lock_queue, blr, struct blocking_lock_record *);
- recalc_brl_timeout();
+ recalc_brl_timeout(sconn);
/* Ensure we'll receive messages when this is unlocked. */
if (!sconn->smb1.locks.blocking_lock_unlock_state) {
- messaging_register(smbd_messaging_context(), NULL,
+ messaging_register(sconn->msg_ctx, NULL,
MSG_SMB_UNLOCK, received_unlock_msg);
sconn->smb1.locks.blocking_lock_unlock_state = true;
}
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 = procid_self();
+ fsp->last_lock_failure.context.pid =
+ sconn_server_id(fsp->conn->sconn);
fsp->last_lock_failure.start = blr->offset;
fsp->last_lock_failure.size = blr->count;
fsp->last_lock_failure.fnum = fsp->fnum;
}
reply_nterror(blr->req, status);
- if (!srv_send_smb(smbd_server_fd(), (char *)blr->req->outbuf,
+ 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.");
* request would never have been queued. JRA.
*/
- do_unlock(smbd_messaging_context(),
+ do_unlock(fsp->conn->sconn->msg_ctx,
fsp,
smblctx,
count,
*/
SCVAL(blr->req->outbuf,smb_com,SMBtrans2);
- if (!srv_send_smb(smbd_server_fd(),
+ if (!srv_send_smb(blr->req->sconn,
(char *)blr->req->outbuf,
true, blr->req->seqnum+1,
IS_CONN_ENCRYPTED(blr->fsp->conn),
* request would never have been queued. JRA.
*/
errno = 0;
- br_lck = do_lock(smbd_messaging_context(),
+ br_lck = do_lock(fsp->conn->sconn->msg_ctx,
fsp,
smblctx,
count,
{
char params[2];
NTSTATUS status;
- struct byte_range_lock *br_lck = do_lock(smbd_messaging_context(),
+ struct byte_range_lock *br_lck = do_lock(
+ blr->fsp->conn->sconn->msg_ctx,
blr->fsp,
blr->smblctx,
blr->count,
brl_lock_cancel(br_lck,
blr->smblctx,
- procid_self(),
+ sconn_server_id(sconn),
blr->offset,
blr->count,
blr->lock_flav,
Only called from the SMB1 cancel code.
*****************************************************************************/
-void remove_pending_lock_requests_by_mid_smb1(uint64_t mid)
+void remove_pending_lock_requests_by_mid_smb1(
+ struct smbd_server_connection *sconn, uint64_t mid)
{
- struct smbd_server_connection *sconn = smbd_server_conn;
struct blocking_lock_record *blr, *next = NULL;
for(blr = sconn->smb1.locks.blocking_lock_queue; blr; blr = next) {
brl_lock_cancel(br_lck,
blr->smblctx,
- procid_self(),
+ sconn_server_id(sconn),
blr->offset,
blr->count,
blr->lock_flav,
Currently only called from the SMB1 unix extensions POSIX lock code.
*****************************************************************************/
-bool blocking_lock_was_deferred_smb1(uint64_t mid)
+bool blocking_lock_was_deferred_smb1(
+ struct smbd_server_connection *sconn, uint64_t mid)
{
- struct smbd_server_connection *sconn = smbd_server_conn;
struct blocking_lock_record *blr, *next = NULL;
for(blr = sconn->smb1.locks.blocking_lock_queue; blr; blr = next) {
struct server_id server_id,
DATA_BLOB *data)
{
+ struct smbd_server_connection *sconn;
+
+ sconn = msg_ctx_to_sconn(msg);
+ if (sconn == NULL) {
+ DEBUG(1, ("could not find sconn\n"));
+ return;
+ }
+
DEBUG(10,("received_unlock_msg\n"));
- process_blocking_lock_queue();
+ process_blocking_lock_queue(sconn);
}
/****************************************************************************
Process the blocking lock queue. Note that this is only called as root.
*****************************************************************************/
-void process_blocking_lock_queue(void)
+void process_blocking_lock_queue(struct smbd_server_connection *sconn)
{
- struct smbd_server_connection *sconn = smbd_server_conn;
struct timeval tv_curr = timeval_current();
struct blocking_lock_record *blr, *next = NULL;
if (sconn->using_smb2) {
- process_blocking_lock_queue_smb2(tv_curr);
+ process_blocking_lock_queue_smb2(sconn, tv_curr);
return;
}
if (br_lck) {
brl_lock_cancel(br_lck,
blr->smblctx,
- procid_self(),
+ sconn_server_id(sconn),
blr->offset,
blr->count,
blr->lock_flav,
brl_lock_cancel(br_lck,
blr->smblctx,
- procid_self(),
+ sconn_server_id(sconn),
blr->offset,
blr->count,
blr->lock_flav,
}
}
- recalc_brl_timeout();
+ recalc_brl_timeout(sconn);
}
/****************************************************************************
struct server_id server_id,
DATA_BLOB *data)
{
- struct smbd_server_connection *sconn = smbd_server_conn;
+ struct smbd_server_connection *sconn;
NTSTATUS err;
const char *msg = (const char *)data->data;
struct blocking_lock_record *blr;
smb_panic("process_blocking_lock_cancel_message: bad msg");
}
+ sconn = msg_ctx_to_sconn(ctx);
+ if (sconn == NULL) {
+ DEBUG(1, ("could not find sconn\n"));
+ return;
+ }
+
memcpy(&blr, msg, sizeof(blr));
memcpy(&err, &msg[sizeof(blr)], sizeof(NTSTATUS));
unsigned char locktype,
NTSTATUS err)
{
- struct smbd_server_connection *sconn = smbd_server_conn;
+ 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(smbd_messaging_context(), NULL,
+ messaging_register(sconn->msg_ctx, NULL,
MSG_SMB_BLOCKING_LOCK_CANCEL,
process_blocking_lock_cancel_message);
memcpy(msg, &blr, sizeof(blr));
memcpy(&msg[sizeof(blr)], &err, sizeof(NTSTATUS));
- messaging_send_buf(smbd_messaging_context(), procid_self(),
+ messaging_send_buf(sconn->msg_ctx, sconn_server_id(sconn),
MSG_SMB_BLOCKING_LOCK_CANCEL,
(uint8 *)&msg, sizeof(msg));
git.samba.org / amitay / samba.git / blobdiff