9 files changed, 124 insertions, 52 deletions

diff --git a/fs/cifs/cifs_unicode.c b/fs/cifs/cifs_unicode.c
index 5a53ac6b1e02..02b071bf3732 100644
--- a/fs/cifs/cifs_unicode.c
+++ b/fs/cifs/cifs_unicode.c
@@ -101,6 +101,12 @@ convert_sfm_char(const __u16 src_char, char *target)
         case SFM_SLASH:
                 *target = '\\';
                 break;
+        case SFM_SPACE:
+                *target = ' ';
+                break;
+        case SFM_PERIOD:
+                *target = '.';
+                break;
         default:
                 return false;
         }
@@ -404,7 +410,7 @@ static __le16 convert_to_sfu_char(char src_char)
         return dest_char;
 }
 
-static __le16 convert_to_sfm_char(char src_char)
+static __le16 convert_to_sfm_char(char src_char, bool end_of_string)
 {
         __le16 dest_char;
 
@@ -427,6 +433,18 @@ static __le16 convert_to_sfm_char(char src_char)
         case '|':
                 dest_char = cpu_to_le16(SFM_PIPE);
                 break;
+        case '.':
+                if (end_of_string)
+                        dest_char = cpu_to_le16(SFM_PERIOD);
+                else
+                        dest_char = 0;
+                break;
+        case ' ':
+                if (end_of_string)
+                        dest_char = cpu_to_le16(SFM_SPACE);
+                else
+                        dest_char = 0;
+                break;
         default:
                 dest_char = 0;
         }
@@ -469,9 +487,16 @@ cifsConvertToUTF16(__le16 *target, const char *source, int srclen,
                 /* see if we must remap this char */
                 if (map_chars == SFU_MAP_UNI_RSVD)
                         dst_char = convert_to_sfu_char(src_char);
-                else if (map_chars == SFM_MAP_UNI_RSVD)
-                        dst_char = convert_to_sfm_char(src_char);
-                else
+                else if (map_chars == SFM_MAP_UNI_RSVD) {
+                        bool end_of_string;
+
+                        if (i == srclen - 1)
+                                end_of_string = true;
+                        else
+                                end_of_string = false;
+
+                        dst_char = convert_to_sfm_char(src_char, end_of_string);
+                } else
                         dst_char = 0;
                 /*
                  * FIXME: We can not handle remapping backslash (UNI_SLASH)
diff --git a/fs/cifs/cifs_unicode.h b/fs/cifs/cifs_unicode.h
index bdc52cb9a676..479bc0a941f3 100644
--- a/fs/cifs/cifs_unicode.h
+++ b/fs/cifs/cifs_unicode.h
@@ -64,6 +64,8 @@
 #define SFM_LESSTHAN    ((__u16) 0xF023)
 #define SFM_PIPE        ((__u16) 0xF027)
 #define SFM_SLASH       ((__u16) 0xF026)
+#define SFM_PERIOD      ((__u16) 0xF028)
+#define SFM_SPACE       ((__u16) 0xF029)
 
 /*
  * Mapping mechanism to use when one of the seven reserved characters is
diff --git a/fs/cifs/cifsfs.c b/fs/cifs/cifsfs.c
index 5d8b7edf8a8f..5d841f39c4b7 100644
--- a/fs/cifs/cifsfs.c
+++ b/fs/cifs/cifsfs.c
@@ -87,6 +87,7 @@ extern mempool_t *cifs_req_poolp;
 extern mempool_t *cifs_mid_poolp;
 
 struct workqueue_struct *cifsiod_wq;
+__u32 cifs_lock_secret;
 
 /*
  * Bumps refcount for cifs super block.
@@ -1266,6 +1267,8 @@ init_cifs(void)
         spin_lock_init(&cifs_file_list_lock);
         spin_lock_init(&GlobalMid_Lock);
 
+        get_random_bytes(&cifs_lock_secret, sizeof(cifs_lock_secret));
+
         if (cifs_max_pending < 2) {
                 cifs_max_pending = 2;
                 cifs_dbg(FYI, "cifs_max_pending set to min of 2\n");
diff --git a/fs/cifs/cifsglob.h b/fs/cifs/cifsglob.h
index bba106cdc43c..8f1d8c1e72be 100644
--- a/fs/cifs/cifsglob.h
+++ b/fs/cifs/cifsglob.h
@@ -1619,6 +1619,7 @@ void cifs_oplock_break(struct work_struct *work);
 
 extern const struct slow_work_ops cifs_oplock_break_ops;
 extern struct workqueue_struct *cifsiod_wq;
+extern __u32 cifs_lock_secret;
 
 extern mempool_t *cifs_mid_poolp;
 
diff --git a/fs/cifs/connect.c b/fs/cifs/connect.c
index 66736f57b5ab..7d2b15c06090 100644
--- a/fs/cifs/connect.c
+++ b/fs/cifs/connect.c
@@ -428,7 +428,9 @@ cifs_echo_request(struct work_struct *work)
          * server->ops->need_neg() == true. Also, no need to ping if
          * we got a response recently.
          */
-        if (!server->ops->need_neg || server->ops->need_neg(server) ||
+
+        if (server->tcpStatus == CifsNeedReconnect ||
+            server->tcpStatus == CifsExiting || server->tcpStatus == CifsNew ||
             (server->ops->can_echo && !server->ops->can_echo(server)) ||
             time_before(jiffies, server->lstrp + echo_interval - HZ))
                 goto requeue_echo;
diff --git a/fs/cifs/file.c b/fs/cifs/file.c
index 9793ae0bcaa2..d4890b6dc22d 100644
--- a/fs/cifs/file.c
+++ b/fs/cifs/file.c
@@ -1112,6 +1112,12 @@ cifs_push_mandatory_locks(struct cifsFileInfo *cfile)
         return rc;
 }
 
+static __u32
+hash_lockowner(fl_owner_t owner)
+{
+        return cifs_lock_secret ^ hash32_ptr((const void *)owner);
+}
+
 struct lock_to_push {
         struct list_head llist;
         __u64 offset;
@@ -1178,7 +1184,7 @@ cifs_push_posix_locks(struct cifsFileInfo *cfile)
                 else
                         type = CIFS_WRLCK;
                 lck = list_entry(el, struct lock_to_push, llist);
-                lck->pid = flock->fl_pid;
+                lck->pid = hash_lockowner(flock->fl_owner);
                 lck->netfid = cfile->fid.netfid;
                 lck->length = length;
                 lck->type = type;
@@ -1305,7 +1311,8 @@ cifs_getlk(struct file *file, struct file_lock *flock, __u32 type,
                         posix_lock_type = CIFS_RDLCK;
                 else
                         posix_lock_type = CIFS_WRLCK;
-                rc = CIFSSMBPosixLock(xid, tcon, netfid, current->tgid,
+                rc = CIFSSMBPosixLock(xid, tcon, netfid,
+                                      hash_lockowner(flock->fl_owner),
                                       flock->fl_start, length, flock,
                                       posix_lock_type, wait_flag);
                 return rc;
@@ -1505,7 +1512,8 @@ cifs_setlk(struct file *file, struct file_lock *flock, __u32 type,
                         posix_lock_type = CIFS_UNLCK;
 
                 rc = CIFSSMBPosixLock(xid, tcon, cfile->fid.netfid,
-                                      current->tgid, flock->fl_start, length,
+                                      hash_lockowner(flock->fl_owner),
+                                      flock->fl_start, length,
                                       NULL, posix_lock_type, wait_flag);
                 goto out;
         }
diff --git a/fs/cifs/ntlmssp.h b/fs/cifs/ntlmssp.h
index 848249fa120f..3079b38f0afb 100644
--- a/fs/cifs/ntlmssp.h
+++ b/fs/cifs/ntlmssp.h
@@ -133,6 +133,6 @@ typedef struct _AUTHENTICATE_MESSAGE {
 
 int decode_ntlmssp_challenge(char *bcc_ptr, int blob_len, struct cifs_ses *ses);
 void build_ntlmssp_negotiate_blob(unsigned char *pbuffer, struct cifs_ses *ses);
-int build_ntlmssp_auth_blob(unsigned char *pbuffer, u16 *buflen,
+int build_ntlmssp_auth_blob(unsigned char **pbuffer, u16 *buflen,
                         struct cifs_ses *ses,
                         const struct nls_table *nls_cp);
diff --git a/fs/cifs/sess.c b/fs/cifs/sess.c
index af0ec2d5ad0e..538d9b55699a 100644
--- a/fs/cifs/sess.c
+++ b/fs/cifs/sess.c
@@ -364,19 +364,43 @@ void build_ntlmssp_negotiate_blob(unsigned char *pbuffer,
         sec_blob->DomainName.MaximumLength = 0;
 }
 
-/* We do not malloc the blob, it is passed in pbuffer, because its
-   maximum possible size is fixed and small, making this approach cleaner.
-   This function returns the length of the data in the blob */
-int build_ntlmssp_auth_blob(unsigned char *pbuffer,
+static int size_of_ntlmssp_blob(struct cifs_ses *ses)
+{
+        int sz = sizeof(AUTHENTICATE_MESSAGE) + ses->auth_key.len
+                - CIFS_SESS_KEY_SIZE + CIFS_CPHTXT_SIZE + 2;
+
+        if (ses->domainName)
+                sz += 2 * strnlen(ses->domainName, CIFS_MAX_DOMAINNAME_LEN);
+        else
+                sz += 2;
+
+        if (ses->user_name)
+                sz += 2 * strnlen(ses->user_name, CIFS_MAX_USERNAME_LEN);
+        else
+                sz += 2;
+
+        return sz;
+}
+
+int build_ntlmssp_auth_blob(unsigned char **pbuffer,
                                         u16 *buflen,
                                    struct cifs_ses *ses,
                                    const struct nls_table *nls_cp)
 {
         int rc;
-        AUTHENTICATE_MESSAGE *sec_blob = (AUTHENTICATE_MESSAGE *)pbuffer;
+        AUTHENTICATE_MESSAGE *sec_blob;
         __u32 flags;
         unsigned char *tmp;
 
+        rc = setup_ntlmv2_rsp(ses, nls_cp);
+        if (rc) {
+                cifs_dbg(VFS, "Error %d during NTLMSSP authentication\n", rc);
+                *buflen = 0;
+                goto setup_ntlmv2_ret;
+        }
+        *pbuffer = kmalloc(size_of_ntlmssp_blob(ses), GFP_KERNEL);
+        sec_blob = (AUTHENTICATE_MESSAGE *)*pbuffer;
+
         memcpy(sec_blob->Signature, NTLMSSP_SIGNATURE, 8);
         sec_blob->MessageType = NtLmAuthenticate;
 
@@ -391,7 +415,7 @@ int build_ntlmssp_auth_blob(unsigned char *pbuffer,
                         flags |= NTLMSSP_NEGOTIATE_KEY_XCH;
         }
 
-        tmp = pbuffer + sizeof(AUTHENTICATE_MESSAGE);
+        tmp = *pbuffer + sizeof(AUTHENTICATE_MESSAGE);
         sec_blob->NegotiateFlags = cpu_to_le32(flags);
 
         sec_blob->LmChallengeResponse.BufferOffset =
@@ -399,13 +423,9 @@ int build_ntlmssp_auth_blob(unsigned char *pbuffer,
         sec_blob->LmChallengeResponse.Length = 0;
         sec_blob->LmChallengeResponse.MaximumLength = 0;
 
-        sec_blob->NtChallengeResponse.BufferOffset = cpu_to_le32(tmp - pbuffer);
+        sec_blob->NtChallengeResponse.BufferOffset =
+                                cpu_to_le32(tmp - *pbuffer);
         if (ses->user_name != NULL) {
-                rc = setup_ntlmv2_rsp(ses, nls_cp);
-                if (rc) {
-                        cifs_dbg(VFS, "Error %d during NTLMSSP authentication\n", rc);
-                        goto setup_ntlmv2_ret;
-                }
                 memcpy(tmp, ses->auth_key.response + CIFS_SESS_KEY_SIZE,
                                 ses->auth_key.len - CIFS_SESS_KEY_SIZE);
                 tmp += ses->auth_key.len - CIFS_SESS_KEY_SIZE;
@@ -423,23 +443,23 @@ int build_ntlmssp_auth_blob(unsigned char *pbuffer,
         }
 
         if (ses->domainName == NULL) {
-                sec_blob->DomainName.BufferOffset = cpu_to_le32(tmp - pbuffer);
+                sec_blob->DomainName.BufferOffset = cpu_to_le32(tmp - *pbuffer);
                 sec_blob->DomainName.Length = 0;
                 sec_blob->DomainName.MaximumLength = 0;
                 tmp += 2;
         } else {
                 int len;
                 len = cifs_strtoUTF16((__le16 *)tmp, ses->domainName,
-                                      CIFS_MAX_USERNAME_LEN, nls_cp);
+                                      CIFS_MAX_DOMAINNAME_LEN, nls_cp);
                 len *= 2; /* unicode is 2 bytes each */
-                sec_blob->DomainName.BufferOffset = cpu_to_le32(tmp - pbuffer);
+                sec_blob->DomainName.BufferOffset = cpu_to_le32(tmp - *pbuffer);
                 sec_blob->DomainName.Length = cpu_to_le16(len);
                 sec_blob->DomainName.MaximumLength = cpu_to_le16(len);
                 tmp += len;
         }
 
         if (ses->user_name == NULL) {
-                sec_blob->UserName.BufferOffset = cpu_to_le32(tmp - pbuffer);
+                sec_blob->UserName.BufferOffset = cpu_to_le32(tmp - *pbuffer);
                 sec_blob->UserName.Length = 0;
                 sec_blob->UserName.MaximumLength = 0;
                 tmp += 2;
@@ -448,13 +468,13 @@ int build_ntlmssp_auth_blob(unsigned char *pbuffer,
                 len = cifs_strtoUTF16((__le16 *)tmp, ses->user_name,
                                       CIFS_MAX_USERNAME_LEN, nls_cp);
                 len *= 2; /* unicode is 2 bytes each */
-                sec_blob->UserName.BufferOffset = cpu_to_le32(tmp - pbuffer);
+                sec_blob->UserName.BufferOffset = cpu_to_le32(tmp - *pbuffer);
                 sec_blob->UserName.Length = cpu_to_le16(len);
                 sec_blob->UserName.MaximumLength = cpu_to_le16(len);
                 tmp += len;
         }
 
-        sec_blob->WorkstationName.BufferOffset = cpu_to_le32(tmp - pbuffer);
+        sec_blob->WorkstationName.BufferOffset = cpu_to_le32(tmp - *pbuffer);
         sec_blob->WorkstationName.Length = 0;
         sec_blob->WorkstationName.MaximumLength = 0;
         tmp += 2;
@@ -463,19 +483,19 @@ int build_ntlmssp_auth_blob(unsigned char *pbuffer,
                 (ses->ntlmssp->server_flags & NTLMSSP_NEGOTIATE_EXTENDED_SEC))
                         && !calc_seckey(ses)) {
                 memcpy(tmp, ses->ntlmssp->ciphertext, CIFS_CPHTXT_SIZE);
-                sec_blob->SessionKey.BufferOffset = cpu_to_le32(tmp - pbuffer);
+                sec_blob->SessionKey.BufferOffset = cpu_to_le32(tmp - *pbuffer);
                 sec_blob->SessionKey.Length = cpu_to_le16(CIFS_CPHTXT_SIZE);
                 sec_blob->SessionKey.MaximumLength =
                                 cpu_to_le16(CIFS_CPHTXT_SIZE);
                 tmp += CIFS_CPHTXT_SIZE;
         } else {
-                sec_blob->SessionKey.BufferOffset = cpu_to_le32(tmp - pbuffer);
+                sec_blob->SessionKey.BufferOffset = cpu_to_le32(tmp - *pbuffer);
                 sec_blob->SessionKey.Length = 0;
                 sec_blob->SessionKey.MaximumLength = 0;
         }
 
+        *buflen = tmp - *pbuffer;
 setup_ntlmv2_ret:
-        *buflen = tmp - pbuffer;
         return rc;
 }
 
@@ -690,6 +710,8 @@ sess_auth_lanman(struct sess_data *sess_data)
                 rc = calc_lanman_hash(ses->password, ses->server->cryptkey,
                                       ses->server->sec_mode & SECMODE_PW_ENCRYPT ?
                                       true : false, lnm_session_key);
+                if (rc)
+                        goto out;
 
                 memcpy(bcc_ptr, (char *)lnm_session_key, CIFS_AUTH_RESP_SIZE);
                 bcc_ptr += CIFS_AUTH_RESP_SIZE;
@@ -1266,7 +1288,7 @@ sess_auth_rawntlmssp_authenticate(struct sess_data *sess_data)
         struct cifs_ses *ses = sess_data->ses;
         __u16 bytes_remaining;
         char *bcc_ptr;
-        char *ntlmsspblob = NULL;
+        unsigned char *ntlmsspblob = NULL;
         u16 blob_len;
 
         cifs_dbg(FYI, "rawntlmssp session setup authenticate phase\n");
@@ -1279,19 +1301,7 @@ sess_auth_rawntlmssp_authenticate(struct sess_data *sess_data)
         /* Build security blob before we assemble the request */
         pSMB = (SESSION_SETUP_ANDX *)sess_data->iov[0].iov_base;
         smb_buf = (struct smb_hdr *)pSMB;
-        /*
-         * 5 is an empirical value, large enough to hold
-         * authenticate message plus max 10 of av paris,
-         * domain, user, workstation names, flags, etc.
-         */
-        ntlmsspblob = kzalloc(5*sizeof(struct _AUTHENTICATE_MESSAGE),
-                                GFP_KERNEL);
-        if (!ntlmsspblob) {
-                rc = -ENOMEM;
-                goto out;
-        }
-
-        rc = build_ntlmssp_auth_blob(ntlmsspblob,
+        rc = build_ntlmssp_auth_blob(&ntlmsspblob,
                                         &blob_len, ses, sess_data->nls_cp);
         if (rc)
                 goto out_free_ntlmsspblob;
diff --git a/fs/cifs/smb2pdu.c b/fs/cifs/smb2pdu.c
index 8f38e33d365b..29e06db5f187 100644
--- a/fs/cifs/smb2pdu.c
+++ b/fs/cifs/smb2pdu.c
@@ -588,7 +588,7 @@ SMB2_sess_setup(const unsigned int xid, struct cifs_ses *ses,
         u16 blob_length = 0;
         struct key *spnego_key = NULL;
         char *security_blob = NULL;
-        char *ntlmssp_blob = NULL;
+        unsigned char *ntlmssp_blob = NULL;
         bool use_spnego = false; /* else use raw ntlmssp */
 
         cifs_dbg(FYI, "Session Setup\n");
@@ -713,13 +713,7 @@ ssetup_ntlmssp_authenticate:
                 iov[1].iov_len = blob_length;
         } else if (phase == NtLmAuthenticate) {
                 req->hdr.SessionId = ses->Suid;
-                ntlmssp_blob = kzalloc(sizeof(struct _NEGOTIATE_MESSAGE) + 500,
-                                       GFP_KERNEL);
-                if (ntlmssp_blob == NULL) {
-                        rc = -ENOMEM;
-                        goto ssetup_exit;
-                }
-                rc = build_ntlmssp_auth_blob(ntlmssp_blob, &blob_length, ses,
+                rc = build_ntlmssp_auth_blob(&ntlmssp_blob, &blob_length, ses,
                                              nls_cp);
                 if (rc) {
                         cifs_dbg(FYI, "build_ntlmssp_auth_blob failed %d\n",
@@ -1818,6 +1812,33 @@ SMB2_echo(struct TCP_Server_Info *server)
 
         cifs_dbg(FYI, "In echo request\n");
 
+        if (server->tcpStatus == CifsNeedNegotiate) {
+                struct list_head *tmp, *tmp2;
+                struct cifs_ses *ses;
+                struct cifs_tcon *tcon;
+
+                cifs_dbg(FYI, "Need negotiate, reconnecting tcons\n");
+                spin_lock(&cifs_tcp_ses_lock);
+                list_for_each(tmp, &server->smb_ses_list) {
+                        ses = list_entry(tmp, struct cifs_ses, smb_ses_list);
+                        list_for_each(tmp2, &ses->tcon_list) {
+                                tcon = list_entry(tmp2, struct cifs_tcon,
+                                                  tcon_list);
+                                /* add check for persistent handle reconnect */
+                                if (tcon && tcon->need_reconnect) {
+                                        spin_unlock(&cifs_tcp_ses_lock);
+                                        rc = smb2_reconnect(SMB2_ECHO, tcon);
+                                        spin_lock(&cifs_tcp_ses_lock);
+                                }
+                        }
+                }
+                spin_unlock(&cifs_tcp_ses_lock);
+        }
+
+        /* if no session, renegotiate failed above */
+        if (server->tcpStatus == CifsNeedNegotiate)
+                return -EIO;
+
         rc = small_smb2_init(SMB2_ECHO, NULL, (void **)&req);
         if (rc)
                 return rc;