SAFE public projects git trees. - safe/jmp/linux-2.6/blob - fs/cifs/readdir.c

   1 /*
   2  *   fs/cifs/readdir.c
   3  *
   4  *   Directory search handling
   5  *
   6  *   Copyright (C) International Business Machines  Corp., 2004, 2007
   7  *   Author(s): Steve French (sfrench@us.ibm.com)
   8  *
   9  *   This library is free software; you can redistribute it and/or modify
  10  *   it under the terms of the GNU Lesser General Public License as published
  11  *   by the Free Software Foundation; either version 2.1 of the License, or
  12  *   (at your option) any later version.
  13  *
  14  *   This library is distributed in the hope that it will be useful,
  15  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
  17  *   the GNU Lesser General Public License for more details.
  18  *
  19  *   You should have received a copy of the GNU Lesser General Public License
  20  *   along with this library; if not, write to the Free Software
  21  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  22  */
  23 #include <linux/fs.h>
  24 #include <linux/pagemap.h>
  25 #include <linux/stat.h>
  26 #include <linux/smp_lock.h>
  27 #include "cifspdu.h"
  28 #include "cifsglob.h"
  29 #include "cifsproto.h"
  30 #include "cifs_unicode.h"
  31 #include "cifs_debug.h"
  32 #include "cifs_fs_sb.h"
  33 #include "cifsfs.h"
  34
  35 #ifdef CONFIG_CIFS_DEBUG2
  36 static void dump_cifs_file_struct(struct file *file, char *label)
  37 {
  38         struct cifsFileInfo * cf;
  39
  40         if(file) {
  41                 cf = file->private_data;
  42                 if(cf == NULL) {
  43                         cFYI(1,("empty cifs private file data"));
  44                         return;
  45                 }
  46                 if(cf->invalidHandle) {
  47                         cFYI(1,("invalid handle"));
  48                 }
  49                 if(cf->srch_inf.endOfSearch) {
  50                         cFYI(1,("end of search"));
  51                 }
  52                 if(cf->srch_inf.emptyDir) {
  53                         cFYI(1,("empty dir"));
  54                 }
  55
  56         }
  57 }
  58 #endif /* DEBUG2 */
  59
  60 /* Returns one if new inode created (which therefore needs to be hashed) */
  61 /* Might check in the future if inode number changed so we can rehash inode */
  62 static int construct_dentry(struct qstr *qstring, struct file *file,
  63         struct inode **ptmp_inode, struct dentry **pnew_dentry)
  64 {
  65         struct dentry *tmp_dentry;
  66         struct cifs_sb_info *cifs_sb;
  67         struct cifsTconInfo *pTcon;
  68         int rc = 0;
  69
  70         cFYI(1, ("For %s", qstring->name));
  71         cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
  72         pTcon = cifs_sb->tcon;
  73
  74         qstring->hash = full_name_hash(qstring->name, qstring->len);
  75         tmp_dentry = d_lookup(file->f_path.dentry, qstring);
  76         if (tmp_dentry) {
  77                 cFYI(0, ("existing dentry with inode 0x%p", tmp_dentry->d_inode));
  78                 *ptmp_inode = tmp_dentry->d_inode;
  79 /* BB overwrite old name? i.e. tmp_dentry->d_name and tmp_dentry->d_name.len??*/
  80                 if(*ptmp_inode == NULL) {
  81                         *ptmp_inode = new_inode(file->f_path.dentry->d_sb);
  82                         if(*ptmp_inode == NULL)
  83                                 return rc;
  84                         rc = 1;
  85                 }
  86                 if(file->f_path.dentry->d_sb->s_flags & MS_NOATIME)
  87                         (*ptmp_inode)->i_flags |= S_NOATIME | S_NOCMTIME;
  88         } else {
  89                 tmp_dentry = d_alloc(file->f_path.dentry, qstring);
  90                 if(tmp_dentry == NULL) {
  91                         cERROR(1,("Failed allocating dentry"));
  92                         *ptmp_inode = NULL;
  93                         return rc;
  94                 }
  95
  96                 *ptmp_inode = new_inode(file->f_path.dentry->d_sb);
  97                 if (pTcon->nocase)
  98                         tmp_dentry->d_op = &cifs_ci_dentry_ops;
  99                 else
 100                         tmp_dentry->d_op = &cifs_dentry_ops;
 101                 if(*ptmp_inode == NULL)
 102                         return rc;
 103                 if(file->f_path.dentry->d_sb->s_flags & MS_NOATIME)
 104                         (*ptmp_inode)->i_flags |= S_NOATIME | S_NOCMTIME;
 105                 rc = 2;
 106         }
 107
 108         tmp_dentry->d_time = jiffies;
 109         *pnew_dentry = tmp_dentry;
 110         return rc;
 111 }
 112
 113 static void AdjustForTZ(struct cifsTconInfo * tcon, struct inode * inode)
 114 {
 115         if((tcon) && (tcon->ses) && (tcon->ses->server)) {
 116                 inode->i_ctime.tv_sec += tcon->ses->server->timeAdj;
 117                 inode->i_mtime.tv_sec += tcon->ses->server->timeAdj;
 118                 inode->i_atime.tv_sec += tcon->ses->server->timeAdj;
 119         }
 120         return;
 121 }
 122
 123
 124 static void fill_in_inode(struct inode *tmp_inode, int new_buf_type,
 125                 char * buf, int *pobject_type, int isNewInode)
 126 {
 127         loff_t local_size;
 128         struct timespec local_mtime;
 129
 130         struct cifsInodeInfo *cifsInfo = CIFS_I(tmp_inode);
 131         struct cifs_sb_info *cifs_sb = CIFS_SB(tmp_inode->i_sb);
 132         __u32 attr;
 133         __u64 allocation_size;
 134         __u64 end_of_file;
 135
 136         /* save mtime and size */
 137         local_mtime = tmp_inode->i_mtime;
 138         local_size  = tmp_inode->i_size;
 139
 140         if(new_buf_type) {
 141                 FILE_DIRECTORY_INFO *pfindData = (FILE_DIRECTORY_INFO *)buf;
 142
 143                 attr = le32_to_cpu(pfindData->ExtFileAttributes);
 144                 allocation_size = le64_to_cpu(pfindData->AllocationSize);
 145                 end_of_file = le64_to_cpu(pfindData->EndOfFile);
 146                 tmp_inode->i_atime =
 147                       cifs_NTtimeToUnix(le64_to_cpu(pfindData->LastAccessTime));
 148                 tmp_inode->i_mtime =
 149                       cifs_NTtimeToUnix(le64_to_cpu(pfindData->LastWriteTime));
 150                 tmp_inode->i_ctime =
 151                       cifs_NTtimeToUnix(le64_to_cpu(pfindData->ChangeTime));
 152         } else { /* legacy, OS2 and DOS style */
 153 /*              struct timespec ts;*/
 154                 FIND_FILE_STANDARD_INFO * pfindData =
 155                         (FIND_FILE_STANDARD_INFO *)buf;
 156
 157                 tmp_inode->i_mtime = cnvrtDosUnixTm(
 158                                 le16_to_cpu(pfindData->LastWriteDate),
 159                                 le16_to_cpu(pfindData->LastWriteTime));
 160                 tmp_inode->i_atime = cnvrtDosUnixTm(
 161                                 le16_to_cpu(pfindData->LastAccessDate),
 162                                 le16_to_cpu(pfindData->LastAccessTime));
 163                 tmp_inode->i_ctime = cnvrtDosUnixTm(
 164                                 le16_to_cpu(pfindData->LastWriteDate),
 165                                 le16_to_cpu(pfindData->LastWriteTime));
 166                 AdjustForTZ(cifs_sb->tcon, tmp_inode);
 167                 attr = le16_to_cpu(pfindData->Attributes);
 168                 allocation_size = le32_to_cpu(pfindData->AllocationSize);
 169                 end_of_file = le32_to_cpu(pfindData->DataSize);
 170         }
 171
 172         /* Linux can not store file creation time unfortunately so ignore it */
 173
 174         cifsInfo->cifsAttrs = attr;
 175         cifsInfo->time = jiffies;
 176
 177         /* treat dos attribute of read-only as read-only mode bit e.g. 555? */
 178         /* 2767 perms - indicate mandatory locking */
 179                 /* BB fill in uid and gid here? with help from winbind?
 180                    or retrieve from NTFS stream extended attribute */
 181         if (atomic_read(&cifsInfo->inUse) == 0) {
 182                 tmp_inode->i_uid = cifs_sb->mnt_uid;
 183                 tmp_inode->i_gid = cifs_sb->mnt_gid;
 184                 /* set default mode. will override for dirs below */
 185                 tmp_inode->i_mode = cifs_sb->mnt_file_mode;
 186         } else {
 187                 /* mask off the type bits since it gets set
 188                 below and we do not want to get two type
 189                 bits set */
 190                 tmp_inode->i_mode &= ~S_IFMT;
 191         }
 192
 193         if (attr & ATTR_DIRECTORY) {
 194                 *pobject_type = DT_DIR;
 195                 /* override default perms since we do not lock dirs */
 196                 if(atomic_read(&cifsInfo->inUse) == 0) {
 197                         tmp_inode->i_mode = cifs_sb->mnt_dir_mode;
 198                 }
 199                 tmp_inode->i_mode |= S_IFDIR;
 200         } else if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL) &&
 201                    (attr & ATTR_SYSTEM)) {
 202                 if (end_of_file == 0)  {
 203                         *pobject_type = DT_FIFO;
 204                         tmp_inode->i_mode |= S_IFIFO;
 205                 } else {
 206                         /* rather than get the type here, we mark the
 207                         inode as needing revalidate and get the real type
 208                         (blk vs chr vs. symlink) later ie in lookup */
 209                         *pobject_type = DT_REG;
 210                         tmp_inode->i_mode |= S_IFREG;
 211                         cifsInfo->time = 0;
 212                 }
 213 /* we no longer mark these because we could not follow them */
 214 /*        } else if (attr & ATTR_REPARSE) {
 215                 *pobject_type = DT_LNK;
 216                 tmp_inode->i_mode |= S_IFLNK; */
 217         } else {
 218                 *pobject_type = DT_REG;
 219                 tmp_inode->i_mode |= S_IFREG;
 220                 if (attr & ATTR_READONLY)
 221                         tmp_inode->i_mode &= ~(S_IWUGO);
 222         } /* could add code here - to validate if device or weird share type? */
 223
 224         /* can not fill in nlink here as in qpathinfo version and Unx search */
 225         if (atomic_read(&cifsInfo->inUse) == 0) {
 226                 atomic_set(&cifsInfo->inUse, 1);
 227         }
 228
 229         spin_lock(&tmp_inode->i_lock);
 230         if (is_size_safe_to_change(cifsInfo, end_of_file)) {
 231                 /* can not safely change the file size here if the
 232                 client is writing to it due to potential races */
 233                 i_size_write(tmp_inode, end_of_file);
 234
 235         /* 512 bytes (2**9) is the fake blocksize that must be used */
 236         /* for this calculation, even though the reported blocksize is larger */
 237                 tmp_inode->i_blocks = (512 - 1 + allocation_size) >> 9;
 238         }
 239         spin_unlock(&tmp_inode->i_lock);
 240
 241         if (allocation_size < end_of_file)
 242                 cFYI(1, ("May be sparse file, allocation less than file size"));
 243         cFYI(1, ("File Size %ld and blocks %llu",
 244                 (unsigned long)tmp_inode->i_size,
 245                 (unsigned long long)tmp_inode->i_blocks));
 246         if (S_ISREG(tmp_inode->i_mode)) {
 247                 cFYI(1, ("File inode"));
 248                 tmp_inode->i_op = &cifs_file_inode_ops;
 249                 if(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
 250                         if(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
 251                                 tmp_inode->i_fop = &cifs_file_direct_nobrl_ops;
 252                         else
 253                                 tmp_inode->i_fop = &cifs_file_direct_ops;
 254
 255                 } else if(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
 256                         tmp_inode->i_fop = &cifs_file_nobrl_ops;
 257                 else
 258                         tmp_inode->i_fop = &cifs_file_ops;
 259
 260                 if((cifs_sb->tcon) && (cifs_sb->tcon->ses) &&
 261                    (cifs_sb->tcon->ses->server->maxBuf <
 262                         PAGE_CACHE_SIZE + MAX_CIFS_HDR_SIZE))
 263                         tmp_inode->i_data.a_ops = &cifs_addr_ops_smallbuf;
 264                 else
 265                         tmp_inode->i_data.a_ops = &cifs_addr_ops;
 266
 267                 if(isNewInode)
 268                         return; /* No sense invalidating pages for new inode
 269                                    since have not started caching readahead file
 270                                    data yet */
 271
 272                 if (timespec_equal(&tmp_inode->i_mtime, &local_mtime) &&
 273                         (local_size == tmp_inode->i_size)) {
 274                         cFYI(1, ("inode exists but unchanged"));
 275                 } else {
 276                         /* file may have changed on server */
 277                         cFYI(1, ("invalidate inode, readdir detected change"));
 278                         invalidate_remote_inode(tmp_inode);
 279                 }
 280         } else if (S_ISDIR(tmp_inode->i_mode)) {
 281                 cFYI(1, ("Directory inode"));
 282                 tmp_inode->i_op = &cifs_dir_inode_ops;
 283                 tmp_inode->i_fop = &cifs_dir_ops;
 284         } else if (S_ISLNK(tmp_inode->i_mode)) {
 285                 cFYI(1, ("Symbolic Link inode"));
 286                 tmp_inode->i_op = &cifs_symlink_inode_ops;
 287         } else {
 288                 cFYI(1, ("Init special inode"));
 289                 init_special_inode(tmp_inode, tmp_inode->i_mode,
 290                                    tmp_inode->i_rdev);
 291         }
 292 }
 293
 294 static void unix_fill_in_inode(struct inode *tmp_inode,
 295         FILE_UNIX_INFO *pfindData, int *pobject_type, int isNewInode)
 296 {
 297         loff_t local_size;
 298         struct timespec local_mtime;
 299
 300         struct cifsInodeInfo *cifsInfo = CIFS_I(tmp_inode);
 301         struct cifs_sb_info *cifs_sb = CIFS_SB(tmp_inode->i_sb);
 302
 303         __u32 type = le32_to_cpu(pfindData->Type);
 304         __u64 num_of_bytes = le64_to_cpu(pfindData->NumOfBytes);
 305         __u64 end_of_file = le64_to_cpu(pfindData->EndOfFile);
 306         cifsInfo->time = jiffies;
 307         atomic_inc(&cifsInfo->inUse);
 308
 309         /* save mtime and size */
 310         local_mtime = tmp_inode->i_mtime;
 311         local_size  = tmp_inode->i_size;
 312
 313         tmp_inode->i_atime =
 314             cifs_NTtimeToUnix(le64_to_cpu(pfindData->LastAccessTime));
 315         tmp_inode->i_mtime =
 316             cifs_NTtimeToUnix(le64_to_cpu(pfindData->LastModificationTime));
 317         tmp_inode->i_ctime =
 318             cifs_NTtimeToUnix(le64_to_cpu(pfindData->LastStatusChange));
 319
 320         tmp_inode->i_mode = le64_to_cpu(pfindData->Permissions);
 321         /* since we set the inode type below we need to mask off type
 322            to avoid strange results if bits above were corrupt */
 323         tmp_inode->i_mode &= ~S_IFMT;
 324         if (type == UNIX_FILE) {
 325                 *pobject_type = DT_REG;
 326                 tmp_inode->i_mode |= S_IFREG;
 327         } else if (type == UNIX_SYMLINK) {
 328                 *pobject_type = DT_LNK;
 329                 tmp_inode->i_mode |= S_IFLNK;
 330         } else if (type == UNIX_DIR) {
 331                 *pobject_type = DT_DIR;
 332                 tmp_inode->i_mode |= S_IFDIR;
 333         } else if (type == UNIX_CHARDEV) {
 334                 *pobject_type = DT_CHR;
 335                 tmp_inode->i_mode |= S_IFCHR;
 336                 tmp_inode->i_rdev = MKDEV(le64_to_cpu(pfindData->DevMajor),
 337                                 le64_to_cpu(pfindData->DevMinor) & MINORMASK);
 338         } else if (type == UNIX_BLOCKDEV) {
 339                 *pobject_type = DT_BLK;
 340                 tmp_inode->i_mode |= S_IFBLK;
 341                 tmp_inode->i_rdev = MKDEV(le64_to_cpu(pfindData->DevMajor),
 342                                 le64_to_cpu(pfindData->DevMinor) & MINORMASK);
 343         } else if (type == UNIX_FIFO) {
 344                 *pobject_type = DT_FIFO;
 345                 tmp_inode->i_mode |= S_IFIFO;
 346         } else if (type == UNIX_SOCKET) {
 347                 *pobject_type = DT_SOCK;
 348                 tmp_inode->i_mode |= S_IFSOCK;
 349         } else {
 350                 /* safest to just call it a file */
 351                 *pobject_type = DT_REG;
 352                 tmp_inode->i_mode |= S_IFREG;
 353                 cFYI(1,("unknown inode type %d",type));
 354         }
 355
 356         tmp_inode->i_uid = le64_to_cpu(pfindData->Uid);
 357         tmp_inode->i_gid = le64_to_cpu(pfindData->Gid);
 358         tmp_inode->i_nlink = le64_to_cpu(pfindData->Nlinks);
 359
 360         spin_lock(&tmp_inode->i_lock);
 361         if (is_size_safe_to_change(cifsInfo, end_of_file)) {
 362                 /* can not safely change the file size here if the
 363                 client is writing to it due to potential races */
 364                 i_size_write(tmp_inode, end_of_file);
 365
 366         /* 512 bytes (2**9) is the fake blocksize that must be used */
 367         /* for this calculation, not the real blocksize */
 368                 tmp_inode->i_blocks = (512 - 1 + num_of_bytes) >> 9;
 369         }
 370         spin_unlock(&tmp_inode->i_lock);
 371
 372         if (S_ISREG(tmp_inode->i_mode)) {
 373                 cFYI(1, ("File inode"));
 374                 tmp_inode->i_op = &cifs_file_inode_ops;
 375
 376                 if(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
 377                         if(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
 378                                 tmp_inode->i_fop = &cifs_file_direct_nobrl_ops;
 379                         else
 380                                 tmp_inode->i_fop = &cifs_file_direct_ops;
 381
 382                 } else if(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
 383                         tmp_inode->i_fop = &cifs_file_nobrl_ops;
 384                 else
 385                         tmp_inode->i_fop = &cifs_file_ops;
 386
 387                 if((cifs_sb->tcon) && (cifs_sb->tcon->ses) &&
 388                    (cifs_sb->tcon->ses->server->maxBuf <
 389                         PAGE_CACHE_SIZE + MAX_CIFS_HDR_SIZE))
 390                         tmp_inode->i_data.a_ops = &cifs_addr_ops_smallbuf;
 391                 else
 392                         tmp_inode->i_data.a_ops = &cifs_addr_ops;
 393
 394                 if(isNewInode)
 395                         return; /* No sense invalidating pages for new inode since we
 396                                            have not started caching readahead file data yet */
 397
 398                 if (timespec_equal(&tmp_inode->i_mtime, &local_mtime) &&
 399                         (local_size == tmp_inode->i_size)) {
 400                         cFYI(1, ("inode exists but unchanged"));
 401                 } else {
 402                         /* file may have changed on server */
 403                         cFYI(1, ("invalidate inode, readdir detected change"));
 404                         invalidate_remote_inode(tmp_inode);
 405                 }
 406         } else if (S_ISDIR(tmp_inode->i_mode)) {
 407                 cFYI(1, ("Directory inode"));
 408                 tmp_inode->i_op = &cifs_dir_inode_ops;
 409                 tmp_inode->i_fop = &cifs_dir_ops;
 410         } else if (S_ISLNK(tmp_inode->i_mode)) {
 411                 cFYI(1, ("Symbolic Link inode"));
 412                 tmp_inode->i_op = &cifs_symlink_inode_ops;
 413 /* tmp_inode->i_fop = *//* do not need to set to anything */
 414         } else {
 415                 cFYI(1, ("Special inode"));
 416                 init_special_inode(tmp_inode, tmp_inode->i_mode,
 417                                    tmp_inode->i_rdev);
 418         }
 419 }
 420
 421 static int initiate_cifs_search(const int xid, struct file *file)
 422 {
 423         int rc = 0;
 424         char * full_path;
 425         struct cifsFileInfo * cifsFile;
 426         struct cifs_sb_info *cifs_sb;
 427         struct cifsTconInfo *pTcon;
 428
 429         if(file->private_data == NULL) {
 430                 file->private_data =
 431                         kmalloc(sizeof(struct cifsFileInfo),GFP_KERNEL);
 432         }
 433
 434         if(file->private_data == NULL) {
 435                 return -ENOMEM;
 436         } else {
 437                 memset(file->private_data,0,sizeof(struct cifsFileInfo));
 438         }
 439         cifsFile = file->private_data;
 440         cifsFile->invalidHandle = TRUE;
 441         cifsFile->srch_inf.endOfSearch = FALSE;
 442
 443         if(file->f_path.dentry == NULL)
 444                 return -ENOENT;
 445
 446         cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
 447         if(cifs_sb == NULL)
 448                 return -EINVAL;
 449
 450         pTcon = cifs_sb->tcon;
 451         if(pTcon == NULL)
 452                 return -EINVAL;
 453
 454         full_path = build_path_from_dentry(file->f_path.dentry);
 455
 456         if(full_path == NULL) {
 457                 return -ENOMEM;
 458         }
 459
 460         cFYI(1, ("Full path: %s start at: %lld", full_path, file->f_pos));
 461
 462 ffirst_retry:
 463         /* test for Unix extensions */
 464         if (pTcon->ses->capabilities & CAP_UNIX) {
 465                 cifsFile->srch_inf.info_level = SMB_FIND_FILE_UNIX;
 466         } else if ((pTcon->ses->capabilities &
 467                         (CAP_NT_SMBS | CAP_NT_FIND)) == 0) {
 468                 cifsFile->srch_inf.info_level = SMB_FIND_FILE_INFO_STANDARD;
 469         } else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
 470                 cifsFile->srch_inf.info_level = SMB_FIND_FILE_ID_FULL_DIR_INFO;
 471         } else /* not srvinos - BB fixme add check for backlevel? */ {
 472                 cifsFile->srch_inf.info_level = SMB_FIND_FILE_DIRECTORY_INFO;
 473         }
 474
 475         rc = CIFSFindFirst(xid, pTcon,full_path,cifs_sb->local_nls,
 476                 &cifsFile->netfid, &cifsFile->srch_inf,
 477                 cifs_sb->mnt_cifs_flags &
 478                         CIFS_MOUNT_MAP_SPECIAL_CHR, CIFS_DIR_SEP(cifs_sb));
 479         if(rc == 0)
 480                 cifsFile->invalidHandle = FALSE;
 481         if((rc == -EOPNOTSUPP) &&
 482                 (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)) {
 483                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_SERVER_INUM;
 484                 goto ffirst_retry;
 485         }
 486         kfree(full_path);
 487         return rc;
 488 }
 489
 490 /* return length of unicode string in bytes */
 491 static int cifs_unicode_bytelen(char *str)
 492 {
 493         int len;
 494         __le16 * ustr = (__le16 *)str;
 495
 496         for(len=0;len <= PATH_MAX;len++) {
 497                 if(ustr[len] == 0)
 498                         return len << 1;
 499         }
 500         cFYI(1,("Unicode string longer than PATH_MAX found"));
 501         return len << 1;
 502 }
 503
 504 static char *nxt_dir_entry(char *old_entry, char *end_of_smb, int level)
 505 {
 506         char * new_entry;
 507         FILE_DIRECTORY_INFO * pDirInfo = (FILE_DIRECTORY_INFO *)old_entry;
 508
 509         if(level == SMB_FIND_FILE_INFO_STANDARD) {
 510                 FIND_FILE_STANDARD_INFO * pfData;
 511                 pfData = (FIND_FILE_STANDARD_INFO *)pDirInfo;
 512
 513                 new_entry = old_entry + sizeof(FIND_FILE_STANDARD_INFO) +
 514                                 pfData->FileNameLength;
 515         } else
 516                 new_entry = old_entry + le32_to_cpu(pDirInfo->NextEntryOffset);
 517         cFYI(1,("new entry %p old entry %p",new_entry,old_entry));
 518         /* validate that new_entry is not past end of SMB */
 519         if(new_entry >= end_of_smb) {
 520                 cERROR(1,
 521                       ("search entry %p began after end of SMB %p old entry %p",
 522                         new_entry, end_of_smb, old_entry));
 523                 return NULL;
 524         } else if(((level == SMB_FIND_FILE_INFO_STANDARD) &&
 525                    (new_entry + sizeof(FIND_FILE_STANDARD_INFO) > end_of_smb)) ||
 526                   ((level != SMB_FIND_FILE_INFO_STANDARD) &&
 527                    (new_entry + sizeof(FILE_DIRECTORY_INFO) > end_of_smb)))  {
 528                 cERROR(1,("search entry %p extends after end of SMB %p",
 529                         new_entry, end_of_smb));
 530                 return NULL;
 531         } else
 532                 return new_entry;
 533
 534 }
 535
 536 #define UNICODE_DOT cpu_to_le16(0x2e)
 537
 538 /* return 0 if no match and 1 for . (current directory) and 2 for .. (parent) */
 539 static int cifs_entry_is_dot(char *current_entry, struct cifsFileInfo *cfile)
 540 {
 541         int rc = 0;
 542         char * filename = NULL;
 543         int len = 0;
 544
 545         if(cfile->srch_inf.info_level == SMB_FIND_FILE_UNIX) {
 546                 FILE_UNIX_INFO * pFindData = (FILE_UNIX_INFO *)current_entry;
 547                 filename = &pFindData->FileName[0];
 548                 if(cfile->srch_inf.unicode) {
 549                         len = cifs_unicode_bytelen(filename);
 550                 } else {
 551                         /* BB should we make this strnlen of PATH_MAX? */
 552                         len = strnlen(filename, 5);
 553                 }
 554         } else if(cfile->srch_inf.info_level == SMB_FIND_FILE_DIRECTORY_INFO) {
 555                 FILE_DIRECTORY_INFO * pFindData =
 556                         (FILE_DIRECTORY_INFO *)current_entry;
 557                 filename = &pFindData->FileName[0];
 558                 len = le32_to_cpu(pFindData->FileNameLength);
 559         } else if(cfile->srch_inf.info_level ==
 560                         SMB_FIND_FILE_FULL_DIRECTORY_INFO) {
 561                 FILE_FULL_DIRECTORY_INFO * pFindData =
 562                         (FILE_FULL_DIRECTORY_INFO *)current_entry;
 563                 filename = &pFindData->FileName[0];
 564                 len = le32_to_cpu(pFindData->FileNameLength);
 565         } else if(cfile->srch_inf.info_level ==
 566                         SMB_FIND_FILE_ID_FULL_DIR_INFO) {
 567                 SEARCH_ID_FULL_DIR_INFO * pFindData =
 568                         (SEARCH_ID_FULL_DIR_INFO *)current_entry;
 569                 filename = &pFindData->FileName[0];
 570                 len = le32_to_cpu(pFindData->FileNameLength);
 571         } else if(cfile->srch_inf.info_level ==
 572                         SMB_FIND_FILE_BOTH_DIRECTORY_INFO) {
 573                 FILE_BOTH_DIRECTORY_INFO * pFindData =
 574                         (FILE_BOTH_DIRECTORY_INFO *)current_entry;
 575                 filename = &pFindData->FileName[0];
 576                 len = le32_to_cpu(pFindData->FileNameLength);
 577         } else if(cfile->srch_inf.info_level == SMB_FIND_FILE_INFO_STANDARD) {
 578                 FIND_FILE_STANDARD_INFO * pFindData =
 579                         (FIND_FILE_STANDARD_INFO *)current_entry;
 580                 filename = &pFindData->FileName[0];
 581                 len = pFindData->FileNameLength;
 582         } else {
 583                 cFYI(1,("Unknown findfirst level %d",cfile->srch_inf.info_level));
 584         }
 585
 586         if(filename) {
 587                 if(cfile->srch_inf.unicode) {
 588                         __le16 *ufilename = (__le16 *)filename;
 589                         if(len == 2) {
 590                                 /* check for . */
 591                                 if(ufilename[0] == UNICODE_DOT)
 592                                         rc = 1;
 593                         } else if(len == 4) {
 594                                 /* check for .. */
 595                                 if((ufilename[0] == UNICODE_DOT)
 596                                    &&(ufilename[1] == UNICODE_DOT))
 597                                         rc = 2;
 598                         }
 599                 } else /* ASCII */ {
 600                         if(len == 1) {
 601                                 if(filename[0] == '.')
 602                                         rc = 1;
 603                         } else if(len == 2) {
 604                                 if((filename[0] == '.') && (filename[1] == '.'))
 605                                         rc = 2;
 606                         }
 607                 }
 608         }
 609
 610         return rc;
 611 }
 612
 613 /* Check if directory that we are searching has changed so we can decide
 614    whether we can use the cached search results from the previous search */
 615 static int is_dir_changed(struct file * file)
 616 {
 617         struct inode * inode;
 618         struct cifsInodeInfo *cifsInfo;
 619
 620         if(file->f_path.dentry == NULL)
 621                 return 0;
 622
 623         inode = file->f_path.dentry->d_inode;
 624
 625         if(inode == NULL)
 626                 return 0;
 627
 628         cifsInfo = CIFS_I(inode);
 629
 630         if(cifsInfo->time == 0)
 631                 return 1; /* directory was changed, perhaps due to unlink */
 632         else
 633                 return 0;
 634
 635 }
 636
 637 /* find the corresponding entry in the search */
 638 /* Note that the SMB server returns search entries for . and .. which
 639    complicates logic here if we choose to parse for them and we do not
 640    assume that they are located in the findfirst return buffer.*/
 641 /* We start counting in the buffer with entry 2 and increment for every
 642    entry (do not increment for . or .. entry) */
 643 static int find_cifs_entry(const int xid, struct cifsTconInfo *pTcon,
 644         struct file *file, char **ppCurrentEntry, int *num_to_ret)
 645 {
 646         int rc = 0;
 647         int pos_in_buf = 0;
 648         loff_t first_entry_in_buffer;
 649         loff_t index_to_find = file->f_pos;
 650         struct cifsFileInfo * cifsFile = file->private_data;
 651         /* check if index in the buffer */
 652
 653         if((cifsFile == NULL) || (ppCurrentEntry == NULL) ||
 654            (num_to_ret == NULL))
 655                 return -ENOENT;
 656
 657         *ppCurrentEntry = NULL;
 658         first_entry_in_buffer =
 659                 cifsFile->srch_inf.index_of_last_entry -
 660                         cifsFile->srch_inf.entries_in_buffer;
 661
 662         /* if first entry in buf is zero then is first buffer
 663         in search response data which means it is likely . and ..
 664         will be in this buffer, although some servers do not return
 665         . and .. for the root of a drive and for those we need
 666         to start two entries earlier */
 667
 668 #ifdef CONFIG_CIFS_DEBUG2
 669         dump_cifs_file_struct(file, "In fce ");
 670 #endif
 671         if(((index_to_find < cifsFile->srch_inf.index_of_last_entry) &&
 672              is_dir_changed(file)) ||
 673            (index_to_find < first_entry_in_buffer)) {
 674                 /* close and restart search */
 675                 cFYI(1,("search backing up - close and restart search"));
 676                 cifsFile->invalidHandle = TRUE;
 677                 CIFSFindClose(xid, pTcon, cifsFile->netfid);
 678                 kfree(cifsFile->search_resume_name);
 679                 cifsFile->search_resume_name = NULL;
 680                 if(cifsFile->srch_inf.ntwrk_buf_start) {
 681                         cFYI(1,("freeing SMB ff cache buf on search rewind"));
 682                         if(cifsFile->srch_inf.smallBuf)
 683                                 cifs_small_buf_release(cifsFile->srch_inf.
 684                                                 ntwrk_buf_start);
 685                         else
 686                                 cifs_buf_release(cifsFile->srch_inf.
 687                                                 ntwrk_buf_start);
 688                 }
 689                 rc = initiate_cifs_search(xid,file);
 690                 if(rc) {
 691                         cFYI(1,("error %d reinitiating a search on rewind",rc));
 692                         return rc;
 693                 }
 694         }
 695
 696         while((index_to_find >= cifsFile->srch_inf.index_of_last_entry) &&
 697               (rc == 0) && (cifsFile->srch_inf.endOfSearch == FALSE)){
 698                 cFYI(1,("calling findnext2"));
 699                 rc = CIFSFindNext(xid,pTcon,cifsFile->netfid,
 700                                   &cifsFile->srch_inf);
 701                 if(rc)
 702                         return -ENOENT;
 703         }
 704         if(index_to_find < cifsFile->srch_inf.index_of_last_entry) {
 705                 /* we found the buffer that contains the entry */
 706                 /* scan and find it */
 707                 int i;
 708                 char * current_entry;
 709                 char * end_of_smb = cifsFile->srch_inf.ntwrk_buf_start +
 710                         smbCalcSize((struct smb_hdr *)
 711                                 cifsFile->srch_inf.ntwrk_buf_start);
 712
 713                 current_entry = cifsFile->srch_inf.srch_entries_start;
 714                 first_entry_in_buffer = cifsFile->srch_inf.index_of_last_entry
 715                                         - cifsFile->srch_inf.entries_in_buffer;
 716                 pos_in_buf = index_to_find - first_entry_in_buffer;
 717                 cFYI(1,("found entry - pos_in_buf %d",pos_in_buf));
 718
 719                 for(i=0;(i<(pos_in_buf)) && (current_entry != NULL);i++) {
 720                         /* go entry by entry figuring out which is first */
 721                         current_entry = nxt_dir_entry(current_entry,end_of_smb,
 722                                                 cifsFile->srch_inf.info_level);
 723                 }
 724                 if((current_entry == NULL) && (i < pos_in_buf)) {
 725                         /* BB fixme - check if we should flag this error */
 726                         cERROR(1,("reached end of buf searching for pos in buf"
 727                           " %d index to find %lld rc %d",
 728                           pos_in_buf,index_to_find,rc));
 729                 }
 730                 rc = 0;
 731                 *ppCurrentEntry = current_entry;
 732         } else {
 733                 cFYI(1,("index not in buffer - could not findnext into it"));
 734                 return 0;
 735         }
 736
 737         if(pos_in_buf >= cifsFile->srch_inf.entries_in_buffer) {
 738                 cFYI(1,("can not return entries pos_in_buf beyond last entry"));
 739                 *num_to_ret = 0;
 740         } else
 741                 *num_to_ret = cifsFile->srch_inf.entries_in_buffer - pos_in_buf;
 742
 743         return rc;
 744 }
 745
 746 /* inode num, inode type and filename returned */
 747 static int cifs_get_name_from_search_buf(struct qstr *pqst,
 748         char *current_entry, __u16 level, unsigned int unicode,
 749         struct cifs_sb_info * cifs_sb, int max_len, ino_t *pinum)
 750 {
 751         int rc = 0;
 752         unsigned int len = 0;
 753         char * filename;
 754         struct nls_table * nlt = cifs_sb->local_nls;
 755
 756         *pinum = 0;
 757
 758         if(level == SMB_FIND_FILE_UNIX) {
 759                 FILE_UNIX_INFO * pFindData = (FILE_UNIX_INFO *)current_entry;
 760
 761                 filename = &pFindData->FileName[0];
 762                 if(unicode) {
 763                         len = cifs_unicode_bytelen(filename);
 764                 } else {
 765                         /* BB should we make this strnlen of PATH_MAX? */
 766                         len = strnlen(filename, PATH_MAX);
 767                 }
 768
 769                 /* BB fixme - hash low and high 32 bits if not 64 bit arch BB fixme */
 770                 if(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
 771                         *pinum = pFindData->UniqueId;
 772         } else if(level == SMB_FIND_FILE_DIRECTORY_INFO) {
 773                 FILE_DIRECTORY_INFO * pFindData =
 774                         (FILE_DIRECTORY_INFO *)current_entry;
 775                 filename = &pFindData->FileName[0];
 776                 len = le32_to_cpu(pFindData->FileNameLength);
 777         } else if(level == SMB_FIND_FILE_FULL_DIRECTORY_INFO) {
 778                 FILE_FULL_DIRECTORY_INFO * pFindData =
 779                         (FILE_FULL_DIRECTORY_INFO *)current_entry;
 780                 filename = &pFindData->FileName[0];
 781                 len = le32_to_cpu(pFindData->FileNameLength);
 782         } else if(level == SMB_FIND_FILE_ID_FULL_DIR_INFO) {
 783                 SEARCH_ID_FULL_DIR_INFO * pFindData =
 784                         (SEARCH_ID_FULL_DIR_INFO *)current_entry;
 785                 filename = &pFindData->FileName[0];
 786                 len = le32_to_cpu(pFindData->FileNameLength);
 787                 *pinum = pFindData->UniqueId;
 788         } else if(level == SMB_FIND_FILE_BOTH_DIRECTORY_INFO) {
 789                 FILE_BOTH_DIRECTORY_INFO * pFindData =
 790                         (FILE_BOTH_DIRECTORY_INFO *)current_entry;
 791                 filename = &pFindData->FileName[0];
 792                 len = le32_to_cpu(pFindData->FileNameLength);
 793         } else if(level == SMB_FIND_FILE_INFO_STANDARD) {
 794                 FIND_FILE_STANDARD_INFO * pFindData =
 795                         (FIND_FILE_STANDARD_INFO *)current_entry;
 796                 filename = &pFindData->FileName[0];
 797                 /* one byte length, no name conversion */
 798                 len = (unsigned int)pFindData->FileNameLength;
 799         } else {
 800                 cFYI(1,("Unknown findfirst level %d",level));
 801                 return -EINVAL;
 802         }
 803
 804         if(len > max_len) {
 805                 cERROR(1,("bad search response length %d past smb end", len));
 806                 return -EINVAL;
 807         }
 808
 809         if(unicode) {
 810                 /* BB fixme - test with long names */
 811                 /* Note converted filename can be longer than in unicode */
 812                 if(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR)
 813                         pqst->len = cifs_convertUCSpath((char *)pqst->name,
 814                                         (__le16 *)filename, len/2, nlt);
 815                 else
 816                         pqst->len = cifs_strfromUCS_le((char *)pqst->name,
 817                                         (__le16 *)filename,len/2,nlt);
 818         } else {
 819                 pqst->name = filename;
 820                 pqst->len = len;
 821         }
 822         pqst->hash = full_name_hash(pqst->name,pqst->len);
 823 /*      cFYI(1,("filldir on %s",pqst->name));  */
 824         return rc;
 825 }
 826
 827 static int cifs_filldir(char *pfindEntry, struct file *file,
 828         filldir_t filldir, void *direntry, char *scratch_buf, int max_len)
 829 {
 830         int rc = 0;
 831         struct qstr qstring;
 832         struct cifsFileInfo * pCifsF;
 833         unsigned obj_type;
 834         ino_t  inum;
 835         struct cifs_sb_info * cifs_sb;
 836         struct inode *tmp_inode;
 837         struct dentry *tmp_dentry;
 838
 839         /* get filename and len into qstring */
 840         /* get dentry */
 841         /* decide whether to create and populate ionde */
 842         if((direntry == NULL) || (file == NULL))
 843                 return -EINVAL;
 844
 845         pCifsF = file->private_data;
 846
 847         if((scratch_buf == NULL) || (pfindEntry == NULL) || (pCifsF == NULL))
 848                 return -ENOENT;
 849
 850         if(file->f_path.dentry == NULL)
 851                 return -ENOENT;
 852
 853         rc = cifs_entry_is_dot(pfindEntry,pCifsF);
 854         /* skip . and .. since we added them first */
 855         if(rc != 0)
 856                 return 0;
 857
 858         cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
 859
 860         qstring.name = scratch_buf;
 861         rc = cifs_get_name_from_search_buf(&qstring,pfindEntry,
 862                         pCifsF->srch_inf.info_level,
 863                         pCifsF->srch_inf.unicode,cifs_sb,
 864                         max_len,
 865                         &inum /* returned */);
 866
 867         if(rc)
 868                 return rc;
 869
 870         rc = construct_dentry(&qstring,file,&tmp_inode, &tmp_dentry);
 871         if((tmp_inode == NULL) || (tmp_dentry == NULL))
 872                 return -ENOMEM;
 873
 874         if(rc) {
 875                 /* inode created, we need to hash it with right inode number */
 876                 if(inum != 0) {
 877                         /* BB fixme - hash the 2 32 quantities bits together if necessary BB */
 878                         tmp_inode->i_ino = inum;
 879                 }
 880                 insert_inode_hash(tmp_inode);
 881         }
 882
 883         /* we pass in rc below, indicating whether it is a new inode,
 884            so we can figure out whether to invalidate the inode cached
 885            data if the file has changed */
 886         if(pCifsF->srch_inf.info_level == SMB_FIND_FILE_UNIX)
 887                 unix_fill_in_inode(tmp_inode,
 888                                    (FILE_UNIX_INFO *)pfindEntry,
 889                                    &obj_type, rc);
 890         else if(pCifsF->srch_inf.info_level == SMB_FIND_FILE_INFO_STANDARD)
 891                 fill_in_inode(tmp_inode, 0 /* old level 1 buffer type */,
 892                                 pfindEntry, &obj_type, rc);
 893         else
 894                 fill_in_inode(tmp_inode, 1 /* NT */, pfindEntry, &obj_type, rc);
 895
 896         if(rc) /* new inode - needs to be tied to dentry */ {
 897                 d_instantiate(tmp_dentry, tmp_inode);
 898                 if(rc == 2)
 899                         d_rehash(tmp_dentry);
 900         }
 901
 902
 903         rc = filldir(direntry,qstring.name,qstring.len,file->f_pos,
 904                      tmp_inode->i_ino,obj_type);
 905         if(rc) {
 906                 cFYI(1,("filldir rc = %d",rc));
 907                 /* we can not return filldir errors to the caller
 908                 since they are "normal" when the stat blocksize
 909                 is too small - we return remapped error instead */
 910                 rc = -EOVERFLOW;
 911         }
 912
 913         dput(tmp_dentry);
 914         return rc;
 915 }
 916
 917 static int cifs_save_resume_key(const char *current_entry,
 918         struct cifsFileInfo *cifsFile)
 919 {
 920         int rc = 0;
 921         unsigned int len = 0;
 922         __u16 level;
 923         char * filename;
 924
 925         if((cifsFile == NULL) || (current_entry == NULL))
 926                 return -EINVAL;
 927
 928         level = cifsFile->srch_inf.info_level;
 929
 930         if(level == SMB_FIND_FILE_UNIX) {
 931                 FILE_UNIX_INFO * pFindData = (FILE_UNIX_INFO *)current_entry;
 932
 933                 filename = &pFindData->FileName[0];
 934                 if(cifsFile->srch_inf.unicode) {
 935                         len = cifs_unicode_bytelen(filename);
 936                 } else {
 937                         /* BB should we make this strnlen of PATH_MAX? */
 938                         len = strnlen(filename, PATH_MAX);
 939                 }
 940                 cifsFile->srch_inf.resume_key = pFindData->ResumeKey;
 941         } else if(level == SMB_FIND_FILE_DIRECTORY_INFO) {
 942                 FILE_DIRECTORY_INFO * pFindData =
 943                         (FILE_DIRECTORY_INFO *)current_entry;
 944                 filename = &pFindData->FileName[0];
 945                 len = le32_to_cpu(pFindData->FileNameLength);
 946                 cifsFile->srch_inf.resume_key = pFindData->FileIndex;
 947         } else if(level == SMB_FIND_FILE_FULL_DIRECTORY_INFO) {
 948                 FILE_FULL_DIRECTORY_INFO * pFindData =
 949                         (FILE_FULL_DIRECTORY_INFO *)current_entry;
 950                 filename = &pFindData->FileName[0];
 951                 len = le32_to_cpu(pFindData->FileNameLength);
 952                 cifsFile->srch_inf.resume_key = pFindData->FileIndex;
 953         } else if(level == SMB_FIND_FILE_ID_FULL_DIR_INFO) {
 954                 SEARCH_ID_FULL_DIR_INFO * pFindData =
 955                         (SEARCH_ID_FULL_DIR_INFO *)current_entry;
 956                 filename = &pFindData->FileName[0];
 957                 len = le32_to_cpu(pFindData->FileNameLength);
 958                 cifsFile->srch_inf.resume_key = pFindData->FileIndex;
 959         } else if(level == SMB_FIND_FILE_BOTH_DIRECTORY_INFO) {
 960                 FILE_BOTH_DIRECTORY_INFO * pFindData =
 961                         (FILE_BOTH_DIRECTORY_INFO *)current_entry;
 962                 filename = &pFindData->FileName[0];
 963                 len = le32_to_cpu(pFindData->FileNameLength);
 964                 cifsFile->srch_inf.resume_key = pFindData->FileIndex;
 965         } else if(level == SMB_FIND_FILE_INFO_STANDARD) {
 966                 FIND_FILE_STANDARD_INFO * pFindData =
 967                         (FIND_FILE_STANDARD_INFO *)current_entry;
 968                 filename = &pFindData->FileName[0];
 969                 /* one byte length, no name conversion */
 970                 len = (unsigned int)pFindData->FileNameLength;
 971                 cifsFile->srch_inf.resume_key = pFindData->ResumeKey;
 972         } else {
 973                 cFYI(1,("Unknown findfirst level %d",level));
 974                 return -EINVAL;
 975         }
 976         cifsFile->srch_inf.resume_name_len = len;
 977         cifsFile->srch_inf.presume_name = filename;
 978         return rc;
 979 }
 980
 981 int cifs_readdir(struct file *file, void *direntry, filldir_t filldir)
 982 {
 983         int rc = 0;
 984         int xid,i;
 985         struct cifs_sb_info *cifs_sb;
 986         struct cifsTconInfo *pTcon;
 987         struct cifsFileInfo *cifsFile = NULL;
 988         char * current_entry;
 989         int num_to_fill = 0;
 990         char * tmp_buf = NULL;
 991         char * end_of_smb;
 992         int max_len;
 993
 994         xid = GetXid();
 995
 996         if(file->f_path.dentry == NULL) {
 997                 FreeXid(xid);
 998                 return -EIO;
 999         }
1000
1001         cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
1002         pTcon = cifs_sb->tcon;
1003         if(pTcon == NULL)
1004                 return -EINVAL;
1005
1006         switch ((int) file->f_pos) {
1007         case 0:
1008                 if (filldir(direntry, ".", 1, file->f_pos,
1009                      file->f_path.dentry->d_inode->i_ino, DT_DIR) < 0) {
1010                         cERROR(1, ("Filldir for current dir failed"));
1011                         rc = -ENOMEM;
1012                         break;
1013                 }
1014                 file->f_pos++;
1015         case 1:
1016                 if (filldir(direntry, "..", 2, file->f_pos,
1017                      file->f_path.dentry->d_parent->d_inode->i_ino, DT_DIR) < 0) {
1018                         cERROR(1, ("Filldir for parent dir failed"));
1019                         rc = -ENOMEM;
1020                         break;
1021                 }
1022                 file->f_pos++;
1023         default:
1024                 /* 1) If search is active,
1025                         is in current search buffer?
1026                         if it before then restart search
1027                         if after then keep searching till find it */
1028
1029                 if(file->private_data == NULL) {
1030                         rc = initiate_cifs_search(xid,file);
1031                         cFYI(1,("initiate cifs search rc %d",rc));
1032                         if(rc) {
1033                                 FreeXid(xid);
1034                                 return rc;
1035                         }
1036                 }
1037                 if(file->private_data == NULL) {
1038                         rc = -EINVAL;
1039                         FreeXid(xid);
1040                         return rc;
1041                 }
1042                 cifsFile = file->private_data;
1043                 if (cifsFile->srch_inf.endOfSearch) {
1044                         if(cifsFile->srch_inf.emptyDir) {
1045                                 cFYI(1, ("End of search, empty dir"));
1046                                 rc = 0;
1047                                 break;
1048                         }
1049                 } /* else {
1050                         cifsFile->invalidHandle = TRUE;
1051                         CIFSFindClose(xid, pTcon, cifsFile->netfid);
1052                 }
1053                 kfree(cifsFile->search_resume_name);
1054                 cifsFile->search_resume_name = NULL; */
1055
1056                 rc = find_cifs_entry(xid,pTcon, file,
1057                                 &current_entry,&num_to_fill);
1058                 if(rc) {
1059                         cFYI(1,("fce error %d",rc));
1060                         goto rddir2_exit;
1061                 } else if (current_entry != NULL) {
1062                         cFYI(1,("entry %lld found",file->f_pos));
1063                 } else {
1064                         cFYI(1,("could not find entry"));
1065                         goto rddir2_exit;
1066                 }
1067                 cFYI(1,("loop through %d times filling dir for net buf %p",
1068                         num_to_fill,cifsFile->srch_inf.ntwrk_buf_start));
1069                 max_len = smbCalcSize((struct smb_hdr *)
1070                                 cifsFile->srch_inf.ntwrk_buf_start);
1071                 end_of_smb = cifsFile->srch_inf.ntwrk_buf_start + max_len;
1072
1073                 /* To be safe - for UCS to UTF-8 with strings loaded
1074                 with the rare long characters alloc more to account for
1075                 such multibyte target UTF-8 characters. cifs_unicode.c,
1076                 which actually does the conversion, has the same limit */
1077                 tmp_buf = kmalloc((2 * NAME_MAX) + 4, GFP_KERNEL);
1078                 for(i=0;(i<num_to_fill) && (rc == 0);i++) {
1079                         if(current_entry == NULL) {
1080                                 /* evaluate whether this case is an error */
1081                                 cERROR(1,("past end of SMB num to fill %d i %d",
1082                                           num_to_fill, i));
1083                                 break;
1084                         }
1085                         /* if buggy server returns . and .. late do
1086                         we want to check for that here? */
1087                         rc = cifs_filldir(current_entry, file,
1088                                         filldir, direntry, tmp_buf, max_len);
1089                         if(rc == -EOVERFLOW) {
1090                                 rc = 0;
1091                                 break;
1092                         }
1093
1094                         file->f_pos++;
1095                         if(file->f_pos ==
1096                                 cifsFile->srch_inf.index_of_last_entry) {
1097                                 cFYI(1,("last entry in buf at pos %lld %s",
1098                                         file->f_pos,tmp_buf));
1099                                 cifs_save_resume_key(current_entry,cifsFile);
1100                                 break;
1101                         } else
1102                                 current_entry =
1103                                         nxt_dir_entry(current_entry, end_of_smb,
1104                                                 cifsFile->srch_inf.info_level);
1105                 }
1106                 kfree(tmp_buf);
1107                 break;
1108         } /* end switch */
1109
1110 rddir2_exit:
1111         FreeXid(xid);
1112         return rc;
1113 }