/*
* %CopyrightBegin%
*
* Copyright Ericsson AB 1997-2009. All Rights Reserved.
*
* The contents of this file are subject to the Erlang Public License,
* Version 1.1, (the "License"); you may not use this file except in
* compliance with the License. You should have received a copy of the
* Erlang Public License along with this software. If not, it can be
* retrieved online at http://www.erlang.org/.
*
* Software distributed under the License is distributed on an "AS IS"
* basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
* the License for the specific language governing rights and limitations
* under the License.
*
* %CopyrightEnd%
*/
/*
* Purpose: Provides file and directory operations for Unix.
*/
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#include "sys.h"
#include "erl_driver.h"
#include "erl_efile.h"
#include <utime.h>
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif
#ifdef HAVE_SYS_UIO_H
#include <sys/types.h>
#include <sys/uio.h>
#endif
#ifdef _OSE_
#include "efs.h"
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#ifdef _OSE_SFK_
#include <string.h>
#endif
#endif /* _OSE_ */
#if defined(__APPLE__) && defined(__MACH__) && !defined(__DARWIN__)
#define DARWIN 1
#endif
#ifdef DARWIN
#include <fcntl.h>
#endif /* DARWIN */
#ifdef VXWORKS
#include <ioLib.h>
#include <dosFsLib.h>
#include <nfsLib.h>
#include <sys/stat.h>
/*
** Not nice to include usrLib.h as MANY normal variable names get reported
** as shadowing globals, like 'i' for example.
** Instead we declare the only function we use here
*/
/*
* #include <usrLib.h>
*/
extern STATUS copy(char *, char *);
#include <errno.h>
#endif
#ifdef SUNOS4
# define getcwd(buf, size) getwd(buf)
#endif
/* Find a definition of MAXIOV, that is used in the code later. */
#if defined IOV_MAX
#define MAXIOV IOV_MAX
#elif defined UIO_MAXIOV
#define MAXIOV UIO_MAXIOV
#else
#define MAXIOV 16
#endif
/*
* Macros for testing file types.
*/
#ifdef _OSE_
#define ISDIR(st) S_ISDIR(((st).st_mode))
#define ISREG(st) S_ISREG(((st).st_mode))
#define ISDEV(st) (S_ISCHR(((st).st_mode)) || S_ISBLK(((st).st_mode)))
#define ISLNK(st) S_ISLNK(((st).st_mode))
#ifdef NO_UMASK
#define FILE_MODE (S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH)
#define DIR_MODE (S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH)
#else
#define FILE_MODE (S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH)
#define DIR_MODE (S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IWGRP | S_IXGRP | S_IROTH | \
S_IWOTH | S_IXOTH)
#endif
#else /* !_OSE_ */
#define ISDIR(st) (((st).st_mode & S_IFMT) == S_IFDIR)
#define ISREG(st) (((st).st_mode & S_IFMT) == S_IFREG)
#define ISDEV(st) \
(((st).st_mode&S_IFMT) == S_IFCHR || ((st).st_mode&S_IFMT) == S_IFBLK)
#define ISLNK(st) (((st).st_mode & S_IFLNK) == S_IFLNK)
#ifdef NO_UMASK
#define FILE_MODE 0644
#define DIR_MODE 0755
#else
#define FILE_MODE 0666
#define DIR_MODE 0777
#endif
#endif /* _OSE_ */
#ifdef VXWORKS /* Currently only used on vxworks */
#define EF_ALLOC(S) driver_alloc((S))
#define EF_REALLOC(P, S) driver_realloc((P), (S))
#define EF_SAFE_ALLOC(S) ef_safe_alloc((S))
#define EF_SAFE_REALLOC(P, S) ef_safe_realloc((P), (S))
#define EF_FREE(P) do { if((P)) driver_free((P)); } while(0)
extern void erl_exit(int n, char *fmt, _DOTS_);
static void *ef_safe_alloc(Uint s)
{
void *p = EF_ALLOC(s);
if (!p) erl_exit(1,
"unix efile drv: Can't allocate %d bytes of memory\n",
s);
return p;
}
#if 0 /* Currently not used */
static void *ef_safe_realloc(void *op, Uint s)
{
void *p = EF_REALLOC(op, s);
if (!p) erl_exit(1,
"unix efile drv: Can't reallocate %d bytes of memory\n",
s);
return p;
}
#endif /* #if 0 */
#endif /* #ifdef VXWORKS */
#define IS_DOT_OR_DOTDOT(s) \
(s[0] == '.' && (s[1] == '\0' || (s[1] == '.' && s[2] == '\0')))
#ifdef VXWORKS
static FUNCTION(int, vxworks_to_posix, (int vx_errno));
#endif
/*
** VxWorks (not) strikes again. Too long RESULTING paths
** may give the infamous bus error. Have to check ALL
** filenames and pathnames. No wonder the emulator is slow on
** these cards...
*/
#ifdef VXWORKS
#define CHECK_PATHLEN(Name, ErrInfo) \
if (path_size(Name) > PATH_MAX) { \
errno = ENAMETOOLONG; \
return check_error(-1, ErrInfo); \
}
#else
#define CHECK_PATHLEN(X,Y) /* Nothing */
#endif
static FUNCTION(int, check_error, (int result, Efile_error* errInfo));
static int
check_error(int result, Efile_error *errInfo)
{
if (result < 0) {
#ifdef VXWORKS
errInfo->posix_errno = errInfo->os_errno = vxworks_to_posix(errno);
#else
errInfo->posix_errno = errInfo->os_errno = errno;
#endif
return 0;
}
return 1;
}
#ifdef VXWORKS
/*
* VxWorks has different error codes for different file systems.
* We map those to POSIX ones.
*/
static int
vxworks_to_posix(int vx_errno)
{
DEBUGF(("[vxworks_to_posix] vx_errno: %08x\n", vx_errno));
switch (vx_errno) {
/* dosFsLib mapping */
#ifdef S_dosFsLib_FILE_ALREADY_EXISTS
case S_dosFsLib_FILE_ALREADY_EXISTS: return EEXIST;
#else
case S_dosFsLib_FILE_EXISTS: return EEXIST;
#endif
#ifdef S_dosFsLib_BAD_DISK
case S_dosFsLib_BAD_DISK: return EIO;
#endif
#ifdef S_dosFsLib_CANT_CHANGE_ROOT
case S_dosFsLib_CANT_CHANGE_ROOT: return EINVAL;
#endif
#ifdef S_dosFsLib_NO_BLOCK_DEVICE
case S_dosFsLib_NO_BLOCK_DEVICE: return ENOTBLK;
#endif
#ifdef S_dosFsLib_BAD_SEEK
case S_dosFsLib_BAD_SEEK: return ESPIPE;
#endif
case S_dosFsLib_VOLUME_NOT_AVAILABLE: return ENXIO;
case S_dosFsLib_DISK_FULL: return ENOSPC;
case S_dosFsLib_FILE_NOT_FOUND: return ENOENT;
case S_dosFsLib_NO_FREE_FILE_DESCRIPTORS: return ENFILE;
case S_dosFsLib_INVALID_NUMBER_OF_BYTES: return EINVAL;
case S_dosFsLib_ILLEGAL_NAME: return EINVAL;
case S_dosFsLib_CANT_DEL_ROOT: return EACCES;
case S_dosFsLib_NOT_FILE: return EISDIR;
case S_dosFsLib_NOT_DIRECTORY: return ENOTDIR;
case S_dosFsLib_NOT_SAME_VOLUME: return EXDEV;
case S_dosFsLib_READ_ONLY: return EACCES;
case S_dosFsLib_ROOT_DIR_FULL: return ENOSPC;
case S_dosFsLib_DIR_NOT_EMPTY: return EEXIST;
case S_dosFsLib_NO_LABEL: return ENXIO;
case S_dosFsLib_INVALID_PARAMETER: return EINVAL;
case S_dosFsLib_NO_CONTIG_SPACE: return ENOSPC;
case S_dosFsLib_FD_OBSOLETE: return EBADF;
case S_dosFsLib_DELETED: return EINVAL;
case S_dosFsLib_INTERNAL_ERROR: return EIO;
case S_dosFsLib_WRITE_ONLY: return EACCES;
/* nfsLib mapping - is needed since Windriver has used */
/* inconsistent error codes (errno.h/nfsLib.h). */
case S_nfsLib_NFS_OK: return 0;
case S_nfsLib_NFSERR_PERM: return EPERM;
case S_nfsLib_NFSERR_NOENT: return ENOENT;
case S_nfsLib_NFSERR_IO: return EIO;
case S_nfsLib_NFSERR_NXIO: return ENXIO;
#ifdef S_nfsLib_NFSERR_ACCES
case S_nfsLib_NFSERR_ACCES: return EACCES;
#else
case S_nfsLib_NFSERR_ACCESS: return EACCES;
#endif
case S_nfsLib_NFSERR_EXIST: return EEXIST;
case S_nfsLib_NFSERR_NODEV: return ENODEV;
case S_nfsLib_NFSERR_NOTDIR: return ENOTDIR;
case S_nfsLib_NFSERR_ISDIR: return EISDIR;
case S_nfsLib_NFSERR_FBIG: return EFBIG;
case S_nfsLib_NFSERR_NOSPC: return ENOSPC;
case S_nfsLib_NFSERR_ROFS: return EROFS;
case S_nfsLib_NFSERR_NAMETOOLONG: return ENAMETOOLONG;
case S_nfsLib_NFSERR_NOTEMPTY: return EEXIST;
case S_nfsLib_NFSERR_DQUOT: return ENOSPC;
case S_nfsLib_NFSERR_STALE: return EINVAL;
case S_nfsLib_NFSERR_WFLUSH: return ENXIO;
/* And sometimes (...) the error codes are from ioLib (as in the */
/* case of the (for nfsLib) unimplemented rename function) */
case S_ioLib_DISK_NOT_PRESENT: return EIO;
#if S_ioLib_DISK_NOT_PRESENT != S_ioLib_NO_DRIVER
case S_ioLib_NO_DRIVER: return ENXIO;
#endif
case S_ioLib_UNKNOWN_REQUEST: return ENOSYS;
case S_ioLib_DEVICE_TIMEOUT: return EIO;
#ifdef S_ioLib_UNFORMATED
/* Added (VxWorks 5.2 -> 5.3.1) */
#if S_ioLib_UNFORMATED != S_ioLib_DEVICE_TIMEOUT
case S_ioLib_UNFORMATED: return EIO;
#endif
#endif
#if S_ioLib_DEVICE_TIMEOUT != S_ioLib_DEVICE_ERROR
case S_ioLib_DEVICE_ERROR: return ENXIO;
#endif
case S_ioLib_WRITE_PROTECTED: return EACCES;
case S_ioLib_NO_FILENAME: return EINVAL;
case S_ioLib_CANCELLED: return EINTR;
case S_ioLib_NO_DEVICE_NAME_IN_PATH: return EINVAL;
case S_ioLib_NAME_TOO_LONG: return ENAMETOOLONG;
#ifdef S_objLib_OBJ_UNAVAILABLE
case S_objLib_OBJ_UNAVAILABLE: return ENOENT;
#endif
/* Temporary workaround for a weird error in passFs
(VxWorks Simsparc only). File operation fails because of
ENOENT, but errno is not set. */
#ifdef SIMSPARCSOLARIS
case 0: return ENOENT;
#endif
}
/* If the error code matches none of the above, assume */
/* it is a POSIX one already. The upper bits (>=16) are */
/* cleared since VxWorks uses those bits to indicate in */
/* what module the error occured. */
return vx_errno & 0xffff;
}
static int
vxworks_enotsup(Efile_error *errInfo)
{
errInfo->posix_errno = errInfo->os_errno = ENOTSUP;
return 0;
}
static int
count_path_length(char *pathname, char *pathname2)
{
static int stack[PATH_MAX / 2 + 1];
int sp = 0;
char *tmp;
char *cpy = NULL;
int i;
int sum;
for(i = 0;i < 2;++i) {
if (!i) {
cpy = EF_SAFE_ALLOC(strlen(pathname)+1);
strcpy(cpy, pathname);
} else if (pathname2 != NULL) {
EF_FREE(cpy);
cpy = EF_SAFE_ALLOC(strlen(pathname2)+1);
strcpy(cpy, pathname2);
} else
break;
for (tmp = strtok(cpy,"/"); tmp != NULL; tmp = strtok(NULL,"/")) {
if (!strcmp(tmp,"..") && sp > 0)
--sp;
else if (strcmp(tmp,"."))
stack[sp++] = strlen(tmp);
}
}
if (cpy != NULL)
EF_FREE(cpy);
sum = 0;
for(i = 0;i < sp; ++i)
sum += stack[i]+1;
return (sum) ? sum : 1;
}
static int
path_size(char *pathname)
{
static char currdir[PATH_MAX+2];
if (*pathname == '/')
return count_path_length(pathname,NULL);
ioDefPathGet(currdir);
strcat(currdir,"/");
return count_path_length(currdir,pathname);
}
#endif /* VXWORKS */
#ifdef _OSE_
static int
ose_enotsup(Efile_error *errInfo)
{
errInfo->posix_errno = errInfo->os_errno = ENOTSUP;
return 0;
}
#endif /* _OSE_ */
int
efile_mkdir(Efile_error* errInfo, /* Where to return error codes. */
char* name) /* Name of directory to create. */
{
CHECK_PATHLEN(name,errInfo);
#ifdef NO_MKDIR_MODE
#ifdef VXWORKS
/* This is a VxWorks/nfs workaround for erl_tar to create
* non-existant directories. (of some reason (...) VxWorks
* returns, the *non-module-prefixed*, 0xd code when
* trying to create a directory in a directory that doesn't exist).
* (see efile_openfile)
*/
if (mkdir(name) < 0) {
struct stat sb;
if (name[0] == '\0') {
/* Return the correct error code enoent */
errno = S_nfsLib_NFSERR_NOENT;
} else if (stat(name, &sb) == OK) {
errno = S_nfsLib_NFSERR_EXIST;
} else if((strchr(name, '/') != NULL) && (errno == 0xd)) {
/* Return the correct error code enoent */
errno = S_nfsLib_NFSERR_NOENT;
}
return check_error(-1, errInfo);
} else return 1;
#else
return check_error(mkdir(name), errInfo);
#endif
#else
return check_error(mkdir(name, DIR_MODE), errInfo);
#endif
}
int
efile_rmdir(Efile_error* errInfo, /* Where to return error codes. */
char* name) /* Name of directory to delete. */
{
CHECK_PATHLEN(name, errInfo);
if (rmdir(name) == 0) {
return 1;
}
#ifdef VXWORKS
if (name[0] == '\0') {
/* Return the correct error code enoent */
errno = S_nfsLib_NFSERR_NOENT;
}
#else
if (errno == ENOTEMPTY) {
errno = EEXIST;
}
if (errno == EEXIST) {
int saved_errno = errno;
struct stat file_stat;
struct stat cwd_stat;
/*
* The error code might be wrong if this is the current directory.
*/
if (stat(name, &file_stat) == 0 && stat(".", &cwd_stat) == 0 &&
file_stat.st_ino == cwd_stat.st_ino &&
file_stat.st_dev == cwd_stat.st_dev) {
saved_errno = EINVAL;
}
errno = saved_errno;
}
#endif
return check_error(-1, errInfo);
}
int
efile_delete_file(Efile_error* errInfo, /* Where to return error codes. */
char* name) /* Name of file to delete. */
{
CHECK_PATHLEN(name,errInfo);
#ifdef _OSE_
if (remove(name) == 0) {
return 1;
}
#else
if (unlink(name) == 0) {
return 1;
}
if (errno == EISDIR) { /* Linux sets the wrong error code. */
errno = EPERM;
}
#endif
return check_error(-1, errInfo);
}
/*
*---------------------------------------------------------------------------
*
* Changes the name of an existing file or directory, from src to dst.
* If src and dst refer to the same file or directory, does nothing
* and returns success. Otherwise if dst already exists, it will be
* deleted and replaced by src subject to the following conditions:
* If src is a directory, dst may be an empty directory.
* If src is a file, dst may be a file.
* In any other situation where dst already exists, the rename will
* fail.
*
* Results:
* If the directory was successfully created, returns 1.
* Otherwise the return value is 0 and errno is set to
* indicate the error. Some possible values for errno are:
*
* EACCES: src or dst parent directory can't be read and/or written.
* EEXIST: dst is a non-empty directory.
* EINVAL: src is a root directory or dst is a subdirectory of src.
* EISDIR: dst is a directory, but src is not.
* ENOENT: src doesn't exist, or src or dst is "".
* ENOTDIR: src is a directory, but dst is not.
* EXDEV: src and dst are on different filesystems.
*
* Side effects:
* The implementation of rename may allow cross-filesystem renames,
* but the caller should be prepared to emulate it with copy and
* delete if errno is EXDEV.
*
*---------------------------------------------------------------------------
*/
int
efile_rename(Efile_error* errInfo, /* Where to return error codes. */
char* src, /* Original name. */
char* dst) /* New name. */
{
CHECK_PATHLEN(src,errInfo);
CHECK_PATHLEN(dst,errInfo);
#ifdef VXWORKS
/* First check if src == dst, if so, just return. */
/* VxWorks dos file system destroys the file otherwise, */
/* VxWorks nfs file system rename doesn't work at all. */
if(strcmp(src, dst) == 0)
return 1;
#endif
if (rename(src, dst) == 0) {
return 1;
}
#ifdef VXWORKS
/* nfs for VxWorks doesn't support rename. We try to emulate it */
/* (by first copying src to dst and then deleting src). */
if(errno == S_ioLib_UNKNOWN_REQUEST && /* error code returned
by ioLib (!) */
copy(src, dst) == OK &&
unlink(src) == OK)
return 1;
#endif
if (errno == ENOTEMPTY) {
errno = EEXIST;
}
#if defined (sparc) && !defined(VXWORKS) && !defined(_OSE_)
/*
* SunOS 4.1.4 reports overwriting a non-empty directory with a
* directory as EINVAL instead of EEXIST (first rule out the correct
* EINVAL result code for moving a directory into itself). Must be
* conditionally compiled because realpath() is only defined on SunOS.
*/
if (errno == EINVAL) {
char srcPath[MAXPATHLEN], dstPath[MAXPATHLEN];
DIR *dirPtr;
struct dirent *dirEntPtr;
#ifdef PURIFY
memset(srcPath, '\0', sizeof(srcPath));
memset(dstPath, '\0', sizeof(dstPath));
#endif
if ((realpath(src, srcPath) != NULL)
&& (realpath(dst, dstPath) != NULL)
&& (strncmp(srcPath, dstPath, strlen(srcPath)) != 0)) {
dirPtr = opendir(dst);
if (dirPtr != NULL) {
while ((dirEntPtr = readdir(dirPtr)) != NULL) {
if ((strcmp(dirEntPtr->d_name, ".") != 0) &&
(strcmp(dirEntPtr->d_name, "..") != 0)) {
errno = EEXIST;
closedir(dirPtr);
return check_error(-1, errInfo);
}
}
closedir(dirPtr);
}
}
errno = EINVAL;
}
#endif /* sparc */
if (strcmp(src, "/") == 0) {
/*
* Alpha reports renaming / as EBUSY and Linux reports it as EACCES,
* instead of EINVAL.
*/
errno = EINVAL;
}
/*
* DEC Alpha OSF1 V3.0 returns EACCES when attempting to move a
* file across filesystems and the parent directory of that file is
* not writable. Most other systems return EXDEV. Does nothing to
* correct this behavior.
*/
return check_error(-1, errInfo);
}
int
efile_chdir(Efile_error* errInfo, /* Where to return error codes. */
char* name) /* Name of directory to make current. */
{
CHECK_PATHLEN(name, errInfo);
return check_error(chdir(name), errInfo);
}
int
efile_getdcwd(Efile_error* errInfo, /* Where to return error codes. */
int drive, /* 0 - current, 1 - A, 2 - B etc. */
char* buffer, /* Where to return the current
directory. */
size_t size) /* Size of buffer. */
{
if (drive == 0) {
if (getcwd(buffer, size) == NULL)
return check_error(-1, errInfo);
#ifdef SIMSPARCSOLARIS
/* We get "host:" prepended to the dirname - remove!. */
{
int i = 0;
int j = 0;
while ((buffer[i] != ':') && (buffer[i] != '\0')) i++;
if (buffer[i] == ':') {
i++;
while ((buffer[j++] = buffer[i++]) != '\0');
}
}
#endif
return 1;
}
/*
* Drives other than 0 is not supported on Unix.
*/
errno = ENOTSUP;
return check_error(-1, errInfo);
}
int
efile_readdir(Efile_error* errInfo, /* Where to return error codes. */
char* name, /* Name of directory to open. */
EFILE_DIR_HANDLE* p_dir_handle, /* Pointer to directory
handle of
open directory.*/
char* buffer, /* Pointer to buffer for
one filename. */
size_t size) /* Size of buffer. */
{
DIR *dp; /* Pointer to directory structure. */
struct dirent* dirp; /* Pointer to directory entry. */
/*
* If this is the first call, we must open the directory.
*/
CHECK_PATHLEN(name, errInfo);
if (*p_dir_handle == NULL) {
dp = opendir(name);
if (dp == NULL)
return check_error(-1, errInfo);
*p_dir_handle = (EFILE_DIR_HANDLE) dp;
}
/*
* Retrieve the name of the next file using the directory handle.
*/
dp = *((DIR **)((void *)p_dir_handle));
for (;;) {
dirp = readdir(dp);
if (dirp == NULL) {
closedir(dp);
return 0;
}
if (IS_DOT_OR_DOTDOT(dirp->d_name))
continue;
buffer[0] = '\0';
strncat(buffer, dirp->d_name, size-1);
return 1;
}
}
int
efile_openfile(Efile_error* errInfo, /* Where to return error codes. */
char* name, /* Name of directory to open. */
int flags, /* Flags to user for opening. */
int* pfd, /* Where to store the file
descriptor. */
Sint64 *pSize) /* Where to store the size of the
file. */
{
struct stat statbuf;
int fd;
int mode; /* Open mode. */
#ifdef VXWORKS
char pathbuff[PATH_MAX+2];
char sbuff[PATH_MAX*2];
char *totbuff = sbuff;
int nameneed;
#endif
CHECK_PATHLEN(name, errInfo);
#ifdef VXWORKS
/* Have to check that it's not a directory. */
if (stat(name,&statbuf) != ERROR && ISDIR(statbuf)) {
errno = EISDIR;
return check_error(-1, errInfo);
}
#endif
if (stat(name, &statbuf) >= 0 && !ISREG(statbuf)) {
#if !defined(VXWORKS) && !defined(OSE)
/*
* For UNIX only, here is some ugly code to allow
* /dev/null to be opened as a file.
*
* Assumption: The i-node number for /dev/null cannot be zero.
*/
static ino_t dev_null_ino = 0;
if (dev_null_ino == 0) {
struct stat nullstatbuf;
if (stat("/dev/null", &nullstatbuf) >= 0) {
dev_null_ino = nullstatbuf.st_ino;
}
}
if (!(dev_null_ino && statbuf.st_ino == dev_null_ino)) {
#endif
errno = EISDIR;
return check_error(-1, errInfo);
#if !defined(VXWORKS) && !defined(OSE)
}
#endif
}
switch (flags & (EFILE_MODE_READ|EFILE_MODE_WRITE)) {
case EFILE_MODE_READ:
mode = O_RDONLY;
break;
case EFILE_MODE_WRITE:
if (flags & EFILE_NO_TRUNCATE)
mode = O_WRONLY | O_CREAT;
else
mode = O_WRONLY | O_CREAT | O_TRUNC;
break;
case EFILE_MODE_READ_WRITE:
mode = O_RDWR | O_CREAT;
break;
default:
errno = EINVAL;
return check_error(-1, errInfo);
}
if (flags & EFILE_MODE_APPEND) {
mode &= ~O_TRUNC;
#ifndef VXWORKS
mode |= O_APPEND; /* Dont make VxWorks think things it shouldn't */
#endif
}
#ifdef VXWORKS
if (*name != '/') {
/* Make sure it is an absolute pathname, because ftruncate needs it */
ioDefPathGet(pathbuff);
strcat(pathbuff,"/");
nameneed = strlen(pathbuff) + strlen(name) + 1;
if (nameneed > PATH_MAX*2)
totbuff = EF_SAFE_ALLOC(nameneed);
strcpy(totbuff,pathbuff);
strcat(totbuff,name);
fd = open(totbuff, mode, FILE_MODE);
if (totbuff != sbuff)
EF_FREE(totbuff);
} else {
fd = open(name, mode, FILE_MODE);
}
#else
fd = open(name, mode, FILE_MODE);
#endif
#ifdef VXWORKS
/* This is a VxWorks/nfs workaround for erl_tar to create
* non-existant directories. (of some reason (...) VxWorks
* returns, the *non-module-prefixed*, 0xd code when
* trying to write a file in a directory that doesn't exist).
* (see efile_mkdir)
*/
if ((fd < 0) && (strchr(name, '/') != NULL) && (errno == 0xd)) {
/* Return the correct error code enoent */
errno = S_nfsLib_NFSERR_NOENT;
return check_error(-1, errInfo);
}
#endif
if (!check_error(fd, errInfo))
return 0;
*pfd = fd;
if (pSize) {
*pSize = statbuf.st_size;
}
return 1;
}
int
efile_may_openfile(Efile_error* errInfo, char *name) {
struct stat statbuf; /* Information about the file */
int result;
result = stat(name, &statbuf);
if (!check_error(result, errInfo))
return 0;
if (!ISREG(statbuf)) {
errno = EISDIR;
return check_error(-1, errInfo);
}
return 1;
}
void
efile_closefile(int fd)
{
close(fd);
}
int
efile_fsync(Efile_error *errInfo, /* Where to return error codes. */
int fd) /* File descriptor for file to sync. */
{
#ifdef NO_FSYNC
#ifdef VXWORKS
return check_error(ioctl(fd, FIOSYNC, 0), errInfo);
#else
undefined fsync
#endif /* VXWORKS */
#else
#if defined(DARWIN) && defined(F_FULLFSYNC)
return check_error(fcntl(fd, F_FULLFSYNC), errInfo);
#else
return check_error(fsync(fd), errInfo);
#endif /* DARWIN */
#endif /* NO_FSYNC */
}
int
efile_fileinfo(Efile_error* errInfo, Efile_info* pInfo,
char* name, int info_for_link)
{
struct stat statbuf; /* Information about the file */
struct tm *timep; /* Broken-apart filetime. */
int result;
#ifdef VXWORKS
if (*name == '\0') {
errInfo->posix_errno = errInfo->os_errno = ENOENT;
return 0;
}
#endif
CHECK_PATHLEN(name, errInfo);
if (info_for_link) {
#if (defined(VXWORKS) || defined(_OSE_))
result = stat(name, &statbuf);
#else
result = lstat(name, &statbuf);
#endif
} else {
result = stat(name, &statbuf);
}
if (!check_error(result, errInfo)) {
return 0;
}
#if SIZEOF_OFF_T == 4
pInfo->size_high = 0;
#else
pInfo->size_high = (Uint32)(statbuf.st_size >> 32);
#endif
pInfo->size_low = (Uint32)statbuf.st_size;
#ifdef NO_ACCESS
/* Just look at read/write access for owner. */
#ifdef VXWORKS
pInfo->access = FA_NONE;
if(statbuf.st_mode & S_IRUSR)
pInfo->access |= FA_READ;
if(statbuf.st_mode & S_IWUSR)
pInfo->access |= FA_WRITE;
#else
pInfo->access = ((statbuf.st_mode >> 6) & 07) >> 1;
#endif /* VXWORKS */
#else
pInfo->access = FA_NONE;
if (access(name, R_OK) == 0)
pInfo->access |= FA_READ;
if (access(name, W_OK) == 0)
pInfo->access |= FA_WRITE;
#endif
if (ISDEV(statbuf))
pInfo->type = FT_DEVICE;
else if (ISDIR(statbuf))
pInfo->type = FT_DIRECTORY;
else if (ISREG(statbuf))
pInfo->type = FT_REGULAR;
else if (ISLNK(statbuf))
pInfo->type = FT_SYMLINK;
else
pInfo->type = FT_OTHER;
#if defined(HAVE_LOCALTIME_R) || defined(VXWORKS)
{
/* Use the reentrant version of localtime() */
static struct tm local_tm;
#define localtime(a) (localtime_r((a), &local_tm), &local_tm)
#endif
#define GET_TIME(dst, src) \
timep = localtime(&statbuf.src); \
(dst).year = timep->tm_year+1900; \
(dst).month = timep->tm_mon+1; \
(dst).day = timep->tm_mday; \
(dst).hour = timep->tm_hour; \
(dst).minute = timep->tm_min; \
(dst).second = timep->tm_sec
GET_TIME(pInfo->accessTime, st_atime);
GET_TIME(pInfo->modifyTime, st_mtime);
GET_TIME(pInfo->cTime, st_ctime);
#undef GET_TIME
#if defined(HAVE_LOCALTIME_R) || defined(VXWORKS)
}
#endif
pInfo->mode = statbuf.st_mode;
pInfo->links = statbuf.st_nlink;
pInfo->major_device = statbuf.st_dev;
#ifdef _OSE_
pInfo->minor_device = 0;
#else
pInfo->minor_device = statbuf.st_rdev;
#endif
pInfo->inode = statbuf.st_ino;
pInfo->uid = statbuf.st_uid;
pInfo->gid = statbuf.st_gid;
return 1;
}
int
efile_write_info(Efile_error *errInfo, Efile_info *pInfo, char *name)
{
CHECK_PATHLEN(name, errInfo);
#ifdef VXWORKS
if (pInfo->mode != -1) {
int fd;
struct stat statbuf;
fd = open(name, O_RDONLY, 0);
if (!check_error(fd, errInfo))
return 0;
if (fstat(fd, &statbuf) < 0) {
close(fd);
return check_error(-1, errInfo);
}
if (pInfo->mode & S_IWUSR) {
/* clear read only bit */
statbuf.st_attrib &= ~DOS_ATTR_RDONLY;
} else {
/* set read only bit */
statbuf.st_attrib |= DOS_ATTR_RDONLY;
}
/* This should work for dos files but not for nfs ditos, so don't
* report errors (to avoid problems when running e.g. erl_tar)
*/
ioctl(fd, FIOATTRIBSET, statbuf.st_attrib);
close(fd);
}
#else
/*
* On some systems chown will always fail for a non-root user unless
* POSIX_CHOWN_RESTRICTED is not set. Others will succeed as long as
* you don't try to chown a file to someone besides youself.
*/
#ifndef _OSE_
if (chown(name, pInfo->uid, pInfo->gid) && errno != EPERM) {
return check_error(-1, errInfo);
}
#endif
if (pInfo->mode != -1) {
mode_t newMode = pInfo->mode & (S_ISUID | S_ISGID |
S_IRWXU | S_IRWXG | S_IRWXO);
if (chmod(name, newMode)) {
newMode &= ~(S_ISUID | S_ISGID);
if (chmod(name, newMode)) {
return check_error(-1, errInfo);
}
}
}
#endif /* !VXWORKS */
#ifndef _OSE_
if (pInfo->accessTime.year != -1 && pInfo->modifyTime.year != -1) {
struct utimbuf tval;
struct tm timebuf;
#define MKTIME(tb, ts) \
timebuf.tm_year = ts.year-1900; \
timebuf.tm_mon = ts.month-1; \
timebuf.tm_mday = ts.day; \
timebuf.tm_hour = ts.hour; \
timebuf.tm_min = ts.minute; \
timebuf.tm_sec = ts.second; \
timebuf.tm_isdst = -1; \
if ((tb = mktime(&timebuf)) == (time_t) -1) { \
errno = EINVAL; \
return check_error(-1, errInfo); \
}
MKTIME(tval.actime, pInfo->accessTime);
MKTIME(tval.modtime, pInfo->modifyTime);
#undef MKTIME
#ifdef VXWORKS
/* VxWorks' utime doesn't work when the file is a nfs mounted
* one, don't report error if utime fails.
*/
utime(name, &tval);
return 1;
#else
return check_error(utime(name, &tval), errInfo);
#endif
}
#endif /* !_OSE_ */
return 1;
}
int
efile_write(Efile_error* errInfo, /* Where to return error codes. */
int flags, /* Flags given when file was
opened. */
int fd, /* File descriptor to write to. */
char* buf, /* Buffer to write. */
size_t count) /* Number of bytes to write. */
{
ssize_t written; /* Bytes written in last operation. */
#ifdef VXWORKS
if (flags & EFILE_MODE_APPEND) {
lseek(fd, 0, SEEK_END); /* Naive append emulation on VXWORKS */
}
#endif
while (count > 0) {
if ((written = write(fd, buf, count)) < 0) {
if (errno != EINTR)
return check_error(-1, errInfo);
else
written = 0;
}
ASSERT(written <= count);
buf += written;
count -= written;
}
return 1;
}
int
efile_writev(Efile_error* errInfo, /* Where to return error codes */
int flags, /* Flags given when file was
* opened */
int fd, /* File descriptor to write to */
SysIOVec* iov, /* Vector of buffer structs.
* The structs are unchanged
* after the call */
int iovcnt, /* Number of structs in vector */
size_t size) /* Number of bytes to write */
{
int cnt = 0; /* Buffers so far written */
int p = 0; /* Position in next buffer */
ASSERT(iovcnt >= 0);
#ifdef VXWORKS
if (flags & EFILE_MODE_APPEND) {
lseek(fd, 0, SEEK_END); /* Naive append emulation on VXWORKS */
}
#endif
while (cnt < iovcnt) {
#ifdef HAVE_WRITEV
int w; /* Bytes written in this call */
int b = iovcnt - cnt; /* Buffers to write */
if (b > MAXIOV)
b = MAXIOV;
if (iov[cnt].iov_base && iov[cnt].iov_len > 0) {
if (b == 1) {
/* Degenerated io vector */
do {
w = write(fd, iov[cnt].iov_base + p, iov[cnt].iov_len - p);
} while (w < 0 && errno == EINTR);
} else {
/* Non-empty vector first.
* Adjust pos in first buffer in case of
* previous incomplete writev */
iov[cnt].iov_base += p;
iov[cnt].iov_len -= p;
do {
w = writev(fd, &iov[cnt], b);
} while (w < 0 && errno == EINTR);
iov[cnt].iov_base -= p;
iov[cnt].iov_len += p;
}
if (w < 0)
return check_error(-1, errInfo);
} else {
/* Empty vector first - skip */
cnt++;
continue;
}
ASSERT(w >= 0);
/* Move forward to next vector to write */
for (; cnt < iovcnt; cnt++) {
if (iov[cnt].iov_base && iov[cnt].iov_len > 0) {
if (w < iov[cnt].iov_len)
break;
else
w -= iov[cnt].iov_len;
}
}
ASSERT(w >= 0);
p = w > 0 ? w : 0; /* Skip p bytes next writev */
#else /* #ifdef HAVE_WRITEV */
if (iov[cnt].iov_base && iov[cnt].iov_len > 0) {
/* Non-empty vector */
int w; /* Bytes written in this call */
while (p < iov[cnt].iov_len) {
do {
w = write(fd, iov[cnt].iov_base + p, iov[cnt].iov_len - p);
} while (w < 0 && errno == EINTR);
if (w < 0)
return check_error(-1, errInfo);
p += w;
}
}
cnt++;
p = 0;
#endif /* #ifdef HAVE_WRITEV */
} /* while (cnt< iovcnt) */
size = 0; /* Avoid compiler warning */
return 1;
}
int
efile_read(Efile_error* errInfo, /* Where to return error codes. */
int flags, /* Flags given when file was opened. */
int fd, /* File descriptor to read from. */
char* buf, /* Buffer to read into. */
size_t count, /* Number of bytes to read. */
size_t *pBytesRead) /* Where to return number of
bytes read. */
{
ssize_t n;
for (;;) {
if ((n = read(fd, buf, count)) >= 0)
break;
else if (errno != EINTR)
return check_error(-1, errInfo);
}
*pBytesRead = (size_t) n;
return 1;
}
/* pread() and pwrite() */
/* Some unix systems, notably Solaris has these syscalls */
/* It is especially nice for i.e. the dets module to have support */
/* for this, even if the underlying OS dosn't support it, it is */
/* reasonably easy to work around by first calling seek, and then */
/* calling read(). */
/* This later strategy however changes the file pointer, which pread() */
/* does not do. We choose to ignore this and say that the location */
/* of the file pointer is undefined after a call to any of the p functions*/
int
efile_pread(Efile_error* errInfo, /* Where to return error codes. */
int fd, /* File descriptor to read from. */
Sint64 offset, /* Offset in bytes from BOF. */
char* buf, /* Buffer to read into. */
size_t count, /* Number of bytes to read. */
size_t *pBytesRead) /* Where to return
number of bytes read. */
{
#if defined(HAVE_PREAD) && defined(HAVE_PWRITE)
ssize_t n;
off_t off = (off_t) offset;
if (off != offset) {
errno = EINVAL;
return check_error(-1, errInfo);
}
for (;;) {
if ((n = pread(fd, buf, count, offset)) >= 0)
break;
else if (errno != EINTR)
return check_error(-1, errInfo);
}
*pBytesRead = (size_t) n;
return 1;
#else
{
int res = efile_seek(errInfo, fd, offset, EFILE_SEEK_SET, NULL);
if (res) {
return efile_read(errInfo, 0, fd, buf, count, pBytesRead);
} else {
return res;
}
}
#endif
}
int
efile_pwrite(Efile_error* errInfo, /* Where to return error codes. */
int fd, /* File descriptor to write to. */
char* buf, /* Buffer to write. */
size_t count, /* Number of bytes to write. */
Sint64 offset) /* where to write it */
{
#if defined(HAVE_PREAD) && defined(HAVE_PWRITE)
ssize_t written; /* Bytes written in last operation. */
off_t off = (off_t) offset;
if (off != offset) {
errno = EINVAL;
return check_error(-1, errInfo);
}
while (count > 0) {
if ((written = pwrite(fd, buf, count, offset)) < 0) {
if (errno != EINTR)
return check_error(-1, errInfo);
else
written = 0;
}
ASSERT(written <= count);
buf += written;
count -= written;
offset += written;
}
return 1;
#else /* For unix systems that don't support pread() and pwrite() */
{
int res = efile_seek(errInfo, fd, offset, EFILE_SEEK_SET, NULL);
if (res) {
return efile_write(errInfo, 0, fd, buf, count);
} else {
return res;
}
}
#endif
}
int
efile_seek(Efile_error* errInfo, /* Where to return error codes. */
int fd, /* File descriptor to do the seek on. */
Sint64 offset, /* Offset in bytes from the given
origin. */
int origin, /* Origin of seek (SEEK_SET, SEEK_CUR,
SEEK_END). */
Sint64 *new_location) /* Resulting new location in file. */
{
off_t off, result;
switch (origin) {
case EFILE_SEEK_SET: origin = SEEK_SET; break;
case EFILE_SEEK_CUR: origin = SEEK_CUR; break;
case EFILE_SEEK_END: origin = SEEK_END; break;
default:
errno = EINVAL;
return check_error(-1, errInfo);
}
off = (off_t) offset;
if (off != offset) {
errno = EINVAL;
return check_error(-1, errInfo);
}
errno = 0;
result = lseek(fd, off, origin);
/*
* Note that the man page for lseek (on SunOs 5) says:
*
* "if fildes is a remote file descriptor and offset is
* negative, lseek() returns the file pointer even if it is
* negative."
*/
if (result < 0 && errno == 0)
errno = EINVAL;
if (result < 0)
return check_error(-1, errInfo);
if (new_location) {
*new_location = result;
}
return 1;
}
int
efile_truncate_file(Efile_error* errInfo, int *fd, int flags)
{
#ifdef VXWORKS
off_t offset;
char namebuf[PATH_MAX+1];
char namebuf2[PATH_MAX+10];
int new;
int dummy;
int i;
int left;
static char buff[1024];
struct stat st;
Efile_error tmperr;
if ((offset = lseek(*fd, 0, 1)) < 0) {
return check_error((int) offset,errInfo);
}
if (ftruncate(*fd, offset) < 0) {
if (vxworks_to_posix(errno) != EINVAL) {
return check_error(-1, errInfo);
}
/*
** Kludge
*/
if(ioctl(*fd,FIOGETNAME,(int) namebuf) < 0) {
return check_error(-1, errInfo);
}
for(i=0;i<1000;++i) {
sprintf(namebuf2,"%s%d",namebuf,i);
CHECK_PATHLEN(namebuf2,errInfo);
if (stat(namebuf2,&st) < 0) {
break;
}
}
if (i > 1000) {
errno = EINVAL;
return check_error(-1, errInfo);
}
if (close(*fd) < 0) {
return check_error(-1, errInfo);
}
if (efile_rename(&tmperr,namebuf,namebuf2) < 0) {
i = check_error(-1,&tmperr);
if (!efile_openfile(errInfo,namebuf,flags | EFILE_NO_TRUNCATE,
fd,&dummy)) {
*fd = -1;
} else {
*errInfo = tmperr;
}
return i;
}
if ((*fd = open(namebuf2, O_RDONLY, 0)) < 0) {
i = check_error(-1,errInfo);
efile_rename(&tmperr,namebuf2,namebuf); /* at least try */
if (!efile_openfile(errInfo,namebuf,flags | EFILE_NO_TRUNCATE,
fd,&dummy)) {
*fd = -1;
} else {
lseek(*fd,offset,SEEK_SET);
}
return i;
}
/* Point of no return... */
if ((new = open(namebuf,O_RDWR | O_CREAT, FILE_MODE)) < 0) {
close(*fd);
*fd = -1;
return 0;
}
left = offset;
while (left) {
if ((i = read(*fd,buff,(left > 1024) ? 1024 : left)) < 0) {
i = check_error(-1,errInfo);
close(new);
close(*fd);
unlink(namebuf);
efile_rename(&tmperr,namebuf2,namebuf); /* at least try */
if (!efile_openfile(errInfo,namebuf,flags | EFILE_NO_TRUNCATE,
fd,&dummy)) {
*fd = -1;
} else {
lseek(*fd,offset,SEEK_SET);
}
return i;
}
left -= i;
if (write(new,buff,i) < 0) {
i = check_error(-1,errInfo);
close(new);
close(*fd);
unlink(namebuf);
rename(namebuf2,namebuf); /* at least try */
if (!efile_openfile(errInfo,namebuf,flags | EFILE_NO_TRUNCATE,
fd,&dummy)) {
*fd = -1;
} else {
lseek(*fd,offset,SEEK_SET);
}
return i;
}
}
close(*fd);
unlink(namebuf2);
close(new);
i = efile_openfile(errInfo,namebuf,flags | EFILE_NO_TRUNCATE,fd,
&dummy);
if (i) {
lseek(*fd,offset,SEEK_SET);
}
return i;
}
return 1;
#else
#ifndef NO_FTRUNCATE
off_t offset;
return check_error((offset = lseek(*fd, 0, 1)) >= 0 &&
ftruncate(*fd, offset) == 0 ? 1 : -1,
errInfo);
#else
return 1;
#endif
#endif
}
int
efile_readlink(Efile_error* errInfo, char* name, char* buffer, size_t size)
{
#ifdef _OSE_
return ose_enotsup(errInfo);
#else
#ifdef VXWORKS
return vxworks_enotsup(errInfo);
#else
int len;
ASSERT(size > 0);
len = readlink(name, buffer, size-1);
if (len == -1) {
return check_error(-1, errInfo);
}
buffer[len] = '\0';
return 1;
#endif
#endif
}
int
efile_altname(Efile_error* errInfo, char* name, char* buffer, size_t size)
{
errno = ENOTSUP;
return check_error(-1, errInfo);
}
int
efile_link(Efile_error* errInfo, char* old, char* new)
{
#ifdef _OSE_
return ose_enotsup(errInfo);
#else
#ifdef VXWORKS
return vxworks_enotsup(errInfo);
#else
return check_error(link(old, new), errInfo);
#endif
#endif
}
int
efile_symlink(Efile_error* errInfo, char* old, char* new)
{
#ifdef _OSE_
return ose_enotsup(errInfo);
#else
#ifdef VXWORKS
return vxworks_enotsup(errInfo);
#else
return check_error(symlink(old, new), errInfo);
#endif
#endif
}
