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;
83 /* the extra reference here is to ensure that the req
84 structure is not destroyed when the async request reply is
85 sent, which would cause problems with the other ntvfs
87 talloc_reference(msg, req);
88 ntvfs_async_setup(pwait->req, pwait);
89 talloc_unlink(msg, req);
94 receive a timeout on a message wait
96 static void pvfs_wait_timeout(struct tevent_context *ev,
97 struct tevent_timer *te, struct timeval t,
100 struct pvfs_wait *pwait = talloc_get_type(private_data,
102 struct ntvfs_request *req = pwait->req;
104 pwait->reason = PVFS_WAIT_TIMEOUT;
106 talloc_increase_ref_count(req);
107 ntvfs_async_setup(pwait->req, pwait);
113 destroy a pending wait
115 static int pvfs_wait_destructor(struct pvfs_wait *pwait)
117 if (pwait->msg_type != -1) {
118 messaging_deregister(pwait->msg_ctx, pwait->msg_type, pwait);
120 DLIST_REMOVE(pwait->pvfs->wait_list, pwait);
125 setup a request to wait on a message of type msg_type, with a
126 timeout (given as an expiry time)
128 the return value is a handle. To stop waiting talloc_free this
131 if msg_type == -1 then no message is registered, and it is assumed
132 that the caller handles any messaging setup needed
134 struct pvfs_wait *pvfs_wait_message(struct pvfs_state *pvfs,
135 struct ntvfs_request *req,
137 struct timeval end_time,
138 void (*fn)(void *, enum pvfs_wait_notice),
141 struct pvfs_wait *pwait;
143 pwait = talloc(pvfs, struct pvfs_wait);
148 pwait->private_data = private_data;
150 pwait->msg_ctx = pvfs->ntvfs->ctx->msg_ctx;
151 pwait->ev = pvfs->ntvfs->ctx->event_ctx;
152 pwait->msg_type = msg_type;
153 pwait->req = talloc_reference(pwait, req);
156 if (!timeval_is_zero(&end_time)) {
158 event_add_timed(pwait->ev, pwait, end_time, pvfs_wait_timeout, pwait);
161 /* register with the messaging subsystem for this message
163 if (msg_type != -1) {
164 messaging_register(pwait->msg_ctx,
170 /* tell the main smb server layer that we will be replying
172 req->async_states->state |= NTVFS_ASYNC_STATE_ASYNC;
174 DLIST_ADD(pvfs->wait_list, pwait);
176 /* make sure we cleanup the timer and message handler */
177 talloc_set_destructor(pwait, pvfs_wait_destructor);
184 cancel an outstanding async request
186 NTSTATUS pvfs_cancel(struct ntvfs_module_context *ntvfs, struct ntvfs_request *req)
188 struct pvfs_state *pvfs = 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);