2
Unix SMB/CIFS implementation.
4
POSIX NTVFS backend - async request wait routines
6
Copyright (C) Andrew Tridgell 2004
8
This program is free software; you can redistribute it and/or modify
9
it under the terms of the GNU General Public License as published by
10
the Free Software Foundation; either version 3 of the License, or
11
(at your option) any later version.
13
This program is distributed in the hope that it will be useful,
14
but WITHOUT ANY WARRANTY; without even the implied warranty of
15
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16
GNU General Public License for more details.
18
You should have received a copy of the GNU General Public License
19
along with this program. If not, see <http://www.gnu.org/licenses/>.
23
#include "lib/events/events.h"
24
#include "../lib/util/dlinklist.h"
25
#include "vfs_posix.h"
26
#include "smbd/service_stream.h"
27
#include "lib/messaging/irpc.h"
29
/* the context for a single wait instance */
31
struct pvfs_wait *next, *prev;
32
struct pvfs_state *pvfs;
33
void (*handler)(void *, enum pvfs_wait_notice);
36
struct messaging_context *msg_ctx;
37
struct tevent_context *ev;
38
struct ntvfs_request *req;
39
enum pvfs_wait_notice reason;
43
called from the ntvfs layer when we have requested setup of an async
44
call. this ensures that async calls runs with the right state of
45
previous ntvfs handlers in the chain (such as security context)
47
NTSTATUS pvfs_async_setup(struct ntvfs_module_context *ntvfs,
48
struct ntvfs_request *req, void *private_data)
50
struct pvfs_wait *pwait = talloc_get_type(private_data,
52
pwait->handler(pwait->private_data, pwait->reason);
57
receive a completion message for a wait
59
static void pvfs_wait_dispatch(struct messaging_context *msg,
60
void *private_data, uint32_t msg_type,
61
struct server_id src, DATA_BLOB *data)
63
struct pvfs_wait *pwait = talloc_get_type(private_data,
65
struct ntvfs_request *req;
68
/* we need to check that this one is for us. See
69
messaging_send_ptr() for the other side of this.
71
if (data->length == sizeof(void *)) {
73
pp = (void **)data->data;
76
if (p == NULL || p != pwait->private_data) {
80
pwait->reason = PVFS_WAIT_EVENT;
82
/* the extra reference here is to ensure that the req
83
structure is not destroyed when the async request reply is
84
sent, which would cause problems with the other ntvfs
86
req = talloc_reference(msg, pwait->req);
87
ntvfs_async_setup(pwait->req, pwait);
88
talloc_unlink(msg, req);
93
receive a timeout on a message wait
95
static void pvfs_wait_timeout(struct tevent_context *ev,
96
struct tevent_timer *te, struct timeval t,
99
struct pvfs_wait *pwait = talloc_get_type(private_data,
101
struct ntvfs_request *req = pwait->req;
103
pwait->reason = PVFS_WAIT_TIMEOUT;
105
talloc_increase_ref_count(req);
106
ntvfs_async_setup(pwait->req, pwait);
112
destroy a pending wait
114
static int pvfs_wait_destructor(struct pvfs_wait *pwait)
116
if (pwait->msg_type != -1) {
117
messaging_deregister(pwait->msg_ctx, pwait->msg_type, pwait);
119
DLIST_REMOVE(pwait->pvfs->wait_list, pwait);
124
setup a request to wait on a message of type msg_type, with a
125
timeout (given as an expiry time)
127
the return value is a handle. To stop waiting talloc_free this
130
if msg_type == -1 then no message is registered, and it is assumed
131
that the caller handles any messaging setup needed
133
struct pvfs_wait *pvfs_wait_message(struct pvfs_state *pvfs,
134
struct ntvfs_request *req,
136
struct timeval end_time,
137
void (*fn)(void *, enum pvfs_wait_notice),
140
struct pvfs_wait *pwait;
142
pwait = talloc(pvfs, struct pvfs_wait);
147
pwait->private_data = private_data;
149
pwait->msg_ctx = pvfs->ntvfs->ctx->msg_ctx;
150
pwait->ev = pvfs->ntvfs->ctx->event_ctx;
151
pwait->msg_type = msg_type;
152
pwait->req = talloc_reference(pwait, req);
155
if (!timeval_is_zero(&end_time)) {
157
event_add_timed(pwait->ev, pwait, end_time, pvfs_wait_timeout, pwait);
160
/* register with the messaging subsystem for this message
162
if (msg_type != -1) {
163
messaging_register(pwait->msg_ctx,
169
/* tell the main smb server layer that we will be replying
171
req->async_states->state |= NTVFS_ASYNC_STATE_ASYNC;
173
DLIST_ADD(pvfs->wait_list, pwait);
175
/* make sure we cleanup the timer and message handler */
176
talloc_set_destructor(pwait, pvfs_wait_destructor);
183
cancel an outstanding async request
185
NTSTATUS pvfs_cancel(struct ntvfs_module_context *ntvfs, struct ntvfs_request *req)
187
struct pvfs_state *pvfs = talloc_get_type(ntvfs->private_data,
189
struct pvfs_wait *pwait;
191
for (pwait=pvfs->wait_list;pwait;pwait=pwait->next) {
192
if (pwait->req == req) {
193
/* trigger a cancel on the request */
194
pwait->reason = PVFS_WAIT_CANCEL;
195
ntvfs_async_setup(pwait->req, pwait);
200
return NT_STATUS_DOS(ERRDOS, ERRcancelviolation);