dired.c 34.4 KB
Newer Older
Richard M. Stallman's avatar
Richard M. Stallman committed
1
/* Lisp functions for making directory listings.
Paul Eggert's avatar
Paul Eggert committed
2
   Copyright (C) 1985-1986, 1993-1994, 1999-2019 Free Software
3
   Foundation, Inc.
Richard M. Stallman's avatar
Richard M. Stallman committed
4 5 6

This file is part of GNU Emacs.

7
GNU Emacs is free software: you can redistribute it and/or modify
Richard M. Stallman's avatar
Richard M. Stallman committed
8
it under the terms of the GNU General Public License as published by
9 10
the Free Software Foundation, either version 3 of the License, or (at
your option) any later version.
Richard M. Stallman's avatar
Richard M. Stallman committed
11 12 13 14 15 16 17

GNU Emacs is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
18
along with GNU Emacs.  If not, see <https://www.gnu.org/licenses/>.  */
Richard M. Stallman's avatar
Richard M. Stallman committed
19 20


21 22
#include <config.h>

Richard M. Stallman's avatar
Richard M. Stallman committed
23 24 25
#include <stdio.h>
#include <sys/stat.h>

26
#ifdef HAVE_PWD_H
Kenichi Handa's avatar
Kenichi Handa committed
27
#include <pwd.h>
28
#endif
Kenichi Handa's avatar
Kenichi Handa committed
29 30
#include <grp.h>

31
#include <errno.h>
32
#include <fcntl.h>
Andreas Schwab's avatar
Andreas Schwab committed
33 34
#include <unistd.h>

Richard M. Stallman's avatar
Richard M. Stallman committed
35
#include <dirent.h>
36
#include <filemode.h>
37
#include <stat-time.h>
38

Richard M. Stallman's avatar
Richard M. Stallman committed
39
#include "lisp.h"
40
#include "systime.h"
Richard M. Stallman's avatar
Richard M. Stallman committed
41
#include "buffer.h"
42
#include "coding.h"
Richard M. Stallman's avatar
Richard M. Stallman committed
43 44
#include "regex.h"

Eli Zaretskii's avatar
Eli Zaretskii committed
45 46 47 48
#ifdef MSDOS
#include "msdos.h"	/* for fstatat */
#endif

49 50 51 52
#ifdef WINDOWSNT
extern int is_slow_fs (const char *);
#endif

53
static ptrdiff_t scmp (const char *, const char *, ptrdiff_t);
54 55
static Lisp_Object file_attributes (int, char const *, Lisp_Object,
				    Lisp_Object, Lisp_Object);
Richard M. Stallman's avatar
Richard M. Stallman committed
56

57 58 59 60 61 62 63 64 65 66 67
/* Return the number of bytes in DP's name.  */
static ptrdiff_t
dirent_namelen (struct dirent *dp)
{
#ifdef _D_EXACT_NAMLEN
  return _D_EXACT_NAMLEN (dp);
#else
  return strlen (dp->d_name);
#endif
}

68 69 70 71 72 73 74 75 76 77 78 79 80 81 82
#ifndef HAVE_STRUCT_DIRENT_D_TYPE
enum { DT_UNKNOWN, DT_DIR, DT_LNK };
#endif

/* Return the file type of DP.  */
static int
dirent_type (struct dirent *dp)
{
#ifdef HAVE_STRUCT_DIRENT_D_TYPE
  return dp->d_type;
#else
  return DT_UNKNOWN;
#endif
}

83
static DIR *
84
open_directory (Lisp_Object dirname, int *fdp)
85
{
86
  char *name = SSDATA (dirname);
87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108
  DIR *d;
  int fd, opendir_errno;

#ifdef DOS_NT
  /* Directories cannot be opened.  The emulation assumes that any
     file descriptor other than AT_FDCWD corresponds to the most
     recently opened directory.  This hack is good enough for Emacs.  */
  fd = 0;
  d = opendir (name);
  opendir_errno = errno;
#else
  fd = emacs_open (name, O_RDONLY | O_DIRECTORY, 0);
  if (fd < 0)
    {
      opendir_errno = errno;
      d = 0;
    }
  else
    {
      d = fdopendir (fd);
      opendir_errno = errno;
      if (! d)
109
	emacs_close (fd);
110 111 112
    }
#endif

113 114
  if (!d)
    report_file_errno ("Opening directory", dirname, opendir_errno);
115 116 117 118
  *fdp = fd;
  return d;
}

119
#ifdef WINDOWSNT
120
static void
121 122 123 124 125
directory_files_internal_w32_unwind (Lisp_Object arg)
{
  Vw32_get_true_file_attributes = arg;
}
#endif
126

127
static void
128
directory_files_internal_unwind (void *d)
129 130 131 132
{
  closedir (d);
}

Paul Eggert's avatar
Paul Eggert committed
133 134
/* Return the next directory entry from DIR; DIR's name is DIRNAME.
   If there are no more directory entries, return a null pointer.
135
   Signal any unrecoverable errors.  */
Paul Eggert's avatar
Paul Eggert committed
136 137

static struct dirent *
138
read_dirent (DIR *dir, Lisp_Object dirname)
Paul Eggert's avatar
Paul Eggert committed
139 140 141 142 143 144 145 146
{
  while (true)
    {
      errno = 0;
      struct dirent *dp = readdir (dir);
      if (dp || errno == 0)
	return dp;
      if (! (errno == EAGAIN || errno == EINTR))
147
	{
148
#ifdef WINDOWSNT
149 150 151 152
	  /* The MS-Windows implementation of 'opendir' doesn't
	     actually open a directory until the first call to
	     'readdir'.  If 'readdir' fails to open the directory, it
	     sets errno to ENOENT or EACCES, see w32.c.  */
153
	  if (errno == ENOENT || errno == EACCES)
154
	    report_file_error ("Opening directory", dirname);
155 156
#endif
	  report_file_error ("Reading directory", dirname);
157
	}
Paul Eggert's avatar
Paul Eggert committed
158
      maybe_quit ();
Paul Eggert's avatar
Paul Eggert committed
159 160 161
    }
}

162
/* Function shared by Fdirectory_files and Fdirectory_files_and_attributes.
163 164
   If not ATTRS, return a list of directory filenames;
   if ATTRS, return a list of directory filenames and their attributes.
165
   In the latter case, pass ID_FORMAT to file_attributes.  */
166

167
Lisp_Object
168 169 170
directory_files_internal (Lisp_Object directory, Lisp_Object full,
			  Lisp_Object match, Lisp_Object nosort, bool attrs,
			  Lisp_Object id_format)
Richard M. Stallman's avatar
Richard M. Stallman committed
171
{
172
  ptrdiff_t directory_nbytes;
173
  Lisp_Object list, dirfilename, encoded_directory;
174
  struct re_pattern_buffer *bufp = NULL;
175
  bool needsep = 0;
176
  ptrdiff_t count = SPECPDL_INDEX ();
177 178 179
#ifdef WINDOWSNT
  Lisp_Object w32_save = Qnil;
#endif
180

181
  /* Don't let the compiler optimize away all copies of DIRECTORY,
182
     which would break GC; see Bug#16986.  */
183 184
  Lisp_Object volatile directory_volatile = directory;

185
  /* Because of file name handlers, these functions might call
186
     Ffuncall, and cause a GC.  */
187
  list = encoded_directory = dirfilename = Qnil;
188
  dirfilename = Fdirectory_file_name (directory);
189

Jim Blandy's avatar
Jim Blandy committed
190
  if (!NILP (match))
Richard M. Stallman's avatar
Richard M. Stallman committed
191
    {
192
      CHECK_STRING (match);
Jim Blandy's avatar
Jim Blandy committed
193 194

      /* MATCH might be a flawed regular expression.  Rather than
Karl Heuer's avatar
Karl Heuer committed
195
	 catching and signaling our own errors, we just call
Jim Blandy's avatar
Jim Blandy committed
196
	 compile_pattern to do the work for us.  */
197 198
      /* Pass 1 for the MULTIBYTE arg
	 because we do make multibyte strings if the contents warrant.  */
199 200 201
# ifdef WINDOWSNT
      /* Windows users want case-insensitive wildcards.  */
      bufp = compile_pattern (match, 0,
Tom Tromey's avatar
Tom Tromey committed
202
			      BVAR (&buffer_defaults, case_canon_table), 0, 1);
203
# else	/* !WINDOWSNT */
204
      bufp = compile_pattern (match, 0, Qnil, 0, 1);
205
# endif	 /* !WINDOWSNT */
Richard M. Stallman's avatar
Richard M. Stallman committed
206 207
    }

208
  /* Note: ENCODE_FILE and DECODE_FILE can GC because they can run
209 210
     run_pre_post_conversion_on_str which calls Lisp directly and
     indirectly.  */
211 212
  dirfilename = ENCODE_FILE (dirfilename);
  encoded_directory = ENCODE_FILE (directory);
213

214
  /* Now *bufp is the compiled form of MATCH; don't call anything
215 216
     which might compile a new regexp until we're done with the loop!  */

217 218
  int fd;
  DIR *d = open_directory (dirfilename, &fd);
Richard M. Stallman's avatar
Richard M. Stallman committed
219

220 221 222
  /* Unfortunately, we can now invoke expand-file-name and
     file-attributes on filenames, both of which can throw, so we must
     do a proper unwind-protect.  */
223
  record_unwind_protect_ptr (directory_files_internal_unwind, d);
224

225 226 227 228
#ifdef WINDOWSNT
  if (attrs)
    {
      /* Do this only once to avoid doing it (in w32.c:stat) for each
229
	 file in the directory, when we call file_attributes below.  */
230 231 232 233 234 235 236
      record_unwind_protect (directory_files_internal_w32_unwind,
			     Vw32_get_true_file_attributes);
      w32_save = Vw32_get_true_file_attributes;
      if (EQ (Vw32_get_true_file_attributes, Qlocal))
	{
	  /* w32.c:stat will notice these bindings and avoid calling
	     GetDriveType for each file.  */
237
	  if (is_slow_fs (SSDATA (dirfilename)))
238 239 240 241 242 243 244
	    Vw32_get_true_file_attributes = Qnil;
	  else
	    Vw32_get_true_file_attributes = Qt;
	}
    }
#endif

245
  directory_nbytes = SBYTES (directory);
246
  re_match_object = Qt;
Richard M. Stallman's avatar
Richard M. Stallman committed
247

248
  /* Decide whether we need to add a directory separator.  */
249
  if (directory_nbytes == 0
250
      || !IS_ANY_SEP (SREF (directory, directory_nbytes - 1)))
251 252
    needsep = 1;

Paul Eggert's avatar
Paul Eggert committed
253
  /* Loop reading directory entries.  */
254
  for (struct dirent *dp; (dp = read_dirent (d, directory)); )
Richard M. Stallman's avatar
Richard M. Stallman committed
255
    {
Paul Eggert's avatar
Paul Eggert committed
256 257 258
      ptrdiff_t len = dirent_namelen (dp);
      Lisp_Object name = make_unibyte_string (dp->d_name, len);
      Lisp_Object finalname = name;
259 260 261 262 263 264 265 266

      /* Note: DECODE_FILE can GC; it should protect its argument,
	 though.  */
      name = DECODE_FILE (name);
      len = SBYTES (name);

      /* Now that we have unwind_protect in place, we might as well
	 allow matching to be interrupted.  */
Paul Eggert's avatar
Paul Eggert committed
267
      maybe_quit ();
268

Paul Eggert's avatar
Paul Eggert committed
269
      bool wanted = (NILP (match)
270
		     || re_search (bufp, SSDATA (name), len, 0, len, 0) >= 0);
271 272

      if (wanted)
Richard M. Stallman's avatar
Richard M. Stallman committed
273
	{
274 275 276 277 278
	  if (!NILP (full))
	    {
	      Lisp_Object fullname;
	      ptrdiff_t nbytes = len + directory_nbytes + needsep;
	      ptrdiff_t nchars;
279

280 281 282
	      fullname = make_uninit_multibyte_string (nbytes, nbytes);
	      memcpy (SDATA (fullname), SDATA (directory),
		      directory_nbytes);
283

284 285
	      if (needsep)
		SSET (fullname, directory_nbytes, DIRECTORY_SEP);
286

287 288
	      memcpy (SDATA (fullname) + directory_nbytes + needsep,
		      SDATA (name), len);
289

290
	      nchars = multibyte_chars_in_text (SDATA (fullname), nbytes);
291

292 293 294
	      /* Some bug somewhere.  */
	      if (nchars > nbytes)
		emacs_abort ();
295

296 297 298 299 300
	      STRING_SET_CHARS (fullname, nchars);
	      if (nchars == nbytes)
		STRING_SET_UNIBYTE (fullname);

	      finalname = fullname;
Richard M. Stallman's avatar
Richard M. Stallman committed
301
	    }
302 303
	  else
	    finalname = name;
304

305 306
	  if (attrs)
	    {
307
	      Lisp_Object fileattrs
308
		= file_attributes (fd, dp->d_name, directory, name, id_format);
309 310 311 312
	      list = Fcons (Fcons (finalname, fileattrs), list);
	    }
	  else
	    list = Fcons (finalname, list);
Richard M. Stallman's avatar
Richard M. Stallman committed
313 314
	}
    }
315

Richard M. Stallman's avatar
Richard M. Stallman committed
316
  closedir (d);
317 318 319 320
#ifdef WINDOWSNT
  if (attrs)
    Vw32_get_true_file_attributes = w32_save;
#endif
321 322 323 324

  /* Discard the unwind protect.  */
  specpdl_ptr = specpdl + count;

325 326 327
  if (NILP (nosort))
    list = Fsort (Fnreverse (list),
		  attrs ? Qfile_attributes_lessp : Qstring_lessp);
328

329
  (void) directory_volatile;
330
  return list;
Richard M. Stallman's avatar
Richard M. Stallman committed
331
}
332 333 334


DEFUN ("directory-files", Fdirectory_files, Sdirectory_files, 1, 4, 0,
335 336 337 338 339 340
       doc: /* Return a list of names of files in DIRECTORY.
There are three optional arguments:
If FULL is non-nil, return absolute file names.  Otherwise return names
 that are relative to the specified directory.
If MATCH is non-nil, mention only file names that match the regexp MATCH.
If NOSORT is non-nil, the list is not sorted--its order is unpredictable.
341 342
 Otherwise, the list returned is sorted with `string-lessp'.
 NOSORT is useful if you plan to sort the result yourself.  */)
Dan Nicolaescu's avatar
Dan Nicolaescu committed
343
  (Lisp_Object directory, Lisp_Object full, Lisp_Object match, Lisp_Object nosort)
344 345
{
  Lisp_Object handler;
346
  directory = Fexpand_file_name (directory, Qnil);
347 348 349 350 351

  /* If the file name has special constructs in it,
     call the corresponding file handler.  */
  handler = Ffind_file_name_handler (directory, Qdirectory_files);
  if (!NILP (handler))
Kenichi Handa's avatar
Kenichi Handa committed
352 353
    return call5 (handler, Qdirectory_files, directory,
                  full, match, nosort);
354

355
  return directory_files_internal (directory, full, match, nosort, false, Qnil);
356 357
}

358
DEFUN ("directory-files-and-attributes", Fdirectory_files_and_attributes,
Kenichi Handa's avatar
Kenichi Handa committed
359
       Sdirectory_files_and_attributes, 1, 5, 0,
360
       doc: /* Return a list of names of files and their attributes in DIRECTORY.
361 362 363 364 365 366 367 368
Value is a list of the form:

  ((FILE1 FILE1-ATTRS) (FILE2 FILE2-ATTRS) ...)

where each FILEn-ATTRS is the attributes of FILEn as returned
by `file-attributes'.

This function accepts four optional arguments:
369 370 371 372
If FULL is non-nil, return absolute file names.  Otherwise return names
 that are relative to the specified directory.
If MATCH is non-nil, mention only file names that match the regexp MATCH.
If NOSORT is non-nil, the list is not sorted--its order is unpredictable.
Kenichi Handa's avatar
Kenichi Handa committed
373 374
 NOSORT is useful if you plan to sort the result yourself.
ID-FORMAT specifies the preferred format of attributes uid and gid, see
375 376 377
`file-attributes' for further documentation.
On MS-Windows, performance depends on `w32-get-true-file-attributes',
which see.  */)
Dan Nicolaescu's avatar
Dan Nicolaescu committed
378
  (Lisp_Object directory, Lisp_Object full, Lisp_Object match, Lisp_Object nosort, Lisp_Object id_format)
379 380
{
  Lisp_Object handler;
381
  directory = Fexpand_file_name (directory, Qnil);
382 383 384 385 386

  /* If the file name has special constructs in it,
     call the corresponding file handler.  */
  handler = Ffind_file_name_handler (directory, Qdirectory_files_and_attributes);
  if (!NILP (handler))
Kenichi Handa's avatar
Kenichi Handa committed
387 388
    return call6 (handler, Qdirectory_files_and_attributes,
                  directory, full, match, nosort, id_format);
389

390 391
  return directory_files_internal (directory, full, match, nosort,
				   true, id_format);
392 393
}

Richard M. Stallman's avatar
Richard M. Stallman committed
394

395 396
static Lisp_Object file_name_completion (Lisp_Object, Lisp_Object, bool,
					 Lisp_Object);
Richard M. Stallman's avatar
Richard M. Stallman committed
397 398

DEFUN ("file-name-completion", Ffile_name_completion, Sfile_name_completion,
399
       2, 3, 0,
400 401 402 403
       doc: /* Complete file name FILE in directory DIRECTORY.
Returns the longest string
common to all file names in DIRECTORY that start with FILE.
If there is only one and FILE matches it exactly, returns t.
404
Returns nil if DIRECTORY contains no name starting with FILE.
405

Richard M. Stallman's avatar
Richard M. Stallman committed
406 407 408
If PREDICATE is non-nil, call PREDICATE with each possible
completion (in absolute form) and ignore it if PREDICATE returns nil.

Stephen Leake's avatar
Stephen Leake committed
409 410 411 412
This function ignores some of the possible completions as determined
by the variables `completion-regexp-list' and
`completion-ignored-extensions', which see.  `completion-regexp-list'
is matched against file and directory names relative to DIRECTORY.  */)
Dan Nicolaescu's avatar
Dan Nicolaescu committed
413
  (Lisp_Object file, Lisp_Object directory, Lisp_Object predicate)
Richard M. Stallman's avatar
Richard M. Stallman committed
414
{
415
  Lisp_Object handler;
416
  directory = Fexpand_file_name (directory, Qnil);
417

418
  /* If the directory name has special constructs in it,
419
     call the corresponding file handler.  */
420
  handler = Ffind_file_name_handler (directory, Qfile_name_completion);
421
  if (!NILP (handler))
422
    return call4 (handler, Qfile_name_completion, file, directory, predicate);
423

424 425 426 427
  /* If the file name has special constructs in it,
     call the corresponding file handler.  */
  handler = Ffind_file_name_handler (file, Qfile_name_completion);
  if (!NILP (handler))
428
    return call4 (handler, Qfile_name_completion, file, directory, predicate);
429

430
  return file_name_completion (file, directory, 0, predicate);
Richard M. Stallman's avatar
Richard M. Stallman committed
431 432 433
}

DEFUN ("file-name-all-completions", Ffile_name_all_completions,
434 435
       Sfile_name_all_completions, 2, 2, 0,
       doc: /* Return a list of all completions of file name FILE in directory DIRECTORY.
Stephen Leake's avatar
Stephen Leake committed
436 437 438
These are all file names in directory DIRECTORY which begin with FILE.

This function ignores some of the possible completions as determined
439
by `completion-regexp-list', which see.  `completion-regexp-list'
Stephen Leake's avatar
Stephen Leake committed
440
is matched against file and directory names relative to DIRECTORY.  */)
Dan Nicolaescu's avatar
Dan Nicolaescu committed
441
  (Lisp_Object file, Lisp_Object directory)
Richard M. Stallman's avatar
Richard M. Stallman committed
442
{
443
  Lisp_Object handler;
444
  directory = Fexpand_file_name (directory, Qnil);
445

446
  /* If the directory name has special constructs in it,
447
     call the corresponding file handler.  */
448
  handler = Ffind_file_name_handler (directory, Qfile_name_all_completions);
449
  if (!NILP (handler))
450
    return call3 (handler, Qfile_name_all_completions, file, directory);
451

452 453 454 455
  /* If the file name has special constructs in it,
     call the corresponding file handler.  */
  handler = Ffind_file_name_handler (file, Qfile_name_all_completions);
  if (!NILP (handler))
456
    return call3 (handler, Qfile_name_all_completions, file, directory);
457

458
  return file_name_completion (file, directory, 1, Qnil);
Richard M. Stallman's avatar
Richard M. Stallman committed
459 460
}

461
static bool file_name_completion_dirp (int, struct dirent *, ptrdiff_t);
Andreas Schwab's avatar
Andreas Schwab committed
462

463
static Lisp_Object
464 465
file_name_completion (Lisp_Object file, Lisp_Object dirname, bool all_flag,
		      Lisp_Object predicate)
Richard M. Stallman's avatar
Richard M. Stallman committed
466
{
467
  ptrdiff_t bestmatchsize = 0;
Richard M. Stallman's avatar
Richard M. Stallman committed
468
  int matchcount = 0;
469 470 471
  /* If ALL_FLAG is 1, BESTMATCH is the list of all matches, decoded.
     If ALL_FLAG is 0, BESTMATCH is either nil
     or the best match so far, not decoded.  */
Richard M. Stallman's avatar
Richard M. Stallman committed
472
  Lisp_Object bestmatch, tem, elt, name;
473 474
  Lisp_Object encoded_file;
  Lisp_Object encoded_dir;
475
  bool directoryp;
476
  /* If not INCLUDEALL, exclude files in completion-ignored-extensions as
477 478
     well as "." and "..".  Until shown otherwise, assume we can't exclude
     anything.  */
479
  bool includeall = 1;
480
  bool check_decoded = false;
481
  ptrdiff_t count = SPECPDL_INDEX ();
482

483 484
  elt = Qnil;

485
  CHECK_STRING (file);
Richard M. Stallman's avatar
Richard M. Stallman committed
486 487

  bestmatch = Qnil;
488
  encoded_file = encoded_dir = Qnil;
489
  specbind (Qdefault_directory, dirname);
Richard M. Stallman's avatar
Richard M. Stallman committed
490

491 492 493
  /* Do completion on the encoded file name
     because the other names in the directory are (we presume)
     encoded likewise.  We decode the completed string at the end.  */
494 495 496
  /* Actually, this is not quite true any more: we do most of the completion
     work with decoded file names, but we still do some filtering based
     on the encoded file name.  */
497
  encoded_file = ENCODE_FILE (file);
498
  encoded_dir = ENCODE_FILE (Fdirectory_file_name (dirname));
499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520

  Lisp_Object file_encoding = Vfile_name_coding_system;
  if (NILP (Vfile_name_coding_system))
    file_encoding = Vdefault_file_name_coding_system;
  /* If the file-name encoding decomposes characters, as we do for
     HFS+ filesystems, we need to make an additional comparison of
     decoded names in order to filter false positives, such as "a"
     falsely matching "a-ring".  */
  if (!NILP (file_encoding)
      && !NILP (Fplist_get (Fcoding_system_plist (file_encoding),
			    Qdecomposed_characters)))
    {
      check_decoded = true;
      if (STRING_MULTIBYTE (file))
	{
	  /* Recompute FILE to make sure any decomposed characters in
	     it are re-composed by the post-read-conversion.
	     Otherwise, any decomposed characters will be rejected by
	     the additional check below.  */
	  file = DECODE_FILE (encoded_file);
	}
    }
521 522
  int fd;
  DIR *d = open_directory (encoded_dir, &fd);
523
  record_unwind_protect_ptr (directory_files_internal_unwind, d);
Richard M. Stallman's avatar
Richard M. Stallman committed
524

Paul Eggert's avatar
Paul Eggert committed
525
  /* Loop reading directory entries.  */
526
  for (struct dirent *dp; (dp = read_dirent (d, dirname)); )
Richard M. Stallman's avatar
Richard M. Stallman committed
527
    {
Paul Eggert's avatar
Paul Eggert committed
528
      ptrdiff_t len = dirent_namelen (dp);
529
      bool canexclude = 0;
Richard M. Stallman's avatar
Richard M. Stallman committed
530

Paul Eggert's avatar
Paul Eggert committed
531
      maybe_quit ();
532
      if (len < SCHARS (encoded_file)
533 534 535
	  || (scmp (dp->d_name, SSDATA (encoded_file),
		    SCHARS (encoded_file))
	      >= 0))
536
	continue;
Richard M. Stallman's avatar
Richard M. Stallman committed
537

538 539 540 541 542 543 544 545 546 547 548 549 550 551
      switch (dirent_type (dp))
	{
	case DT_DIR:
	  directoryp = true;
	  break;

	case DT_LNK: case DT_UNKNOWN:
	  directoryp = file_name_completion_dirp (fd, dp, len);
	  break;

	default:
	  directoryp = false;
	  break;
	}
Richard M. Stallman's avatar
Richard M. Stallman committed
552

553 554 555 556 557 558
      tem = Qnil;
      /* If all_flag is set, always include all.
	 It would not actually be helpful to the user to ignore any possible
	 completions when making a list of them.  */
      if (!all_flag)
	{
559
	  ptrdiff_t skip;
560

561
#if 0 /* FIXME: The `scmp' call compares an encoded and a decoded string. */
562 563 564 565 566 567 568 569
	  /* If this entry matches the current bestmatch, the only
	     thing it can do is increase matchcount, so don't bother
	     investigating it any further.  */
	  if (!completion_ignore_case
	      /* The return result depends on whether it's the sole match.  */
	      && matchcount > 1
	      && !includeall /* This match may allow includeall to 0.  */
	      && len >= bestmatchsize
570
	      && 0 > scmp (dp->d_name, SSDATA (bestmatch), bestmatchsize))
571
	    continue;
572
#endif
573

574
	  if (directoryp)
575 576 577 578
	    {
#ifndef TRIVIAL_DIRECTORY_ENTRY
#define TRIVIAL_DIRECTORY_ENTRY(n) (!strcmp (n, ".") || !strcmp (n, ".."))
#endif
579 580
	      /* "." and ".." are never interesting as completions, and are
		 actually in the way in a directory with only one file.  */
581 582 583
	      if (TRIVIAL_DIRECTORY_ENTRY (dp->d_name))
		canexclude = 1;
	      else if (len > SCHARS (encoded_file))
584 585 586 587 588
		/* Ignore directories if they match an element of
		   completion-ignored-extensions which ends in a slash.  */
		for (tem = Vcompletion_ignored_extensions;
		     CONSP (tem); tem = XCDR (tem))
		  {
589
		    ptrdiff_t elt_len;
590
		    char *p1;
591 592 593 594

		    elt = XCAR (tem);
		    if (!STRINGP (elt))
		      continue;
595 596 597
		    /* Need to encode ELT, since scmp compares unibyte
		       strings only.  */
		    elt = ENCODE_FILE (elt);
598
		    elt_len = SCHARS (elt) - 1; /* -1 for trailing / */
599
		    if (elt_len <= 0)
600
		      continue;
601
		    p1 = SSDATA (elt);
602 603 604 605 606 607
		    if (p1[elt_len] != '/')
		      continue;
		    skip = len - elt_len;
		    if (skip < 0)
		      continue;

608
		    if (scmp (dp->d_name + skip, p1, elt_len) >= 0)
609 610 611
		      continue;
		    break;
		  }
612 613
	    }
	  else
614
	    {
Richard M. Stallman's avatar
Richard M. Stallman committed
615 616
	      /* Compare extensions-to-be-ignored against end of this file name */
	      /* if name is not an exact match against specified string */
617
	      if (len > SCHARS (encoded_file))
Richard M. Stallman's avatar
Richard M. Stallman committed
618 619
		/* and exit this for loop if a match is found */
		for (tem = Vcompletion_ignored_extensions;
620
		     CONSP (tem); tem = XCDR (tem))
Richard M. Stallman's avatar
Richard M. Stallman committed
621
		  {
622
		    elt = XCAR (tem);
623
		    if (!STRINGP (elt)) continue;
624 625 626
		    /* Need to encode ELT, since scmp compares unibyte
		       strings only.  */
		    elt = ENCODE_FILE (elt);
627
		    skip = len - SCHARS (elt);
Richard M. Stallman's avatar
Richard M. Stallman committed
628 629
		    if (skip < 0) continue;

630 631
		    if (scmp (dp->d_name + skip, SSDATA (elt), SCHARS (elt))
			>= 0)
Richard M. Stallman's avatar
Richard M. Stallman committed
632 633 634 635 636
		      continue;
		    break;
		  }
	    }

637 638
	  /* If an ignored-extensions match was found,
	     don't process this name as a completion.  */
639 640
	  if (CONSP (tem))
	    canexclude = 1;
641

642 643 644
	  if (!includeall && canexclude)
	    /* We're not including all files and this file can be excluded.  */
	    continue;
645

646 647
	  if (includeall && !canexclude)
	    { /* If we have one non-excludable file, we want to exclude the
Paul Eggert's avatar
Paul Eggert committed
648
		 excludable files.  */
649 650 651 652 653
	      includeall = 0;
	      /* Throw away any previous excludable match found.  */
	      bestmatch = Qnil;
	      bestmatchsize = 0;
	      matchcount = 0;
654
	    }
655 656 657 658 659 660 661
	}
      /* FIXME: If we move this `decode' earlier we can eliminate
	 the repeated ENCODE_FILE on Vcompletion_ignored_extensions.  */
      name = make_unibyte_string (dp->d_name, len);
      name = DECODE_FILE (name);

      {
662 663
	Lisp_Object regexps, table = (completion_ignore_case
				      ? Vascii_canon_table : Qnil);
664 665

	/* Ignore this element if it fails to match all the regexps.  */
666 667 668 669
	for (regexps = Vcompletion_regexp_list; CONSP (regexps);
	     regexps = XCDR (regexps))
	  if (fast_string_match_internal (XCAR (regexps), name, table) < 0)
	    break;
670

671 672 673 674 675 676 677 678 679 680
	if (CONSP (regexps))
	  continue;
      }

      /* This is a possible completion */
      if (directoryp)
	/* This completion is a directory; make it end with '/'.  */
	name = Ffile_name_as_directory (name);

      /* Test the predicate, if any.  */
681 682
      if (!NILP (predicate) && NILP (call1 (predicate, name)))
	continue;
683

684 685 686 687
      /* Reject entries where the encoded strings match, but the
         decoded don't.  For example, "a" should not match "a-ring" on
         file systems that store decomposed characters. */
      Lisp_Object zero = make_number (0);
688

689 690
      if (check_decoded && SCHARS (file) <= SCHARS (name))
	{
691 692 693 694 695 696
	  /* FIXME: This is a copy of the code below.  */
	  ptrdiff_t compare = SCHARS (file);
	  Lisp_Object cmp
	    = Fcompare_strings (name, zero, make_number (compare),
				file, zero, make_number (compare),
				completion_ignore_case ? Qt : Qnil);
697 698 699 700
	  if (!EQ (cmp, Qt))
	    continue;
	}

701
      /* Suitably record this match.  */
Richard M. Stallman's avatar
Richard M. Stallman committed
702

703
      matchcount += matchcount <= 1;
704

705 706 707 708 709 710 711 712 713 714
      if (all_flag)
	bestmatch = Fcons (name, bestmatch);
      else if (NILP (bestmatch))
	{
	  bestmatch = name;
	  bestmatchsize = SCHARS (name);
	}
      else
	{
	  /* FIXME: This is a copy of the code in Ftry_completion.  */
715 716 717 718 719
	  ptrdiff_t compare = min (bestmatchsize, SCHARS (name));
	  Lisp_Object cmp
	    = Fcompare_strings (bestmatch, zero, make_number (compare),
				name, zero, make_number (compare),
				completion_ignore_case ? Qt : Qnil);
Paul Eggert's avatar
Paul Eggert committed
720
	  ptrdiff_t matchsize = EQ (cmp, Qt) ? compare : eabs (XINT (cmp)) - 1;
721 722

	  if (completion_ignore_case)
723
	    {
724 725 726 727 728 729 730
	      /* If this is an exact match except for case,
		 use it as the best match rather than one that is not
		 an exact match.  This way, we get the case pattern
		 of the actual match.  */
	      /* This tests that the current file is an exact match
		 but BESTMATCH is not (it is too long).  */
	      if ((matchsize == SCHARS (name)
731
		   && matchsize + directoryp < SCHARS (bestmatch))
732 733 734 735 736 737 738 739 740 741 742
		  ||
		  /* If there is no exact match ignoring case,
		     prefer a match that does not change the case
		     of the input.  */
		  /* If there is more than one exact match aside from
		     case, and one of them is exact including case,
		     prefer that one.  */
		  /* This == checks that, of current file and BESTMATCH,
		     either both or neither are exact.  */
		  (((matchsize == SCHARS (name))
		    ==
743
		    (matchsize + directoryp == SCHARS (bestmatch)))
744
		   && (cmp = Fcompare_strings (name, zero,
745 746 747 748
					       make_number (SCHARS (file)),
					       file, zero,
					       Qnil,
					       Qnil),
749 750
		       EQ (Qt, cmp))
		   && (cmp = Fcompare_strings (bestmatch, zero,
751 752 753 754
					       make_number (SCHARS (file)),
					       file, zero,
					       Qnil,
					       Qnil),
755
		       ! EQ (Qt, cmp))))
756
		bestmatch = name;
Richard M. Stallman's avatar
Richard M. Stallman committed
757
	    }
758
	  bestmatchsize = matchsize;
759 760 761 762 763 764 765 766 767 768 769 770 771 772

	  /* If the best completion so far is reduced to the string
	     we're trying to complete, then we already know there's no
	     other completion, so there's no point looking any further.  */
	  if (matchsize <= SCHARS (file)
	      && !includeall /* A future match may allow includeall to 0.  */
	      /* If completion-ignore-case is non-nil, don't
		 short-circuit because we want to find the best
		 possible match *including* case differences.  */
	      && (!completion_ignore_case || matchsize == 0)
	      /* The return value depends on whether it's the sole match.  */
	      && matchcount > 1)
	    break;

Richard M. Stallman's avatar
Richard M. Stallman committed
773 774 775
	}
    }

776
  /* This closes the directory.  */
777
  bestmatch = unbind_to (count, bestmatch);
Richard M. Stallman's avatar
Richard M. Stallman committed
778

Jim Blandy's avatar
Jim Blandy committed
779
  if (all_flag || NILP (bestmatch))
780
    return bestmatch;
781 782 783
  /* Return t if the supplied string is an exact match (counting case);
     it does not require any change to be made.  */
  if (matchcount == 1 && !NILP (Fequal (bestmatch, file)))
Richard M. Stallman's avatar
Richard M. Stallman committed
784
    return Qt;
785 786 787
  bestmatch = Fsubstring (bestmatch, make_number (0),
			  make_number (bestmatchsize));
  return bestmatch;
Richard M. Stallman's avatar
Richard M. Stallman committed
788 789
}

790 791 792 793 794
/* Compare exactly LEN chars of strings at S1 and S2,
   ignoring case if appropriate.
   Return -1 if strings match,
   else number of chars that match at the beginning.  */

795 796
static ptrdiff_t
scmp (const char *s1, const char *s2, ptrdiff_t len)
797
{
798
  register ptrdiff_t l = len;
799 800 801

  if (completion_ignore_case)
    {
802
      while (l
803 804
	     && (downcase ((unsigned char) *s1++)
		 == downcase ((unsigned char) *s2++)))
805 806 807 808 809 810 811 812 813 814 815 816 817
	l--;
    }
  else
    {
      while (l && *s1++ == *s2++)
	l--;
    }
  if (l == 0)
    return -1;
  else
    return len - l;
}

818 819 820 821
/* Return true if in the directory FD the directory entry DP, whose
   string length is LEN, is that of a subdirectory that can be searched.  */
static bool
file_name_completion_dirp (int fd, struct dirent *dp, ptrdiff_t len)
Richard M. Stallman's avatar
Richard M. Stallman committed
822
{
823 824 825 826 827 828 829
  USE_SAFE_ALLOCA;
  char *subdir_name = SAFE_ALLOCA (len + 2);
  memcpy (subdir_name, dp->d_name, len);
  strcpy (subdir_name + len, "/");
  bool dirp = faccessat (fd, subdir_name, F_OK, AT_EACCESS) == 0;
  SAFE_FREE ();
  return dirp;
Richard M. Stallman's avatar
Richard M. Stallman committed
830 831
}

832 833 834 835 836 837
static char *
stat_uname (struct stat *st)
{
#ifdef WINDOWSNT
  return st->st_uname;
#else
838
  struct passwd *pw = getpwuid (st->st_uid);
839 840 841 842 843 844 845 846 847 848 849 850 851 852

  if (pw)
    return pw->pw_name;
  else
    return NULL;
#endif
}

static char *
stat_gname (struct stat *st)
{
#ifdef WINDOWSNT
  return st->st_gname;
#else
853
  struct group *gr = getgrgid (st->st_gid);
854 855 856 857 858 859 860 861

  if (gr)
    return gr->gr_name;
  else
    return NULL;
#endif
}

Kenichi Handa's avatar
Kenichi Handa committed
862
DEFUN ("file-attributes", Ffile_attributes, Sfile_attributes, 1, 2, 0,
863 864
       doc: /* Return a list of attributes of file FILENAME.
Value is nil if specified file cannot be opened.
Kenichi Handa's avatar
Kenichi Handa committed
865 866

ID-FORMAT specifies the preferred format of attributes uid and gid (see
867
below) - valid values are `string' and `integer'.  The latter is the
868 869
default, but we plan to change that, so you should specify a non-nil value
for ID-FORMAT if you use the returned uid or gid.
Kenichi Handa's avatar
Kenichi Handa committed
870

871 872 873 874 875 876 877 878
To access the elements returned, the following access functions are
provided: `file-attribute-type', `file-attribute-link-number',
`file-attribute-user-id', `file-attribute-group-id',
`file-attribute-access-time', `file-attribute-modification-time',
`file-attribute-status-change-time', `file-attribute-size',
`file-attribute-modes', `file-attribute-inode-number', and
`file-attribute-device-number'.

Kenichi Handa's avatar
Kenichi Handa committed
879
Elements of the attribute list are:
880 881
 0. t for directory, string (name linked to) for symbolic link, or nil.
 1. Number of links to file.
882 883
 2. File uid as a string or a number.  If a string value cannot be
  looked up, a numeric value, either an integer or a float, is returned.
Kenichi Handa's avatar
Kenichi Handa committed
884
 3. File gid, likewise.
885 886
 4. Last access time, as a list of integers (HIGH LOW USEC PSEC) in the
  same style as (current-time).
887 888 889 890 891
  (See a note below about access time on FAT-based filesystems.)
 5. Last modification time, likewise.  This is the time of the last
  change to the file's contents.
 6. Last status change time, likewise.  This is the time of last change
  to the file's attributes: owner and group, access mode bits, etc.
892 893 894
 7. Size in bytes.
  This is a floating point number if the size is too large for an integer.
 8. File modes, as a string of ten letters or dashes as in ls -l.
895
 9. An unspecified value, present only for backward compatibility.
896 897 898 899
10. inode number.  If it is larger than what an Emacs integer can hold,
  this is of the form (HIGH . LOW): first the high bits, then the low 16 bits.
  If even HIGH is too large for an Emacs integer, this is instead of the form
  (HIGH MIDDLE . LOW): first the high bits, then the middle 24 bits,
900 901 902 903 904 905
  and finally the low 16 bits.
11. Filesystem device number.  If it is larger than what the Emacs
  integer can hold, this is a cons cell, similar to the inode number.

On most filesystems, the combination of the inode and the device
number uniquely identifies the file.
906 907

On MS-Windows, performance depends on `w32-get-true-file-attributes',
Eli Zaretskii's avatar
Eli Zaretskii committed
908 909 910 911
which see.

On some FAT-based filesystems, only the date of last access is recorded,
so last access time will always be midnight of that day.  */)
Dan Nicolaescu's avatar
Dan Nicolaescu committed
912
  (Lisp_Object filename, Lisp_Object id_format)
Richard M. Stallman's avatar
Richard M. Stallman committed
913
{
914
  Lisp_Object encoded;
915
  Lisp_Object handler;
Richard M. Stallman's avatar
Richard M. Stallman committed
916

917 918 919 920
  filename = internal_condition_case_2 (Fexpand_file_name, filename, Qnil,
					Qt, Fidentity);
  if (!STRINGP (filename))
    return Qnil;
921 922 923

  /* If the file name has special constructs in it,
     call the corresponding file handler.  */
924
  handler = Ffind_file_name_handler (filename, Qfile_attributes);
925
  if (!NILP (handler))
Kenichi Handa's avatar
Kenichi Handa committed
926 927 928 929 930 931 932
    { /* Only pass the extra arg if it is used to help backward compatibility
	 with old file handlers which do not implement the new arg.  --Stef  */
      if (NILP (id_format))
	return call2 (handler, Qfile_attributes, filename);
      else
	return call3 (handler, Qfile_attributes, filename, id_format);
    }
933

934
  encoded = ENCODE_FILE (filename);
935 936
  return file_attributes (AT_FDCWD, SSDATA (encoded), Qnil, filename,
			  id_format);
937 938 939
}

static Lisp_Object
940 941 942
file_attributes (int fd, char const *name,
		 Lisp_Object dirname, Lisp_Object filename,
		 Lisp_Object id_format)
943
{
944
  ptrdiff_t count = SPECPDL_INDEX ();
945 946 947 948 949 950 951
  struct stat s;

  /* An array to hold the mode string generated by filemodestring,
     including its terminating space and null byte.  */
  char modes[sizeof "-rwxr-xr-x "];

  char *uname = NULL, *gname = NULL;
952

953
  int err = EINVAL;
954

955 956 957 958 959 960 961 962
#ifdef O_PATH
  int namefd = openat (fd, name, O_PATH | O_CLOEXEC | O_NOFOLLOW);
  if (namefd < 0)
    err = errno;
  else
    {
      record_unwind_protect_int (close_file_unwind, namefd);
      if (fstat (namefd, &s) != 0)
963 964 965 966 967 968 969 970
	{
	  err = errno;
	  /* The Linux kernel before version 3.6 does not support
	     fstat on O_PATH file descriptors.  Handle this error like
	     missing support for O_PATH.  */
	  if (err == EBADF)
	    err = EINVAL;
	}
Paul Eggert's avatar