CIFS: Add capability to send SMB2 negotiate message

and add negotiate request type to let set_credits know that
we are only on negotiate stage and no need to make a decision
about disabling echos and oplocks.

Signed-off-by: Pavel Shilovsky <piastry@etersoft.ru>
Signed-off-by: Steve French <smfrench@gmail.com>

8 files changed, 417 insertions, 11 deletions

diff --git a/fs/cifs/Makefile b/fs/cifs/Makefile
index b77e9ec02bd1..daf6837d9e0e 100644
--- a/fs/cifs/Makefile
+++ b/fs/cifs/Makefile
@@ -16,4 +16,5 @@ cifs-$(CONFIG_CIFS_DFS_UPCALL) += dns_resolve.o cifs_dfs_ref.o
 
 cifs-$(CONFIG_CIFS_FSCACHE) += fscache.o cache.o
 
-cifs-$(CONFIG_CIFS_SMB2) += smb2ops.o smb2maperror.o smb2transport.o smb2misc.o
+cifs-$(CONFIG_CIFS_SMB2) += smb2ops.o smb2maperror.o smb2transport.o \
+                            smb2misc.o smb2pdu.o
diff --git a/fs/cifs/cifsglob.h b/fs/cifs/cifsglob.h
index 480b6385a9b6..2d48f880b130 100644
--- a/fs/cifs/cifsglob.h
+++ b/fs/cifs/cifsglob.h
@@ -313,6 +313,12 @@ get_rfc1002_length(void *buf)
         return be32_to_cpu(*((__be32 *)buf));
 }
 
+static inline void
+inc_rfc1001_len(void *buf, int count)
+{
+        be32_add_cpu((__be32 *)buf, count);
+}
+
 struct TCP_Server_Info {
         struct list_head tcp_ses_list;
         struct list_head smb_ses_list;
@@ -393,6 +399,10 @@ struct TCP_Server_Info {
         atomic_t in_send; /* requests trying to send */
         atomic_t num_waiters;   /* blocked waiting to get in sendrecv */
 #endif
+#ifdef CONFIG_CIFS_SMB2
+        unsigned int    max_read;
+        unsigned int    max_write;
+#endif /* CONFIG_CIFS_SMB2 */
 };
 
 static inline unsigned int
@@ -986,7 +996,8 @@ static inline void free_dfs_info_array(struct dfs_info3_param *param,
 /* Type of request operation */
 #define   CIFS_ECHO_OP      0x080    /* echo request */
 #define   CIFS_OBREAK_OP   0x0100    /* oplock break request */
-#define   CIFS_OP_MASK     0x0180    /* mask request type */
+#define   CIFS_NEG_OP      0x0200    /* negotiate request */
+#define   CIFS_OP_MASK     0x0380    /* mask request type */
 
 /* Security Flags: indicate type of session setup needed */
 #define   CIFSSEC_MAY_SIGN      0x00001
diff --git a/fs/cifs/cifssmb.c b/fs/cifs/cifssmb.c
index 7a3b4a3b113b..dcb0ad87e173 100644
--- a/fs/cifs/cifssmb.c
+++ b/fs/cifs/cifssmb.c
@@ -388,13 +388,6 @@ vt2_err:
         return -EINVAL;
 }
 
-static inline void inc_rfc1001_len(void *pSMB, int count)
-{
-        struct smb_hdr *hdr = (struct smb_hdr *)pSMB;
-
-        be32_add_cpu(&hdr->smb_buf_length, count);
-}
-
 int
 CIFSSMBNegotiate(const unsigned int xid, struct cifs_ses *ses)
 {
diff --git a/fs/cifs/smb2misc.c b/fs/cifs/smb2misc.c
index d4226782ec88..e4dede4ae058 100644
--- a/fs/cifs/smb2misc.c
+++ b/fs/cifs/smb2misc.c
@@ -199,7 +199,7 @@ static const bool has_smb2_data_area[NUMBER_OF_SMB2_COMMANDS] = {
  * Returns the pointer to the beginning of the data area. Length of the data
  * area and the offset to it (from the beginning of the smb are also returned.
  */
-static char *
+char *
 smb2_get_data_area_len(int *off, int *len, struct smb2_hdr *hdr)
 {
         *off = 0;
@@ -218,6 +218,11 @@ smb2_get_data_area_len(int *off, int *len, struct smb2_hdr *hdr)
          */
         switch (hdr->Command) {
         case SMB2_NEGOTIATE:
+                *off = le16_to_cpu(
+                    ((struct smb2_negotiate_rsp *)hdr)->SecurityBufferOffset);
+                *len = le16_to_cpu(
+                    ((struct smb2_negotiate_rsp *)hdr)->SecurityBufferLength);
+                break;
         case SMB2_SESSION_SETUP:
         case SMB2_CREATE:
         case SMB2_READ:
diff --git a/fs/cifs/smb2ops.c b/fs/cifs/smb2ops.c
index c6f81541a635..2b5232b4f7e7 100644
--- a/fs/cifs/smb2ops.c
+++ b/fs/cifs/smb2ops.c
@@ -61,7 +61,7 @@ smb2_add_credits(struct TCP_Server_Info *server, const unsigned int add,
         val = server->ops->get_credits_field(server, optype);
         *val += add;
         server->in_flight--;
-        if (server->in_flight == 0)
+        if (server->in_flight == 0 && (optype & CIFS_OP_MASK) != CIFS_NEG_OP)
                 rc = change_conf(server);
         spin_unlock(&server->req_lock);
         wake_up(&server->request_q);
@@ -139,6 +139,24 @@ smb2_dump_detail(void *buf)
 #endif
 }
 
+static bool
+smb2_need_neg(struct TCP_Server_Info *server)
+{
+        return server->max_read == 0;
+}
+
+static int
+smb2_negotiate(const unsigned int xid, struct cifs_ses *ses)
+{
+        int rc;
+        ses->server->CurrentMid = 0;
+        rc = SMB2_negotiate(xid, ses);
+        /* BB we probably don't need to retry with modern servers */
+        if (rc == -EAGAIN)
+                rc = -EHOSTDOWN;
+        return rc;
+}
+
 struct smb_version_operations smb21_operations = {
         .setup_request = smb2_setup_request,
         .check_receive = smb2_check_receive,
@@ -150,6 +168,8 @@ struct smb_version_operations smb21_operations = {
         .find_mid = smb2_find_mid,
         .check_message = smb2_check_message,
         .dump_detail = smb2_dump_detail,
+        .need_neg = smb2_need_neg,
+        .negotiate = smb2_negotiate,
 };
 
 struct smb_version_values smb21_values = {
diff --git a/fs/cifs/smb2pdu.c b/fs/cifs/smb2pdu.c
new file mode 100644
index 000000000000..719e4c4f0307
--- /dev/null
+++ b/fs/cifs/smb2pdu.c
@@ -0,0 +1,330 @@
+/*
+ *   fs/cifs/smb2pdu.c
+ *
+ *   Copyright (C) International Business Machines  Corp., 2009, 2011
+ *                 Etersoft, 2012
+ *   Author(s): Steve French (sfrench@us.ibm.com)
+ *              Pavel Shilovsky (pshilovsky@samba.org) 2012
+ *
+ *   Contains the routines for constructing the SMB2 PDUs themselves
+ *
+ *   This library is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU Lesser General Public License as published
+ *   by the Free Software Foundation; either version 2.1 of the License, or
+ *   (at your option) any later version.
+ *
+ *   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
+ */
+
+ /* SMB2 PDU handling routines here - except for leftovers (eg session setup) */
+ /* Note that there are handle based routines which must be                   */
+ /* treated slightly differently for reconnection purposes since we never     */
+ /* want to reuse a stale file handle and only the caller knows the file info */
+
+#include <linux/fs.h>
+#include <linux/kernel.h>
+#include <linux/vfs.h>
+#include <linux/uaccess.h>
+#include <linux/xattr.h>
+#include "smb2pdu.h"
+#include "cifsglob.h"
+#include "cifsacl.h"
+#include "cifsproto.h"
+#include "smb2proto.h"
+#include "cifs_unicode.h"
+#include "cifs_debug.h"
+#include "ntlmssp.h"
+#include "smb2status.h"
+
+/*
+ *  The following table defines the expected "StructureSize" of SMB2 requests
+ *  in order by SMB2 command.  This is similar to "wct" in SMB/CIFS requests.
+ *
+ *  Note that commands are defined in smb2pdu.h in le16 but the array below is
+ *  indexed by command in host byte order.
+ */
+static const int smb2_req_struct_sizes[NUMBER_OF_SMB2_COMMANDS] = {
+        /* SMB2_NEGOTIATE */ 36,
+        /* SMB2_SESSION_SETUP */ 25,
+        /* SMB2_LOGOFF */ 4,
+        /* SMB2_TREE_CONNECT */ 9,
+        /* SMB2_TREE_DISCONNECT */ 4,
+        /* SMB2_CREATE */ 57,
+        /* SMB2_CLOSE */ 24,
+        /* SMB2_FLUSH */ 24,
+        /* SMB2_READ */ 49,
+        /* SMB2_WRITE */ 49,
+        /* SMB2_LOCK */ 48,
+        /* SMB2_IOCTL */ 57,
+        /* SMB2_CANCEL */ 4,
+        /* SMB2_ECHO */ 4,
+        /* SMB2_QUERY_DIRECTORY */ 33,
+        /* SMB2_CHANGE_NOTIFY */ 32,
+        /* SMB2_QUERY_INFO */ 41,
+        /* SMB2_SET_INFO */ 33,
+        /* SMB2_OPLOCK_BREAK */ 24 /* BB this is 36 for LEASE_BREAK variant */
+};
+
+
+static void
+smb2_hdr_assemble(struct smb2_hdr *hdr, __le16 smb2_cmd /* command */ ,
+                  const struct cifs_tcon *tcon)
+{
+        struct smb2_pdu *pdu = (struct smb2_pdu *)hdr;
+        char *temp = (char *)hdr;
+        /* lookup word count ie StructureSize from table */
+        __u16 parmsize = smb2_req_struct_sizes[le16_to_cpu(smb2_cmd)];
+
+        /*
+         * smaller than SMALL_BUFFER_SIZE but bigger than fixed area of
+         * largest operations (Create)
+         */
+        memset(temp, 0, 256);
+
+        /* Note this is only network field converted to big endian */
+        hdr->smb2_buf_length = cpu_to_be32(parmsize + sizeof(struct smb2_hdr)
+                        - 4 /*  RFC 1001 length field itself not counted */);
+
+        hdr->ProtocolId[0] = 0xFE;
+        hdr->ProtocolId[1] = 'S';
+        hdr->ProtocolId[2] = 'M';
+        hdr->ProtocolId[3] = 'B';
+        hdr->StructureSize = cpu_to_le16(64);
+        hdr->Command = smb2_cmd;
+        hdr->CreditRequest = cpu_to_le16(2); /* BB make this dynamic */
+        hdr->ProcessId = cpu_to_le32((__u16)current->tgid);
+
+        if (!tcon)
+                goto out;
+
+        hdr->TreeId = tcon->tid;
+        /* Uid is not converted */
+        if (tcon->ses)
+                hdr->SessionId = tcon->ses->Suid;
+        /* BB check following DFS flags BB */
+        /* BB do we have to add check for SHI1005_FLAGS_DFS_ROOT too? */
+        /* if (tcon->share_flags & SHI1005_FLAGS_DFS)
+                hdr->Flags |= SMB2_FLAGS_DFS_OPERATIONS; */
+        /* BB how does SMB2 do case sensitive? */
+        /* if (tcon->nocase)
+                hdr->Flags |= SMBFLG_CASELESS; */
+        /* if (tcon->ses && tcon->ses->server &&
+            (tcon->ses->server->sec_mode & SECMODE_SIGN_REQUIRED))
+                hdr->Flags |= SMB2_FLAGS_SIGNED; */
+out:
+        pdu->StructureSize2 = cpu_to_le16(parmsize);
+        return;
+}
+
+static int
+smb2_reconnect(__le16 smb2_command, struct cifs_tcon *tcon)
+{
+        int rc = 0;
+        /* BB add missing code here */
+        return rc;
+}
+
+/*
+ * Allocate and return pointer to an SMB request hdr, and set basic
+ * SMB information in the SMB header. If the return code is zero, this
+ * function must have filled in request_buf pointer.
+ */
+static int
+small_smb2_init(__le16 smb2_command, struct cifs_tcon *tcon,
+                void **request_buf)
+{
+        int rc = 0;
+
+        rc = smb2_reconnect(smb2_command, tcon);
+        if (rc)
+                return rc;
+
+        /* BB eventually switch this to SMB2 specific small buf size */
+        *request_buf = cifs_small_buf_get();
+        if (*request_buf == NULL) {
+                /* BB should we add a retry in here if not a writepage? */
+                return -ENOMEM;
+        }
+
+        smb2_hdr_assemble((struct smb2_hdr *) *request_buf, smb2_command, tcon);
+
+        if (tcon != NULL) {
+#ifdef CONFIG_CIFS_STATS2
+                /*
+                uint16_t com_code = le16_to_cpu(smb2_command);
+                cifs_stats_inc(&tcon->stats.smb2_stats.smb2_com_sent[com_code]);
+                */
+#endif
+                cifs_stats_inc(&tcon->num_smbs_sent);
+        }
+
+        return rc;
+}
+
+static void
+free_rsp_buf(int resp_buftype, void *rsp)
+{
+        if (resp_buftype == CIFS_SMALL_BUFFER)
+                cifs_small_buf_release(rsp);
+        else if (resp_buftype == CIFS_LARGE_BUFFER)
+                cifs_buf_release(rsp);
+}
+
+#define SMB2_NUM_PROT 1
+
+#define SMB2_PROT   0
+#define SMB21_PROT  1
+#define BAD_PROT 0xFFFF
+
+#define SMB2_PROT_ID  0x0202
+#define SMB21_PROT_ID 0x0210
+#define BAD_PROT_ID   0xFFFF
+
+static struct {
+        int index;
+        __le16 name;
+} smb2protocols[] = {
+        {SMB2_PROT,  cpu_to_le16(SMB2_PROT_ID)},
+        {SMB21_PROT, cpu_to_le16(SMB21_PROT_ID)},
+        {BAD_PROT,   cpu_to_le16(BAD_PROT_ID)}
+};
+
+/*
+ *
+ *      SMB2 Worker functions follow:
+ *
+ *      The general structure of the worker functions is:
+ *      1) Call smb2_init (assembles SMB2 header)
+ *      2) Initialize SMB2 command specific fields in fixed length area of SMB
+ *      3) Call smb_sendrcv2 (sends request on socket and waits for response)
+ *      4) Decode SMB2 command specific fields in the fixed length area
+ *      5) Decode variable length data area (if any for this SMB2 command type)
+ *      6) Call free smb buffer
+ *      7) return
+ *
+ */
+
+int
+SMB2_negotiate(const unsigned int xid, struct cifs_ses *ses)
+{
+        struct smb2_negotiate_req *req;
+        struct smb2_negotiate_rsp *rsp;
+        struct kvec iov[1];
+        int rc = 0;
+        int resp_buftype;
+        struct TCP_Server_Info *server;
+        unsigned int sec_flags;
+        u16 i;
+        u16 temp = 0;
+        int blob_offset, blob_length;
+        char *security_blob;
+        int flags = CIFS_NEG_OP;
+
+        cFYI(1, "Negotiate protocol");
+
+        if (ses->server)
+                server = ses->server;
+        else {
+                rc = -EIO;
+                return rc;
+        }
+
+        rc = small_smb2_init(SMB2_NEGOTIATE, NULL, (void **) &req);
+        if (rc)
+                return rc;
+
+        /* if any of auth flags (ie not sign or seal) are overriden use them */
+        if (ses->overrideSecFlg & (~(CIFSSEC_MUST_SIGN | CIFSSEC_MUST_SEAL)))
+                sec_flags = ses->overrideSecFlg;  /* BB FIXME fix sign flags?*/
+        else /* if override flags set only sign/seal OR them with global auth */
+                sec_flags = global_secflags | ses->overrideSecFlg;
+
+        cFYI(1, "sec_flags 0x%x", sec_flags);
+
+        req->hdr.SessionId = 0;
+
+        for (i = 0; i < SMB2_NUM_PROT; i++)
+                req->Dialects[i] = smb2protocols[i].name;
+
+        req->DialectCount = cpu_to_le16(i);
+        inc_rfc1001_len(req, i * 2);
+
+        /* only one of SMB2 signing flags may be set in SMB2 request */
+        if ((sec_flags & CIFSSEC_MUST_SIGN) == CIFSSEC_MUST_SIGN)
+                temp = SMB2_NEGOTIATE_SIGNING_REQUIRED;
+        else if (sec_flags & CIFSSEC_MAY_SIGN) /* MAY_SIGN is a single flag */
+                temp = SMB2_NEGOTIATE_SIGNING_ENABLED;
+
+        req->SecurityMode = cpu_to_le16(temp);
+
+        req->Capabilities = cpu_to_le32(SMB2_GLOBAL_CAP_DFS);
+
+        iov[0].iov_base = (char *)req;
+        /* 4 for rfc1002 length field */
+        iov[0].iov_len = get_rfc1002_length(req) + 4;
+
+        rc = SendReceive2(xid, ses, iov, 1, &resp_buftype, flags);
+
+        rsp = (struct smb2_negotiate_rsp *)iov[0].iov_base;
+        /*
+         * No tcon so can't do
+         * cifs_stats_inc(&tcon->stats.smb2_stats.smb2_com_fail[SMB2...]);
+         */
+        if (rc != 0)
+                goto neg_exit;
+
+        if (rsp == NULL) {
+                rc = -EIO;
+                goto neg_exit;
+        }
+
+        cFYI(1, "mode 0x%x", rsp->SecurityMode);
+
+        if (rsp->DialectRevision == smb2protocols[SMB21_PROT].name)
+                cFYI(1, "negotiated smb2.1 dialect");
+        else if (rsp->DialectRevision == smb2protocols[SMB2_PROT].name)
+                cFYI(1, "negotiated smb2 dialect");
+        else {
+                cERROR(1, "Illegal dialect returned by server %d",
+                           le16_to_cpu(rsp->DialectRevision));
+                rc = -EIO;
+                goto neg_exit;
+        }
+        server->dialect = le16_to_cpu(rsp->DialectRevision);
+
+        server->maxBuf = le32_to_cpu(rsp->MaxTransactSize);
+        server->max_read = le32_to_cpu(rsp->MaxReadSize);
+        server->max_write = le32_to_cpu(rsp->MaxWriteSize);
+        /* BB Do we need to validate the SecurityMode? */
+        server->sec_mode = le16_to_cpu(rsp->SecurityMode);
+        server->capabilities = le32_to_cpu(rsp->Capabilities);
+
+        security_blob = smb2_get_data_area_len(&blob_offset, &blob_length,
+                                               &rsp->hdr);
+        if (blob_length == 0) {
+                cERROR(1, "missing security blob on negprot");
+                rc = -EIO;
+                goto neg_exit;
+        }
+#ifdef CONFIG_SMB2_ASN1  /* BB REMOVEME when updated asn1.c ready */
+        rc = decode_neg_token_init(security_blob, blob_length,
+                                   &server->sec_type);
+        if (rc == 1)
+                rc = 0;
+        else if (rc == 0) {
+                rc = -EIO;
+                goto neg_exit;
+        }
+#endif
+
+neg_exit:
+        free_rsp_buf(resp_buftype, rsp);
+        return rc;
+}
diff --git a/fs/cifs/smb2pdu.h b/fs/cifs/smb2pdu.h
index b08a277df896..ef8dae213f60 100644
--- a/fs/cifs/smb2pdu.h
+++ b/fs/cifs/smb2pdu.h
@@ -148,4 +148,43 @@ struct smb2_err_rsp {
         __u8   ErrorData[1];  /* variable length */
 } __packed;
 
+struct smb2_negotiate_req {
+        struct smb2_hdr hdr;
+        __le16 StructureSize; /* Must be 36 */
+        __le16 DialectCount;
+        __le16 SecurityMode;
+        __le16 Reserved;        /* MBZ */
+        __le32 Capabilities;
+        __u8   ClientGUID[16];  /* MBZ */
+        __le64 ClientStartTime; /* MBZ */
+        __le16 Dialects[2]; /* variable length */
+} __packed;
+
+/* SecurityMode flags */
+#define SMB2_NEGOTIATE_SIGNING_ENABLED  0x0001
+#define SMB2_NEGOTIATE_SIGNING_REQUIRED 0x0002
+/* Capabilities flags */
+#define SMB2_GLOBAL_CAP_DFS             0x00000001
+#define SMB2_GLOBAL_CAP_LEASING         0x00000002 /* Resp only New to SMB2.1 */
+#define SMB2_GLOBAL_CAP_LARGE_MTU       0X00000004 /* Resp only New to SMB2.1 */
+
+struct smb2_negotiate_rsp {
+        struct smb2_hdr hdr;
+        __le16 StructureSize;   /* Must be 65 */
+        __le16 SecurityMode;
+        __le16 DialectRevision;
+        __le16 Reserved;        /* MBZ */
+        __u8   ServerGUID[16];
+        __le32 Capabilities;
+        __le32 MaxTransactSize;
+        __le32 MaxReadSize;
+        __le32 MaxWriteSize;
+        __le64 SystemTime;      /* MBZ */
+        __le64 ServerStartTime;
+        __le16 SecurityBufferOffset;
+        __le16 SecurityBufferLength;
+        __le32 Reserved2;       /* may be any value, ignore */
+        __u8   Buffer[1];       /* variable length GSS security buffer */
+} __packed;
+
 #endif                          /* _SMB2PDU_H */
diff --git a/fs/cifs/smb2proto.h b/fs/cifs/smb2proto.h
index 19bf987c2648..881767002807 100644
--- a/fs/cifs/smb2proto.h
+++ b/fs/cifs/smb2proto.h
@@ -35,10 +35,17 @@ struct statfs;
 extern int map_smb2_to_linux_error(char *buf, bool log_err);
 extern int smb2_check_message(char *buf, unsigned int length);
 extern unsigned int smb2_calc_size(struct smb2_hdr *hdr);
+extern char *smb2_get_data_area_len(int *off, int *len, struct smb2_hdr *hdr);
 
 extern int smb2_check_receive(struct mid_q_entry *mid,
                               struct TCP_Server_Info *server, bool log_error);
 extern int smb2_setup_request(struct cifs_ses *ses, struct kvec *iov,
                               unsigned int nvec, struct mid_q_entry **ret_mid);
 
+/*
+ * SMB2 Worker functions - most of protocol specific implementation details
+ * are contained within these calls.
+ */
+extern int SMB2_negotiate(const unsigned int xid, struct cifs_ses *ses);
+
 #endif                  /* _SMB2PROTO_H */