Merge branch 'for-linus' of git://oss.sgi.com/xfs/xfs
[linux-2.6.git] / fs / smbfs / sock.c
1 /*
2  *  sock.c
3  *
4  *  Copyright (C) 1995, 1996 by Paal-Kr. Engstad and Volker Lendecke
5  *  Copyright (C) 1997 by Volker Lendecke
6  *
7  *  Please add a note about your changes to smbfs in the ChangeLog file.
8  */
9
10 #include <linux/fs.h>
11 #include <linux/time.h>
12 #include <linux/errno.h>
13 #include <linux/socket.h>
14 #include <linux/fcntl.h>
15 #include <linux/file.h>
16 #include <linux/in.h>
17 #include <linux/net.h>
18 #include <linux/mm.h>
19 #include <linux/netdevice.h>
20 #include <linux/workqueue.h>
21 #include <net/scm.h>
22 #include <net/tcp_states.h>
23 #include <net/ip.h>
24
25 #include <linux/smb_fs.h>
26 #include <linux/smb.h>
27 #include <linux/smbno.h>
28
29 #include <asm/uaccess.h>
30 #include <asm/ioctls.h>
31
32 #include "smb_debug.h"
33 #include "proto.h"
34 #include "request.h"
35
36
37 static int
38 _recvfrom(struct socket *socket, unsigned char *ubuf, int size, unsigned flags)
39 {
40         struct kvec iov = {ubuf, size};
41         struct msghdr msg = {.msg_flags = flags};
42         msg.msg_flags |= MSG_DONTWAIT | MSG_NOSIGNAL;
43         return kernel_recvmsg(socket, &msg, &iov, 1, size, msg.msg_flags);
44 }
45
46 /*
47  * Return the server this socket belongs to
48  */
49 static struct smb_sb_info *
50 server_from_socket(struct socket *socket)
51 {
52         return socket->sk->sk_user_data;
53 }
54
55 /*
56  * Called when there is data on the socket.
57  */
58 void
59 smb_data_ready(struct sock *sk, int len)
60 {
61         struct smb_sb_info *server = server_from_socket(sk->sk_socket);
62         void (*data_ready)(struct sock *, int) = server->data_ready;
63
64         data_ready(sk, len);
65         VERBOSE("(%p, %d)\n", sk, len);
66         smbiod_wake_up();
67 }
68
69 int
70 smb_valid_socket(struct inode * inode)
71 {
72         return (inode && S_ISSOCK(inode->i_mode) && 
73                 SOCKET_I(inode)->type == SOCK_STREAM);
74 }
75
76 static struct socket *
77 server_sock(struct smb_sb_info *server)
78 {
79         struct file *file;
80
81         if (server && (file = server->sock_file))
82         {
83 #ifdef SMBFS_PARANOIA
84                 if (!smb_valid_socket(file->f_path.dentry->d_inode))
85                         PARANOIA("bad socket!\n");
86 #endif
87                 return SOCKET_I(file->f_path.dentry->d_inode);
88         }
89         return NULL;
90 }
91
92 void
93 smb_close_socket(struct smb_sb_info *server)
94 {
95         struct file * file = server->sock_file;
96
97         if (file) {
98                 struct socket *sock = server_sock(server);
99
100                 VERBOSE("closing socket %p\n", sock);
101                 sock->sk->sk_data_ready = server->data_ready;
102                 server->sock_file = NULL;
103                 fput(file);
104         }
105 }
106
107 static int
108 smb_get_length(struct socket *socket, unsigned char *header)
109 {
110         int result;
111
112         result = _recvfrom(socket, header, 4, MSG_PEEK);
113         if (result == -EAGAIN)
114                 return -ENODATA;
115         if (result < 0) {
116                 PARANOIA("recv error = %d\n", -result);
117                 return result;
118         }
119         if (result < 4)
120                 return -ENODATA;
121
122         switch (header[0]) {
123         case 0x00:
124         case 0x82:
125                 break;
126
127         case 0x85:
128                 DEBUG1("Got SESSION KEEP ALIVE\n");
129                 _recvfrom(socket, header, 4, 0);        /* read away */
130                 return -ENODATA;
131
132         default:
133                 PARANOIA("Invalid NBT packet, code=%x\n", header[0]);
134                 return -EIO;
135         }
136
137         /* The length in the RFC NB header is the raw data length */
138         return smb_len(header);
139 }
140
141 int
142 smb_recv_available(struct smb_sb_info *server)
143 {
144         mm_segment_t oldfs;
145         int avail, err;
146         struct socket *sock = server_sock(server);
147
148         oldfs = get_fs();
149         set_fs(get_ds());
150         err = sock->ops->ioctl(sock, SIOCINQ, (unsigned long) &avail);
151         set_fs(oldfs);
152         return (err >= 0) ? avail : err;
153 }
154
155 /*
156  * Adjust the kvec to move on 'n' bytes (from nfs/sunrpc)
157  */
158 static int
159 smb_move_iov(struct kvec **data, size_t *num, struct kvec *vec, unsigned amount)
160 {
161         struct kvec *iv = *data;
162         int i;
163         int len;
164
165         /*
166          *      Eat any sent kvecs
167          */
168         while (iv->iov_len <= amount) {
169                 amount -= iv->iov_len;
170                 iv++;
171                 (*num)--;
172         }
173
174         /*
175          *      And chew down the partial one
176          */
177         vec[0].iov_len = iv->iov_len-amount;
178         vec[0].iov_base =((unsigned char *)iv->iov_base)+amount;
179         iv++;
180
181         len = vec[0].iov_len;
182
183         /*
184          *      And copy any others
185          */
186         for (i = 1; i < *num; i++) {
187                 vec[i] = *iv++;
188                 len += vec[i].iov_len;
189         }
190
191         *data = vec;
192         return len;
193 }
194
195 /*
196  * smb_receive_header
197  * Only called by the smbiod thread.
198  */
199 int
200 smb_receive_header(struct smb_sb_info *server)
201 {
202         struct socket *sock;
203         int result = 0;
204         unsigned char peek_buf[4];
205
206         result = -EIO; 
207         sock = server_sock(server);
208         if (!sock)
209                 goto out;
210         if (sock->sk->sk_state != TCP_ESTABLISHED)
211                 goto out;
212
213         if (!server->smb_read) {
214                 result = smb_get_length(sock, peek_buf);
215                 if (result < 0) {
216                         if (result == -ENODATA)
217                                 result = 0;
218                         goto out;
219                 }
220                 server->smb_len = result + 4;
221
222                 if (server->smb_len < SMB_HEADER_LEN) {
223                         PARANOIA("short packet: %d\n", result);
224                         server->rstate = SMB_RECV_DROP;
225                         result = -EIO;
226                         goto out;
227                 }
228                 if (server->smb_len > SMB_MAX_PACKET_SIZE) {
229                         PARANOIA("long packet: %d\n", result);
230                         server->rstate = SMB_RECV_DROP;
231                         result = -EIO;
232                         goto out;
233                 }
234         }
235
236         result = _recvfrom(sock, server->header + server->smb_read,
237                            SMB_HEADER_LEN - server->smb_read, 0);
238         VERBOSE("_recvfrom: %d\n", result);
239         if (result < 0) {
240                 VERBOSE("receive error: %d\n", result);
241                 goto out;
242         }
243         server->smb_read += result;
244
245         if (server->smb_read == SMB_HEADER_LEN)
246                 server->rstate = SMB_RECV_HCOMPLETE;
247 out:
248         return result;
249 }
250
251 static char drop_buffer[PAGE_SIZE];
252
253 /*
254  * smb_receive_drop - read and throw away the data
255  * Only called by the smbiod thread.
256  *
257  * FIXME: we are in the kernel, could we just tell the socket that we want
258  * to drop stuff from the buffer?
259  */
260 int
261 smb_receive_drop(struct smb_sb_info *server)
262 {
263         struct socket *sock;
264         unsigned int flags;
265         struct kvec iov;
266         struct msghdr msg;
267         int rlen = smb_len(server->header) - server->smb_read + 4;
268         int result = -EIO;
269
270         if (rlen > PAGE_SIZE)
271                 rlen = PAGE_SIZE;
272
273         sock = server_sock(server);
274         if (!sock)
275                 goto out;
276         if (sock->sk->sk_state != TCP_ESTABLISHED)
277                 goto out;
278
279         flags = MSG_DONTWAIT | MSG_NOSIGNAL;
280         iov.iov_base = drop_buffer;
281         iov.iov_len = PAGE_SIZE;
282         msg.msg_flags = flags;
283         msg.msg_name = NULL;
284         msg.msg_namelen = 0;
285         msg.msg_control = NULL;
286
287         result = kernel_recvmsg(sock, &msg, &iov, 1, rlen, flags);
288
289         VERBOSE("read: %d\n", result);
290         if (result < 0) {
291                 VERBOSE("receive error: %d\n", result);
292                 goto out;
293         }
294         server->smb_read += result;
295
296         if (server->smb_read >= server->smb_len)
297                 server->rstate = SMB_RECV_END;
298
299 out:
300         return result;
301 }
302
303 /*
304  * smb_receive
305  * Only called by the smbiod thread.
306  */
307 int
308 smb_receive(struct smb_sb_info *server, struct smb_request *req)
309 {
310         struct socket *sock;
311         unsigned int flags;
312         struct kvec iov[4];
313         struct kvec *p = req->rq_iov;
314         size_t num = req->rq_iovlen;
315         struct msghdr msg;
316         int rlen;
317         int result = -EIO;
318
319         sock = server_sock(server);
320         if (!sock)
321                 goto out;
322         if (sock->sk->sk_state != TCP_ESTABLISHED)
323                 goto out;
324
325         flags = MSG_DONTWAIT | MSG_NOSIGNAL;
326         msg.msg_flags = flags;
327         msg.msg_name = NULL;
328         msg.msg_namelen = 0;
329         msg.msg_control = NULL;
330
331         /* Dont repeat bytes and count available bufferspace */
332         rlen = min_t(int, smb_move_iov(&p, &num, iov, req->rq_bytes_recvd),
333                         (req->rq_rlen - req->rq_bytes_recvd));
334
335         result = kernel_recvmsg(sock, &msg, p, num, rlen, flags);
336
337         VERBOSE("read: %d\n", result);
338         if (result < 0) {
339                 VERBOSE("receive error: %d\n", result);
340                 goto out;
341         }
342         req->rq_bytes_recvd += result;
343         server->smb_read += result;
344
345 out:
346         return result;
347 }
348
349 /*
350  * Try to send a SMB request. This may return after sending only parts of the
351  * request. SMB_REQ_TRANSMITTED will be set if a request was fully sent.
352  *
353  * Parts of this was taken from xprt_sendmsg from net/sunrpc/xprt.c
354  */
355 int
356 smb_send_request(struct smb_request *req)
357 {
358         struct smb_sb_info *server = req->rq_server;
359         struct socket *sock;
360         struct msghdr msg = {.msg_flags = MSG_NOSIGNAL | MSG_DONTWAIT};
361         int slen = req->rq_slen - req->rq_bytes_sent;
362         int result = -EIO;
363         struct kvec iov[4];
364         struct kvec *p = req->rq_iov;
365         size_t num = req->rq_iovlen;
366
367         sock = server_sock(server);
368         if (!sock)
369                 goto out;
370         if (sock->sk->sk_state != TCP_ESTABLISHED)
371                 goto out;
372
373         /* Dont repeat bytes */
374         if (req->rq_bytes_sent)
375                 smb_move_iov(&p, &num, iov, req->rq_bytes_sent);
376
377         result = kernel_sendmsg(sock, &msg, p, num, slen);
378
379         if (result >= 0) {
380                 req->rq_bytes_sent += result;
381                 if (req->rq_bytes_sent >= req->rq_slen)
382                         req->rq_flags |= SMB_REQ_TRANSMITTED;
383         }
384 out:
385         return result;
386 }