/* * 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/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_path.dentry->d_inode)) PARANOIA("bad socket!\n"); #endif return SOCKET_I(file->f_path.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 = min_t(int, smb_move_iov(&p, &num, iov, req->rq_bytes_recvd), (req->rq_rlen - req->rq_bytes_recvd)); 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; }