1 /* NFSv4.1 client for Windows
2  * Copyright � 2012 The Regents of the University of Michigan
3  *
4  * Olga Kornievskaia <aglo@umich.edu>
5  * Casey Bodley <cbodley@umich.edu>
6  *
7  * This library is free software; you can redistribute it and/or modify it
8  * under the terms of the GNU Lesser General Public License as published by
9  * the Free Software Foundation; either version 2.1 of the License, or (at
10  * your option) any later version.
11  *
12  * This library is distributed in the hope that it will be useful, but
13  * without any warranty; without even the implied warranty of merchantability
14  * or fitness for a particular purpose.  See the GNU Lesser General Public
15  * License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public License
18  * along with this library; if not, write to the Free Software Foundation,
19  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA
20  */
21 
22 #include <windows.h>
23 #include <strsafe.h>
24 
25 #include "nfs41_ops.h"
26 #include "delegation.h"
27 #include "nfs41_callback.h"
28 #include "daemon_debug.h"
29 
30 
31 #define CBSLVL 2 /* dprintf level for callback server logging */
32 
33 
34 static const char g_server_tag[] = "ms-nfs41-callback";
35 
36 
37 /* callback session */
38 static void replay_cache_write(
39     IN nfs41_cb_session *session,
40     IN struct cb_compound_args *args,
41     IN struct cb_compound_res *res,
42     IN bool_t cachethis);
43 
44 void nfs41_callback_session_init(
45     IN nfs41_session *session)
46 {
47     /* initialize the replay cache with status NFS4ERR_SEQ_MISORDERED */
48     struct cb_compound_res res = { 0 };
49     StringCchCopyA(res.tag.str, CB_COMPOUND_MAX_TAG, g_server_tag);
50     res.tag.len = sizeof(g_server_tag);
51     res.status = NFS4ERR_SEQ_MISORDERED;
52 
53     session->cb_session.cb_sessionid = session->session_id;
54 
55     replay_cache_write(&session->cb_session, NULL, &res, FALSE);
56 }
57 
58 
59 /* OP_CB_LAYOUTRECALL */
60 static enum_t handle_cb_layoutrecall(
61     IN nfs41_rpc_clnt *rpc_clnt,
62     IN struct cb_layoutrecall_args *args,
63     OUT struct cb_layoutrecall_res *res)
64 {
65     enum pnfs_status status;
66 
67     status = pnfs_file_layout_recall(rpc_clnt->client, args);
68     switch (status) {
69     case PNFS_PENDING:
70         /* not enough information to process the recall yet */
71         res->status = NFS4ERR_DELAY;
72         break;
73     default:
74         /* forgetful model for layout recalls */
75         res->status = NFS4ERR_NOMATCHING_LAYOUT;
76         break;
77     }
78 
79     dprintf(CBSLVL, "  OP_CB_LAYOUTRECALL { %s, %s, recall %u } %s\n",
80         pnfs_layout_type_string(args->type),
81         pnfs_iomode_string(args->iomode), args->recall.type,
82         nfs_error_string(res->status));
83     return res->status;
84 }
85 
86 /* OP_CB_RECALL_SLOT */
87 static enum_t handle_cb_recall_slot(
88     IN nfs41_rpc_clnt *rpc_clnt,
89     IN struct cb_recall_slot_args *args,
90     OUT struct cb_recall_slot_res *res)
91 {
92     res->status = nfs41_session_recall_slot(rpc_clnt->client->session,
93         args->target_highest_slotid);
94 
95     dprintf(CBSLVL, "  OP_CB_RECALL_SLOT { %u } %s\n",
96         args->target_highest_slotid, nfs_error_string(res->status));
97     return res->status;
98 }
99 
100 /* OP_CB_SEQUENCE */
101 static enum_t handle_cb_sequence(
102     IN nfs41_rpc_clnt *rpc_clnt,
103     IN struct cb_sequence_args *args,
104     OUT struct cb_sequence_res *res,
105     OUT nfs41_cb_session **session_out,
106     OUT bool_t *cachethis)
107 {
108     nfs41_cb_session *cb_session = &rpc_clnt->client->session->cb_session;
109     uint32_t status = NFS4_OK;
110     res->status = NFS4_OK;
111 
112     *session_out = cb_session;
113 
114     /* validate the sessionid */
115     if (memcmp(cb_session->cb_sessionid, args->sessionid,
116             NFS4_SESSIONID_SIZE)) {
117         eprintf("[cb] received sessionid doesn't match session\n");
118         res->status = NFS4ERR_BADSESSION;
119         goto out;
120     }
121 
122     /* we only support 1 slot for the back channel so slotid MUST be 0 */
123     if (args->slotid != 0) {
124         eprintf("[cb] received unexpected slotid=%d\n", args->slotid);
125         res->status = NFS4ERR_BADSLOT;
126         goto out;
127     }
128     if (args->highest_slotid != 0) {
129         eprintf("[cb] received unexpected highest_slotid=%d\n",
130             args->highest_slotid);
131         res->status = NFS4ERR_BAD_HIGH_SLOT;
132         goto out;
133     }
134 
135     /* check for a retry with the same seqid */
136     if (args->sequenceid == cb_session->cb_seqnum) {
137         if (!cb_session->replay.res.length) {
138             /* return success for sequence, but fail the next operation */
139             res->status = NFS4_OK;
140             status = NFS4ERR_RETRY_UNCACHED_REP;
141         } else {
142             /* return NFS4ERR_SEQ_FALSE_RETRY for all replays; if the retry
143              * turns out to be valid, this response will be replaced anyway */
144             status = res->status = NFS4ERR_SEQ_FALSE_RETRY;
145         }
146         goto out;
147     }
148 
149     /* error on any unexpected seqids */
150     if (args->sequenceid != cb_session->cb_seqnum+1) {
151         eprintf("[cb] bad received seq#=%d, expected=%d\n",
152             args->sequenceid, cb_session->cb_seqnum+1);
153         res->status = NFS4ERR_SEQ_MISORDERED;
154         goto out;
155     }
156 
157     cb_session->cb_seqnum = args->sequenceid;
158     *cachethis = args->cachethis;
159 
160     memcpy(res->ok.sessionid, args->sessionid, NFS4_SESSIONID_SIZE);
161     res->ok.sequenceid = args->sequenceid;
162     res->ok.slotid = args->slotid;
163     res->ok.highest_slotid = args->highest_slotid;
164     res->ok.target_highest_slotid = args->highest_slotid;
165 
166 out:
167     dprintf(CBSLVL, "  OP_CB_SEQUENCE { seqid %u, slot %u, cachethis %d } "
168         "%s\n", args->sequenceid, args->slotid, args->cachethis,
169         nfs_error_string(res->status));
170     return status;
171 }
172 
173 /* OP_CB_GETATTR */
174 static enum_t handle_cb_getattr(
175     IN nfs41_rpc_clnt *rpc_clnt,
176     IN struct cb_getattr_args *args,
177     OUT struct cb_getattr_res *res)
178 {
179     /* look up cached attributes for the given filehandle */
180     res->status = nfs41_delegation_getattr(rpc_clnt->client,
181         &args->fh, &args->attr_request, &res->info);
182     return res->status;
183 }
184 
185 /* OP_CB_RECALL */
186 static enum_t handle_cb_recall(
187     IN nfs41_rpc_clnt *rpc_clnt,
188     IN struct cb_recall_args *args,
189     OUT struct cb_recall_res *res)
190 {
191     /* return the delegation asynchronously */
192     res->status = nfs41_delegation_recall(rpc_clnt->client,
193         &args->fh, &args->stateid, args->truncate);
194     return res->status;
195 }
196 
197 /* OP_CB_NOTIFY_DEVICEID */
198 static enum_t handle_cb_notify_deviceid(
199     IN nfs41_rpc_clnt *rpc_clnt,
200     IN struct cb_notify_deviceid_args *args,
201     OUT struct cb_notify_deviceid_res *res)
202 {
203     uint32_t i;
204     for (i = 0; i < args->change_count; i++) {
205         pnfs_file_device_notify(rpc_clnt->client->devices,
206             &args->change_list[i]);
207     }
208     res->status = NFS4_OK;
209     return res->status;
210 }
211 
212 static void replay_cache_write(
213     IN nfs41_cb_session *session,
214     IN OPTIONAL struct cb_compound_args *args,
215     IN struct cb_compound_res *res,
216     IN bool_t cachethis)
217 {
218     XDR xdr;
219     uint32_t i;
220 
221     session->replay.arg.length = 0;
222     session->replay.res.length = 0;
223 
224     /* encode the reply directly into the replay cache */
225     xdrmem_create(&xdr, (char*)session->replay.res.buffer,
226         NFS41_MAX_SERVER_CACHE, XDR_ENCODE);
227 
228     /* always try to cache the result */
229     if (proc_cb_compound_res(&xdr, res)) {
230         session->replay.res.length = XDR_GETPOS(&xdr);
231 
232         if (args) {
233             /* encode the arguments into the request cache */
234             xdrmem_create(&xdr, (char*)session->replay.arg.buffer,
235                 NFS41_MAX_SERVER_CACHE, XDR_ENCODE);
236 
237             if (proc_cb_compound_args(&xdr, args))
238                 session->replay.arg.length = XDR_GETPOS(&xdr);
239         }
240     } else if (cachethis) {
241         /* on failure, only return errors if caching was requested */
242         res->status = NFS4ERR_REP_TOO_BIG_TO_CACHE;
243 
244         /* find the first operation that failed to encode */
245         for (i = 0; i < res->resarray_count; i++) {
246             if (!res->resarray[i].xdr_ok) {
247                 res->resarray[i].res.status = NFS4ERR_REP_TOO_BIG_TO_CACHE;
248                 res->resarray_count = i + 1;
249                 break;
250             }
251         }
252     }
253 }
254 
255 static bool_t replay_validate_args(
256     IN struct cb_compound_args *args,
257     IN const struct replay_cache *cache)
258 {
259     char buffer[NFS41_MAX_SERVER_CACHE];
260     XDR xdr;
261 
262     /* encode the current arguments into a temporary buffer */
263     xdrmem_create(&xdr, buffer, NFS41_MAX_SERVER_CACHE, XDR_ENCODE);
264 
265     if (!proc_cb_compound_args(&xdr, args))
266         return FALSE;
267 
268     /* must match the cached length */
269     if (XDR_GETPOS(&xdr) != cache->length)
270         return FALSE;
271 
272     /* must match the cached buffer contents */
273     return memcmp(cache->buffer, buffer, cache->length) == 0;
274 }
275 
276 static bool_t replay_validate_ops(
277     IN const struct cb_compound_args *args,
278     IN const struct cb_compound_res *res)
279 {
280     uint32_t i;
281     for (i = 0; i < res->resarray_count; i++) {
282         /* can't have more operations than the request */
283         if (i >= args->argarray_count)
284             return FALSE;
285 
286         /* each opnum must match the request */
287         if (args->argarray[i].opnum != res->resarray[i].opnum)
288             return FALSE;
289 
290         if (res->resarray[i].res.status)
291             break;
292     }
293     return TRUE;
294 }
295 
296 static int replay_cache_read(
297     IN nfs41_cb_session *session,
298     IN struct cb_compound_args *args,
299     OUT struct cb_compound_res **res_out)
300 {
301     XDR xdr;
302     struct cb_compound_res *replay;
303     struct cb_compound_res *res = *res_out;
304     uint32_t status = NFS4_OK;
305 
306     replay = calloc(1, sizeof(struct cb_compound_res));
307     if (replay == NULL) {
308         eprintf("[cb] failed to allocate replay buffer\n");
309         status = NFS4ERR_SERVERFAULT;
310         goto out;
311     }
312 
313     /* decode the response from the replay cache */
314     xdrmem_create(&xdr, (char*)session->replay.res.buffer,
315         NFS41_MAX_SERVER_CACHE, XDR_DECODE);
316     if (!proc_cb_compound_res(&xdr, replay)) {
317         eprintf("[cb] failed to decode replay buffer\n");
318         status = NFS4ERR_SEQ_FALSE_RETRY;
319         goto out_free_replay;
320     }
321 
322     /* if we cached the arguments, use them to validate the retry */
323     if (session->replay.arg.length) {
324         if (!replay_validate_args(args, &session->replay.arg)) {
325             eprintf("[cb] retry attempt with different arguments\n");
326             status = NFS4ERR_SEQ_FALSE_RETRY;
327             goto out_free_replay;
328         }
329     } else { /* otherwise, comparing opnums is the best we can do */
330         if (!replay_validate_ops(args, replay)) {
331             eprintf("[cb] retry attempt with different operations\n");
332             status = NFS4ERR_SEQ_FALSE_RETRY;
333             goto out_free_replay;
334         }
335     }
336 
337     /* free previous response and replace it with the replay */
338     xdr.x_op = XDR_FREE;
339     proc_cb_compound_res(&xdr, res);
340 
341     dprintf(2, "[cb] retry: returning cached response\n");
342 
343     *res_out = replay;
344 out:
345     return status;
346 
347 out_free_replay:
348     xdr.x_op = XDR_FREE;
349     proc_cb_compound_res(&xdr, replay);
350     goto out;
351 }
352 
353 /* CB_COMPOUND */
354 static void handle_cb_compound(nfs41_rpc_clnt *rpc_clnt, cb_req *req, struct cb_compound_res **reply)
355 {
356     struct cb_compound_args args = { 0 };
357     struct cb_compound_res *res = NULL;
358     struct cb_argop *argop;
359     struct cb_resop *resop;
360     XDR *xdr = (XDR*)req->xdr;
361     nfs41_cb_session *session = NULL;
362     bool_t cachethis = FALSE;
363     uint32_t i, status = NFS4_OK;
364 
365     dprintf(CBSLVL, "--> handle_cb_compound()\n");
366 
367     /* decode the arguments */
368     if (!proc_cb_compound_args(xdr, &args)) {
369         status = NFS4ERR_BADXDR;
370         eprintf("failed to decode compound arguments\n");
371     }
372 
373     /* allocate the compound results */
374     res = calloc(1, sizeof(struct cb_compound_res));
375     if (res == NULL) {
376         status = NFS4ERR_SERVERFAULT;
377         goto out;
378     }
379     res->status = status;
380     StringCchCopyA(res->tag.str, CB_COMPOUND_MAX_TAG, g_server_tag);
381     res->tag.str[CB_COMPOUND_MAX_TAG-1] = 0;
382     res->tag.len = (uint32_t)strlen(res->tag.str);
383     res->resarray = calloc(args.argarray_count, sizeof(struct cb_resop));
384     if (res->resarray == NULL) {
385         res->status = NFS4ERR_SERVERFAULT;
386         goto out;
387     }
388 
389     dprintf(CBSLVL, "CB_COMPOUND('%s', %u)\n", args.tag.str, args.argarray_count);
390     if (args.minorversion != 1) {
391         res->status = NFS4ERR_MINOR_VERS_MISMATCH; //XXXXX
392         eprintf("args.minorversion %u != 1\n", args.minorversion);
393         goto out;
394     }
395 
396     /* handle each operation in the compound */
397     for (i = 0; i < args.argarray_count && res->status == NFS4_OK; i++) {
398         argop = &args.argarray[i];
399         resop = &res->resarray[i];
400         resop->opnum = argop->opnum;
401         res->resarray_count++;
402 
403         /* 20.9.3: The error NFS4ERR_SEQUENCE_POS MUST be returned
404          * when CB_SEQUENCE is found in any position in a CB_COMPOUND
405          * beyond the first.  If any other operation is in the first
406          * position of CB_COMPOUND, NFS4ERR_OP_NOT_IN_SESSION MUST
407          * be returned.
408          */
409         if (i == 0 && argop->opnum != OP_CB_SEQUENCE) {
410             res->status = resop->res.status = NFS4ERR_OP_NOT_IN_SESSION;
411             break;
412         }
413         if (i != 0 && argop->opnum == OP_CB_SEQUENCE) {
414             res->status = resop->res.status = NFS4ERR_SEQUENCE_POS;
415             break;
416         }
417         if (status == NFS4ERR_RETRY_UNCACHED_REP) {
418             res->status = resop->res.status = status;
419             break;
420         }
421 
422         switch (argop->opnum) {
423         case OP_CB_LAYOUTRECALL:
424             dprintf(1, "OP_CB_LAYOUTRECALL\n");
425             res->status = handle_cb_layoutrecall(rpc_clnt,
426                 &argop->args.layoutrecall, &resop->res.layoutrecall);
427             break;
428         case OP_CB_RECALL_SLOT:
429             dprintf(1, "OP_CB_RECALL_SLOT\n");
430             res->status = handle_cb_recall_slot(rpc_clnt,
431                 &argop->args.recall_slot, &resop->res.recall_slot);
432             break;
433         case OP_CB_SEQUENCE:
434             dprintf(1, "OP_CB_SEQUENCE\n");
435             status = handle_cb_sequence(rpc_clnt, &argop->args.sequence,
436                 &resop->res.sequence, &session, &cachethis);
437 
438             if (status == NFS4ERR_SEQ_FALSE_RETRY) {
439                 /* replace the current results with the cached response */
440                 status = replay_cache_read(session, &args, &res);
441                 if (status) res->status = status;
442                 goto out;
443             }
444 
445             if (status == NFS4_OK)
446                 res->status = resop->res.sequence.status;
447             break;
448         case OP_CB_GETATTR:
449             dprintf(1, "OP_CB_GETATTR\n");
450             res->status = handle_cb_getattr(rpc_clnt,
451                 &argop->args.getattr, &resop->res.getattr);
452             break;
453         case OP_CB_RECALL:
454             dprintf(1, "OP_CB_RECALL\n");
455             res->status = handle_cb_recall(rpc_clnt,
456                 &argop->args.recall, &resop->res.recall);
457             break;
458         case OP_CB_NOTIFY:
459             dprintf(1, "OP_CB_NOTIFY\n");
460             res->status = NFS4ERR_NOTSUPP;
461             break;
462         case OP_CB_PUSH_DELEG:
463             dprintf(1, "OP_CB_PUSH_DELEG\n");
464             res->status = NFS4ERR_NOTSUPP;
465             break;
466         case OP_CB_RECALL_ANY:
467             dprintf(1, "OP_CB_RECALL_ANY\n");
468             res->status = NFS4ERR_NOTSUPP;
469             break;
470         case OP_CB_RECALLABLE_OBJ_AVAIL:
471             dprintf(1, "OP_CB_RECALLABLE_OBJ_AVAIL\n");
472             res->status = NFS4ERR_NOTSUPP;
473             break;
474         case OP_CB_WANTS_CANCELLED:
475             dprintf(1, "OP_CB_WANTS_CANCELLED\n");
476             res->status = NFS4ERR_NOTSUPP;
477             break;
478         case OP_CB_NOTIFY_LOCK:
479             dprintf(1, "OP_CB_NOTIFY_LOCK\n");
480             res->status = NFS4ERR_NOTSUPP;
481             break;
482         case OP_CB_NOTIFY_DEVICEID:
483             dprintf(1, "OP_CB_NOTIFY_DEVICEID\n");
484             res->status = NFS4_OK;
485             break;
486         case OP_CB_ILLEGAL:
487             dprintf(1, "OP_CB_ILLEGAL\n");
488             res->status = NFS4ERR_NOTSUPP;
489             break;
490         default:
491             eprintf("operation %u not supported\n", argop->opnum);
492             res->status = NFS4ERR_NOTSUPP;
493             break;
494         }
495     }
496 
497     /* always attempt to cache the reply */
498     if (session)
499         replay_cache_write(session, &args, res, cachethis);
500 out:
501     /* free the arguments */
502     xdr->x_op = XDR_FREE;
503     proc_cb_compound_args(xdr, &args);
504 
505     *reply = res;
506     dprintf(CBSLVL, "<-- handle_cb_compound() returning %s (%u results)\n",
507         nfs_error_string(res ? res->status : status),
508         res ? res->resarray_count : 0);
509 }
510 
511 #ifdef __REACTOS__
512 int nfs41_handle_callback(void *rpc_clnt, void *cb, void * dummy)
513 {
514     struct cb_compound_res **reply = dummy;
515 #else
516 int nfs41_handle_callback(void *rpc_clnt, void *cb, struct cb_compound_res **reply)
517 {
518 #endif
519     nfs41_rpc_clnt *rpc = (nfs41_rpc_clnt *)rpc_clnt;
520     cb_req *request = (cb_req *)cb;
521     uint32_t status = 0;
522 
523     dprintf(1, "nfs41_handle_callback: received call\n");
524     if (request->rq_prog != NFS41_RPC_CBPROGRAM) {
525         eprintf("invalid rpc program %u\n", request->rq_prog);
526         status = 2;
527         goto out;
528     }
529 
530     switch (request->rq_proc) {
531     case CB_NULL:
532         dprintf(1, "CB_NULL\n");
533         break;
534 
535     case CB_COMPOUND:
536         dprintf(1, "CB_COMPOUND\n");
537         handle_cb_compound(rpc, request, reply);
538         break;
539 
540     default:
541         dprintf(1, "invalid rpc procedure %u\n", request->rq_proc);
542         status = 3;
543         goto out;
544     }
545 out:
546     return status;
547 }
548