CRED: Wrap current->cred and a few other accessors
[linux-2.6.git] / fs / smbfs / request.c
1 /*
2  *  request.c
3  *
4  *  Copyright (C) 2001 by Urban Widmark
5  *
6  *  Please add a note about your changes to smbfs in the ChangeLog file.
7  */
8
9 #include <linux/kernel.h>
10 #include <linux/types.h>
11 #include <linux/fs.h>
12 #include <linux/slab.h>
13 #include <linux/net.h>
14 #include <linux/sched.h>
15
16 #include <linux/smb_fs.h>
17 #include <linux/smbno.h>
18 #include <linux/smb_mount.h>
19
20 #include "smb_debug.h"
21 #include "request.h"
22 #include "proto.h"
23
24 /* #define SMB_SLAB_DEBUG       (SLAB_RED_ZONE | SLAB_POISON) */
25 #define SMB_SLAB_DEBUG  0
26
27 /* cache for request structures */
28 static struct kmem_cache *req_cachep;
29
30 static int smb_request_send_req(struct smb_request *req);
31
32 /*
33   /proc/slabinfo:
34   name, active, num, objsize, active_slabs, num_slaps, #pages
35 */
36
37
38 int smb_init_request_cache(void)
39 {
40         req_cachep = kmem_cache_create("smb_request",
41                                        sizeof(struct smb_request), 0,
42                                        SMB_SLAB_DEBUG | SLAB_HWCACHE_ALIGN,
43                                        NULL);
44         if (req_cachep == NULL)
45                 return -ENOMEM;
46
47         return 0;
48 }
49
50 void smb_destroy_request_cache(void)
51 {
52         kmem_cache_destroy(req_cachep);
53 }
54
55 /*
56  * Allocate and initialise a request structure
57  */
58 static struct smb_request *smb_do_alloc_request(struct smb_sb_info *server,
59                                                 int bufsize)
60 {
61         struct smb_request *req;
62         unsigned char *buf = NULL;
63
64         req = kmem_cache_zalloc(req_cachep, GFP_KERNEL);
65         VERBOSE("allocating request: %p\n", req);
66         if (!req)
67                 goto out;
68
69         if (bufsize > 0) {
70                 buf = kmalloc(bufsize, GFP_NOFS);
71                 if (!buf) {
72                         kmem_cache_free(req_cachep, req);
73                         return NULL;
74                 }
75         }
76
77         req->rq_buffer = buf;
78         req->rq_bufsize = bufsize;
79         req->rq_server = server;
80         init_waitqueue_head(&req->rq_wait);
81         INIT_LIST_HEAD(&req->rq_queue);
82         atomic_set(&req->rq_count, 1);
83
84 out:
85         return req;
86 }
87
88 struct smb_request *smb_alloc_request(struct smb_sb_info *server, int bufsize)
89 {
90         struct smb_request *req = NULL;
91
92         for (;;) {
93                 atomic_inc(&server->nr_requests);
94                 if (atomic_read(&server->nr_requests) <= MAX_REQUEST_HARD) {
95                         req = smb_do_alloc_request(server, bufsize);
96                         if (req != NULL)
97                                 break;
98                 }
99
100 #if 0
101                 /*
102                  * Try to free up at least one request in order to stay
103                  * below the hard limit
104                  */
105                 if (nfs_try_to_free_pages(server))
106                         continue;
107
108                 if (fatal_signal_pending(current))
109                         return ERR_PTR(-ERESTARTSYS);
110                 current->policy = SCHED_YIELD;
111                 schedule();
112 #else
113                 /* FIXME: we want something like nfs does above, but that
114                    requires changes to all callers and can wait. */
115                 break;
116 #endif
117         }
118         return req;
119 }
120
121 static void smb_free_request(struct smb_request *req)
122 {
123         atomic_dec(&req->rq_server->nr_requests);
124         if (req->rq_buffer && !(req->rq_flags & SMB_REQ_STATIC))
125                 kfree(req->rq_buffer);
126         kfree(req->rq_trans2buffer);
127         kmem_cache_free(req_cachep, req);
128 }
129
130 /*
131  * What prevents a rget to race with a rput? The count must never drop to zero
132  * while it is in use. Only rput if it is ok that it is free'd.
133  */
134 static void smb_rget(struct smb_request *req)
135 {
136         atomic_inc(&req->rq_count);
137 }
138 void smb_rput(struct smb_request *req)
139 {
140         if (atomic_dec_and_test(&req->rq_count)) {
141                 list_del_init(&req->rq_queue);
142                 smb_free_request(req);
143         }
144 }
145
146 /* setup to receive the data part of the SMB */
147 static int smb_setup_bcc(struct smb_request *req)
148 {
149         int result = 0;
150         req->rq_rlen = smb_len(req->rq_header) + 4 - req->rq_bytes_recvd;
151
152         if (req->rq_rlen > req->rq_bufsize) {
153                 PARANOIA("Packet too large %d > %d\n",
154                          req->rq_rlen, req->rq_bufsize);
155                 return -ENOBUFS;
156         }
157
158         req->rq_iov[0].iov_base = req->rq_buffer;
159         req->rq_iov[0].iov_len  = req->rq_rlen;
160         req->rq_iovlen = 1;
161
162         return result;
163 }
164
165 /*
166  * Prepare a "normal" request structure.
167  */
168 static int smb_setup_request(struct smb_request *req)
169 {
170         int len = smb_len(req->rq_header) + 4;
171         req->rq_slen = len;
172
173         /* if we expect a data part in the reply we set the iov's to read it */
174         if (req->rq_resp_bcc)
175                 req->rq_setup_read = smb_setup_bcc;
176
177         /* This tries to support re-using the same request */
178         req->rq_bytes_sent = 0;
179         req->rq_rcls = 0;
180         req->rq_err = 0;
181         req->rq_errno = 0;
182         req->rq_fragment = 0;
183         kfree(req->rq_trans2buffer);
184         req->rq_trans2buffer = NULL;
185
186         return 0;
187 }
188
189 /*
190  * Prepare a transaction2 request structure
191  */
192 static int smb_setup_trans2request(struct smb_request *req)
193 {
194         struct smb_sb_info *server = req->rq_server;
195         int mparam, mdata;
196         static unsigned char padding[4];
197
198         /* I know the following is very ugly, but I want to build the
199            smb packet as efficiently as possible. */
200
201         const int smb_parameters = 15;
202         const int header = SMB_HEADER_LEN + 2 * smb_parameters + 2;
203         const int oparam = ALIGN(header + 3, sizeof(u32));
204         const int odata  = ALIGN(oparam + req->rq_lparm, sizeof(u32));
205         const int bcc = (req->rq_data ? odata + req->rq_ldata :
206                                         oparam + req->rq_lparm) - header;
207
208         if ((bcc + oparam) > server->opt.max_xmit)
209                 return -ENOMEM;
210         smb_setup_header(req, SMBtrans2, smb_parameters, bcc);
211
212         /*
213          * max parameters + max data + max setup == bufsize to make NT4 happy
214          * and not abort the transfer or split into multiple responses. It also
215          * makes smbfs happy as handling packets larger than the buffer size
216          * is extra work.
217          *
218          * OS/2 is probably going to hate me for this ...
219          */
220         mparam = SMB_TRANS2_MAX_PARAM;
221         mdata = req->rq_bufsize - mparam;
222
223         mdata = server->opt.max_xmit - mparam - 100;
224         if (mdata < 1024) {
225                 mdata = 1024;
226                 mparam = 20;
227         }
228
229 #if 0
230         /* NT/win2k has ~4k max_xmit, so with this we request more than it wants
231            to return as one SMB. Useful for testing the fragmented trans2
232            handling. */
233         mdata = 8192;
234 #endif
235
236         WSET(req->rq_header, smb_tpscnt, req->rq_lparm);
237         WSET(req->rq_header, smb_tdscnt, req->rq_ldata);
238         WSET(req->rq_header, smb_mprcnt, mparam);
239         WSET(req->rq_header, smb_mdrcnt, mdata);
240         WSET(req->rq_header, smb_msrcnt, 0);    /* max setup always 0 ? */
241         WSET(req->rq_header, smb_flags, 0);
242         DSET(req->rq_header, smb_timeout, 0);
243         WSET(req->rq_header, smb_pscnt, req->rq_lparm);
244         WSET(req->rq_header, smb_psoff, oparam - 4);
245         WSET(req->rq_header, smb_dscnt, req->rq_ldata);
246         WSET(req->rq_header, smb_dsoff, req->rq_data ? odata - 4 : 0);
247         *(req->rq_header + smb_suwcnt) = 0x01;          /* setup count */
248         *(req->rq_header + smb_suwcnt + 1) = 0x00;      /* reserved */
249         WSET(req->rq_header, smb_setup0, req->rq_trans2_command);
250
251         req->rq_iovlen = 2;
252         req->rq_iov[0].iov_base = (void *) req->rq_header;
253         req->rq_iov[0].iov_len = oparam;
254         req->rq_iov[1].iov_base = (req->rq_parm==NULL) ? padding : req->rq_parm;
255         req->rq_iov[1].iov_len = req->rq_lparm;
256         req->rq_slen = oparam + req->rq_lparm;
257
258         if (req->rq_data) {
259                 req->rq_iovlen += 2;
260                 req->rq_iov[2].iov_base = padding;
261                 req->rq_iov[2].iov_len = odata - oparam - req->rq_lparm;
262                 req->rq_iov[3].iov_base = req->rq_data;
263                 req->rq_iov[3].iov_len = req->rq_ldata;
264                 req->rq_slen = odata + req->rq_ldata;
265         }
266
267         /* always a data part for trans2 replies */
268         req->rq_setup_read = smb_setup_bcc;
269
270         return 0;
271 }
272
273 /*
274  * Add a request and tell smbiod to process it
275  */
276 int smb_add_request(struct smb_request *req)
277 {
278         long timeleft;
279         struct smb_sb_info *server = req->rq_server;
280         int result = 0;
281
282         smb_setup_request(req);
283         if (req->rq_trans2_command) {
284                 if (req->rq_buffer == NULL) {
285                         PARANOIA("trans2 attempted without response buffer!\n");
286                         return -EIO;
287                 }
288                 result = smb_setup_trans2request(req);
289         }
290         if (result < 0)
291                 return result;
292
293 #ifdef SMB_DEBUG_PACKET_SIZE
294         add_xmit_stats(req);
295 #endif
296
297         /* add 'req' to the queue of requests */
298         if (smb_lock_server_interruptible(server))
299                 return -EINTR;
300
301         /*
302          * Try to send the request as the process. If that fails we queue the
303          * request and let smbiod send it later.
304          */
305
306         /* FIXME: each server has a number on the maximum number of parallel
307            requests. 10, 50 or so. We should not allow more requests to be
308            active. */
309         if (server->mid > 0xf000)
310                 server->mid = 0;
311         req->rq_mid = server->mid++;
312         WSET(req->rq_header, smb_mid, req->rq_mid);
313
314         result = 0;
315         if (server->state == CONN_VALID) {
316                 if (list_empty(&server->xmitq))
317                         result = smb_request_send_req(req);
318                 if (result < 0) {
319                         /* Connection lost? */
320                         server->conn_error = result;
321                         server->state = CONN_INVALID;
322                 }
323         }
324         if (result != 1)
325                 list_add_tail(&req->rq_queue, &server->xmitq);
326         smb_rget(req);
327
328         if (server->state != CONN_VALID)
329                 smbiod_retry(server);
330
331         smb_unlock_server(server);
332
333         smbiod_wake_up();
334
335         timeleft = wait_event_interruptible_timeout(req->rq_wait,
336                                     req->rq_flags & SMB_REQ_RECEIVED, 30*HZ);
337         if (!timeleft || signal_pending(current)) {
338                 /*
339                  * On timeout or on interrupt we want to try and remove the
340                  * request from the recvq/xmitq.
341                  * First check if the request is still part of a queue. (May
342                  * have been removed by some error condition)
343                  */
344                 smb_lock_server(server);
345                 if (!list_empty(&req->rq_queue)) {
346                         list_del_init(&req->rq_queue);
347                         smb_rput(req);
348                 }
349                 smb_unlock_server(server);
350         }
351
352         if (!timeleft) {
353                 PARANOIA("request [%p, mid=%d] timed out!\n",
354                          req, req->rq_mid);
355                 VERBOSE("smb_com:  %02x\n", *(req->rq_header + smb_com));
356                 VERBOSE("smb_rcls: %02x\n", *(req->rq_header + smb_rcls));
357                 VERBOSE("smb_flg:  %02x\n", *(req->rq_header + smb_flg));
358                 VERBOSE("smb_tid:  %04x\n", WVAL(req->rq_header, smb_tid));
359                 VERBOSE("smb_pid:  %04x\n", WVAL(req->rq_header, smb_pid));
360                 VERBOSE("smb_uid:  %04x\n", WVAL(req->rq_header, smb_uid));
361                 VERBOSE("smb_mid:  %04x\n", WVAL(req->rq_header, smb_mid));
362                 VERBOSE("smb_wct:  %02x\n", *(req->rq_header + smb_wct));
363
364                 req->rq_rcls = ERRSRV;
365                 req->rq_err  = ERRtimeout;
366
367                 /* Just in case it was "stuck" */
368                 smbiod_wake_up();
369         }
370         VERBOSE("woke up, rcls=%d\n", req->rq_rcls);
371
372         if (req->rq_rcls != 0)
373                 req->rq_errno = smb_errno(req);
374         if (signal_pending(current))
375                 req->rq_errno = -ERESTARTSYS;
376         return req->rq_errno;
377 }
378
379 /*
380  * Send a request and place it on the recvq if successfully sent.
381  * Must be called with the server lock held.
382  */
383 static int smb_request_send_req(struct smb_request *req)
384 {
385         struct smb_sb_info *server = req->rq_server;
386         int result;
387
388         if (req->rq_bytes_sent == 0) {
389                 WSET(req->rq_header, smb_tid, server->opt.tid);
390                 WSET(req->rq_header, smb_pid, 1);
391                 WSET(req->rq_header, smb_uid, server->opt.server_uid);
392         }
393
394         result = smb_send_request(req);
395         if (result < 0 && result != -EAGAIN)
396                 goto out;
397
398         result = 0;
399         if (!(req->rq_flags & SMB_REQ_TRANSMITTED))
400                 goto out;
401
402         list_move_tail(&req->rq_queue, &server->recvq);
403         result = 1;
404 out:
405         return result;
406 }
407
408 /*
409  * Sends one request for this server. (smbiod)
410  * Must be called with the server lock held.
411  * Returns: <0 on error
412  *           0 if no request could be completely sent
413  *           1 if all data for one request was sent
414  */
415 int smb_request_send_server(struct smb_sb_info *server)
416 {
417         struct list_head *head;
418         struct smb_request *req;
419         int result;
420
421         if (server->state != CONN_VALID)
422                 return 0;
423
424         /* dequeue first request, if any */
425         req = NULL;
426         head = server->xmitq.next;
427         if (head != &server->xmitq) {
428                 req = list_entry(head, struct smb_request, rq_queue);
429         }
430         if (!req)
431                 return 0;
432
433         result = smb_request_send_req(req);
434         if (result < 0) {
435                 server->conn_error = result;
436                 list_move(&req->rq_queue, &server->xmitq);
437                 result = -EIO;
438                 goto out;
439         }
440
441 out:
442         return result;
443 }
444
445 /*
446  * Try to find a request matching this "mid". Typically the first entry will
447  * be the matching one.
448  */
449 static struct smb_request *find_request(struct smb_sb_info *server, int mid)
450 {
451         struct list_head *tmp;
452         struct smb_request *req = NULL;
453
454         list_for_each(tmp, &server->recvq) {
455                 req = list_entry(tmp, struct smb_request, rq_queue);
456                 if (req->rq_mid == mid) {
457                         break;
458                 }
459                 req = NULL;
460         }
461
462         if (!req) {
463                 VERBOSE("received reply with mid %d but no request!\n",
464                         WVAL(server->header, smb_mid));
465                 server->rstate = SMB_RECV_DROP;
466         }
467
468         return req;
469 }
470
471 /*
472  * Called when we have read the smb header and believe this is a response.
473  */
474 static int smb_init_request(struct smb_sb_info *server, struct smb_request *req)
475 {
476         int hdrlen, wct;
477
478         memcpy(req->rq_header, server->header, SMB_HEADER_LEN);
479
480         wct = *(req->rq_header + smb_wct);
481         if (wct > 20) { 
482                 PARANOIA("wct too large, %d > 20\n", wct);
483                 server->rstate = SMB_RECV_DROP;
484                 return 0;
485         }
486
487         req->rq_resp_wct = wct;
488         hdrlen = SMB_HEADER_LEN + wct*2 + 2;
489         VERBOSE("header length: %d   smb_wct: %2d\n", hdrlen, wct);
490
491         req->rq_bytes_recvd = SMB_HEADER_LEN;
492         req->rq_rlen = hdrlen;
493         req->rq_iov[0].iov_base = req->rq_header;
494         req->rq_iov[0].iov_len  = hdrlen;
495         req->rq_iovlen = 1;
496         server->rstate = SMB_RECV_PARAM;
497
498 #ifdef SMB_DEBUG_PACKET_SIZE
499         add_recv_stats(smb_len(server->header));
500 #endif
501         return 0;
502 }
503
504 /*
505  * Reads the SMB parameters
506  */
507 static int smb_recv_param(struct smb_sb_info *server, struct smb_request *req)
508 {
509         int result;
510
511         result = smb_receive(server, req);
512         if (result < 0)
513                 return result;
514         if (req->rq_bytes_recvd < req->rq_rlen)
515                 return 0;
516
517         VERBOSE("result: %d   smb_bcc:  %04x\n", result,
518                 WVAL(req->rq_header, SMB_HEADER_LEN +
519                      (*(req->rq_header + smb_wct) * 2)));
520
521         result = 0;
522         req->rq_iov[0].iov_base = NULL;
523         req->rq_rlen = 0;
524         if (req->rq_callback)
525                 req->rq_callback(req);
526         else if (req->rq_setup_read)
527                 result = req->rq_setup_read(req);
528         if (result < 0) {
529                 server->rstate = SMB_RECV_DROP;
530                 return result;
531         }
532
533         server->rstate = req->rq_rlen > 0 ? SMB_RECV_DATA : SMB_RECV_END;
534
535         req->rq_bytes_recvd = 0;        // recvd out of the iov
536
537         VERBOSE("rlen: %d\n", req->rq_rlen);
538         if (req->rq_rlen < 0) {
539                 PARANOIA("Parameters read beyond end of packet!\n");
540                 server->rstate = SMB_RECV_END;
541                 return -EIO;
542         }
543         return 0;
544 }
545
546 /*
547  * Reads the SMB data
548  */
549 static int smb_recv_data(struct smb_sb_info *server, struct smb_request *req)
550 {
551         int result;
552
553         result = smb_receive(server, req);
554         if (result < 0)
555                 goto out;
556         if (req->rq_bytes_recvd < req->rq_rlen)
557                 goto out;
558         server->rstate = SMB_RECV_END;
559 out:
560         VERBOSE("result: %d\n", result);
561         return result;
562 }
563
564 /*
565  * Receive a transaction2 response
566  * Return: 0 if the response has been fully read
567  *         1 if there are further "fragments" to read
568  *        <0 if there is an error
569  */
570 static int smb_recv_trans2(struct smb_sb_info *server, struct smb_request *req)
571 {
572         unsigned char *inbuf;
573         unsigned int parm_disp, parm_offset, parm_count, parm_tot;
574         unsigned int data_disp, data_offset, data_count, data_tot;
575         int hdrlen = SMB_HEADER_LEN + req->rq_resp_wct*2 - 2;
576
577         VERBOSE("handling trans2\n");
578
579         inbuf = req->rq_header;
580         data_tot    = WVAL(inbuf, smb_tdrcnt);
581         parm_tot    = WVAL(inbuf, smb_tprcnt);
582         parm_disp   = WVAL(inbuf, smb_prdisp);
583         parm_offset = WVAL(inbuf, smb_proff);
584         parm_count  = WVAL(inbuf, smb_prcnt);
585         data_disp   = WVAL(inbuf, smb_drdisp);
586         data_offset = WVAL(inbuf, smb_droff);
587         data_count  = WVAL(inbuf, smb_drcnt);
588
589         /* Modify offset for the split header/buffer we use */
590         if (data_count || data_offset) {
591                 if (unlikely(data_offset < hdrlen))
592                         goto out_bad_data;
593                 else
594                         data_offset -= hdrlen;
595         }
596         if (parm_count || parm_offset) {
597                 if (unlikely(parm_offset < hdrlen))
598                         goto out_bad_parm;
599                 else
600                         parm_offset -= hdrlen;
601         }
602
603         if (parm_count == parm_tot && data_count == data_tot) {
604                 /*
605                  * This packet has all the trans2 data.
606                  *
607                  * We setup the request so that this will be the common
608                  * case. It may be a server error to not return a
609                  * response that fits.
610                  */
611                 VERBOSE("single trans2 response  "
612                         "dcnt=%u, pcnt=%u, doff=%u, poff=%u\n",
613                         data_count, parm_count,
614                         data_offset, parm_offset);
615                 req->rq_ldata = data_count;
616                 req->rq_lparm = parm_count;
617                 req->rq_data = req->rq_buffer + data_offset;
618                 req->rq_parm = req->rq_buffer + parm_offset;
619                 if (unlikely(parm_offset + parm_count > req->rq_rlen))
620                         goto out_bad_parm;
621                 if (unlikely(data_offset + data_count > req->rq_rlen))
622                         goto out_bad_data;
623                 return 0;
624         }
625
626         VERBOSE("multi trans2 response  "
627                 "frag=%d, dcnt=%u, pcnt=%u, doff=%u, poff=%u\n",
628                 req->rq_fragment,
629                 data_count, parm_count,
630                 data_offset, parm_offset);
631
632         if (!req->rq_fragment) {
633                 int buf_len;
634
635                 /* We got the first trans2 fragment */
636                 req->rq_fragment = 1;
637                 req->rq_total_data = data_tot;
638                 req->rq_total_parm = parm_tot;
639                 req->rq_ldata = 0;
640                 req->rq_lparm = 0;
641
642                 buf_len = data_tot + parm_tot;
643                 if (buf_len > SMB_MAX_PACKET_SIZE)
644                         goto out_too_long;
645
646                 req->rq_trans2bufsize = buf_len;
647                 req->rq_trans2buffer = kzalloc(buf_len, GFP_NOFS);
648                 if (!req->rq_trans2buffer)
649                         goto out_no_mem;
650
651                 req->rq_parm = req->rq_trans2buffer;
652                 req->rq_data = req->rq_trans2buffer + parm_tot;
653         } else if (unlikely(req->rq_total_data < data_tot ||
654                             req->rq_total_parm < parm_tot))
655                 goto out_data_grew;
656
657         if (unlikely(parm_disp + parm_count > req->rq_total_parm ||
658                      parm_offset + parm_count > req->rq_rlen))
659                 goto out_bad_parm;
660         if (unlikely(data_disp + data_count > req->rq_total_data ||
661                      data_offset + data_count > req->rq_rlen))
662                 goto out_bad_data;
663
664         inbuf = req->rq_buffer;
665         memcpy(req->rq_parm + parm_disp, inbuf + parm_offset, parm_count);
666         memcpy(req->rq_data + data_disp, inbuf + data_offset, data_count);
667
668         req->rq_ldata += data_count;
669         req->rq_lparm += parm_count;
670
671         /*
672          * Check whether we've received all of the data. Note that
673          * we use the packet totals -- total lengths might shrink!
674          */
675         if (req->rq_ldata >= data_tot && req->rq_lparm >= parm_tot) {
676                 req->rq_ldata = data_tot;
677                 req->rq_lparm = parm_tot;
678                 return 0;
679         }
680         return 1;
681
682 out_too_long:
683         printk(KERN_ERR "smb_trans2: data/param too long, data=%u, parm=%u\n",
684                 data_tot, parm_tot);
685         goto out_EIO;
686 out_no_mem:
687         printk(KERN_ERR "smb_trans2: couldn't allocate data area of %d bytes\n",
688                req->rq_trans2bufsize);
689         req->rq_errno = -ENOMEM;
690         goto out;
691 out_data_grew:
692         printk(KERN_ERR "smb_trans2: data/params grew!\n");
693         goto out_EIO;
694 out_bad_parm:
695         printk(KERN_ERR "smb_trans2: invalid parms, disp=%u, cnt=%u, tot=%u, ofs=%u\n",
696                parm_disp, parm_count, parm_tot, parm_offset);
697         goto out_EIO;
698 out_bad_data:
699         printk(KERN_ERR "smb_trans2: invalid data, disp=%u, cnt=%u, tot=%u, ofs=%u\n",
700                data_disp, data_count, data_tot, data_offset);
701 out_EIO:
702         req->rq_errno = -EIO;
703 out:
704         return req->rq_errno;
705 }
706
707 /*
708  * State machine for receiving responses. We handle the fact that we can't
709  * read the full response in one try by having states telling us how much we
710  * have read.
711  *
712  * Must be called with the server lock held (only called from smbiod).
713  *
714  * Return: <0 on error
715  */
716 int smb_request_recv(struct smb_sb_info *server)
717 {
718         struct smb_request *req = NULL;
719         int result = 0;
720
721         if (smb_recv_available(server) <= 0)
722                 return 0;
723
724         VERBOSE("state: %d\n", server->rstate);
725         switch (server->rstate) {
726         case SMB_RECV_DROP:
727                 result = smb_receive_drop(server);
728                 if (result < 0)
729                         break;
730                 if (server->rstate == SMB_RECV_DROP)
731                         break;
732                 server->rstate = SMB_RECV_START;
733                 /* fallthrough */
734         case SMB_RECV_START:
735                 server->smb_read = 0;
736                 server->rstate = SMB_RECV_HEADER;
737                 /* fallthrough */
738         case SMB_RECV_HEADER:
739                 result = smb_receive_header(server);
740                 if (result < 0)
741                         break;
742                 if (server->rstate == SMB_RECV_HEADER)
743                         break;
744                 if (! (*(server->header + smb_flg) & SMB_FLAGS_REPLY) ) {
745                         server->rstate = SMB_RECV_REQUEST;
746                         break;
747                 }
748                 if (server->rstate != SMB_RECV_HCOMPLETE)
749                         break;
750                 /* fallthrough */
751         case SMB_RECV_HCOMPLETE:
752                 req = find_request(server, WVAL(server->header, smb_mid));
753                 if (!req)
754                         break;
755                 smb_init_request(server, req);
756                 req->rq_rcls = *(req->rq_header + smb_rcls);
757                 req->rq_err  = WVAL(req->rq_header, smb_err);
758                 if (server->rstate != SMB_RECV_PARAM)
759                         break;
760                 /* fallthrough */
761         case SMB_RECV_PARAM:
762                 if (!req)
763                         req = find_request(server,WVAL(server->header,smb_mid));
764                 if (!req)
765                         break;
766                 result = smb_recv_param(server, req);
767                 if (result < 0)
768                         break;
769                 if (server->rstate != SMB_RECV_DATA)
770                         break;
771                 /* fallthrough */
772         case SMB_RECV_DATA:
773                 if (!req)
774                         req = find_request(server,WVAL(server->header,smb_mid));
775                 if (!req)
776                         break;
777                 result = smb_recv_data(server, req);
778                 if (result < 0)
779                         break;
780                 break;
781
782                 /* We should never be called with any of these states */
783         case SMB_RECV_END:
784         case SMB_RECV_REQUEST:
785                 BUG();
786         }
787
788         if (result < 0) {
789                 /* We saw an error */
790                 return result;
791         }
792
793         if (server->rstate != SMB_RECV_END)
794                 return 0;
795
796         result = 0;
797         if (req->rq_trans2_command && req->rq_rcls == SUCCESS)
798                 result = smb_recv_trans2(server, req);
799
800         /*
801          * Response completely read. Drop any extra bytes sent by the server.
802          * (Yes, servers sometimes add extra bytes to responses)
803          */
804         VERBOSE("smb_len: %d   smb_read: %d\n",
805                 server->smb_len, server->smb_read);
806         if (server->smb_read < server->smb_len)
807                 smb_receive_drop(server);
808
809         server->rstate = SMB_RECV_START;
810
811         if (!result) {
812                 list_del_init(&req->rq_queue);
813                 req->rq_flags |= SMB_REQ_RECEIVED;
814                 smb_rput(req);
815                 wake_up_interruptible(&req->rq_wait);
816         }
817         return 0;
818 }