[CIFS] Remove sparse endian warnings

Removes two sparse CHECK_ENDIAN warnings from Jeffs earlier patch,
and removes the dead readlink code (after noting where in
findfirst we will need to add something like that in the future
to handle the newly discovered unexpected error on FindFirst of NTFS symlinks.

Signed-off-by: Steve French <sfrench@us.ibm.com>

diff --git a/fs/cifs/cifssmb.c b/fs/cifs/cifssmb.c
index df5276e628bfa5a6cac844f5dcf7f7555c8aedcb..b968e5bd7df3fb00d77a133cb0dd1cba736c5632 100644 (file)
--- a/fs/cifs/cifssmb.c
+++ b/fs/cifs/cifssmb.c
@@ -2451,16 +2451,20 @@ querySymLinkRetry:
                if (rc || (pSMBr->ByteCount < 2))
                        rc = -EIO;
                else {
+                       bool is_unicode;
                        u16 count = le16_to_cpu(pSMBr->t2.DataCount);
 
                        data_start = ((char *) &pSMBr->hdr.Protocol) +
                                           le16_to_cpu(pSMBr->t2.DataOffset);
 
+                       if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE)
+                               is_unicode = true;
+                       else
+                               is_unicode = false;
+
                        /* BB FIXME investigate remapping reserved chars here */
                        *symlinkinfo = cifs_strndup_from_ucs(data_start, count,
-                                                   pSMBr->hdr.Flags2 &
-                                                       SMBFLG2_UNICODE,
-                                                   nls_codepage);
+                                                   is_unicode, nls_codepage);
                        if (!symlinkinfo)
                                rc = -ENOMEM;
                }
@@ -3930,7 +3934,7 @@ parse_DFS_referrals(TRANSACTION2_GET_DFS_REFER_RSP *pSMBr,
 
        cFYI(1, ("num_referrals: %d dfs flags: 0x%x ... \n",
                        *num_of_nodes,
-                       le16_to_cpu(pSMBr->DFSFlags)));
+                       le32_to_cpu(pSMBr->DFSFlags)));
 
        *target_nodes = kzalloc(sizeof(struct dfs_info3_param) *
                        *num_of_nodes, GFP_KERNEL);
@@ -3946,7 +3950,7 @@ parse_DFS_referrals(TRANSACTION2_GET_DFS_REFER_RSP *pSMBr,
                int max_len;
                struct dfs_info3_param *node = (*target_nodes)+i;
 
-               node->flags = le16_to_cpu(pSMBr->DFSFlags);
+               node->flags = le32_to_cpu(pSMBr->DFSFlags);
                if (is_unicode) {
                        __le16 *tmp = kmalloc(strlen(searchName)*2 + 2,
                                                GFP_KERNEL);

diff --git a/fs/cifs/connect.c b/fs/cifs/connect.c
index 5bce2778163b86292f04b67b45a9ad088f5e3d36..9dcdb0c707ea5992d87c8397148c975ddbde9227 100644 (file)
--- a/fs/cifs/connect.c
+++ b/fs/cifs/connect.c
@@ -2681,8 +2681,6 @@ CIFSNTLMSSPNegotiateSessSetup(unsigned int xid,
            /* NTLMSSP_NEGOTIATE_ALWAYS_SIGN | */ NTLMSSP_NEGOTIATE_128;
        if (sign_CIFS_PDUs)
                negotiate_flags |= NTLMSSP_NEGOTIATE_SIGN;
-/*     if (ntlmv2_support)
-               negotiate_flags |= NTLMSSP_NEGOTIATE_NTLMV2;*/
        /* setup pointers to domain name and workstation name */
        bcc_ptr += SecurityBlobLength;
 
@@ -2780,9 +2778,10 @@ CIFSNTLMSSPNegotiateSessSetup(unsigned int xid,
                                memcpy(ses->server->cryptKey,
                                       SecurityBlob2->Challenge,
                                       CIFS_CRYPTO_KEY_SIZE);
-                               if (SecurityBlob2->NegotiateFlags &
+/* NTLMV2 flag is not for NTLMv2 password hash */
+/*                             if (SecurityBlob2->NegotiateFlags &
                                        cpu_to_le32(NTLMSSP_NEGOTIATE_NTLMV2))
-                                       *pNTLMv2_flag = true;
+                                       *pNTLMv2_flag = true; */ /* BB wrong */
 
                                if ((SecurityBlob2->NegotiateFlags &
                                        cpu_to_le32(NTLMSSP_NEGOTIATE_ALWAYS_SIGN))
@@ -3012,11 +3011,10 @@ CIFSNTLMSSPAuthSessSetup(unsigned int xid, struct cifsSesInfo *ses,
        bcc_ptr += SecurityBlobLength;
        negotiate_flags = NTLMSSP_NEGOTIATE_UNICODE | NTLMSSP_REQUEST_TARGET |
                        NTLMSSP_NEGOTIATE_NTLM | NTLMSSP_NEGOTIATE_TARGET_INFO |
-                       0x80000000 | NTLMSSP_NEGOTIATE_128;
+                       NTLMSSP_NEGOTIATE_56 | NTLMSSP_NEGOTIATE_128 |
+                       NTLMSSP_NEGOTIATE_EXTENDED_SEC;
        if (sign_CIFS_PDUs)
                negotiate_flags |= /* NTLMSSP_NEGOTIATE_ALWAYS_SIGN |*/ NTLMSSP_NEGOTIATE_SIGN;
-       if (ntlmv2_flag)
-               negotiate_flags |= NTLMSSP_NEGOTIATE_NTLMV2;
 
 /* setup pointers to domain name and workstation name */
 
@@ -3438,12 +3436,19 @@ CIFSTCon(unsigned int xid, struct cifsSesInfo *ses,
 
        /* above now done in SendReceive */
        if ((rc == 0) && (tcon != NULL)) {
+               bool is_unicode;
+
                tcon->tidStatus = CifsGood;
                tcon->need_reconnect = false;
                tcon->tid = smb_buffer_response->Tid;
                bcc_ptr = pByteArea(smb_buffer_response);
                bytes_left = BCC(smb_buffer_response);
                length = strnlen(bcc_ptr, bytes_left - 2);
+               if (smb_buffer->Flags2 & SMBFLG2_UNICODE)
+                       is_unicode = true;
+               else
+                       is_unicode = false;
+
 
                /* skip service field (NB: this field is always ASCII) */
                if (length == 3) {
@@ -3464,9 +3469,7 @@ CIFSTCon(unsigned int xid, struct cifsSesInfo *ses,
 
                /* mostly informational -- no need to fail on error here */
                tcon->nativeFileSystem = cifs_strndup_from_ucs(bcc_ptr,
-                                                     bytes_left,
-                                                     smb_buffer->Flags2 &
-                                                        SMBFLG2_UNICODE,
+                                                     bytes_left, is_unicode,
                                                      nls_codepage);
 
                cFYI(1, ("nativeFileSystem=%s", tcon->nativeFileSystem));

diff --git a/fs/cifs/link.c b/fs/cifs/link.c
index eb2fbbe865d24b4e86a493bc74015ce160bc5e55..ea9d11e3dcbb03a99aaccebb415b4a8032d36298 100644 (file)
--- a/fs/cifs/link.c
+++ b/fs/cifs/link.c
@@ -212,93 +212,6 @@ cifs_symlink(struct inode *inode, struct dentry *direntry, const char *symname)
        return rc;
 }
 
-int
-cifs_readlink(struct dentry *direntry, char __user *pBuffer, int buflen)
-{
-       struct inode *inode = direntry->d_inode;
-       int rc = -EACCES;
-       int xid;
-       int oplock = 0;
-       struct cifs_sb_info *cifs_sb;
-       struct cifsTconInfo *pTcon;
-       char *full_path = NULL;
-       char *tmpbuffer;
-       int len;
-       __u16 fid;
-
-       xid = GetXid();
-       cifs_sb = CIFS_SB(inode->i_sb);
-       pTcon = cifs_sb->tcon;
-
-/* BB would it be safe against deadlock to grab this sem
-      even though rename itself grabs the sem and calls lookup? */
-/*       mutex_lock(&inode->i_sb->s_vfs_rename_mutex);*/
-       full_path = build_path_from_dentry(direntry);
-/*       mutex_unlock(&inode->i_sb->s_vfs_rename_mutex);*/
-
-       if (full_path == NULL) {
-               FreeXid(xid);
-               return -ENOMEM;
-       }
-
-       cFYI(1,
-            ("Full path: %s inode = 0x%p pBuffer = 0x%p buflen = %d",
-             full_path, inode, pBuffer, buflen));
-       if (buflen > PATH_MAX)
-               len = PATH_MAX;
-       else
-               len = buflen;
-       tmpbuffer = kmalloc(len, GFP_KERNEL);
-       if (tmpbuffer == NULL) {
-               kfree(full_path);
-               FreeXid(xid);
-               return -ENOMEM;
-       }
-
-/* BB add read reparse point symlink code and
-       Unix extensions symlink code here BB */
-
-       if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL) {
-               cERROR(1, ("SFU style symlinks not implemented yet"));
-               /* add open and read as in fs/cifs/inode.c */
-       } else {
-               rc = CIFSSMBOpen(xid, pTcon, full_path, FILE_OPEN, GENERIC_READ,
-                               OPEN_REPARSE_POINT, &fid, &oplock, NULL,
-                               cifs_sb->local_nls,
-                               cifs_sb->mnt_cifs_flags &
-                                       CIFS_MOUNT_MAP_SPECIAL_CHR);
-               if (!rc) {
-                       rc = CIFSSMBQueryReparseLinkInfo(xid, pTcon, full_path,
-                               tmpbuffer,
-                               len - 1,
-                               fid,
-                               cifs_sb->local_nls);
-                       if (CIFSSMBClose(xid, pTcon, fid)) {
-                               cFYI(1, ("Error closing junction point "
-                                        "(open for ioctl)"));
-                       }
-                       /* If it is a DFS junction earlier we would have gotten
-                          PATH_NOT_COVERED returned from server so we do
-                          not need to request the DFS info here */
-               }
-       }
-       /* BB Anything else to do to handle recursive links? */
-       /* BB Should we be using page ops here? */
-
-       /* BB null terminate returned string in pBuffer? BB */
-       if (rc == 0) {
-               rc = vfs_readlink(direntry, pBuffer, len, tmpbuffer);
-               cFYI(1,
-                    ("vfs_readlink called from cifs_readlink returned %d",
-                     rc));
-       }
-
-       kfree(tmpbuffer);
-       kfree(full_path);
-       FreeXid(xid);
-       return rc;
-}
-
 void cifs_put_link(struct dentry *direntry, struct nameidata *nd, void *cookie)
 {
        char *p = nd_get_link(nd);

diff --git a/fs/cifs/readdir.c b/fs/cifs/readdir.c
index 5bc9ab7586bc6cfa8f5b56f4edd8f82fdea3bfe1..df003fe3710fcfe478d99ebcd169aa53f847d692 100644 (file)
--- a/fs/cifs/readdir.c
+++ b/fs/cifs/readdir.c
@@ -445,6 +445,38 @@ static void unix_fill_in_inode(struct inode *tmp_inode,
        }
 }
 
+/* BB eventually need to add the following helper function to
+      resolve NT_STATUS_STOPPED_ON_SYMLINK return code when
+      we try to do FindFirst on (NTFS) directory symlinks */
+/*
+int get_symlink_reparse_path(char *full_path, struct cifs_sb_info *cifs_sb,
+                            int xid)
+{
+       __u16 fid;
+       int len;
+       int oplock = 0;
+       int rc;
+       struct cifsTconInfo *ptcon = cifs_sb->tcon;
+       char *tmpbuffer;
+
+       rc = CIFSSMBOpen(xid, ptcon, full_path, FILE_OPEN, GENERIC_READ,
+                       OPEN_REPARSE_POINT, &fid, &oplock, NULL,
+                       cifs_sb->local_nls,
+                       cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
+       if (!rc) {
+               tmpbuffer = kmalloc(maxpath);
+               rc = CIFSSMBQueryReparseLinkInfo(xid, ptcon, full_path,
+                               tmpbuffer,
+                               maxpath -1,
+                               fid,
+                               cifs_sb->local_nls);
+               if (CIFSSMBClose(xid, ptcon, fid)) {
+                       cFYI(1, ("Error closing temporary reparsepoint open)"));
+               }
+       }
+}
+ */
+
 static int initiate_cifs_search(const int xid, struct file *file)
 {
        int rc = 0;
@@ -500,7 +532,10 @@ ffirst_retry:
                        CIFS_MOUNT_MAP_SPECIAL_CHR, CIFS_DIR_SEP(cifs_sb));
        if (rc == 0)
                cifsFile->invalidHandle = false;
-       if ((rc == -EOPNOTSUPP) &&
+       /* BB add following call to handle readdir on new NTFS symlink errors 
+       else if STATUS_STOPPED_ON_SYMLINK
+               call get_symlink_reparse_path and retry with new path */
+       else if ((rc == -EOPNOTSUPP) &&
                (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)) {
                cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_SERVER_INUM;
                goto ffirst_retry;