dired.c 33.9 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-2020 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
#include <sys/stat.h>

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

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

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

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

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

47 48 49 50
#ifdef WINDOWSNT
extern int is_slow_fs (const char *);
#endif

51
static ptrdiff_t scmp (const char *, const char *, ptrdiff_t);
52 53
static Lisp_Object file_attributes (int, char const *, Lisp_Object,
				    Lisp_Object, Lisp_Object);
Richard M. Stallman's avatar
Richard M. Stallman committed
54

55 56 57 58 59 60 61 62 63 64 65
/* 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
}

66 67 68 69 70 71 72 73 74 75 76 77 78 79 80
#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
}

81
static DIR *
82
open_directory (Lisp_Object dirname, Lisp_Object encoded_dirname, int *fdp)
83
{
84
  char *name = SSDATA (encoded_dirname);
85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106
  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)
107
	emacs_close (fd);
108 109 110
    }
#endif

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

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

125
static void
126
directory_files_internal_unwind (void *d)
127 128 129 130
{
  closedir (d);
}

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

static struct dirent *
136
read_dirent (DIR *dir, Lisp_Object dirname)
Paul Eggert's avatar
Paul Eggert committed
137 138 139 140 141 142 143 144
{
  while (true)
    {
      errno = 0;
      struct dirent *dp = readdir (dir);
      if (dp || errno == 0)
	return dp;
      if (! (errno == EAGAIN || errno == EINTR))
145
	{
146
#ifdef WINDOWSNT
147 148 149 150
	  /* 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.  */
151
	  if (errno == ENOENT || errno == EACCES)
152
	    report_file_error ("Opening directory", dirname);
153 154
#endif
	  report_file_error ("Reading directory", dirname);
155
	}
Paul Eggert's avatar
Paul Eggert committed
156
      maybe_quit ();
Paul Eggert's avatar
Paul Eggert committed
157 158 159
    }
}

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

165
Lisp_Object
166 167 168
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
169
{
170 171
  if (!NILP (match))
    CHECK_STRING (match);
172

173
  /* Don't let the compiler optimize away all copies of DIRECTORY,
174
     which would break GC; see Bug#16986.  */
175 176
  Lisp_Object volatile directory_volatile = directory;

177
  Lisp_Object dirfilename = Fdirectory_file_name (directory);
178

179
  /* Note: ENCODE_FILE and DECODE_FILE can GC because they can run
180 181
     run_pre_post_conversion_on_str which calls Lisp directly and
     indirectly.  */
182
  Lisp_Object encoded_dirfilename = ENCODE_FILE (dirfilename);
183

184
  int fd;
185
  DIR *d = open_directory (dirfilename, encoded_dirfilename, &fd);
Richard M. Stallman's avatar
Richard M. Stallman committed
186

187 188 189
  /* 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.  */
190
  ptrdiff_t count = SPECPDL_INDEX ();
191
  record_unwind_protect_ptr (directory_files_internal_unwind, d);
192

193
#ifdef WINDOWSNT
194
  Lisp_Object w32_save = Qnil;
195 196 197
  if (attrs)
    {
      /* Do this only once to avoid doing it (in w32.c:stat) for each
198
	 file in the directory, when we call file_attributes below.  */
199 200 201 202 203 204 205
      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.  */
206
	  if (is_slow_fs (SSDATA (encoded_dirfilename)))
207 208 209 210 211 212 213
	    Vw32_get_true_file_attributes = Qnil;
	  else
	    Vw32_get_true_file_attributes = Qt;
	}
    }
#endif

214
  ptrdiff_t directory_nbytes = SBYTES (directory);
215
  re_match_object = Qt;
Richard M. Stallman's avatar
Richard M. Stallman committed
216

217
  /* Decide whether we need to add a directory separator.  */
218 219
  bool needsep = (directory_nbytes == 0
		  || !IS_ANY_SEP (SREF (directory, directory_nbytes - 1)));
220

221
  /* Windows users want case-insensitive wildcards.  */
222
  Lisp_Object case_table = Qnil;
223
#ifdef WINDOWSNT
224
  case_table = BVAR (&buffer_defaults, case_canon_table);
225 226
#endif

227 228
  /* Read directory entries and accumulate them into LIST.  */
  Lisp_Object list = Qnil;
229
  for (struct dirent *dp; (dp = read_dirent (d, directory)); )
Richard M. Stallman's avatar
Richard M. Stallman committed
230
    {
Paul Eggert's avatar
Paul Eggert committed
231 232 233
      ptrdiff_t len = dirent_namelen (dp);
      Lisp_Object name = make_unibyte_string (dp->d_name, len);
      Lisp_Object finalname = name;
234

235
      /* This can GC.  */
236 237
      name = DECODE_FILE (name);

Paul Eggert's avatar
Paul Eggert committed
238
      maybe_quit ();
239

240 241 242
      if (!NILP (match)
	  && fast_string_match_internal (match, name, case_table) < 0)
	continue;
243

Paul Eggert's avatar
Paul Eggert committed
244
      Lisp_Object fileattrs UNINIT;
245
      if (attrs)
Richard M. Stallman's avatar
Richard M. Stallman committed
246
	{
247 248 249 250 251
	  fileattrs = file_attributes (fd, dp->d_name, directory, name,
				       id_format);
	  if (NILP (fileattrs))
	    continue;
	}
252

253 254 255 256 257 258 259 260 261 262 263 264 265
      if (!NILP (full))
	{
	  ptrdiff_t name_nbytes = SBYTES (name);
	  ptrdiff_t nbytes = directory_nbytes + needsep + name_nbytes;
	  ptrdiff_t nchars = SCHARS (directory) + needsep + SCHARS (name);
	  finalname = make_uninit_multibyte_string (nchars, nbytes);
	  if (nchars == nbytes)
	    STRING_SET_UNIBYTE (finalname);
	  memcpy (SDATA (finalname), SDATA (directory), directory_nbytes);
	  if (needsep)
	    SSET (finalname, directory_nbytes, DIRECTORY_SEP);
	  memcpy (SDATA (finalname) + directory_nbytes + needsep,
		  SDATA (name), name_nbytes);
Richard M. Stallman's avatar
Richard M. Stallman committed
266
	}
267 268 269 270
      else
	finalname = name;

      list = Fcons (attrs ? Fcons (finalname, fileattrs) : finalname, list);
Richard M. Stallman's avatar
Richard M. Stallman committed
271
    }
272

Richard M. Stallman's avatar
Richard M. Stallman committed
273
  closedir (d);
274 275 276 277
#ifdef WINDOWSNT
  if (attrs)
    Vw32_get_true_file_attributes = w32_save;
#endif
278 279 280 281

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

282 283 284
  if (NILP (nosort))
    list = Fsort (Fnreverse (list),
		  attrs ? Qfile_attributes_lessp : Qstring_lessp);
285

286
  (void) directory_volatile;
287
  return list;
Richard M. Stallman's avatar
Richard M. Stallman committed
288
}
289 290 291


DEFUN ("directory-files", Fdirectory_files, Sdirectory_files, 1, 4, 0,
292 293 294 295 296 297
       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.
298 299
 Otherwise, the list returned is sorted with `string-lessp'.
 NOSORT is useful if you plan to sort the result yourself.  */)
300 301
  (Lisp_Object directory, Lisp_Object full, Lisp_Object match,
   Lisp_Object nosort)
302
{
303
  directory = Fexpand_file_name (directory, Qnil);
304 305

  /* If the file name has special constructs in it,
306
     call the corresponding file name handler.  */
307
  Lisp_Object handler = Ffind_file_name_handler (directory, Qdirectory_files);
308
  if (!NILP (handler))
Kenichi Handa's avatar
Kenichi Handa committed
309 310
    return call5 (handler, Qdirectory_files, directory,
                  full, match, nosort);
311

312
  return directory_files_internal (directory, full, match, nosort, false, Qnil);
313 314
}

315
DEFUN ("directory-files-and-attributes", Fdirectory_files_and_attributes,
Kenichi Handa's avatar
Kenichi Handa committed
316
       Sdirectory_files_and_attributes, 1, 5, 0,
317
       doc: /* Return a list of names of files and their attributes in DIRECTORY.
318 319
Value is a list of the form:

Paul Eggert's avatar
Paul Eggert committed
320
  ((FILE1 . FILE1-ATTRS) (FILE2 . FILE2-ATTRS) ...)
321 322 323 324 325

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

This function accepts four optional arguments:
326 327 328 329
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
330 331
 NOSORT is useful if you plan to sort the result yourself.
ID-FORMAT specifies the preferred format of attributes uid and gid, see
332 333 334
`file-attributes' for further documentation.
On MS-Windows, performance depends on `w32-get-true-file-attributes',
which see.  */)
335 336
  (Lisp_Object directory, Lisp_Object full, Lisp_Object match,
   Lisp_Object nosort, Lisp_Object id_format)
337
{
338
  directory = Fexpand_file_name (directory, Qnil);
339 340

  /* If the file name has special constructs in it,
341
     call the corresponding file name handler.  */
342 343
  Lisp_Object handler
    = Ffind_file_name_handler (directory, Qdirectory_files_and_attributes);
344
  if (!NILP (handler))
Kenichi Handa's avatar
Kenichi Handa committed
345 346
    return call6 (handler, Qdirectory_files_and_attributes,
                  directory, full, match, nosort, id_format);
347

348 349
  return directory_files_internal (directory, full, match, nosort,
				   true, id_format);
350 351
}

Richard M. Stallman's avatar
Richard M. Stallman committed
352

353 354
static Lisp_Object file_name_completion (Lisp_Object, Lisp_Object, bool,
					 Lisp_Object);
Richard M. Stallman's avatar
Richard M. Stallman committed
355 356

DEFUN ("file-name-completion", Ffile_name_completion, Sfile_name_completion,
357
       2, 3, 0,
358 359 360 361
       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.
362
Returns nil if DIRECTORY contains no name starting with FILE.
363

Richard M. Stallman's avatar
Richard M. Stallman committed
364 365 366
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
367 368 369 370
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
371
  (Lisp_Object file, Lisp_Object directory, Lisp_Object predicate)
Richard M. Stallman's avatar
Richard M. Stallman committed
372
{
373
  Lisp_Object handler;
374
  directory = Fexpand_file_name (directory, Qnil);
375

376
  /* If the directory name has special constructs in it,
377
     call the corresponding file name handler.  */
378
  handler = Ffind_file_name_handler (directory, Qfile_name_completion);
379
  if (!NILP (handler))
380
    return call4 (handler, Qfile_name_completion, file, directory, predicate);
381

382
  /* If the file name has special constructs in it,
383
     call the corresponding file name handler.  */
384 385
  handler = Ffind_file_name_handler (file, Qfile_name_completion);
  if (!NILP (handler))
386
    return call4 (handler, Qfile_name_completion, file, directory, predicate);
387

388
  return file_name_completion (file, directory, 0, predicate);
Richard M. Stallman's avatar
Richard M. Stallman committed
389 390 391
}

DEFUN ("file-name-all-completions", Ffile_name_all_completions,
392 393
       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
394 395 396
These are all file names in directory DIRECTORY which begin with FILE.

This function ignores some of the possible completions as determined
397
by `completion-regexp-list', which see.  `completion-regexp-list'
Stephen Leake's avatar
Stephen Leake committed
398
is matched against file and directory names relative to DIRECTORY.  */)
Dan Nicolaescu's avatar
Dan Nicolaescu committed
399
  (Lisp_Object file, Lisp_Object directory)
Richard M. Stallman's avatar
Richard M. Stallman committed
400
{
401
  Lisp_Object handler;
402
  directory = Fexpand_file_name (directory, Qnil);
403

404
  /* If the directory name has special constructs in it,
405
     call the corresponding file name handler.  */
406
  handler = Ffind_file_name_handler (directory, Qfile_name_all_completions);
407
  if (!NILP (handler))
408
    return call3 (handler, Qfile_name_all_completions, file, directory);
409

410
  /* If the file name has special constructs in it,
411
     call the corresponding file name handler.  */
412 413
  handler = Ffind_file_name_handler (file, Qfile_name_all_completions);
  if (!NILP (handler))
414
    return call3 (handler, Qfile_name_all_completions, file, directory);
415

416
  return file_name_completion (file, directory, 1, Qnil);
Richard M. Stallman's avatar
Richard M. Stallman committed
417 418
}

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

421
static Lisp_Object
422 423
file_name_completion (Lisp_Object file, Lisp_Object dirname, bool all_flag,
		      Lisp_Object predicate)
Richard M. Stallman's avatar
Richard M. Stallman committed
424
{
425
  ptrdiff_t bestmatchsize = 0;
Richard M. Stallman's avatar
Richard M. Stallman committed
426
  int matchcount = 0;
427 428 429
  /* 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
430
  Lisp_Object bestmatch, tem, elt, name;
431 432
  Lisp_Object encoded_file;
  Lisp_Object encoded_dir;
433
  bool directoryp;
434
  /* If not INCLUDEALL, exclude files in completion-ignored-extensions as
435 436
     well as "." and "..".  Until shown otherwise, assume we can't exclude
     anything.  */
437
  bool includeall = 1;
438
  bool check_decoded = false;
439
  ptrdiff_t count = SPECPDL_INDEX ();
440

441 442
  elt = Qnil;

443
  CHECK_STRING (file);
Richard M. Stallman's avatar
Richard M. Stallman committed
444 445

  bestmatch = Qnil;
446
  encoded_file = encoded_dir = Qnil;
447
  specbind (Qdefault_directory, dirname);
Richard M. Stallman's avatar
Richard M. Stallman committed
448

449 450 451
  /* 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.  */
452 453 454
  /* 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.  */
455
  encoded_file = ENCODE_FILE (file);
456
  encoded_dir = ENCODE_FILE (Fdirectory_file_name (dirname));
457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478

  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);
	}
    }
479
  int fd;
480
  DIR *d = open_directory (dirname, encoded_dir, &fd);
481
  record_unwind_protect_ptr (directory_files_internal_unwind, d);
Richard M. Stallman's avatar
Richard M. Stallman committed
482

Paul Eggert's avatar
Paul Eggert committed
483
  /* Loop reading directory entries.  */
484 485 486
  Lisp_Object zero = make_fixnum (0);
  ptrdiff_t enc_file_len = SCHARS (encoded_file);
  Lisp_Object file_len = make_fixnum (SCHARS (file));
487
  for (struct dirent *dp; (dp = read_dirent (d, dirname)); )
Richard M. Stallman's avatar
Richard M. Stallman committed
488
    {
Paul Eggert's avatar
Paul Eggert committed
489
      ptrdiff_t len = dirent_namelen (dp);
490
      bool canexclude = 0;
Richard M. Stallman's avatar
Richard M. Stallman committed
491

Paul Eggert's avatar
Paul Eggert committed
492
      maybe_quit ();
493 494 495 496 497 498

      if (len < enc_file_len
	  /* scmp cannot reliably compare non-ASCII strings while
	     ignoring letter-case.  */
	  || (!completion_ignore_case
	      && scmp (dp->d_name, SSDATA (encoded_file), enc_file_len) >= 0))
499
	continue;
Richard M. Stallman's avatar
Richard M. Stallman committed
500

501 502 503 504 505 506 507 508 509
      name = make_unibyte_string (dp->d_name, len);
      name = DECODE_FILE (name);
      ptrdiff_t name_blen = SBYTES (name), name_len = SCHARS (name);
      if (completion_ignore_case
	  && !EQ (Fcompare_strings (name, zero, file_len, file, zero, file_len,
				    Qt),
		  Qt))
	    continue;

510 511 512 513 514 515 516 517 518 519 520 521 522 523
      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
524

525 526 527 528 529 530
      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)
	{
531
	  ptrdiff_t skip;
532
	  Lisp_Object cmp_len = make_fixnum (name_len);
533

534
#if 0 /* FIXME: The `scmp' call compares an encoded and a decoded string. */
535 536 537 538 539 540 541 542
	  /* 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
543
	      && 0 > scmp (dp->d_name, SSDATA (bestmatch), bestmatchsize))
544
	    continue;
545
#endif
546

547
	  if (directoryp)
548 549 550 551
	    {
#ifndef TRIVIAL_DIRECTORY_ENTRY
#define TRIVIAL_DIRECTORY_ENTRY(n) (!strcmp (n, ".") || !strcmp (n, ".."))
#endif
552 553
	      /* "." and ".." are never interesting as completions, and are
		 actually in the way in a directory with only one file.  */
554 555
	      if (TRIVIAL_DIRECTORY_ENTRY (dp->d_name))
		canexclude = 1;
556
	      else if (len > enc_file_len)
557 558 559 560 561
		/* 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))
		  {
562
		    ptrdiff_t elt_len;
563
		    char *p1;
564 565 566 567

		    elt = XCAR (tem);
		    if (!STRINGP (elt))
		      continue;
568
		    elt_len = SBYTES (elt) - 1; /* -1 for trailing / */
569
		    if (elt_len <= 0)
570
		      continue;
571
		    p1 = SSDATA (elt);
572 573
		    if (p1[elt_len] != '/')
		      continue;
574
		    skip = name_blen - elt_len;
575 576 577
		    if (skip < 0)
		      continue;

578 579
		    if (!completion_ignore_case
			&& scmp (SSDATA (name) + skip, p1, elt_len) >= 0)
580
		      continue;
581 582 583 584 585 586 587
		    if (completion_ignore_case)
		      {
			elt_len = SCHARS (elt) - 1;
			skip = name_len - elt_len;
			cmp_len = make_fixnum (elt_len);
			if (skip < 0
			    || !EQ (Fcompare_strings (name, make_fixnum (skip),
Eli Zaretskii's avatar
Eli Zaretskii committed
588
						      Qnil,
589 590 591 592
						      elt, zero, cmp_len, Qt),
				    Qt))
			  continue;
		      }
593 594
		    break;
		  }
595 596
	    }
	  else
597
	    {
Richard M. Stallman's avatar
Richard M. Stallman committed
598 599
	      /* Compare extensions-to-be-ignored against end of this file name */
	      /* if name is not an exact match against specified string */
600
	      if (len > enc_file_len)
Richard M. Stallman's avatar
Richard M. Stallman committed
601 602
		/* and exit this for loop if a match is found */
		for (tem = Vcompletion_ignored_extensions;
603
		     CONSP (tem); tem = XCDR (tem))
Richard M. Stallman's avatar
Richard M. Stallman committed
604
		  {
605
		    elt = XCAR (tem);
606
		    if (!STRINGP (elt)) continue;
607 608
		    ptrdiff_t elt_len = SBYTES (elt);
		    skip = len - elt_len;
Richard M. Stallman's avatar
Richard M. Stallman committed
609 610
		    if (skip < 0) continue;

611 612 613
		    if (!completion_ignore_case
			&& (scmp (SSDATA (name) + skip, SSDATA (elt), elt_len)
			    >= 0))
Richard M. Stallman's avatar
Richard M. Stallman committed
614
		      continue;
615 616 617 618 619 620 621
		    if (completion_ignore_case)
		      {
			elt_len = SCHARS (elt);
			skip = name_len - elt_len;
			cmp_len = make_fixnum (elt_len);
			if (skip < 0
			    || !EQ (Fcompare_strings (name, make_fixnum (skip),
Eli Zaretskii's avatar
Eli Zaretskii committed
622
						      Qnil,
623 624 625 626
						      elt, zero, cmp_len, Qt),
				    Qt))
			  continue;
		      }
Richard M. Stallman's avatar
Richard M. Stallman committed
627 628 629 630
		    break;
		  }
	    }

631 632
	  /* If an ignored-extensions match was found,
	     don't process this name as a completion.  */
633 634
	  if (CONSP (tem))
	    canexclude = 1;
635

636 637 638
	  if (!includeall && canexclude)
	    /* We're not including all files and this file can be excluded.  */
	    continue;
639

640 641
	  if (includeall && !canexclude)
	    { /* If we have one non-excludable file, we want to exclude the
Paul Eggert's avatar
Paul Eggert committed
642
		 excludable files.  */
643 644 645 646 647
	      includeall = 0;
	      /* Throw away any previous excludable match found.  */
	      bestmatch = Qnil;
	      bestmatchsize = 0;
	      matchcount = 0;
648
	    }
649 650
	}

651 652
      Lisp_Object regexps, table = (completion_ignore_case
				    ? Vascii_canon_table : Qnil);
653

654 655 656 657 658
      /* Ignore this element if it fails to match all the regexps.  */
      for (regexps = Vcompletion_regexp_list; CONSP (regexps);
	   regexps = XCDR (regexps))
	if (fast_string_match_internal (XCAR (regexps), name, table) < 0)
	  break;
659

660 661
      if (CONSP (regexps))
	continue;
662 663 664 665 666 667 668

      /* 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.  */
669 670
      if (!NILP (predicate) && NILP (call1 (predicate, name)))
	continue;
671

672 673 674 675 676
      /* 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. */
      if (check_decoded && SCHARS (file) <= SCHARS (name))
	{
677 678 679
	  /* FIXME: This is a copy of the code below.  */
	  ptrdiff_t compare = SCHARS (file);
	  Lisp_Object cmp
680 681
	    = Fcompare_strings (name, zero, make_fixnum (compare),
				file, zero, make_fixnum (compare),
682
				completion_ignore_case ? Qt : Qnil);
683 684 685 686
	  if (!EQ (cmp, Qt))
	    continue;
	}

687
      /* Suitably record this match.  */
Richard M. Stallman's avatar
Richard M. Stallman committed
688

689
      matchcount += matchcount <= 1;
690

691 692 693 694 695 696 697 698 699 700
      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.  */
701 702
	  ptrdiff_t compare = min (bestmatchsize, SCHARS (name));
	  Lisp_Object cmp
703 704
	    = Fcompare_strings (bestmatch, zero, make_fixnum (compare),
				name, zero, make_fixnum (compare),
705
				completion_ignore_case ? Qt : Qnil);
Tom Tromey's avatar
Tom Tromey committed
706
	  ptrdiff_t matchsize = EQ (cmp, Qt) ? compare : eabs (XFIXNUM (cmp)) - 1;
707 708

	  if (completion_ignore_case)
709
	    {
710 711 712 713 714 715 716
	      /* 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)
717
		   && matchsize + directoryp < SCHARS (bestmatch))
718 719 720 721 722 723 724 725 726 727 728
		  ||
		  /* 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))
		    ==
729
		    (matchsize + directoryp == SCHARS (bestmatch)))
730
		   && (cmp = Fcompare_strings (name, zero,
731
					       make_fixnum (SCHARS (file)),
732 733 734
					       file, zero,
					       Qnil,
					       Qnil),
735 736
		       EQ (Qt, cmp))
		   && (cmp = Fcompare_strings (bestmatch, zero,
737
					       make_fixnum (SCHARS (file)),
738 739 740
					       file, zero,
					       Qnil,
					       Qnil),
741
		       ! EQ (Qt, cmp))))
742
		bestmatch = name;
Richard M. Stallman's avatar
Richard M. Stallman committed
743
	    }
744
	  bestmatchsize = matchsize;
745 746 747 748 749 750 751 752 753 754 755 756 757 758

	  /* 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
759 760 761
	}
    }

762
  /* This closes the directory.  */
763
  bestmatch = unbind_to (count, bestmatch);
Richard M. Stallman's avatar
Richard M. Stallman committed
764

Jim Blandy's avatar
Jim Blandy committed
765
  if (all_flag || NILP (bestmatch))
766
    return bestmatch;
767 768 769
  /* 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
770
    return Qt;
771 772
  bestmatch = Fsubstring (bestmatch, make_fixnum (0),
			  make_fixnum (bestmatchsize));
773
  return bestmatch;
Richard M. Stallman's avatar
Richard M. Stallman committed
774 775
}

776 777 778 779 780
/* 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.  */

781 782
static ptrdiff_t
scmp (const char *s1, const char *s2, ptrdiff_t len)
783
{
784
  register ptrdiff_t l = len;
785 786 787

  if (completion_ignore_case)
    {
788 789 790
      /* WARNING: This only works for pure ASCII strings, as we
	 compare bytes, not characters!  Use Fcompare_strings for
	 comparing non-ASCII strings case-insensitively.  */
791
      while (l
792 793
	     && (downcase ((unsigned char) *s1++)
		 == downcase ((unsigned char) *s2++)))
794 795 796 797 798 799 800 801 802 803 804 805 806
	l--;
    }
  else
    {
      while (l && *s1++ == *s2++)
	l--;
    }
  if (l == 0)
    return -1;
  else
    return len - l;
}

807 808 809 810
/* 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
811
{
812 813 814 815 816 817 818
  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
819 820
}

821 822 823 824 825 826
static char *
stat_uname (struct stat *st)
{
#ifdef WINDOWSNT
  return st->st_uname;
#else
827
  struct passwd *pw = getpwuid (st->st_uid);
828 829 830 831 832 833 834 835 836 837 838 839 840 841

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

static char *
stat_gname (struct stat *st)
{
#ifdef WINDOWSNT
  return st->st_gname;
#else
842
  struct group *gr = getgrgid (st->st_gid);
843 844 845 846 847 848 849 850

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

Kenichi Handa's avatar
Kenichi Handa committed
851
DEFUN ("file-attributes", Ffile_attributes, Sfile_attributes, 1, 2, 0,
852
       doc: /* Return a list of attributes of file FILENAME.
853
Value is nil if specified file does not exist.
Kenichi Handa's avatar
Kenichi Handa committed
854 855

ID-FORMAT specifies the preferred format of attributes uid and gid (see
856
below) - valid values are `string' and `integer'.  The latter is the
857 858
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
859

860 861 862 863 864 865 866 867
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
868
Elements of the attribute list are:
869 870
 0. t for directory, string (name linked to) for symbolic link, or nil.
 1. Number of links to file.
Paul Eggert's avatar
Paul Eggert committed
871 872
 2. File uid as a string or (if ID-FORMAT is `integer' or a string value
  cannot be looked up) as an integer.
Kenichi Handa's avatar
Kenichi Handa committed
873
 3. File gid, likewise.
Paul Eggert's avatar
Paul Eggert committed
874
 4. Last access time, in the style of `current-time'.
875 876 877 878 879
  (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.
Paul Eggert's avatar
Paul Eggert committed
880
 7. Size in bytes, as an integer.
881
 8. File modes, as a string of ten letters or dashes as in ls -l.
882
 9. An unspecified value, present only for backward compatibility.
Paul Eggert's avatar
Paul Eggert committed
883 884
10. inode number, as a nonnegative integer.
11. Filesystem device number, as an integer.
885

Paul Eggert's avatar
Paul Eggert committed
886
Large integers are bignums, so `eq' might not work on them.
887 888
On most filesystems, the combination of the inode and the device
number uniquely identifies the file.
889 890

On MS-Windows, performance depends on `w32-get-true-file-attributes',
Eli Zaretskii's avatar
Eli Zaretskii committed
891 892 893 894
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
895
  (Lisp_Object filename, Lisp_Object id_format)
Richard M. Stallman's avatar
Richard M. Stallman committed
896
{
897
  Lisp_Object encoded;
898
  Lisp_Object handler;
Richard M. Stallman's avatar
Richard M. Stallman committed
899

900 901 902 903
  filename = internal_condition_case_2 (Fexpand_file_name, filename, Qnil,
					Qt, Fidentity);
  if (!STRINGP (filename))
    return Qnil;
904 905

  /* If the file name has special constructs in it,
906
     call the corresponding file name handler.  */
907
  handler = Ffind_file_name_handler (filename, Qfile_attributes);
908
  if (!NILP (handler))
909 910 911
    { /* Only pass the extra arg if it is used to help backward
	 compatibility with old file name handlers which do not
	 implement the new arg.  --Stef */
Kenichi Handa's avatar
Kenichi Handa committed
912 913 914 915 916
      if (NILP (id_format))
	return call2 (handler, Qfile_attributes, filename);
      else
	return call3 (handler, Qfile_attributes, filename, id_format);
    }
917

918
  encoded = ENCODE_FILE (filename);
919 920
  return file_attributes (AT_FDCWD, SSDATA (encoded), Qnil, filename,
			  id_format);
921 922 923
}

static Lisp_Object
924 925 926
file_attributes (int fd, char const *name,
		 Lisp_Object dirname, Lisp_Object filename,
		 Lisp_Object id_format)
927
{
928
  ptrdiff_t count = SPECPDL_INDEX ();
929 930 931
  struct stat s;

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

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

937
  int err = EINVAL;
938

939
#if defined O_PATH && !defined HAVE_CYGWIN_O_PATH_BUG
940
  int namefd = emacs_openat (fd, name, O_PATH | O_CLOEXEC | O_NOFOLLOW, 0);
941 942 943 944 945 946
  if (namefd < 0)
    err = errno;
  else
    {
      record_unwind_protect_int (close_file_unwind, namefd);
      if (fstat (namefd, &s) != 0)
947 948 949 950 951 952 953 954
	{
	  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;
	}
955 956 957 958 959 960 961 962
      else
	{
	  err = 0;
	  fd = namefd;
	  name = "";
	}
    }
#endif
963

964 965 966 967 968 969 970 971 972
  if (err == EINVAL)
    {
#ifdef WINDOWSNT
      /* We usually don't request accurate owner and group info,
	 because it can be expensive on Windows to get that, and most
	 callers of 'lstat' don't need that.  But here we do want that
	 information to be accurate.  */
      w32_stat_get_owner_group = 1;
#endif
973
      err = emacs_fstatat (fd, name, &s, AT_SYMLINK_NOFOLLOW) == 0 ? 0 : errno;
974
#ifdef WINDOWSNT
975
      w32_stat_get_owner_group = 0;
976
#endif
977
    }
978

979
  if (err != 0)
980
    return unbind_to (count, file_attribute_errno (filename, err));
981 982 983 984 985 986 987 988

  Lisp_Object file_type;
  if (S_ISLNK (s.st_mode))
    {
      /* On systems lacking O_PATH support there is a race if the
	 symlink is replaced between the call to fstatat and the call
	 to emacs_readlinkat.  Detect this race unless the replacement
	 is also a symlink.  */
989
      file_type = check_emacs_readlinkat (fd, filename, name);
990 991 992 993 994 995 996
      if (NILP (file_type))
	return unbind_to (count, Qnil);
    }
  else
    file_type = S_ISDIR (s.st_mode) ? Qt : Qnil;

  unbind_to (count, Qnil);
Richard M. Stallman's avatar
Richard M. Stallman committed
997

998
  if (!(NILP (id_format) || EQ (id_format, Qinteger)))
Kenichi Handa's avatar
Kenichi Handa committed
999
    {
1000 1001
      uname = stat_uname (&s);
      gname = stat_gname (&s);
Kenichi Handa's avatar
Kenichi Handa committed
1002
    }
1003

Richard M. Stallman's avatar
Richard M. Stallman committed
1004
  filemodestring (&s, modes);
1005

1006
  return CALLN (Flist,
1007
		file_type,
1008
		make_fixnum (s.st_nlink),
1009 1010
		(uname
		 ? DECODE_SYSTEM (build_unibyte_string (uname))
1011
		 : INT_TO_INTEGER (s.st_uid)),
1012 1013
		(gname
		 ? DECODE_SYSTEM (build_unibyte_string (gname))
1014
		 : INT_TO_INTEGER (s.st_gid)),
1015 1016 1017 1018 1019 1020 1021 1022
		make_lisp_time (get_stat_atime (&s)),
		make_lisp_time (get_stat_mtime (&s)),
		make_lisp_time (get_stat_ctime (&s)),

		/* If the file size is a 4-byte type, assume that
		   files of sizes in the 2-4 GiB range wrap around to
		   negative values, as this is a common bug on older
		   32-bit platforms.  */
1023 1024 1025
		INT_TO_INTEGER (sizeof (s.st_size) == 4
			    ? s.st_size & 0xffffffffu
			    : s.st_size),
1026 1027 1028

		make_string (modes, 10),
		Qt,
1029 1030
		INT_TO_INTEGER (s.st_ino),
		INT_TO_INTEGER (s.st_dev));
Richard M. Stallman's avatar
Richard M. Stallman committed
1031
}
1032

1033 1034
DEFUN ("file-attributes-lessp", Ffile_attributes_lessp,
       Sfile_attributes_lessp, 2, 2, 0,
1035 1036
       doc: /* Return t if first arg file attributes list is less than second.
Comparison is in lexicographic order and case is significant.  */)
Dan Nicolaescu's avatar
Dan Nicolaescu committed
1037
  (Lisp_Object f1, Lisp_Object f2)
1038 1039 1040
{
  return Fstring_lessp (Fcar (f1), Fcar (f2));
}
Richard M. Stallman's avatar
Richard M. Stallman committed
1041

1042 1043 1044

DEFUN ("system-users", Fsystem_users, Ssystem_users, 0, 0, 0,
       doc: /* Return a list of user names currently registered in the system.
1045 1046
If we don't know how to determine that on this platform, just
return a list with one element, taken from `user-real-login-name'.  */)
1047 1048 1049
     (void)
{
  Lisp_Object users = Qnil;
1050
#if defined HAVE_GETPWENT && defined HAVE_ENDPWENT