aboutsummaryrefslogblamecommitdiffstats
path: root/erts/emulator/drivers/unix/unix_efile.c
blob: 0cece76221d0a76673e2292390a184ce3f8bdefb (plain) (tree)
1
2
3
4
5
6
7
8
9
10
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314
1315
1316
1317
1318
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328
1329
1330
1331
1332
1333
1334
1335
1336
1337
1338
1339
1340
1341
1342
1343
1344
1345
1346
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357
1358
1359
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378
1379
1380
1381
1382
1383
1384
1385
1386
1387
1388
1389
1390
1391
1392
1393
1394
1395
1396
1397
1398
1399
1400
1401
1402
1403
1404
1405
1406
1407
1408
1409
1410

                   


                                                        




                                                                      
  



                                                                         
  



















                                                            










































                                                                          












                                                                        
















































































































































































































































                                                                             











































































                                                                           





                                                                      

































































                                                                             
                                        





































































































































































































































































































                                                                              










                                                                              



































                                                                         
                      


















































































                                                             
                                          












































                                                                          


                                                                













                                                                     






























                                                                       
























































































































































































































































































































































































































                                                                               











                                         











                                                                          




                                                




                                                         




                                                   
 
/*
 * %CopyrightBegin%
 *
 * Copyright Ericsson AB 1997-2010. 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

#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.
 */

#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

#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 */

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);
    if (unlink(name) == 0) {
	return 1;
    }
    if (errno == EISDIR) {	/* Linux sets the wrong error code. */
	errno = EPERM;
    }
    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)
    /*
     * 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_fdatasync(Efile_error *errInfo, /* Where to return error codes. */
	    int fd)               /* File descriptor for file to sync data. */
{
#ifdef HAVE_FDATASYNC
    return check_error(fdatasync(fd), errInfo);
#else
    return efile_fsync(errInfo, fd);
#endif
}

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))
	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;
    pInfo->minor_device = statbuf.st_rdev;
    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.
     */

    if (chown(name, pInfo->uid, pInfo->gid) && errno != EPERM) {
	return check_error(-1, errInfo);
    }

    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 */

    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
    }
    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 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
}

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 VXWORKS
    return vxworks_enotsup(errInfo);
#else
    return check_error(link(old, new), errInfo);
#endif
}

int
efile_symlink(Efile_error* errInfo, char* old, char* new)
{
#ifdef VXWORKS
    return vxworks_enotsup(errInfo);
#else
    return check_error(symlink(old, new), errInfo);
#endif
}