1 /* Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2004, 2006,
2 * 2009, 2010, 2011, 2012, 2013, 2014 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>
76 #ifdef LIBC_H_WITH_UNISTD_H
80 #include <sys/select.h>
86 #include <sys/types.h>
96 #define NAMLEN(dirent) strlen ((dirent)->d_name)
98 #ifdef HAVE_SYS_SENDFILE_H
99 # include <sys/sendfile.h>
102 /* Glibc's `sendfile' function. */
103 #define sendfile_or_sendfile64 \
104 CHOOSE_LARGEFILE (sendfile, sendfile64)
106 #include <full-read.h>
107 #include <full-write.h>
112 /* Two helper macros for an often used pattern */
114 #define STRING_SYSCALL(str,cstr,code) \
117 char *cstr = scm_to_locale_string (str); \
118 SCM_SYSCALL (code); \
119 eno = errno; free (cstr); errno = eno; \
122 #define STRING2_SYSCALL(str1,cstr1,str2,cstr2,code) \
125 char *cstr1, *cstr2; \
126 scm_dynwind_begin (0); \
127 cstr1 = scm_to_locale_string (str1); \
128 scm_dynwind_free (cstr1); \
129 cstr2 = scm_to_locale_string (str2); \
130 scm_dynwind_free (cstr2); \
131 SCM_SYSCALL (code); \
132 eno = errno; scm_dynwind_end (); errno = eno; \
136 #define MAX(A, B) ((A) > (B) ? (A) : (B))
137 #define MIN(A, B) ((A) < (B) ? (A) : (B))
147 SCM_DEFINE (scm_chown
, "chown", 3, 0, 0,
148 (SCM object
, SCM owner
, SCM group
),
149 "Change the ownership and group of the file referred to by @var{object} to\n"
150 "the integer values @var{owner} and @var{group}. @var{object} can be\n"
151 "a string containing a file name or, if the platform\n"
152 "supports fchown, a port or integer file descriptor\n"
153 "which is open on the file. The return value\n"
154 "is unspecified.\n\n"
155 "If @var{object} is a symbolic link, either the\n"
156 "ownership of the link or the ownership of the referenced file will be\n"
157 "changed depending on the operating system (lchown is\n"
158 "unsupported at present). If @var{owner} or @var{group} is specified\n"
159 "as @code{-1}, then that ID is not changed.")
160 #define FUNC_NAME s_scm_chown
164 object
= SCM_COERCE_OUTPORT (object
);
167 if (scm_is_integer (object
) || (SCM_OPFPORTP (object
)))
169 int fdes
= (SCM_OPFPORTP (object
)?
170 SCM_FPORT_FDES (object
) : scm_to_int (object
));
172 SCM_SYSCALL (rv
= fchown (fdes
, scm_to_int (owner
), scm_to_int (group
)));
177 STRING_SYSCALL (object
, c_object
,
178 rv
= chown (c_object
,
179 scm_to_int (owner
), scm_to_int (group
)));
183 return SCM_UNSPECIFIED
;
186 #endif /* HAVE_CHOWN */
190 SCM_DEFINE (scm_open_fdes
, "open-fdes", 2, 1, 0,
191 (SCM path
, SCM flags
, SCM mode
),
192 "Similar to @code{open} but return a file descriptor instead of\n"
194 #define FUNC_NAME s_scm_open_fdes
200 iflags
= SCM_NUM2INT (2, flags
);
201 imode
= SCM_NUM2INT_DEF (3, mode
, 0666);
202 STRING_SYSCALL (path
, c_path
, fd
= open_or_open64 (c_path
, iflags
, imode
));
205 return scm_from_int (fd
);
209 SCM_DEFINE (scm_open
, "open", 2, 1, 0,
210 (SCM path
, SCM flags
, SCM mode
),
211 "Open the file named by @var{path} for reading and/or writing.\n"
212 "@var{flags} is an integer specifying how the file should be opened.\n"
213 "@var{mode} is an integer specifying the permission bits of the file, if\n"
214 "it needs to be created, before the umask is applied. The default is 666\n"
215 "(Unix itself has no default).\n\n"
216 "@var{flags} can be constructed by combining variables using @code{logior}.\n"
217 "Basic flags are:\n\n"
219 "Open the file read-only.\n"
222 "Open the file write-only.\n"
225 "Open the file read/write.\n"
228 "Append to the file instead of truncating.\n"
231 "Create the file if it does not already exist.\n"
233 "See the Unix documentation of the @code{open} system call\n"
234 "for additional flags.")
235 #define FUNC_NAME s_scm_open
242 fd
= scm_to_int (scm_open_fdes (path
, flags
, mode
));
243 iflags
= SCM_NUM2INT (2, flags
);
245 if ((iflags
& O_RDWR
) == O_RDWR
)
247 /* Opened read-write. */
248 if (iflags
& O_APPEND
)
250 else if (iflags
& O_CREAT
)
257 /* Opened read-only or write-only. */
258 if (iflags
& O_APPEND
)
260 else if (iflags
& O_WRONLY
)
266 newpt
= scm_fdes_to_port (fd
, port_mode
, path
);
271 SCM_DEFINE (scm_close
, "close", 1, 0, 0,
273 "Similar to close-port (@pxref{Closing, close-port}),\n"
274 "but also works on file descriptors. A side\n"
275 "effect of closing a file descriptor is that any ports using that file\n"
276 "descriptor are moved to a different file descriptor and have\n"
277 "their revealed counts set to zero.")
278 #define FUNC_NAME s_scm_close
283 fd_or_port
= SCM_COERCE_OUTPORT (fd_or_port
);
285 if (SCM_PORTP (fd_or_port
))
286 return scm_close_port (fd_or_port
);
287 fd
= scm_to_int (fd_or_port
);
288 scm_evict_ports (fd
); /* see scsh manual. */
289 SCM_SYSCALL (rv
= close (fd
));
290 /* following scsh, closing an already closed file descriptor is
292 if (rv
< 0 && errno
!= EBADF
)
294 return scm_from_bool (rv
>= 0);
298 SCM_DEFINE (scm_close_fdes
, "close-fdes", 1, 0, 0,
300 "A simple wrapper for the @code{close} system call.\n"
301 "Close file descriptor @var{fd}, which must be an integer.\n"
302 "Unlike close (@pxref{Ports and File Descriptors, close}),\n"
303 "the file descriptor will be closed even if a port is using it.\n"
304 "The return value is unspecified.")
305 #define FUNC_NAME s_scm_close_fdes
310 c_fd
= scm_to_int (fd
);
311 SCM_SYSCALL (rv
= close (c_fd
));
314 return SCM_UNSPECIFIED
;
318 #endif /* HAVE_POSIX */
324 SCM_SYMBOL (scm_sym_regular
, "regular");
325 SCM_SYMBOL (scm_sym_directory
, "directory");
327 SCM_SYMBOL (scm_sym_symlink
, "symlink");
329 SCM_SYMBOL (scm_sym_block_special
, "block-special");
330 SCM_SYMBOL (scm_sym_char_special
, "char-special");
331 SCM_SYMBOL (scm_sym_fifo
, "fifo");
332 SCM_SYMBOL (scm_sym_sock
, "socket");
333 SCM_SYMBOL (scm_sym_unknown
, "unknown");
336 scm_stat2scm (struct stat_or_stat64
*stat_temp
)
338 SCM ans
= scm_c_make_vector (18, SCM_UNSPECIFIED
);
340 SCM_SIMPLE_VECTOR_SET(ans
, 0, scm_from_ulong (stat_temp
->st_dev
));
341 SCM_SIMPLE_VECTOR_SET(ans
, 1, scm_from_ino_t_or_ino64_t (stat_temp
->st_ino
));
342 SCM_SIMPLE_VECTOR_SET(ans
, 2, scm_from_ulong (stat_temp
->st_mode
));
343 SCM_SIMPLE_VECTOR_SET(ans
, 3, scm_from_ulong (stat_temp
->st_nlink
));
344 SCM_SIMPLE_VECTOR_SET(ans
, 4, scm_from_ulong (stat_temp
->st_uid
));
345 SCM_SIMPLE_VECTOR_SET(ans
, 5, scm_from_ulong (stat_temp
->st_gid
));
346 #ifdef HAVE_STRUCT_STAT_ST_RDEV
347 SCM_SIMPLE_VECTOR_SET(ans
, 6, scm_from_ulong (stat_temp
->st_rdev
));
349 SCM_SIMPLE_VECTOR_SET(ans
, 6, SCM_BOOL_F
);
351 SCM_SIMPLE_VECTOR_SET(ans
, 7, scm_from_off_t_or_off64_t (stat_temp
->st_size
));
352 SCM_SIMPLE_VECTOR_SET(ans
, 8, scm_from_ulong (stat_temp
->st_atime
));
353 SCM_SIMPLE_VECTOR_SET(ans
, 9, scm_from_ulong (stat_temp
->st_mtime
));
354 SCM_SIMPLE_VECTOR_SET(ans
, 10, scm_from_ulong (stat_temp
->st_ctime
));
355 #ifdef HAVE_STRUCT_STAT_ST_BLKSIZE
356 SCM_SIMPLE_VECTOR_SET(ans
, 11, scm_from_ulong (stat_temp
->st_blksize
));
358 SCM_SIMPLE_VECTOR_SET(ans
, 11, scm_from_ulong (4096L));
360 #ifdef HAVE_STRUCT_STAT_ST_BLOCKS
361 SCM_SIMPLE_VECTOR_SET(ans
, 12, scm_from_blkcnt_t_or_blkcnt64_t (stat_temp
->st_blocks
));
363 SCM_SIMPLE_VECTOR_SET(ans
, 12, SCM_BOOL_F
);
366 int mode
= stat_temp
->st_mode
;
369 SCM_SIMPLE_VECTOR_SET(ans
, 13, scm_sym_regular
);
370 else if (S_ISDIR (mode
))
371 SCM_SIMPLE_VECTOR_SET(ans
, 13, scm_sym_directory
);
373 /* systems without symlinks probably don't have S_ISLNK */
374 else if (S_ISLNK (mode
))
375 SCM_SIMPLE_VECTOR_SET(ans
, 13, scm_sym_symlink
);
377 else if (S_ISBLK (mode
))
378 SCM_SIMPLE_VECTOR_SET(ans
, 13, scm_sym_block_special
);
379 else if (S_ISCHR (mode
))
380 SCM_SIMPLE_VECTOR_SET(ans
, 13, scm_sym_char_special
);
381 else if (S_ISFIFO (mode
))
382 SCM_SIMPLE_VECTOR_SET(ans
, 13, scm_sym_fifo
);
384 else if (S_ISSOCK (mode
))
385 SCM_SIMPLE_VECTOR_SET(ans
, 13, scm_sym_sock
);
388 SCM_SIMPLE_VECTOR_SET(ans
, 13, scm_sym_unknown
);
390 SCM_SIMPLE_VECTOR_SET(ans
, 14, scm_from_int ((~S_IFMT
) & mode
));
392 /* the layout of the bits in ve[14] is intended to be portable.
393 If there are systems that don't follow the usual convention,
394 the following could be used:
397 if (S_ISUID & mode) tmp += 1;
399 if (S_IRGRP & mode) tmp += 1;
401 if (S_ISVTX & mode) tmp += 1;
403 if (S_IRUSR & mode) tmp += 1;
405 if (S_IWUSR & mode) tmp += 1;
407 if (S_IXUSR & mode) tmp += 1;
409 if (S_IWGRP & mode) tmp += 1;
411 if (S_IXGRP & mode) tmp += 1;
413 if (S_IROTH & mode) tmp += 1;
415 if (S_IWOTH & mode) tmp += 1;
417 if (S_IXOTH & mode) tmp += 1;
419 SCM_SIMPLE_VECTOR_SET(ans, 14, scm_from_int (tmp));
423 #ifdef HAVE_STRUCT_STAT_ST_ATIM
424 SCM_SIMPLE_VECTOR_SET(ans
, 15, scm_from_long (stat_temp
->st_atim
.tv_nsec
));
426 SCM_SIMPLE_VECTOR_SET(ans
, 15, SCM_I_MAKINUM (0));
428 #ifdef HAVE_STRUCT_STAT_ST_MTIM
429 SCM_SIMPLE_VECTOR_SET(ans
, 16, scm_from_long (stat_temp
->st_mtim
.tv_nsec
));
431 SCM_SIMPLE_VECTOR_SET(ans
, 16, SCM_I_MAKINUM (0));
433 #ifdef HAVE_STRUCT_STAT_ST_CTIM
434 SCM_SIMPLE_VECTOR_SET(ans
, 17, scm_from_ulong (stat_temp
->st_ctim
.tv_sec
));
436 SCM_SIMPLE_VECTOR_SET(ans
, 17, SCM_I_MAKINUM (0));
443 is_file_name_separator (SCM c
)
445 if (scm_is_eq (c
, SCM_MAKE_CHAR ('/')))
448 if (scm_is_eq (c
, SCM_MAKE_CHAR ('\\')))
454 SCM_DEFINE (scm_stat
, "stat", 1, 1, 0,
455 (SCM object
, SCM exception_on_error
),
456 "Return an object containing various information about the file\n"
457 "determined by @var{object}. @var{object} can be a string containing\n"
458 "a file name or a port or integer file descriptor which is open\n"
459 "on a file (in which case @code{fstat} is used as the underlying\n"
462 "If the optional @var{exception_on_error} argument is true, which\n"
463 "is the default, an exception will be raised if the underlying\n"
464 "system call returns an error, for example if the file is not\n"
465 "found or is not readable. Otherwise, an error will cause\n"
466 "@code{stat} to return @code{#f}."
468 "The object returned by a successful call to @code{stat} can be\n"
469 "passed as a single parameter to the following procedures, all of\n"
470 "which return integers:\n"
474 "The device containing the file.\n"
476 "The file serial number, which distinguishes this file from all\n"
477 "other files on the same device.\n"
479 "The mode of the file. This includes file type information and\n"
480 "the file permission bits. See @code{stat:type} and\n"
481 "@code{stat:perms} below.\n"
483 "The number of hard links to the file.\n"
485 "The user ID of the file's owner.\n"
487 "The group ID of the file.\n"
489 "Device ID; this entry is defined only for character or block\n"
492 "The size of a regular file in bytes.\n"
494 "The last access time for the file.\n"
496 "The last modification time for the file.\n"
498 "The last modification time for the attributes of the file.\n"
499 "@item stat:blksize\n"
500 "The optimal block size for reading or writing the file, in\n"
502 "@item stat:blocks\n"
503 "The amount of disk space that the file occupies measured in\n"
504 "units of 512 byte blocks.\n"
507 "In addition, the following procedures return the information\n"
508 "from stat:mode in a more convenient form:\n"
512 "A symbol representing the type of file. Possible values are\n"
513 "regular, directory, symlink, block-special, char-special, fifo,\n"
514 "socket and unknown\n"
516 "An integer representing the access permission bits.\n"
518 #define FUNC_NAME s_scm_stat
522 struct stat_or_stat64 stat_temp
;
524 if (scm_is_integer (object
))
526 SCM_SYSCALL (rv
= fstat_or_fstat64 (scm_to_int (object
), &stat_temp
));
528 else if (scm_is_string (object
))
530 char *file
= scm_to_locale_string (object
);
531 SCM_SYSCALL (rv
= stat_or_stat64 (file
, &stat_temp
));
536 object
= SCM_COERCE_OUTPORT (object
);
537 SCM_VALIDATE_OPFPORT (1, object
);
538 fdes
= SCM_FPORT_FDES (object
);
539 SCM_SYSCALL (rv
= fstat_or_fstat64 (fdes
, &stat_temp
));
544 if (SCM_UNBNDP (exception_on_error
) || scm_is_true (exception_on_error
))
547 SCM_SYSERROR_MSG ("~A: ~S",
548 scm_list_2 (scm_strerror (scm_from_int (en
)),
555 return scm_stat2scm (&stat_temp
);
559 SCM_DEFINE (scm_lstat
, "lstat", 1, 0, 0,
561 "Similar to @code{stat}, but does not follow symbolic links, i.e.,\n"
562 "it will return information about a symbolic link itself, not the\n"
563 "file it points to. @var{str} must be a string.")
564 #define FUNC_NAME s_scm_lstat
567 struct stat_or_stat64 stat_temp
;
569 STRING_SYSCALL (str
, c_str
, rv
= lstat_or_lstat64 (c_str
, &stat_temp
));
574 SCM_SYSERROR_MSG ("~A: ~S",
575 scm_list_2 (scm_strerror (scm_from_int (en
)), str
),
578 return scm_stat2scm (&stat_temp
);
585 /* {Modifying Directories}
588 SCM_DEFINE (scm_link
, "link", 2, 0, 0,
589 (SCM oldpath
, SCM newpath
),
590 "Creates a new name @var{newpath} in the file system for the\n"
591 "file named by @var{oldpath}. If @var{oldpath} is a symbolic\n"
592 "link, the link may or may not be followed depending on the\n"
594 #define FUNC_NAME s_scm_link
598 STRING2_SYSCALL (oldpath
, c_oldpath
,
600 val
= link (c_oldpath
, c_newpath
));
603 return SCM_UNSPECIFIED
;
608 /* {Navigating Directories}
612 SCM_DEFINE (scm_chdir
, "chdir", 1, 0, 0,
614 "Change the current working directory to @var{str}.\n"
615 "The return value is unspecified.")
616 #define FUNC_NAME s_scm_chdir
620 STRING_SYSCALL (str
, c_str
, ans
= chdir (c_str
));
623 return SCM_UNSPECIFIED
;
629 /* check that element is a port or file descriptor. if it's a port
630 and its buffer is ready for use, add it to the ports_ready list.
631 otherwise add its file descriptor to *set. the type of list can be
632 determined from pos: SCM_ARG1 for reads, SCM_ARG2 for writes,
633 SCM_ARG3 for excepts. */
635 set_element (fd_set
*set
, SCM
*ports_ready
, SCM element
, int pos
)
639 if (scm_is_integer (element
))
641 fd
= scm_to_int (element
);
647 element
= SCM_COERCE_OUTPORT (element
);
648 SCM_ASSERT (SCM_OPFPORTP (element
), element
, pos
, "select");
651 /* check whether port has buffered input. */
652 scm_t_port
*pt
= SCM_PTAB_ENTRY (element
);
654 if (pt
->read_pos
< pt
->read_end
)
657 else if (pos
== SCM_ARG2
)
659 /* check whether port's output buffer has room. */
660 scm_t_port
*pt
= SCM_PTAB_ENTRY (element
);
662 /* > 1 since writing the last byte in the buffer causes flush. */
663 if (pt
->write_end
- pt
->write_pos
> 1)
666 fd
= use_buf
? -1 : SCM_FPORT_FDES (element
);
669 *ports_ready
= scm_cons (element
, *ports_ready
);
675 /* check list_or_vec, a list or vector of ports or file descriptors,
676 adding each member to either the ports_ready list (if it's a port
677 with a usable buffer) or to *set. the kind of list_or_vec can be
678 determined from pos: SCM_ARG1 for reads, SCM_ARG2 for writes,
679 SCM_ARG3 for excepts. */
681 fill_select_type (fd_set
*set
, SCM
*ports_ready
, SCM list_or_vec
, int pos
)
685 if (scm_is_vector (list_or_vec
))
687 int i
= SCM_SIMPLE_VECTOR_LENGTH (list_or_vec
);
691 int fd
= set_element (set
, ports_ready
,
692 SCM_SIMPLE_VECTOR_REF (list_or_vec
, i
), pos
);
700 while (!SCM_NULL_OR_NIL_P (list_or_vec
))
702 int fd
= set_element (set
, ports_ready
, SCM_CAR (list_or_vec
), pos
);
706 list_or_vec
= SCM_CDR (list_or_vec
);
713 /* if element (a file descriptor or port) appears in *set, cons it to
714 list. return list. */
716 get_element (fd_set
*set
, SCM element
, SCM list
)
720 if (scm_is_integer (element
))
722 fd
= scm_to_int (element
);
726 fd
= SCM_FPORT_FDES (SCM_COERCE_OUTPORT (element
));
728 if (FD_ISSET (fd
, set
))
729 list
= scm_cons (element
, list
);
733 /* construct component of scm_select return value.
734 set: pointer to set of file descriptors found by select to be ready
735 ports_ready: ports ready due to buffering
736 list_or_vec: original list/vector handed to scm_select.
737 the return value is a list/vector of ready ports/file descriptors.
738 works by finding the objects in list which correspond to members of
739 *set and appending them to ports_ready. result is converted to a
740 vector if list_or_vec is a vector. */
742 retrieve_select_type (fd_set
*set
, SCM ports_ready
, SCM list_or_vec
)
744 SCM answer_list
= ports_ready
;
746 if (scm_is_vector (list_or_vec
))
748 int i
= SCM_SIMPLE_VECTOR_LENGTH (list_or_vec
);
752 answer_list
= get_element (set
,
753 SCM_SIMPLE_VECTOR_REF (list_or_vec
, i
),
756 return scm_vector (answer_list
);
760 /* list_or_vec must be a list. */
761 while (!SCM_NULL_OR_NIL_P (list_or_vec
))
763 answer_list
= get_element (set
, SCM_CAR (list_or_vec
), answer_list
);
764 list_or_vec
= SCM_CDR (list_or_vec
);
770 /* Static helper functions above refer to s_scm_select directly as s_select */
771 SCM_DEFINE (scm_select
, "select", 3, 2, 0,
772 (SCM reads
, SCM writes
, SCM excepts
, SCM secs
, SCM usecs
),
773 "This procedure has a variety of uses: waiting for the ability\n"
774 "to provide input, accept output, or the existence of\n"
775 "exceptional conditions on a collection of ports or file\n"
776 "descriptors, or waiting for a timeout to occur.\n"
777 "It also returns if interrupted by a signal.\n\n"
778 "@var{reads}, @var{writes} and @var{excepts} can be lists or\n"
779 "vectors, with each member a port or a file descriptor.\n"
780 "The value returned is a list of three corresponding\n"
781 "lists or vectors containing only the members which meet the\n"
782 "specified requirement. The ability of port buffers to\n"
783 "provide input or accept output is taken into account.\n"
784 "Ordering of the input lists or vectors is not preserved.\n\n"
785 "The optional arguments @var{secs} and @var{usecs} specify the\n"
786 "timeout. Either @var{secs} can be specified alone, as\n"
787 "either an integer or a real number, or both @var{secs} and\n"
788 "@var{usecs} can be specified as integers, in which case\n"
789 "@var{usecs} is an additional timeout expressed in\n"
790 "microseconds. If @var{secs} is omitted or is @code{#f} then\n"
791 "select will wait for as long as it takes for one of the other\n"
792 "conditions to be satisfied.\n\n"
793 "The scsh version of @code{select} differs as follows:\n"
794 "Only vectors are accepted for the first three arguments.\n"
795 "The @var{usecs} argument is not supported.\n"
796 "Multiple values are returned instead of a list.\n"
797 "Duplicates in the input vectors appear only once in output.\n"
798 "An additional @code{select!} interface is provided.")
799 #define FUNC_NAME s_scm_select
801 struct timeval timeout
;
802 struct timeval
* time_ptr
;
809 /* these lists accumulate ports which are ready due to buffering.
810 their file descriptors don't need to be added to the select sets. */
811 SCM read_ports_ready
= SCM_EOL
;
812 SCM write_ports_ready
= SCM_EOL
;
815 if (scm_is_vector (reads
))
817 read_count
= SCM_SIMPLE_VECTOR_LENGTH (reads
);
821 read_count
= scm_ilength (reads
);
822 SCM_ASSERT (read_count
>= 0, reads
, SCM_ARG1
, FUNC_NAME
);
824 if (scm_is_vector (writes
))
826 write_count
= SCM_SIMPLE_VECTOR_LENGTH (writes
);
830 write_count
= scm_ilength (writes
);
831 SCM_ASSERT (write_count
>= 0, writes
, SCM_ARG2
, FUNC_NAME
);
833 if (scm_is_vector (excepts
))
835 except_count
= SCM_SIMPLE_VECTOR_LENGTH (excepts
);
839 except_count
= scm_ilength (excepts
);
840 SCM_ASSERT (except_count
>= 0, excepts
, SCM_ARG3
, FUNC_NAME
);
844 FD_ZERO (&write_set
);
845 FD_ZERO (&except_set
);
847 max_fd
= fill_select_type (&read_set
, &read_ports_ready
, reads
, SCM_ARG1
);
850 int write_max
= fill_select_type (&write_set
, &write_ports_ready
,
852 int except_max
= fill_select_type (&except_set
, NULL
,
855 if (write_max
> max_fd
)
857 if (except_max
> max_fd
)
861 /* if there's a port with a ready buffer, don't block, just
862 check for ready file descriptors. */
863 if (!scm_is_null (read_ports_ready
) || !scm_is_null (write_ports_ready
))
869 else if (SCM_UNBNDP (secs
) || scm_is_false (secs
))
873 if (scm_is_unsigned_integer (secs
, 0, ULONG_MAX
))
875 timeout
.tv_sec
= scm_to_ulong (secs
);
876 if (SCM_UNBNDP (usecs
))
879 timeout
.tv_usec
= scm_to_long (usecs
);
883 double fl
= scm_to_double (secs
);
885 if (!SCM_UNBNDP (usecs
))
886 SCM_WRONG_TYPE_ARG (4, secs
);
888 SCM_OUT_OF_RANGE (4, secs
);
889 timeout
.tv_sec
= (long) fl
;
890 timeout
.tv_usec
= (long) ((fl
- timeout
.tv_sec
) * 1000000);
896 int rv
= select (max_fd
+ 1,
897 &read_set
, &write_set
, &except_set
,
902 return scm_list_3 (retrieve_select_type (&read_set
, read_ports_ready
, reads
),
903 retrieve_select_type (&write_set
, write_ports_ready
, writes
),
904 retrieve_select_type (&except_set
, SCM_EOL
, excepts
));
911 SCM_DEFINE (scm_fcntl
, "fcntl", 2, 1, 0,
912 (SCM object
, SCM cmd
, SCM value
),
913 "Apply @var{cmd} to the specified file descriptor or the underlying\n"
914 "file descriptor of the specified port. @var{value} is an optional\n"
915 "integer argument.\n\n"
916 "Values for @var{cmd} are:\n\n"
919 "Duplicate a file descriptor\n"
921 "Get flags associated with the file descriptor.\n"
923 "Set flags associated with the file descriptor to @var{value}.\n"
925 "Get flags associated with the open file.\n"
927 "Set flags associated with the open file to @var{value}\n"
929 "Get the process ID of a socket's owner, for @code{SIGIO} signals.\n"
931 "Set the process that owns a socket to @var{value}, for @code{SIGIO} signals.\n"
933 "The value used to indicate the \"close on exec\" flag with @code{F_GETFL} or\n"
936 #define FUNC_NAME s_scm_fcntl
942 object
= SCM_COERCE_OUTPORT (object
);
944 if (SCM_OPFPORTP (object
))
945 fdes
= SCM_FPORT_FDES (object
);
947 fdes
= scm_to_int (object
);
949 if (SCM_UNBNDP (value
))
952 ivalue
= scm_to_int (value
);
954 SCM_SYSCALL (rv
= fcntl (fdes
, scm_to_int (cmd
), ivalue
));
957 return scm_from_int (rv
);
960 #endif /* HAVE_FCNTL */
962 SCM_DEFINE (scm_fsync
, "fsync", 1, 0, 0,
964 "Copies any unwritten data for the specified output file\n"
965 "descriptor to disk. If @var{object} is a port, its buffer is\n"
966 "flushed before the underlying file descriptor is fsync'd.\n"
967 "The return value is unspecified.")
968 #define FUNC_NAME s_scm_fsync
972 object
= SCM_COERCE_OUTPORT (object
);
974 if (SCM_OPFPORTP (object
))
976 scm_flush_unlocked (object
);
977 fdes
= SCM_FPORT_FDES (object
);
980 fdes
= scm_to_int (object
);
982 if (fsync (fdes
) == -1)
984 return SCM_UNSPECIFIED
;
989 SCM_DEFINE (scm_symlink
, "symlink", 2, 0, 0,
990 (SCM oldpath
, SCM newpath
),
991 "Create a symbolic link named @var{oldpath} with the value\n"
992 "(i.e., pointing to) @var{newpath}. The return value is\n"
994 #define FUNC_NAME s_scm_symlink
998 STRING2_SYSCALL (oldpath
, c_oldpath
,
1000 val
= symlink (c_oldpath
, c_newpath
));
1003 return SCM_UNSPECIFIED
;
1006 #endif /* HAVE_SYMLINK */
1008 SCM_DEFINE (scm_readlink
, "readlink", 1, 0, 0,
1010 "Return the value of the symbolic link named by @var{path} (a\n"
1011 "string), i.e., the file that the link points to.")
1012 #define FUNC_NAME s_scm_readlink
1020 scm_dynwind_begin (0);
1022 c_path
= scm_to_locale_string (path
);
1023 scm_dynwind_free (c_path
);
1025 buf
= scm_malloc (size
);
1027 while ((rv
= readlink (c_path
, buf
, size
)) == size
)
1031 buf
= scm_malloc (size
);
1035 int save_errno
= errno
;
1040 result
= scm_take_locale_stringn (buf
, rv
);
1047 SCM_DEFINE (scm_copy_file
, "copy-file", 2, 0, 0,
1048 (SCM oldfile
, SCM newfile
),
1049 "Copy the file specified by @var{oldfile} to @var{newfile}.\n"
1050 "The return value is unspecified.")
1051 #define FUNC_NAME s_scm_copy_file
1053 char *c_oldfile
, *c_newfile
;
1057 struct stat_or_stat64 oldstat
;
1059 scm_dynwind_begin (0);
1061 c_oldfile
= scm_to_locale_string (oldfile
);
1062 scm_dynwind_free (c_oldfile
);
1063 c_newfile
= scm_to_locale_string (newfile
);
1064 scm_dynwind_free (c_newfile
);
1066 oldfd
= open_or_open64 (c_oldfile
, O_RDONLY
| O_BINARY
);
1070 SCM_SYSCALL (rv
= fstat_or_fstat64 (oldfd
, &oldstat
));
1072 goto err_close_oldfd
;
1074 /* use POSIX flags instead of 07777?. */
1075 newfd
= open_or_open64 (c_newfile
, O_WRONLY
| O_CREAT
| O_TRUNC
,
1076 oldstat
.st_mode
& 07777);
1084 while ((n
= read (oldfd
, buf
, sizeof buf
)) > 0)
1085 if (write (newfd
, buf
, n
) != n
)
1092 if (close (newfd
) == -1)
1096 return SCM_UNSPECIFIED
;
1100 SCM_DEFINE (scm_sendfile
, "sendfile", 3, 1, 0,
1101 (SCM out
, SCM in
, SCM count
, SCM offset
),
1102 "Send @var{count} bytes from @var{in} to @var{out}, both of which "
1103 "must be either open file ports or file descriptors. When "
1104 "@var{offset} is omitted, start reading from @var{in}'s current "
1105 "position; otherwise, start reading at @var{offset}. Return "
1106 "the number of bytes actually sent.")
1107 #define FUNC_NAME s_scm_sendfile
1109 #define VALIDATE_FD_OR_PORT(cvar, svar, pos) \
1110 if (scm_is_integer (svar)) \
1111 cvar = scm_to_int (svar); \
1114 SCM_VALIDATE_OPFPORT (pos, svar); \
1116 cvar = SCM_FPORT_FDES (svar); \
1119 ssize_t result SCM_UNUSED
;
1120 size_t c_count
, total
= 0;
1124 VALIDATE_FD_OR_PORT (out_fd
, out
, 1);
1125 VALIDATE_FD_OR_PORT (in_fd
, in
, 2);
1126 c_count
= scm_to_size_t (count
);
1127 c_offset
= SCM_UNBNDP (offset
) ? 0 : scm_to_off_t (offset
);
1129 #if defined HAVE_SYS_SENDFILE_H && defined HAVE_SENDFILE
1130 /* The Linux-style sendfile(2), which is different from the BSD-style. */
1135 offset_ptr
= SCM_UNBNDP (offset
) ? NULL
: &c_offset
;
1137 /* On Linux, when OUT_FD is a file, everything is transferred at once and
1138 RESULT == C_COUNT. However, when OUT_FD is a pipe or other "slow"
1139 device, fewer bytes may be transferred, hence the loop. RESULT == 0
1140 means EOF on IN_FD, so leave the loop in that case. */
1143 result
= sendfile_or_sendfile64 (out_fd
, in_fd
, offset_ptr
,
1146 /* At this point, either OFFSET_PTR is non-NULL and it has been
1147 updated to the current offset in IN_FD, or it is NULL and IN_FD's
1148 offset has been updated. */
1150 else if (result
< 0 && (errno
== EINTR
|| errno
== EAGAIN
))
1154 while (total
< c_count
&& result
> 0);
1157 /* Quoting the Linux man page: "In Linux kernels before 2.6.33, out_fd
1158 must refer to a socket. Since Linux 2.6.33 it can be any file."
1159 Fall back to read(2) and write(2) when such an error occurs. */
1160 if (result
< 0 && errno
!= EINVAL
&& errno
!= ENOSYS
)
1162 else if (result
< 0)
1167 int reached_eof
= 0;
1169 if (!SCM_UNBNDP (offset
))
1172 scm_seek (in
, scm_from_off_t (c_offset
), scm_from_int (SEEK_SET
));
1175 if (lseek_or_lseek64 (in_fd
, c_offset
, SEEK_SET
) < 0)
1180 for (total
= 0, left
= c_count
; total
< c_count
&& !reached_eof
; )
1182 size_t asked
, obtained
, written
;
1184 asked
= MIN (sizeof buf
, left
);
1185 obtained
= full_read (in_fd
, buf
, asked
);
1186 if (obtained
< asked
)
1196 written
= full_write (out_fd
, buf
, obtained
);
1197 if (written
< obtained
)
1205 return scm_from_size_t (total
);
1207 #undef VALIDATE_FD_OR_PORT
1211 #endif /* HAVE_POSIX */
1214 /* Essential procedures used in (system base compile). */
1217 SCM_DEFINE (scm_getcwd
, "getcwd", 0, 0, 0,
1219 "Return the name of the current working directory.")
1220 #define FUNC_NAME s_scm_getcwd
1227 wd
= scm_malloc (size
);
1228 while ((rv
= getcwd (wd
, size
)) == 0 && errno
== ERANGE
)
1232 wd
= scm_malloc (size
);
1236 int save_errno
= errno
;
1241 result
= scm_from_locale_stringn (wd
, strlen (wd
));
1246 #endif /* HAVE_GETCWD */
1248 SCM_DEFINE (scm_mkdir
, "mkdir", 1, 1, 0,
1249 (SCM path
, SCM mode
),
1250 "Create a new directory named by @var{path}. If @var{mode} is omitted\n"
1251 "then the permissions of the directory file are set using the current\n"
1252 "umask. Otherwise they are set to the decimal value specified with\n"
1253 "@var{mode}. The return value is unspecified.")
1254 #define FUNC_NAME s_scm_mkdir
1259 if (SCM_UNBNDP (mode
))
1263 STRING_SYSCALL (path
, c_path
, rv
= mkdir (c_path
, 0777 ^ mask
));
1267 STRING_SYSCALL (path
, c_path
, rv
= mkdir (c_path
, scm_to_uint (mode
)));
1271 return SCM_UNSPECIFIED
;
1275 SCM_DEFINE (scm_rmdir
, "rmdir", 1, 0, 0,
1277 "Remove the existing directory named by @var{path}. The directory must\n"
1278 "be empty for this to succeed. The return value is unspecified.")
1279 #define FUNC_NAME s_scm_rmdir
1283 STRING_SYSCALL (path
, c_path
, val
= rmdir (c_path
));
1286 return SCM_UNSPECIFIED
;
1290 SCM_DEFINE (scm_rename
, "rename-file", 2, 0, 0,
1291 (SCM oldname
, SCM newname
),
1292 "Renames the file specified by @var{oldname} to @var{newname}.\n"
1293 "The return value is unspecified.")
1294 #define FUNC_NAME s_scm_rename
1298 STRING2_SYSCALL (oldname
, c_oldname
,
1300 rv
= rename (c_oldname
, c_newname
));
1303 return SCM_UNSPECIFIED
;
1308 SCM_DEFINE (scm_delete_file
, "delete-file", 1, 0, 0,
1310 "Deletes (or \"unlinks\") the file specified by @var{str}.")
1311 #define FUNC_NAME s_scm_delete_file
1314 STRING_SYSCALL (str
, c_str
, ans
= unlink (c_str
));
1317 return SCM_UNSPECIFIED
;
1321 SCM_DEFINE (scm_access
, "access?", 2, 0, 0,
1322 (SCM path
, SCM how
),
1323 "Test accessibility of a file under the real UID and GID of the\n"
1324 "calling process. The return is @code{#t} if @var{path} exists\n"
1325 "and the permissions requested by @var{how} are all allowed, or\n"
1326 "@code{#f} if not.\n"
1328 "@var{how} is an integer which is one of the following values,\n"
1329 "or a bitwise-OR (@code{logior}) of multiple values.\n"
1332 "Test for read permission.\n"
1335 "Test for write permission.\n"
1338 "Test for execute permission.\n"
1341 "Test for existence of the file. This is implied by each of the\n"
1342 "other tests, so there's no need to combine it with them.\n"
1345 "It's important to note that @code{access?} does not simply\n"
1346 "indicate what will happen on attempting to read or write a\n"
1347 "file. In normal circumstances it does, but in a set-UID or\n"
1348 "set-GID program it doesn't because @code{access?} tests the\n"
1349 "real ID, whereas an open or execute attempt uses the effective\n"
1352 "A program which will never run set-UID/GID can ignore the\n"
1353 "difference between real and effective IDs, but for maximum\n"
1354 "generality, especially in library functions, it's best not to\n"
1355 "use @code{access?} to predict the result of an open or execute,\n"
1356 "instead simply attempt that and catch any exception.\n"
1358 "The main use for @code{access?} is to let a set-UID/GID program\n"
1359 "determine what the invoking user would have been allowed to do,\n"
1360 "without the greater (or perhaps lesser) privileges afforded by\n"
1361 "the effective ID. For more on this, see ``Testing File\n"
1362 "Access'' in The GNU C Library Reference Manual.")
1363 #define FUNC_NAME s_scm_access
1368 c_path
= scm_to_locale_string (path
);
1369 rv
= access (c_path
, scm_to_int (how
));
1372 return scm_from_bool (!rv
);
1376 SCM_DEFINE (scm_chmod
, "chmod", 2, 0, 0,
1377 (SCM object
, SCM mode
),
1378 "Changes the permissions of the file referred to by\n"
1379 "@var{object}. @var{object} can be a string containing a file\n"
1380 "name or a port or integer file descriptor which is open on a\n"
1381 "file (in which case @code{fchmod} is used as the underlying\n"
1382 "system call). @var{mode} specifies the new permissions as a\n"
1383 "decimal number, e.g., @code{(chmod \"foo\" #o755)}.\n"
1384 "The return value is unspecified.")
1385 #define FUNC_NAME s_scm_chmod
1389 object
= SCM_COERCE_OUTPORT (object
);
1392 if (scm_is_integer (object
) || SCM_OPFPORTP (object
))
1395 if (scm_is_integer (object
))
1396 fdes
= scm_to_int (object
);
1398 fdes
= SCM_FPORT_FDES (object
);
1399 SCM_SYSCALL (rv
= fchmod (fdes
, scm_to_int (mode
)));
1404 STRING_SYSCALL (object
, c_object
,
1405 rv
= chmod (c_object
, scm_to_int (mode
)));
1409 return SCM_UNSPECIFIED
;
1413 SCM_DEFINE (scm_umask
, "umask", 0, 1, 0,
1415 "If @var{mode} is omitted, returns a decimal number representing the current\n"
1416 "file creation mask. Otherwise the file creation mask is set to\n"
1417 "@var{mode} and the previous value is returned.\n\n"
1418 "E.g., @code{(umask #o022)} sets the mask to octal 22, decimal 18.")
1419 #define FUNC_NAME s_scm_umask
1422 if (SCM_UNBNDP (mode
))
1429 mask
= umask (scm_to_uint (mode
));
1431 return scm_from_uint (mask
);
1435 SCM_DEFINE (scm_mkstemp
, "mkstemp!", 1, 0, 0,
1437 "Create a new unique file in the file system and return a new\n"
1438 "buffered port open for reading and writing to the file.\n"
1440 "@var{tmpl} is a string specifying where the file should be\n"
1441 "created: it must end with @samp{XXXXXX} and those @samp{X}s\n"
1442 "will be changed in the string to return the name of the file.\n"
1443 "(@code{port-filename} on the port also gives the name.)\n"
1445 "POSIX doesn't specify the permissions mode of the file, on GNU\n"
1446 "and most systems it's @code{#o600}. An application can use\n"
1447 "@code{chmod} to relax that if desired. For example\n"
1448 "@code{#o666} less @code{umask}, which is usual for ordinary\n"
1452 "(let ((port (mkstemp! (string-copy \"/tmp/myfile-XXXXXX\"))))\n"
1453 " (chmod port (logand #o666 (lognot (umask))))\n"
1456 #define FUNC_NAME s_scm_mkstemp
1461 scm_dynwind_begin (0);
1463 c_tmpl
= scm_to_locale_string (tmpl
);
1464 scm_dynwind_free (c_tmpl
);
1466 SCM_SYSCALL (rv
= mkstemp (c_tmpl
));
1470 scm_substring_move_x (scm_from_locale_string (c_tmpl
),
1471 SCM_INUM0
, scm_string_length (tmpl
),
1475 return scm_fdes_to_port (rv
, "w+", tmpl
);
1480 /* Filename manipulation */
1485 SCM_SYMBOL (sym_file_name_convention
, "windows");
1487 SCM_SYMBOL (sym_file_name_convention
, "posix");
1490 SCM_INTERNAL SCM
scm_system_file_name_convention (void);
1492 SCM_DEFINE (scm_system_file_name_convention
,
1493 "system-file-name-convention", 0, 0, 0, (void),
1494 "Return either @code{posix} or @code{windows}, depending on\n"
1495 "what kind of system this Guile is running on.")
1496 #define FUNC_NAME s_scm_system_file_name_convention
1498 return sym_file_name_convention
;
1502 SCM_DEFINE (scm_dirname
, "dirname", 1, 0, 0,
1504 "Return the directory name component of the file name\n"
1505 "@var{filename}. If @var{filename} does not contain a directory\n"
1506 "component, @code{.} is returned.")
1507 #define FUNC_NAME s_scm_dirname
1510 unsigned long int len
;
1512 SCM_VALIDATE_STRING (1, filename
);
1514 len
= scm_i_string_length (filename
);
1518 while (i
>= 0 && is_file_name_separator (scm_c_string_ref (filename
, i
)))
1520 while (i
>= 0 && !is_file_name_separator (scm_c_string_ref (filename
, i
)))
1522 while (i
>= 0 && is_file_name_separator (scm_c_string_ref (filename
, i
)))
1527 if (len
> 0 && is_file_name_separator (scm_c_string_ref (filename
, 0)))
1528 return scm_c_substring (filename
, 0, 1);
1530 return scm_dot_string
;
1533 return scm_c_substring (filename
, 0, i
+ 1);
1537 SCM_DEFINE (scm_basename
, "basename", 1, 1, 0,
1538 (SCM filename
, SCM suffix
),
1539 "Return the base name of the file name @var{filename}. The\n"
1540 "base name is the file name without any directory components.\n"
1541 "If @var{suffix} is provided, and is equal to the end of\n"
1542 "@var{filename}, it is removed also.")
1543 #define FUNC_NAME s_scm_basename
1547 SCM_VALIDATE_STRING (1, filename
);
1548 len
= scm_i_string_length (filename
);
1550 if (SCM_UNBNDP (suffix
))
1554 SCM_VALIDATE_STRING (2, suffix
);
1555 j
= scm_i_string_length (suffix
) - 1;
1558 while (i
>= 0 && is_file_name_separator (scm_c_string_ref (filename
, i
)))
1561 while (i
>= 0 && j
>= 0
1562 && (scm_i_string_ref (filename
, i
)
1563 == scm_i_string_ref (suffix
, j
)))
1570 while (i
>= 0 && !is_file_name_separator (scm_c_string_ref (filename
, i
)))
1574 if (len
> 0 && is_file_name_separator (scm_c_string_ref (filename
, 0)))
1575 return scm_c_substring (filename
, 0, 1);
1577 return scm_dot_string
;
1580 return scm_c_substring (filename
, i
+1, end
+1);
1584 SCM_DEFINE (scm_canonicalize_path
, "canonicalize-path", 1, 0, 0,
1586 "Return the canonical path of @var{path}. A canonical path has\n"
1587 "no @code{.} or @code{..} components, nor any repeated path\n"
1588 "separators (@code{/}) nor symlinks.\n\n"
1589 "Raises an error if any component of @var{path} does not exist.")
1590 #define FUNC_NAME s_scm_canonicalize_path
1594 SCM_VALIDATE_STRING (1, path
);
1596 str
= scm_to_locale_string (path
);
1597 canon
= canonicalize_file_name (str
);
1601 return scm_take_locale_string (canon
);
1608 scm_i_relativize_path (SCM path
, SCM in_path
)
1613 str
= scm_to_locale_string (path
);
1614 canon
= canonicalize_file_name (str
);
1620 scanon
= scm_take_locale_string (canon
);
1622 for (; scm_is_pair (in_path
); in_path
= scm_cdr (in_path
))
1624 SCM dir
= scm_car (in_path
);
1625 size_t len
= scm_c_string_length (dir
);
1627 /* When DIR is empty, it means "current working directory". We
1628 could set DIR to (getcwd) in that case, but then the
1629 canonicalization would depend on the current directory, which
1630 is not what we want in the context of `compile-file', for
1633 && scm_is_true (scm_string_prefix_p (dir
, scanon
,
1634 SCM_UNDEFINED
, SCM_UNDEFINED
,
1635 SCM_UNDEFINED
, SCM_UNDEFINED
)))
1637 /* DIR either has a trailing delimiter or doesn't. SCANON
1638 will be delimited by single delimiters. When DIR does not
1639 have a trailing delimiter, add one to the length to strip
1640 off the delimiter within SCANON. */
1641 if (!is_file_name_separator (scm_c_string_ref (dir
, len
- 1)))
1644 if (scm_c_string_length (scanon
) > len
)
1645 return scm_substring (scanon
, scm_from_size_t (len
), SCM_UNDEFINED
);
1655 /* Examining directories. These procedures are used by `check-guile'
1656 and thus compiled unconditionally. */
1658 scm_t_bits scm_tc16_dir
;
1661 SCM_DEFINE (scm_directory_stream_p
, "directory-stream?", 1, 0, 0,
1663 "Return a boolean indicating whether @var{obj} is a directory\n"
1664 "stream as returned by @code{opendir}.")
1665 #define FUNC_NAME s_scm_directory_stream_p
1667 return scm_from_bool (SCM_DIRP (obj
));
1672 SCM_DEFINE (scm_opendir
, "opendir", 1, 0, 0,
1674 "Open the directory specified by @var{dirname} and return a directory\n"
1676 #define FUNC_NAME s_scm_opendir
1679 STRING_SYSCALL (dirname
, c_dirname
, ds
= opendir (c_dirname
));
1682 SCM_RETURN_NEWSMOB (scm_tc16_dir
| (SCM_DIR_FLAG_OPEN
<<16), ds
);
1687 /* FIXME: The glibc manual has a portability note that readdir_r may not
1688 null-terminate its return string. The circumstances outlined for this
1689 are not clear, nor is it clear what should be done about it. Lets use
1690 NAMLEN and worry about what else should be done if/when someone can
1693 SCM_DEFINE (scm_readdir
, "readdir", 1, 0, 0,
1695 "Return (as a string) the next directory entry from the directory stream\n"
1696 "@var{port}. If there is no remaining entry to be read then the\n"
1697 "end of file object is returned.")
1698 #define FUNC_NAME s_scm_readdir
1700 struct dirent_or_dirent64
*rdent
;
1702 SCM_VALIDATE_DIR (1, port
);
1703 if (!SCM_DIR_OPEN_P (port
))
1704 SCM_MISC_ERROR ("Directory ~S is not open.", scm_list_1 (port
));
1707 /* As noted in the glibc manual, on various systems (such as Solaris)
1708 the d_name[] field is only 1 char and you're expected to size the
1709 dirent buffer for readdir_r based on NAME_MAX. The MAX expressions
1710 below effectively give either sizeof(d_name) or NAME_MAX+1,
1711 whichever is bigger.
1713 On solaris 10 there's no NAME_MAX constant, it's necessary to use
1714 pathconf(). We prefer NAME_MAX though, since it should be a constant
1715 and will therefore save a system call. We also prefer it since dirfd()
1716 is not available everywhere.
1718 An alternative to dirfd() would be to open() the directory and then use
1719 fdopendir(), if the latter is available. That'd let us hold the fd
1720 somewhere in the smob, or just the dirent size calculated once. */
1722 struct dirent_or_dirent64 de
; /* just for sizeof */
1723 DIR *ds
= (DIR *) SCM_SMOB_DATA_1 (port
);
1725 char buf
[MAX (sizeof (de
),
1726 sizeof (de
) - sizeof (de
.d_name
) + NAME_MAX
+ 1)];
1729 long name_max
= fpathconf (dirfd (ds
), _PC_NAME_MAX
);
1732 buf
= alloca (MAX (sizeof (de
),
1733 sizeof (de
) - sizeof (de
.d_name
) + name_max
+ 1));
1737 SCM_SYSCALL (readdir_r_or_readdir64_r (ds
, (struct dirent_or_dirent64
*) buf
, &rdent
));
1743 return (rdent
? scm_from_locale_stringn (rdent
->d_name
, NAMLEN (rdent
))
1749 scm_dynwind_begin (0);
1750 scm_i_dynwind_pthread_mutex_lock (&scm_i_misc_mutex
);
1753 SCM_SYSCALL (rdent
= readdir_or_readdir64 ((DIR *) SCM_SMOB_DATA_1 (port
)));
1757 ret
= (rdent
? scm_from_locale_stringn (rdent
->d_name
, NAMLEN (rdent
))
1768 SCM_DEFINE (scm_rewinddir
, "rewinddir", 1, 0, 0,
1770 "Reset the directory port @var{port} so that the next call to\n"
1771 "@code{readdir} will return the first directory entry.")
1772 #define FUNC_NAME s_scm_rewinddir
1774 SCM_VALIDATE_DIR (1, port
);
1775 if (!SCM_DIR_OPEN_P (port
))
1776 SCM_MISC_ERROR ("Directory ~S is not open.", scm_list_1 (port
));
1778 rewinddir ((DIR *) SCM_SMOB_DATA_1 (port
));
1780 return SCM_UNSPECIFIED
;
1785 SCM_DEFINE (scm_closedir
, "closedir", 1, 0, 0,
1787 "Close the directory stream @var{port}.\n"
1788 "The return value is unspecified.")
1789 #define FUNC_NAME s_scm_closedir
1791 SCM_VALIDATE_DIR (1, port
);
1793 if (SCM_DIR_OPEN_P (port
))
1797 SCM_SYSCALL (sts
= closedir ((DIR *) SCM_SMOB_DATA_1 (port
)));
1801 SCM_SET_SMOB_DATA_0 (port
, scm_tc16_dir
);
1804 return SCM_UNSPECIFIED
;
1811 scm_dir_print (SCM exp
, SCM port
, scm_print_state
*pstate SCM_UNUSED
)
1813 scm_puts_unlocked ("#<", port
);
1814 if (!SCM_DIR_OPEN_P (exp
))
1815 scm_puts_unlocked ("closed: ", port
);
1816 scm_puts_unlocked ("directory stream ", port
);
1817 scm_uintprint (SCM_SMOB_DATA_1 (exp
), 16, port
);
1818 scm_putc_unlocked ('>', port
);
1824 scm_dir_free (SCM p
)
1826 if (SCM_DIR_OPEN_P (p
))
1827 closedir ((DIR *) SCM_SMOB_DATA_1 (p
));
1838 scm_tc16_dir
= scm_make_smob_type ("directory", 0);
1839 scm_set_smob_free (scm_tc16_dir
, scm_dir_free
);
1840 scm_set_smob_print (scm_tc16_dir
, scm_dir_print
);
1843 scm_c_define ("O_RDONLY", scm_from_int (O_RDONLY
));
1846 scm_c_define ("O_WRONLY", scm_from_int (O_WRONLY
));
1849 scm_c_define ("O_RDWR", scm_from_int (O_RDWR
));
1852 scm_c_define ("O_CREAT", scm_from_int (O_CREAT
));
1855 scm_c_define ("O_EXCL", scm_from_int (O_EXCL
));
1858 scm_c_define ("O_NOCTTY", scm_from_int (O_NOCTTY
));
1861 scm_c_define ("O_TRUNC", scm_from_int (O_TRUNC
));
1864 scm_c_define ("O_APPEND", scm_from_int (O_APPEND
));
1867 scm_c_define ("O_NONBLOCK", scm_from_int (O_NONBLOCK
));
1870 scm_c_define ("O_NDELAY", scm_from_int (O_NDELAY
));
1873 scm_c_define ("O_SYNC", scm_from_int (O_SYNC
));
1876 scm_c_define ("O_LARGEFILE", scm_from_int (O_LARGEFILE
));
1879 scm_c_define ("O_NOTRANS", scm_from_int (O_NOTRANS
));
1883 scm_c_define ("F_DUPFD", scm_from_int (F_DUPFD
));
1886 scm_c_define ("F_GETFD", scm_from_int (F_GETFD
));
1889 scm_c_define ("F_SETFD", scm_from_int (F_SETFD
));
1892 scm_c_define ("F_GETFL", scm_from_int (F_GETFL
));
1895 scm_c_define ("F_SETFL", scm_from_int (F_SETFL
));
1898 scm_c_define ("F_GETOWN", scm_from_int (F_GETOWN
));
1901 scm_c_define ("F_SETOWN", scm_from_int (F_SETOWN
));
1904 scm_c_define ("FD_CLOEXEC", scm_from_int (FD_CLOEXEC
));
1906 #endif /* HAVE_POSIX */
1908 /* `access' symbols. */
1909 scm_c_define ("R_OK", scm_from_int (R_OK
));
1910 scm_c_define ("W_OK", scm_from_int (W_OK
));
1911 scm_c_define ("X_OK", scm_from_int (X_OK
));
1912 scm_c_define ("F_OK", scm_from_int (F_OK
));
1914 scm_dot_string
= scm_from_locale_string (".");
1916 #include "libguile/filesys.x"