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"
53 #include "libguile/load.h" /* for scm_i_mirror_backslashes */
64 #ifdef TIME_WITH_SYS_TIME
65 # include <sys/time.h>
69 # include <sys/time.h>
77 #ifdef LIBC_H_WITH_UNISTD_H
81 #include <sys/select.h>
87 #include <sys/types.h>
97 #define NAMLEN(dirent) strlen ((dirent)->d_name)
99 #ifdef HAVE_SYS_SENDFILE_H
100 # include <sys/sendfile.h>
103 /* Glibc's `sendfile' function. */
104 #define sendfile_or_sendfile64 \
105 CHOOSE_LARGEFILE (sendfile, sendfile64)
107 #include <full-read.h>
108 #include <full-write.h>
113 /* Two helper macros for an often used pattern */
115 #define STRING_SYSCALL(str,cstr,code) \
118 char *cstr = scm_to_locale_string (str); \
119 SCM_SYSCALL (code); \
120 eno = errno; free (cstr); errno = eno; \
123 #define STRING2_SYSCALL(str1,cstr1,str2,cstr2,code) \
126 char *cstr1, *cstr2; \
127 scm_dynwind_begin (0); \
128 cstr1 = scm_to_locale_string (str1); \
129 scm_dynwind_free (cstr1); \
130 cstr2 = scm_to_locale_string (str2); \
131 scm_dynwind_free (cstr2); \
132 SCM_SYSCALL (code); \
133 eno = errno; scm_dynwind_end (); errno = eno; \
137 #define MAX(A, B) ((A) > (B) ? (A) : (B))
138 #define MIN(A, B) ((A) < (B) ? (A) : (B))
148 SCM_DEFINE (scm_chown
, "chown", 3, 0, 0,
149 (SCM object
, SCM owner
, SCM group
),
150 "Change the ownership and group of the file referred to by @var{object} to\n"
151 "the integer values @var{owner} and @var{group}. @var{object} can be\n"
152 "a string containing a file name or, if the platform\n"
153 "supports fchown, a port or integer file descriptor\n"
154 "which is open on the file. The return value\n"
155 "is unspecified.\n\n"
156 "If @var{object} is a symbolic link, either the\n"
157 "ownership of the link or the ownership of the referenced file will be\n"
158 "changed depending on the operating system (lchown is\n"
159 "unsupported at present). If @var{owner} or @var{group} is specified\n"
160 "as @code{-1}, then that ID is not changed.")
161 #define FUNC_NAME s_scm_chown
165 object
= SCM_COERCE_OUTPORT (object
);
168 if (scm_is_integer (object
) || (SCM_OPFPORTP (object
)))
170 int fdes
= (SCM_OPFPORTP (object
)?
171 SCM_FPORT_FDES (object
) : scm_to_int (object
));
173 SCM_SYSCALL (rv
= fchown (fdes
, scm_to_int (owner
), scm_to_int (group
)));
178 STRING_SYSCALL (object
, c_object
,
179 rv
= chown (c_object
,
180 scm_to_int (owner
), scm_to_int (group
)));
184 return SCM_UNSPECIFIED
;
187 #endif /* HAVE_CHOWN */
191 SCM_DEFINE (scm_open_fdes
, "open-fdes", 2, 1, 0,
192 (SCM path
, SCM flags
, SCM mode
),
193 "Similar to @code{open} but return a file descriptor instead of\n"
195 #define FUNC_NAME s_scm_open_fdes
201 iflags
= SCM_NUM2INT (2, flags
);
202 imode
= SCM_NUM2INT_DEF (3, mode
, 0666);
203 STRING_SYSCALL (path
, c_path
, fd
= open_or_open64 (c_path
, iflags
, imode
));
206 return scm_from_int (fd
);
210 SCM_DEFINE (scm_open
, "open", 2, 1, 0,
211 (SCM path
, SCM flags
, SCM mode
),
212 "Open the file named by @var{path} for reading and/or writing.\n"
213 "@var{flags} is an integer specifying how the file should be opened.\n"
214 "@var{mode} is an integer specifying the permission bits of the file, if\n"
215 "it needs to be created, before the umask is applied. The default is 666\n"
216 "(Unix itself has no default).\n\n"
217 "@var{flags} can be constructed by combining variables using @code{logior}.\n"
218 "Basic flags are:\n\n"
220 "Open the file read-only.\n"
223 "Open the file write-only.\n"
226 "Open the file read/write.\n"
229 "Append to the file instead of truncating.\n"
232 "Create the file if it does not already exist.\n"
234 "See the Unix documentation of the @code{open} system call\n"
235 "for additional flags.")
236 #define FUNC_NAME s_scm_open
243 fd
= scm_to_int (scm_open_fdes (path
, flags
, mode
));
244 iflags
= SCM_NUM2INT (2, flags
);
246 if ((iflags
& O_RDWR
) == O_RDWR
)
248 /* Opened read-write. */
249 if (iflags
& O_APPEND
)
251 else if (iflags
& O_CREAT
)
258 /* Opened read-only or write-only. */
259 if (iflags
& O_APPEND
)
261 else if (iflags
& O_WRONLY
)
267 newpt
= scm_fdes_to_port (fd
, port_mode
, path
);
272 SCM_DEFINE (scm_close
, "close", 1, 0, 0,
274 "Similar to close-port (@pxref{Closing, close-port}),\n"
275 "but also works on file descriptors. A side\n"
276 "effect of closing a file descriptor is that any ports using that file\n"
277 "descriptor are moved to a different file descriptor and have\n"
278 "their revealed counts set to zero.")
279 #define FUNC_NAME s_scm_close
284 fd_or_port
= SCM_COERCE_OUTPORT (fd_or_port
);
286 if (SCM_PORTP (fd_or_port
))
287 return scm_close_port (fd_or_port
);
288 fd
= scm_to_int (fd_or_port
);
289 scm_evict_ports (fd
); /* see scsh manual. */
290 SCM_SYSCALL (rv
= close (fd
));
291 /* following scsh, closing an already closed file descriptor is
293 if (rv
< 0 && errno
!= EBADF
)
295 return scm_from_bool (rv
>= 0);
299 SCM_DEFINE (scm_close_fdes
, "close-fdes", 1, 0, 0,
301 "A simple wrapper for the @code{close} system call.\n"
302 "Close file descriptor @var{fd}, which must be an integer.\n"
303 "Unlike close (@pxref{Ports and File Descriptors, close}),\n"
304 "the file descriptor will be closed even if a port is using it.\n"
305 "The return value is unspecified.")
306 #define FUNC_NAME s_scm_close_fdes
311 c_fd
= scm_to_int (fd
);
312 SCM_SYSCALL (rv
= close (c_fd
));
315 return SCM_UNSPECIFIED
;
319 #endif /* HAVE_POSIX */
325 SCM_SYMBOL (scm_sym_regular
, "regular");
326 SCM_SYMBOL (scm_sym_directory
, "directory");
328 SCM_SYMBOL (scm_sym_symlink
, "symlink");
330 SCM_SYMBOL (scm_sym_block_special
, "block-special");
331 SCM_SYMBOL (scm_sym_char_special
, "char-special");
332 SCM_SYMBOL (scm_sym_fifo
, "fifo");
333 SCM_SYMBOL (scm_sym_sock
, "socket");
334 SCM_SYMBOL (scm_sym_unknown
, "unknown");
337 scm_stat2scm (struct stat_or_stat64
*stat_temp
)
339 SCM ans
= scm_c_make_vector (18, SCM_UNSPECIFIED
);
341 SCM_SIMPLE_VECTOR_SET(ans
, 0, scm_from_ulong (stat_temp
->st_dev
));
342 SCM_SIMPLE_VECTOR_SET(ans
, 1, scm_from_ino_t_or_ino64_t (stat_temp
->st_ino
));
343 SCM_SIMPLE_VECTOR_SET(ans
, 2, scm_from_ulong (stat_temp
->st_mode
));
344 SCM_SIMPLE_VECTOR_SET(ans
, 3, scm_from_ulong (stat_temp
->st_nlink
));
345 SCM_SIMPLE_VECTOR_SET(ans
, 4, scm_from_ulong (stat_temp
->st_uid
));
346 SCM_SIMPLE_VECTOR_SET(ans
, 5, scm_from_ulong (stat_temp
->st_gid
));
347 #ifdef HAVE_STRUCT_STAT_ST_RDEV
348 SCM_SIMPLE_VECTOR_SET(ans
, 6, scm_from_ulong (stat_temp
->st_rdev
));
350 SCM_SIMPLE_VECTOR_SET(ans
, 6, SCM_BOOL_F
);
352 SCM_SIMPLE_VECTOR_SET(ans
, 7, scm_from_off_t_or_off64_t (stat_temp
->st_size
));
353 SCM_SIMPLE_VECTOR_SET(ans
, 8, scm_from_ulong (stat_temp
->st_atime
));
354 SCM_SIMPLE_VECTOR_SET(ans
, 9, scm_from_ulong (stat_temp
->st_mtime
));
355 SCM_SIMPLE_VECTOR_SET(ans
, 10, scm_from_ulong (stat_temp
->st_ctime
));
356 #ifdef HAVE_STRUCT_STAT_ST_BLKSIZE
357 SCM_SIMPLE_VECTOR_SET(ans
, 11, scm_from_ulong (stat_temp
->st_blksize
));
359 SCM_SIMPLE_VECTOR_SET(ans
, 11, scm_from_ulong (4096L));
361 #ifdef HAVE_STRUCT_STAT_ST_BLOCKS
362 SCM_SIMPLE_VECTOR_SET(ans
, 12, scm_from_blkcnt_t_or_blkcnt64_t (stat_temp
->st_blocks
));
364 SCM_SIMPLE_VECTOR_SET(ans
, 12, SCM_BOOL_F
);
367 int mode
= stat_temp
->st_mode
;
370 SCM_SIMPLE_VECTOR_SET(ans
, 13, scm_sym_regular
);
371 else if (S_ISDIR (mode
))
372 SCM_SIMPLE_VECTOR_SET(ans
, 13, scm_sym_directory
);
374 /* systems without symlinks probably don't have S_ISLNK */
375 else if (S_ISLNK (mode
))
376 SCM_SIMPLE_VECTOR_SET(ans
, 13, scm_sym_symlink
);
378 else if (S_ISBLK (mode
))
379 SCM_SIMPLE_VECTOR_SET(ans
, 13, scm_sym_block_special
);
380 else if (S_ISCHR (mode
))
381 SCM_SIMPLE_VECTOR_SET(ans
, 13, scm_sym_char_special
);
382 else if (S_ISFIFO (mode
))
383 SCM_SIMPLE_VECTOR_SET(ans
, 13, scm_sym_fifo
);
385 else if (S_ISSOCK (mode
))
386 SCM_SIMPLE_VECTOR_SET(ans
, 13, scm_sym_sock
);
389 SCM_SIMPLE_VECTOR_SET(ans
, 13, scm_sym_unknown
);
391 SCM_SIMPLE_VECTOR_SET(ans
, 14, scm_from_int ((~S_IFMT
) & mode
));
393 /* the layout of the bits in ve[14] is intended to be portable.
394 If there are systems that don't follow the usual convention,
395 the following could be used:
398 if (S_ISUID & mode) tmp += 1;
400 if (S_IRGRP & mode) tmp += 1;
402 if (S_ISVTX & mode) tmp += 1;
404 if (S_IRUSR & mode) tmp += 1;
406 if (S_IWUSR & mode) tmp += 1;
408 if (S_IXUSR & mode) tmp += 1;
410 if (S_IWGRP & mode) tmp += 1;
412 if (S_IXGRP & mode) tmp += 1;
414 if (S_IROTH & mode) tmp += 1;
416 if (S_IWOTH & mode) tmp += 1;
418 if (S_IXOTH & mode) tmp += 1;
420 SCM_SIMPLE_VECTOR_SET(ans, 14, scm_from_int (tmp));
424 #ifdef HAVE_STRUCT_STAT_ST_ATIM
425 SCM_SIMPLE_VECTOR_SET(ans
, 15, scm_from_long (stat_temp
->st_atim
.tv_nsec
));
427 SCM_SIMPLE_VECTOR_SET(ans
, 15, SCM_I_MAKINUM (0));
429 #ifdef HAVE_STRUCT_STAT_ST_MTIM
430 SCM_SIMPLE_VECTOR_SET(ans
, 16, scm_from_long (stat_temp
->st_mtim
.tv_nsec
));
432 SCM_SIMPLE_VECTOR_SET(ans
, 16, SCM_I_MAKINUM (0));
434 #ifdef HAVE_STRUCT_STAT_ST_CTIM
435 SCM_SIMPLE_VECTOR_SET(ans
, 17, scm_from_ulong (stat_temp
->st_ctim
.tv_sec
));
437 SCM_SIMPLE_VECTOR_SET(ans
, 17, SCM_I_MAKINUM (0));
444 is_file_name_separator (SCM c
)
446 if (scm_is_eq (c
, SCM_MAKE_CHAR ('/')))
449 if (scm_is_eq (c
, SCM_MAKE_CHAR ('\\')))
455 SCM_DEFINE (scm_stat
, "stat", 1, 1, 0,
456 (SCM object
, SCM exception_on_error
),
457 "Return an object containing various information about the file\n"
458 "determined by @var{object}. @var{object} can be a string containing\n"
459 "a file name or a port or integer file descriptor which is open\n"
460 "on a file (in which case @code{fstat} is used as the underlying\n"
463 "If the optional @var{exception_on_error} argument is true, which\n"
464 "is the default, an exception will be raised if the underlying\n"
465 "system call returns an error, for example if the file is not\n"
466 "found or is not readable. Otherwise, an error will cause\n"
467 "@code{stat} to return @code{#f}."
469 "The object returned by a successful call to @code{stat} can be\n"
470 "passed as a single parameter to the following procedures, all of\n"
471 "which return integers:\n"
475 "The device containing the file.\n"
477 "The file serial number, which distinguishes this file from all\n"
478 "other files on the same device.\n"
480 "The mode of the file. This includes file type information and\n"
481 "the file permission bits. See @code{stat:type} and\n"
482 "@code{stat:perms} below.\n"
484 "The number of hard links to the file.\n"
486 "The user ID of the file's owner.\n"
488 "The group ID of the file.\n"
490 "Device ID; this entry is defined only for character or block\n"
493 "The size of a regular file in bytes.\n"
495 "The last access time for the file.\n"
497 "The last modification time for the file.\n"
499 "The last modification time for the attributes of the file.\n"
500 "@item stat:blksize\n"
501 "The optimal block size for reading or writing the file, in\n"
503 "@item stat:blocks\n"
504 "The amount of disk space that the file occupies measured in\n"
505 "units of 512 byte blocks.\n"
508 "In addition, the following procedures return the information\n"
509 "from stat:mode in a more convenient form:\n"
513 "A symbol representing the type of file. Possible values are\n"
514 "regular, directory, symlink, block-special, char-special, fifo,\n"
515 "socket and unknown\n"
517 "An integer representing the access permission bits.\n"
519 #define FUNC_NAME s_scm_stat
523 struct stat_or_stat64 stat_temp
;
525 if (scm_is_integer (object
))
527 SCM_SYSCALL (rv
= fstat_or_fstat64 (scm_to_int (object
), &stat_temp
));
529 else if (scm_is_string (object
))
531 char *file
= scm_to_locale_string (object
);
532 SCM_SYSCALL (rv
= stat_or_stat64 (file
, &stat_temp
));
537 object
= SCM_COERCE_OUTPORT (object
);
538 SCM_VALIDATE_OPFPORT (1, object
);
539 fdes
= SCM_FPORT_FDES (object
);
540 SCM_SYSCALL (rv
= fstat_or_fstat64 (fdes
, &stat_temp
));
545 if (SCM_UNBNDP (exception_on_error
) || scm_is_true (exception_on_error
))
548 SCM_SYSERROR_MSG ("~A: ~S",
549 scm_list_2 (scm_strerror (scm_from_int (en
)),
556 return scm_stat2scm (&stat_temp
);
560 SCM_DEFINE (scm_lstat
, "lstat", 1, 0, 0,
562 "Similar to @code{stat}, but does not follow symbolic links, i.e.,\n"
563 "it will return information about a symbolic link itself, not the\n"
564 "file it points to. @var{str} must be a string.")
565 #define FUNC_NAME s_scm_lstat
568 struct stat_or_stat64 stat_temp
;
570 STRING_SYSCALL (str
, c_str
, rv
= lstat_or_lstat64 (c_str
, &stat_temp
));
575 SCM_SYSERROR_MSG ("~A: ~S",
576 scm_list_2 (scm_strerror (scm_from_int (en
)), str
),
579 return scm_stat2scm (&stat_temp
);
586 /* {Modifying Directories}
589 SCM_DEFINE (scm_link
, "link", 2, 0, 0,
590 (SCM oldpath
, SCM newpath
),
591 "Creates a new name @var{newpath} in the file system for the\n"
592 "file named by @var{oldpath}. If @var{oldpath} is a symbolic\n"
593 "link, the link may or may not be followed depending on the\n"
595 #define FUNC_NAME s_scm_link
599 STRING2_SYSCALL (oldpath
, c_oldpath
,
601 val
= link (c_oldpath
, c_newpath
));
604 return SCM_UNSPECIFIED
;
609 /* {Navigating Directories}
613 SCM_DEFINE (scm_chdir
, "chdir", 1, 0, 0,
615 "Change the current working directory to @var{str}.\n"
616 "The return value is unspecified.")
617 #define FUNC_NAME s_scm_chdir
621 STRING_SYSCALL (str
, c_str
, ans
= chdir (c_str
));
624 return SCM_UNSPECIFIED
;
630 /* check that element is a port or file descriptor. if it's a port
631 and its buffer is ready for use, add it to the ports_ready list.
632 otherwise add its file descriptor to *set. the type of list can be
633 determined from pos: SCM_ARG1 for reads, SCM_ARG2 for writes,
634 SCM_ARG3 for excepts. */
636 set_element (fd_set
*set
, SCM
*ports_ready
, SCM element
, int pos
)
640 if (scm_is_integer (element
))
642 fd
= scm_to_int (element
);
648 element
= SCM_COERCE_OUTPORT (element
);
649 SCM_ASSERT (SCM_OPFPORTP (element
), element
, pos
, "select");
652 /* check whether port has buffered input. */
653 scm_t_port
*pt
= SCM_PTAB_ENTRY (element
);
655 if (pt
->read_pos
< pt
->read_end
)
658 else if (pos
== SCM_ARG2
)
660 /* check whether port's output buffer has room. */
661 scm_t_port
*pt
= SCM_PTAB_ENTRY (element
);
663 /* > 1 since writing the last byte in the buffer causes flush. */
664 if (pt
->write_end
- pt
->write_pos
> 1)
667 fd
= use_buf
? -1 : SCM_FPORT_FDES (element
);
670 *ports_ready
= scm_cons (element
, *ports_ready
);
676 /* check list_or_vec, a list or vector of ports or file descriptors,
677 adding each member to either the ports_ready list (if it's a port
678 with a usable buffer) or to *set. the kind of list_or_vec can be
679 determined from pos: SCM_ARG1 for reads, SCM_ARG2 for writes,
680 SCM_ARG3 for excepts. */
682 fill_select_type (fd_set
*set
, SCM
*ports_ready
, SCM list_or_vec
, int pos
)
686 if (scm_is_vector (list_or_vec
))
688 int i
= SCM_SIMPLE_VECTOR_LENGTH (list_or_vec
);
692 int fd
= set_element (set
, ports_ready
,
693 SCM_SIMPLE_VECTOR_REF (list_or_vec
, i
), pos
);
701 while (!SCM_NULL_OR_NIL_P (list_or_vec
))
703 int fd
= set_element (set
, ports_ready
, SCM_CAR (list_or_vec
), pos
);
707 list_or_vec
= SCM_CDR (list_or_vec
);
714 /* if element (a file descriptor or port) appears in *set, cons it to
715 list. return list. */
717 get_element (fd_set
*set
, SCM element
, SCM list
)
721 if (scm_is_integer (element
))
723 fd
= scm_to_int (element
);
727 fd
= SCM_FPORT_FDES (SCM_COERCE_OUTPORT (element
));
729 if (FD_ISSET (fd
, set
))
730 list
= scm_cons (element
, list
);
734 /* construct component of scm_select return value.
735 set: pointer to set of file descriptors found by select to be ready
736 ports_ready: ports ready due to buffering
737 list_or_vec: original list/vector handed to scm_select.
738 the return value is a list/vector of ready ports/file descriptors.
739 works by finding the objects in list which correspond to members of
740 *set and appending them to ports_ready. result is converted to a
741 vector if list_or_vec is a vector. */
743 retrieve_select_type (fd_set
*set
, SCM ports_ready
, SCM list_or_vec
)
745 SCM answer_list
= ports_ready
;
747 if (scm_is_vector (list_or_vec
))
749 int i
= SCM_SIMPLE_VECTOR_LENGTH (list_or_vec
);
753 answer_list
= get_element (set
,
754 SCM_SIMPLE_VECTOR_REF (list_or_vec
, i
),
757 return scm_vector (answer_list
);
761 /* list_or_vec must be a list. */
762 while (!SCM_NULL_OR_NIL_P (list_or_vec
))
764 answer_list
= get_element (set
, SCM_CAR (list_or_vec
), answer_list
);
765 list_or_vec
= SCM_CDR (list_or_vec
);
771 /* Static helper functions above refer to s_scm_select directly as s_select */
772 SCM_DEFINE (scm_select
, "select", 3, 2, 0,
773 (SCM reads
, SCM writes
, SCM excepts
, SCM secs
, SCM usecs
),
774 "This procedure has a variety of uses: waiting for the ability\n"
775 "to provide input, accept output, or the existence of\n"
776 "exceptional conditions on a collection of ports or file\n"
777 "descriptors, or waiting for a timeout to occur.\n\n"
779 "When an error occurs, of if it is interrupted by a signal, this\n"
780 "procedure throws a @code{system-error} exception\n"
781 "(@pxref{Conventions, @code{system-error}}). In case of an\n"
782 "interruption, the associated error number is @var{EINTR}.\n\n"
784 "@var{reads}, @var{writes} and @var{excepts} can be lists or\n"
785 "vectors, with each member a port or a file descriptor.\n"
786 "The value returned is a list of three corresponding\n"
787 "lists or vectors containing only the members which meet the\n"
788 "specified requirement. The ability of port buffers to\n"
789 "provide input or accept output is taken into account.\n"
790 "Ordering of the input lists or vectors is not preserved.\n\n"
791 "The optional arguments @var{secs} and @var{usecs} specify the\n"
792 "timeout. Either @var{secs} can be specified alone, as\n"
793 "either an integer or a real number, or both @var{secs} and\n"
794 "@var{usecs} can be specified as integers, in which case\n"
795 "@var{usecs} is an additional timeout expressed in\n"
796 "microseconds. If @var{secs} is omitted or is @code{#f} then\n"
797 "select will wait for as long as it takes for one of the other\n"
798 "conditions to be satisfied.\n\n"
799 "The scsh version of @code{select} differs as follows:\n"
800 "Only vectors are accepted for the first three arguments.\n"
801 "The @var{usecs} argument is not supported.\n"
802 "Multiple values are returned instead of a list.\n"
803 "Duplicates in the input vectors appear only once in output.\n"
804 "An additional @code{select!} interface is provided.")
805 #define FUNC_NAME s_scm_select
807 struct timeval timeout
;
808 struct timeval
* time_ptr
;
815 /* these lists accumulate ports which are ready due to buffering.
816 their file descriptors don't need to be added to the select sets. */
817 SCM read_ports_ready
= SCM_EOL
;
818 SCM write_ports_ready
= SCM_EOL
;
821 if (scm_is_vector (reads
))
823 read_count
= SCM_SIMPLE_VECTOR_LENGTH (reads
);
827 read_count
= scm_ilength (reads
);
828 SCM_ASSERT (read_count
>= 0, reads
, SCM_ARG1
, FUNC_NAME
);
830 if (scm_is_vector (writes
))
832 write_count
= SCM_SIMPLE_VECTOR_LENGTH (writes
);
836 write_count
= scm_ilength (writes
);
837 SCM_ASSERT (write_count
>= 0, writes
, SCM_ARG2
, FUNC_NAME
);
839 if (scm_is_vector (excepts
))
841 except_count
= SCM_SIMPLE_VECTOR_LENGTH (excepts
);
845 except_count
= scm_ilength (excepts
);
846 SCM_ASSERT (except_count
>= 0, excepts
, SCM_ARG3
, FUNC_NAME
);
850 FD_ZERO (&write_set
);
851 FD_ZERO (&except_set
);
853 max_fd
= fill_select_type (&read_set
, &read_ports_ready
, reads
, SCM_ARG1
);
856 int write_max
= fill_select_type (&write_set
, &write_ports_ready
,
858 int except_max
= fill_select_type (&except_set
, NULL
,
861 if (write_max
> max_fd
)
863 if (except_max
> max_fd
)
867 /* if there's a port with a ready buffer, don't block, just
868 check for ready file descriptors. */
869 if (!scm_is_null (read_ports_ready
) || !scm_is_null (write_ports_ready
))
875 else if (SCM_UNBNDP (secs
) || scm_is_false (secs
))
879 if (scm_is_unsigned_integer (secs
, 0, ULONG_MAX
))
881 timeout
.tv_sec
= scm_to_ulong (secs
);
882 if (SCM_UNBNDP (usecs
))
885 timeout
.tv_usec
= scm_to_long (usecs
);
889 double fl
= scm_to_double (secs
);
891 if (!SCM_UNBNDP (usecs
))
892 SCM_WRONG_TYPE_ARG (4, secs
);
894 SCM_OUT_OF_RANGE (4, secs
);
895 timeout
.tv_sec
= (long) fl
;
896 timeout
.tv_usec
= (long) ((fl
- timeout
.tv_sec
) * 1000000);
902 int rv
= select (max_fd
+ 1,
903 &read_set
, &write_set
, &except_set
,
908 return scm_list_3 (retrieve_select_type (&read_set
, read_ports_ready
, reads
),
909 retrieve_select_type (&write_set
, write_ports_ready
, writes
),
910 retrieve_select_type (&except_set
, SCM_EOL
, excepts
));
917 SCM_DEFINE (scm_fcntl
, "fcntl", 2, 1, 0,
918 (SCM object
, SCM cmd
, SCM value
),
919 "Apply @var{cmd} to the specified file descriptor or the underlying\n"
920 "file descriptor of the specified port. @var{value} is an optional\n"
921 "integer argument.\n\n"
922 "Values for @var{cmd} are:\n\n"
925 "Duplicate a file descriptor\n"
927 "Get flags associated with the file descriptor.\n"
929 "Set flags associated with the file descriptor to @var{value}.\n"
931 "Get flags associated with the open file.\n"
933 "Set flags associated with the open file to @var{value}\n"
935 "Get the process ID of a socket's owner, for @code{SIGIO} signals.\n"
937 "Set the process that owns a socket to @var{value}, for @code{SIGIO} signals.\n"
939 "The value used to indicate the \"close on exec\" flag with @code{F_GETFL} or\n"
942 #define FUNC_NAME s_scm_fcntl
948 object
= SCM_COERCE_OUTPORT (object
);
950 if (SCM_OPFPORTP (object
))
951 fdes
= SCM_FPORT_FDES (object
);
953 fdes
= scm_to_int (object
);
955 if (SCM_UNBNDP (value
))
958 ivalue
= scm_to_int (value
);
960 SCM_SYSCALL (rv
= fcntl (fdes
, scm_to_int (cmd
), ivalue
));
963 return scm_from_int (rv
);
966 #endif /* HAVE_FCNTL */
968 SCM_DEFINE (scm_fsync
, "fsync", 1, 0, 0,
970 "Copies any unwritten data for the specified output file\n"
971 "descriptor to disk. If @var{object} is a port, its buffer is\n"
972 "flushed before the underlying file descriptor is fsync'd.\n"
973 "The return value is unspecified.")
974 #define FUNC_NAME s_scm_fsync
978 object
= SCM_COERCE_OUTPORT (object
);
980 if (SCM_OPFPORTP (object
))
982 scm_flush_unlocked (object
);
983 fdes
= SCM_FPORT_FDES (object
);
986 fdes
= scm_to_int (object
);
988 if (fsync (fdes
) == -1)
990 return SCM_UNSPECIFIED
;
995 SCM_DEFINE (scm_symlink
, "symlink", 2, 0, 0,
996 (SCM oldpath
, SCM newpath
),
997 "Create a symbolic link named @var{oldpath} with the value\n"
998 "(i.e., pointing to) @var{newpath}. The return value is\n"
1000 #define FUNC_NAME s_scm_symlink
1004 STRING2_SYSCALL (oldpath
, c_oldpath
,
1006 val
= symlink (c_oldpath
, c_newpath
));
1009 return SCM_UNSPECIFIED
;
1012 #endif /* HAVE_SYMLINK */
1014 SCM_DEFINE (scm_readlink
, "readlink", 1, 0, 0,
1016 "Return the value of the symbolic link named by @var{path} (a\n"
1017 "string), i.e., the file that the link points to.")
1018 #define FUNC_NAME s_scm_readlink
1026 scm_dynwind_begin (0);
1028 c_path
= scm_to_locale_string (path
);
1029 scm_dynwind_free (c_path
);
1031 buf
= scm_malloc (size
);
1033 while ((rv
= readlink (c_path
, buf
, size
)) == size
)
1037 buf
= scm_malloc (size
);
1041 int save_errno
= errno
;
1046 result
= scm_take_locale_stringn (buf
, rv
);
1053 SCM_DEFINE (scm_copy_file
, "copy-file", 2, 0, 0,
1054 (SCM oldfile
, SCM newfile
),
1055 "Copy the file specified by @var{oldfile} to @var{newfile}.\n"
1056 "The return value is unspecified.")
1057 #define FUNC_NAME s_scm_copy_file
1059 char *c_oldfile
, *c_newfile
;
1063 struct stat_or_stat64 oldstat
;
1065 scm_dynwind_begin (0);
1067 c_oldfile
= scm_to_locale_string (oldfile
);
1068 scm_dynwind_free (c_oldfile
);
1069 c_newfile
= scm_to_locale_string (newfile
);
1070 scm_dynwind_free (c_newfile
);
1072 oldfd
= open_or_open64 (c_oldfile
, O_RDONLY
| O_BINARY
);
1076 SCM_SYSCALL (rv
= fstat_or_fstat64 (oldfd
, &oldstat
));
1078 goto err_close_oldfd
;
1080 /* use POSIX flags instead of 07777?. */
1081 newfd
= open_or_open64 (c_newfile
, O_WRONLY
| O_CREAT
| O_TRUNC
,
1082 oldstat
.st_mode
& 07777);
1090 while ((n
= read (oldfd
, buf
, sizeof buf
)) > 0)
1091 if (write (newfd
, buf
, n
) != n
)
1098 if (close (newfd
) == -1)
1102 return SCM_UNSPECIFIED
;
1106 SCM_DEFINE (scm_sendfile
, "sendfile", 3, 1, 0,
1107 (SCM out
, SCM in
, SCM count
, SCM offset
),
1108 "Send @var{count} bytes from @var{in} to @var{out}, both of which "
1109 "must be either open file ports or file descriptors. When "
1110 "@var{offset} is omitted, start reading from @var{in}'s current "
1111 "position; otherwise, start reading at @var{offset}. Return "
1112 "the number of bytes actually sent.")
1113 #define FUNC_NAME s_scm_sendfile
1115 #define VALIDATE_FD_OR_PORT(cvar, svar, pos) \
1116 if (scm_is_integer (svar)) \
1117 cvar = scm_to_int (svar); \
1120 SCM_VALIDATE_OPFPORT (pos, svar); \
1122 cvar = SCM_FPORT_FDES (svar); \
1125 ssize_t result SCM_UNUSED
;
1126 size_t c_count
, total
= 0;
1130 VALIDATE_FD_OR_PORT (out_fd
, out
, 1);
1131 VALIDATE_FD_OR_PORT (in_fd
, in
, 2);
1132 c_count
= scm_to_size_t (count
);
1133 c_offset
= SCM_UNBNDP (offset
) ? 0 : scm_to_off_t (offset
);
1135 #if defined HAVE_SYS_SENDFILE_H && defined HAVE_SENDFILE
1136 /* The Linux-style sendfile(2), which is different from the BSD-style. */
1141 offset_ptr
= SCM_UNBNDP (offset
) ? NULL
: &c_offset
;
1143 /* On Linux, when OUT_FD is a file, everything is transferred at once and
1144 RESULT == C_COUNT. However, when OUT_FD is a pipe or other "slow"
1145 device, fewer bytes may be transferred, hence the loop. RESULT == 0
1146 means EOF on IN_FD, so leave the loop in that case. */
1149 result
= sendfile_or_sendfile64 (out_fd
, in_fd
, offset_ptr
,
1152 /* At this point, either OFFSET_PTR is non-NULL and it has been
1153 updated to the current offset in IN_FD, or it is NULL and IN_FD's
1154 offset has been updated. */
1156 else if (result
< 0 && (errno
== EINTR
|| errno
== EAGAIN
))
1160 while (total
< c_count
&& result
> 0);
1163 /* Quoting the Linux man page: "In Linux kernels before 2.6.33, out_fd
1164 must refer to a socket. Since Linux 2.6.33 it can be any file."
1165 Fall back to read(2) and write(2) when such an error occurs. */
1166 if (result
< 0 && errno
!= EINVAL
&& errno
!= ENOSYS
)
1168 else if (result
< 0)
1173 int reached_eof
= 0;
1175 if (!SCM_UNBNDP (offset
))
1178 scm_seek (in
, scm_from_off_t (c_offset
), scm_from_int (SEEK_SET
));
1181 if (lseek_or_lseek64 (in_fd
, c_offset
, SEEK_SET
) < 0)
1186 for (total
= 0, left
= c_count
; total
< c_count
&& !reached_eof
; )
1188 size_t asked
, obtained
, written
;
1190 asked
= MIN (sizeof buf
, left
);
1191 obtained
= full_read (in_fd
, buf
, asked
);
1192 if (obtained
< asked
)
1202 written
= full_write (out_fd
, buf
, obtained
);
1203 if (written
< obtained
)
1211 return scm_from_size_t (total
);
1213 #undef VALIDATE_FD_OR_PORT
1217 #endif /* HAVE_POSIX */
1220 /* Essential procedures used in (system base compile). */
1223 SCM_DEFINE (scm_getcwd
, "getcwd", 0, 0, 0,
1225 "Return the name of the current working directory.")
1226 #define FUNC_NAME s_scm_getcwd
1233 wd
= scm_malloc (size
);
1234 while ((rv
= getcwd (wd
, size
)) == 0 && errno
== ERANGE
)
1238 wd
= scm_malloc (size
);
1242 int save_errno
= errno
;
1247 /* On Windows, convert backslashes in current directory to forward
1249 scm_i_mirror_backslashes (wd
);
1250 result
= scm_from_locale_stringn (wd
, strlen (wd
));
1255 #endif /* HAVE_GETCWD */
1257 SCM_DEFINE (scm_mkdir
, "mkdir", 1, 1, 0,
1258 (SCM path
, SCM mode
),
1259 "Create a new directory named by @var{path}. If @var{mode} is omitted\n"
1260 "then the permissions of the directory file are set using the current\n"
1261 "umask. Otherwise they are set to the decimal value specified with\n"
1262 "@var{mode}. The return value is unspecified.")
1263 #define FUNC_NAME s_scm_mkdir
1268 if (SCM_UNBNDP (mode
))
1272 STRING_SYSCALL (path
, c_path
, rv
= mkdir (c_path
, 0777 ^ mask
));
1276 STRING_SYSCALL (path
, c_path
, rv
= mkdir (c_path
, scm_to_uint (mode
)));
1280 return SCM_UNSPECIFIED
;
1284 SCM_DEFINE (scm_rmdir
, "rmdir", 1, 0, 0,
1286 "Remove the existing directory named by @var{path}. The directory must\n"
1287 "be empty for this to succeed. The return value is unspecified.")
1288 #define FUNC_NAME s_scm_rmdir
1292 STRING_SYSCALL (path
, c_path
, val
= rmdir (c_path
));
1295 return SCM_UNSPECIFIED
;
1299 SCM_DEFINE (scm_rename
, "rename-file", 2, 0, 0,
1300 (SCM oldname
, SCM newname
),
1301 "Renames the file specified by @var{oldname} to @var{newname}.\n"
1302 "The return value is unspecified.")
1303 #define FUNC_NAME s_scm_rename
1307 STRING2_SYSCALL (oldname
, c_oldname
,
1309 rv
= rename (c_oldname
, c_newname
));
1312 return SCM_UNSPECIFIED
;
1317 SCM_DEFINE (scm_delete_file
, "delete-file", 1, 0, 0,
1319 "Deletes (or \"unlinks\") the file specified by @var{str}.")
1320 #define FUNC_NAME s_scm_delete_file
1323 STRING_SYSCALL (str
, c_str
, ans
= unlink (c_str
));
1326 return SCM_UNSPECIFIED
;
1330 SCM_DEFINE (scm_access
, "access?", 2, 0, 0,
1331 (SCM path
, SCM how
),
1332 "Test accessibility of a file under the real UID and GID of the\n"
1333 "calling process. The return is @code{#t} if @var{path} exists\n"
1334 "and the permissions requested by @var{how} are all allowed, or\n"
1335 "@code{#f} if not.\n"
1337 "@var{how} is an integer which is one of the following values,\n"
1338 "or a bitwise-OR (@code{logior}) of multiple values.\n"
1341 "Test for read permission.\n"
1344 "Test for write permission.\n"
1347 "Test for execute permission.\n"
1350 "Test for existence of the file. This is implied by each of the\n"
1351 "other tests, so there's no need to combine it with them.\n"
1354 "It's important to note that @code{access?} does not simply\n"
1355 "indicate what will happen on attempting to read or write a\n"
1356 "file. In normal circumstances it does, but in a set-UID or\n"
1357 "set-GID program it doesn't because @code{access?} tests the\n"
1358 "real ID, whereas an open or execute attempt uses the effective\n"
1361 "A program which will never run set-UID/GID can ignore the\n"
1362 "difference between real and effective IDs, but for maximum\n"
1363 "generality, especially in library functions, it's best not to\n"
1364 "use @code{access?} to predict the result of an open or execute,\n"
1365 "instead simply attempt that and catch any exception.\n"
1367 "The main use for @code{access?} is to let a set-UID/GID program\n"
1368 "determine what the invoking user would have been allowed to do,\n"
1369 "without the greater (or perhaps lesser) privileges afforded by\n"
1370 "the effective ID. For more on this, see ``Testing File\n"
1371 "Access'' in The GNU C Library Reference Manual.")
1372 #define FUNC_NAME s_scm_access
1377 c_path
= scm_to_locale_string (path
);
1378 rv
= access (c_path
, scm_to_int (how
));
1381 return scm_from_bool (!rv
);
1385 SCM_DEFINE (scm_chmod
, "chmod", 2, 0, 0,
1386 (SCM object
, SCM mode
),
1387 "Changes the permissions of the file referred to by\n"
1388 "@var{object}. @var{object} can be a string containing a file\n"
1389 "name or a port or integer file descriptor which is open on a\n"
1390 "file (in which case @code{fchmod} is used as the underlying\n"
1391 "system call). @var{mode} specifies the new permissions as a\n"
1392 "decimal number, e.g., @code{(chmod \"foo\" #o755)}.\n"
1393 "The return value is unspecified.")
1394 #define FUNC_NAME s_scm_chmod
1398 object
= SCM_COERCE_OUTPORT (object
);
1401 if (scm_is_integer (object
) || SCM_OPFPORTP (object
))
1404 if (scm_is_integer (object
))
1405 fdes
= scm_to_int (object
);
1407 fdes
= SCM_FPORT_FDES (object
);
1408 SCM_SYSCALL (rv
= fchmod (fdes
, scm_to_int (mode
)));
1413 STRING_SYSCALL (object
, c_object
,
1414 rv
= chmod (c_object
, scm_to_int (mode
)));
1418 return SCM_UNSPECIFIED
;
1422 SCM_DEFINE (scm_umask
, "umask", 0, 1, 0,
1424 "If @var{mode} is omitted, returns a decimal number representing the current\n"
1425 "file creation mask. Otherwise the file creation mask is set to\n"
1426 "@var{mode} and the previous value is returned.\n\n"
1427 "E.g., @code{(umask #o022)} sets the mask to octal 22, decimal 18.")
1428 #define FUNC_NAME s_scm_umask
1431 if (SCM_UNBNDP (mode
))
1438 mask
= umask (scm_to_uint (mode
));
1440 return scm_from_uint (mask
);
1444 SCM_DEFINE (scm_mkstemp
, "mkstemp!", 1, 0, 0,
1446 "Create a new unique file in the file system and return a new\n"
1447 "buffered port open for reading and writing to the file.\n"
1449 "@var{tmpl} is a string specifying where the file should be\n"
1450 "created: it must end with @samp{XXXXXX} and those @samp{X}s\n"
1451 "will be changed in the string to return the name of the file.\n"
1452 "(@code{port-filename} on the port also gives the name.)\n"
1454 "POSIX doesn't specify the permissions mode of the file, on GNU\n"
1455 "and most systems it's @code{#o600}. An application can use\n"
1456 "@code{chmod} to relax that if desired. For example\n"
1457 "@code{#o666} less @code{umask}, which is usual for ordinary\n"
1461 "(let ((port (mkstemp! (string-copy \"/tmp/myfile-XXXXXX\"))))\n"
1462 " (chmod port (logand #o666 (lognot (umask))))\n"
1465 #define FUNC_NAME s_scm_mkstemp
1470 scm_dynwind_begin (0);
1472 c_tmpl
= scm_to_locale_string (tmpl
);
1473 scm_dynwind_free (c_tmpl
);
1475 SCM_SYSCALL (rv
= mkstemp (c_tmpl
));
1479 scm_substring_move_x (scm_from_locale_string (c_tmpl
),
1480 SCM_INUM0
, scm_string_length (tmpl
),
1484 return scm_fdes_to_port (rv
, "w+", tmpl
);
1489 /* Filename manipulation */
1494 SCM_SYMBOL (sym_file_name_convention
, "windows");
1496 SCM_SYMBOL (sym_file_name_convention
, "posix");
1499 SCM_INTERNAL SCM
scm_system_file_name_convention (void);
1501 SCM_DEFINE (scm_system_file_name_convention
,
1502 "system-file-name-convention", 0, 0, 0, (void),
1503 "Return either @code{posix} or @code{windows}, depending on\n"
1504 "what kind of system this Guile is running on.")
1505 #define FUNC_NAME s_scm_system_file_name_convention
1507 return sym_file_name_convention
;
1511 SCM_DEFINE (scm_dirname
, "dirname", 1, 0, 0,
1513 "Return the directory name component of the file name\n"
1514 "@var{filename}. If @var{filename} does not contain a directory\n"
1515 "component, @code{.} is returned.")
1516 #define FUNC_NAME s_scm_dirname
1519 unsigned long int len
;
1521 SCM_VALIDATE_STRING (1, filename
);
1523 len
= scm_i_string_length (filename
);
1527 while (i
>= 0 && is_file_name_separator (scm_c_string_ref (filename
, i
)))
1529 while (i
>= 0 && !is_file_name_separator (scm_c_string_ref (filename
, i
)))
1531 while (i
>= 0 && is_file_name_separator (scm_c_string_ref (filename
, i
)))
1536 if (len
> 0 && is_file_name_separator (scm_c_string_ref (filename
, 0)))
1537 return scm_c_substring (filename
, 0, 1);
1539 return scm_dot_string
;
1542 return scm_c_substring (filename
, 0, i
+ 1);
1546 SCM_DEFINE (scm_basename
, "basename", 1, 1, 0,
1547 (SCM filename
, SCM suffix
),
1548 "Return the base name of the file name @var{filename}. The\n"
1549 "base name is the file name without any directory components.\n"
1550 "If @var{suffix} is provided, and is equal to the end of\n"
1551 "@var{filename}, it is removed also.")
1552 #define FUNC_NAME s_scm_basename
1556 SCM_VALIDATE_STRING (1, filename
);
1557 len
= scm_i_string_length (filename
);
1559 if (SCM_UNBNDP (suffix
))
1563 SCM_VALIDATE_STRING (2, suffix
);
1564 j
= scm_i_string_length (suffix
) - 1;
1567 while (i
>= 0 && is_file_name_separator (scm_c_string_ref (filename
, i
)))
1570 while (i
>= 0 && j
>= 0
1571 && (scm_i_string_ref (filename
, i
)
1572 == scm_i_string_ref (suffix
, j
)))
1579 while (i
>= 0 && !is_file_name_separator (scm_c_string_ref (filename
, i
)))
1583 if (len
> 0 && is_file_name_separator (scm_c_string_ref (filename
, 0)))
1584 return scm_c_substring (filename
, 0, 1);
1586 return scm_dot_string
;
1589 return scm_c_substring (filename
, i
+1, end
+1);
1593 SCM_DEFINE (scm_canonicalize_path
, "canonicalize-path", 1, 0, 0,
1595 "Return the canonical path of @var{path}. A canonical path has\n"
1596 "no @code{.} or @code{..} components, nor any repeated path\n"
1597 "separators (@code{/}) nor symlinks.\n\n"
1598 "Raises an error if any component of @var{path} does not exist.")
1599 #define FUNC_NAME s_scm_canonicalize_path
1603 SCM_VALIDATE_STRING (1, path
);
1605 str
= scm_to_locale_string (path
);
1606 canon
= canonicalize_file_name (str
);
1610 return scm_take_locale_string (canon
);
1617 scm_i_relativize_path (SCM path
, SCM in_path
)
1622 str
= scm_to_locale_string (path
);
1623 canon
= canonicalize_file_name (str
);
1629 scanon
= scm_take_locale_string (canon
);
1631 for (; scm_is_pair (in_path
); in_path
= scm_cdr (in_path
))
1633 SCM dir
= scm_car (in_path
);
1634 size_t len
= scm_c_string_length (dir
);
1636 /* When DIR is empty, it means "current working directory". We
1637 could set DIR to (getcwd) in that case, but then the
1638 canonicalization would depend on the current directory, which
1639 is not what we want in the context of `compile-file', for
1642 && scm_is_true (scm_string_prefix_p (dir
, scanon
,
1643 SCM_UNDEFINED
, SCM_UNDEFINED
,
1644 SCM_UNDEFINED
, SCM_UNDEFINED
)))
1646 /* DIR either has a trailing delimiter or doesn't. SCANON
1647 will be delimited by single delimiters. When DIR does not
1648 have a trailing delimiter, add one to the length to strip
1649 off the delimiter within SCANON. */
1650 if (!is_file_name_separator (scm_c_string_ref (dir
, len
- 1)))
1653 if (scm_c_string_length (scanon
) > len
)
1654 return scm_substring (scanon
, scm_from_size_t (len
), SCM_UNDEFINED
);
1664 /* Examining directories. These procedures are used by `check-guile'
1665 and thus compiled unconditionally. */
1667 scm_t_bits scm_tc16_dir
;
1670 SCM_DEFINE (scm_directory_stream_p
, "directory-stream?", 1, 0, 0,
1672 "Return a boolean indicating whether @var{obj} is a directory\n"
1673 "stream as returned by @code{opendir}.")
1674 #define FUNC_NAME s_scm_directory_stream_p
1676 return scm_from_bool (SCM_DIRP (obj
));
1681 SCM_DEFINE (scm_opendir
, "opendir", 1, 0, 0,
1683 "Open the directory specified by @var{dirname} and return a directory\n"
1685 #define FUNC_NAME s_scm_opendir
1688 STRING_SYSCALL (dirname
, c_dirname
, ds
= opendir (c_dirname
));
1691 SCM_RETURN_NEWSMOB (scm_tc16_dir
| (SCM_DIR_FLAG_OPEN
<<16), ds
);
1696 /* FIXME: The glibc manual has a portability note that readdir_r may not
1697 null-terminate its return string. The circumstances outlined for this
1698 are not clear, nor is it clear what should be done about it. Lets use
1699 NAMLEN and worry about what else should be done if/when someone can
1702 SCM_DEFINE (scm_readdir
, "readdir", 1, 0, 0,
1704 "Return (as a string) the next directory entry from the directory stream\n"
1705 "@var{port}. If there is no remaining entry to be read then the\n"
1706 "end of file object is returned.")
1707 #define FUNC_NAME s_scm_readdir
1709 struct dirent_or_dirent64
*rdent
;
1711 SCM_VALIDATE_DIR (1, port
);
1712 if (!SCM_DIR_OPEN_P (port
))
1713 SCM_MISC_ERROR ("Directory ~S is not open.", scm_list_1 (port
));
1716 /* As noted in the glibc manual, on various systems (such as Solaris)
1717 the d_name[] field is only 1 char and you're expected to size the
1718 dirent buffer for readdir_r based on NAME_MAX. The MAX expressions
1719 below effectively give either sizeof(d_name) or NAME_MAX+1,
1720 whichever is bigger.
1722 On solaris 10 there's no NAME_MAX constant, it's necessary to use
1723 pathconf(). We prefer NAME_MAX though, since it should be a constant
1724 and will therefore save a system call. We also prefer it since dirfd()
1725 is not available everywhere.
1727 An alternative to dirfd() would be to open() the directory and then use
1728 fdopendir(), if the latter is available. That'd let us hold the fd
1729 somewhere in the smob, or just the dirent size calculated once. */
1731 struct dirent_or_dirent64 de
; /* just for sizeof */
1732 DIR *ds
= (DIR *) SCM_SMOB_DATA_1 (port
);
1734 char buf
[MAX (sizeof (de
),
1735 sizeof (de
) - sizeof (de
.d_name
) + NAME_MAX
+ 1)];
1738 long name_max
= fpathconf (dirfd (ds
), _PC_NAME_MAX
);
1741 buf
= alloca (MAX (sizeof (de
),
1742 sizeof (de
) - sizeof (de
.d_name
) + name_max
+ 1));
1746 SCM_SYSCALL (readdir_r_or_readdir64_r (ds
, (struct dirent_or_dirent64
*) buf
, &rdent
));
1752 return (rdent
? scm_from_locale_stringn (rdent
->d_name
, NAMLEN (rdent
))
1758 scm_dynwind_begin (0);
1759 scm_i_dynwind_pthread_mutex_lock (&scm_i_misc_mutex
);
1762 SCM_SYSCALL (rdent
= readdir_or_readdir64 ((DIR *) SCM_SMOB_DATA_1 (port
)));
1766 ret
= (rdent
? scm_from_locale_stringn (rdent
->d_name
, NAMLEN (rdent
))
1777 SCM_DEFINE (scm_rewinddir
, "rewinddir", 1, 0, 0,
1779 "Reset the directory port @var{port} so that the next call to\n"
1780 "@code{readdir} will return the first directory entry.")
1781 #define FUNC_NAME s_scm_rewinddir
1783 SCM_VALIDATE_DIR (1, port
);
1784 if (!SCM_DIR_OPEN_P (port
))
1785 SCM_MISC_ERROR ("Directory ~S is not open.", scm_list_1 (port
));
1787 rewinddir ((DIR *) SCM_SMOB_DATA_1 (port
));
1789 return SCM_UNSPECIFIED
;
1794 SCM_DEFINE (scm_closedir
, "closedir", 1, 0, 0,
1796 "Close the directory stream @var{port}.\n"
1797 "The return value is unspecified.")
1798 #define FUNC_NAME s_scm_closedir
1800 SCM_VALIDATE_DIR (1, port
);
1802 if (SCM_DIR_OPEN_P (port
))
1806 SCM_SYSCALL (sts
= closedir ((DIR *) SCM_SMOB_DATA_1 (port
)));
1810 SCM_SET_SMOB_DATA_0 (port
, scm_tc16_dir
);
1813 return SCM_UNSPECIFIED
;
1820 scm_dir_print (SCM exp
, SCM port
, scm_print_state
*pstate SCM_UNUSED
)
1822 scm_puts_unlocked ("#<", port
);
1823 if (!SCM_DIR_OPEN_P (exp
))
1824 scm_puts_unlocked ("closed: ", port
);
1825 scm_puts_unlocked ("directory stream ", port
);
1826 scm_uintprint (SCM_SMOB_DATA_1 (exp
), 16, port
);
1827 scm_putc_unlocked ('>', port
);
1833 scm_dir_free (SCM p
)
1835 if (SCM_DIR_OPEN_P (p
))
1836 closedir ((DIR *) SCM_SMOB_DATA_1 (p
));
1847 scm_tc16_dir
= scm_make_smob_type ("directory", 0);
1848 scm_set_smob_free (scm_tc16_dir
, scm_dir_free
);
1849 scm_set_smob_print (scm_tc16_dir
, scm_dir_print
);
1852 scm_c_define ("O_RDONLY", scm_from_int (O_RDONLY
));
1855 scm_c_define ("O_WRONLY", scm_from_int (O_WRONLY
));
1858 scm_c_define ("O_RDWR", scm_from_int (O_RDWR
));
1861 scm_c_define ("O_CREAT", scm_from_int (O_CREAT
));
1864 scm_c_define ("O_EXCL", scm_from_int (O_EXCL
));
1867 scm_c_define ("O_NOCTTY", scm_from_int (O_NOCTTY
));
1870 scm_c_define ("O_TRUNC", scm_from_int (O_TRUNC
));
1873 scm_c_define ("O_APPEND", scm_from_int (O_APPEND
));
1876 scm_c_define ("O_NONBLOCK", scm_from_int (O_NONBLOCK
));
1879 scm_c_define ("O_NDELAY", scm_from_int (O_NDELAY
));
1882 scm_c_define ("O_SYNC", scm_from_int (O_SYNC
));
1885 scm_c_define ("O_LARGEFILE", scm_from_int (O_LARGEFILE
));
1888 scm_c_define ("O_NOTRANS", scm_from_int (O_NOTRANS
));
1892 scm_c_define ("F_DUPFD", scm_from_int (F_DUPFD
));
1895 scm_c_define ("F_GETFD", scm_from_int (F_GETFD
));
1898 scm_c_define ("F_SETFD", scm_from_int (F_SETFD
));
1901 scm_c_define ("F_GETFL", scm_from_int (F_GETFL
));
1904 scm_c_define ("F_SETFL", scm_from_int (F_SETFL
));
1907 scm_c_define ("F_GETOWN", scm_from_int (F_GETOWN
));
1910 scm_c_define ("F_SETOWN", scm_from_int (F_SETOWN
));
1913 scm_c_define ("FD_CLOEXEC", scm_from_int (FD_CLOEXEC
));
1915 #endif /* HAVE_POSIX */
1917 /* `access' symbols. */
1918 scm_c_define ("R_OK", scm_from_int (R_OK
));
1919 scm_c_define ("W_OK", scm_from_int (W_OK
));
1920 scm_c_define ("X_OK", scm_from_int (X_OK
));
1921 scm_c_define ("F_OK", scm_from_int (F_OK
));
1923 scm_dot_string
= scm_from_locale_string (".");
1925 #include "libguile/filesys.x"