4 * Directory search handling
6 * Copyright (C) International Business Machines Corp., 2004, 2008
7 * Author(s): Steve French (sfrench@us.ibm.com)
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.
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.
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
24 #include <linux/pagemap.h>
25 #include <linux/slab.h>
26 #include <linux/stat.h>
29 #include "cifsproto.h"
30 #include "cifs_unicode.h"
31 #include "cifs_debug.h"
32 #include "cifs_fs_sb.h"
36 * To be safe - for UCS to UTF-8 with strings loaded with the rare long
37 * characters alloc more to account for such multibyte target UTF-8
40 #define UNICODE_NAME_MAX ((4 * NAME_MAX) + 2)
42 #ifdef CONFIG_CIFS_DEBUG2
43 static void dump_cifs_file_struct(struct file
*file
, char *label
)
45 struct cifsFileInfo
*cf
;
48 cf
= file
->private_data
;
50 cFYI(1, "empty cifs private file data");
53 if (cf
->invalidHandle
)
54 cFYI(1, "invalid handle");
55 if (cf
->srch_inf
.endOfSearch
)
56 cFYI(1, "end of search");
57 if (cf
->srch_inf
.emptyDir
)
62 static inline void dump_cifs_file_struct(struct file
*file
, char *label
)
68 * Find the dentry that matches "name". If there isn't one, create one. If it's
69 * a negative dentry or the uniqueid changed, then drop it and recreate it.
71 static struct dentry
*
72 cifs_readdir_lookup(struct dentry
*parent
, struct qstr
*name
,
73 struct cifs_fattr
*fattr
)
75 struct dentry
*dentry
, *alias
;
77 struct super_block
*sb
= parent
->d_inode
->i_sb
;
79 cFYI(1, "For %s", name
->name
);
81 if (parent
->d_op
&& parent
->d_op
->d_hash
)
82 parent
->d_op
->d_hash(parent
, name
);
84 name
->hash
= full_name_hash(name
->name
, name
->len
);
86 dentry
= d_lookup(parent
, name
);
88 /* FIXME: check for inode number changes? */
89 if (dentry
->d_inode
!= NULL
)
95 dentry
= d_alloc(parent
, name
);
99 inode
= cifs_iget(sb
, fattr
);
105 if (cifs_sb_master_tcon(CIFS_SB(sb
))->nocase
)
106 dentry
->d_op
= &cifs_ci_dentry_ops
;
108 dentry
->d_op
= &cifs_dentry_ops
;
110 alias
= d_materialise_unique(dentry
, inode
);
122 cifs_fill_common_info(struct cifs_fattr
*fattr
, struct cifs_sb_info
*cifs_sb
)
124 fattr
->cf_uid
= cifs_sb
->mnt_uid
;
125 fattr
->cf_gid
= cifs_sb
->mnt_gid
;
127 if (fattr
->cf_cifsattrs
& ATTR_DIRECTORY
) {
128 fattr
->cf_mode
= S_IFDIR
| cifs_sb
->mnt_dir_mode
;
129 fattr
->cf_dtype
= DT_DIR
;
131 fattr
->cf_mode
= S_IFREG
| cifs_sb
->mnt_file_mode
;
132 fattr
->cf_dtype
= DT_REG
;
135 if (fattr
->cf_cifsattrs
& ATTR_READONLY
)
136 fattr
->cf_mode
&= ~S_IWUGO
;
138 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_UNX_EMUL
&&
139 fattr
->cf_cifsattrs
& ATTR_SYSTEM
) {
140 if (fattr
->cf_eof
== 0) {
141 fattr
->cf_mode
&= ~S_IFMT
;
142 fattr
->cf_mode
|= S_IFIFO
;
143 fattr
->cf_dtype
= DT_FIFO
;
146 * trying to get the type and mode via SFU can be slow,
147 * so just call those regular files for now, and mark
150 fattr
->cf_flags
|= CIFS_FATTR_NEED_REVAL
;
156 cifs_dir_info_to_fattr(struct cifs_fattr
*fattr
, FILE_DIRECTORY_INFO
*info
,
157 struct cifs_sb_info
*cifs_sb
)
159 memset(fattr
, 0, sizeof(*fattr
));
160 fattr
->cf_cifsattrs
= le32_to_cpu(info
->ExtFileAttributes
);
161 fattr
->cf_eof
= le64_to_cpu(info
->EndOfFile
);
162 fattr
->cf_bytes
= le64_to_cpu(info
->AllocationSize
);
163 fattr
->cf_atime
= cifs_NTtimeToUnix(info
->LastAccessTime
);
164 fattr
->cf_ctime
= cifs_NTtimeToUnix(info
->ChangeTime
);
165 fattr
->cf_mtime
= cifs_NTtimeToUnix(info
->LastWriteTime
);
167 cifs_fill_common_info(fattr
, cifs_sb
);
171 cifs_std_info_to_fattr(struct cifs_fattr
*fattr
, FIND_FILE_STANDARD_INFO
*info
,
172 struct cifs_sb_info
*cifs_sb
)
174 int offset
= cifs_sb_master_tcon(cifs_sb
)->ses
->server
->timeAdj
;
176 memset(fattr
, 0, sizeof(*fattr
));
177 fattr
->cf_atime
= cnvrtDosUnixTm(info
->LastAccessDate
,
178 info
->LastAccessTime
, offset
);
179 fattr
->cf_ctime
= cnvrtDosUnixTm(info
->LastWriteDate
,
180 info
->LastWriteTime
, offset
);
181 fattr
->cf_mtime
= cnvrtDosUnixTm(info
->LastWriteDate
,
182 info
->LastWriteTime
, offset
);
184 fattr
->cf_cifsattrs
= le16_to_cpu(info
->Attributes
);
185 fattr
->cf_bytes
= le32_to_cpu(info
->AllocationSize
);
186 fattr
->cf_eof
= le32_to_cpu(info
->DataSize
);
188 cifs_fill_common_info(fattr
, cifs_sb
);
191 /* BB eventually need to add the following helper function to
192 resolve NT_STATUS_STOPPED_ON_SYMLINK return code when
193 we try to do FindFirst on (NTFS) directory symlinks */
195 int get_symlink_reparse_path(char *full_path, struct cifs_sb_info *cifs_sb,
202 struct cifsTconInfo *ptcon = cifs_sb_tcon(cifs_sb);
205 rc = CIFSSMBOpen(xid, ptcon, full_path, FILE_OPEN, GENERIC_READ,
206 OPEN_REPARSE_POINT, &fid, &oplock, NULL,
208 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
210 tmpbuffer = kmalloc(maxpath);
211 rc = CIFSSMBQueryReparseLinkInfo(xid, ptcon, full_path,
216 if (CIFSSMBClose(xid, ptcon, fid)) {
217 cFYI(1, "Error closing temporary reparsepoint open");
223 static int initiate_cifs_search(const int xid
, struct file
*file
)
227 struct cifsFileInfo
*cifsFile
;
228 struct cifs_sb_info
*cifs_sb
;
229 struct cifsTconInfo
*pTcon
;
231 cifs_sb
= CIFS_SB(file
->f_path
.dentry
->d_sb
);
235 if (file
->private_data
== NULL
)
237 kzalloc(sizeof(struct cifsFileInfo
), GFP_KERNEL
);
239 if (file
->private_data
== NULL
)
241 cifsFile
= file
->private_data
;
242 cifsFile
->invalidHandle
= true;
243 cifsFile
->srch_inf
.endOfSearch
= false;
244 cifsFile
->tcon
= cifs_sb_tcon(cifs_sb
);
245 pTcon
= cifsFile
->tcon
;
249 full_path
= build_path_from_dentry(file
->f_path
.dentry
);
251 if (full_path
== NULL
)
254 cFYI(1, "Full path: %s start at: %lld", full_path
, file
->f_pos
);
257 /* test for Unix extensions */
258 /* but now check for them on the share/mount not on the SMB session */
259 /* if (pTcon->ses->capabilities & CAP_UNIX) { */
261 cifsFile
->srch_inf
.info_level
= SMB_FIND_FILE_UNIX
;
262 else if ((pTcon
->ses
->capabilities
&
263 (CAP_NT_SMBS
| CAP_NT_FIND
)) == 0) {
264 cifsFile
->srch_inf
.info_level
= SMB_FIND_FILE_INFO_STANDARD
;
265 } else if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_SERVER_INUM
) {
266 cifsFile
->srch_inf
.info_level
= SMB_FIND_FILE_ID_FULL_DIR_INFO
;
267 } else /* not srvinos - BB fixme add check for backlevel? */ {
268 cifsFile
->srch_inf
.info_level
= SMB_FIND_FILE_DIRECTORY_INFO
;
271 rc
= CIFSFindFirst(xid
, pTcon
, full_path
, cifs_sb
->local_nls
,
272 &cifsFile
->netfid
, &cifsFile
->srch_inf
,
273 cifs_sb
->mnt_cifs_flags
&
274 CIFS_MOUNT_MAP_SPECIAL_CHR
, CIFS_DIR_SEP(cifs_sb
));
276 cifsFile
->invalidHandle
= false;
277 /* BB add following call to handle readdir on new NTFS symlink errors
278 else if STATUS_STOPPED_ON_SYMLINK
279 call get_symlink_reparse_path and retry with new path */
280 else if ((rc
== -EOPNOTSUPP
) &&
281 (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_SERVER_INUM
)) {
282 cifs_sb
->mnt_cifs_flags
&= ~CIFS_MOUNT_SERVER_INUM
;
289 /* return length of unicode string in bytes */
290 static int cifs_unicode_bytelen(char *str
)
293 __le16
*ustr
= (__le16
*)str
;
295 for (len
= 0; len
<= PATH_MAX
; len
++) {
299 cFYI(1, "Unicode string longer than PATH_MAX found");
303 static char *nxt_dir_entry(char *old_entry
, char *end_of_smb
, int level
)
306 FILE_DIRECTORY_INFO
*pDirInfo
= (FILE_DIRECTORY_INFO
*)old_entry
;
308 if (level
== SMB_FIND_FILE_INFO_STANDARD
) {
309 FIND_FILE_STANDARD_INFO
*pfData
;
310 pfData
= (FIND_FILE_STANDARD_INFO
*)pDirInfo
;
312 new_entry
= old_entry
+ sizeof(FIND_FILE_STANDARD_INFO
) +
313 pfData
->FileNameLength
;
315 new_entry
= old_entry
+ le32_to_cpu(pDirInfo
->NextEntryOffset
);
316 cFYI(1, "new entry %p old entry %p", new_entry
, old_entry
);
317 /* validate that new_entry is not past end of SMB */
318 if (new_entry
>= end_of_smb
) {
319 cERROR(1, "search entry %p began after end of SMB %p old entry %p",
320 new_entry
, end_of_smb
, old_entry
);
322 } else if (((level
== SMB_FIND_FILE_INFO_STANDARD
) &&
323 (new_entry
+ sizeof(FIND_FILE_STANDARD_INFO
) > end_of_smb
))
324 || ((level
!= SMB_FIND_FILE_INFO_STANDARD
) &&
325 (new_entry
+ sizeof(FILE_DIRECTORY_INFO
) > end_of_smb
))) {
326 cERROR(1, "search entry %p extends after end of SMB %p",
327 new_entry
, end_of_smb
);
334 #define UNICODE_DOT cpu_to_le16(0x2e)
336 /* return 0 if no match and 1 for . (current directory) and 2 for .. (parent) */
337 static int cifs_entry_is_dot(char *current_entry
, struct cifsFileInfo
*cfile
)
340 char *filename
= NULL
;
343 if (cfile
->srch_inf
.info_level
== SMB_FIND_FILE_UNIX
) {
344 FILE_UNIX_INFO
*pFindData
= (FILE_UNIX_INFO
*)current_entry
;
345 filename
= &pFindData
->FileName
[0];
346 if (cfile
->srch_inf
.unicode
) {
347 len
= cifs_unicode_bytelen(filename
);
349 /* BB should we make this strnlen of PATH_MAX? */
350 len
= strnlen(filename
, 5);
352 } else if (cfile
->srch_inf
.info_level
== SMB_FIND_FILE_DIRECTORY_INFO
) {
353 FILE_DIRECTORY_INFO
*pFindData
=
354 (FILE_DIRECTORY_INFO
*)current_entry
;
355 filename
= &pFindData
->FileName
[0];
356 len
= le32_to_cpu(pFindData
->FileNameLength
);
357 } else if (cfile
->srch_inf
.info_level
==
358 SMB_FIND_FILE_FULL_DIRECTORY_INFO
) {
359 FILE_FULL_DIRECTORY_INFO
*pFindData
=
360 (FILE_FULL_DIRECTORY_INFO
*)current_entry
;
361 filename
= &pFindData
->FileName
[0];
362 len
= le32_to_cpu(pFindData
->FileNameLength
);
363 } else if (cfile
->srch_inf
.info_level
==
364 SMB_FIND_FILE_ID_FULL_DIR_INFO
) {
365 SEARCH_ID_FULL_DIR_INFO
*pFindData
=
366 (SEARCH_ID_FULL_DIR_INFO
*)current_entry
;
367 filename
= &pFindData
->FileName
[0];
368 len
= le32_to_cpu(pFindData
->FileNameLength
);
369 } else if (cfile
->srch_inf
.info_level
==
370 SMB_FIND_FILE_BOTH_DIRECTORY_INFO
) {
371 FILE_BOTH_DIRECTORY_INFO
*pFindData
=
372 (FILE_BOTH_DIRECTORY_INFO
*)current_entry
;
373 filename
= &pFindData
->FileName
[0];
374 len
= le32_to_cpu(pFindData
->FileNameLength
);
375 } else if (cfile
->srch_inf
.info_level
== SMB_FIND_FILE_INFO_STANDARD
) {
376 FIND_FILE_STANDARD_INFO
*pFindData
=
377 (FIND_FILE_STANDARD_INFO
*)current_entry
;
378 filename
= &pFindData
->FileName
[0];
379 len
= pFindData
->FileNameLength
;
381 cFYI(1, "Unknown findfirst level %d",
382 cfile
->srch_inf
.info_level
);
386 if (cfile
->srch_inf
.unicode
) {
387 __le16
*ufilename
= (__le16
*)filename
;
390 if (ufilename
[0] == UNICODE_DOT
)
392 } else if (len
== 4) {
394 if ((ufilename
[0] == UNICODE_DOT
)
395 && (ufilename
[1] == UNICODE_DOT
))
400 if (filename
[0] == '.')
402 } else if (len
== 2) {
403 if ((filename
[0] == '.') && (filename
[1] == '.'))
412 /* Check if directory that we are searching has changed so we can decide
413 whether we can use the cached search results from the previous search */
414 static int is_dir_changed(struct file
*file
)
416 struct inode
*inode
= file
->f_path
.dentry
->d_inode
;
417 struct cifsInodeInfo
*cifsInfo
= CIFS_I(inode
);
419 if (cifsInfo
->time
== 0)
420 return 1; /* directory was changed, perhaps due to unlink */
426 static int cifs_save_resume_key(const char *current_entry
,
427 struct cifsFileInfo
*cifsFile
)
430 unsigned int len
= 0;
434 if ((cifsFile
== NULL
) || (current_entry
== NULL
))
437 level
= cifsFile
->srch_inf
.info_level
;
439 if (level
== SMB_FIND_FILE_UNIX
) {
440 FILE_UNIX_INFO
*pFindData
= (FILE_UNIX_INFO
*)current_entry
;
442 filename
= &pFindData
->FileName
[0];
443 if (cifsFile
->srch_inf
.unicode
) {
444 len
= cifs_unicode_bytelen(filename
);
446 /* BB should we make this strnlen of PATH_MAX? */
447 len
= strnlen(filename
, PATH_MAX
);
449 cifsFile
->srch_inf
.resume_key
= pFindData
->ResumeKey
;
450 } else if (level
== SMB_FIND_FILE_DIRECTORY_INFO
) {
451 FILE_DIRECTORY_INFO
*pFindData
=
452 (FILE_DIRECTORY_INFO
*)current_entry
;
453 filename
= &pFindData
->FileName
[0];
454 len
= le32_to_cpu(pFindData
->FileNameLength
);
455 cifsFile
->srch_inf
.resume_key
= pFindData
->FileIndex
;
456 } else if (level
== SMB_FIND_FILE_FULL_DIRECTORY_INFO
) {
457 FILE_FULL_DIRECTORY_INFO
*pFindData
=
458 (FILE_FULL_DIRECTORY_INFO
*)current_entry
;
459 filename
= &pFindData
->FileName
[0];
460 len
= le32_to_cpu(pFindData
->FileNameLength
);
461 cifsFile
->srch_inf
.resume_key
= pFindData
->FileIndex
;
462 } else if (level
== SMB_FIND_FILE_ID_FULL_DIR_INFO
) {
463 SEARCH_ID_FULL_DIR_INFO
*pFindData
=
464 (SEARCH_ID_FULL_DIR_INFO
*)current_entry
;
465 filename
= &pFindData
->FileName
[0];
466 len
= le32_to_cpu(pFindData
->FileNameLength
);
467 cifsFile
->srch_inf
.resume_key
= pFindData
->FileIndex
;
468 } else if (level
== SMB_FIND_FILE_BOTH_DIRECTORY_INFO
) {
469 FILE_BOTH_DIRECTORY_INFO
*pFindData
=
470 (FILE_BOTH_DIRECTORY_INFO
*)current_entry
;
471 filename
= &pFindData
->FileName
[0];
472 len
= le32_to_cpu(pFindData
->FileNameLength
);
473 cifsFile
->srch_inf
.resume_key
= pFindData
->FileIndex
;
474 } else if (level
== SMB_FIND_FILE_INFO_STANDARD
) {
475 FIND_FILE_STANDARD_INFO
*pFindData
=
476 (FIND_FILE_STANDARD_INFO
*)current_entry
;
477 filename
= &pFindData
->FileName
[0];
478 /* one byte length, no name conversion */
479 len
= (unsigned int)pFindData
->FileNameLength
;
480 cifsFile
->srch_inf
.resume_key
= pFindData
->ResumeKey
;
482 cFYI(1, "Unknown findfirst level %d", level
);
485 cifsFile
->srch_inf
.resume_name_len
= len
;
486 cifsFile
->srch_inf
.presume_name
= filename
;
490 /* find the corresponding entry in the search */
491 /* Note that the SMB server returns search entries for . and .. which
492 complicates logic here if we choose to parse for them and we do not
493 assume that they are located in the findfirst return buffer.*/
494 /* We start counting in the buffer with entry 2 and increment for every
495 entry (do not increment for . or .. entry) */
496 static int find_cifs_entry(const int xid
, struct cifsTconInfo
*pTcon
,
497 struct file
*file
, char **ppCurrentEntry
, int *num_to_ret
)
501 loff_t first_entry_in_buffer
;
502 loff_t index_to_find
= file
->f_pos
;
503 struct cifsFileInfo
*cifsFile
= file
->private_data
;
504 /* check if index in the buffer */
506 if ((cifsFile
== NULL
) || (ppCurrentEntry
== NULL
) ||
507 (num_to_ret
== NULL
))
510 *ppCurrentEntry
= NULL
;
511 first_entry_in_buffer
=
512 cifsFile
->srch_inf
.index_of_last_entry
-
513 cifsFile
->srch_inf
.entries_in_buffer
;
515 /* if first entry in buf is zero then is first buffer
516 in search response data which means it is likely . and ..
517 will be in this buffer, although some servers do not return
518 . and .. for the root of a drive and for those we need
519 to start two entries earlier */
521 dump_cifs_file_struct(file
, "In fce ");
522 if (((index_to_find
< cifsFile
->srch_inf
.index_of_last_entry
) &&
523 is_dir_changed(file
)) ||
524 (index_to_find
< first_entry_in_buffer
)) {
525 /* close and restart search */
526 cFYI(1, "search backing up - close and restart search");
527 write_lock(&GlobalSMBSeslock
);
528 if (!cifsFile
->srch_inf
.endOfSearch
&&
529 !cifsFile
->invalidHandle
) {
530 cifsFile
->invalidHandle
= true;
531 write_unlock(&GlobalSMBSeslock
);
532 CIFSFindClose(xid
, pTcon
, cifsFile
->netfid
);
534 write_unlock(&GlobalSMBSeslock
);
535 if (cifsFile
->srch_inf
.ntwrk_buf_start
) {
536 cFYI(1, "freeing SMB ff cache buf on search rewind");
537 if (cifsFile
->srch_inf
.smallBuf
)
538 cifs_small_buf_release(cifsFile
->srch_inf
.
541 cifs_buf_release(cifsFile
->srch_inf
.
543 cifsFile
->srch_inf
.ntwrk_buf_start
= NULL
;
545 rc
= initiate_cifs_search(xid
, file
);
547 cFYI(1, "error %d reinitiating a search on rewind",
551 cifs_save_resume_key(cifsFile
->srch_inf
.last_entry
, cifsFile
);
554 while ((index_to_find
>= cifsFile
->srch_inf
.index_of_last_entry
) &&
555 (rc
== 0) && !cifsFile
->srch_inf
.endOfSearch
) {
556 cFYI(1, "calling findnext2");
557 rc
= CIFSFindNext(xid
, pTcon
, cifsFile
->netfid
,
558 &cifsFile
->srch_inf
);
559 cifs_save_resume_key(cifsFile
->srch_inf
.last_entry
, cifsFile
);
563 if (index_to_find
< cifsFile
->srch_inf
.index_of_last_entry
) {
564 /* we found the buffer that contains the entry */
565 /* scan and find it */
568 char *end_of_smb
= cifsFile
->srch_inf
.ntwrk_buf_start
+
569 smbCalcSize((struct smb_hdr
*)
570 cifsFile
->srch_inf
.ntwrk_buf_start
);
572 current_entry
= cifsFile
->srch_inf
.srch_entries_start
;
573 first_entry_in_buffer
= cifsFile
->srch_inf
.index_of_last_entry
574 - cifsFile
->srch_inf
.entries_in_buffer
;
575 pos_in_buf
= index_to_find
- first_entry_in_buffer
;
576 cFYI(1, "found entry - pos_in_buf %d", pos_in_buf
);
578 for (i
= 0; (i
< (pos_in_buf
)) && (current_entry
!= NULL
); i
++) {
579 /* go entry by entry figuring out which is first */
580 current_entry
= nxt_dir_entry(current_entry
, end_of_smb
,
581 cifsFile
->srch_inf
.info_level
);
583 if ((current_entry
== NULL
) && (i
< pos_in_buf
)) {
584 /* BB fixme - check if we should flag this error */
585 cERROR(1, "reached end of buf searching for pos in buf"
586 " %d index to find %lld rc %d",
587 pos_in_buf
, index_to_find
, rc
);
590 *ppCurrentEntry
= current_entry
;
592 cFYI(1, "index not in buffer - could not findnext into it");
596 if (pos_in_buf
>= cifsFile
->srch_inf
.entries_in_buffer
) {
597 cFYI(1, "can not return entries pos_in_buf beyond last");
600 *num_to_ret
= cifsFile
->srch_inf
.entries_in_buffer
- pos_in_buf
;
605 /* inode num, inode type and filename returned */
606 static int cifs_get_name_from_search_buf(struct qstr
*pqst
,
607 char *current_entry
, __u16 level
, unsigned int unicode
,
608 struct cifs_sb_info
*cifs_sb
, unsigned int max_len
, __u64
*pinum
)
611 unsigned int len
= 0;
613 struct nls_table
*nlt
= cifs_sb
->local_nls
;
617 if (level
== SMB_FIND_FILE_UNIX
) {
618 FILE_UNIX_INFO
*pFindData
= (FILE_UNIX_INFO
*)current_entry
;
620 filename
= &pFindData
->FileName
[0];
622 len
= cifs_unicode_bytelen(filename
);
624 /* BB should we make this strnlen of PATH_MAX? */
625 len
= strnlen(filename
, PATH_MAX
);
628 *pinum
= le64_to_cpu(pFindData
->basic
.UniqueId
);
629 } else if (level
== SMB_FIND_FILE_DIRECTORY_INFO
) {
630 FILE_DIRECTORY_INFO
*pFindData
=
631 (FILE_DIRECTORY_INFO
*)current_entry
;
632 filename
= &pFindData
->FileName
[0];
633 len
= le32_to_cpu(pFindData
->FileNameLength
);
634 } else if (level
== SMB_FIND_FILE_FULL_DIRECTORY_INFO
) {
635 FILE_FULL_DIRECTORY_INFO
*pFindData
=
636 (FILE_FULL_DIRECTORY_INFO
*)current_entry
;
637 filename
= &pFindData
->FileName
[0];
638 len
= le32_to_cpu(pFindData
->FileNameLength
);
639 } else if (level
== SMB_FIND_FILE_ID_FULL_DIR_INFO
) {
640 SEARCH_ID_FULL_DIR_INFO
*pFindData
=
641 (SEARCH_ID_FULL_DIR_INFO
*)current_entry
;
642 filename
= &pFindData
->FileName
[0];
643 len
= le32_to_cpu(pFindData
->FileNameLength
);
644 *pinum
= le64_to_cpu(pFindData
->UniqueId
);
645 } else if (level
== SMB_FIND_FILE_BOTH_DIRECTORY_INFO
) {
646 FILE_BOTH_DIRECTORY_INFO
*pFindData
=
647 (FILE_BOTH_DIRECTORY_INFO
*)current_entry
;
648 filename
= &pFindData
->FileName
[0];
649 len
= le32_to_cpu(pFindData
->FileNameLength
);
650 } else if (level
== SMB_FIND_FILE_INFO_STANDARD
) {
651 FIND_FILE_STANDARD_INFO
*pFindData
=
652 (FIND_FILE_STANDARD_INFO
*)current_entry
;
653 filename
= &pFindData
->FileName
[0];
654 /* one byte length, no name conversion */
655 len
= (unsigned int)pFindData
->FileNameLength
;
657 cFYI(1, "Unknown findfirst level %d", level
);
662 cERROR(1, "bad search response length %d past smb end", len
);
667 pqst
->len
= cifs_from_ucs2((char *) pqst
->name
,
670 min(len
, max_len
), nlt
,
671 cifs_sb
->mnt_cifs_flags
&
672 CIFS_MOUNT_MAP_SPECIAL_CHR
);
673 pqst
->len
-= nls_nullsize(nlt
);
675 pqst
->name
= filename
;
681 static int cifs_filldir(char *pfindEntry
, struct file
*file
, filldir_t filldir
,
682 void *direntry
, char *scratch_buf
, unsigned int max_len
)
686 struct cifsFileInfo
*pCifsF
;
689 struct super_block
*sb
;
690 struct cifs_sb_info
*cifs_sb
;
691 struct dentry
*tmp_dentry
;
692 struct cifs_fattr fattr
;
694 /* get filename and len into qstring */
696 /* decide whether to create and populate ionde */
697 if ((direntry
== NULL
) || (file
== NULL
))
700 pCifsF
= file
->private_data
;
702 if ((scratch_buf
== NULL
) || (pfindEntry
== NULL
) || (pCifsF
== NULL
))
705 rc
= cifs_entry_is_dot(pfindEntry
, pCifsF
);
706 /* skip . and .. since we added them first */
710 sb
= file
->f_path
.dentry
->d_sb
;
711 cifs_sb
= CIFS_SB(sb
);
713 qstring
.name
= scratch_buf
;
714 rc
= cifs_get_name_from_search_buf(&qstring
, pfindEntry
,
715 pCifsF
->srch_inf
.info_level
,
716 pCifsF
->srch_inf
.unicode
, cifs_sb
,
717 max_len
, &inum
/* returned */);
722 if (pCifsF
->srch_inf
.info_level
== SMB_FIND_FILE_UNIX
)
723 cifs_unix_basic_to_fattr(&fattr
,
724 &((FILE_UNIX_INFO
*) pfindEntry
)->basic
,
726 else if (pCifsF
->srch_inf
.info_level
== SMB_FIND_FILE_INFO_STANDARD
)
727 cifs_std_info_to_fattr(&fattr
, (FIND_FILE_STANDARD_INFO
*)
728 pfindEntry
, cifs_sb
);
730 cifs_dir_info_to_fattr(&fattr
, (FILE_DIRECTORY_INFO
*)
731 pfindEntry
, cifs_sb
);
733 if (inum
&& (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_SERVER_INUM
)) {
734 fattr
.cf_uniqueid
= inum
;
736 fattr
.cf_uniqueid
= iunique(sb
, ROOT_I
);
737 cifs_autodisable_serverino(cifs_sb
);
740 if ((cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_MF_SYMLINKS
) &&
741 CIFSCouldBeMFSymlink(&fattr
))
743 * trying to get the type and mode can be slow,
744 * so just call those regular files for now, and mark
747 fattr
.cf_flags
|= CIFS_FATTR_NEED_REVAL
;
749 ino
= cifs_uniqueid_to_ino_t(fattr
.cf_uniqueid
);
750 tmp_dentry
= cifs_readdir_lookup(file
->f_dentry
, &qstring
, &fattr
);
752 rc
= filldir(direntry
, qstring
.name
, qstring
.len
, file
->f_pos
,
753 ino
, fattr
.cf_dtype
);
756 * we can not return filldir errors to the caller since they are
757 * "normal" when the stat blocksize is too small - we return remapped
760 * FIXME: This looks bogus. filldir returns -EOVERFLOW in the above
761 * case already. Why should we be clobbering other errors from it?
764 cFYI(1, "filldir rc = %d", rc
);
772 int cifs_readdir(struct file
*file
, void *direntry
, filldir_t filldir
)
776 struct cifs_sb_info
*cifs_sb
;
777 struct cifsTconInfo
*pTcon
;
778 struct cifsFileInfo
*cifsFile
= NULL
;
781 char *tmp_buf
= NULL
;
783 unsigned int max_len
;
787 cifs_sb
= CIFS_SB(file
->f_path
.dentry
->d_sb
);
789 switch ((int) file
->f_pos
) {
791 if (filldir(direntry
, ".", 1, file
->f_pos
,
792 file
->f_path
.dentry
->d_inode
->i_ino
, DT_DIR
) < 0) {
793 cERROR(1, "Filldir for current dir failed");
799 if (filldir(direntry
, "..", 2, file
->f_pos
,
800 file
->f_path
.dentry
->d_parent
->d_inode
->i_ino
, DT_DIR
) < 0) {
801 cERROR(1, "Filldir for parent dir failed");
807 /* 1) If search is active,
808 is in current search buffer?
809 if it before then restart search
810 if after then keep searching till find it */
812 if (file
->private_data
== NULL
) {
813 rc
= initiate_cifs_search(xid
, file
);
814 cFYI(1, "initiate cifs search rc %d", rc
);
820 if (file
->private_data
== NULL
) {
825 cifsFile
= file
->private_data
;
826 if (cifsFile
->srch_inf
.endOfSearch
) {
827 if (cifsFile
->srch_inf
.emptyDir
) {
828 cFYI(1, "End of search, empty dir");
833 cifsFile->invalidHandle = true;
834 CIFSFindClose(xid, pTcon, cifsFile->netfid);
837 pTcon
= cifsFile
->tcon
;
838 rc
= find_cifs_entry(xid
, pTcon
, file
,
839 ¤t_entry
, &num_to_fill
);
841 cFYI(1, "fce error %d", rc
);
843 } else if (current_entry
!= NULL
) {
844 cFYI(1, "entry %lld found", file
->f_pos
);
846 cFYI(1, "could not find entry");
849 cFYI(1, "loop through %d times filling dir for net buf %p",
850 num_to_fill
, cifsFile
->srch_inf
.ntwrk_buf_start
);
851 max_len
= smbCalcSize((struct smb_hdr
*)
852 cifsFile
->srch_inf
.ntwrk_buf_start
);
853 end_of_smb
= cifsFile
->srch_inf
.ntwrk_buf_start
+ max_len
;
855 tmp_buf
= kmalloc(UNICODE_NAME_MAX
, GFP_KERNEL
);
856 if (tmp_buf
== NULL
) {
861 for (i
= 0; (i
< num_to_fill
) && (rc
== 0); i
++) {
862 if (current_entry
== NULL
) {
863 /* evaluate whether this case is an error */
864 cERROR(1, "past SMB end, num to fill %d i %d",
868 /* if buggy server returns . and .. late do
869 we want to check for that here? */
870 rc
= cifs_filldir(current_entry
, file
,
871 filldir
, direntry
, tmp_buf
, max_len
);
872 if (rc
== -EOVERFLOW
) {
879 cifsFile
->srch_inf
.index_of_last_entry
) {
880 cFYI(1, "last entry in buf at pos %lld %s",
881 file
->f_pos
, tmp_buf
);
882 cifs_save_resume_key(current_entry
, cifsFile
);
886 nxt_dir_entry(current_entry
, end_of_smb
,
887 cifsFile
->srch_inf
.info_level
);