1 /* Copyright (C) 1996,1997,1998,1999,2000,2001, 2002, 2004, 2006, 2009, 2010, 2011 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 License
5 * as published by the Free Software Foundation; either version 3 of
6 * the License, or (at your option) any later version.
8 * This library is distributed in the hope that it will be useful, but
9 * 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
21 /* This file contains POSIX file system access procedures. Procedures
22 essential to the compiler and run-time (`stat', `canonicalize-path',
23 etc.) are compiled even with `--disable-posix'. */
26 /* See stime.c for comments on why _POSIX_C_SOURCE is not always defined. */
27 #define _LARGEFILE64_SOURCE /* ask for stat64 etc */
29 #define _POSIX_C_SOURCE 199506L /* for readdir_r */
42 #include "libguile/_scm.h"
43 #include "libguile/smob.h"
44 #include "libguile/feature.h"
45 #include "libguile/fports.h"
46 #include "libguile/private-gc.h" /* for SCM_MAX */
47 #include "libguile/iselect.h"
48 #include "libguile/strings.h"
49 #include "libguile/vectors.h"
50 #include "libguile/dynwind.h"
52 #include "libguile/validate.h"
53 #include "libguile/filesys.h"
64 #ifdef TIME_WITH_SYS_TIME
65 # include <sys/time.h>
69 # include <sys/time.h>
79 #ifdef LIBC_H_WITH_UNISTD_H
83 #ifdef HAVE_SYS_SELECT_H
84 #include <sys/select.h>
91 #include <sys/types.h>
102 # define NAMLEN(dirent) strlen((dirent)->d_name)
104 # define dirent direct
105 # define NAMLEN(dirent) (dirent)->d_namlen
107 # include <sys/ndir.h>
110 # include <sys/dir.h>
117 /* Some more definitions for the native Windows port. */
119 # define mkdir(path, mode) mkdir (path)
120 # define fsync(fd) _commit (fd)
121 # define fchmod(fd, mode) (-1)
122 #endif /* __MINGW32__ */
124 /* dirfd() returns the file descriptor underlying a "DIR*" directory stream.
125 Found on MacOS X for instance. The following definition is for Solaris
126 10, it's probably not right elsewhere, but that's ok, it shouldn't be
127 used elsewhere. Crib note: If we need more then gnulib has a dirfd.m4
128 figuring out how to get the fd (dirfd function, dirfd macro, dd_fd field,
131 #define dirfd(dirstream) ((dirstream)->dd_fd)
136 /* Two helper macros for an often used pattern */
138 #define STRING_SYSCALL(str,cstr,code) \
141 char *cstr = scm_to_locale_string (str); \
142 SCM_SYSCALL (code); \
143 eno = errno; free (cstr); errno = eno; \
146 #define STRING2_SYSCALL(str1,cstr1,str2,cstr2,code) \
149 char *cstr1, *cstr2; \
150 scm_dynwind_begin (0); \
151 cstr1 = scm_to_locale_string (str1); \
152 scm_dynwind_free (cstr1); \
153 cstr2 = scm_to_locale_string (str2); \
154 scm_dynwind_free (cstr2); \
155 SCM_SYSCALL (code); \
156 eno = errno; scm_dynwind_end (); errno = eno; \
167 SCM_DEFINE (scm_chown
, "chown", 3, 0, 0,
168 (SCM object
, SCM owner
, SCM group
),
169 "Change the ownership and group of the file referred to by @var{object} to\n"
170 "the integer values @var{owner} and @var{group}. @var{object} can be\n"
171 "a string containing a file name or, if the platform\n"
172 "supports fchown, a port or integer file descriptor\n"
173 "which is open on the file. The return value\n"
174 "is unspecified.\n\n"
175 "If @var{object} is a symbolic link, either the\n"
176 "ownership of the link or the ownership of the referenced file will be\n"
177 "changed depending on the operating system (lchown is\n"
178 "unsupported at present). If @var{owner} or @var{group} is specified\n"
179 "as @code{-1}, then that ID is not changed.")
180 #define FUNC_NAME s_scm_chown
184 object
= SCM_COERCE_OUTPORT (object
);
187 if (scm_is_integer (object
) || (SCM_OPFPORTP (object
)))
189 int fdes
= (SCM_OPFPORTP (object
)?
190 SCM_FPORT_FDES (object
) : scm_to_int (object
));
192 SCM_SYSCALL (rv
= fchown (fdes
, scm_to_int (owner
), scm_to_int (group
)));
197 STRING_SYSCALL (object
, c_object
,
198 rv
= chown (c_object
,
199 scm_to_int (owner
), scm_to_int (group
)));
203 return SCM_UNSPECIFIED
;
206 #endif /* HAVE_CHOWN */
210 SCM_DEFINE (scm_open_fdes
, "open-fdes", 2, 1, 0,
211 (SCM path
, SCM flags
, SCM mode
),
212 "Similar to @code{open} but return a file descriptor instead of\n"
214 #define FUNC_NAME s_scm_open_fdes
220 iflags
= SCM_NUM2INT (2, flags
);
221 imode
= SCM_NUM2INT_DEF (3, mode
, 0666);
222 STRING_SYSCALL (path
, c_path
, fd
= open_or_open64 (c_path
, iflags
, imode
));
225 return scm_from_int (fd
);
229 SCM_DEFINE (scm_open
, "open", 2, 1, 0,
230 (SCM path
, SCM flags
, SCM mode
),
231 "Open the file named by @var{path} for reading and/or writing.\n"
232 "@var{flags} is an integer specifying how the file should be opened.\n"
233 "@var{mode} is an integer specifying the permission bits of the file, if\n"
234 "it needs to be created, before the umask is applied. The default is 666\n"
235 "(Unix itself has no default).\n\n"
236 "@var{flags} can be constructed by combining variables using @code{logior}.\n"
237 "Basic flags are:\n\n"
239 "Open the file read-only.\n"
242 "Open the file write-only.\n"
245 "Open the file read/write.\n"
248 "Append to the file instead of truncating.\n"
251 "Create the file if it does not already exist.\n"
253 "See the Unix documentation of the @code{open} system call\n"
254 "for additional flags.")
255 #define FUNC_NAME s_scm_open
262 fd
= scm_to_int (scm_open_fdes (path
, flags
, mode
));
263 iflags
= SCM_NUM2INT (2, flags
);
265 if ((iflags
& O_RDWR
) == O_RDWR
)
267 /* Opened read-write. */
268 if (iflags
& O_APPEND
)
270 else if (iflags
& O_CREAT
)
277 /* Opened read-only or write-only. */
278 if (iflags
& O_APPEND
)
280 else if (iflags
& O_WRONLY
)
286 newpt
= scm_fdes_to_port (fd
, port_mode
, path
);
291 SCM_DEFINE (scm_close
, "close", 1, 0, 0,
293 "Similar to close-port (@pxref{Closing, close-port}),\n"
294 "but also works on file descriptors. A side\n"
295 "effect of closing a file descriptor is that any ports using that file\n"
296 "descriptor are moved to a different file descriptor and have\n"
297 "their revealed counts set to zero.")
298 #define FUNC_NAME s_scm_close
303 fd_or_port
= SCM_COERCE_OUTPORT (fd_or_port
);
305 if (SCM_PORTP (fd_or_port
))
306 return scm_close_port (fd_or_port
);
307 fd
= scm_to_int (fd_or_port
);
308 scm_evict_ports (fd
); /* see scsh manual. */
309 SCM_SYSCALL (rv
= close (fd
));
310 /* following scsh, closing an already closed file descriptor is
312 if (rv
< 0 && errno
!= EBADF
)
314 return scm_from_bool (rv
>= 0);
318 SCM_DEFINE (scm_close_fdes
, "close-fdes", 1, 0, 0,
320 "A simple wrapper for the @code{close} system call.\n"
321 "Close file descriptor @var{fd}, which must be an integer.\n"
322 "Unlike close (@pxref{Ports and File Descriptors, close}),\n"
323 "the file descriptor will be closed even if a port is using it.\n"
324 "The return value is unspecified.")
325 #define FUNC_NAME s_scm_close_fdes
330 c_fd
= scm_to_int (fd
);
331 SCM_SYSCALL (rv
= close (c_fd
));
334 return SCM_UNSPECIFIED
;
338 #endif /* HAVE_POSIX */
344 SCM_SYMBOL (scm_sym_regular
, "regular");
345 SCM_SYMBOL (scm_sym_directory
, "directory");
347 SCM_SYMBOL (scm_sym_symlink
, "symlink");
349 SCM_SYMBOL (scm_sym_block_special
, "block-special");
350 SCM_SYMBOL (scm_sym_char_special
, "char-special");
351 SCM_SYMBOL (scm_sym_fifo
, "fifo");
352 SCM_SYMBOL (scm_sym_sock
, "socket");
353 SCM_SYMBOL (scm_sym_unknown
, "unknown");
356 scm_stat2scm (struct stat_or_stat64
*stat_temp
)
358 SCM ans
= scm_c_make_vector (18, SCM_UNSPECIFIED
);
360 SCM_SIMPLE_VECTOR_SET(ans
, 0, scm_from_ulong (stat_temp
->st_dev
));
361 SCM_SIMPLE_VECTOR_SET(ans
, 1, scm_from_ino_t_or_ino64_t (stat_temp
->st_ino
));
362 SCM_SIMPLE_VECTOR_SET(ans
, 2, scm_from_ulong (stat_temp
->st_mode
));
363 SCM_SIMPLE_VECTOR_SET(ans
, 3, scm_from_ulong (stat_temp
->st_nlink
));
364 SCM_SIMPLE_VECTOR_SET(ans
, 4, scm_from_ulong (stat_temp
->st_uid
));
365 SCM_SIMPLE_VECTOR_SET(ans
, 5, scm_from_ulong (stat_temp
->st_gid
));
366 #ifdef HAVE_STRUCT_STAT_ST_RDEV
367 SCM_SIMPLE_VECTOR_SET(ans
, 6, scm_from_ulong (stat_temp
->st_rdev
));
369 SCM_SIMPLE_VECTOR_SET(ans
, 6, SCM_BOOL_F
);
371 SCM_SIMPLE_VECTOR_SET(ans
, 7, scm_from_off_t_or_off64_t (stat_temp
->st_size
));
372 SCM_SIMPLE_VECTOR_SET(ans
, 8, scm_from_ulong (stat_temp
->st_atime
));
373 SCM_SIMPLE_VECTOR_SET(ans
, 9, scm_from_ulong (stat_temp
->st_mtime
));
374 SCM_SIMPLE_VECTOR_SET(ans
, 10, scm_from_ulong (stat_temp
->st_ctime
));
375 #ifdef HAVE_STRUCT_STAT_ST_BLKSIZE
376 SCM_SIMPLE_VECTOR_SET(ans
, 11, scm_from_ulong (stat_temp
->st_blksize
));
378 SCM_SIMPLE_VECTOR_SET(ans
, 11, scm_from_ulong (4096L));
380 #ifdef HAVE_STRUCT_STAT_ST_BLOCKS
381 SCM_SIMPLE_VECTOR_SET(ans
, 12, scm_from_blkcnt_t_or_blkcnt64_t (stat_temp
->st_blocks
));
383 SCM_SIMPLE_VECTOR_SET(ans
, 12, SCM_BOOL_F
);
386 int mode
= stat_temp
->st_mode
;
389 SCM_SIMPLE_VECTOR_SET(ans
, 13, scm_sym_regular
);
390 else if (S_ISDIR (mode
))
391 SCM_SIMPLE_VECTOR_SET(ans
, 13, scm_sym_directory
);
393 /* systems without symlinks probably don't have S_ISLNK */
394 else if (S_ISLNK (mode
))
395 SCM_SIMPLE_VECTOR_SET(ans
, 13, scm_sym_symlink
);
397 else if (S_ISBLK (mode
))
398 SCM_SIMPLE_VECTOR_SET(ans
, 13, scm_sym_block_special
);
399 else if (S_ISCHR (mode
))
400 SCM_SIMPLE_VECTOR_SET(ans
, 13, scm_sym_char_special
);
401 else if (S_ISFIFO (mode
))
402 SCM_SIMPLE_VECTOR_SET(ans
, 13, scm_sym_fifo
);
404 else if (S_ISSOCK (mode
))
405 SCM_SIMPLE_VECTOR_SET(ans
, 13, scm_sym_sock
);
408 SCM_SIMPLE_VECTOR_SET(ans
, 13, scm_sym_unknown
);
410 SCM_SIMPLE_VECTOR_SET(ans
, 14, scm_from_int ((~S_IFMT
) & mode
));
412 /* the layout of the bits in ve[14] is intended to be portable.
413 If there are systems that don't follow the usual convention,
414 the following could be used:
417 if (S_ISUID & mode) tmp += 1;
419 if (S_IRGRP & mode) tmp += 1;
421 if (S_ISVTX & mode) tmp += 1;
423 if (S_IRUSR & mode) tmp += 1;
425 if (S_IWUSR & mode) tmp += 1;
427 if (S_IXUSR & mode) tmp += 1;
429 if (S_IWGRP & mode) tmp += 1;
431 if (S_IXGRP & mode) tmp += 1;
433 if (S_IROTH & mode) tmp += 1;
435 if (S_IWOTH & mode) tmp += 1;
437 if (S_IXOTH & mode) tmp += 1;
439 SCM_SIMPLE_VECTOR_SET(ans, 14, scm_from_int (tmp));
443 #ifdef HAVE_STRUCT_STAT_ST_ATIM
444 SCM_SIMPLE_VECTOR_SET(ans
, 15, scm_from_long (stat_temp
->st_atim
.tv_nsec
));
446 SCM_SIMPLE_VECTOR_SET(ans
, 15, SCM_I_MAKINUM (0));
448 #ifdef HAVE_STRUCT_STAT_ST_MTIM
449 SCM_SIMPLE_VECTOR_SET(ans
, 16, scm_from_long (stat_temp
->st_mtim
.tv_nsec
));
451 SCM_SIMPLE_VECTOR_SET(ans
, 16, SCM_I_MAKINUM (0));
453 #ifdef HAVE_STRUCT_STAT_ST_CTIM
454 SCM_SIMPLE_VECTOR_SET(ans
, 17, scm_from_ulong (stat_temp
->st_ctim
.tv_sec
));
456 SCM_SIMPLE_VECTOR_SET(ans
, 17, SCM_I_MAKINUM (0));
464 * Try getting the appropiate stat buffer for a given file descriptor
465 * under Windows. It differentiates between file, pipe and socket
468 static int fstat_Win32 (int fdes
, struct stat
*buf
)
470 int error
, optlen
= sizeof (int);
472 memset (buf
, 0, sizeof (struct stat
));
474 /* Is this a socket ? */
475 if (getsockopt (fdes
, SOL_SOCKET
, SO_ERROR
, (void *) &error
, &optlen
) >= 0)
477 buf
->st_mode
= _S_IREAD
| _S_IWRITE
| _S_IEXEC
;
479 buf
->st_atime
= buf
->st_ctime
= buf
->st_mtime
= time (NULL
);
482 /* Maybe a regular file or pipe ? */
483 return fstat (fdes
, buf
);
485 #endif /* __MINGW32__ */
487 SCM_DEFINE (scm_stat
, "stat", 1, 1, 0,
488 (SCM object
, SCM exception_on_error
),
489 "Return an object containing various information about the file\n"
490 "determined by @var{obj}. @var{obj} can be a string containing\n"
491 "a file name or a port or integer file descriptor which is open\n"
492 "on a file (in which case @code{fstat} is used as the underlying\n"
495 "If the optional @var{exception_on_error} argument is true, which\n"
496 "is the default, an exception will be raised if the underlying\n"
497 "system call returns an error, for example if the file is not\n"
498 "found or is not readable. Otherwise, an error will cause\n"
499 "@code{stat} to return @code{#f}."
501 "The object returned by a successful call to @code{stat} can be\n"
502 "passed as a single parameter to the following procedures, all of\n"
503 "which return integers:\n"
507 "The device containing the file.\n"
509 "The file serial number, which distinguishes this file from all\n"
510 "other files on the same device.\n"
512 "The mode of the file. This includes file type information and\n"
513 "the file permission bits. See @code{stat:type} and\n"
514 "@code{stat:perms} below.\n"
516 "The number of hard links to the file.\n"
518 "The user ID of the file's owner.\n"
520 "The group ID of the file.\n"
522 "Device ID; this entry is defined only for character or block\n"
525 "The size of a regular file in bytes.\n"
527 "The last access time for the file.\n"
529 "The last modification time for the file.\n"
531 "The last modification time for the attributes of the file.\n"
532 "@item stat:blksize\n"
533 "The optimal block size for reading or writing the file, in\n"
535 "@item stat:blocks\n"
536 "The amount of disk space that the file occupies measured in\n"
537 "units of 512 byte blocks.\n"
540 "In addition, the following procedures return the information\n"
541 "from stat:mode in a more convenient form:\n"
545 "A symbol representing the type of file. Possible values are\n"
546 "regular, directory, symlink, block-special, char-special, fifo,\n"
547 "socket and unknown\n"
549 "An integer representing the access permission bits.\n"
551 #define FUNC_NAME s_scm_stat
555 struct stat_or_stat64 stat_temp
;
557 if (scm_is_integer (object
))
560 SCM_SYSCALL (rv
= fstat_Win32 (scm_to_int (object
), &stat_temp
));
562 SCM_SYSCALL (rv
= fstat_or_fstat64 (scm_to_int (object
), &stat_temp
));
565 else if (scm_is_string (object
))
567 char *file
= scm_to_locale_string (object
);
570 p
= file
+ strlen (file
) - 1;
571 while (p
> file
&& (*p
== '/' || *p
== '\\'))
574 SCM_SYSCALL (rv
= stat_or_stat64 (file
, &stat_temp
));
579 object
= SCM_COERCE_OUTPORT (object
);
580 SCM_VALIDATE_OPFPORT (1, object
);
581 fdes
= SCM_FPORT_FDES (object
);
583 SCM_SYSCALL (rv
= fstat_Win32 (fdes
, &stat_temp
));
585 SCM_SYSCALL (rv
= fstat_or_fstat64 (fdes
, &stat_temp
));
591 if (SCM_UNBNDP (exception_on_error
) || scm_is_true (exception_on_error
))
594 SCM_SYSERROR_MSG ("~A: ~S",
595 scm_list_2 (scm_strerror (scm_from_int (en
)),
602 return scm_stat2scm (&stat_temp
);
607 SCM_DEFINE (scm_lstat
, "lstat", 1, 0, 0,
609 "Similar to @code{stat}, but does not follow symbolic links, i.e.,\n"
610 "it will return information about a symbolic link itself, not the\n"
611 "file it points to. @var{path} must be a string.")
612 #define FUNC_NAME s_scm_lstat
615 struct stat_or_stat64 stat_temp
;
617 STRING_SYSCALL (str
, c_str
, rv
= lstat_or_lstat64 (c_str
, &stat_temp
));
622 SCM_SYSERROR_MSG ("~A: ~S",
623 scm_list_2 (scm_strerror (scm_from_int (en
)), str
),
626 return scm_stat2scm (&stat_temp
);
629 #endif /* HAVE_LSTAT */
634 /* {Modifying Directories}
638 SCM_DEFINE (scm_link
, "link", 2, 0, 0,
639 (SCM oldpath
, SCM newpath
),
640 "Creates a new name @var{newpath} in the file system for the\n"
641 "file named by @var{oldpath}. If @var{oldpath} is a symbolic\n"
642 "link, the link may or may not be followed depending on the\n"
644 #define FUNC_NAME s_scm_link
648 STRING2_SYSCALL (oldpath
, c_oldpath
,
650 val
= link (c_oldpath
, c_newpath
));
653 return SCM_UNSPECIFIED
;
656 #endif /* HAVE_LINK */
659 /* {Navigating Directories}
663 SCM_DEFINE (scm_chdir
, "chdir", 1, 0, 0,
665 "Change the current working directory to @var{path}.\n"
666 "The return value is unspecified.")
667 #define FUNC_NAME s_scm_chdir
671 STRING_SYSCALL (str
, c_str
, ans
= chdir (c_str
));
674 return SCM_UNSPECIFIED
;
682 /* check that element is a port or file descriptor. if it's a port
683 and its buffer is ready for use, add it to the ports_ready list.
684 otherwise add its file descriptor to *set. the type of list can be
685 determined from pos: SCM_ARG1 for reads, SCM_ARG2 for writes,
686 SCM_ARG3 for excepts. */
688 set_element (SELECT_TYPE
*set
, SCM
*ports_ready
, SCM element
, int pos
)
692 if (scm_is_integer (element
))
694 fd
= scm_to_int (element
);
700 element
= SCM_COERCE_OUTPORT (element
);
701 SCM_ASSERT (SCM_OPFPORTP (element
), element
, pos
, "select");
704 /* check whether port has buffered input. */
705 scm_t_port
*pt
= SCM_PTAB_ENTRY (element
);
707 if (pt
->read_pos
< pt
->read_end
)
710 else if (pos
== SCM_ARG2
)
712 /* check whether port's output buffer has room. */
713 scm_t_port
*pt
= SCM_PTAB_ENTRY (element
);
715 /* > 1 since writing the last byte in the buffer causes flush. */
716 if (pt
->write_end
- pt
->write_pos
> 1)
719 fd
= use_buf
? -1 : SCM_FPORT_FDES (element
);
722 *ports_ready
= scm_cons (element
, *ports_ready
);
728 /* check list_or_vec, a list or vector of ports or file descriptors,
729 adding each member to either the ports_ready list (if it's a port
730 with a usable buffer) or to *set. the kind of list_or_vec can be
731 determined from pos: SCM_ARG1 for reads, SCM_ARG2 for writes,
732 SCM_ARG3 for excepts. */
734 fill_select_type (SELECT_TYPE
*set
, SCM
*ports_ready
, SCM list_or_vec
, int pos
)
738 if (scm_is_simple_vector (list_or_vec
))
740 int i
= SCM_SIMPLE_VECTOR_LENGTH (list_or_vec
);
744 int fd
= set_element (set
, ports_ready
,
745 SCM_SIMPLE_VECTOR_REF (list_or_vec
, i
), pos
);
753 while (!SCM_NULL_OR_NIL_P (list_or_vec
))
755 int fd
= set_element (set
, ports_ready
, SCM_CAR (list_or_vec
), pos
);
759 list_or_vec
= SCM_CDR (list_or_vec
);
766 /* if element (a file descriptor or port) appears in *set, cons it to
767 list. return list. */
769 get_element (SELECT_TYPE
*set
, SCM element
, SCM list
)
773 if (scm_is_integer (element
))
775 fd
= scm_to_int (element
);
779 fd
= SCM_FPORT_FDES (SCM_COERCE_OUTPORT (element
));
781 if (FD_ISSET (fd
, set
))
782 list
= scm_cons (element
, list
);
786 /* construct component of scm_select return value.
787 set: pointer to set of file descriptors found by select to be ready
788 ports_ready: ports ready due to buffering
789 list_or_vec: original list/vector handed to scm_select.
790 the return value is a list/vector of ready ports/file descriptors.
791 works by finding the objects in list which correspond to members of
792 *set and appending them to ports_ready. result is converted to a
793 vector if list_or_vec is a vector. */
795 retrieve_select_type (SELECT_TYPE
*set
, SCM ports_ready
, SCM list_or_vec
)
797 SCM answer_list
= ports_ready
;
799 if (scm_is_simple_vector (list_or_vec
))
801 int i
= SCM_SIMPLE_VECTOR_LENGTH (list_or_vec
);
805 answer_list
= get_element (set
,
806 SCM_SIMPLE_VECTOR_REF (list_or_vec
, i
),
809 return scm_vector (answer_list
);
813 /* list_or_vec must be a list. */
814 while (!SCM_NULL_OR_NIL_P (list_or_vec
))
816 answer_list
= get_element (set
, SCM_CAR (list_or_vec
), answer_list
);
817 list_or_vec
= SCM_CDR (list_or_vec
);
823 /* Static helper functions above refer to s_scm_select directly as s_select */
824 SCM_DEFINE (scm_select
, "select", 3, 2, 0,
825 (SCM reads
, SCM writes
, SCM excepts
, SCM secs
, SCM usecs
),
826 "This procedure has a variety of uses: waiting for the ability\n"
827 "to provide input, accept output, or the existence of\n"
828 "exceptional conditions on a collection of ports or file\n"
829 "descriptors, or waiting for a timeout to occur.\n"
830 "It also returns if interrupted by a signal.\n\n"
831 "@var{reads}, @var{writes} and @var{excepts} can be lists or\n"
832 "vectors, with each member a port or a file descriptor.\n"
833 "The value returned is a list of three corresponding\n"
834 "lists or vectors containing only the members which meet the\n"
835 "specified requirement. The ability of port buffers to\n"
836 "provide input or accept output is taken into account.\n"
837 "Ordering of the input lists or vectors is not preserved.\n\n"
838 "The optional arguments @var{secs} and @var{usecs} specify the\n"
839 "timeout. Either @var{secs} can be specified alone, as\n"
840 "either an integer or a real number, or both @var{secs} and\n"
841 "@var{usecs} can be specified as integers, in which case\n"
842 "@var{usecs} is an additional timeout expressed in\n"
843 "microseconds. If @var{secs} is omitted or is @code{#f} then\n"
844 "select will wait for as long as it takes for one of the other\n"
845 "conditions to be satisfied.\n\n"
846 "The scsh version of @code{select} differs as follows:\n"
847 "Only vectors are accepted for the first three arguments.\n"
848 "The @var{usecs} argument is not supported.\n"
849 "Multiple values are returned instead of a list.\n"
850 "Duplicates in the input vectors appear only once in output.\n"
851 "An additional @code{select!} interface is provided.")
852 #define FUNC_NAME s_scm_select
854 struct timeval timeout
;
855 struct timeval
* time_ptr
;
856 SELECT_TYPE read_set
;
857 SELECT_TYPE write_set
;
858 SELECT_TYPE except_set
;
862 /* these lists accumulate ports which are ready due to buffering.
863 their file descriptors don't need to be added to the select sets. */
864 SCM read_ports_ready
= SCM_EOL
;
865 SCM write_ports_ready
= SCM_EOL
;
868 if (scm_is_simple_vector (reads
))
870 read_count
= SCM_SIMPLE_VECTOR_LENGTH (reads
);
874 read_count
= scm_ilength (reads
);
875 SCM_ASSERT (read_count
>= 0, reads
, SCM_ARG1
, FUNC_NAME
);
877 if (scm_is_simple_vector (writes
))
879 write_count
= SCM_SIMPLE_VECTOR_LENGTH (writes
);
883 write_count
= scm_ilength (writes
);
884 SCM_ASSERT (write_count
>= 0, writes
, SCM_ARG2
, FUNC_NAME
);
886 if (scm_is_simple_vector (excepts
))
888 except_count
= SCM_SIMPLE_VECTOR_LENGTH (excepts
);
892 except_count
= scm_ilength (excepts
);
893 SCM_ASSERT (except_count
>= 0, excepts
, SCM_ARG3
, FUNC_NAME
);
897 FD_ZERO (&write_set
);
898 FD_ZERO (&except_set
);
900 max_fd
= fill_select_type (&read_set
, &read_ports_ready
, reads
, SCM_ARG1
);
903 int write_max
= fill_select_type (&write_set
, &write_ports_ready
,
905 int except_max
= fill_select_type (&except_set
, NULL
,
908 if (write_max
> max_fd
)
910 if (except_max
> max_fd
)
914 /* if there's a port with a ready buffer, don't block, just
915 check for ready file descriptors. */
916 if (!scm_is_null (read_ports_ready
) || !scm_is_null (write_ports_ready
))
922 else if (SCM_UNBNDP (secs
) || scm_is_false (secs
))
926 if (scm_is_unsigned_integer (secs
, 0, ULONG_MAX
))
928 timeout
.tv_sec
= scm_to_ulong (secs
);
929 if (SCM_UNBNDP (usecs
))
932 timeout
.tv_usec
= scm_to_long (usecs
);
936 double fl
= scm_to_double (secs
);
938 if (!SCM_UNBNDP (usecs
))
939 SCM_WRONG_TYPE_ARG (4, secs
);
941 SCM_OUT_OF_RANGE (4, secs
);
942 timeout
.tv_sec
= (long) fl
;
943 timeout
.tv_usec
= (long) ((fl
- timeout
.tv_sec
) * 1000000);
949 int rv
= scm_std_select (max_fd
+ 1,
950 &read_set
, &write_set
, &except_set
,
955 return scm_list_3 (retrieve_select_type (&read_set
, read_ports_ready
, reads
),
956 retrieve_select_type (&write_set
, write_ports_ready
, writes
),
957 retrieve_select_type (&except_set
, SCM_EOL
, excepts
));
960 #endif /* HAVE_SELECT */
965 SCM_DEFINE (scm_fcntl
, "fcntl", 2, 1, 0,
966 (SCM object
, SCM cmd
, SCM value
),
967 "Apply @var{command} to the specified file descriptor or the underlying\n"
968 "file descriptor of the specified port. @var{value} is an optional\n"
969 "integer argument.\n\n"
970 "Values for @var{command} are:\n\n"
973 "Duplicate a file descriptor\n"
975 "Get flags associated with the file descriptor.\n"
977 "Set flags associated with the file descriptor to @var{value}.\n"
979 "Get flags associated with the open file.\n"
981 "Set flags associated with the open file to @var{value}\n"
983 "Get the process ID of a socket's owner, for @code{SIGIO} signals.\n"
985 "Set the process that owns a socket to @var{value}, for @code{SIGIO} signals.\n"
987 "The value used to indicate the \"close on exec\" flag with @code{F_GETFL} or\n"
990 #define FUNC_NAME s_scm_fcntl
996 object
= SCM_COERCE_OUTPORT (object
);
998 if (SCM_OPFPORTP (object
))
999 fdes
= SCM_FPORT_FDES (object
);
1001 fdes
= scm_to_int (object
);
1003 if (SCM_UNBNDP (value
))
1006 ivalue
= scm_to_int (value
);
1008 SCM_SYSCALL (rv
= fcntl (fdes
, scm_to_int (cmd
), ivalue
));
1011 return scm_from_int (rv
);
1014 #endif /* HAVE_FCNTL */
1016 SCM_DEFINE (scm_fsync
, "fsync", 1, 0, 0,
1018 "Copies any unwritten data for the specified output file descriptor to disk.\n"
1019 "If @var{port/fd} is a port, its buffer is flushed before the underlying\n"
1020 "file descriptor is fsync'd.\n"
1021 "The return value is unspecified.")
1022 #define FUNC_NAME s_scm_fsync
1026 object
= SCM_COERCE_OUTPORT (object
);
1028 if (SCM_OPFPORTP (object
))
1031 fdes
= SCM_FPORT_FDES (object
);
1034 fdes
= scm_to_int (object
);
1036 if (fsync (fdes
) == -1)
1038 return SCM_UNSPECIFIED
;
1043 SCM_DEFINE (scm_symlink
, "symlink", 2, 0, 0,
1044 (SCM oldpath
, SCM newpath
),
1045 "Create a symbolic link named @var{path-to} with the value (i.e., pointing to)\n"
1046 "@var{path-from}. The return value is unspecified.")
1047 #define FUNC_NAME s_scm_symlink
1051 STRING2_SYSCALL (oldpath
, c_oldpath
,
1053 val
= symlink (c_oldpath
, c_newpath
));
1056 return SCM_UNSPECIFIED
;
1059 #endif /* HAVE_SYMLINK */
1061 #ifdef HAVE_READLINK
1062 SCM_DEFINE (scm_readlink
, "readlink", 1, 0, 0,
1064 "Return the value of the symbolic link named by @var{path} (a\n"
1065 "string), i.e., the file that the link points to.")
1066 #define FUNC_NAME s_scm_readlink
1074 scm_dynwind_begin (0);
1076 c_path
= scm_to_locale_string (path
);
1077 scm_dynwind_free (c_path
);
1079 buf
= scm_malloc (size
);
1081 while ((rv
= readlink (c_path
, buf
, size
)) == size
)
1085 buf
= scm_malloc (size
);
1089 int save_errno
= errno
;
1094 result
= scm_take_locale_stringn (buf
, rv
);
1100 #endif /* HAVE_READLINK */
1102 SCM_DEFINE (scm_copy_file
, "copy-file", 2, 0, 0,
1103 (SCM oldfile
, SCM newfile
),
1104 "Copy the file specified by @var{path-from} to @var{path-to}.\n"
1105 "The return value is unspecified.")
1106 #define FUNC_NAME s_scm_copy_file
1108 char *c_oldfile
, *c_newfile
;
1112 struct stat_or_stat64 oldstat
;
1114 scm_dynwind_begin (0);
1116 c_oldfile
= scm_to_locale_string (oldfile
);
1117 scm_dynwind_free (c_oldfile
);
1118 c_newfile
= scm_to_locale_string (newfile
);
1119 scm_dynwind_free (c_newfile
);
1121 oldfd
= open_or_open64 (c_oldfile
, O_RDONLY
);
1126 SCM_SYSCALL (rv
= fstat_Win32 (oldfd
, &oldstat
));
1128 SCM_SYSCALL (rv
= fstat_or_fstat64 (oldfd
, &oldstat
));
1131 goto err_close_oldfd
;
1133 /* use POSIX flags instead of 07777?. */
1134 newfd
= open_or_open64 (c_newfile
, O_WRONLY
| O_CREAT
| O_TRUNC
,
1135 oldstat
.st_mode
& 07777);
1143 while ((n
= read (oldfd
, buf
, sizeof buf
)) > 0)
1144 if (write (newfd
, buf
, n
) != n
)
1151 if (close (newfd
) == -1)
1155 return SCM_UNSPECIFIED
;
1159 #endif /* HAVE_POSIX */
1162 /* Essential procedures used in (system base compile). */
1165 SCM_DEFINE (scm_getcwd
, "getcwd", 0, 0, 0,
1167 "Return the name of the current working directory.")
1168 #define FUNC_NAME s_scm_getcwd
1175 wd
= scm_malloc (size
);
1176 while ((rv
= getcwd (wd
, size
)) == 0 && errno
== ERANGE
)
1180 wd
= scm_malloc (size
);
1184 int save_errno
= errno
;
1189 result
= scm_from_locale_stringn (wd
, strlen (wd
));
1194 #endif /* HAVE_GETCWD */
1197 SCM_DEFINE (scm_mkdir
, "mkdir", 1, 1, 0,
1198 (SCM path
, SCM mode
),
1199 "Create a new directory named by @var{path}. If @var{mode} is omitted\n"
1200 "then the permissions of the directory file are set using the current\n"
1201 "umask. Otherwise they are set to the decimal value specified with\n"
1202 "@var{mode}. The return value is unspecified.")
1203 #define FUNC_NAME s_scm_mkdir
1208 if (SCM_UNBNDP (mode
))
1212 STRING_SYSCALL (path
, c_path
, rv
= mkdir (c_path
, 0777 ^ mask
));
1216 STRING_SYSCALL (path
, c_path
, rv
= mkdir (c_path
, scm_to_uint (mode
)));
1220 return SCM_UNSPECIFIED
;
1223 #endif /* HAVE_MKDIR */
1226 SCM_DEFINE (scm_rmdir
, "rmdir", 1, 0, 0,
1228 "Remove the existing directory named by @var{path}. The directory must\n"
1229 "be empty for this to succeed. The return value is unspecified.")
1230 #define FUNC_NAME s_scm_rmdir
1234 STRING_SYSCALL (path
, c_path
, val
= rmdir (c_path
));
1237 return SCM_UNSPECIFIED
;
1243 #define my_rename rename
1246 my_rename (const char *oldname
, const char *newname
)
1250 SCM_SYSCALL (rv
= link (oldname
, newname
));
1253 SCM_SYSCALL (rv
= unlink (oldname
));
1255 /* unlink failed. remove new name */
1256 SCM_SYSCALL (unlink (newname
));
1262 SCM_DEFINE (scm_rename
, "rename-file", 2, 0, 0,
1263 (SCM oldname
, SCM newname
),
1264 "Renames the file specified by @var{oldname} to @var{newname}.\n"
1265 "The return value is unspecified.")
1266 #define FUNC_NAME s_scm_rename
1270 STRING2_SYSCALL (oldname
, c_oldname
,
1272 rv
= my_rename (c_oldname
, c_newname
));
1275 return SCM_UNSPECIFIED
;
1280 SCM_DEFINE (scm_delete_file
, "delete-file", 1, 0, 0,
1282 "Deletes (or \"unlinks\") the file specified by @var{path}.")
1283 #define FUNC_NAME s_scm_delete_file
1286 STRING_SYSCALL (str
, c_str
, ans
= unlink (c_str
));
1289 return SCM_UNSPECIFIED
;
1293 SCM_DEFINE (scm_access
, "access?", 2, 0, 0,
1294 (SCM path
, SCM how
),
1295 "Test accessibility of a file under the real UID and GID of the\n"
1296 "calling process. The return is @code{#t} if @var{path} exists\n"
1297 "and the permissions requested by @var{how} are all allowed, or\n"
1298 "@code{#f} if not.\n"
1300 "@var{how} is an integer which is one of the following values,\n"
1301 "or a bitwise-OR (@code{logior}) of multiple values.\n"
1304 "Test for read permission.\n"
1307 "Test for write permission.\n"
1310 "Test for execute permission.\n"
1313 "Test for existence of the file. This is implied by each of the\n"
1314 "other tests, so there's no need to combine it with them.\n"
1317 "It's important to note that @code{access?} does not simply\n"
1318 "indicate what will happen on attempting to read or write a\n"
1319 "file. In normal circumstances it does, but in a set-UID or\n"
1320 "set-GID program it doesn't because @code{access?} tests the\n"
1321 "real ID, whereas an open or execute attempt uses the effective\n"
1324 "A program which will never run set-UID/GID can ignore the\n"
1325 "difference between real and effective IDs, but for maximum\n"
1326 "generality, especially in library functions, it's best not to\n"
1327 "use @code{access?} to predict the result of an open or execute,\n"
1328 "instead simply attempt that and catch any exception.\n"
1330 "The main use for @code{access?} is to let a set-UID/GID program\n"
1331 "determine what the invoking user would have been allowed to do,\n"
1332 "without the greater (or perhaps lesser) privileges afforded by\n"
1333 "the effective ID. For more on this, see ``Testing File\n"
1334 "Access'' in The GNU C Library Reference Manual.")
1335 #define FUNC_NAME s_scm_access
1340 c_path
= scm_to_locale_string (path
);
1341 rv
= access (c_path
, scm_to_int (how
));
1344 return scm_from_bool (!rv
);
1348 SCM_DEFINE (scm_chmod
, "chmod", 2, 0, 0,
1349 (SCM object
, SCM mode
),
1350 "Changes the permissions of the file referred to by @var{obj}.\n"
1351 "@var{obj} can be a string containing a file name or a port or integer file\n"
1352 "descriptor which is open on a file (in which case @code{fchmod} is used\n"
1353 "as the underlying system call).\n"
1354 "@var{mode} specifies\n"
1355 "the new permissions as a decimal number, e.g., @code{(chmod \"foo\" #o755)}.\n"
1356 "The return value is unspecified.")
1357 #define FUNC_NAME s_scm_chmod
1362 object
= SCM_COERCE_OUTPORT (object
);
1364 if (scm_is_integer (object
) || SCM_OPFPORTP (object
))
1366 if (scm_is_integer (object
))
1367 fdes
= scm_to_int (object
);
1369 fdes
= SCM_FPORT_FDES (object
);
1370 SCM_SYSCALL (rv
= fchmod (fdes
, scm_to_int (mode
)));
1374 STRING_SYSCALL (object
, c_object
,
1375 rv
= chmod (c_object
, scm_to_int (mode
)));
1379 return SCM_UNSPECIFIED
;
1383 SCM_DEFINE (scm_umask
, "umask", 0, 1, 0,
1385 "If @var{mode} is omitted, returns a decimal number representing the current\n"
1386 "file creation mask. Otherwise the file creation mask is set to\n"
1387 "@var{mode} and the previous value is returned.\n\n"
1388 "E.g., @code{(umask #o022)} sets the mask to octal 22, decimal 18.")
1389 #define FUNC_NAME s_scm_umask
1392 if (SCM_UNBNDP (mode
))
1399 mask
= umask (scm_to_uint (mode
));
1401 return scm_from_uint (mask
);
1405 #ifndef HAVE_MKSTEMP
1406 extern int mkstemp (char *);
1409 SCM_DEFINE (scm_mkstemp
, "mkstemp!", 1, 0, 0,
1411 "Create a new unique file in the file system and return a new\n"
1412 "buffered port open for reading and writing to the file.\n"
1414 "@var{tmpl} is a string specifying where the file should be\n"
1415 "created: it must end with @samp{XXXXXX} and those @samp{X}s\n"
1416 "will be changed in the string to return the name of the file.\n"
1417 "(@code{port-filename} on the port also gives the name.)\n"
1419 "POSIX doesn't specify the permissions mode of the file, on GNU\n"
1420 "and most systems it's @code{#o600}. An application can use\n"
1421 "@code{chmod} to relax that if desired. For example\n"
1422 "@code{#o666} less @code{umask}, which is usual for ordinary\n"
1426 "(let ((port (mkstemp! (string-copy \"/tmp/myfile-XXXXXX\"))))\n"
1427 " (chmod port (logand #o666 (lognot (umask))))\n"
1430 #define FUNC_NAME s_scm_mkstemp
1435 scm_dynwind_begin (0);
1437 c_tmpl
= scm_to_locale_string (tmpl
);
1438 scm_dynwind_free (c_tmpl
);
1440 SCM_SYSCALL (rv
= mkstemp (c_tmpl
));
1444 scm_substring_move_x (scm_from_locale_string (c_tmpl
),
1445 SCM_INUM0
, scm_string_length (tmpl
),
1449 return scm_fdes_to_port (rv
, "w+", tmpl
);
1454 /* Filename manipulation */
1458 SCM_DEFINE (scm_dirname
, "dirname", 1, 0, 0,
1460 "Return the directory name component of the file name\n"
1461 "@var{filename}. If @var{filename} does not contain a directory\n"
1462 "component, @code{.} is returned.")
1463 #define FUNC_NAME s_scm_dirname
1466 unsigned long int len
;
1468 SCM_VALIDATE_STRING (1, filename
);
1470 len
= scm_i_string_length (filename
);
1474 while (i
>= 0 && (scm_i_string_ref (filename
, i
) == '/'
1475 || scm_i_string_ref (filename
, i
) == '\\'))
1477 while (i
>= 0 && (scm_i_string_ref (filename
, i
) != '/'
1478 && scm_i_string_ref (filename
, i
) != '\\'))
1480 while (i
>= 0 && (scm_i_string_ref (filename
, i
) == '/'
1481 || scm_i_string_ref (filename
, i
) == '\\'))
1484 while (i
>= 0 && scm_i_string_ref (filename
, i
) == '/')
1486 while (i
>= 0 && scm_i_string_ref (filename
, i
) != '/')
1488 while (i
>= 0 && scm_i_string_ref (filename
, i
) == '/')
1490 #endif /* ndef __MINGW32__ */
1494 if (len
> 0 && (scm_i_string_ref (filename
, 0) == '/'
1495 || scm_i_string_ref (filename
, 0) == '\\'))
1497 if (len
> 0 && scm_i_string_ref (filename
, 0) == '/')
1498 #endif /* ndef __MINGW32__ */
1499 return scm_c_substring (filename
, 0, 1);
1501 return scm_dot_string
;
1504 return scm_c_substring (filename
, 0, i
+ 1);
1508 SCM_DEFINE (scm_basename
, "basename", 1, 1, 0,
1509 (SCM filename
, SCM suffix
),
1510 "Return the base name of the file name @var{filename}. The\n"
1511 "base name is the file name without any directory components.\n"
1512 "If @var{suffix} is provided, and is equal to the end of\n"
1513 "@var{basename}, it is removed also.")
1514 #define FUNC_NAME s_scm_basename
1518 SCM_VALIDATE_STRING (1, filename
);
1519 len
= scm_i_string_length (filename
);
1521 if (SCM_UNBNDP (suffix
))
1525 SCM_VALIDATE_STRING (2, suffix
);
1526 j
= scm_i_string_length (suffix
) - 1;
1530 while (i
>= 0 && (scm_i_string_ref (filename
, i
) == '/'
1531 || scm_i_string_ref (filename
, i
) == '\\'))
1534 while (i
>= 0 && scm_i_string_ref (filename
, i
) == '/')
1536 #endif /* ndef __MINGW32__ */
1538 while (i
>= 0 && j
>= 0
1539 && (scm_i_string_ref (filename
, i
)
1540 == scm_i_string_ref (suffix
, j
)))
1548 while (i
>= 0 && (scm_i_string_ref (filename
, i
) != '/'
1549 && scm_i_string_ref (filename
, i
) != '\\'))
1552 while (i
>= 0 && scm_i_string_ref (filename
, i
) != '/')
1554 #endif /* ndef __MINGW32__ */
1558 if (len
> 0 && (scm_i_string_ref (filename
, 0) == '/'
1559 || scm_i_string_ref (filename
, 0) == '\\'))
1561 if (len
> 0 && scm_i_string_ref (filename
, 0) == '/')
1562 #endif /* ndef __MINGW32__ */
1563 return scm_c_substring (filename
, 0, 1);
1565 return scm_dot_string
;
1568 return scm_c_substring (filename
, i
+1, end
+1);
1572 SCM_DEFINE (scm_canonicalize_path
, "canonicalize-path", 1, 0, 0,
1574 "Return the canonical path of @var{path}. A canonical path has\n"
1575 "no @code{.} or @code{..} components, nor any repeated path\n"
1576 "separators (@code{/}) nor symlinks.\n\n"
1577 "Raises an error if any component of @var{path} does not exist.")
1578 #define FUNC_NAME s_scm_canonicalize_path
1582 SCM_VALIDATE_STRING (1, path
);
1584 str
= scm_to_locale_string (path
);
1585 canon
= canonicalize_file_name (str
);
1589 return scm_take_locale_string (canon
);
1596 scm_i_relativize_path (SCM path
, SCM in_path
)
1601 str
= scm_to_locale_string (path
);
1602 canon
= canonicalize_file_name (str
);
1608 scanon
= scm_take_locale_string (canon
);
1610 for (; scm_is_pair (in_path
); in_path
= scm_cdr (in_path
))
1611 if (scm_is_true (scm_string_prefix_p (scm_car (in_path
),
1613 SCM_UNDEFINED
, SCM_UNDEFINED
,
1614 SCM_UNDEFINED
, SCM_UNDEFINED
)))
1616 size_t len
= scm_c_string_length (scm_car (in_path
));
1618 /* The path either has a trailing delimiter or doesn't. scanon will be
1619 delimited by single delimiters. In the case in which the path does
1620 not have a trailing delimiter, add one to the length to strip off the
1621 delimiter within scanon. */
1624 || (scm_i_string_ref (scm_car (in_path
), len
- 1) != '/'
1625 && scm_i_string_ref (scm_car (in_path
), len
- 1) != '\\')
1627 || scm_i_string_ref (scm_car (in_path
), len
- 1) != '/'
1632 if (scm_c_string_length (scanon
) > len
)
1633 return scm_substring (scanon
, scm_from_size_t (len
), SCM_UNDEFINED
);
1642 /* Examining directories. These procedures are used by `check-guile'
1643 and thus compiled unconditionally. */
1645 scm_t_bits scm_tc16_dir
;
1648 SCM_DEFINE (scm_directory_stream_p
, "directory-stream?", 1, 0, 0,
1650 "Return a boolean indicating whether @var{object} is a directory\n"
1651 "stream as returned by @code{opendir}.")
1652 #define FUNC_NAME s_scm_directory_stream_p
1654 return scm_from_bool (SCM_DIRP (obj
));
1659 SCM_DEFINE (scm_opendir
, "opendir", 1, 0, 0,
1661 "Open the directory specified by @var{path} and return a directory\n"
1663 #define FUNC_NAME s_scm_opendir
1666 STRING_SYSCALL (dirname
, c_dirname
, ds
= opendir (c_dirname
));
1669 SCM_RETURN_NEWSMOB (scm_tc16_dir
| (SCM_DIR_FLAG_OPEN
<<16), ds
);
1674 /* FIXME: The glibc manual has a portability note that readdir_r may not
1675 null-terminate its return string. The circumstances outlined for this
1676 are not clear, nor is it clear what should be done about it. Lets use
1677 NAMLEN and worry about what else should be done if/when someone can
1680 SCM_DEFINE (scm_readdir
, "readdir", 1, 0, 0,
1682 "Return (as a string) the next directory entry from the directory stream\n"
1683 "@var{stream}. If there is no remaining entry to be read then the\n"
1684 "end of file object is returned.")
1685 #define FUNC_NAME s_scm_readdir
1687 struct dirent_or_dirent64
*rdent
;
1689 SCM_VALIDATE_DIR (1, port
);
1690 if (!SCM_DIR_OPEN_P (port
))
1691 SCM_MISC_ERROR ("Directory ~S is not open.", scm_list_1 (port
));
1694 /* As noted in the glibc manual, on various systems (such as Solaris) the
1695 d_name[] field is only 1 char and you're expected to size the dirent
1696 buffer for readdir_r based on NAME_MAX. The SCM_MAX expressions below
1697 effectively give either sizeof(d_name) or NAME_MAX+1, whichever is
1700 On solaris 10 there's no NAME_MAX constant, it's necessary to use
1701 pathconf(). We prefer NAME_MAX though, since it should be a constant
1702 and will therefore save a system call. We also prefer it since dirfd()
1703 is not available everywhere.
1705 An alternative to dirfd() would be to open() the directory and then use
1706 fdopendir(), if the latter is available. That'd let us hold the fd
1707 somewhere in the smob, or just the dirent size calculated once. */
1709 struct dirent_or_dirent64 de
; /* just for sizeof */
1710 DIR *ds
= (DIR *) SCM_SMOB_DATA_1 (port
);
1712 char buf
[SCM_MAX (sizeof (de
),
1713 sizeof (de
) - sizeof (de
.d_name
) + NAME_MAX
+ 1)];
1716 long name_max
= fpathconf (dirfd (ds
), _PC_NAME_MAX
);
1719 buf
= alloca (SCM_MAX (sizeof (de
),
1720 sizeof (de
) - sizeof (de
.d_name
) + name_max
+ 1));
1724 SCM_SYSCALL (readdir_r_or_readdir64_r (ds
, (struct dirent_or_dirent64
*) buf
, &rdent
));
1730 return (rdent
? scm_from_locale_stringn (rdent
->d_name
, NAMLEN (rdent
))
1736 scm_dynwind_begin (0);
1737 scm_i_dynwind_pthread_mutex_lock (&scm_i_misc_mutex
);
1740 SCM_SYSCALL (rdent
= readdir_or_readdir64 ((DIR *) SCM_SMOB_DATA_1 (port
)));
1744 ret
= (rdent
? scm_from_locale_stringn (rdent
->d_name
, NAMLEN (rdent
))
1755 SCM_DEFINE (scm_rewinddir
, "rewinddir", 1, 0, 0,
1757 "Reset the directory port @var{stream} so that the next call to\n"
1758 "@code{readdir} will return the first directory entry.")
1759 #define FUNC_NAME s_scm_rewinddir
1761 SCM_VALIDATE_DIR (1, port
);
1762 if (!SCM_DIR_OPEN_P (port
))
1763 SCM_MISC_ERROR ("Directory ~S is not open.", scm_list_1 (port
));
1765 rewinddir ((DIR *) SCM_SMOB_DATA_1 (port
));
1767 return SCM_UNSPECIFIED
;
1772 SCM_DEFINE (scm_closedir
, "closedir", 1, 0, 0,
1774 "Close the directory stream @var{stream}.\n"
1775 "The return value is unspecified.")
1776 #define FUNC_NAME s_scm_closedir
1778 SCM_VALIDATE_DIR (1, port
);
1780 if (SCM_DIR_OPEN_P (port
))
1784 SCM_SYSCALL (sts
= closedir ((DIR *) SCM_SMOB_DATA_1 (port
)));
1788 SCM_SET_SMOB_DATA_0 (port
, scm_tc16_dir
);
1791 return SCM_UNSPECIFIED
;
1798 scm_dir_print (SCM exp
, SCM port
, scm_print_state
*pstate SCM_UNUSED
)
1800 scm_puts ("#<", port
);
1801 if (!SCM_DIR_OPEN_P (exp
))
1802 scm_puts ("closed: ", port
);
1803 scm_puts ("directory stream ", port
);
1804 scm_uintprint (SCM_SMOB_DATA_1 (exp
), 16, port
);
1805 scm_putc ('>', port
);
1811 scm_dir_free (SCM p
)
1813 if (SCM_DIR_OPEN_P (p
))
1814 closedir ((DIR *) SCM_SMOB_DATA_1 (p
));
1825 scm_tc16_dir
= scm_make_smob_type ("directory", 0);
1826 scm_set_smob_free (scm_tc16_dir
, scm_dir_free
);
1827 scm_set_smob_print (scm_tc16_dir
, scm_dir_print
);
1830 scm_c_define ("O_RDONLY", scm_from_int (O_RDONLY
));
1833 scm_c_define ("O_WRONLY", scm_from_int (O_WRONLY
));
1836 scm_c_define ("O_RDWR", scm_from_int (O_RDWR
));
1839 scm_c_define ("O_CREAT", scm_from_int (O_CREAT
));
1842 scm_c_define ("O_EXCL", scm_from_int (O_EXCL
));
1845 scm_c_define ("O_NOCTTY", scm_from_int (O_NOCTTY
));
1848 scm_c_define ("O_TRUNC", scm_from_int (O_TRUNC
));
1851 scm_c_define ("O_APPEND", scm_from_int (O_APPEND
));
1854 scm_c_define ("O_NONBLOCK", scm_from_int (O_NONBLOCK
));
1857 scm_c_define ("O_NDELAY", scm_from_int (O_NDELAY
));
1860 scm_c_define ("O_SYNC", scm_from_int (O_SYNC
));
1863 scm_c_define ("O_LARGEFILE", scm_from_int (O_LARGEFILE
));
1866 scm_c_define ("O_NOTRANS", scm_from_int (O_NOTRANS
));
1870 scm_c_define ("F_DUPFD", scm_from_int (F_DUPFD
));
1873 scm_c_define ("F_GETFD", scm_from_int (F_GETFD
));
1876 scm_c_define ("F_SETFD", scm_from_int (F_SETFD
));
1879 scm_c_define ("F_GETFL", scm_from_int (F_GETFL
));
1882 scm_c_define ("F_SETFL", scm_from_int (F_SETFL
));
1885 scm_c_define ("F_GETOWN", scm_from_int (F_GETOWN
));
1888 scm_c_define ("F_SETOWN", scm_from_int (F_SETOWN
));
1891 scm_c_define ("FD_CLOEXEC", scm_from_int (FD_CLOEXEC
));
1893 #endif /* HAVE_POSIX */
1895 /* `access' symbols. */
1896 scm_c_define ("R_OK", scm_from_int (R_OK
));
1897 scm_c_define ("W_OK", scm_from_int (W_OK
));
1898 scm_c_define ("X_OK", scm_from_int (X_OK
));
1899 scm_c_define ("F_OK", scm_from_int (F_OK
));
1901 scm_dot_string
= scm_from_locale_string (".");
1903 #include "libguile/filesys.x"