Check to see if a file is accessible
Int_Type access (String_Type pathname, Int_Type mode)
This functions checks to see if the current process has access to the
specified pathname. The mode parameter determines the type of
desired access. Its value is given by the bitwise-or of one or more
of the following constants:
R_OK Check for read permission
W_OK Check for write permission
X_OK Check for execute permission
F_OK Check for existence
The function will return 0 if process has the requested access
permissions to the file, otherwise it will return -1 and set
errno accordingly.
Access to a file depend not only upon the file itself, but also upon the permissions of each of the directories in the pathname. The checks are done using the real user and group ids of the process, and not using the effective ids.
Change the current working directory
Int_Type chdir (String_Type dir)
The chdir function may be used to change the current working
directory to the directory specified by dir. Upon success it
returns zero. Upon failure it returns -1 and sets
errno accordingly.
Change the mode of a file
Int_Type chmod (String_Type file, Int_Type mode)
The chmod function changes the permissions of the specified
file to those given by mode. It returns 0 upon
success, or -1 upon failure setting errno accordingly.
See the system specific documentation for the C library
function chmod for a discussion of the mode parameter.
Change the owner of a file
Int_Type chown (String_Type file, Int_Type uid, Int_Type gid)
The chown function is used to change the user-id and group-id of
file to uid and gid, respectively. It returns
0 upon success and -1 upon failure, with errno
set accordingly.
On most systems, only the superuser can change the ownership of a file.
Some systems do not support this function.
Get the current working directory
String_Type getcwd ()
The getcwd function returns the absolute pathname of the
current working directory. If an error occurs or it cannot
determine the working directory, it returns NULL and sets
errno accordingly.
Under Unix, OS/2, and MSDOS, the pathname returned by this function includes the trailing slash character. It may also include the drive specifier for systems where that is meaningful.
Create a hard-link
Int_Type hardlink (String_Type oldpath, String_Type newpath)
The hardlink function creates a hard-link called
newpath to the existing file oldpath. If the link was
successfully created, the function will return 0. Upon error, the
function returns -1 and sets errno accordingly.
Not all systems support the concept of a hard-link.
Change the owner of a file
Int_Type lchown (String_Type file, Int_Type uid, Int_Type gid)
The lchown function is like chown, except that it does
not dereference a symbolic link. Hence, it may be used to change
the ownership of a symbolic link itself, and not to what it
references. See the documentation for the chown function for
more details.
Get a list of the files in a directory
String_Type[] listdir (String_Type dir)
The listdir function returns the directory listing of all the
files in the specified directory dir as an array of strings.
It does not return the special files ".." and "." as
part of the list.
Get information about a symbolic link
Struct_Type lstat_file (String_Type file)
The lstat_file function behaves identically to stat_file
but if file is a symbolic link, lstat_file returns
information about the link itself, and not the file that it
references.
See the documentation for stat_file for more information.
On systems that do not support symbolic links, there is no
difference between this function and the stat_file function.
Create a new directory
Int_Type mkdir (String_Type dir [,Int_Type mode])
The mkdir function creates a directory whose name is specified
by the dir parameter with permissions given by the optional
mode parameter. Upon success mkdir returns 0, or it
returns -1 upon failure setting errno accordingly. In
particular, if the directory already exists, the function will fail
and set errno to EEXIST.
The following function creates a new directory, if it does not
already exist (indicated by errno==EEXIST).
define my_mkdir (dir)
{
if (0 == mkdir (dir)) return;
if (errno == EEXIST) return;
throw IOError,
sprintf ("mkdir %s failed: %s", dir, errno_string (errno));
}
The mode parameter may not be meaningful on all systems. On
systems where it is meaningful, the actual permissions on the newly
created directory are modified by the process's umask.
String_Type readlink (String_Type path)
Get the value of a symbolic link
The readlink function returns the value of a symbolic link.
Upon failure, NULL is returned and errno set accordingly.
Not all systems support this function.
Delete a file
Int_Type remove (String_Type file)
The remove function deletes a file. It returns 0 upon
success, or -1 upon error and sets errno accordingly.
Rename a file
Int_Type rename (String_Type old, String_Type new)
The rename function renames a file from old to new
moving it between directories if necessary. This function may fail
if the directories are not on the same file system. It returns
0 upon success, or -1 upon error and sets errno accordingly.
Remove a directory
Int_Type rmdir (String_Type dir)
The rmdir function deletes the specified directory. It returns
0 upon success or -1 upon error and sets errno accordingly.
The directory must be empty before it can be removed.
Get information about a file
Struct_Type stat_file (String_Type file)
The stat_file function returns information about file
through the use of the system stat call. If the stat call
fails, the function returns NULL and sets errno accordingly.
If it is successful, it returns a stat structure with the following
integer-value fields:
st_dev
st_ino
st_mode
st_nlink
st_uid
st_gid
st_rdev
st_size
st_atime
st_mtime
st_ctime
stat for a discussion of the
meanings of these fields.
The following example shows how the stat_file function may be
used to get the size of a file:
define file_size (file)
{
variable st;
st = stat_file(file);
if (st == NULL)
throw IOError, "Unable to stat $file"$;
return st.st_size;
}
Parse the st_mode field of a stat structure
Char_Type stat_is (String_Type type, Int_Type st_mode)
The stat_is function returns a boolean value according to
whether or not the st_mode parameter is of the specified type.
Specifically, type must be one of the strings:
"sock" (socket)
"fifo" (fifo)
"blk" (block device)
"chr" (character device)
"reg" (regular file)
"lnk" (link)
"dir" (dir)
st_mode corresponds to
type.
The following example illustrates how to use the stat_is
function to determine whether or not a file is a directory:
define is_directory (file)
{
variable st;
st = stat_file (file);
if (st == NULL) return 0;
return stat_is ("dir", st.st_mode);
}
Format the file type code and access permission bits as a string
String_Type stat_mode_to_string (Int_Type st_mode)
The stat_mode_to_string function returns a 10 characters string
that indicates the type and permissions of a file as represented by
the st_mode parameter. The returned string consists of the following
characters:
"s" (socket)
"p" (fifo)
"b" (block device)
"c" (character device)
"-" (regular file)
"l" (link)
"d" (dir)
"s" (set-user-id)
"w" (writable)
"x" (executable)
"r" (readable)
This function is an slsh intrinsic. As such, it is not part of S-Lang proper.
Create a symbolic link
Int_Type symlink (String_Type oldpath, String_Type new_path)
The symlink function may be used to create a symbolic link
named new_path for oldpath. If successful, the function
returns 0, otherwise it returns -1 and sets errno appropriately.
This function is not supported on all systems and even if supported, not all file systems support the concept of a symbolic link.
Change a file's last access and modification times
Int_Type utime(String_Type file, Double_Type actime, Double_Type modtime)
This function may be used to change the last access (actime) and last
modification (modtime) times associated with the specified file. If
sucessful, the function returns 0; otherwise it returns -1 and sets
errno accordingly.
The utime function will call the C library utimes
function if available, which permits microsecond accuracy.
Otherwise, it will truncate the time arguments to integers and call
the utime function.