1 /* Copyright (C) 1996,1997,1998,1999,2000,2001, 2002, 2004, 2006, 2008 Free Software Foundation, Inc.
3 * This library is free software; you can redistribute it and/or
4 * modify it under the terms of the GNU Lesser General Public
5 * License as published by the Free Software Foundation; either
6 * version 2.1 of the License, or (at your option) any later version.
8 * This library is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
11 * Lesser General Public License for more details.
13 * You should have received a copy of the GNU Lesser General Public
14 * License along with this library; if not, write to the Free Software
15 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21 /* See stime.c for comments on why _POSIX_C_SOURCE is not always defined. */
22 #define _LARGEFILE64_SOURCE /* ask for stat64 etc */
24 #define _POSIX_C_SOURCE 199506L /* for readdir_r */
26 #if defined(__INTERIX) && !defined(_REENTRANT)
27 # define _REENTRANT /* ask Interix for readdir_r prototype */
34 /* This blob per the Autoconf manual (under "Particular Functions"), updated
35 to match that of Gnulib. */
39 # elif defined __GNUC__
40 # define alloca __builtin_alloca
42 # define alloca __alloca
43 # elif defined _MSC_VER
45 # define alloca _alloca
51 void *alloca (size_t);
58 #include "libguile/_scm.h"
59 #include "libguile/smob.h"
60 #include "libguile/feature.h"
61 #include "libguile/fports.h"
62 #include "libguile/private-gc.h" /* for SCM_MAX */
63 #include "libguile/iselect.h"
64 #include "libguile/strings.h"
65 #include "libguile/vectors.h"
66 #include "libguile/lang.h"
67 #include "libguile/dynwind.h"
69 #include "libguile/validate.h"
70 #include "libguile/filesys.h"
81 #ifdef TIME_WITH_SYS_TIME
82 # include <sys/time.h>
86 # include <sys/time.h>
96 #ifdef LIBC_H_WITH_UNISTD_H
100 #ifdef HAVE_SYS_SELECT_H
101 #include <sys/select.h>
108 #include <sys/types.h>
109 #include <sys/stat.h>
117 #if defined (__MINGW32__) || defined (_MSC_VER) || defined (__BORLANDC__)
118 # include "win32-dirent.h"
119 # define NAMLEN(dirent) strlen((dirent)->d_name)
120 /* The following bits are per AC_HEADER_DIRENT doco in the autoconf manual */
123 # define NAMLEN(dirent) strlen((dirent)->d_name)
125 # define dirent direct
126 # define NAMLEN(dirent) (dirent)->d_namlen
128 # include <sys/ndir.h>
131 # include <sys/dir.h>
138 /* Ultrix has S_IFSOCK, but no S_ISSOCK. Ipe! */
139 #if defined (S_IFSOCK) && ! defined (S_ISSOCK)
140 #define S_ISSOCK(mode) (((mode) & S_IFMT) == S_IFSOCK)
143 /* The MinGW gcc does not define the S_ISSOCK macro. Any other native Windows
144 compiler like BorlandC or MSVC has none of these macros defined. */
166 # define _S_IFIFO 0x1000 /* FIFO */
167 # define _S_IFCHR 0x2000 /* Character */
168 # define _S_IFBLK 0x3000 /* Block */
169 # define _S_IFDIR 0x4000 /* Directory */
170 # define _S_IFREG 0x8000 /* Regular */
171 # define _S_IFSOCK 0xC000 /* Socket */
192 # define S_ISBLK(mode) (((mode) & _S_IFMT) == _S_IFBLK)
193 # define S_ISFIFO(mode) (((mode) & _S_IFMT) == _S_IFIFO)
194 # define S_ISCHR(mode) (((mode) & _S_IFMT) == _S_IFCHR)
195 # define S_ISDIR(mode) (((mode) & _S_IFMT) == _S_IFDIR)
196 # define S_ISREG(mode) (((mode) & _S_IFMT) == _S_IFREG)
197 # define S_ISSOCK(mode) (((mode) & _S_IFMT) == _S_IFSOCK)
199 #endif /* __MINGW32__ */
201 /* Some more definitions for the native Windows port. */
203 # define mkdir(path, mode) mkdir (path)
204 # define fsync(fd) _commit (fd)
205 # define fchmod(fd, mode) (-1)
206 #endif /* __MINGW32__ */
208 /* dirfd() returns the file descriptor underlying a "DIR*" directory stream.
209 Found on MacOS X for instance. The following definition is for Solaris
210 10, it's probably not right elsewhere, but that's ok, it shouldn't be
211 used elsewhere. Crib note: If we need more then gnulib has a dirfd.m4
212 figuring out how to get the fd (dirfd function, dirfd macro, dd_fd field,
215 #define dirfd(dirstream) ((dirstream)->dd_fd)
220 /* Two helper macros for an often used pattern */
222 #define STRING_SYSCALL(str,cstr,code) \
225 char *cstr = scm_to_locale_string (str); \
226 SCM_SYSCALL (code); \
227 eno = errno; free (cstr); errno = eno; \
230 #define STRING2_SYSCALL(str1,cstr1,str2,cstr2,code) \
233 char *cstr1, *cstr2; \
234 scm_dynwind_begin (0); \
235 cstr1 = scm_to_locale_string (str1); \
236 scm_dynwind_free (cstr1); \
237 cstr2 = scm_to_locale_string (str2); \
238 scm_dynwind_free (cstr2); \
239 SCM_SYSCALL (code); \
240 eno = errno; scm_dynwind_end (); errno = eno; \
249 SCM_DEFINE (scm_chown, "chown", 3, 0, 0,
250 (SCM object, SCM owner, SCM group),
251 "Change the ownership and group of the file referred to by @var{object} to\n"
252 "the integer values @var{owner} and @var{group}. @var{object} can be\n"
253 "a string containing a file name or, if the platform\n"
254 "supports fchown, a port or integer file descriptor\n"
255 "which is open on the file. The return value\n"
256 "is unspecified.\n\n"
257 "If @var{object} is a symbolic link, either the\n"
258 "ownership of the link or the ownership of the referenced file will be\n"
259 "changed depending on the operating system (lchown is\n"
260 "unsupported at present). If @var{owner} or @var{group} is specified\n"
261 "as @code{-1}, then that ID is not changed.")
262 #define FUNC_NAME s_scm_chown
266 object = SCM_COERCE_OUTPORT (object);
269 if (scm_is_integer (object) || (SCM_OPFPORTP (object)))
271 int fdes = (SCM_OPFPORTP (object)?
272 SCM_FPORT_FDES (object) : scm_to_int (object));
274 SCM_SYSCALL (rv = fchown (fdes, scm_to_int (owner), scm_to_int (group)));
279 STRING_SYSCALL (object, c_object,
280 rv = chown (c_object,
281 scm_to_int (owner), scm_to_int (group)));
285 return SCM_UNSPECIFIED;
288 #endif /* HAVE_CHOWN */
291 SCM_DEFINE (scm_chmod, "chmod", 2, 0, 0,
292 (SCM object, SCM mode),
293 "Changes the permissions of the file referred to by @var{obj}.\n"
294 "@var{obj} can be a string containing a file name or a port or integer file\n"
295 "descriptor which is open on a file (in which case @code{fchmod} is used\n"
296 "as the underlying system call).\n"
297 "@var{mode} specifies\n"
298 "the new permissions as a decimal number, e.g., @code{(chmod \"foo\" #o755)}.\n"
299 "The return value is unspecified.")
300 #define FUNC_NAME s_scm_chmod
305 object = SCM_COERCE_OUTPORT (object);
307 if (scm_is_integer (object) || SCM_OPFPORTP (object))
309 if (scm_is_integer (object))
310 fdes = scm_to_int (object);
312 fdes = SCM_FPORT_FDES (object);
313 SCM_SYSCALL (rv = fchmod (fdes, scm_to_int (mode)));
317 STRING_SYSCALL (object, c_object,
318 rv = chmod (c_object, scm_to_int (mode)));
322 return SCM_UNSPECIFIED;
326 SCM_DEFINE (scm_umask, "umask", 0, 1, 0,
328 "If @var{mode} is omitted, returns a decimal number representing the current\n"
329 "file creation mask. Otherwise the file creation mask is set to\n"
330 "@var{mode} and the previous value is returned.\n\n"
331 "E.g., @code{(umask #o022)} sets the mask to octal 22, decimal 18.")
332 #define FUNC_NAME s_scm_umask
335 if (SCM_UNBNDP (mode))
342 mask = umask (scm_to_uint (mode));
344 return scm_from_uint (mask);
350 SCM_DEFINE (scm_open_fdes, "open-fdes", 2, 1, 0,
351 (SCM path, SCM flags, SCM mode),
352 "Similar to @code{open} but return a file descriptor instead of\n"
354 #define FUNC_NAME s_scm_open_fdes
360 iflags = SCM_NUM2INT (2, flags);
361 imode = SCM_NUM2INT_DEF (3, mode, 0666);
362 STRING_SYSCALL (path, c_path, fd = open_or_open64 (c_path, iflags, imode));
365 return scm_from_int (fd);
369 SCM_DEFINE (scm_open, "open", 2, 1, 0,
370 (SCM path, SCM flags, SCM mode),
371 "Open the file named by @var{path} for reading and/or writing.\n"
372 "@var{flags} is an integer specifying how the file should be opened.\n"
373 "@var{mode} is an integer specifying the permission bits of the file, if\n"
374 "it needs to be created, before the umask is applied. The default is 666\n"
375 "(Unix itself has no default).\n\n"
376 "@var{flags} can be constructed by combining variables using @code{logior}.\n"
377 "Basic flags are:\n\n"
379 "Open the file read-only.\n"
382 "Open the file write-only.\n"
385 "Open the file read/write.\n"
388 "Append to the file instead of truncating.\n"
391 "Create the file if it does not already exist.\n"
393 "See the Unix documentation of the @code{open} system call\n"
394 "for additional flags.")
395 #define FUNC_NAME s_scm_open
402 fd = scm_to_int (scm_open_fdes (path, flags, mode));
403 iflags = SCM_NUM2INT (2, flags);
406 if (iflags & O_APPEND)
408 else if (iflags & O_CREAT)
414 if (iflags & O_APPEND)
416 else if (iflags & O_WRONLY)
421 newpt = scm_fdes_to_port (fd, port_mode, path);
426 SCM_DEFINE (scm_close, "close", 1, 0, 0,
428 "Similar to close-port (@pxref{Closing, close-port}),\n"
429 "but also works on file descriptors. A side\n"
430 "effect of closing a file descriptor is that any ports using that file\n"
431 "descriptor are moved to a different file descriptor and have\n"
432 "their revealed counts set to zero.")
433 #define FUNC_NAME s_scm_close
438 fd_or_port = SCM_COERCE_OUTPORT (fd_or_port);
440 if (SCM_PORTP (fd_or_port))
441 return scm_close_port (fd_or_port);
442 fd = scm_to_int (fd_or_port);
443 scm_evict_ports (fd); /* see scsh manual. */
444 SCM_SYSCALL (rv = close (fd));
445 /* following scsh, closing an already closed file descriptor is
447 if (rv < 0 && errno != EBADF)
449 return scm_from_bool (rv >= 0);
453 SCM_DEFINE (scm_close_fdes, "close-fdes", 1, 0, 0,
455 "A simple wrapper for the @code{close} system call.\n"
456 "Close file descriptor @var{fd}, which must be an integer.\n"
457 "Unlike close (@pxref{Ports and File Descriptors, close}),\n"
458 "the file descriptor will be closed even if a port is using it.\n"
459 "The return value is unspecified.")
460 #define FUNC_NAME s_scm_close_fdes
465 c_fd = scm_to_int (fd);
466 SCM_SYSCALL (rv = close (c_fd));
469 return SCM_UNSPECIFIED;
477 SCM_SYMBOL (scm_sym_regular, "regular");
478 SCM_SYMBOL (scm_sym_directory, "directory");
480 SCM_SYMBOL (scm_sym_symlink, "symlink");
482 SCM_SYMBOL (scm_sym_block_special, "block-special");
483 SCM_SYMBOL (scm_sym_char_special, "char-special");
484 SCM_SYMBOL (scm_sym_fifo, "fifo");
485 SCM_SYMBOL (scm_sym_sock, "socket");
486 SCM_SYMBOL (scm_sym_unknown, "unknown");
489 scm_stat2scm (struct stat_or_stat64 *stat_temp)
491 SCM ans = scm_c_make_vector (15, SCM_UNSPECIFIED);
493 SCM_SIMPLE_VECTOR_SET(ans, 0, scm_from_ulong (stat_temp->st_dev));
494 SCM_SIMPLE_VECTOR_SET(ans, 1, scm_from_ino_t_or_ino64_t (stat_temp->st_ino));
495 SCM_SIMPLE_VECTOR_SET(ans, 2, scm_from_ulong (stat_temp->st_mode));
496 SCM_SIMPLE_VECTOR_SET(ans, 3, scm_from_ulong (stat_temp->st_nlink));
497 SCM_SIMPLE_VECTOR_SET(ans, 4, scm_from_ulong (stat_temp->st_uid));
498 SCM_SIMPLE_VECTOR_SET(ans, 5, scm_from_ulong (stat_temp->st_gid));
499 #ifdef HAVE_STRUCT_STAT_ST_RDEV
500 SCM_SIMPLE_VECTOR_SET(ans, 6, scm_from_ulong (stat_temp->st_rdev));
502 SCM_SIMPLE_VECTOR_SET(ans, 6, SCM_BOOL_F);
504 SCM_SIMPLE_VECTOR_SET(ans, 7, scm_from_off_t_or_off64_t (stat_temp->st_size));
505 SCM_SIMPLE_VECTOR_SET(ans, 8, scm_from_ulong (stat_temp->st_atime));
506 SCM_SIMPLE_VECTOR_SET(ans, 9, scm_from_ulong (stat_temp->st_mtime));
507 SCM_SIMPLE_VECTOR_SET(ans, 10, scm_from_ulong (stat_temp->st_ctime));
508 #ifdef HAVE_STRUCT_STAT_ST_BLKSIZE
509 SCM_SIMPLE_VECTOR_SET(ans, 11, scm_from_ulong (stat_temp->st_blksize));
511 SCM_SIMPLE_VECTOR_SET(ans, 11, scm_from_ulong (4096L));
513 #ifdef HAVE_STRUCT_STAT_ST_BLOCKS
514 SCM_SIMPLE_VECTOR_SET(ans, 12, scm_from_blkcnt_t_or_blkcnt64_t (stat_temp->st_blocks));
516 SCM_SIMPLE_VECTOR_SET(ans, 12, SCM_BOOL_F);
519 int mode = stat_temp->st_mode;
522 SCM_SIMPLE_VECTOR_SET(ans, 13, scm_sym_regular);
523 else if (S_ISDIR (mode))
524 SCM_SIMPLE_VECTOR_SET(ans, 13, scm_sym_directory);
526 /* systems without symlinks probably don't have S_ISLNK */
527 else if (S_ISLNK (mode))
528 SCM_SIMPLE_VECTOR_SET(ans, 13, scm_sym_symlink);
530 else if (S_ISBLK (mode))
531 SCM_SIMPLE_VECTOR_SET(ans, 13, scm_sym_block_special);
532 else if (S_ISCHR (mode))
533 SCM_SIMPLE_VECTOR_SET(ans, 13, scm_sym_char_special);
534 else if (S_ISFIFO (mode))
535 SCM_SIMPLE_VECTOR_SET(ans, 13, scm_sym_fifo);
537 else if (S_ISSOCK (mode))
538 SCM_SIMPLE_VECTOR_SET(ans, 13, scm_sym_sock);
541 SCM_SIMPLE_VECTOR_SET(ans, 13, scm_sym_unknown);
543 SCM_SIMPLE_VECTOR_SET(ans, 14, scm_from_int ((~S_IFMT) & mode));
545 /* the layout of the bits in ve[14] is intended to be portable.
546 If there are systems that don't follow the usual convention,
547 the following could be used:
550 if (S_ISUID & mode) tmp += 1;
552 if (S_IRGRP & mode) tmp += 1;
554 if (S_ISVTX & mode) tmp += 1;
556 if (S_IRUSR & mode) tmp += 1;
558 if (S_IWUSR & mode) tmp += 1;
560 if (S_IXUSR & mode) tmp += 1;
562 if (S_IWGRP & mode) tmp += 1;
564 if (S_IXGRP & mode) tmp += 1;
566 if (S_IROTH & mode) tmp += 1;
568 if (S_IWOTH & mode) tmp += 1;
570 if (S_IXOTH & mode) tmp += 1;
572 SCM_SIMPLE_VECTOR_SET(ans, 14, scm_from_int (tmp));
582 * Try getting the appropiate stat buffer for a given file descriptor
583 * under Windows. It differentiates between file, pipe and socket
586 static int fstat_Win32 (int fdes, struct stat *buf)
588 int error, optlen = sizeof (int);
590 memset (buf, 0, sizeof (struct stat));
592 /* Is this a socket ? */
593 if (getsockopt (fdes, SOL_SOCKET, SO_ERROR, (void *) &error, &optlen) >= 0)
595 buf->st_mode = _S_IFSOCK | _S_IREAD | _S_IWRITE | _S_IEXEC;
597 buf->st_atime = buf->st_ctime = buf->st_mtime = time (NULL);
600 /* Maybe a regular file or pipe ? */
601 return fstat (fdes, buf);
603 #endif /* __MINGW32__ */
605 SCM_DEFINE (scm_stat, "stat", 1, 0, 0,
607 "Return an object containing various information about the file\n"
608 "determined by @var{obj}. @var{obj} can be a string containing\n"
609 "a file name or a port or integer file descriptor which is open\n"
610 "on a file (in which case @code{fstat} is used as the underlying\n"
613 "The object returned by @code{stat} can be passed as a single\n"
614 "parameter to the following procedures, all of which return\n"
619 "The device containing the file.\n"
621 "The file serial number, which distinguishes this file from all\n"
622 "other files on the same device.\n"
624 "The mode of the file. This includes file type information and\n"
625 "the file permission bits. See @code{stat:type} and\n"
626 "@code{stat:perms} below.\n"
628 "The number of hard links to the file.\n"
630 "The user ID of the file's owner.\n"
632 "The group ID of the file.\n"
634 "Device ID; this entry is defined only for character or block\n"
637 "The size of a regular file in bytes.\n"
639 "The last access time for the file.\n"
641 "The last modification time for the file.\n"
643 "The last modification time for the attributes of the file.\n"
644 "@item stat:blksize\n"
645 "The optimal block size for reading or writing the file, in\n"
647 "@item stat:blocks\n"
648 "The amount of disk space that the file occupies measured in\n"
649 "units of 512 byte blocks.\n"
652 "In addition, the following procedures return the information\n"
653 "from stat:mode in a more convenient form:\n"
657 "A symbol representing the type of file. Possible values are\n"
658 "regular, directory, symlink, block-special, char-special, fifo,\n"
659 "socket and unknown\n"
661 "An integer representing the access permission bits.\n"
663 #define FUNC_NAME s_scm_stat
667 struct stat_or_stat64 stat_temp;
669 if (scm_is_integer (object))
672 SCM_SYSCALL (rv = fstat_Win32 (scm_to_int (object), &stat_temp));
674 SCM_SYSCALL (rv = fstat_or_fstat64 (scm_to_int (object), &stat_temp));
677 else if (scm_is_string (object))
679 char *file = scm_to_locale_string (object);
682 p = file + strlen (file) - 1;
683 while (p > file && (*p == '/' || *p == '\\'))
686 SCM_SYSCALL (rv = stat_or_stat64 (file, &stat_temp));
691 object = SCM_COERCE_OUTPORT (object);
692 SCM_VALIDATE_OPFPORT (1, object);
693 fdes = SCM_FPORT_FDES (object);
695 SCM_SYSCALL (rv = fstat_Win32 (fdes, &stat_temp));
697 SCM_SYSCALL (rv = fstat_or_fstat64 (fdes, &stat_temp));
705 SCM_SYSERROR_MSG ("~A: ~S",
706 scm_list_2 (scm_strerror (scm_from_int (en)),
710 return scm_stat2scm (&stat_temp);
715 /* {Modifying Directories}
719 SCM_DEFINE (scm_link, "link", 2, 0, 0,
720 (SCM oldpath, SCM newpath),
721 "Creates a new name @var{newpath} in the file system for the\n"
722 "file named by @var{oldpath}. If @var{oldpath} is a symbolic\n"
723 "link, the link may or may not be followed depending on the\n"
725 #define FUNC_NAME s_scm_link
729 STRING2_SYSCALL (oldpath, c_oldpath,
731 val = link (c_oldpath, c_newpath));
734 return SCM_UNSPECIFIED;
737 #endif /* HAVE_LINK */
740 #define my_rename rename
743 my_rename (const char *oldname, const char *newname)
747 SCM_SYSCALL (rv = link (oldname, newname));
750 SCM_SYSCALL (rv = unlink (oldname));
752 /* unlink failed. remove new name */
753 SCM_SYSCALL (unlink (newname));
759 SCM_DEFINE (scm_rename, "rename-file", 2, 0, 0,
760 (SCM oldname, SCM newname),
761 "Renames the file specified by @var{oldname} to @var{newname}.\n"
762 "The return value is unspecified.")
763 #define FUNC_NAME s_scm_rename
767 STRING2_SYSCALL (oldname, c_oldname,
769 rv = my_rename (c_oldname, c_newname));
772 return SCM_UNSPECIFIED;
777 SCM_DEFINE (scm_delete_file, "delete-file", 1, 0, 0,
779 "Deletes (or \"unlinks\") the file specified by @var{path}.")
780 #define FUNC_NAME s_scm_delete_file
783 STRING_SYSCALL (str, c_str, ans = unlink (c_str));
786 return SCM_UNSPECIFIED;
791 SCM_DEFINE (scm_mkdir, "mkdir", 1, 1, 0,
792 (SCM path, SCM mode),
793 "Create a new directory named by @var{path}. If @var{mode} is omitted\n"
794 "then the permissions of the directory file are set using the current\n"
795 "umask. Otherwise they are set to the decimal value specified with\n"
796 "@var{mode}. The return value is unspecified.")
797 #define FUNC_NAME s_scm_mkdir
802 if (SCM_UNBNDP (mode))
806 STRING_SYSCALL (path, c_path, rv = mkdir (c_path, 0777 ^ mask));
810 STRING_SYSCALL (path, c_path, rv = mkdir (c_path, scm_to_uint (mode)));
814 return SCM_UNSPECIFIED;
817 #endif /* HAVE_MKDIR */
820 SCM_DEFINE (scm_rmdir, "rmdir", 1, 0, 0,
822 "Remove the existing directory named by @var{path}. The directory must\n"
823 "be empty for this to succeed. The return value is unspecified.")
824 #define FUNC_NAME s_scm_rmdir
828 STRING_SYSCALL (path, c_path, val = rmdir (c_path));
831 return SCM_UNSPECIFIED;
838 /* {Examining Directories}
841 scm_t_bits scm_tc16_dir;
844 SCM_DEFINE (scm_directory_stream_p, "directory-stream?", 1, 0, 0,
846 "Return a boolean indicating whether @var{object} is a directory\n"
847 "stream as returned by @code{opendir}.")
848 #define FUNC_NAME s_scm_directory_stream_p
850 return scm_from_bool (SCM_DIRP (obj));
855 SCM_DEFINE (scm_opendir, "opendir", 1, 0, 0,
857 "Open the directory specified by @var{path} and return a directory\n"
859 #define FUNC_NAME s_scm_opendir
862 STRING_SYSCALL (dirname, c_dirname, ds = opendir (c_dirname));
865 SCM_RETURN_NEWSMOB (scm_tc16_dir | SCM_DIR_FLAG_OPEN, ds);
870 /* FIXME: The glibc manual has a portability note that readdir_r may not
871 null-terminate its return string. The circumstances outlined for this
872 are not clear, nor is it clear what should be done about it. Lets use
873 NAMLEN and worry about what else should be done if/when someone can
876 SCM_DEFINE (scm_readdir, "readdir", 1, 0, 0,
878 "Return (as a string) the next directory entry from the directory stream\n"
879 "@var{stream}. If there is no remaining entry to be read then the\n"
880 "end of file object is returned.")
881 #define FUNC_NAME s_scm_readdir
883 struct dirent_or_dirent64 *rdent;
885 SCM_VALIDATE_DIR (1, port);
886 if (!SCM_DIR_OPEN_P (port))
887 SCM_MISC_ERROR ("Directory ~S is not open.", scm_list_1 (port));
890 /* As noted in the glibc manual, on various systems (such as Solaris) the
891 d_name[] field is only 1 char and you're expected to size the dirent
892 buffer for readdir_r based on NAME_MAX. The SCM_MAX expressions below
893 effectively give either sizeof(d_name) or NAME_MAX+1, whichever is
896 On solaris 10 there's no NAME_MAX constant, it's necessary to use
897 pathconf(). We prefer NAME_MAX though, since it should be a constant
898 and will therefore save a system call. We also prefer it since dirfd()
899 is not available everywhere.
901 An alternative to dirfd() would be to open() the directory and then use
902 fdopendir(), if the latter is available. That'd let us hold the fd
903 somewhere in the smob, or just the dirent size calculated once. */
905 struct dirent_or_dirent64 de; /* just for sizeof */
906 DIR *ds = (DIR *) SCM_CELL_WORD_1 (port);
909 char buf [SCM_MAX (sizeof (de),
910 sizeof (de) - sizeof (de.d_name) + NAME_MAX + 1)];
913 long name_max = fpathconf (dirfd (ds), _PC_NAME_MAX);
916 buf = alloca (SCM_MAX (sizeof (de),
917 sizeof (de) - sizeof (de.d_name) + name_max + 1));
921 SCM_SYSCALL (readdir_r_or_readdir64_r (ds, (struct dirent_or_dirent64 *) buf, &rdent));
927 namlen = NAMLEN (rdent);
929 return (rdent ? scm_from_locale_stringn (rdent->d_name, NAMLEN (rdent))
935 scm_dynwind_begin (0);
936 scm_i_dynwind_pthread_mutex_lock (&scm_i_misc_mutex);
939 SCM_SYSCALL (rdent = readdir_or_readdir64 ((DIR *) SCM_CELL_WORD_1 (port)));
943 ret = (rdent ? scm_from_locale_stringn (rdent->d_name, NAMLEN (rdent))
954 SCM_DEFINE (scm_rewinddir, "rewinddir", 1, 0, 0,
956 "Reset the directory port @var{stream} so that the next call to\n"
957 "@code{readdir} will return the first directory entry.")
958 #define FUNC_NAME s_scm_rewinddir
960 SCM_VALIDATE_DIR (1, port);
961 if (!SCM_DIR_OPEN_P (port))
962 SCM_MISC_ERROR ("Directory ~S is not open.", scm_list_1 (port));
964 rewinddir ((DIR *) SCM_CELL_WORD_1 (port));
966 return SCM_UNSPECIFIED;
971 SCM_DEFINE (scm_closedir, "closedir", 1, 0, 0,
973 "Close the directory stream @var{stream}.\n"
974 "The return value is unspecified.")
975 #define FUNC_NAME s_scm_closedir
977 SCM_VALIDATE_DIR (1, port);
979 if (SCM_DIR_OPEN_P (port))
983 SCM_SYSCALL (sts = closedir ((DIR *) SCM_CELL_WORD_1 (port)));
987 SCM_SET_CELL_WORD_0 (port, scm_tc16_dir);
990 return SCM_UNSPECIFIED;
996 scm_dir_print (SCM exp, SCM port, scm_print_state *pstate SCM_UNUSED)
998 scm_puts ("#<", port);
999 if (!SCM_DIR_OPEN_P (exp))
1000 scm_puts ("closed: ", port);
1001 scm_puts ("directory stream ", port);
1002 scm_uintprint (SCM_CELL_WORD_1 (exp), 16, port);
1003 scm_putc ('>', port);
1009 scm_dir_free (SCM p)
1011 if (SCM_DIR_OPEN_P (p))
1012 closedir ((DIR *) SCM_CELL_WORD_1 (p));
1017 /* {Navigating Directories}
1021 SCM_DEFINE (scm_chdir, "chdir", 1, 0, 0,
1023 "Change the current working directory to @var{path}.\n"
1024 "The return value is unspecified.")
1025 #define FUNC_NAME s_scm_chdir
1029 STRING_SYSCALL (str, c_str, ans = chdir (c_str));
1032 return SCM_UNSPECIFIED;
1037 SCM_DEFINE (scm_getcwd, "getcwd", 0, 0, 0,
1039 "Return the name of the current working directory.")
1040 #define FUNC_NAME s_scm_getcwd
1047 wd = scm_malloc (size);
1048 while ((rv = getcwd (wd, size)) == 0 && errno == ERANGE)
1052 wd = scm_malloc (size);
1056 int save_errno = errno;
1061 result = scm_from_locale_stringn (wd, strlen (wd));
1066 #endif /* HAVE_GETCWD */
1072 /* check that element is a port or file descriptor. if it's a port
1073 and its buffer is ready for use, add it to the ports_ready list.
1074 otherwise add its file descriptor to *set. the type of list can be
1075 determined from pos: SCM_ARG1 for reads, SCM_ARG2 for writes,
1076 SCM_ARG3 for excepts. */
1078 set_element (SELECT_TYPE *set, SCM *ports_ready, SCM element, int pos)
1082 if (scm_is_integer (element))
1084 fd = scm_to_int (element);
1090 element = SCM_COERCE_OUTPORT (element);
1091 SCM_ASSERT (SCM_OPFPORTP (element), element, pos, "select");
1092 if (pos == SCM_ARG1)
1094 /* check whether port has buffered input. */
1095 scm_t_port *pt = SCM_PTAB_ENTRY (element);
1097 if (pt->read_pos < pt->read_end)
1100 else if (pos == SCM_ARG2)
1102 /* check whether port's output buffer has room. */
1103 scm_t_port *pt = SCM_PTAB_ENTRY (element);
1105 /* > 1 since writing the last byte in the buffer causes flush. */
1106 if (pt->write_end - pt->write_pos > 1)
1109 fd = use_buf ? -1 : SCM_FPORT_FDES (element);
1112 *ports_ready = scm_cons (element, *ports_ready);
1118 /* check list_or_vec, a list or vector of ports or file descriptors,
1119 adding each member to either the ports_ready list (if it's a port
1120 with a usable buffer) or to *set. the kind of list_or_vec can be
1121 determined from pos: SCM_ARG1 for reads, SCM_ARG2 for writes,
1122 SCM_ARG3 for excepts. */
1124 fill_select_type (SELECT_TYPE *set, SCM *ports_ready, SCM list_or_vec, int pos)
1128 if (scm_is_simple_vector (list_or_vec))
1130 int i = SCM_SIMPLE_VECTOR_LENGTH (list_or_vec);
1134 int fd = set_element (set, ports_ready,
1135 SCM_SIMPLE_VECTOR_REF (list_or_vec, i), pos);
1143 while (!SCM_NULL_OR_NIL_P (list_or_vec))
1145 int fd = set_element (set, ports_ready, SCM_CAR (list_or_vec), pos);
1149 list_or_vec = SCM_CDR (list_or_vec);
1156 /* if element (a file descriptor or port) appears in *set, cons it to
1157 list. return list. */
1159 get_element (SELECT_TYPE *set, SCM element, SCM list)
1163 if (scm_is_integer (element))
1165 fd = scm_to_int (element);
1169 fd = SCM_FPORT_FDES (SCM_COERCE_OUTPORT (element));
1171 if (FD_ISSET (fd, set))
1172 list = scm_cons (element, list);
1176 /* construct component of scm_select return value.
1177 set: pointer to set of file descriptors found by select to be ready
1178 ports_ready: ports ready due to buffering
1179 list_or_vec: original list/vector handed to scm_select.
1180 the return value is a list/vector of ready ports/file descriptors.
1181 works by finding the objects in list which correspond to members of
1182 *set and appending them to ports_ready. result is converted to a
1183 vector if list_or_vec is a vector. */
1185 retrieve_select_type (SELECT_TYPE *set, SCM ports_ready, SCM list_or_vec)
1187 SCM answer_list = ports_ready;
1189 if (scm_is_simple_vector (list_or_vec))
1191 int i = SCM_SIMPLE_VECTOR_LENGTH (list_or_vec);
1195 answer_list = get_element (set,
1196 SCM_SIMPLE_VECTOR_REF (list_or_vec, i),
1199 return scm_vector (answer_list);
1203 /* list_or_vec must be a list. */
1204 while (!SCM_NULL_OR_NIL_P (list_or_vec))
1206 answer_list = get_element (set, SCM_CAR (list_or_vec), answer_list);
1207 list_or_vec = SCM_CDR (list_or_vec);
1213 /* Static helper functions above refer to s_scm_select directly as s_select */
1214 SCM_DEFINE (scm_select, "select", 3, 2, 0,
1215 (SCM reads, SCM writes, SCM excepts, SCM secs, SCM usecs),
1216 "This procedure has a variety of uses: waiting for the ability\n"
1217 "to provide input, accept output, or the existence of\n"
1218 "exceptional conditions on a collection of ports or file\n"
1219 "descriptors, or waiting for a timeout to occur.\n"
1220 "It also returns if interrupted by a signal.\n\n"
1221 "@var{reads}, @var{writes} and @var{excepts} can be lists or\n"
1222 "vectors, with each member a port or a file descriptor.\n"
1223 "The value returned is a list of three corresponding\n"
1224 "lists or vectors containing only the members which meet the\n"
1225 "specified requirement. The ability of port buffers to\n"
1226 "provide input or accept output is taken into account.\n"
1227 "Ordering of the input lists or vectors is not preserved.\n\n"
1228 "The optional arguments @var{secs} and @var{usecs} specify the\n"
1229 "timeout. Either @var{secs} can be specified alone, as\n"
1230 "either an integer or a real number, or both @var{secs} and\n"
1231 "@var{usecs} can be specified as integers, in which case\n"
1232 "@var{usecs} is an additional timeout expressed in\n"
1233 "microseconds. If @var{secs} is omitted or is @code{#f} then\n"
1234 "select will wait for as long as it takes for one of the other\n"
1235 "conditions to be satisfied.\n\n"
1236 "The scsh version of @code{select} differs as follows:\n"
1237 "Only vectors are accepted for the first three arguments.\n"
1238 "The @var{usecs} argument is not supported.\n"
1239 "Multiple values are returned instead of a list.\n"
1240 "Duplicates in the input vectors appear only once in output.\n"
1241 "An additional @code{select!} interface is provided.")
1242 #define FUNC_NAME s_scm_select
1244 struct timeval timeout;
1245 struct timeval * time_ptr;
1246 SELECT_TYPE read_set;
1247 SELECT_TYPE write_set;
1248 SELECT_TYPE except_set;
1252 /* these lists accumulate ports which are ready due to buffering.
1253 their file descriptors don't need to be added to the select sets. */
1254 SCM read_ports_ready = SCM_EOL;
1255 SCM write_ports_ready = SCM_EOL;
1258 if (scm_is_simple_vector (reads))
1260 read_count = SCM_SIMPLE_VECTOR_LENGTH (reads);
1264 read_count = scm_ilength (reads);
1265 SCM_ASSERT (read_count >= 0, reads, SCM_ARG1, FUNC_NAME);
1267 if (scm_is_simple_vector (writes))
1269 write_count = SCM_SIMPLE_VECTOR_LENGTH (writes);
1273 write_count = scm_ilength (writes);
1274 SCM_ASSERT (write_count >= 0, writes, SCM_ARG2, FUNC_NAME);
1276 if (scm_is_simple_vector (excepts))
1278 except_count = SCM_SIMPLE_VECTOR_LENGTH (excepts);
1282 except_count = scm_ilength (excepts);
1283 SCM_ASSERT (except_count >= 0, excepts, SCM_ARG3, FUNC_NAME);
1286 FD_ZERO (&read_set);
1287 FD_ZERO (&write_set);
1288 FD_ZERO (&except_set);
1290 max_fd = fill_select_type (&read_set, &read_ports_ready, reads, SCM_ARG1);
1293 int write_max = fill_select_type (&write_set, &write_ports_ready,
1295 int except_max = fill_select_type (&except_set, NULL,
1298 if (write_max > max_fd)
1300 if (except_max > max_fd)
1301 max_fd = except_max;
1304 /* if there's a port with a ready buffer, don't block, just
1305 check for ready file descriptors. */
1306 if (!scm_is_null (read_ports_ready) || !scm_is_null (write_ports_ready))
1309 timeout.tv_usec = 0;
1310 time_ptr = &timeout;
1312 else if (SCM_UNBNDP (secs) || scm_is_false (secs))
1316 if (scm_is_unsigned_integer (secs, 0, ULONG_MAX))
1318 timeout.tv_sec = scm_to_ulong (secs);
1319 if (SCM_UNBNDP (usecs))
1320 timeout.tv_usec = 0;
1322 timeout.tv_usec = scm_to_long (usecs);
1326 double fl = scm_to_double (secs);
1328 if (!SCM_UNBNDP (usecs))
1329 SCM_WRONG_TYPE_ARG (4, secs);
1331 SCM_OUT_OF_RANGE (4, secs);
1332 timeout.tv_sec = (long) fl;
1333 timeout.tv_usec = (long) ((fl - timeout.tv_sec) * 1000000);
1335 time_ptr = &timeout;
1339 int rv = scm_std_select (max_fd + 1,
1340 &read_set, &write_set, &except_set,
1345 return scm_list_3 (retrieve_select_type (&read_set, read_ports_ready, reads),
1346 retrieve_select_type (&write_set, write_ports_ready, writes),
1347 retrieve_select_type (&except_set, SCM_EOL, excepts));
1350 #endif /* HAVE_SELECT */
1355 SCM_DEFINE (scm_fcntl, "fcntl", 2, 1, 0,
1356 (SCM object, SCM cmd, SCM value),
1357 "Apply @var{command} to the specified file descriptor or the underlying\n"
1358 "file descriptor of the specified port. @var{value} is an optional\n"
1359 "integer argument.\n\n"
1360 "Values for @var{command} are:\n\n"
1363 "Duplicate a file descriptor\n"
1365 "Get flags associated with the file descriptor.\n"
1367 "Set flags associated with the file descriptor to @var{value}.\n"
1369 "Get flags associated with the open file.\n"
1371 "Set flags associated with the open file to @var{value}\n"
1373 "Get the process ID of a socket's owner, for @code{SIGIO} signals.\n"
1375 "Set the process that owns a socket to @var{value}, for @code{SIGIO} signals.\n"
1376 "@item FD_CLOEXEC\n"
1377 "The value used to indicate the \"close on exec\" flag with @code{F_GETFL} or\n"
1380 #define FUNC_NAME s_scm_fcntl
1386 object = SCM_COERCE_OUTPORT (object);
1388 if (SCM_OPFPORTP (object))
1389 fdes = SCM_FPORT_FDES (object);
1391 fdes = scm_to_int (object);
1393 if (SCM_UNBNDP (value))
1396 ivalue = scm_to_int (value);
1398 SCM_SYSCALL (rv = fcntl (fdes, scm_to_int (cmd), ivalue));
1401 return scm_from_int (rv);
1404 #endif /* HAVE_FCNTL */
1406 SCM_DEFINE (scm_fsync, "fsync", 1, 0, 0,
1408 "Copies any unwritten data for the specified output file descriptor to disk.\n"
1409 "If @var{port/fd} is a port, its buffer is flushed before the underlying\n"
1410 "file descriptor is fsync'd.\n"
1411 "The return value is unspecified.")
1412 #define FUNC_NAME s_scm_fsync
1416 object = SCM_COERCE_OUTPORT (object);
1418 if (SCM_OPFPORTP (object))
1421 fdes = SCM_FPORT_FDES (object);
1424 fdes = scm_to_int (object);
1426 if (fsync (fdes) == -1)
1428 return SCM_UNSPECIFIED;
1433 SCM_DEFINE (scm_symlink, "symlink", 2, 0, 0,
1434 (SCM oldpath, SCM newpath),
1435 "Create a symbolic link named @var{path-to} with the value (i.e., pointing to)\n"
1436 "@var{path-from}. The return value is unspecified.")
1437 #define FUNC_NAME s_scm_symlink
1441 STRING2_SYSCALL (oldpath, c_oldpath,
1443 val = symlink (c_oldpath, c_newpath));
1446 return SCM_UNSPECIFIED;
1449 #endif /* HAVE_SYMLINK */
1451 #ifdef HAVE_READLINK
1452 SCM_DEFINE (scm_readlink, "readlink", 1, 0, 0,
1454 "Return the value of the symbolic link named by @var{path} (a\n"
1455 "string), i.e., the file that the link points to.")
1456 #define FUNC_NAME s_scm_readlink
1464 scm_dynwind_begin (0);
1466 c_path = scm_to_locale_string (path);
1467 scm_dynwind_free (c_path);
1469 buf = scm_malloc (size);
1471 while ((rv = readlink (c_path, buf, size)) == size)
1475 buf = scm_malloc (size);
1479 int save_errno = errno;
1484 result = scm_take_locale_stringn (buf, rv);
1490 #endif /* HAVE_READLINK */
1493 SCM_DEFINE (scm_lstat, "lstat", 1, 0, 0,
1495 "Similar to @code{stat}, but does not follow symbolic links, i.e.,\n"
1496 "it will return information about a symbolic link itself, not the\n"
1497 "file it points to. @var{path} must be a string.")
1498 #define FUNC_NAME s_scm_lstat
1501 struct stat_or_stat64 stat_temp;
1503 STRING_SYSCALL (str, c_str, rv = lstat_or_lstat64 (c_str, &stat_temp));
1508 SCM_SYSERROR_MSG ("~A: ~S",
1509 scm_list_2 (scm_strerror (scm_from_int (en)), str),
1512 return scm_stat2scm (&stat_temp);
1515 #endif /* HAVE_LSTAT */
1517 SCM_DEFINE (scm_copy_file, "copy-file", 2, 0, 0,
1518 (SCM oldfile, SCM newfile),
1519 "Copy the file specified by @var{path-from} to @var{path-to}.\n"
1520 "The return value is unspecified.")
1521 #define FUNC_NAME s_scm_copy_file
1523 char *c_oldfile, *c_newfile;
1527 struct stat_or_stat64 oldstat;
1529 scm_dynwind_begin (0);
1531 c_oldfile = scm_to_locale_string (oldfile);
1532 scm_dynwind_free (c_oldfile);
1533 c_newfile = scm_to_locale_string (newfile);
1534 scm_dynwind_free (c_newfile);
1536 oldfd = open_or_open64 (c_oldfile, O_RDONLY);
1541 SCM_SYSCALL (rv = fstat_Win32 (oldfd, &oldstat));
1543 SCM_SYSCALL (rv = fstat_or_fstat64 (oldfd, &oldstat));
1546 goto err_close_oldfd;
1548 /* use POSIX flags instead of 07777?. */
1549 newfd = open_or_open64 (c_newfile, O_WRONLY | O_CREAT | O_TRUNC,
1550 oldstat.st_mode & 07777);
1558 while ((n = read (oldfd, buf, sizeof buf)) > 0)
1559 if (write (newfd, buf, n) != n)
1566 if (close (newfd) == -1)
1570 return SCM_UNSPECIFIED;
1575 /* Filename manipulation */
1579 SCM_DEFINE (scm_dirname, "dirname", 1, 0, 0,
1581 "Return the directory name component of the file name\n"
1582 "@var{filename}. If @var{filename} does not contain a directory\n"
1583 "component, @code{.} is returned.")
1584 #define FUNC_NAME s_scm_dirname
1588 unsigned long int len;
1590 SCM_VALIDATE_STRING (1, filename);
1592 s = scm_i_string_chars (filename);
1593 len = scm_i_string_length (filename);
1597 while (i >= 0 && (s[i] == '/' || s[i] == '\\')) --i;
1598 while (i >= 0 && (s[i] != '/' && s[i] != '\\')) --i;
1599 while (i >= 0 && (s[i] == '/' || s[i] == '\\')) --i;
1601 while (i >= 0 && s[i] == '/') --i;
1602 while (i >= 0 && s[i] != '/') --i;
1603 while (i >= 0 && s[i] == '/') --i;
1604 #endif /* ndef __MINGW32__ */
1608 if (len > 0 && (s[0] == '/' || s[0] == '\\'))
1610 if (len > 0 && s[0] == '/')
1611 #endif /* ndef __MINGW32__ */
1612 return scm_c_substring (filename, 0, 1);
1614 return scm_dot_string;
1617 return scm_c_substring (filename, 0, i + 1);
1621 SCM_DEFINE (scm_basename, "basename", 1, 1, 0,
1622 (SCM filename, SCM suffix),
1623 "Return the base name of the file name @var{filename}. The\n"
1624 "base name is the file name without any directory components.\n"
1625 "If @var{suffix} is provided, and is equal to the end of\n"
1626 "@var{basename}, it is removed also.")
1627 #define FUNC_NAME s_scm_basename
1629 const char *f, *s = 0;
1632 SCM_VALIDATE_STRING (1, filename);
1633 f = scm_i_string_chars (filename);
1634 len = scm_i_string_length (filename);
1636 if (SCM_UNBNDP (suffix))
1640 SCM_VALIDATE_STRING (2, suffix);
1641 s = scm_i_string_chars (suffix);
1642 j = scm_i_string_length (suffix) - 1;
1646 while (i >= 0 && (f[i] == '/' || f[i] == '\\')) --i;
1648 while (i >= 0 && f[i] == '/') --i;
1649 #endif /* ndef __MINGW32__ */
1651 while (i >= 0 && j >= 0 && f[i] == s[j]) --i, --j;
1655 while (i >= 0 && f[i] != '/' && f[i] != '\\') --i;
1657 while (i >= 0 && f[i] != '/') --i;
1658 #endif /* ndef __MINGW32__ */
1662 if (len > 0 && (f[0] == '/' || f[0] == '\\'))
1664 if (len > 0 && f[0] == '/')
1665 #endif /* ndef __MINGW32__ */
1666 return scm_c_substring (filename, 0, 1);
1668 return scm_dot_string;
1671 return scm_c_substring (filename, i+1, end+1);
1682 scm_tc16_dir = scm_make_smob_type ("directory", 0);
1683 scm_set_smob_free (scm_tc16_dir, scm_dir_free);
1684 scm_set_smob_print (scm_tc16_dir, scm_dir_print);
1686 scm_dot_string = scm_permanent_object (scm_from_locale_string ("."));
1689 scm_c_define ("O_RDONLY", scm_from_int (O_RDONLY));
1692 scm_c_define ("O_WRONLY", scm_from_int (O_WRONLY));
1695 scm_c_define ("O_RDWR", scm_from_int (O_RDWR));
1698 scm_c_define ("O_CREAT", scm_from_int (O_CREAT));
1701 scm_c_define ("O_EXCL", scm_from_int (O_EXCL));
1704 scm_c_define ("O_NOCTTY", scm_from_int (O_NOCTTY));
1707 scm_c_define ("O_TRUNC", scm_from_int (O_TRUNC));
1710 scm_c_define ("O_APPEND", scm_from_int (O_APPEND));
1713 scm_c_define ("O_NONBLOCK", scm_from_int (O_NONBLOCK));
1716 scm_c_define ("O_NDELAY", scm_from_int (O_NDELAY));
1719 scm_c_define ("O_SYNC", scm_from_int (O_SYNC));
1722 scm_c_define ("O_LARGEFILE", scm_from_int (O_LARGEFILE));
1726 scm_c_define ("F_DUPFD", scm_from_int (F_DUPFD));
1729 scm_c_define ("F_GETFD", scm_from_int (F_GETFD));
1732 scm_c_define ("F_SETFD", scm_from_int (F_SETFD));
1735 scm_c_define ("F_GETFL", scm_from_int (F_GETFL));
1738 scm_c_define ("F_SETFL", scm_from_int (F_SETFL));
1741 scm_c_define ("F_GETOWN", scm_from_int (F_GETOWN));
1744 scm_c_define ("F_SETOWN", scm_from_int (F_SETOWN));
1747 scm_c_define ("FD_CLOEXEC", scm_from_int (FD_CLOEXEC));
1750 #include "libguile/filesys.x"