7 files changed, 81 insertions, 51 deletions

diff --git a/fs/cifs/CHANGES b/fs/cifs/CHANGES
index 1eb9a2ec0a..0b3c37ef52 100644
--- a/fs/cifs/CHANGES
+++ b/fs/cifs/CHANGES
@@ -1,6 +1,11 @@
 Version 1.46
 ------------
 Support deep tree mounts.  Better support OS/2, Win9x (DOS) time stamps.
+Allow null user to be specified on mount ("username="). Do not return
+EINVAL on readdir when filldir fails due to overwritten blocksize
+(fixes FC problem).  Return error in rename 2nd attempt retry (ie report
+if rename by handle also fails, after rename by path fails, we were
+not reporting whether the retry worked or not).
 
 Version 1.45
 ------------
diff --git a/fs/cifs/connect.c b/fs/cifs/connect.c
index 4093d53329..71f77914ce 100644
--- a/fs/cifs/connect.c
+++ b/fs/cifs/connect.c
@@ -822,10 +822,13 @@ cifs_parse_mount_options(char *options, const char *devname,struct smb_vol *vol)
                 } else if (strnicmp(data, "nouser_xattr",12) == 0) {
                         vol->no_xattr = 1;
                 } else if (strnicmp(data, "user", 4) == 0) {
-                        if (!value || !*value) {
+                        if (!value) {
                                 printk(KERN_WARNING
                                        "CIFS: invalid or missing username\n");
                                 return 1;       /* needs_arg; */
+                        } else if(!*value) {
+                                /* null user, ie anonymous, authentication */
+                                vol->nullauth = 1;
                         }
                         if (strnlen(value, 200) < 200) {
                                 vol->username = value;
@@ -1642,6 +1645,8 @@ cifs_mount(struct super_block *sb, struct cifs_sb_info *cifs_sb,
                 /* BB fixme parse for domain name here */
                 cFYI(1, ("Username: %s ", volume_info.username));
 
+        } else if (volume_info.nullauth) {
+                cFYI(1,("null user"));
         } else {
                 cifserror("No username specified");
         /* In userspace mount helper we can get user name from alternate
diff --git a/fs/cifs/file.c b/fs/cifs/file.c
index 976a691c5a..2436ed8fc8 100644
--- a/fs/cifs/file.c
+++ b/fs/cifs/file.c
@@ -492,10 +492,14 @@ int cifs_close(struct inode *inode, struct file *file)
                                         the struct would be in each open file,
                                         but this should give enough time to 
                                         clear the socket */
-                                        cERROR(1,("close with pending writes"));
+#ifdef CONFIG_CIFS_DEBUG2
+                                        cFYI(1,("close delay, write pending"));
+#endif /* DEBUG2 */
                                         msleep(timeout);
                                         timeout *= 4;
-                                } 
+                                }
+                                if(atomic_read(&pSMBFile->wrtPending))
+                                        cERROR(1,("close with pending writes"));
                                 rc = CIFSSMBClose(xid, pTcon,
                                                   pSMBFile->netfid);
                         }
@@ -1806,13 +1810,6 @@ static int cifs_readpages(struct file *file, struct address_space *mapping,
                 }
                 if ((rc < 0) || (smb_read_data == NULL)) {
                         cFYI(1, ("Read error in readpages: %d", rc));
-                        /* clean up remaing pages off list */
-                        while (!list_empty(page_list) && (i < num_pages)) {
-                                page = list_entry(page_list->prev, struct page,
-                                                  lru);
-                                list_del(&page->lru);
-                                page_cache_release(page);
-                        }
                         break;
                 } else if (bytes_read > 0) {
                         pSMBr = (struct smb_com_read_rsp *)smb_read_data;
@@ -1831,13 +1828,7 @@ static int cifs_readpages(struct file *file, struct address_space *mapping,
                                    this case is ok - if we are at server EOF 
                                    we will hit it on next read */
 
-                        /* while (!list_empty(page_list) && (i < num_pages)) {
-                                        page = list_entry(page_list->prev, 
-                                                          struct page, list);
-                                        list_del(&page->list);
-                                        page_cache_release(page);
-                                }
-                                break; */
+                                /* break; */
                         }
                 } else {
                         cFYI(1, ("No bytes read (%d) at offset %lld . "
@@ -1845,14 +1836,6 @@ static int cifs_readpages(struct file *file, struct address_space *mapping,
                                  bytes_read, offset));
                         /* BB turn off caching and do new lookup on 
                            file size at server? */
-                        while (!list_empty(page_list) && (i < num_pages)) {
-                                page = list_entry(page_list->prev, struct page,
-                                                  lru);
-                                list_del(&page->lru);
-
-                                /* BB removeme - replace with zero of page? */
-                                page_cache_release(page);
-                        }
                         break;
                 }
                 if (smb_read_data) {
diff --git a/fs/cifs/inode.c b/fs/cifs/inode.c
index 35d54bb086..c4fa91b8b6 100644
--- a/fs/cifs/inode.c
+++ b/fs/cifs/inode.c
@@ -318,6 +318,7 @@ int cifs_get_inode_info(struct inode **pinode,
         struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
         char *tmp_path;
         char *buf = NULL;
+        int adjustTZ = FALSE;
 
         pTcon = cifs_sb->tcon;
         cFYI(1,("Getting info on %s", search_path));
@@ -348,6 +349,7 @@ int cifs_get_inode_info(struct inode **pinode,
                                         pfindData, cifs_sb->local_nls, 
                                         cifs_sb->mnt_cifs_flags &
                                           CIFS_MOUNT_MAP_SPECIAL_CHR);
+                        adjustTZ = TRUE;
                 }
                 
         }
@@ -444,6 +446,10 @@ int cifs_get_inode_info(struct inode **pinode,
                 inode->i_ctime =
                     cifs_NTtimeToUnix(le64_to_cpu(pfindData->ChangeTime));
                 cFYI(0, ("Attributes came in as 0x%x", attr));
+                if(adjustTZ && (pTcon->ses) && (pTcon->ses->server)) {
+                        inode->i_ctime.tv_sec += pTcon->ses->server->timeAdj;
+                        inode->i_mtime.tv_sec += pTcon->ses->server->timeAdj;
+                }
 
                 /* set default mode. will override for dirs below */
                 if (atomic_read(&cifsInfo->inUse) == 0)
@@ -885,10 +891,14 @@ int cifs_rename(struct inode *source_inode, struct dentry *source_direntry,
                         kmalloc(2 * sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
                 if (info_buf_source != NULL) {
                         info_buf_target = info_buf_source + 1;
-                        rc = CIFSSMBUnixQPathInfo(xid, pTcon, fromName,
-                                info_buf_source, cifs_sb_source->local_nls, 
-                                cifs_sb_source->mnt_cifs_flags &
-                                        CIFS_MOUNT_MAP_SPECIAL_CHR);
+                        if (pTcon->ses->capabilities & CAP_UNIX)
+                                rc = CIFSSMBUnixQPathInfo(xid, pTcon, fromName,
+                                        info_buf_source, 
+                                        cifs_sb_source->local_nls,
+                                        cifs_sb_source->mnt_cifs_flags &
+                                                CIFS_MOUNT_MAP_SPECIAL_CHR);
+                        /* else rc is still EEXIST so will fall through to
+                           unlink the target and retry rename */
                         if (rc == 0) {
                                 rc = CIFSSMBUnixQPathInfo(xid, pTcon, toName,
                                                 info_buf_target,
@@ -937,7 +947,7 @@ int cifs_rename(struct inode *source_inode, struct dentry *source_direntry,
                                  cifs_sb_source->mnt_cifs_flags & 
                                         CIFS_MOUNT_MAP_SPECIAL_CHR);
                 if (rc==0) {
-                        CIFSSMBRenameOpenFile(xid, pTcon, netfid, toName,
+                        rc = CIFSSMBRenameOpenFile(xid, pTcon, netfid, toName,
                                               cifs_sb_source->local_nls, 
                                               cifs_sb_source->mnt_cifs_flags &
                                                 CIFS_MOUNT_MAP_SPECIAL_CHR);
@@ -1085,8 +1095,10 @@ int cifs_getattr(struct vfsmount *mnt, struct dentry *dentry,
         struct kstat *stat)
 {
         int err = cifs_revalidate(dentry);
-        if (!err)
+        if (!err) {
                 generic_fillattr(dentry->d_inode, stat);
+                stat->blksize = CIFS_MAX_MSGSIZE;
+        }
         return err;
 }
 
diff --git a/fs/cifs/link.c b/fs/cifs/link.c
index 0bee8b7e52..8e25996935 100644
--- a/fs/cifs/link.c
+++ b/fs/cifs/link.c
@@ -69,17 +69,30 @@ cifs_hardlink(struct dentry *old_file, struct inode *inode,
                         rc = -EOPNOTSUPP;  
         }
 
-/* if (!rc)     */
-        {
-                /*   renew_parental_timestamps(old_file);
-                   inode->i_nlink++;
-                   mark_inode_dirty(inode);
-                   d_instantiate(direntry, inode); */
-                /* BB add call to either mark inode dirty or refresh its data and timestamp to current time */
+        d_drop(direntry);       /* force new lookup from server of target */
+
+        /* if source file is cached (oplocked) revalidate will not go to server
+           until the file is closed or oplock broken so update nlinks locally */
+        if(old_file->d_inode) {
+                cifsInode = CIFS_I(old_file->d_inode);
+                if(rc == 0) {
+                        old_file->d_inode->i_nlink++;
+                        old_file->d_inode->i_ctime = CURRENT_TIME;
+                        /* parent dir timestamps will update from srv
+                        within a second, would it really be worth it
+                        to set the parent dir cifs inode time to zero
+                        to force revalidate (faster) for it too? */
+                }
+                /* if not oplocked will force revalidate to get info 
+                   on source file from srv */
+                cifsInode->time = 0;
+
+                /* Will update parent dir timestamps from srv within a second.
+                   Would it really be worth it to set the parent dir (cifs
+                   inode) time field to zero to force revalidate on parent
+                   directory faster ie 
+                        CIFS_I(inode)->time = 0;  */
         }
-        d_drop(direntry);       /* force new lookup from server */
-        cifsInode = CIFS_I(old_file->d_inode);
-        cifsInode->time = 0;    /* will force revalidate to go get info when needed */
 
 cifs_hl_exit:
         kfree(fromName);
diff --git a/fs/cifs/readdir.c b/fs/cifs/readdir.c
index b5b0a2a41b..ed18c3965f 100644
--- a/fs/cifs/readdir.c
+++ b/fs/cifs/readdir.c
@@ -896,6 +896,10 @@ static int cifs_filldir(char *pfindEntry, struct file *file,
                      tmp_inode->i_ino,obj_type);
         if(rc) {
                 cFYI(1,("filldir rc = %d",rc));
+                /* we can not return filldir errors to the caller
+                since they are "normal" when the stat blocksize
+                is too small - we return remapped error instead */
+                rc = -EOVERFLOW;
         }
 
         dput(tmp_dentry);
@@ -1074,6 +1078,11 @@ int cifs_readdir(struct file *file, void *direntry, filldir_t filldir)
                         we want to check for that here? */
                         rc = cifs_filldir(current_entry, file,
                                         filldir, direntry, tmp_buf, max_len);
+                        if(rc == -EOVERFLOW) {
+                                rc = 0;
+                                break;
+                        }
+
                         file->f_pos++;
                         if(file->f_pos == 
                                 cifsFile->srch_inf.index_of_last_entry) {
diff --git a/fs/cifs/sess.c b/fs/cifs/sess.c
index a8a083543b..bbdda99dce 100644
--- a/fs/cifs/sess.c
+++ b/fs/cifs/sess.c
@@ -90,7 +90,9 @@ static void unicode_ssetup_strings(char ** pbcc_area, struct cifsSesInfo *ses,
         } */
         /* copy user */
         if(ses->userName == NULL) {
-                /* BB what about null user mounts - check that we do this BB */
+                /* null user mount */
+                *bcc_ptr = 0;
+                *(bcc_ptr+1) = 0;
         } else { /* 300 should be long enough for any conceivable user name */
                 bytes_ret = cifs_strtoUCS((__le16 *) bcc_ptr, ses->userName,
                                           300, nls_cp);
@@ -98,10 +100,13 @@ static void unicode_ssetup_strings(char ** pbcc_area, struct cifsSesInfo *ses,
         bcc_ptr += 2 * bytes_ret;
         bcc_ptr += 2; /* account for null termination */
         /* copy domain */
-        if(ses->domainName == NULL)
-                bytes_ret = cifs_strtoUCS((__le16 *) bcc_ptr,
-                                          "CIFS_LINUX_DOM", 32, nls_cp);
-        else
+        if(ses->domainName == NULL) {
+                /* Sending null domain better than using a bogus domain name (as
+                we did briefly in 2.6.18) since server will use its default */
+                *bcc_ptr = 0;
+                *(bcc_ptr+1) = 0;
+                bytes_ret = 0;
+        } else
                 bytes_ret = cifs_strtoUCS((__le16 *) bcc_ptr, ses->domainName, 
                                           256, nls_cp);
         bcc_ptr += 2 * bytes_ret;
@@ -144,13 +149,11 @@ static void ascii_ssetup_strings(char ** pbcc_area, struct cifsSesInfo *ses,
 
         /* copy domain */
         
-        if(ses->domainName == NULL) {
-                strcpy(bcc_ptr, "CIFS_LINUX_DOM");
-                bcc_ptr += 14;  /* strlen(CIFS_LINUX_DOM) */
-        } else {
+        if(ses->domainName != NULL) {
                 strncpy(bcc_ptr, ses->domainName, 256); 
                 bcc_ptr += strnlen(ses->domainName, 256);
-        }
+        } /* else we will send a null domain name 
+             so the server will default to its own domain */
         *bcc_ptr = 0;
         bcc_ptr++;