[linux-2.6-block.git] / fs / cifs / smb1ops.c

/*
 *  SMB1 (CIFS) version specific operations
 *
 *  Copyright (c) 2012, Jeff Layton <jlayton@redhat.com>
 *
 *  This library is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License v2 as published
 *  by the Free Software Foundation.
 *
 *  This library is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
 *  the GNU Lesser General Public License for more details.
 *
 *  You should have received a copy of the GNU Lesser General Public License
 *  along with this library; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 */

#include "cifsglob.h"
#include "cifsproto.h"
#include "cifs_debug.h"
#include "cifspdu.h"

/*
 * An NT cancel request header looks just like the original request except:
 *
 * The Command is SMB_COM_NT_CANCEL
 * The WordCount is zeroed out
 * The ByteCount is zeroed out
 *
 * This function mangles an existing request buffer into a
 * SMB_COM_NT_CANCEL request and then sends it.
 */
static int
send_nt_cancel(struct TCP_Server_Info *server, void *buf,
	       struct mid_q_entry *mid)
{
	int rc = 0;
	struct smb_hdr *in_buf = (struct smb_hdr *)buf;

	/* -4 for RFC1001 length and +2 for BCC field */
	in_buf->smb_buf_length = cpu_to_be32(sizeof(struct smb_hdr) - 4  + 2);
	in_buf->Command = SMB_COM_NT_CANCEL;
	in_buf->WordCount = 0;
	put_bcc(0, in_buf);

	mutex_lock(&server->srv_mutex);
	rc = cifs_sign_smb(in_buf, server, &mid->sequence_number);
	if (rc) {
		mutex_unlock(&server->srv_mutex);
		return rc;
	}
	rc = smb_send(server, in_buf, be32_to_cpu(in_buf->smb_buf_length));
	mutex_unlock(&server->srv_mutex);

	cFYI(1, "issued NT_CANCEL for mid %u, rc = %d",
		in_buf->Mid, rc);

	return rc;
}

static bool
cifs_compare_fids(struct cifsFileInfo *ob1, struct cifsFileInfo *ob2)
{
	return ob1->netfid == ob2->netfid;
}

static unsigned int
cifs_read_data_offset(char *buf)
{
	READ_RSP *rsp = (READ_RSP *)buf;
	return le16_to_cpu(rsp->DataOffset);
}

static unsigned int
cifs_read_data_length(char *buf)
{
	READ_RSP *rsp = (READ_RSP *)buf;
	return (le16_to_cpu(rsp->DataLengthHigh) << 16) +
	       le16_to_cpu(rsp->DataLength);
}

static struct mid_q_entry *
cifs_find_mid(struct TCP_Server_Info *server, char *buffer)
{
	struct smb_hdr *buf = (struct smb_hdr *)buffer;
	struct mid_q_entry *mid;

	spin_lock(&GlobalMid_Lock);
	list_for_each_entry(mid, &server->pending_mid_q, qhead) {
		if (mid->mid == buf->Mid &&
		    mid->mid_state == MID_REQUEST_SUBMITTED &&
		    le16_to_cpu(mid->command) == buf->Command) {
			spin_unlock(&GlobalMid_Lock);
			return mid;
		}
	}
	spin_unlock(&GlobalMid_Lock);
	return NULL;
}

struct smb_version_operations smb1_operations = {
	.send_cancel = send_nt_cancel,
	.compare_fids = cifs_compare_fids,
	.setup_request = cifs_setup_request,
	.check_receive = cifs_check_receive,
	.read_data_offset = cifs_read_data_offset,
	.read_data_length = cifs_read_data_length,
	.map_error = map_smb_to_linux_error,
	.find_mid = cifs_find_mid,
	.check_message = checkSMB,
	.dump_detail = cifs_dump_detail,
	.is_oplock_break = is_valid_oplock_break,
};

struct smb_version_values smb1_values = {
	.version_string = SMB1_VERSION_STRING,
	.large_lock_type = LOCKING_ANDX_LARGE_FILES,
	.exclusive_lock_type = 0,
	.shared_lock_type = LOCKING_ANDX_SHARED_LOCK,
	.unlock_lock_type = 0,
	.header_size = sizeof(struct smb_hdr),
	.max_header_size = MAX_CIFS_HDR_SIZE,
	.read_rsp_size = sizeof(READ_RSP),
};
Commit	Line	Data
23db65f5 JL	1	/*
	2	* SMB1 (CIFS) version specific operations
	3	*
	4	* Copyright (c) 2012, Jeff Layton <jlayton@redhat.com>
	5	*
	6	* This library is free software; you can redistribute it and/or modify
	7	* it under the terms of the GNU General Public License v2 as published
	8	* by the Free Software Foundation.
	9	*
	10	* This library is distributed in the hope that it will be useful,
	11	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
	13	* the GNU Lesser General Public License for more details.
	14	*
	15	* You should have received a copy of the GNU Lesser General Public License
	16	* along with this library; if not, write to the Free Software
	17	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	18	*/
	19
	20	#include "cifsglob.h"
121b046a JL	21	#include "cifsproto.h"
121b046a JL	22	#include "cifs_debug.h"
106dc538	23	#include "cifspdu.h"
121b046a JL	24
	25	/*
	26	* An NT cancel request header looks just like the original request except:
	27	*
	28	* The Command is SMB_COM_NT_CANCEL
	29	* The WordCount is zeroed out
	30	* The ByteCount is zeroed out
	31	*
	32	* This function mangles an existing request buffer into a
	33	* SMB_COM_NT_CANCEL request and then sends it.
	34	*/
	35	static int
	36	send_nt_cancel(struct TCP_Server_Info server, void buf,
	37	struct mid_q_entry *mid)
	38	{
	39	int rc = 0;
	40	struct smb_hdr in_buf = (struct smb_hdr )buf;
	41
	42	/* -4 for RFC1001 length and +2 for BCC field */
	43	in_buf->smb_buf_length = cpu_to_be32(sizeof(struct smb_hdr) - 4 + 2);
	44	in_buf->Command = SMB_COM_NT_CANCEL;
	45	in_buf->WordCount = 0;
	46	put_bcc(0, in_buf);
	47
	48	mutex_lock(&server->srv_mutex);
	49	rc = cifs_sign_smb(in_buf, server, &mid->sequence_number);
	50	if (rc) {
	51	mutex_unlock(&server->srv_mutex);
	52	return rc;
	53	}
	54	rc = smb_send(server, in_buf, be32_to_cpu(in_buf->smb_buf_length));
	55	mutex_unlock(&server->srv_mutex);
	56
	57	cFYI(1, "issued NT_CANCEL for mid %u, rc = %d",
	58	in_buf->Mid, rc);
	59
	60	return rc;
	61	}
23db65f5	62
55157dfb PS	63	static bool
	64	cifs_compare_fids(struct cifsFileInfo ob1, struct cifsFileInfo ob2)
	65	{
	66	return ob1->netfid == ob2->netfid;
	67	}
	68
eb378711 PS	69	static unsigned int
	70	cifs_read_data_offset(char *buf)
	71	{
	72	READ_RSP rsp = (READ_RSP )buf;
	73	return le16_to_cpu(rsp->DataOffset);
	74	}
	75
	76	static unsigned int
	77	cifs_read_data_length(char *buf)
	78	{
	79	READ_RSP rsp = (READ_RSP )buf;
	80	return (le16_to_cpu(rsp->DataLengthHigh) << 16) +
	81	le16_to_cpu(rsp->DataLength);
	82	}
	83
8aa26f3e PS	84	static struct mid_q_entry *
	85	cifs_find_mid(struct TCP_Server_Info server, char buffer)
	86	{
	87	struct smb_hdr buf = (struct smb_hdr )buffer;
	88	struct mid_q_entry *mid;
	89
	90	spin_lock(&GlobalMid_Lock);
	91	list_for_each_entry(mid, &server->pending_mid_q, qhead) {
	92	if (mid->mid == buf->Mid &&
	93	mid->mid_state == MID_REQUEST_SUBMITTED &&
	94	le16_to_cpu(mid->command) == buf->Command) {
	95	spin_unlock(&GlobalMid_Lock);
	96	return mid;
	97	}
	98	}
	99	spin_unlock(&GlobalMid_Lock);
	100	return NULL;
	101	}
	102
23db65f5	103	struct smb_version_operations smb1_operations = {
121b046a	104	.send_cancel = send_nt_cancel,
55157dfb	105	.compare_fids = cifs_compare_fids,
082d0642 PS	106	.setup_request = cifs_setup_request,
082d0642 PS	107	.check_receive = cifs_check_receive,
eb378711 PS	108	.read_data_offset = cifs_read_data_offset,
	109	.read_data_length = cifs_read_data_length,
	110	.map_error = map_smb_to_linux_error,
8aa26f3e PS	111	.find_mid = cifs_find_mid,
	112	.check_message = checkSMB,
	113	.dump_detail = cifs_dump_detail,
	114	.is_oplock_break = is_valid_oplock_break,
23db65f5 JL	115	};
	116
	117	struct smb_version_values smb1_values = {
	118	.version_string = SMB1_VERSION_STRING,
106dc538 PS	119	.large_lock_type = LOCKING_ANDX_LARGE_FILES,
	120	.exclusive_lock_type = 0,
	121	.shared_lock_type = LOCKING_ANDX_SHARED_LOCK,
	122	.unlock_lock_type = 0,
1887f601 PS	123	.header_size = sizeof(struct smb_hdr),
1887f601 PS	124	.max_header_size = MAX_CIFS_HDR_SIZE,
eb378711	125	.read_rsp_size = sizeof(READ_RSP),
23db65f5	126	};