1 /* Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2004, 2006,
2 * 2009, 2010, 2011, 2012, 2013 Free Software Foundation, Inc.
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public License
6 * as published by the Free Software Foundation; either version 3 of
7 * the License, or (at your option) any later version.
9 * This library is distributed in the hope that it will be useful, but
10 * WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with this library; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
22 /* This file contains POSIX file system access procedures. Procedures
23 essential to the compiler and run-time (`stat', `canonicalize-path',
24 etc.) are compiled even with `--disable-posix'. */
27 /* See stime.c for comments on why _POSIX_C_SOURCE is not always defined. */
28 #define _LARGEFILE64_SOURCE /* ask for stat64 etc */
30 #define _POSIX_C_SOURCE 199506L /* for readdir_r */
43 #include "libguile/_scm.h"
44 #include "libguile/smob.h"
45 #include "libguile/feature.h"
46 #include "libguile/fports.h"
47 #include "libguile/strings.h"
48 #include "libguile/vectors.h"
49 #include "libguile/dynwind.h"
51 #include "libguile/validate.h"
52 #include "libguile/filesys.h"
63 #ifdef TIME_WITH_SYS_TIME
64 # include <sys/time.h>
68 # include <sys/time.h>
78 #ifdef LIBC_H_WITH_UNISTD_H
82 #include <sys/select.h>
88 #include <sys/types.h>
98 #define NAMLEN(dirent) strlen ((dirent)->d_name)
100 #ifdef HAVE_SYS_SENDFILE_H
101 # include <sys/sendfile.h>
104 /* Glibc's `sendfile' function. */
105 #define sendfile_or_sendfile64 \
106 CHOOSE_LARGEFILE (sendfile, sendfile64)
108 #include <full-read.h>
109 #include <full-write.h>
112 /* Some more definitions for the native Windows port. */
114 # define fsync(fd) _commit (fd)
115 #endif /* __MINGW32__ */
120 /* Two helper macros for an often used pattern */
122 #define STRING_SYSCALL(str,cstr,code) \
125 char *cstr = scm_to_locale_string (str); \
126 SCM_SYSCALL (code); \
127 eno = errno; free (cstr); errno = eno; \
130 #define STRING2_SYSCALL(str1,cstr1,str2,cstr2,code) \
133 char *cstr1, *cstr2; \
134 scm_dynwind_begin (0); \
135 cstr1 = scm_to_locale_string (str1); \
136 scm_dynwind_free (cstr1); \
137 cstr2 = scm_to_locale_string (str2); \
138 scm_dynwind_free (cstr2); \
139 SCM_SYSCALL (code); \
140 eno = errno; scm_dynwind_end (); errno = eno; \
144 #define MAX(A, B) ((A) > (B) ? (A) : (B))
145 #define MIN(A, B) ((A) < (B) ? (A) : (B))
155 SCM_DEFINE (scm_chown
, "chown", 3, 0, 0,
156 (SCM object
, SCM owner
, SCM group
),
157 "Change the ownership and group of the file referred to by @var{object} to\n"
158 "the integer values @var{owner} and @var{group}. @var{object} can be\n"
159 "a string containing a file name or, if the platform\n"
160 "supports fchown, a port or integer file descriptor\n"
161 "which is open on the file. The return value\n"
162 "is unspecified.\n\n"
163 "If @var{object} is a symbolic link, either the\n"
164 "ownership of the link or the ownership of the referenced file will be\n"
165 "changed depending on the operating system (lchown is\n"
166 "unsupported at present). If @var{owner} or @var{group} is specified\n"
167 "as @code{-1}, then that ID is not changed.")
168 #define FUNC_NAME s_scm_chown
172 object
= SCM_COERCE_OUTPORT (object
);
175 if (scm_is_integer (object
) || (SCM_OPFPORTP (object
)))
177 int fdes
= (SCM_OPFPORTP (object
)?
178 SCM_FPORT_FDES (object
) : scm_to_int (object
));
180 SCM_SYSCALL (rv
= fchown (fdes
, scm_to_int (owner
), scm_to_int (group
)));
185 STRING_SYSCALL (object
, c_object
,
186 rv
= chown (c_object
,
187 scm_to_int (owner
), scm_to_int (group
)));
191 return SCM_UNSPECIFIED
;
194 #endif /* HAVE_CHOWN */
198 SCM_DEFINE (scm_open_fdes
, "open-fdes", 2, 1, 0,
199 (SCM path
, SCM flags
, SCM mode
),
200 "Similar to @code{open} but return a file descriptor instead of\n"
202 #define FUNC_NAME s_scm_open_fdes
208 iflags
= SCM_NUM2INT (2, flags
);
209 imode
= SCM_NUM2INT_DEF (3, mode
, 0666);
210 STRING_SYSCALL (path
, c_path
, fd
= open_or_open64 (c_path
, iflags
, imode
));
213 return scm_from_int (fd
);
217 SCM_DEFINE (scm_open
, "open", 2, 1, 0,
218 (SCM path
, SCM flags
, SCM mode
),
219 "Open the file named by @var{path} for reading and/or writing.\n"
220 "@var{flags} is an integer specifying how the file should be opened.\n"
221 "@var{mode} is an integer specifying the permission bits of the file, if\n"
222 "it needs to be created, before the umask is applied. The default is 666\n"
223 "(Unix itself has no default).\n\n"
224 "@var{flags} can be constructed by combining variables using @code{logior}.\n"
225 "Basic flags are:\n\n"
227 "Open the file read-only.\n"
230 "Open the file write-only.\n"
233 "Open the file read/write.\n"
236 "Append to the file instead of truncating.\n"
239 "Create the file if it does not already exist.\n"
241 "See the Unix documentation of the @code{open} system call\n"
242 "for additional flags.")
243 #define FUNC_NAME s_scm_open
250 fd
= scm_to_int (scm_open_fdes (path
, flags
, mode
));
251 iflags
= SCM_NUM2INT (2, flags
);
253 if ((iflags
& O_RDWR
) == O_RDWR
)
255 /* Opened read-write. */
256 if (iflags
& O_APPEND
)
258 else if (iflags
& O_CREAT
)
265 /* Opened read-only or write-only. */
266 if (iflags
& O_APPEND
)
268 else if (iflags
& O_WRONLY
)
274 newpt
= scm_fdes_to_port (fd
, port_mode
, path
);
279 SCM_DEFINE (scm_close
, "close", 1, 0, 0,
281 "Similar to close-port (@pxref{Closing, close-port}),\n"
282 "but also works on file descriptors. A side\n"
283 "effect of closing a file descriptor is that any ports using that file\n"
284 "descriptor are moved to a different file descriptor and have\n"
285 "their revealed counts set to zero.")
286 #define FUNC_NAME s_scm_close
291 fd_or_port
= SCM_COERCE_OUTPORT (fd_or_port
);
293 if (SCM_PORTP (fd_or_port
))
294 return scm_close_port (fd_or_port
);
295 fd
= scm_to_int (fd_or_port
);
296 scm_evict_ports (fd
); /* see scsh manual. */
297 SCM_SYSCALL (rv
= close (fd
));
298 /* following scsh, closing an already closed file descriptor is
300 if (rv
< 0 && errno
!= EBADF
)
302 return scm_from_bool (rv
>= 0);
306 SCM_DEFINE (scm_close_fdes
, "close-fdes", 1, 0, 0,
308 "A simple wrapper for the @code{close} system call.\n"
309 "Close file descriptor @var{fd}, which must be an integer.\n"
310 "Unlike close (@pxref{Ports and File Descriptors, close}),\n"
311 "the file descriptor will be closed even if a port is using it.\n"
312 "The return value is unspecified.")
313 #define FUNC_NAME s_scm_close_fdes
318 c_fd
= scm_to_int (fd
);
319 SCM_SYSCALL (rv
= close (c_fd
));
322 return SCM_UNSPECIFIED
;
326 #endif /* HAVE_POSIX */
332 SCM_SYMBOL (scm_sym_regular
, "regular");
333 SCM_SYMBOL (scm_sym_directory
, "directory");
335 SCM_SYMBOL (scm_sym_symlink
, "symlink");
337 SCM_SYMBOL (scm_sym_block_special
, "block-special");
338 SCM_SYMBOL (scm_sym_char_special
, "char-special");
339 SCM_SYMBOL (scm_sym_fifo
, "fifo");
340 SCM_SYMBOL (scm_sym_sock
, "socket");
341 SCM_SYMBOL (scm_sym_unknown
, "unknown");
344 scm_stat2scm (struct stat_or_stat64
*stat_temp
)
346 SCM ans
= scm_c_make_vector (18, SCM_UNSPECIFIED
);
348 SCM_SIMPLE_VECTOR_SET(ans
, 0, scm_from_ulong (stat_temp
->st_dev
));
349 SCM_SIMPLE_VECTOR_SET(ans
, 1, scm_from_ino_t_or_ino64_t (stat_temp
->st_ino
));
350 SCM_SIMPLE_VECTOR_SET(ans
, 2, scm_from_ulong (stat_temp
->st_mode
));
351 SCM_SIMPLE_VECTOR_SET(ans
, 3, scm_from_ulong (stat_temp
->st_nlink
));
352 SCM_SIMPLE_VECTOR_SET(ans
, 4, scm_from_ulong (stat_temp
->st_uid
));
353 SCM_SIMPLE_VECTOR_SET(ans
, 5, scm_from_ulong (stat_temp
->st_gid
));
354 #ifdef HAVE_STRUCT_STAT_ST_RDEV
355 SCM_SIMPLE_VECTOR_SET(ans
, 6, scm_from_ulong (stat_temp
->st_rdev
));
357 SCM_SIMPLE_VECTOR_SET(ans
, 6, SCM_BOOL_F
);
359 SCM_SIMPLE_VECTOR_SET(ans
, 7, scm_from_off_t_or_off64_t (stat_temp
->st_size
));
360 SCM_SIMPLE_VECTOR_SET(ans
, 8, scm_from_ulong (stat_temp
->st_atime
));
361 SCM_SIMPLE_VECTOR_SET(ans
, 9, scm_from_ulong (stat_temp
->st_mtime
));
362 SCM_SIMPLE_VECTOR_SET(ans
, 10, scm_from_ulong (stat_temp
->st_ctime
));
363 #ifdef HAVE_STRUCT_STAT_ST_BLKSIZE
364 SCM_SIMPLE_VECTOR_SET(ans
, 11, scm_from_ulong (stat_temp
->st_blksize
));
366 SCM_SIMPLE_VECTOR_SET(ans
, 11, scm_from_ulong (4096L));
368 #ifdef HAVE_STRUCT_STAT_ST_BLOCKS
369 SCM_SIMPLE_VECTOR_SET(ans
, 12, scm_from_blkcnt_t_or_blkcnt64_t (stat_temp
->st_blocks
));
371 SCM_SIMPLE_VECTOR_SET(ans
, 12, SCM_BOOL_F
);
374 int mode
= stat_temp
->st_mode
;
377 SCM_SIMPLE_VECTOR_SET(ans
, 13, scm_sym_regular
);
378 else if (S_ISDIR (mode
))
379 SCM_SIMPLE_VECTOR_SET(ans
, 13, scm_sym_directory
);
381 /* systems without symlinks probably don't have S_ISLNK */
382 else if (S_ISLNK (mode
))
383 SCM_SIMPLE_VECTOR_SET(ans
, 13, scm_sym_symlink
);
385 else if (S_ISBLK (mode
))
386 SCM_SIMPLE_VECTOR_SET(ans
, 13, scm_sym_block_special
);
387 else if (S_ISCHR (mode
))
388 SCM_SIMPLE_VECTOR_SET(ans
, 13, scm_sym_char_special
);
389 else if (S_ISFIFO (mode
))
390 SCM_SIMPLE_VECTOR_SET(ans
, 13, scm_sym_fifo
);
392 else if (S_ISSOCK (mode
))
393 SCM_SIMPLE_VECTOR_SET(ans
, 13, scm_sym_sock
);
396 SCM_SIMPLE_VECTOR_SET(ans
, 13, scm_sym_unknown
);
398 SCM_SIMPLE_VECTOR_SET(ans
, 14, scm_from_int ((~S_IFMT
) & mode
));
400 /* the layout of the bits in ve[14] is intended to be portable.
401 If there are systems that don't follow the usual convention,
402 the following could be used:
405 if (S_ISUID & mode) tmp += 1;
407 if (S_IRGRP & mode) tmp += 1;
409 if (S_ISVTX & mode) tmp += 1;
411 if (S_IRUSR & mode) tmp += 1;
413 if (S_IWUSR & mode) tmp += 1;
415 if (S_IXUSR & mode) tmp += 1;
417 if (S_IWGRP & mode) tmp += 1;
419 if (S_IXGRP & mode) tmp += 1;
421 if (S_IROTH & mode) tmp += 1;
423 if (S_IWOTH & mode) tmp += 1;
425 if (S_IXOTH & mode) tmp += 1;
427 SCM_SIMPLE_VECTOR_SET(ans, 14, scm_from_int (tmp));
431 #ifdef HAVE_STRUCT_STAT_ST_ATIM
432 SCM_SIMPLE_VECTOR_SET(ans
, 15, scm_from_long (stat_temp
->st_atim
.tv_nsec
));
434 SCM_SIMPLE_VECTOR_SET(ans
, 15, SCM_I_MAKINUM (0));
436 #ifdef HAVE_STRUCT_STAT_ST_MTIM
437 SCM_SIMPLE_VECTOR_SET(ans
, 16, scm_from_long (stat_temp
->st_mtim
.tv_nsec
));
439 SCM_SIMPLE_VECTOR_SET(ans
, 16, SCM_I_MAKINUM (0));
441 #ifdef HAVE_STRUCT_STAT_ST_CTIM
442 SCM_SIMPLE_VECTOR_SET(ans
, 17, scm_from_ulong (stat_temp
->st_ctim
.tv_sec
));
444 SCM_SIMPLE_VECTOR_SET(ans
, 17, SCM_I_MAKINUM (0));
451 is_file_name_separator (SCM c
)
453 if (scm_is_eq (c
, SCM_MAKE_CHAR ('/')))
456 if (scm_is_eq (c
, SCM_MAKE_CHAR ('\\')))
462 SCM_DEFINE (scm_stat
, "stat", 1, 1, 0,
463 (SCM object
, SCM exception_on_error
),
464 "Return an object containing various information about the file\n"
465 "determined by @var{object}. @var{object} can be a string containing\n"
466 "a file name or a port or integer file descriptor which is open\n"
467 "on a file (in which case @code{fstat} is used as the underlying\n"
470 "If the optional @var{exception_on_error} argument is true, which\n"
471 "is the default, an exception will be raised if the underlying\n"
472 "system call returns an error, for example if the file is not\n"
473 "found or is not readable. Otherwise, an error will cause\n"
474 "@code{stat} to return @code{#f}."
476 "The object returned by a successful call to @code{stat} can be\n"
477 "passed as a single parameter to the following procedures, all of\n"
478 "which return integers:\n"
482 "The device containing the file.\n"
484 "The file serial number, which distinguishes this file from all\n"
485 "other files on the same device.\n"
487 "The mode of the file. This includes file type information and\n"
488 "the file permission bits. See @code{stat:type} and\n"
489 "@code{stat:perms} below.\n"
491 "The number of hard links to the file.\n"
493 "The user ID of the file's owner.\n"
495 "The group ID of the file.\n"
497 "Device ID; this entry is defined only for character or block\n"
500 "The size of a regular file in bytes.\n"
502 "The last access time for the file.\n"
504 "The last modification time for the file.\n"
506 "The last modification time for the attributes of the file.\n"
507 "@item stat:blksize\n"
508 "The optimal block size for reading or writing the file, in\n"
510 "@item stat:blocks\n"
511 "The amount of disk space that the file occupies measured in\n"
512 "units of 512 byte blocks.\n"
515 "In addition, the following procedures return the information\n"
516 "from stat:mode in a more convenient form:\n"
520 "A symbol representing the type of file. Possible values are\n"
521 "regular, directory, symlink, block-special, char-special, fifo,\n"
522 "socket and unknown\n"
524 "An integer representing the access permission bits.\n"
526 #define FUNC_NAME s_scm_stat
530 struct stat_or_stat64 stat_temp
;
532 if (scm_is_integer (object
))
534 SCM_SYSCALL (rv
= fstat_or_fstat64 (scm_to_int (object
), &stat_temp
));
536 else if (scm_is_string (object
))
538 char *file
= scm_to_locale_string (object
);
539 SCM_SYSCALL (rv
= stat_or_stat64 (file
, &stat_temp
));
544 object
= SCM_COERCE_OUTPORT (object
);
545 SCM_VALIDATE_OPFPORT (1, object
);
546 fdes
= SCM_FPORT_FDES (object
);
547 SCM_SYSCALL (rv
= fstat_or_fstat64 (fdes
, &stat_temp
));
552 if (SCM_UNBNDP (exception_on_error
) || scm_is_true (exception_on_error
))
555 SCM_SYSERROR_MSG ("~A: ~S",
556 scm_list_2 (scm_strerror (scm_from_int (en
)),
563 return scm_stat2scm (&stat_temp
);
568 SCM_DEFINE (scm_lstat
, "lstat", 1, 0, 0,
570 "Similar to @code{stat}, but does not follow symbolic links, i.e.,\n"
571 "it will return information about a symbolic link itself, not the\n"
572 "file it points to. @var{str} must be a string.")
573 #define FUNC_NAME s_scm_lstat
576 struct stat_or_stat64 stat_temp
;
578 STRING_SYSCALL (str
, c_str
, rv
= lstat_or_lstat64 (c_str
, &stat_temp
));
583 SCM_SYSERROR_MSG ("~A: ~S",
584 scm_list_2 (scm_strerror (scm_from_int (en
)), str
),
587 return scm_stat2scm (&stat_temp
);
590 #endif /* HAVE_LSTAT */
595 /* {Modifying Directories}
599 SCM_DEFINE (scm_link
, "link", 2, 0, 0,
600 (SCM oldpath
, SCM newpath
),
601 "Creates a new name @var{newpath} in the file system for the\n"
602 "file named by @var{oldpath}. If @var{oldpath} is a symbolic\n"
603 "link, the link may or may not be followed depending on the\n"
605 #define FUNC_NAME s_scm_link
609 STRING2_SYSCALL (oldpath
, c_oldpath
,
611 val
= link (c_oldpath
, c_newpath
));
614 return SCM_UNSPECIFIED
;
617 #endif /* HAVE_LINK */
620 /* {Navigating Directories}
624 SCM_DEFINE (scm_chdir
, "chdir", 1, 0, 0,
626 "Change the current working directory to @var{str}.\n"
627 "The return value is unspecified.")
628 #define FUNC_NAME s_scm_chdir
632 STRING_SYSCALL (str
, c_str
, ans
= chdir (c_str
));
635 return SCM_UNSPECIFIED
;
641 /* check that element is a port or file descriptor. if it's a port
642 and its buffer is ready for use, add it to the ports_ready list.
643 otherwise add its file descriptor to *set. the type of list can be
644 determined from pos: SCM_ARG1 for reads, SCM_ARG2 for writes,
645 SCM_ARG3 for excepts. */
647 set_element (fd_set
*set
, SCM
*ports_ready
, SCM element
, int pos
)
651 if (scm_is_integer (element
))
653 fd
= scm_to_int (element
);
659 element
= SCM_COERCE_OUTPORT (element
);
660 SCM_ASSERT (SCM_OPFPORTP (element
), element
, pos
, "select");
663 /* check whether port has buffered input. */
664 scm_t_port
*pt
= SCM_PTAB_ENTRY (element
);
666 if (pt
->read_pos
< pt
->read_end
)
669 else if (pos
== SCM_ARG2
)
671 /* check whether port's output buffer has room. */
672 scm_t_port
*pt
= SCM_PTAB_ENTRY (element
);
674 /* > 1 since writing the last byte in the buffer causes flush. */
675 if (pt
->write_end
- pt
->write_pos
> 1)
678 fd
= use_buf
? -1 : SCM_FPORT_FDES (element
);
681 *ports_ready
= scm_cons (element
, *ports_ready
);
687 /* check list_or_vec, a list or vector of ports or file descriptors,
688 adding each member to either the ports_ready list (if it's a port
689 with a usable buffer) or to *set. the kind of list_or_vec can be
690 determined from pos: SCM_ARG1 for reads, SCM_ARG2 for writes,
691 SCM_ARG3 for excepts. */
693 fill_select_type (fd_set
*set
, SCM
*ports_ready
, SCM list_or_vec
, int pos
)
697 if (scm_is_simple_vector (list_or_vec
))
699 int i
= SCM_SIMPLE_VECTOR_LENGTH (list_or_vec
);
703 int fd
= set_element (set
, ports_ready
,
704 SCM_SIMPLE_VECTOR_REF (list_or_vec
, i
), pos
);
712 while (!SCM_NULL_OR_NIL_P (list_or_vec
))
714 int fd
= set_element (set
, ports_ready
, SCM_CAR (list_or_vec
), pos
);
718 list_or_vec
= SCM_CDR (list_or_vec
);
725 /* if element (a file descriptor or port) appears in *set, cons it to
726 list. return list. */
728 get_element (fd_set
*set
, SCM element
, SCM list
)
732 if (scm_is_integer (element
))
734 fd
= scm_to_int (element
);
738 fd
= SCM_FPORT_FDES (SCM_COERCE_OUTPORT (element
));
740 if (FD_ISSET (fd
, set
))
741 list
= scm_cons (element
, list
);
745 /* construct component of scm_select return value.
746 set: pointer to set of file descriptors found by select to be ready
747 ports_ready: ports ready due to buffering
748 list_or_vec: original list/vector handed to scm_select.
749 the return value is a list/vector of ready ports/file descriptors.
750 works by finding the objects in list which correspond to members of
751 *set and appending them to ports_ready. result is converted to a
752 vector if list_or_vec is a vector. */
754 retrieve_select_type (fd_set
*set
, SCM ports_ready
, SCM list_or_vec
)
756 SCM answer_list
= ports_ready
;
758 if (scm_is_simple_vector (list_or_vec
))
760 int i
= SCM_SIMPLE_VECTOR_LENGTH (list_or_vec
);
764 answer_list
= get_element (set
,
765 SCM_SIMPLE_VECTOR_REF (list_or_vec
, i
),
768 return scm_vector (answer_list
);
772 /* list_or_vec must be a list. */
773 while (!SCM_NULL_OR_NIL_P (list_or_vec
))
775 answer_list
= get_element (set
, SCM_CAR (list_or_vec
), answer_list
);
776 list_or_vec
= SCM_CDR (list_or_vec
);
782 /* Static helper functions above refer to s_scm_select directly as s_select */
783 SCM_DEFINE (scm_select
, "select", 3, 2, 0,
784 (SCM reads
, SCM writes
, SCM excepts
, SCM secs
, SCM usecs
),
785 "This procedure has a variety of uses: waiting for the ability\n"
786 "to provide input, accept output, or the existence of\n"
787 "exceptional conditions on a collection of ports or file\n"
788 "descriptors, or waiting for a timeout to occur.\n"
789 "It also returns if interrupted by a signal.\n\n"
790 "@var{reads}, @var{writes} and @var{excepts} can be lists or\n"
791 "vectors, with each member a port or a file descriptor.\n"
792 "The value returned is a list of three corresponding\n"
793 "lists or vectors containing only the members which meet the\n"
794 "specified requirement. The ability of port buffers to\n"
795 "provide input or accept output is taken into account.\n"
796 "Ordering of the input lists or vectors is not preserved.\n\n"
797 "The optional arguments @var{secs} and @var{usecs} specify the\n"
798 "timeout. Either @var{secs} can be specified alone, as\n"
799 "either an integer or a real number, or both @var{secs} and\n"
800 "@var{usecs} can be specified as integers, in which case\n"
801 "@var{usecs} is an additional timeout expressed in\n"
802 "microseconds. If @var{secs} is omitted or is @code{#f} then\n"
803 "select will wait for as long as it takes for one of the other\n"
804 "conditions to be satisfied.\n\n"
805 "The scsh version of @code{select} differs as follows:\n"
806 "Only vectors are accepted for the first three arguments.\n"
807 "The @var{usecs} argument is not supported.\n"
808 "Multiple values are returned instead of a list.\n"
809 "Duplicates in the input vectors appear only once in output.\n"
810 "An additional @code{select!} interface is provided.")
811 #define FUNC_NAME s_scm_select
813 struct timeval timeout
;
814 struct timeval
* time_ptr
;
821 /* these lists accumulate ports which are ready due to buffering.
822 their file descriptors don't need to be added to the select sets. */
823 SCM read_ports_ready
= SCM_EOL
;
824 SCM write_ports_ready
= SCM_EOL
;
827 if (scm_is_simple_vector (reads
))
829 read_count
= SCM_SIMPLE_VECTOR_LENGTH (reads
);
833 read_count
= scm_ilength (reads
);
834 SCM_ASSERT (read_count
>= 0, reads
, SCM_ARG1
, FUNC_NAME
);
836 if (scm_is_simple_vector (writes
))
838 write_count
= SCM_SIMPLE_VECTOR_LENGTH (writes
);
842 write_count
= scm_ilength (writes
);
843 SCM_ASSERT (write_count
>= 0, writes
, SCM_ARG2
, FUNC_NAME
);
845 if (scm_is_simple_vector (excepts
))
847 except_count
= SCM_SIMPLE_VECTOR_LENGTH (excepts
);
851 except_count
= scm_ilength (excepts
);
852 SCM_ASSERT (except_count
>= 0, excepts
, SCM_ARG3
, FUNC_NAME
);
856 FD_ZERO (&write_set
);
857 FD_ZERO (&except_set
);
859 max_fd
= fill_select_type (&read_set
, &read_ports_ready
, reads
, SCM_ARG1
);
862 int write_max
= fill_select_type (&write_set
, &write_ports_ready
,
864 int except_max
= fill_select_type (&except_set
, NULL
,
867 if (write_max
> max_fd
)
869 if (except_max
> max_fd
)
873 /* if there's a port with a ready buffer, don't block, just
874 check for ready file descriptors. */
875 if (!scm_is_null (read_ports_ready
) || !scm_is_null (write_ports_ready
))
881 else if (SCM_UNBNDP (secs
) || scm_is_false (secs
))
885 if (scm_is_unsigned_integer (secs
, 0, ULONG_MAX
))
887 timeout
.tv_sec
= scm_to_ulong (secs
);
888 if (SCM_UNBNDP (usecs
))
891 timeout
.tv_usec
= scm_to_long (usecs
);
895 double fl
= scm_to_double (secs
);
897 if (!SCM_UNBNDP (usecs
))
898 SCM_WRONG_TYPE_ARG (4, secs
);
900 SCM_OUT_OF_RANGE (4, secs
);
901 timeout
.tv_sec
= (long) fl
;
902 timeout
.tv_usec
= (long) ((fl
- timeout
.tv_sec
) * 1000000);
908 int rv
= select (max_fd
+ 1,
909 &read_set
, &write_set
, &except_set
,
914 return scm_list_3 (retrieve_select_type (&read_set
, read_ports_ready
, reads
),
915 retrieve_select_type (&write_set
, write_ports_ready
, writes
),
916 retrieve_select_type (&except_set
, SCM_EOL
, excepts
));
923 SCM_DEFINE (scm_fcntl
, "fcntl", 2, 1, 0,
924 (SCM object
, SCM cmd
, SCM value
),
925 "Apply @var{cmd} to the specified file descriptor or the underlying\n"
926 "file descriptor of the specified port. @var{value} is an optional\n"
927 "integer argument.\n\n"
928 "Values for @var{cmd} are:\n\n"
931 "Duplicate a file descriptor\n"
933 "Get flags associated with the file descriptor.\n"
935 "Set flags associated with the file descriptor to @var{value}.\n"
937 "Get flags associated with the open file.\n"
939 "Set flags associated with the open file to @var{value}\n"
941 "Get the process ID of a socket's owner, for @code{SIGIO} signals.\n"
943 "Set the process that owns a socket to @var{value}, for @code{SIGIO} signals.\n"
945 "The value used to indicate the \"close on exec\" flag with @code{F_GETFL} or\n"
948 #define FUNC_NAME s_scm_fcntl
954 object
= SCM_COERCE_OUTPORT (object
);
956 if (SCM_OPFPORTP (object
))
957 fdes
= SCM_FPORT_FDES (object
);
959 fdes
= scm_to_int (object
);
961 if (SCM_UNBNDP (value
))
964 ivalue
= scm_to_int (value
);
966 SCM_SYSCALL (rv
= fcntl (fdes
, scm_to_int (cmd
), ivalue
));
969 return scm_from_int (rv
);
972 #endif /* HAVE_FCNTL */
974 SCM_DEFINE (scm_fsync
, "fsync", 1, 0, 0,
976 "Copies any unwritten data for the specified output file\n"
977 "descriptor to disk. If @var{object} is a port, its buffer is\n"
978 "flushed before the underlying file descriptor is fsync'd.\n"
979 "The return value is unspecified.")
980 #define FUNC_NAME s_scm_fsync
984 object
= SCM_COERCE_OUTPORT (object
);
986 if (SCM_OPFPORTP (object
))
988 scm_flush_unlocked (object
);
989 fdes
= SCM_FPORT_FDES (object
);
992 fdes
= scm_to_int (object
);
994 if (fsync (fdes
) == -1)
996 return SCM_UNSPECIFIED
;
1001 SCM_DEFINE (scm_symlink
, "symlink", 2, 0, 0,
1002 (SCM oldpath
, SCM newpath
),
1003 "Create a symbolic link named @var{oldpath} with the value\n"
1004 "(i.e., pointing to) @var{newpath}. The return value is\n"
1006 #define FUNC_NAME s_scm_symlink
1010 STRING2_SYSCALL (oldpath
, c_oldpath
,
1012 val
= symlink (c_oldpath
, c_newpath
));
1015 return SCM_UNSPECIFIED
;
1018 #endif /* HAVE_SYMLINK */
1020 #ifdef HAVE_READLINK
1021 SCM_DEFINE (scm_readlink
, "readlink", 1, 0, 0,
1023 "Return the value of the symbolic link named by @var{path} (a\n"
1024 "string), i.e., the file that the link points to.")
1025 #define FUNC_NAME s_scm_readlink
1033 scm_dynwind_begin (0);
1035 c_path
= scm_to_locale_string (path
);
1036 scm_dynwind_free (c_path
);
1038 buf
= scm_malloc (size
);
1040 while ((rv
= readlink (c_path
, buf
, size
)) == size
)
1044 buf
= scm_malloc (size
);
1048 int save_errno
= errno
;
1053 result
= scm_take_locale_stringn (buf
, rv
);
1059 #endif /* HAVE_READLINK */
1061 SCM_DEFINE (scm_copy_file
, "copy-file", 2, 0, 0,
1062 (SCM oldfile
, SCM newfile
),
1063 "Copy the file specified by @var{oldfile} to @var{newfile}.\n"
1064 "The return value is unspecified.")
1065 #define FUNC_NAME s_scm_copy_file
1067 char *c_oldfile
, *c_newfile
;
1071 struct stat_or_stat64 oldstat
;
1073 scm_dynwind_begin (0);
1075 c_oldfile
= scm_to_locale_string (oldfile
);
1076 scm_dynwind_free (c_oldfile
);
1077 c_newfile
= scm_to_locale_string (newfile
);
1078 scm_dynwind_free (c_newfile
);
1080 oldfd
= open_or_open64 (c_oldfile
, O_RDONLY
| O_BINARY
);
1084 SCM_SYSCALL (rv
= fstat_or_fstat64 (oldfd
, &oldstat
));
1086 goto err_close_oldfd
;
1088 /* use POSIX flags instead of 07777?. */
1089 newfd
= open_or_open64 (c_newfile
, O_WRONLY
| O_CREAT
| O_TRUNC
,
1090 oldstat
.st_mode
& 07777);
1098 while ((n
= read (oldfd
, buf
, sizeof buf
)) > 0)
1099 if (write (newfd
, buf
, n
) != n
)
1106 if (close (newfd
) == -1)
1110 return SCM_UNSPECIFIED
;
1114 SCM_DEFINE (scm_sendfile
, "sendfile", 3, 1, 0,
1115 (SCM out
, SCM in
, SCM count
, SCM offset
),
1116 "Send @var{count} bytes from @var{in} to @var{out}, both of which "
1117 "must be either open file ports or file descriptors. When "
1118 "@var{offset} is omitted, start reading from @var{in}'s current "
1119 "position; otherwise, start reading at @var{offset}. Return "
1120 "the number of bytes actually sent.")
1121 #define FUNC_NAME s_scm_sendfile
1123 #define VALIDATE_FD_OR_PORT(cvar, svar, pos) \
1124 if (scm_is_integer (svar)) \
1125 cvar = scm_to_int (svar); \
1128 SCM_VALIDATE_OPFPORT (pos, svar); \
1130 cvar = SCM_FPORT_FDES (svar); \
1133 ssize_t result SCM_UNUSED
;
1134 size_t c_count
, total
= 0;
1138 VALIDATE_FD_OR_PORT (out_fd
, out
, 1);
1139 VALIDATE_FD_OR_PORT (in_fd
, in
, 2);
1140 c_count
= scm_to_size_t (count
);
1141 c_offset
= SCM_UNBNDP (offset
) ? 0 : scm_to_off_t (offset
);
1143 #if defined HAVE_SYS_SENDFILE_H && defined HAVE_SENDFILE
1144 /* The Linux-style sendfile(2), which is different from the BSD-style. */
1149 offset_ptr
= SCM_UNBNDP (offset
) ? NULL
: &c_offset
;
1151 /* On Linux, when OUT_FD is a file, everything is transferred at once and
1152 RESULT == C_COUNT. However, when OUT_FD is a pipe or other "slow"
1153 device, fewer bytes may be transferred, hence the loop. RESULT == 0
1154 means EOF on IN_FD, so leave the loop in that case. */
1157 result
= sendfile_or_sendfile64 (out_fd
, in_fd
, offset_ptr
,
1160 /* At this point, either OFFSET_PTR is non-NULL and it has been
1161 updated to the current offset in IN_FD, or it is NULL and IN_FD's
1162 offset has been updated. */
1164 else if (result
< 0 && (errno
== EINTR
|| errno
== EAGAIN
))
1168 while (total
< c_count
&& result
> 0);
1171 /* Quoting the Linux man page: "In Linux kernels before 2.6.33, out_fd
1172 must refer to a socket. Since Linux 2.6.33 it can be any file."
1173 Fall back to read(2) and write(2) when such an error occurs. */
1174 if (result
< 0 && errno
!= EINVAL
&& errno
!= ENOSYS
)
1176 else if (result
< 0)
1181 int reached_eof
= 0;
1183 if (!SCM_UNBNDP (offset
))
1186 scm_seek (in
, scm_from_off_t (c_offset
), scm_from_int (SEEK_SET
));
1189 if (lseek_or_lseek64 (in_fd
, c_offset
, SEEK_SET
) < 0)
1194 for (total
= 0, left
= c_count
; total
< c_count
&& !reached_eof
; )
1196 size_t asked
, obtained
, written
;
1198 asked
= MIN (sizeof buf
, left
);
1199 obtained
= full_read (in_fd
, buf
, asked
);
1200 if (obtained
< asked
)
1210 written
= full_write (out_fd
, buf
, obtained
);
1211 if (written
< obtained
)
1219 return scm_from_size_t (total
);
1221 #undef VALIDATE_FD_OR_PORT
1225 #endif /* HAVE_POSIX */
1228 /* Essential procedures used in (system base compile). */
1231 SCM_DEFINE (scm_getcwd
, "getcwd", 0, 0, 0,
1233 "Return the name of the current working directory.")
1234 #define FUNC_NAME s_scm_getcwd
1241 wd
= scm_malloc (size
);
1242 while ((rv
= getcwd (wd
, size
)) == 0 && errno
== ERANGE
)
1246 wd
= scm_malloc (size
);
1250 int save_errno
= errno
;
1255 result
= scm_from_locale_stringn (wd
, strlen (wd
));
1260 #endif /* HAVE_GETCWD */
1263 SCM_DEFINE (scm_mkdir
, "mkdir", 1, 1, 0,
1264 (SCM path
, SCM mode
),
1265 "Create a new directory named by @var{path}. If @var{mode} is omitted\n"
1266 "then the permissions of the directory file are set using the current\n"
1267 "umask. Otherwise they are set to the decimal value specified with\n"
1268 "@var{mode}. The return value is unspecified.")
1269 #define FUNC_NAME s_scm_mkdir
1274 if (SCM_UNBNDP (mode
))
1278 STRING_SYSCALL (path
, c_path
, rv
= mkdir (c_path
, 0777 ^ mask
));
1282 STRING_SYSCALL (path
, c_path
, rv
= mkdir (c_path
, scm_to_uint (mode
)));
1286 return SCM_UNSPECIFIED
;
1289 #endif /* HAVE_MKDIR */
1292 SCM_DEFINE (scm_rmdir
, "rmdir", 1, 0, 0,
1294 "Remove the existing directory named by @var{path}. The directory must\n"
1295 "be empty for this to succeed. The return value is unspecified.")
1296 #define FUNC_NAME s_scm_rmdir
1300 STRING_SYSCALL (path
, c_path
, val
= rmdir (c_path
));
1303 return SCM_UNSPECIFIED
;
1309 #define my_rename rename
1312 my_rename (const char *oldname
, const char *newname
)
1316 SCM_SYSCALL (rv
= link (oldname
, newname
));
1319 SCM_SYSCALL (rv
= unlink (oldname
));
1321 /* unlink failed. remove new name */
1322 SCM_SYSCALL (unlink (newname
));
1328 SCM_DEFINE (scm_rename
, "rename-file", 2, 0, 0,
1329 (SCM oldname
, SCM newname
),
1330 "Renames the file specified by @var{oldname} to @var{newname}.\n"
1331 "The return value is unspecified.")
1332 #define FUNC_NAME s_scm_rename
1336 STRING2_SYSCALL (oldname
, c_oldname
,
1338 rv
= my_rename (c_oldname
, c_newname
));
1341 return SCM_UNSPECIFIED
;
1346 SCM_DEFINE (scm_delete_file
, "delete-file", 1, 0, 0,
1348 "Deletes (or \"unlinks\") the file specified by @var{str}.")
1349 #define FUNC_NAME s_scm_delete_file
1352 STRING_SYSCALL (str
, c_str
, ans
= unlink (c_str
));
1355 return SCM_UNSPECIFIED
;
1359 SCM_DEFINE (scm_access
, "access?", 2, 0, 0,
1360 (SCM path
, SCM how
),
1361 "Test accessibility of a file under the real UID and GID of the\n"
1362 "calling process. The return is @code{#t} if @var{path} exists\n"
1363 "and the permissions requested by @var{how} are all allowed, or\n"
1364 "@code{#f} if not.\n"
1366 "@var{how} is an integer which is one of the following values,\n"
1367 "or a bitwise-OR (@code{logior}) of multiple values.\n"
1370 "Test for read permission.\n"
1373 "Test for write permission.\n"
1376 "Test for execute permission.\n"
1379 "Test for existence of the file. This is implied by each of the\n"
1380 "other tests, so there's no need to combine it with them.\n"
1383 "It's important to note that @code{access?} does not simply\n"
1384 "indicate what will happen on attempting to read or write a\n"
1385 "file. In normal circumstances it does, but in a set-UID or\n"
1386 "set-GID program it doesn't because @code{access?} tests the\n"
1387 "real ID, whereas an open or execute attempt uses the effective\n"
1390 "A program which will never run set-UID/GID can ignore the\n"
1391 "difference between real and effective IDs, but for maximum\n"
1392 "generality, especially in library functions, it's best not to\n"
1393 "use @code{access?} to predict the result of an open or execute,\n"
1394 "instead simply attempt that and catch any exception.\n"
1396 "The main use for @code{access?} is to let a set-UID/GID program\n"
1397 "determine what the invoking user would have been allowed to do,\n"
1398 "without the greater (or perhaps lesser) privileges afforded by\n"
1399 "the effective ID. For more on this, see ``Testing File\n"
1400 "Access'' in The GNU C Library Reference Manual.")
1401 #define FUNC_NAME s_scm_access
1406 c_path
= scm_to_locale_string (path
);
1407 rv
= access (c_path
, scm_to_int (how
));
1410 return scm_from_bool (!rv
);
1414 SCM_DEFINE (scm_chmod
, "chmod", 2, 0, 0,
1415 (SCM object
, SCM mode
),
1416 "Changes the permissions of the file referred to by\n"
1417 "@var{object}. @var{object} can be a string containing a file\n"
1418 "name or a port or integer file descriptor which is open on a\n"
1419 "file (in which case @code{fchmod} is used as the underlying\n"
1420 "system call). @var{mode} specifies the new permissions as a\n"
1421 "decimal number, e.g., @code{(chmod \"foo\" #o755)}.\n"
1422 "The return value is unspecified.")
1423 #define FUNC_NAME s_scm_chmod
1427 object
= SCM_COERCE_OUTPORT (object
);
1430 if (scm_is_integer (object
) || SCM_OPFPORTP (object
))
1433 if (scm_is_integer (object
))
1434 fdes
= scm_to_int (object
);
1436 fdes
= SCM_FPORT_FDES (object
);
1437 SCM_SYSCALL (rv
= fchmod (fdes
, scm_to_int (mode
)));
1442 STRING_SYSCALL (object
, c_object
,
1443 rv
= chmod (c_object
, scm_to_int (mode
)));
1447 return SCM_UNSPECIFIED
;
1451 SCM_DEFINE (scm_umask
, "umask", 0, 1, 0,
1453 "If @var{mode} is omitted, returns a decimal number representing the current\n"
1454 "file creation mask. Otherwise the file creation mask is set to\n"
1455 "@var{mode} and the previous value is returned.\n\n"
1456 "E.g., @code{(umask #o022)} sets the mask to octal 22, decimal 18.")
1457 #define FUNC_NAME s_scm_umask
1460 if (SCM_UNBNDP (mode
))
1467 mask
= umask (scm_to_uint (mode
));
1469 return scm_from_uint (mask
);
1473 #ifndef HAVE_MKSTEMP
1474 extern int mkstemp (char *);
1477 SCM_DEFINE (scm_mkstemp
, "mkstemp!", 1, 0, 0,
1479 "Create a new unique file in the file system and return a new\n"
1480 "buffered port open for reading and writing to the file.\n"
1482 "@var{tmpl} is a string specifying where the file should be\n"
1483 "created: it must end with @samp{XXXXXX} and those @samp{X}s\n"
1484 "will be changed in the string to return the name of the file.\n"
1485 "(@code{port-filename} on the port also gives the name.)\n"
1487 "POSIX doesn't specify the permissions mode of the file, on GNU\n"
1488 "and most systems it's @code{#o600}. An application can use\n"
1489 "@code{chmod} to relax that if desired. For example\n"
1490 "@code{#o666} less @code{umask}, which is usual for ordinary\n"
1494 "(let ((port (mkstemp! (string-copy \"/tmp/myfile-XXXXXX\"))))\n"
1495 " (chmod port (logand #o666 (lognot (umask))))\n"
1498 #define FUNC_NAME s_scm_mkstemp
1503 scm_dynwind_begin (0);
1505 c_tmpl
= scm_to_locale_string (tmpl
);
1506 scm_dynwind_free (c_tmpl
);
1508 SCM_SYSCALL (rv
= mkstemp (c_tmpl
));
1512 scm_substring_move_x (scm_from_locale_string (c_tmpl
),
1513 SCM_INUM0
, scm_string_length (tmpl
),
1517 return scm_fdes_to_port (rv
, "w+", tmpl
);
1522 /* Filename manipulation */
1527 SCM_SYMBOL (sym_file_name_convention
, "windows");
1529 SCM_SYMBOL (sym_file_name_convention
, "posix");
1532 SCM_INTERNAL SCM
scm_system_file_name_convention (void);
1534 SCM_DEFINE (scm_system_file_name_convention
,
1535 "system-file-name-convention", 0, 0, 0, (void),
1536 "Return either @code{posix} or @code{windows}, depending on\n"
1537 "what kind of system this Guile is running on.")
1538 #define FUNC_NAME s_scm_system_file_name_convention
1540 return sym_file_name_convention
;
1544 SCM_DEFINE (scm_dirname
, "dirname", 1, 0, 0,
1546 "Return the directory name component of the file name\n"
1547 "@var{filename}. If @var{filename} does not contain a directory\n"
1548 "component, @code{.} is returned.")
1549 #define FUNC_NAME s_scm_dirname
1552 unsigned long int len
;
1554 SCM_VALIDATE_STRING (1, filename
);
1556 len
= scm_i_string_length (filename
);
1560 while (i
>= 0 && is_file_name_separator (scm_c_string_ref (filename
, i
)))
1562 while (i
>= 0 && !is_file_name_separator (scm_c_string_ref (filename
, i
)))
1564 while (i
>= 0 && is_file_name_separator (scm_c_string_ref (filename
, i
)))
1569 if (len
> 0 && is_file_name_separator (scm_c_string_ref (filename
, 0)))
1570 return scm_c_substring (filename
, 0, 1);
1572 return scm_dot_string
;
1575 return scm_c_substring (filename
, 0, i
+ 1);
1579 SCM_DEFINE (scm_basename
, "basename", 1, 1, 0,
1580 (SCM filename
, SCM suffix
),
1581 "Return the base name of the file name @var{filename}. The\n"
1582 "base name is the file name without any directory components.\n"
1583 "If @var{suffix} is provided, and is equal to the end of\n"
1584 "@var{filename}, it is removed also.")
1585 #define FUNC_NAME s_scm_basename
1589 SCM_VALIDATE_STRING (1, filename
);
1590 len
= scm_i_string_length (filename
);
1592 if (SCM_UNBNDP (suffix
))
1596 SCM_VALIDATE_STRING (2, suffix
);
1597 j
= scm_i_string_length (suffix
) - 1;
1600 while (i
>= 0 && is_file_name_separator (scm_c_string_ref (filename
, i
)))
1603 while (i
>= 0 && j
>= 0
1604 && (scm_i_string_ref (filename
, i
)
1605 == scm_i_string_ref (suffix
, j
)))
1612 while (i
>= 0 && !is_file_name_separator (scm_c_string_ref (filename
, i
)))
1616 if (len
> 0 && is_file_name_separator (scm_c_string_ref (filename
, 0)))
1617 return scm_c_substring (filename
, 0, 1);
1619 return scm_dot_string
;
1622 return scm_c_substring (filename
, i
+1, end
+1);
1626 SCM_DEFINE (scm_canonicalize_path
, "canonicalize-path", 1, 0, 0,
1628 "Return the canonical path of @var{path}. A canonical path has\n"
1629 "no @code{.} or @code{..} components, nor any repeated path\n"
1630 "separators (@code{/}) nor symlinks.\n\n"
1631 "Raises an error if any component of @var{path} does not exist.")
1632 #define FUNC_NAME s_scm_canonicalize_path
1636 SCM_VALIDATE_STRING (1, path
);
1638 str
= scm_to_locale_string (path
);
1639 canon
= canonicalize_file_name (str
);
1643 return scm_take_locale_string (canon
);
1650 scm_i_relativize_path (SCM path
, SCM in_path
)
1655 str
= scm_to_locale_string (path
);
1656 canon
= canonicalize_file_name (str
);
1662 scanon
= scm_take_locale_string (canon
);
1664 for (; scm_is_pair (in_path
); in_path
= scm_cdr (in_path
))
1666 SCM dir
= scm_car (in_path
);
1667 size_t len
= scm_c_string_length (dir
);
1669 /* When DIR is empty, it means "current working directory". We
1670 could set DIR to (getcwd) in that case, but then the
1671 canonicalization would depend on the current directory, which
1672 is not what we want in the context of `compile-file', for
1675 && scm_is_true (scm_string_prefix_p (dir
, scanon
,
1676 SCM_UNDEFINED
, SCM_UNDEFINED
,
1677 SCM_UNDEFINED
, SCM_UNDEFINED
)))
1679 /* DIR either has a trailing delimiter or doesn't. SCANON
1680 will be delimited by single delimiters. When DIR does not
1681 have a trailing delimiter, add one to the length to strip
1682 off the delimiter within SCANON. */
1683 if (!is_file_name_separator (scm_c_string_ref (dir
, len
- 1)))
1686 if (scm_c_string_length (scanon
) > len
)
1687 return scm_substring (scanon
, scm_from_size_t (len
), SCM_UNDEFINED
);
1697 /* Examining directories. These procedures are used by `check-guile'
1698 and thus compiled unconditionally. */
1700 scm_t_bits scm_tc16_dir
;
1703 SCM_DEFINE (scm_directory_stream_p
, "directory-stream?", 1, 0, 0,
1705 "Return a boolean indicating whether @var{obj} is a directory\n"
1706 "stream as returned by @code{opendir}.")
1707 #define FUNC_NAME s_scm_directory_stream_p
1709 return scm_from_bool (SCM_DIRP (obj
));
1714 SCM_DEFINE (scm_opendir
, "opendir", 1, 0, 0,
1716 "Open the directory specified by @var{dirname} and return a directory\n"
1718 #define FUNC_NAME s_scm_opendir
1721 STRING_SYSCALL (dirname
, c_dirname
, ds
= opendir (c_dirname
));
1724 SCM_RETURN_NEWSMOB (scm_tc16_dir
| (SCM_DIR_FLAG_OPEN
<<16), ds
);
1729 /* FIXME: The glibc manual has a portability note that readdir_r may not
1730 null-terminate its return string. The circumstances outlined for this
1731 are not clear, nor is it clear what should be done about it. Lets use
1732 NAMLEN and worry about what else should be done if/when someone can
1735 SCM_DEFINE (scm_readdir
, "readdir", 1, 0, 0,
1737 "Return (as a string) the next directory entry from the directory stream\n"
1738 "@var{port}. If there is no remaining entry to be read then the\n"
1739 "end of file object is returned.")
1740 #define FUNC_NAME s_scm_readdir
1742 struct dirent_or_dirent64
*rdent
;
1744 SCM_VALIDATE_DIR (1, port
);
1745 if (!SCM_DIR_OPEN_P (port
))
1746 SCM_MISC_ERROR ("Directory ~S is not open.", scm_list_1 (port
));
1749 /* As noted in the glibc manual, on various systems (such as Solaris)
1750 the d_name[] field is only 1 char and you're expected to size the
1751 dirent buffer for readdir_r based on NAME_MAX. The MAX expressions
1752 below effectively give either sizeof(d_name) or NAME_MAX+1,
1753 whichever is bigger.
1755 On solaris 10 there's no NAME_MAX constant, it's necessary to use
1756 pathconf(). We prefer NAME_MAX though, since it should be a constant
1757 and will therefore save a system call. We also prefer it since dirfd()
1758 is not available everywhere.
1760 An alternative to dirfd() would be to open() the directory and then use
1761 fdopendir(), if the latter is available. That'd let us hold the fd
1762 somewhere in the smob, or just the dirent size calculated once. */
1764 struct dirent_or_dirent64 de
; /* just for sizeof */
1765 DIR *ds
= (DIR *) SCM_SMOB_DATA_1 (port
);
1767 char buf
[MAX (sizeof (de
),
1768 sizeof (de
) - sizeof (de
.d_name
) + NAME_MAX
+ 1)];
1771 long name_max
= fpathconf (dirfd (ds
), _PC_NAME_MAX
);
1774 buf
= alloca (MAX (sizeof (de
),
1775 sizeof (de
) - sizeof (de
.d_name
) + name_max
+ 1));
1779 SCM_SYSCALL (readdir_r_or_readdir64_r (ds
, (struct dirent_or_dirent64
*) buf
, &rdent
));
1785 return (rdent
? scm_from_locale_stringn (rdent
->d_name
, NAMLEN (rdent
))
1791 scm_dynwind_begin (0);
1792 scm_i_dynwind_pthread_mutex_lock (&scm_i_misc_mutex
);
1795 SCM_SYSCALL (rdent
= readdir_or_readdir64 ((DIR *) SCM_SMOB_DATA_1 (port
)));
1799 ret
= (rdent
? scm_from_locale_stringn (rdent
->d_name
, NAMLEN (rdent
))
1810 SCM_DEFINE (scm_rewinddir
, "rewinddir", 1, 0, 0,
1812 "Reset the directory port @var{port} so that the next call to\n"
1813 "@code{readdir} will return the first directory entry.")
1814 #define FUNC_NAME s_scm_rewinddir
1816 SCM_VALIDATE_DIR (1, port
);
1817 if (!SCM_DIR_OPEN_P (port
))
1818 SCM_MISC_ERROR ("Directory ~S is not open.", scm_list_1 (port
));
1820 rewinddir ((DIR *) SCM_SMOB_DATA_1 (port
));
1822 return SCM_UNSPECIFIED
;
1827 SCM_DEFINE (scm_closedir
, "closedir", 1, 0, 0,
1829 "Close the directory stream @var{port}.\n"
1830 "The return value is unspecified.")
1831 #define FUNC_NAME s_scm_closedir
1833 SCM_VALIDATE_DIR (1, port
);
1835 if (SCM_DIR_OPEN_P (port
))
1839 SCM_SYSCALL (sts
= closedir ((DIR *) SCM_SMOB_DATA_1 (port
)));
1843 SCM_SET_SMOB_DATA_0 (port
, scm_tc16_dir
);
1846 return SCM_UNSPECIFIED
;
1853 scm_dir_print (SCM exp
, SCM port
, scm_print_state
*pstate SCM_UNUSED
)
1855 scm_puts_unlocked ("#<", port
);
1856 if (!SCM_DIR_OPEN_P (exp
))
1857 scm_puts_unlocked ("closed: ", port
);
1858 scm_puts_unlocked ("directory stream ", port
);
1859 scm_uintprint (SCM_SMOB_DATA_1 (exp
), 16, port
);
1860 scm_putc_unlocked ('>', port
);
1866 scm_dir_free (SCM p
)
1868 if (SCM_DIR_OPEN_P (p
))
1869 closedir ((DIR *) SCM_SMOB_DATA_1 (p
));
1880 scm_tc16_dir
= scm_make_smob_type ("directory", 0);
1881 scm_set_smob_free (scm_tc16_dir
, scm_dir_free
);
1882 scm_set_smob_print (scm_tc16_dir
, scm_dir_print
);
1885 scm_c_define ("O_RDONLY", scm_from_int (O_RDONLY
));
1888 scm_c_define ("O_WRONLY", scm_from_int (O_WRONLY
));
1891 scm_c_define ("O_RDWR", scm_from_int (O_RDWR
));
1894 scm_c_define ("O_CREAT", scm_from_int (O_CREAT
));
1897 scm_c_define ("O_EXCL", scm_from_int (O_EXCL
));
1900 scm_c_define ("O_NOCTTY", scm_from_int (O_NOCTTY
));
1903 scm_c_define ("O_TRUNC", scm_from_int (O_TRUNC
));
1906 scm_c_define ("O_APPEND", scm_from_int (O_APPEND
));
1909 scm_c_define ("O_NONBLOCK", scm_from_int (O_NONBLOCK
));
1912 scm_c_define ("O_NDELAY", scm_from_int (O_NDELAY
));
1915 scm_c_define ("O_SYNC", scm_from_int (O_SYNC
));
1918 scm_c_define ("O_LARGEFILE", scm_from_int (O_LARGEFILE
));
1921 scm_c_define ("O_NOTRANS", scm_from_int (O_NOTRANS
));
1925 scm_c_define ("F_DUPFD", scm_from_int (F_DUPFD
));
1928 scm_c_define ("F_GETFD", scm_from_int (F_GETFD
));
1931 scm_c_define ("F_SETFD", scm_from_int (F_SETFD
));
1934 scm_c_define ("F_GETFL", scm_from_int (F_GETFL
));
1937 scm_c_define ("F_SETFL", scm_from_int (F_SETFL
));
1940 scm_c_define ("F_GETOWN", scm_from_int (F_GETOWN
));
1943 scm_c_define ("F_SETOWN", scm_from_int (F_SETOWN
));
1946 scm_c_define ("FD_CLOEXEC", scm_from_int (FD_CLOEXEC
));
1948 #endif /* HAVE_POSIX */
1950 /* `access' symbols. */
1951 scm_c_define ("R_OK", scm_from_int (R_OK
));
1952 scm_c_define ("W_OK", scm_from_int (W_OK
));
1953 scm_c_define ("X_OK", scm_from_int (X_OK
));
1954 scm_c_define ("F_OK", scm_from_int (F_OK
));
1956 scm_dot_string
= scm_from_locale_string (".");
1958 #include "libguile/filesys.x"