[linux.git] / fs / smbfs / sock.c

/*
 *  sock.c
 *
 *  Copyright (C) 1995, 1996 by Paal-Kr. Engstad and Volker Lendecke
 *  Copyright (C) 1997 by Volker Lendecke
 *
 *  Please add a note about your changes to smbfs in the ChangeLog file.
 */

#include <linux/fs.h>
#include <linux/time.h>
#include <linux/errno.h>
#include <linux/socket.h>
#include <linux/fcntl.h>
#include <linux/file.h>
#include <linux/in.h>
#include <linux/net.h>
#include <linux/mm.h>
#include <linux/netdevice.h>
#include <linux/smp_lock.h>
#include <linux/workqueue.h>
#include <net/scm.h>
#include <net/tcp_states.h>
#include <net/ip.h>

#include <linux/smb_fs.h>
#include <linux/smb.h>
#include <linux/smbno.h>

#include <asm/uaccess.h>
#include <asm/ioctls.h>

#include "smb_debug.h"
#include "proto.h"
#include "request.h"


static int
_recvfrom(struct socket *socket, unsigned char *ubuf, int size, unsigned flags)
{
	struct kvec iov = {ubuf, size};
	struct msghdr msg = {.msg_flags = flags};
	msg.msg_flags |= MSG_DONTWAIT | MSG_NOSIGNAL;
	return kernel_recvmsg(socket, &msg, &iov, 1, size, msg.msg_flags);
}

/*
 * Return the server this socket belongs to
 */
static struct smb_sb_info *
server_from_socket(struct socket *socket)
{
	return socket->sk->sk_user_data;
}

/*
 * Called when there is data on the socket.
 */
void
smb_data_ready(struct sock *sk, int len)
{
	struct smb_sb_info *server = server_from_socket(sk->sk_socket);
	void (*data_ready)(struct sock *, int) = server->data_ready;

	data_ready(sk, len);
	VERBOSE("(%p, %d)\n", sk, len);
	smbiod_wake_up();
}

int
smb_valid_socket(struct inode * inode)
{
	return (inode && S_ISSOCK(inode->i_mode) && 
		SOCKET_I(inode)->type == SOCK_STREAM);
}

static struct socket *
server_sock(struct smb_sb_info *server)
{
	struct file *file;

	if (server && (file = server->sock_file))
	{
#ifdef SMBFS_PARANOIA
		if (!smb_valid_socket(file->f_dentry->d_inode))
			PARANOIA("bad socket!\n");
#endif
		return SOCKET_I(file->f_dentry->d_inode);
	}
	return NULL;
}

void
smb_close_socket(struct smb_sb_info *server)
{
	struct file * file = server->sock_file;

	if (file) {
		struct socket *sock = server_sock(server);

		VERBOSE("closing socket %p\n", sock);
		sock->sk->sk_data_ready = server->data_ready;
		server->sock_file = NULL;
		fput(file);
	}
}

static int
smb_get_length(struct socket *socket, unsigned char *header)
{
	int result;

	result = _recvfrom(socket, header, 4, MSG_PEEK);
	if (result == -EAGAIN)
		return -ENODATA;
	if (result < 0) {
		PARANOIA("recv error = %d\n", -result);
		return result;
	}
	if (result < 4)
		return -ENODATA;

	switch (header[0]) {
	case 0x00:
	case 0x82:
		break;

	case 0x85:
		DEBUG1("Got SESSION KEEP ALIVE\n");
		_recvfrom(socket, header, 4, 0);	/* read away */
		return -ENODATA;

	default:
		PARANOIA("Invalid NBT packet, code=%x\n", header[0]);
		return -EIO;
	}

	/* The length in the RFC NB header is the raw data length */
	return smb_len(header);
}

int
smb_recv_available(struct smb_sb_info *server)
{
	mm_segment_t oldfs;
	int avail, err;
	struct socket *sock = server_sock(server);

	oldfs = get_fs();
	set_fs(get_ds());
	err = sock->ops->ioctl(sock, SIOCINQ, (unsigned long) &avail);
	set_fs(oldfs);
	return (err >= 0) ? avail : err;
}

/*
 * Adjust the kvec to move on 'n' bytes (from nfs/sunrpc)
 */
static int
smb_move_iov(struct kvec **data, size_t *num, struct kvec *vec, unsigned amount)
{
	struct kvec *iv = *data;
	int i;
	int len;

	/*
	 *	Eat any sent kvecs
	 */
	while (iv->iov_len <= amount) {
		amount -= iv->iov_len;
		iv++;
		(*num)--;
	}

	/*
	 *	And chew down the partial one
	 */
	vec[0].iov_len = iv->iov_len-amount;
	vec[0].iov_base =((unsigned char *)iv->iov_base)+amount;
	iv++;

	len = vec[0].iov_len;

	/*
	 *	And copy any others
	 */
	for (i = 1; i < *num; i++) {
		vec[i] = *iv++;
		len += vec[i].iov_len;
	}

	*data = vec;
	return len;
}

/*
 * smb_receive_header
 * Only called by the smbiod thread.
 */
int
smb_receive_header(struct smb_sb_info *server)
{
	struct socket *sock;
	int result = 0;
	unsigned char peek_buf[4];

	result = -EIO; 
	sock = server_sock(server);
	if (!sock)
		goto out;
	if (sock->sk->sk_state != TCP_ESTABLISHED)
		goto out;

	if (!server->smb_read) {
		result = smb_get_length(sock, peek_buf);
		if (result < 0) {
			if (result == -ENODATA)
				result = 0;
			goto out;
		}
		server->smb_len = result + 4;

		if (server->smb_len < SMB_HEADER_LEN) {
			PARANOIA("short packet: %d\n", result);
			server->rstate = SMB_RECV_DROP;
			result = -EIO;
			goto out;
		}
		if (server->smb_len > SMB_MAX_PACKET_SIZE) {
			PARANOIA("long packet: %d\n", result);
			server->rstate = SMB_RECV_DROP;
			result = -EIO;
			goto out;
		}
	}

	result = _recvfrom(sock, server->header + server->smb_read,
			   SMB_HEADER_LEN - server->smb_read, 0);
	VERBOSE("_recvfrom: %d\n", result);
	if (result < 0) {
		VERBOSE("receive error: %d\n", result);
		goto out;
	}
	server->smb_read += result;

	if (server->smb_read == SMB_HEADER_LEN)
		server->rstate = SMB_RECV_HCOMPLETE;
out:
	return result;
}

static char drop_buffer[PAGE_SIZE];

/*
 * smb_receive_drop - read and throw away the data
 * Only called by the smbiod thread.
 *
 * FIXME: we are in the kernel, could we just tell the socket that we want
 * to drop stuff from the buffer?
 */
int
smb_receive_drop(struct smb_sb_info *server)
{
	struct socket *sock;
	unsigned int flags;
	struct kvec iov;
	struct msghdr msg;
	int rlen = smb_len(server->header) - server->smb_read + 4;
	int result = -EIO;

	if (rlen > PAGE_SIZE)
		rlen = PAGE_SIZE;

	sock = server_sock(server);
	if (!sock)
		goto out;
	if (sock->sk->sk_state != TCP_ESTABLISHED)
		goto out;

	flags = MSG_DONTWAIT | MSG_NOSIGNAL;
	iov.iov_base = drop_buffer;
	iov.iov_len = PAGE_SIZE;
	msg.msg_flags = flags;
	msg.msg_name = NULL;
	msg.msg_namelen = 0;
	msg.msg_control = NULL;

	result = kernel_recvmsg(sock, &msg, &iov, 1, rlen, flags);

	VERBOSE("read: %d\n", result);
	if (result < 0) {
		VERBOSE("receive error: %d\n", result);
		goto out;
	}
	server->smb_read += result;

	if (server->smb_read >= server->smb_len)
		server->rstate = SMB_RECV_END;

out:
	return result;
}

/*
 * smb_receive
 * Only called by the smbiod thread.
 */
int
smb_receive(struct smb_sb_info *server, struct smb_request *req)
{
	struct socket *sock;
	unsigned int flags;
	struct kvec iov[4];
	struct kvec *p = req->rq_iov;
	size_t num = req->rq_iovlen;
	struct msghdr msg;
	int rlen;
	int result = -EIO;

	sock = server_sock(server);
	if (!sock)
		goto out;
	if (sock->sk->sk_state != TCP_ESTABLISHED)
		goto out;

	flags = MSG_DONTWAIT | MSG_NOSIGNAL;
	msg.msg_flags = flags;
	msg.msg_name = NULL;
	msg.msg_namelen = 0;
	msg.msg_control = NULL;

	/* Dont repeat bytes and count available bufferspace */
	rlen = smb_move_iov(&p, &num, iov, req->rq_bytes_recvd);
	if (req->rq_rlen < rlen)
		rlen = req->rq_rlen;

	result = kernel_recvmsg(sock, &msg, p, num, rlen, flags);

	VERBOSE("read: %d\n", result);
	if (result < 0) {
		VERBOSE("receive error: %d\n", result);
		goto out;
	}
	req->rq_bytes_recvd += result;
	server->smb_read += result;

out:
	return result;
}

/*
 * Try to send a SMB request. This may return after sending only parts of the
 * request. SMB_REQ_TRANSMITTED will be set if a request was fully sent.
 *
 * Parts of this was taken from xprt_sendmsg from net/sunrpc/xprt.c
 */
int
smb_send_request(struct smb_request *req)
{
	struct smb_sb_info *server = req->rq_server;
	struct socket *sock;
	struct msghdr msg = {.msg_flags = MSG_NOSIGNAL | MSG_DONTWAIT};
        int slen = req->rq_slen - req->rq_bytes_sent;
	int result = -EIO;
	struct kvec iov[4];
	struct kvec *p = req->rq_iov;
	size_t num = req->rq_iovlen;

	sock = server_sock(server);
	if (!sock)
		goto out;
	if (sock->sk->sk_state != TCP_ESTABLISHED)
		goto out;

	/* Dont repeat bytes */
	if (req->rq_bytes_sent)
		smb_move_iov(&p, &num, iov, req->rq_bytes_sent);

	result = kernel_sendmsg(sock, &msg, p, num, slen);

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