summaryrefslogtreecommitdiffstats
path: root/nsprpub/pr/src/md/beos
diff options
context:
space:
mode:
Diffstat (limited to 'nsprpub/pr/src/md/beos')
-rw-r--r--nsprpub/pr/src/md/beos/.cvsignore1
-rw-r--r--nsprpub/pr/src/md/beos/Makefile.in28
-rw-r--r--nsprpub/pr/src/md/beos/bcpu.c23
-rw-r--r--nsprpub/pr/src/md/beos/beos.c232
-rw-r--r--nsprpub/pr/src/md/beos/beos_errors.c1494
-rw-r--r--nsprpub/pr/src/md/beos/bfile.c873
-rw-r--r--nsprpub/pr/src/md/beos/bmemory.c10
-rw-r--r--nsprpub/pr/src/md/beos/bmisc.c91
-rw-r--r--nsprpub/pr/src/md/beos/bmmap.c41
-rw-r--r--nsprpub/pr/src/md/beos/bnet.c911
-rw-r--r--nsprpub/pr/src/md/beos/bproc.c212
-rw-r--r--nsprpub/pr/src/md/beos/brng.c40
-rw-r--r--nsprpub/pr/src/md/beos/bseg.c22
-rw-r--r--nsprpub/pr/src/md/beos/bsrcs.mk22
-rw-r--r--nsprpub/pr/src/md/beos/btime.c43
-rw-r--r--nsprpub/pr/src/md/beos/objs.mk11
16 files changed, 0 insertions, 4054 deletions
diff --git a/nsprpub/pr/src/md/beos/.cvsignore b/nsprpub/pr/src/md/beos/.cvsignore
deleted file mode 100644
index f3c7a7c5d..000000000
--- a/nsprpub/pr/src/md/beos/.cvsignore
+++ /dev/null
@@ -1 +0,0 @@
-Makefile
diff --git a/nsprpub/pr/src/md/beos/Makefile.in b/nsprpub/pr/src/md/beos/Makefile.in
deleted file mode 100644
index 340f144a8..000000000
--- a/nsprpub/pr/src/md/beos/Makefile.in
+++ /dev/null
@@ -1,28 +0,0 @@
-#
-# This Source Code Form is subject to the terms of the Mozilla Public
-# License, v. 2.0. If a copy of the MPL was not distributed with this
-# file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-
-MOD_DEPTH = ../../../..
-topsrcdir = @top_srcdir@
-srcdir = @srcdir@
-VPATH = @srcdir@
-
-include $(MOD_DEPTH)/config/autoconf.mk
-
-include $(topsrcdir)/config/config.mk
-
-include $(srcdir)/bsrcs.mk
-CSRCS += $(MDCSRCS)
-
-TARGETS = $(OBJS)
-
-INCLUDES = -I$(dist_includedir) -I$(topsrcdir)/pr/include -I$(topsrcdir)/pr/include/private
-
-DEFINES += -D_NSPR_BUILD_
-
-include $(topsrcdir)/config/rules.mk
-
-export:: $(TARGETS)
-
diff --git a/nsprpub/pr/src/md/beos/bcpu.c b/nsprpub/pr/src/md/beos/bcpu.c
deleted file mode 100644
index 6c2538654..000000000
--- a/nsprpub/pr/src/md/beos/bcpu.c
+++ /dev/null
@@ -1,23 +0,0 @@
-/* -*- Mode: C++; c-basic-offset: 4 -*- */
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-
-#include "primpl.h"
-
-PR_EXTERN(void) _PR_MD_INIT_CPUS();
-PR_EXTERN(void) _PR_MD_WAKEUP_CPUS();
-PR_EXTERN(void) _PR_MD_START_INTERRUPTS(void);
-PR_EXTERN(void) _PR_MD_STOP_INTERRUPTS(void);
-PR_EXTERN(void) _PR_MD_DISABLE_CLOCK_INTERRUPTS(void);
-PR_EXTERN(void) _PR_MD_BLOCK_CLOCK_INTERRUPTS(void);
-PR_EXTERN(void) _PR_MD_UNBLOCK_CLOCK_INTERRUPTS(void);
-PR_EXTERN(void) _PR_MD_CLOCK_INTERRUPT(void);
-PR_EXTERN(void) _PR_MD_INIT_STACK(PRThreadStack *ts, PRIntn redzone);
-PR_EXTERN(void) _PR_MD_CLEAR_STACK(PRThreadStack* ts);
-PR_EXTERN(PRInt32) _PR_MD_GET_INTSOFF(void);
-PR_EXTERN(void) _PR_MD_SET_INTSOFF(PRInt32 _val);
-PR_EXTERN(_PRCPU*) _PR_MD_CURRENT_CPU(void);
-PR_EXTERN(void) _PR_MD_SET_CURRENT_CPU(_PRCPU *cpu);
-PR_EXTERN(void) _PR_MD_INIT_RUNNING_CPU(_PRCPU *cpu);
-PR_EXTERN(PRInt32) _PR_MD_PAUSE_CPU(PRIntervalTime timeout);
diff --git a/nsprpub/pr/src/md/beos/beos.c b/nsprpub/pr/src/md/beos/beos.c
deleted file mode 100644
index a1df7d2f1..000000000
--- a/nsprpub/pr/src/md/beos/beos.c
+++ /dev/null
@@ -1,232 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-
-#include "primpl.h"
-
-#include <signal.h>
-#include <unistd.h>
-#include <memory.h>
-#include <fcntl.h>
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <sys/time.h>
-#include <sys/ioctl.h>
-#include <errno.h>
-
-/*
- * Make sure _PRSockLen_t is 32-bit, because we will cast a PRUint32* or
- * PRInt32* pointer to a _PRSockLen_t* pointer.
- */
-#define _PRSockLen_t int
-
-/*
-** Global lock variable used to bracket calls into rusty libraries that
-** aren't thread safe (like libc, libX, etc).
-*/
-static PRLock *_pr_rename_lock = NULL;
-static PRMonitor *_pr_Xfe_mon = NULL;
-
-/*
- * Variables used by the GC code, initialized in _MD_InitSegs().
- * _pr_zero_fd should be a static variable. Unfortunately, there is
- * still some Unix-specific code left in function PR_GrowSegment()
- * in file memory/prseg.c that references it, so it needs
- * to be a global variable for now.
- */
-PRInt32 _pr_zero_fd = -1;
-static PRLock *_pr_md_lock = NULL;
-
-sigset_t timer_set;
-
-void _PR_UnixInit()
-{
- struct sigaction sigact;
- int rv;
-
- sigemptyset(&timer_set);
-
- sigact.sa_handler = SIG_IGN;
- sigemptyset(&sigact.sa_mask);
- sigact.sa_flags = 0;
- rv = sigaction(SIGPIPE, &sigact, 0);
- PR_ASSERT(0 == rv);
-
- _pr_rename_lock = PR_NewLock();
- PR_ASSERT(NULL != _pr_rename_lock);
- _pr_Xfe_mon = PR_NewMonitor();
- PR_ASSERT(NULL != _pr_Xfe_mon);
-}
-
-/*
- *-----------------------------------------------------------------------
- *
- * PR_Now --
- *
- * Returns the current time in microseconds since the epoch.
- * The epoch is midnight January 1, 1970 GMT.
- * The implementation is machine dependent. This is the Unix
- * implementation.
- * Cf. time_t time(time_t *tp)
- *
- *-----------------------------------------------------------------------
- */
-
-PR_IMPLEMENT(PRTime)
-PR_Now(void)
-{
- struct timeval tv;
- PRInt64 s, us, s2us;
-
- GETTIMEOFDAY(&tv);
- LL_I2L(s2us, PR_USEC_PER_SEC);
- LL_I2L(s, tv.tv_sec);
- LL_I2L(us, tv.tv_usec);
- LL_MUL(s, s, s2us);
- LL_ADD(s, s, us);
- return s;
-}
-
-PRIntervalTime
-_PR_UNIX_GetInterval()
-{
- struct timeval time;
- PRIntervalTime ticks;
-
- (void)GETTIMEOFDAY(&time); /* fallicy of course */
- ticks = (PRUint32)time.tv_sec * PR_MSEC_PER_SEC; /* that's in milliseconds */
- ticks += (PRUint32)time.tv_usec / PR_USEC_PER_MSEC; /* so's that */
- return ticks;
-} /* _PR_SUNOS_GetInterval */
-
-PRIntervalTime _PR_UNIX_TicksPerSecond()
-{
- return 1000; /* this needs some work :) */
-}
-
-/************************************************************************/
-
-/*
-** Special hacks for xlib. Xlib/Xt/Xm is not re-entrant nor is it thread
-** safe. Unfortunately, neither is mozilla. To make these programs work
-** in a pre-emptive threaded environment, we need to use a lock.
-*/
-
-void PR_XLock()
-{
- PR_EnterMonitor(_pr_Xfe_mon);
-}
-
-void PR_XUnlock()
-{
- PR_ExitMonitor(_pr_Xfe_mon);
-}
-
-PRBool PR_XIsLocked()
-{
- return (PR_InMonitor(_pr_Xfe_mon)) ? PR_TRUE : PR_FALSE;
-}
-
-void PR_XWait(int ms)
-{
- PR_Wait(_pr_Xfe_mon, PR_MillisecondsToInterval(ms));
-}
-
-void PR_XNotify(void)
-{
- PR_Notify(_pr_Xfe_mon);
-}
-
-void PR_XNotifyAll(void)
-{
- PR_NotifyAll(_pr_Xfe_mon);
-}
-
-#if !defined(BEOS)
-#ifdef HAVE_BSD_FLOCK
-
-#include <sys/file.h>
-
-PR_IMPLEMENT(PRStatus)
-_MD_LOCKFILE (PRInt32 f)
-{
- PRInt32 rv;
- rv = flock(f, LOCK_EX);
- if (rv == 0)
- return PR_SUCCESS;
- _PR_MD_MAP_FLOCK_ERROR(_MD_ERRNO());
- return PR_FAILURE;
-}
-
-PR_IMPLEMENT(PRStatus)
-_MD_TLOCKFILE (PRInt32 f)
-{
- PRInt32 rv;
- rv = flock(f, LOCK_EX|LOCK_NB);
- if (rv == 0)
- return PR_SUCCESS;
- _PR_MD_MAP_FLOCK_ERROR(_MD_ERRNO());
- return PR_FAILURE;
-}
-
-PR_IMPLEMENT(PRStatus)
-_MD_UNLOCKFILE (PRInt32 f)
-{
- PRInt32 rv;
- rv = flock(f, LOCK_UN);
- if (rv == 0)
- return PR_SUCCESS;
- _PR_MD_MAP_FLOCK_ERROR(_MD_ERRNO());
- return PR_FAILURE;
-}
-#else
-
-PR_IMPLEMENT(PRStatus)
-_MD_LOCKFILE (PRInt32 f)
-{
- PRInt32 rv;
- rv = lockf(f, F_LOCK, 0);
- if (rv == 0)
- return PR_SUCCESS;
- _PR_MD_MAP_LOCKF_ERROR(_MD_ERRNO());
- return PR_FAILURE;
-}
-
-PR_IMPLEMENT(PRStatus)
-_MD_TLOCKFILE (PRInt32 f)
-{
- PRInt32 rv;
- rv = lockf(f, F_TLOCK, 0);
- if (rv == 0)
- return PR_SUCCESS;
- _PR_MD_MAP_LOCKF_ERROR(_MD_ERRNO());
- return PR_FAILURE;
-}
-
-PR_IMPLEMENT(PRStatus)
-_MD_UNLOCKFILE (PRInt32 f)
-{
- PRInt32 rv;
- rv = lockf(f, F_ULOCK, 0);
- if (rv == 0)
- return PR_SUCCESS;
- _PR_MD_MAP_LOCKF_ERROR(_MD_ERRNO());
- return PR_FAILURE;
-}
-#endif
-
-PR_IMPLEMENT(PRStatus)
- _MD_GETHOSTNAME (char *name, PRUint32 namelen)
-{
- PRIntn rv;
-
- rv = gethostname(name, namelen);
- if (0 == rv) {
- return PR_SUCCESS;
- }
- _PR_MD_MAP_GETHOSTNAME_ERROR(_MD_ERRNO());
- return PR_FAILURE;
-}
-
-#endif
diff --git a/nsprpub/pr/src/md/beos/beos_errors.c b/nsprpub/pr/src/md/beos/beos_errors.c
deleted file mode 100644
index 687a53519..000000000
--- a/nsprpub/pr/src/md/beos/beos_errors.c
+++ /dev/null
@@ -1,1494 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-
-#include "prtypes.h"
-#include "md/_unix_errors.h"
-#include "prerror.h"
-#include <errno.h>
-
-void _MD_unix_map_opendir_error(int err)
-{
- switch (err) {
- case ENOTDIR:
- PR_SetError(PR_NOT_DIRECTORY_ERROR, err);
- break;
- case EACCES:
- PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
- break;
- case EMFILE:
- PR_SetError(PR_PROC_DESC_TABLE_FULL_ERROR, err);
- break;
- case ENFILE:
- PR_SetError(PR_SYS_DESC_TABLE_FULL_ERROR, err);
- break;
- case EFAULT:
- PR_SetError(PR_ACCESS_FAULT_ERROR, err);
- break;
- case ELOOP:
- PR_SetError(PR_LOOP_ERROR, err);
- break;
- case ENAMETOOLONG:
- PR_SetError(PR_NAME_TOO_LONG_ERROR, err);
- break;
- case ENOENT:
- PR_SetError(PR_FILE_NOT_FOUND_ERROR, err);
- break;
- default:
- PR_SetError(PR_UNKNOWN_ERROR, err);
- break;
- }
-}
-
-void _MD_unix_map_closedir_error(int err)
-{
- switch (err) {
- case EINVAL:
- case EBADF:
- PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
- break;
- default:
- PR_SetError(PR_UNKNOWN_ERROR, err);
- break;
- }
-}
-
-void _MD_unix_readdir_error(int err)
-{
-
- switch (err) {
- case 0:
- case ENOENT:
- PR_SetError(PR_NO_MORE_FILES_ERROR, err);
- break;
- case EBADF:
- PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
- break;
-#ifdef IRIX
-#ifdef IRIX5_3
-#else
- case EDIRCORRUPTED:
- PR_SetError(PR_DIRECTORY_CORRUPTED_ERROR, err);
- break;
-#endif
-#endif
-#ifdef EOVERFLOW
- case EOVERFLOW:
- PR_SetError(PR_IO_ERROR, err);
- break;
-#endif
- case EINVAL:
- PR_SetError(PR_IO_ERROR, err);
- break;
-#ifdef EBADMSG
- case EBADMSG:
- PR_SetError(PR_IO_ERROR, err);
- break;
-#endif
- case EDEADLK:
- PR_SetError(PR_DEADLOCK_ERROR, err);
- break;
- case EFAULT:
- PR_SetError(PR_ACCESS_FAULT_ERROR, err);
- break;
- case EINTR:
- PR_SetError(PR_PENDING_INTERRUPT_ERROR, err);
- break;
- case EIO:
- PR_SetError(PR_IO_ERROR, err);
- break;
- case ENOLCK:
- PR_SetError(PR_FILE_IS_LOCKED_ERROR, err);
- break;
-#ifdef ENOLINK
- case ENOLINK:
- PR_SetError(PR_REMOTE_FILE_ERROR, err);
- break;
-#endif
- case ENXIO:
- PR_SetError(PR_IO_ERROR, err);
- break;
- default:
- PR_SetError(PR_UNKNOWN_ERROR, err);
- break;
- }
-}
-
-void _MD_unix_map_unlink_error(int err)
-{
- switch (err) {
- case EACCES:
- PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
- break;
- case EBUSY:
- PR_SetError(PR_FILESYSTEM_MOUNTED_ERROR, err);
- break;
- case EFAULT:
- PR_SetError(PR_ACCESS_FAULT_ERROR, err);
- break;
- case EINTR:
- PR_SetError(PR_PENDING_INTERRUPT_ERROR, err);
- break;
- case ELOOP:
- PR_SetError(PR_LOOP_ERROR, err);
- break;
- case ENAMETOOLONG:
- PR_SetError(PR_NAME_TOO_LONG_ERROR, err);
- break;
- case ENOENT:
- PR_SetError(PR_FILE_NOT_FOUND_ERROR, err);
- break;
- case ENOTDIR:
- PR_SetError(PR_NOT_DIRECTORY_ERROR, err);
- break;
- case EPERM:
- PR_SetError(PR_IS_DIRECTORY_ERROR, err);
- break;
- case EROFS:
- PR_SetError(PR_READ_ONLY_FILESYSTEM_ERROR, err);
- break;
- default:
- PR_SetError(PR_UNKNOWN_ERROR, err);
- break;
- }
-}
-
-void _MD_unix_map_stat_error(int err)
-{
- switch (err) {
- case EACCES:
- PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
- break;
- case EFAULT:
- PR_SetError(PR_ACCESS_FAULT_ERROR, err);
- break;
- case EINTR:
- PR_SetError(PR_PENDING_INTERRUPT_ERROR, err);
- break;
- case ETIMEDOUT:
- PR_SetError(PR_REMOTE_FILE_ERROR, err);
- break;
- case ELOOP:
- PR_SetError(PR_LOOP_ERROR, err);
- break;
- case ENAMETOOLONG:
- PR_SetError(PR_NAME_TOO_LONG_ERROR, err);
- break;
- case ENOENT:
- PR_SetError(PR_FILE_NOT_FOUND_ERROR, err);
- break;
- case ENOTDIR:
- PR_SetError(PR_NOT_DIRECTORY_ERROR, err);
- break;
-#ifdef EOVERFLOW
- case EOVERFLOW:
- PR_SetError(PR_BUFFER_OVERFLOW_ERROR, err);
- break;
-#endif
- default:
- PR_SetError(PR_UNKNOWN_ERROR, err);
- break;
- }
-}
-
-void _MD_unix_map_fstat_error(int err)
-{
- switch (err) {
- case EBADF:
- PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
- break;
- case EFAULT:
- PR_SetError(PR_ACCESS_FAULT_ERROR, err);
- break;
- case EINTR:
- PR_SetError(PR_PENDING_INTERRUPT_ERROR, err);
- break;
- case ETIMEDOUT:
-#ifdef ENOLINK
- case ENOLINK:
-#endif
- PR_SetError(PR_REMOTE_FILE_ERROR, err);
- break;
-#ifdef EOVERFLOW
- case EOVERFLOW:
- PR_SetError(PR_BUFFER_OVERFLOW_ERROR, err);
- break;
-#endif
- default:
- PR_SetError(PR_UNKNOWN_ERROR, err);
- break;
- }
-}
-
-void _MD_unix_map_rename_error(int err)
-{
- switch (err) {
- case EACCES:
- PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
- break;
- case EBUSY:
- PR_SetError(PR_FILESYSTEM_MOUNTED_ERROR, err);
- break;
-#ifdef EDQUOT
- case EDQUOT:
- PR_SetError(PR_NO_DEVICE_SPACE_ERROR, err);
- break;
-#endif
- case EEXIST:
- PR_SetError(PR_DIRECTORY_NOT_EMPTY_ERROR, err);
- break;
- case EFAULT:
- PR_SetError(PR_ACCESS_FAULT_ERROR, err);
- break;
- case EINTR:
- PR_SetError(PR_PENDING_INTERRUPT_ERROR, err);
- break;
- case EINVAL:
- PR_SetError(PR_INVALID_ARGUMENT_ERROR, err);
- break;
- case EIO:
- PR_SetError(PR_IO_ERROR, err);
- break;
- case EISDIR:
- PR_SetError(PR_IS_DIRECTORY_ERROR, err);
- break;
- case ELOOP:
- PR_SetError(PR_LOOP_ERROR, err);
- break;
- case ENAMETOOLONG:
- PR_SetError(PR_NAME_TOO_LONG_ERROR, err);
- break;
- case ENOENT:
- PR_SetError(PR_FILE_NOT_FOUND_ERROR, err);
- break;
- case ENOSPC:
- PR_SetError(PR_NO_DEVICE_SPACE_ERROR, err);
- break;
- case ENOTDIR:
- PR_SetError(PR_NOT_DIRECTORY_ERROR, err);
- break;
- case EROFS:
- PR_SetError(PR_READ_ONLY_FILESYSTEM_ERROR, err);
- break;
- case EXDEV:
- PR_SetError(PR_NOT_SAME_DEVICE_ERROR, err);
- break;
- case EMLINK:
- PR_SetError(PR_MAX_DIRECTORY_ENTRIES_ERROR, err);
- break;
- default:
- PR_SetError(PR_UNKNOWN_ERROR, err);
- break;
- }
-}
-
-void _MD_unix_map_access_error(int err)
-{
- switch (err) {
- case EACCES:
- PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
- break;
- case EFAULT:
- PR_SetError(PR_ACCESS_FAULT_ERROR, err);
- break;
- case EINTR:
- PR_SetError(PR_PENDING_INTERRUPT_ERROR, err);
- break;
- case EINVAL:
- PR_SetError(PR_INVALID_ARGUMENT_ERROR, err);
- break;
- case ELOOP:
- PR_SetError(PR_LOOP_ERROR, err);
- break;
- case ETIMEDOUT:
- PR_SetError(PR_REMOTE_FILE_ERROR, err);
- break;
- case ENAMETOOLONG:
- PR_SetError(PR_NAME_TOO_LONG_ERROR, err);
- break;
- case ENOENT:
- PR_SetError(PR_FILE_NOT_FOUND_ERROR, err);
- break;
- case ENOTDIR:
- PR_SetError(PR_NOT_DIRECTORY_ERROR, err);
- break;
- case EROFS:
- PR_SetError(PR_READ_ONLY_FILESYSTEM_ERROR, err);
- break;
- default:
- PR_SetError(PR_UNKNOWN_ERROR, err);
- break;
- }
-}
-
-void _MD_unix_map_mkdir_error(int err)
-{
- switch (err) {
- case ENOTDIR:
- PR_SetError(PR_NOT_DIRECTORY_ERROR, err);
- break;
- case ENOENT:
- PR_SetError(PR_FILE_NOT_FOUND_ERROR, err);
- break;
- case ENAMETOOLONG:
- PR_SetError(PR_NAME_TOO_LONG_ERROR, err);
- break;
- case EACCES:
- PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
- break;
- case EEXIST:
- PR_SetError(PR_FILE_EXISTS_ERROR, err);
- break;
- case EROFS:
- PR_SetError(PR_READ_ONLY_FILESYSTEM_ERROR, err);
- break;
- case EFAULT:
- PR_SetError(PR_ACCESS_FAULT_ERROR, err);
- break;
- case ELOOP:
- PR_SetError(PR_LOOP_ERROR, err);
- break;
- case EMLINK:
- PR_SetError(PR_MAX_DIRECTORY_ENTRIES_ERROR, err);
- break;
- case ENOSPC:
- PR_SetError(PR_NO_DEVICE_SPACE_ERROR, err);
- break;
-#ifdef EDQUOT
- case EDQUOT:
- PR_SetError(PR_NO_DEVICE_SPACE_ERROR, err);
- break;
-#endif
- case EIO:
- PR_SetError(PR_IO_ERROR, err);
- break;
- default:
- PR_SetError(PR_UNKNOWN_ERROR, err);
- break;
- }
-}
-
-void _MD_unix_map_rmdir_error(int err)
-{
-
- switch (err) {
- case EACCES:
- PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
- break;
- case EBUSY:
- PR_SetError(PR_FILESYSTEM_MOUNTED_ERROR, err);
- break;
- case EEXIST:
- PR_SetError(PR_DIRECTORY_NOT_EMPTY_ERROR, err);
- break;
- case EFAULT:
- PR_SetError(PR_ACCESS_FAULT_ERROR, err);
- break;
- case EINVAL:
- PR_SetError(PR_DIRECTORY_NOT_EMPTY_ERROR, err);
- break;
- case EIO:
- PR_SetError(PR_IO_ERROR, err);
- break;
- case ELOOP:
- PR_SetError(PR_LOOP_ERROR, err);
- break;
- case ETIMEDOUT:
- PR_SetError(PR_REMOTE_FILE_ERROR, err);
- break;
- case ENAMETOOLONG:
- PR_SetError(PR_NAME_TOO_LONG_ERROR, err);
- break;
- case ENOENT:
- PR_SetError(PR_FILE_NOT_FOUND_ERROR, err);
- break;
- case ENOTDIR:
- PR_SetError(PR_NOT_DIRECTORY_ERROR, err);
- break;
- case EROFS:
- PR_SetError(PR_READ_ONLY_FILESYSTEM_ERROR, err);
- break;
- default:
- PR_SetError(PR_UNKNOWN_ERROR, err);
- break;
- }
-}
-
-void _MD_unix_map_read_error(int err)
-{
- switch (err) {
- case EACCES:
- PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
- break;
- case EAGAIN:
-#if EWOULDBLOCK != EAGAIN
- case EWOULDBLOCK:
-#endif
- PR_SetError(PR_WOULD_BLOCK_ERROR, err);
- break;
- case EBADF:
- PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
- break;
-#ifdef EBADMSG
- case EBADMSG:
- PR_SetError(PR_IO_ERROR, err);
- break;
-#endif
- case EDEADLK:
- PR_SetError(PR_DEADLOCK_ERROR, err);
- break;
- case EFAULT:
- PR_SetError(PR_ACCESS_FAULT_ERROR, err);
- break;
- case EINTR:
- PR_SetError(PR_PENDING_INTERRUPT_ERROR, err);
- break;
- case EINVAL:
- PR_SetError(PR_INVALID_METHOD_ERROR, err);
- break;
- case EIO:
- PR_SetError(PR_IO_ERROR, err);
- break;
- case ENOLCK:
- PR_SetError(PR_FILE_IS_LOCKED_ERROR, err);
- break;
- case ENXIO:
- PR_SetError(PR_INVALID_ARGUMENT_ERROR, err);
- break;
- case EISDIR:
- PR_SetError(PR_IS_DIRECTORY_ERROR, err);
- break;
- case ECONNRESET:
- case EPIPE:
- PR_SetError(PR_CONNECT_RESET_ERROR, err);
- break;
-#ifdef ENOLINK
- case ENOLINK:
- PR_SetError(PR_REMOTE_FILE_ERROR, err);
- break;
-#endif
- default:
- PR_SetError(PR_UNKNOWN_ERROR, err);
- break;
- }
-}
-
-void _MD_unix_map_write_error(int err)
-{
- switch (err) {
- case EAGAIN:
-#if EWOULDBLOCK != EAGAIN
- case EWOULDBLOCK:
-#endif
- PR_SetError(PR_WOULD_BLOCK_ERROR, err);
- break;
- case EBADF:
- PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
- break;
- case EDEADLK:
- PR_SetError(PR_DEADLOCK_ERROR, err);
- break;
- case EFAULT:
- PR_SetError(PR_ACCESS_FAULT_ERROR, err);
- break;
- case EFBIG:
- PR_SetError(PR_FILE_TOO_BIG_ERROR, err);
- break;
- case EINTR:
- PR_SetError(PR_PENDING_INTERRUPT_ERROR, err);
- break;
- case EINVAL:
- PR_SetError(PR_INVALID_METHOD_ERROR, err);
- break;
- case EIO:
- PR_SetError(PR_IO_ERROR, err);
- break;
- case ENOLCK:
- PR_SetError(PR_FILE_IS_LOCKED_ERROR, err);
- break;
-#ifdef ENOSR
- case ENOSR:
- PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
- break;
-#endif
- case ENOSPC:
- PR_SetError(PR_NO_DEVICE_SPACE_ERROR, err);
- break;
- case ENXIO:
- PR_SetError(PR_INVALID_METHOD_ERROR, err);
- break;
- case ERANGE:
- PR_SetError(PR_INVALID_METHOD_ERROR, err);
- break;
- case ETIMEDOUT:
- PR_SetError(PR_REMOTE_FILE_ERROR, err);
- break;
- case ECONNRESET:
- case EPIPE:
- PR_SetError(PR_CONNECT_RESET_ERROR, err);
- break;
-#ifdef EDQUOT
- case EDQUOT:
- PR_SetError(PR_NO_DEVICE_SPACE_ERROR, err);
- break;
-#endif
-#ifdef ENOLINK
- case ENOLINK:
- PR_SetError(PR_REMOTE_FILE_ERROR, err);
- break;
-#endif
- default:
- PR_SetError(PR_UNKNOWN_ERROR, err);
- break;
- }
-}
-
-void _MD_unix_map_lseek_error(int err)
-{
- switch (err) {
- case EBADF:
- PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
- break;
- case ESPIPE:
- PR_SetError(PR_INVALID_METHOD_ERROR, err);
- break;
- case EINVAL:
- PR_SetError(PR_INVALID_ARGUMENT_ERROR, err);
- break;
- default:
- PR_SetError(PR_UNKNOWN_ERROR, err);
- break;
- }
-}
-
-void _MD_unix_map_fsync_error(int err)
-{
- switch (err) {
- case EBADF:
- PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
- break;
-#ifdef ENOLINK
- case ENOLINK:
-#endif
- case ETIMEDOUT:
- PR_SetError(PR_REMOTE_FILE_ERROR, err);
- break;
- case EINTR:
- PR_SetError(PR_PENDING_INTERRUPT_ERROR, err);
- break;
- case EIO:
- PR_SetError(PR_IO_ERROR, err);
- break;
- case EINVAL:
- PR_SetError(PR_INVALID_METHOD_ERROR, err);
- break;
- default:
- PR_SetError(PR_UNKNOWN_ERROR, err);
- break;
- }
-}
-
-void _MD_unix_map_close_error(int err)
-{
- switch (err) {
- case EBADF:
- PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
- break;
- case EINTR:
- PR_SetError(PR_PENDING_INTERRUPT_ERROR, err);
- break;
-#ifdef ENOLINK
- case ENOLINK:
-#endif
- case ETIMEDOUT:
- PR_SetError(PR_REMOTE_FILE_ERROR, err);
- break;
- case EIO:
- PR_SetError(PR_IO_ERROR, err);
- break;
- default:
- PR_SetError(PR_UNKNOWN_ERROR, err);
- break;
- }
-}
-
-void _MD_unix_map_socket_error(int err)
-{
- switch (err) {
- case EPROTONOSUPPORT:
- PR_SetError(PR_PROTOCOL_NOT_SUPPORTED_ERROR, err);
- break;
- case EMFILE:
- PR_SetError(PR_PROC_DESC_TABLE_FULL_ERROR, err);
- break;
- case ENFILE:
- PR_SetError(PR_SYS_DESC_TABLE_FULL_ERROR, err);
- break;
- case EACCES:
- PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
- break;
-#if !defined(SCO)
- case ENOBUFS:
-#endif /* !defined(SCO) */
- case ENOMEM:
-#ifdef ENOSR
- case ENOSR:
- PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
- break;
-#endif
- default:
- PR_SetError(PR_UNKNOWN_ERROR, err);
- break;
- }
-}
-
-void _MD_unix_map_socketavailable_error(int err)
-{
- PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
-}
-
-void _MD_unix_map_recv_error(int err)
-{
- switch (err) {
- case EAGAIN:
-#if EWOULDBLOCK != EAGAIN
- case EWOULDBLOCK:
-#endif
- PR_SetError(PR_WOULD_BLOCK_ERROR, err);
- break;
- case EBADF:
- PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
- break;
-#if !defined(BEOS)
- case ENOTSOCK:
- PR_SetError(PR_NOT_SOCKET_ERROR, err);
- break;
-#endif
- case EINTR:
- PR_SetError(PR_PENDING_INTERRUPT_ERROR, err);
- break;
- case EFAULT:
- PR_SetError(PR_ACCESS_FAULT_ERROR, err);
- break;
- case ENOMEM:
- PR_SetError(PR_OUT_OF_MEMORY_ERROR, err);
- break;
- case ECONNRESET:
- case EPIPE:
- PR_SetError(PR_CONNECT_RESET_ERROR, err);
- break;
-#ifdef ENOSR
- case ENOSR:
- PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
- break;
-#endif
- default:
- PR_SetError(PR_UNKNOWN_ERROR, err);
- break;
- }
-}
-
-void _MD_unix_map_recvfrom_error(int err)
-{
- switch (err) {
- case EAGAIN:
-#if EWOULDBLOCK != EAGAIN
- case EWOULDBLOCK:
-#endif
- PR_SetError(PR_WOULD_BLOCK_ERROR, err);
- break;
- case EBADF:
- PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
- break;
-#if !defined(BEOS)
- case ENOTSOCK:
- PR_SetError(PR_NOT_SOCKET_ERROR, err);
- break;
-#endif
- case EINTR:
- PR_SetError(PR_PENDING_INTERRUPT_ERROR, err);
- break;
- case EFAULT:
- PR_SetError(PR_ACCESS_FAULT_ERROR, err);
- break;
- case ENOMEM:
- PR_SetError(PR_OUT_OF_MEMORY_ERROR, err);
- break;
-#ifdef ENOSR
- case ENOSR:
- PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
- break;
-#endif
- case ECONNRESET:
- PR_SetError(PR_CONNECT_RESET_ERROR, err);
- break;
- default:
- PR_SetError(PR_UNKNOWN_ERROR, err);
- break;
- }
-}
-
-void _MD_unix_map_send_error(int err)
-{
- switch (err) {
- case EAGAIN:
-#if EWOULDBLOCK != EAGAIN
- case EWOULDBLOCK:
-#endif
- PR_SetError(PR_WOULD_BLOCK_ERROR, err);
- break;
- case EBADF:
- PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
- break;
-#if !defined(BEOS)
- case ENOTSOCK:
- PR_SetError(PR_NOT_SOCKET_ERROR, err);
- break;
-#endif
-#if !defined(BEOS)
- case EMSGSIZE:
-#endif
- case EINVAL:
- PR_SetError(PR_INVALID_ARGUMENT_ERROR, err);
- break;
-#if !defined(SCO)
- case ENOBUFS:
- PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
- break;
-#endif /* !defined(SCO) */
- case ECONNREFUSED:
- PR_SetError(PR_CONNECT_REFUSED_ERROR, err);
- break;
- case EISCONN:
- PR_SetError(PR_IS_CONNECTED_ERROR, err);
- break;
- case EFAULT:
- PR_SetError(PR_ACCESS_FAULT_ERROR, err);
- break;
- case EINTR:
- PR_SetError(PR_PENDING_INTERRUPT_ERROR, err);
- break;
- case ENOMEM:
- PR_SetError(PR_OUT_OF_MEMORY_ERROR, err);
- break;
-#ifdef ENOSR
- case ENOSR:
- PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
- break;
-#endif
- case ECONNRESET:
- case EPIPE:
- PR_SetError(PR_CONNECT_RESET_ERROR, err);
- break;
- default:
- PR_SetError(PR_UNKNOWN_ERROR, err);
- break;
- }
-}
-
-void _MD_unix_map_sendto_error(int err)
-{
- switch (err) {
- case EAGAIN:
-#if EWOULDBLOCK != EAGAIN
- case EWOULDBLOCK:
-#endif
- PR_SetError(PR_WOULD_BLOCK_ERROR, err);
- break;
- case EBADF:
- PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
- break;
-#if !defined(BEOS)
- case ENOTSOCK:
- PR_SetError(PR_NOT_SOCKET_ERROR, err);
- break;
-#endif
-#if !defined(BEOS)
- case EMSGSIZE:
-#endif
- case EINVAL:
- PR_SetError(PR_INVALID_ARGUMENT_ERROR, err);
- break;
-#if !defined(SCO)
- case ENOBUFS:
- PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
- break;
-#endif /* !defined(SCO) */
- case ECONNREFUSED:
- PR_SetError(PR_CONNECT_REFUSED_ERROR, err);
- break;
- case EISCONN:
- PR_SetError(PR_IS_CONNECTED_ERROR, err);
- break;
- case EFAULT:
- PR_SetError(PR_ACCESS_FAULT_ERROR, err);
- break;
- case EINTR:
- PR_SetError(PR_PENDING_INTERRUPT_ERROR, err);
- break;
- case ENOMEM:
- PR_SetError(PR_OUT_OF_MEMORY_ERROR, err);
- break;
-#ifdef ENOSR
- case ENOSR:
- PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
- break;
-#endif
- case ECONNRESET:
- case EPIPE:
- PR_SetError(PR_CONNECT_RESET_ERROR, err);
- break;
- default:
- PR_SetError(PR_UNKNOWN_ERROR, err);
- break;
- }
-}
-
-void _MD_unix_map_writev_error(int err)
-{
- switch (err) {
- case EAGAIN:
-#if EWOULDBLOCK != EAGAIN
- case EWOULDBLOCK:
-#endif
- PR_SetError(PR_WOULD_BLOCK_ERROR, err);
- break;
- case EBADF:
- PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
- break;
- case EFAULT:
- PR_SetError(PR_ACCESS_FAULT_ERROR, err);
- break;
- case EINTR:
- PR_SetError(PR_PENDING_INTERRUPT_ERROR, err);
- break;
-#ifdef ENOSR
- case ENOSR:
- PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
- break;
-#endif
- case EINVAL:
- PR_SetError(PR_INVALID_ARGUMENT_ERROR, err);
- break;
- case ECONNRESET:
- case EPIPE:
- PR_SetError(PR_CONNECT_RESET_ERROR, err);
- break;
- default:
- PR_SetError(PR_UNKNOWN_ERROR, err);
- break;
- }
-}
-
-void _MD_unix_map_accept_error(int err)
-{
- switch (err) {
- case EAGAIN:
-#if EWOULDBLOCK != EAGAIN
- case EWOULDBLOCK:
-#endif
- PR_SetError(PR_WOULD_BLOCK_ERROR, err);
- break;
- case EBADF:
- PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
- break;
-#if !defined(BEOS)
- case ENOTSOCK:
- PR_SetError(PR_NOT_SOCKET_ERROR, err);
- break;
-#endif
-#if !defined(BEOS)
- case EOPNOTSUPP:
-#endif
- case ENODEV:
- PR_SetError(PR_NOT_TCP_SOCKET_ERROR, err);
- break;
- case EFAULT:
- PR_SetError(PR_ACCESS_FAULT_ERROR, err);
- break;
- case EMFILE:
- PR_SetError(PR_PROC_DESC_TABLE_FULL_ERROR, err);
- break;
- case ENFILE:
- PR_SetError(PR_SYS_DESC_TABLE_FULL_ERROR, err);
- break;
- case EINTR:
- PR_SetError(PR_PENDING_INTERRUPT_ERROR, err);
- break;
- case ENOMEM:
- PR_SetError(PR_OUT_OF_MEMORY_ERROR, err);
- break;
-#ifdef ENOSR
- case ENOSR:
- PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
- break;
-#endif
-#ifdef EPROTO
- case EPROTO:
- PR_SetError(PR_IO_ERROR, err);
- break;
-#endif
- default:
- PR_SetError(PR_UNKNOWN_ERROR, err);
- break;
- }
-}
-
-void _MD_unix_map_connect_error(int err)
-{
- switch (err) {
- case EBADF:
- PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
- break;
- case EADDRNOTAVAIL:
- PR_SetError(PR_ADDRESS_NOT_AVAILABLE_ERROR, err);
- break;
- case EINPROGRESS:
- PR_SetError(PR_IN_PROGRESS_ERROR, err);
- break;
- case EALREADY:
- PR_SetError(PR_ALREADY_INITIATED_ERROR, err);
- break;
-#if !defined(BEOS)
- case ENOTSOCK:
- PR_SetError(PR_NOT_SOCKET_ERROR, err);
- break;
-#endif
- case EAFNOSUPPORT:
- PR_SetError(PR_ADDRESS_NOT_SUPPORTED_ERROR, err);
- break;
- case EISCONN:
- PR_SetError(PR_IS_CONNECTED_ERROR, err);
- break;
- case ETIMEDOUT:
- PR_SetError(PR_IO_TIMEOUT_ERROR, err);
- break;
- case ECONNREFUSED:
- PR_SetError(PR_CONNECT_REFUSED_ERROR, err);
- break;
- case ENETUNREACH:
- PR_SetError(PR_NETWORK_UNREACHABLE_ERROR, err);
- break;
- case EADDRINUSE:
- PR_SetError(PR_ADDRESS_IN_USE_ERROR, err);
- break;
- case EFAULT:
- PR_SetError(PR_ACCESS_FAULT_ERROR, err);
- break;
- /*
- * UNIX domain sockets are not supported in NSPR
- */
- case EACCES:
- PR_SetError(PR_ADDRESS_NOT_SUPPORTED_ERROR, err);
- break;
- case EINTR:
- PR_SetError(PR_PENDING_INTERRUPT_ERROR, err);
- break;
- case EINVAL:
- PR_SetError(PR_INVALID_ARGUMENT_ERROR, err);
- break;
- case EIO:
-#if defined(UNIXWARE)
- /*
- * On some platforms, if we connect to a port on
- * the local host (the loopback address) that no
- * process is listening on, we get EIO instead
- * of ECONNREFUSED.
- */
- PR_SetError(PR_CONNECT_REFUSED_ERROR, err);
-#else
- PR_SetError(PR_IO_ERROR, err);
-#endif
- break;
- case ELOOP:
- PR_SetError(PR_ADDRESS_NOT_SUPPORTED_ERROR, err);
- break;
- case ENOENT:
- PR_SetError(PR_ADDRESS_NOT_SUPPORTED_ERROR, err);
- break;
-#ifdef ENOSR
- case ENOSR:
- PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
- break;
-#endif
- case ENXIO:
- PR_SetError(PR_IO_ERROR, err);
- break;
- case EPROTOTYPE:
- PR_SetError(PR_ADDRESS_NOT_SUPPORTED_ERROR, err);
- break;
- default:
- PR_SetError(PR_UNKNOWN_ERROR, err);
- break;
- }
-}
-
-void _MD_unix_map_bind_error(int err)
-{
- switch (err) {
- case EBADF:
- PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
- break;
-#if !defined(BEOS)
- case ENOTSOCK:
- PR_SetError(PR_NOT_SOCKET_ERROR, err);
- break;
-#endif
- case EFAULT:
- PR_SetError(PR_ACCESS_FAULT_ERROR, err);
- break;
- case EADDRNOTAVAIL:
- PR_SetError(PR_ADDRESS_NOT_AVAILABLE_ERROR, err);
- break;
- case EADDRINUSE:
- PR_SetError(PR_ADDRESS_IN_USE_ERROR, err);
- break;
- case EACCES:
- PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
- break;
- case EINVAL:
- PR_SetError(PR_SOCKET_ADDRESS_IS_BOUND_ERROR, err);
- break;
-#ifdef ENOSR
- case ENOSR:
- PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
- break;
-#endif
- /*
- * UNIX domain sockets are not supported in NSPR
- */
- case EIO:
- case EISDIR:
- case ELOOP:
- case ENOENT:
- case ENOTDIR:
- case EROFS:
- PR_SetError(PR_ADDRESS_NOT_SUPPORTED_ERROR, err);
- break;
- default:
- PR_SetError(PR_UNKNOWN_ERROR, err);
- break;
- }
-}
-
-void _MD_unix_map_listen_error(int err)
-{
- switch (err) {
- case EBADF:
- PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
- break;
-#if !defined(BEOS)
- case ENOTSOCK:
- PR_SetError(PR_NOT_SOCKET_ERROR, err);
- break;
-#endif
-#if !defined(BEOS)
- case EOPNOTSUPP:
- PR_SetError(PR_NOT_TCP_SOCKET_ERROR, err);
- break;
-#endif
- default:
- PR_SetError(PR_UNKNOWN_ERROR, err);
- break;
- }
-}
-
-void _MD_unix_map_shutdown_error(int err)
-{
- switch (err) {
- case EBADF:
- PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
- break;
-#if !defined(BEOS)
- case ENOTSOCK:
- PR_SetError(PR_NOT_SOCKET_ERROR, err);
- break;
-#endif
- case ENOTCONN:
- PR_SetError(PR_NOT_CONNECTED_ERROR, err);
- break;
- case ENOMEM:
- PR_SetError(PR_OUT_OF_MEMORY_ERROR, err);
- break;
-#ifdef ENOSR
- case ENOSR:
- PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
- break;
-#endif
- default:
- PR_SetError(PR_UNKNOWN_ERROR, err);
- break;
- }
-}
-
-void _MD_unix_map_socketpair_error(int err)
-{
- switch (err) {
- case EMFILE:
- PR_SetError(PR_PROC_DESC_TABLE_FULL_ERROR, err);
- break;
- case EFAULT:
- PR_SetError(PR_ACCESS_FAULT_ERROR, err);
- break;
- case ENOMEM:
-#ifdef ENOSR
- case ENOSR:
-#endif
- PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
- break;
- case EAFNOSUPPORT:
- case EPROTONOSUPPORT:
-#if !defined(BEOS)
- case EOPNOTSUPP:
-#endif
- default:
- PR_SetError(PR_UNKNOWN_ERROR, err);
- break;
- }
-}
-
-void _MD_unix_map_getsockname_error(int err)
-{
- switch (err) {
- case EBADF:
- PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
- break;
-#if !defined(BEOS)
- case ENOTSOCK:
- PR_SetError(PR_NOT_SOCKET_ERROR, err);
- break;
-#endif
- case EFAULT:
- PR_SetError(PR_ACCESS_FAULT_ERROR, err);
- break;
-#if !defined(SCO)
- case ENOBUFS:
-#endif /* !defined(SCO) */
- case ENOMEM:
-#ifdef ENOSR
- case ENOSR:
-#endif
- PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
- break;
- default:
- PR_SetError(PR_UNKNOWN_ERROR, err);
- break;
- }
-}
-
-void _MD_unix_map_getpeername_error(int err)
-{
-
- switch (err) {
- case EBADF:
- PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
- break;
-#if !defined(BEOS)
- case ENOTSOCK:
- PR_SetError(PR_NOT_SOCKET_ERROR, err);
- break;
-#endif
- case ENOTCONN:
- PR_SetError(PR_NOT_CONNECTED_ERROR, err);
- break;
- case EFAULT:
- PR_SetError(PR_ACCESS_FAULT_ERROR, err);
- break;
-#if !defined(SCO)
- case ENOBUFS:
-#endif /* !defined(SCO) */
- case ENOMEM:
-#ifdef ENOSR
- case ENOSR:
-#endif
- PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
- break;
- default:
- PR_SetError(PR_UNKNOWN_ERROR, err);
- break;
- }
-}
-
-void _MD_unix_map_getsockopt_error(int err)
-{
- switch (err) {
- case EBADF:
- PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
- break;
-#if !defined(BEOS)
- case ENOTSOCK:
- PR_SetError(PR_NOT_SOCKET_ERROR, err);
- break;
-#endif
- case ENOPROTOOPT:
- PR_SetError(PR_INVALID_ARGUMENT_ERROR, err);
- break;
- case EFAULT:
- PR_SetError(PR_ACCESS_FAULT_ERROR, err);
- break;
- case EINVAL:
- PR_SetError(PR_BUFFER_OVERFLOW_ERROR, err);
- break;
- case ENOMEM:
-#ifdef ENOSR
- case ENOSR:
-#endif
- PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
- break;
- default:
- PR_SetError(PR_UNKNOWN_ERROR, err);
- break;
- }
-}
-
-void _MD_unix_map_setsockopt_error(int err)
-{
- switch (err) {
- case EBADF:
- PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
- break;
-#if !defined(BEOS)
- case ENOTSOCK:
- PR_SetError(PR_NOT_SOCKET_ERROR, err);
- break;
-#endif
- case ENOPROTOOPT:
- PR_SetError(PR_INVALID_ARGUMENT_ERROR, err);
- break;
- case EFAULT:
- PR_SetError(PR_ACCESS_FAULT_ERROR, err);
- break;
- case EINVAL:
- PR_SetError(PR_BUFFER_OVERFLOW_ERROR, err);
- break;
- case ENOMEM:
-#ifdef ENOSR
- case ENOSR:
-#endif
- PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
- break;
- default:
- PR_SetError(PR_UNKNOWN_ERROR, err);
- break;
- }
-}
-
-void _MD_unix_map_open_error(int err)
-{
- switch (err) {
- case EACCES:
- PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
- break;
- case EAGAIN:
- PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
- break;
- case EBUSY:
- PR_SetError(PR_IO_ERROR, err);
- break;
- case EEXIST:
- PR_SetError(PR_FILE_EXISTS_ERROR, err);
- break;
- case EFAULT:
- PR_SetError(PR_ACCESS_FAULT_ERROR, err);
- break;
- case EINTR:
- PR_SetError(PR_PENDING_INTERRUPT_ERROR, err);
- break;
- case EINVAL:
- PR_SetError(PR_INVALID_ARGUMENT_ERROR, err);
- break;
- case EIO:
- PR_SetError(PR_IO_ERROR, err);
- break;
- case EISDIR:
- PR_SetError(PR_IS_DIRECTORY_ERROR, err);
- break;
- case ELOOP:
- PR_SetError(PR_LOOP_ERROR, err);
- break;
- case EMFILE:
- PR_SetError(PR_PROC_DESC_TABLE_FULL_ERROR, err);
- break;
- case ENAMETOOLONG:
- PR_SetError(PR_NAME_TOO_LONG_ERROR, err);
- break;
- case ENFILE:
- PR_SetError(PR_SYS_DESC_TABLE_FULL_ERROR, err);
- break;
- case ENODEV:
- case ENOENT:
- case ENXIO:
- PR_SetError(PR_FILE_NOT_FOUND_ERROR, err);
- break;
- case ENOMEM:
- PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
- break;
- case ENOSPC:
- PR_SetError(PR_NO_DEVICE_SPACE_ERROR, err);
- break;
-#ifdef ENOSR
- case ENOSR:
-#endif
- PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
- break;
- case ENOTDIR:
- PR_SetError(PR_NOT_DIRECTORY_ERROR, err);
- break;
- case EPERM:
- PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
- break;
- case ETIMEDOUT:
- PR_SetError(PR_REMOTE_FILE_ERROR, err);
- break;
- case EROFS:
- PR_SetError(PR_READ_ONLY_FILESYSTEM_ERROR, err);
- break;
- default:
- PR_SetError(PR_UNKNOWN_ERROR, err);
- break;
- }
-}
-
-void _MD_unix_map_mmap_error(int err)
-{
-
- switch (err) {
- case EBADF:
- PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
- break;
- case EAGAIN:
- PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
- break;
- case EACCES:
- PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, err);
- break;
- case ENOMEM:
- PR_SetError(PR_OUT_OF_MEMORY_ERROR, err);
- break;
- default:
- PR_SetError(PR_UNKNOWN_ERROR, err);
- break;
- }
-}
-
-void _MD_unix_map_gethostname_error(int err)
-{
- switch (err) {
- case EFAULT:
- PR_SetError(PR_ACCESS_FAULT_ERROR, err);
- break;
- default:
- PR_SetError(PR_UNKNOWN_ERROR, err);
- break;
- }
-}
-
-void _MD_unix_map_select_error(int err)
-{
- switch (err) {
- case EBADF:
- PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
- break;
- case EINTR:
- PR_SetError(PR_PENDING_INTERRUPT_ERROR, err);
- break;
- case EINVAL:
- PR_SetError(PR_INVALID_ARGUMENT_ERROR, err);
- break;
- default:
- PR_SetError(PR_UNKNOWN_ERROR, err);
- break;
- }
-}
-
-void _MD_unix_map_poll_error(int err)
-{
- PRErrorCode prerror;
- switch (err) {
- case EAGAIN:
- prerror = PR_INSUFFICIENT_RESOURCES_ERROR;
- break;
- case EINVAL:
- prerror = PR_INVALID_ARGUMENT_ERROR;
- break;
- case EFAULT:
- prerror = PR_ACCESS_FAULT_ERROR;
- break;
- default:
- prerror = PR_UNKNOWN_ERROR;
- break;
- }
- PR_SetError(prerror, err);
-}
-
-void _MD_unix_map_flock_error(int err)
-{
- switch (err) {
- case EBADF:
- case EINVAL:
- PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
- break;
- case EWOULDBLOCK:
- PR_SetError(PR_FILE_IS_LOCKED_ERROR, err);
- break;
- default:
- PR_SetError(PR_UNKNOWN_ERROR, err);
- break;
- }
-}
-
-void _MD_unix_map_lockf_error(int err)
-{
- switch (err) {
- case EBADF:
- PR_SetError(PR_BAD_DESCRIPTOR_ERROR, err);
- break;
- case EACCES:
- PR_SetError(PR_FILE_IS_LOCKED_ERROR, err);
- break;
- case EDEADLK:
- PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, err);
- break;
- default:
- PR_SetError(PR_UNKNOWN_ERROR, err);
- break;
- }
-}
-
-#ifdef HPUX11
-void _MD_hpux_map_sendfile_error(int oserror)
-{
- PRErrorCode prerror;
-
- switch (oserror) {
- case ENOTSOCK:
- prerror = PR_NOT_SOCKET_ERROR;
- break;
- case EFAULT:
- prerror = PR_ACCESS_FAULT_ERROR;
- break;
- case ENOBUFS:
- prerror = PR_INSUFFICIENT_RESOURCES_ERROR;
- break;
- case EINVAL:
- prerror = PR_INVALID_ARGUMENT_ERROR;
- break;
- case ENOTCONN:
- prerror = PR_NOT_CONNECTED_ERROR;
- break;
- case EPIPE:
- prerror = PR_CONNECT_RESET_ERROR;
- break;
- case ENOMEM:
- prerror = PR_OUT_OF_MEMORY_ERROR;
- break;
- case EOPNOTSUPP:
- prerror = PR_NOT_TCP_SOCKET_ERROR;
- break;
- default:
- prerror = PR_UNKNOWN_ERROR;
- }
- PR_SetError(prerror, oserror);
-}
-#endif /* HPUX11 */
diff --git a/nsprpub/pr/src/md/beos/bfile.c b/nsprpub/pr/src/md/beos/bfile.c
deleted file mode 100644
index 89fea29a2..000000000
--- a/nsprpub/pr/src/md/beos/bfile.c
+++ /dev/null
@@ -1,873 +0,0 @@
-/* -*- Mode: C++; tab-width: 8; c-basic-offset: 8 -*- */
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-
-#include "primpl.h"
-
-/*
-** Global lock variable used to bracket calls into rusty libraries that
-** aren't thread safe (like libc, libX, etc).
-*/
-static PRLock *_pr_rename_lock = NULL;
-
-void
-_MD_InitIO (void)
-{
-}
-
-PRStatus
-_MD_open_dir (_MDDir *md,const char *name)
-{
-int err;
-
- md->d = opendir(name);
- if (!md->d) {
- err = _MD_ERRNO();
- _PR_MD_MAP_OPENDIR_ERROR(err);
- return PR_FAILURE;
- }
- return PR_SUCCESS;
-}
-
-char*
-_MD_read_dir (_MDDir *md, PRIntn flags)
-{
-struct dirent *de;
-int err;
-
- for (;;) {
- /*
- * XXX: readdir() is not MT-safe
- */
- _MD_ERRNO() = 0;
- de = readdir(md->d);
-
- if (!de) {
- err = _MD_ERRNO();
- _PR_MD_MAP_READDIR_ERROR(err);
- return 0;
- }
-
- if ((flags & PR_SKIP_DOT) &&
- (de->d_name[0] == '.') && (de->d_name[1] == 0))
- continue;
-
- if ((flags & PR_SKIP_DOT_DOT) &&
- (de->d_name[0] == '.') && (de->d_name[1] == '.') &&
- (de->d_name[2] == 0))
- continue;
-
- if ((flags & PR_SKIP_HIDDEN) && (de->d_name[1] == '.'))
- continue;
-
- break;
- }
- return de->d_name;
-}
-
-
-PRInt32
-_MD_close_dir (_MDDir *md)
-{
-int rv = 0, err;
-
- if (md->d) {
- rv = closedir(md->d);
- if (rv == -1) {
- err = _MD_ERRNO();
- _PR_MD_MAP_CLOSEDIR_ERROR(err);
- }
- }
- return(rv);
-}
-
-void
-_MD_make_nonblock (PRFileDesc *fd)
-{
- int blocking = 1;
- setsockopt(fd->secret->md.osfd, SOL_SOCKET, SO_NONBLOCK, &blocking, sizeof(blocking));
-
-}
-
-PRStatus
-_MD_set_fd_inheritable (PRFileDesc *fd, PRBool inheritable)
-{
- int rv;
-
- rv = fcntl(fd->secret->md.osfd, F_SETFD, inheritable ? 0 : FD_CLOEXEC);
- if (-1 == rv) {
- PR_SetError(PR_UNKNOWN_ERROR, _MD_ERRNO());
- return PR_FAILURE;
- }
- return PR_SUCCESS;
-}
-
-void
-_MD_init_fd_inheritable (PRFileDesc *fd, PRBool imported)
-{
- if (imported) {
- fd->secret->inheritable = _PR_TRI_UNKNOWN;
- } else {
- int flags = fcntl(fd->secret->md.osfd, F_GETFD, 0);
- if (flags == -1) {
- PR_SetError(PR_UNKNOWN_ERROR, _MD_ERRNO());
- return;
- }
- fd->secret->inheritable = (flags & FD_CLOEXEC) ?
- _PR_TRI_TRUE : _PR_TRI_FALSE;
- }
-}
-
-void
-_MD_query_fd_inheritable (PRFileDesc *fd)
-{
- int flags;
-
- PR_ASSERT(_PR_TRI_UNKNOWN == fd->secret->inheritable);
- flags = fcntl(fd->secret->md.osfd, F_GETFD, 0);
- PR_ASSERT(-1 != flags);
- fd->secret->inheritable = (flags & FD_CLOEXEC) ?
- _PR_TRI_FALSE : _PR_TRI_TRUE;
-}
-
-PRInt32
-_MD_open (const char *name, PRIntn flags, PRIntn mode)
-{
- PRInt32 osflags;
- PRInt32 rv, err;
-
- if (flags & PR_RDWR) {
- osflags = O_RDWR;
- } else if (flags & PR_WRONLY) {
- osflags = O_WRONLY;
- } else {
- osflags = O_RDONLY;
- }
-
- if (flags & PR_EXCL)
- osflags |= O_EXCL;
- if (flags & PR_APPEND)
- osflags |= O_APPEND;
- if (flags & PR_TRUNCATE)
- osflags |= O_TRUNC;
- if (flags & PR_SYNC) {
-/* Ummmm. BeOS doesn't appear to
- support sync in any way shape or
- form. */
- return PR_NOT_IMPLEMENTED_ERROR;
- }
-
- /*
- ** On creations we hold the 'create' lock in order to enforce
- ** the semantics of PR_Rename. (see the latter for more details)
- */
- if (flags & PR_CREATE_FILE)
- {
- osflags |= O_CREAT ;
- if (NULL !=_pr_rename_lock)
- PR_Lock(_pr_rename_lock);
- }
-
- rv = open(name, osflags, mode);
-
- if (rv < 0) {
- err = _MD_ERRNO();
- _PR_MD_MAP_OPEN_ERROR(err);
- }
-
- if ((flags & PR_CREATE_FILE) && (NULL !=_pr_rename_lock))
- PR_Unlock(_pr_rename_lock);
- return rv;
-}
-
-PRInt32
-_MD_close_file (PRInt32 osfd)
-{
-PRInt32 rv, err;
-
- rv = close(osfd);
- if (rv == -1) {
- err = _MD_ERRNO();
- _PR_MD_MAP_CLOSE_ERROR(err);
- }
- return(rv);
-}
-
-PRInt32
-_MD_read (PRFileDesc *fd, void *buf, PRInt32 amount)
-{
- PRInt32 rv, err;
- PRInt32 osfd = fd->secret->md.osfd;
-
- rv = read( osfd, buf, amount );
- if (rv < 0) {
- err = _MD_ERRNO();
- _PR_MD_MAP_READ_ERROR(err);
- }
- return(rv);
-}
-
-PRInt32
-_MD_write (PRFileDesc *fd, const void *buf, PRInt32 amount)
-{
- PRInt32 rv, err;
- PRInt32 osfd = fd->secret->md.osfd;
-
- rv = write( osfd, buf, amount );
-
- if( rv < 0 ) {
-
- err = _MD_ERRNO();
- _PR_MD_MAP_WRITE_ERROR(err);
- }
- return( rv );
-}
-
-#ifndef BONE_VERSION /* Writev moves to bnet.c with BONE */
-PRInt32
-_MD_writev (PRFileDesc *fd, const PRIOVec *iov, PRInt32 iov_size,
- PRIntervalTime timeout)
-{
- return PR_NOT_IMPLEMENTED_ERROR;
-}
-#endif
-
-PRInt32
-_MD_lseek (PRFileDesc *fd, PRInt32 offset, int whence)
-{
-PRInt32 rv, err;
-
- rv = lseek (fd->secret->md.osfd, offset, whence);
- if (rv == -1) {
- err = _MD_ERRNO();
- _PR_MD_MAP_LSEEK_ERROR(err);
- }
- return( rv );
-}
-
-PRInt64
-_MD_lseek64 (PRFileDesc *fd, PRInt64 offset, int whence)
-{
-PRInt32 rv, err;
-
-/* According to the BeOS headers, lseek accepts a
- * variable of type off_t for the offset, and off_t
- * is defined to be a 64-bit value. So no special
- * cracking needs to be done on "offset".
- */
-
- rv = lseek (fd->secret->md.osfd, offset, whence);
- if (rv == -1) {
- err = _MD_ERRNO();
- _PR_MD_MAP_LSEEK_ERROR(err);
- }
- return( rv );
-}
-
-PRInt32
-_MD_fsync (PRFileDesc *fd)
-{
-PRInt32 rv, err;
-
- rv = fsync(fd->secret->md.osfd);
- if (rv == -1) {
- err = _MD_ERRNO();
- _PR_MD_MAP_FSYNC_ERROR(err);
- }
- return(rv);
-}
-
-PRInt32
-_MD_delete (const char *name)
-{
-PRInt32 rv, err;
-
- rv = unlink(name);
- if (rv == -1)
- {
- err = _MD_ERRNO();
- _PR_MD_MAP_UNLINK_ERROR(err);
- }
- return (rv);
-}
-
-PRInt32
-_MD_getfileinfo (const char *fn, PRFileInfo *info)
-{
-struct stat sb;
-PRInt32 rv, err;
-PRInt64 s, s2us;
-
- rv = stat(fn, &sb);
- if (rv < 0) {
- err = _MD_ERRNO();
- _PR_MD_MAP_STAT_ERROR(err);
- } else if (info) {
- if (S_IFREG & sb.st_mode)
- info->type = PR_FILE_FILE;
- else if (S_IFDIR & sb.st_mode)
- info->type = PR_FILE_DIRECTORY;
- else
- info->type = PR_FILE_OTHER;
-
- /* Must truncate file size for the 32 bit
- version */
- info->size = (sb.st_size & 0xffffffff);
- LL_I2L(s, sb.st_mtime);
- LL_I2L(s2us, PR_USEC_PER_SEC);
- LL_MUL(s, s, s2us);
- info->modifyTime = s;
- LL_I2L(s, sb.st_ctime);
- LL_MUL(s, s, s2us);
- info->creationTime = s;
- }
- return rv;
-}
-
-PRInt32
-_MD_getfileinfo64 (const char *fn, PRFileInfo64 *info)
-{
-struct stat sb;
-PRInt32 rv, err;
-PRInt64 s, s2us;
-
- rv = stat(fn, &sb);
- if (rv < 0) {
- err = _MD_ERRNO();
- _PR_MD_MAP_STAT_ERROR(err);
- } else if (info) {
- if (S_IFREG & sb.st_mode)
- info->type = PR_FILE_FILE;
- else if (S_IFDIR & sb.st_mode)
- info->type = PR_FILE_DIRECTORY;
- else
- info->type = PR_FILE_OTHER;
-
- /* For the 64 bit version we can use
- * the native st_size without modification
- */
- info->size = sb.st_size;
- LL_I2L(s, sb.st_mtime);
- LL_I2L(s2us, PR_USEC_PER_SEC);
- LL_MUL(s, s, s2us);
- info->modifyTime = s;
- LL_I2L(s, sb.st_ctime);
- LL_MUL(s, s, s2us);
- info->creationTime = s;
- }
- return rv;
-}
-
-PRInt32
-_MD_getopenfileinfo (const PRFileDesc *fd, PRFileInfo *info)
-{
- struct stat sb;
- PRInt64 s, s2us;
- PRInt32 rv, err;
-
- rv = fstat(fd->secret->md.osfd, &sb);
- if (rv < 0) {
- err = _MD_ERRNO();
- _PR_MD_MAP_FSTAT_ERROR(err);
- } else if (info) {
- if (info) {
- if (S_IFREG & sb.st_mode)
- info->type = PR_FILE_FILE ;
- else if (S_IFDIR & sb.st_mode)
- info->type = PR_FILE_DIRECTORY;
- else
- info->type = PR_FILE_OTHER;
- /* Use lower 32 bits of file size */
- info->size = ( sb.st_size & 0xffffffff);
- LL_I2L(s, sb.st_mtime);
- LL_I2L(s2us, PR_USEC_PER_SEC);
- LL_MUL(s, s, s2us);
- info->modifyTime = s;
- LL_I2L(s, sb.st_ctime);
- LL_MUL(s, s, s2us);
- info->creationTime = s;
- }
- }
- return rv;
-}
-
-PRInt32
-_MD_getopenfileinfo64 (const PRFileDesc *fd, PRFileInfo64 *info)
-{
- struct stat sb;
- PRInt64 s, s2us;
- PRInt32 rv, err;
-
- rv = fstat(fd->secret->md.osfd, &sb);
- if (rv < 0) {
- err = _MD_ERRNO();
- _PR_MD_MAP_FSTAT_ERROR(err);
- } else if (info) {
- if (info) {
- if (S_IFREG & sb.st_mode)
- info->type = PR_FILE_FILE ;
- else if (S_IFDIR & sb.st_mode)
- info->type = PR_FILE_DIRECTORY;
- else
- info->type = PR_FILE_OTHER;
- info->size = sb.st_size;
- LL_I2L(s, sb.st_mtime);
- LL_I2L(s2us, PR_USEC_PER_SEC);
- LL_MUL(s, s, s2us);
- info->modifyTime = s;
- LL_I2L(s, sb.st_ctime);
- LL_MUL(s, s, s2us);
- info->creationTime = s;
- }
- }
- return rv;
-}
-
-PRInt32
-_MD_rename (const char *from, const char *to)
-{
- PRInt32 rv = -1, err;
-
- /*
- ** This is trying to enforce the semantics of WINDOZE' rename
- ** operation. That means one is not allowed to rename over top
- ** of an existing file. Holding a lock across these two function
- ** and the open function is known to be a bad idea, but ....
- */
- if (NULL != _pr_rename_lock)
- PR_Lock(_pr_rename_lock);
- if (0 == access(to, F_OK))
- PR_SetError(PR_FILE_EXISTS_ERROR, 0);
- else
- {
- rv = rename(from, to);
- if (rv < 0) {
- err = _MD_ERRNO();
- _PR_MD_MAP_RENAME_ERROR(err);
- }
- }
- if (NULL != _pr_rename_lock)
- PR_Unlock(_pr_rename_lock);
- return rv;
-}
-
-PRInt32
-_MD_access (const char *name, PRIntn how)
-{
-PRInt32 rv, err;
-int checkFlags;
-struct stat buf;
-
- switch (how) {
- case PR_ACCESS_WRITE_OK:
- checkFlags = S_IWUSR | S_IWGRP | S_IWOTH;
- break;
-
- case PR_ACCESS_READ_OK:
- checkFlags = S_IRUSR | S_IRGRP | S_IROTH;
- break;
-
- case PR_ACCESS_EXISTS:
- /* we don't need to examine st_mode. */
- break;
-
- default:
- PR_SetError(PR_INVALID_ARGUMENT_ERROR, 0);
- return -1;
- }
-
- rv = stat(name, &buf);
- if (rv == 0 && how != PR_ACCESS_EXISTS && (!(buf.st_mode & checkFlags))) {
- PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, 0);
- return -1;
- }
-
- if (rv < 0) {
- err = _MD_ERRNO();
- _PR_MD_MAP_STAT_ERROR(err);
- }
-
- return(rv);
-}
-
-PRInt32
-_MD_stat (const char *name, struct stat *buf)
-{
- return PR_NOT_IMPLEMENTED_ERROR;
-}
-
-PRInt32
-_MD_mkdir (const char *name, PRIntn mode)
-{
- status_t rv;
- int err;
-
- /*
- ** This lock is used to enforce rename semantics as described
- ** in PR_Rename. Look there for more fun details.
- */
- if (NULL !=_pr_rename_lock)
- PR_Lock(_pr_rename_lock);
-
- rv = mkdir(name, mode);
- if (rv < 0) {
- err = _MD_ERRNO();
- _PR_MD_MAP_MKDIR_ERROR(err);
- }
- if (NULL !=_pr_rename_lock)
- PR_Unlock(_pr_rename_lock);
- return rv;
-}
-
-PRInt32
-_MD_rmdir (const char *name)
-{
-int rv, err;
-
- rv = rmdir(name);
- if (rv == -1) {
- err = _MD_ERRNO();
- _PR_MD_MAP_RMDIR_ERROR(err);
- }
- return rv;
-}
-
-PRInt32
-_MD_pr_poll(PRPollDesc *pds, PRIntn npds, PRIntervalTime timeout)
-{
- PRInt32 rv = 0;
- PRThread *me = _PR_MD_CURRENT_THREAD();
- /*
- * This code is almost a duplicate of w32poll.c's _PR_MD_PR_POLL().
- */
- fd_set rd, wt, ex;
- PRFileDesc *bottom;
- PRPollDesc *pd, *epd;
- PRInt32 maxfd = -1, ready, err;
- PRIntervalTime remaining, elapsed, start;
-
- struct timeval tv, *tvp = NULL;
-
- if (_PR_PENDING_INTERRUPT(me))
- {
- me->flags &= ~_PR_INTERRUPT;
- PR_SetError(PR_PENDING_INTERRUPT_ERROR, 0);
- return -1;
- }
-
- if (0 == npds) {
- PR_Sleep(timeout);
- return rv;
- }
-
- FD_ZERO(&rd);
- FD_ZERO(&wt);
- FD_ZERO(&ex);
-
- ready = 0;
- for (pd = pds, epd = pd + npds; pd < epd; pd++)
- {
- PRInt16 in_flags_read = 0, in_flags_write = 0;
- PRInt16 out_flags_read = 0, out_flags_write = 0;
-
- if ((NULL != pd->fd) && (0 != pd->in_flags))
- {
- if (pd->in_flags & PR_POLL_READ)
- {
- in_flags_read = (pd->fd->methods->poll)(pd->fd, pd->in_flags & ~PR_POLL_WRITE, &out_flags_read);
- }
- if (pd->in_flags & PR_POLL_WRITE)
- {
- in_flags_write = (pd->fd->methods->poll)(pd->fd, pd->in_flags & ~PR_POLL_READ, &out_flags_write);
- }
- if ((0 != (in_flags_read & out_flags_read))
- || (0 != (in_flags_write & out_flags_write)))
- {
- /* this one's ready right now */
- if (0 == ready)
- {
- /*
- * We will have to return without calling the
- * system poll/select function. So zero the
- * out_flags fields of all the poll descriptors
- * before this one.
- */
- PRPollDesc *prev;
- for (prev = pds; prev < pd; prev++)
- {
- prev->out_flags = 0;
- }
- }
- ready += 1;
- pd->out_flags = out_flags_read | out_flags_write;
- }
- else
- {
- pd->out_flags = 0; /* pre-condition */
-
- /* make sure this is an NSPR supported stack */
- bottom = PR_GetIdentitiesLayer(pd->fd, PR_NSPR_IO_LAYER);
- PR_ASSERT(NULL != bottom); /* what to do about that? */
- if ((NULL != bottom)
- && (_PR_FILEDESC_OPEN == bottom->secret->state))
- {
- if (0 == ready)
- {
- PRInt32 osfd = bottom->secret->md.osfd;
- if (osfd > maxfd) maxfd = osfd;
- if (in_flags_read & PR_POLL_READ)
- {
- pd->out_flags |= _PR_POLL_READ_SYS_READ;
- FD_SET(osfd, &rd);
- }
- if (in_flags_read & PR_POLL_WRITE)
- {
- pd->out_flags |= _PR_POLL_READ_SYS_WRITE;
- FD_SET(osfd, &wt);
- }
- if (in_flags_write & PR_POLL_READ)
- {
- pd->out_flags |= _PR_POLL_WRITE_SYS_READ;
- FD_SET(osfd, &rd);
- }
- if (in_flags_write & PR_POLL_WRITE)
- {
- pd->out_flags |= _PR_POLL_WRITE_SYS_WRITE;
- FD_SET(osfd, &wt);
- }
- if (pd->in_flags & PR_POLL_EXCEPT) FD_SET(osfd, &ex);
- }
- }
- else
- {
- if (0 == ready)
- {
- PRPollDesc *prev;
- for (prev = pds; prev < pd; prev++)
- {
- prev->out_flags = 0;
- }
- }
- ready += 1; /* this will cause an abrupt return */
- pd->out_flags = PR_POLL_NVAL; /* bogii */
- }
- }
- }
- else
- {
- pd->out_flags = 0;
- }
- }
-
- if (0 != ready) return ready; /* no need to block */
-
- remaining = timeout;
- start = PR_IntervalNow();
-
- retry:
- if (timeout != PR_INTERVAL_NO_TIMEOUT)
- {
- PRInt32 ticksPerSecond = PR_TicksPerSecond();
- tv.tv_sec = remaining / ticksPerSecond;
- tv.tv_usec = PR_IntervalToMicroseconds( remaining % ticksPerSecond );
- tvp = &tv;
- }
-
- ready = _MD_SELECT(maxfd + 1, &rd, &wt, &ex, tvp);
-
- if (ready == -1 && errno == EINTR)
- {
- if (timeout == PR_INTERVAL_NO_TIMEOUT) goto retry;
- else
- {
- elapsed = (PRIntervalTime) (PR_IntervalNow() - start);
- if (elapsed > timeout) ready = 0; /* timed out */
- else
- {
- remaining = timeout - elapsed;
- goto retry;
- }
- }
- }
-
- /*
- ** Now to unravel the select sets back into the client's poll
- ** descriptor list. Is this possibly an area for pissing away
- ** a few cycles or what?
- */
- if (ready > 0)
- {
- ready = 0;
- for (pd = pds, epd = pd + npds; pd < epd; pd++)
- {
- PRInt16 out_flags = 0;
- if ((NULL != pd->fd) && (0 != pd->in_flags))
- {
- PRInt32 osfd;
- bottom = PR_GetIdentitiesLayer(pd->fd, PR_NSPR_IO_LAYER);
- PR_ASSERT(NULL != bottom);
-
- osfd = bottom->secret->md.osfd;
-
- if (FD_ISSET(osfd, &rd))
- {
- if (pd->out_flags & _PR_POLL_READ_SYS_READ)
- out_flags |= PR_POLL_READ;
- if (pd->out_flags & _PR_POLL_WRITE_SYS_READ)
- out_flags |= PR_POLL_WRITE;
- }
- if (FD_ISSET(osfd, &wt))
- {
- if (pd->out_flags & _PR_POLL_READ_SYS_WRITE)
- out_flags |= PR_POLL_READ;
- if (pd->out_flags & _PR_POLL_WRITE_SYS_WRITE)
- out_flags |= PR_POLL_WRITE;
- }
- if (FD_ISSET(osfd, &ex)) out_flags |= PR_POLL_EXCEPT;
-
-/* Workaround for nonblocking connects under net_server */
-#ifndef BONE_VERSION
- if (out_flags)
- {
- /* check if it is a pending connect */
- int i = 0, j = 0;
- PR_Lock( _connectLock );
- for( i = 0; i < connectCount; i++ )
- {
- if(connectList[i].osfd == osfd)
- {
- int connectError;
- int connectResult;
-
- connectResult = connect(connectList[i].osfd,
- &connectList[i].addr,
- connectList[i].addrlen);
- connectError = errno;
-
- if(connectResult < 0 )
- {
- if(connectError == EINTR || connectError == EWOULDBLOCK ||
- connectError == EINPROGRESS || connectError == EALREADY)
- {
- break;
- }
- }
-
- if(i == (connectCount - 1))
- {
- connectList[i].osfd = -1;
- } else {
- for(j = i; j < connectCount; j++ )
- {
- memcpy( &connectList[j], &connectList[j+1],
- sizeof(connectList[j]));
- }
- }
- connectCount--;
-
- bottom->secret->md.connectReturnValue = connectResult;
- bottom->secret->md.connectReturnError = connectError;
- bottom->secret->md.connectValueValid = PR_TRUE;
- break;
- }
- }
- PR_Unlock( _connectLock );
- }
-#endif
- }
- pd->out_flags = out_flags;
- if (out_flags) ready++;
- }
- PR_ASSERT(ready > 0);
- }
- else if (ready < 0)
- {
- err = _MD_ERRNO();
- if (err == EBADF)
- {
- /* Find the bad fds */
- ready = 0;
- for (pd = pds, epd = pd + npds; pd < epd; pd++)
- {
- pd->out_flags = 0;
- if ((NULL != pd->fd) && (0 != pd->in_flags))
- {
- bottom = PR_GetIdentitiesLayer(pd->fd, PR_NSPR_IO_LAYER);
- if (fcntl(bottom->secret->md.osfd, F_GETFL, 0) == -1)
- {
- pd->out_flags = PR_POLL_NVAL;
- ready++;
- }
- }
- }
- PR_ASSERT(ready > 0);
- }
- else _PR_MD_MAP_SELECT_ERROR(err);
- }
-
- return ready;
-} /* _MD_pr_poll */
-
-/*
- * File locking.
- */
-
-PRStatus
-_MD_lockfile (PRInt32 osfd)
-{
- PRInt32 rv;
- struct flock linfo;
-
- linfo.l_type =
- linfo.l_whence = SEEK_SET;
- linfo.l_start = 0;
- linfo.l_len = 0;
-
- rv = fcntl(osfd, F_SETLKW, &linfo);
- if (rv == 0)
- return PR_SUCCESS;
-
- _PR_MD_MAP_FLOCK_ERROR(_MD_ERRNO());
- return PR_FAILURE;
-}
-
-PRStatus
-_MD_tlockfile (PRInt32 osfd)
-{
- PRInt32 rv;
- struct flock linfo;
-
- linfo.l_type =
- linfo.l_whence = SEEK_SET;
- linfo.l_start = 0;
- linfo.l_len = 0;
-
- rv = fcntl(osfd, F_SETLK, &linfo);
- if (rv == 0)
- return PR_SUCCESS;
-
- _PR_MD_MAP_FLOCK_ERROR(_MD_ERRNO());
- return PR_FAILURE;
-}
-
-PRStatus
-_MD_unlockfile (PRInt32 osfd)
-{
- PRInt32 rv;
- struct flock linfo;
-
- linfo.l_type =
- linfo.l_whence = SEEK_SET;
- linfo.l_start = 0;
- linfo.l_len = 0;
-
- rv = fcntl(osfd, F_UNLCK, &linfo);
-
- if (rv == 0)
- return PR_SUCCESS;
-
- _PR_MD_MAP_FLOCK_ERROR(_MD_ERRNO());
- return PR_FAILURE;
-}
-
diff --git a/nsprpub/pr/src/md/beos/bmemory.c b/nsprpub/pr/src/md/beos/bmemory.c
deleted file mode 100644
index fb906f0f9..000000000
--- a/nsprpub/pr/src/md/beos/bmemory.c
+++ /dev/null
@@ -1,10 +0,0 @@
-/* -*- Mode: C++; c-basic-offset: 4 -*- */
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-
-#include "primpl.h"
-
-PR_EXTERN(void) _PR_MD_INIT_SEGS(void);
-PR_EXTERN(PRStatus) _PR_MD_ALLOC_SEGMENT(PRSegment *seg, PRUint32 size, void *vaddr);
-PR_EXTERN(void) _PR_MD_FREE_SEGMENT(PRSegment *seg);
diff --git a/nsprpub/pr/src/md/beos/bmisc.c b/nsprpub/pr/src/md/beos/bmisc.c
deleted file mode 100644
index 4bdad411e..000000000
--- a/nsprpub/pr/src/md/beos/bmisc.c
+++ /dev/null
@@ -1,91 +0,0 @@
-/* -*- Mode: C++; c-basic-offset: 4 -*- */
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-
-#include "primpl.h"
-
-#include <stdlib.h>
-
-PRLock *_connectLock = NULL;
-
-#ifndef BONE_VERSION
-/* Workaround for nonblocking connects under net_server */
-PRUint32 connectCount = 0;
-ConnectListNode connectList[64];
-#endif
-
-void
-_MD_cleanup_before_exit (void)
-{
-}
-
-void
-_MD_exit (PRIntn status)
-{
- exit(status);
-}
-
-void
-_MD_early_init (void)
-{
-}
-
-static PRLock *monitor = NULL;
-
-void
-_MD_final_init (void)
-{
- _connectLock = PR_NewLock();
- PR_ASSERT(NULL != _connectLock);
-#ifndef BONE_VERSION
- /* Workaround for nonblocking connects under net_server */
- connectCount = 0;
-#endif
-}
-
-void
-_MD_AtomicInit (void)
-{
- if (monitor == NULL) {
- monitor = PR_NewLock();
- }
-}
-
-/*
-** This is exceedingly messy. atomic_add returns the last value, NSPR expects the new value.
-** We just add or subtract 1 from the result. The actual memory update is atomic.
-*/
-
-PRInt32
-_MD_AtomicAdd( PRInt32 *ptr, PRInt32 val )
-{
- return( ( atomic_add( (long *)ptr, val ) ) + val );
-}
-
-PRInt32
-_MD_AtomicIncrement( PRInt32 *val )
-{
- return( ( atomic_add( (long *)val, 1 ) ) + 1 );
-}
-
-PRInt32
-_MD_AtomicDecrement( PRInt32 *val )
-{
- return( ( atomic_add( (long *)val, -1 ) ) - 1 );
-}
-
-PRInt32
-_MD_AtomicSet( PRInt32 *val, PRInt32 newval )
-{
- PRInt32 rv;
-
- if (!_pr_initialized) {
- _PR_ImplicitInitialization();
- }
- PR_Lock(monitor);
- rv = *val;
- *val = newval;
- PR_Unlock(monitor);
- return rv;
-}
diff --git a/nsprpub/pr/src/md/beos/bmmap.c b/nsprpub/pr/src/md/beos/bmmap.c
deleted file mode 100644
index a9b3ac589..000000000
--- a/nsprpub/pr/src/md/beos/bmmap.c
+++ /dev/null
@@ -1,41 +0,0 @@
-/* -*- Mode: C++; c-basic-offset: 4 -*- */
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-
-#include "primpl.h"
-
-PR_EXTERN(PRStatus)
-_PR_MD_CREATE_FILE_MAP(PRFileMap *fmap, PRInt64 size)
-{
- PR_SetError( PR_NOT_IMPLEMENTED_ERROR, 0 );
- return PR_FAILURE;
-}
-
-PR_EXTERN(PRInt32)
-_PR_MD_GET_MEM_MAP_ALIGNMENT(void)
-{
- PR_SetError( PR_NOT_IMPLEMENTED_ERROR, 0 );
- return -1;
-}
-
-PR_EXTERN(void *)
-_PR_MD_MEM_MAP(PRFileMap *fmap, PRInt64 offset, PRUint32 len)
-{
- PR_SetError( PR_NOT_IMPLEMENTED_ERROR, 0 );
- return 0;
-}
-
-PR_EXTERN(PRStatus)
-_PR_MD_MEM_UNMAP(void *addr, PRUint32 size)
-{
- PR_SetError( PR_NOT_IMPLEMENTED_ERROR, 0 );
- return PR_FAILURE;
-}
-
-PR_EXTERN(PRStatus)
-_PR_MD_CLOSE_FILE_MAP(PRFileMap *fmap)
-{
- PR_SetError( PR_NOT_IMPLEMENTED_ERROR, 0 );
- return PR_FAILURE;
-}
diff --git a/nsprpub/pr/src/md/beos/bnet.c b/nsprpub/pr/src/md/beos/bnet.c
deleted file mode 100644
index 8bfd4aead..000000000
--- a/nsprpub/pr/src/md/beos/bnet.c
+++ /dev/null
@@ -1,911 +0,0 @@
-/* -*- Mode: C++; c-basic-offset: 4 -*- */
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-
-#include "primpl.h"
-
-#include <signal.h>
-#include <unistd.h>
-#include <memory.h>
-#include <fcntl.h>
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <sys/time.h>
-#include <sys/ioctl.h>
-
-/*
- * Make sure _PRSockLen_t is 32-bit, because we will cast a PRUint32* or
- * PRInt32* pointer to a _PRSockLen_t* pointer.
- */
-#define _PRSockLen_t int
-
-
-/*
-** Global lock variable used to bracket calls into rusty libraries that
-** aren't thread safe (like libc, libX, etc).
-*/
-static PRLock *_pr_rename_lock = NULL;
-static PRMonitor *_pr_Xfe_mon = NULL;
-
-#define READ_FD 1
-#define WRITE_FD 2
-
-/*
-** This is a support routine to handle "deferred" i/o on sockets.
-** It uses "select", so it is subject to all of the BeOS limitations
-** (only READ notification, only sockets)
-*/
-
-/*
- * socket_io_wait --
- *
- * wait for socket i/o, periodically checking for interrupt
- *
- */
-
-static PRInt32 socket_io_wait(PRInt32 osfd, PRInt32 fd_type,
- PRIntervalTime timeout)
-{
- PRInt32 rv = -1;
- struct timeval tv;
- PRThread *me = _PR_MD_CURRENT_THREAD();
- PRIntervalTime epoch, now, elapsed, remaining;
- PRBool wait_for_remaining;
- PRInt32 syserror;
- fd_set rd_wr;
-
- switch (timeout) {
- case PR_INTERVAL_NO_WAIT:
- PR_SetError(PR_IO_TIMEOUT_ERROR, 0);
- break;
- case PR_INTERVAL_NO_TIMEOUT:
- /*
- * This is a special case of the 'default' case below.
- * Please see the comments there.
- */
- tv.tv_sec = _PR_INTERRUPT_CHECK_INTERVAL_SECS;
- tv.tv_usec = 0;
- FD_ZERO(&rd_wr);
- do {
- FD_SET(osfd, &rd_wr);
- if (fd_type == READ_FD)
- rv = _MD_SELECT(osfd + 1, &rd_wr, NULL, NULL, &tv);
- else
- rv = _MD_SELECT(osfd + 1, NULL, &rd_wr, NULL, &tv);
- if (rv == -1 && (syserror = _MD_ERRNO()) != EINTR) {
-#ifdef BONE_VERSION
- _PR_MD_MAP_SELECT_ERROR(syserror);
-#else
- if (syserror == EBADF) {
- PR_SetError(PR_BAD_DESCRIPTOR_ERROR, EBADF);
- } else {
- PR_SetError(PR_UNKNOWN_ERROR, syserror);
- }
-#endif
- break;
- }
- if (_PR_PENDING_INTERRUPT(me)) {
- me->flags &= ~_PR_INTERRUPT;
- PR_SetError(PR_PENDING_INTERRUPT_ERROR, 0);
- rv = -1;
- break;
- }
- } while (rv == 0 || (rv == -1 && syserror == EINTR));
- break;
- default:
- now = epoch = PR_IntervalNow();
- remaining = timeout;
- FD_ZERO(&rd_wr);
- do {
- /*
- * We block in _MD_SELECT for at most
- * _PR_INTERRUPT_CHECK_INTERVAL_SECS seconds,
- * so that there is an upper limit on the delay
- * before the interrupt bit is checked.
- */
- wait_for_remaining = PR_TRUE;
- tv.tv_sec = PR_IntervalToSeconds(remaining);
- if (tv.tv_sec > _PR_INTERRUPT_CHECK_INTERVAL_SECS) {
- wait_for_remaining = PR_FALSE;
- tv.tv_sec = _PR_INTERRUPT_CHECK_INTERVAL_SECS;
- tv.tv_usec = 0;
- } else {
- tv.tv_usec = PR_IntervalToMicroseconds(
- remaining -
- PR_SecondsToInterval(tv.tv_sec));
- }
- FD_SET(osfd, &rd_wr);
- if (fd_type == READ_FD)
- rv = _MD_SELECT(osfd + 1, &rd_wr, NULL, NULL, &tv);
- else
- rv = _MD_SELECT(osfd + 1, NULL, &rd_wr, NULL, &tv);
- /*
- * we don't consider EINTR a real error
- */
- if (rv == -1 && (syserror = _MD_ERRNO()) != EINTR) {
-#ifdef BONE_VERSION
- _PR_MD_MAP_SELECT_ERROR(syserror);
-#else
- if (syserror == EBADF) {
- PR_SetError(PR_BAD_DESCRIPTOR_ERROR, EBADF);
- } else {
- PR_SetError(PR_UNKNOWN_ERROR, syserror);
- }
-#endif
- break;
- }
- if (_PR_PENDING_INTERRUPT(me)) {
- me->flags &= ~_PR_INTERRUPT;
- PR_SetError(PR_PENDING_INTERRUPT_ERROR, 0);
- rv = -1;
- break;
- }
- /*
- * We loop again if _MD_SELECT timed out or got interrupted
- * by a signal, and the timeout deadline has not passed yet.
- */
- if (rv == 0 || (rv == -1 && syserror == EINTR)) {
- /*
- * If _MD_SELECT timed out, we know how much time
- * we spent in blocking, so we can avoid a
- * PR_IntervalNow() call.
- */
- if (rv == 0) {
- if (wait_for_remaining) {
- now += remaining;
- } else {
- now += PR_SecondsToInterval(tv.tv_sec)
- + PR_MicrosecondsToInterval(tv.tv_usec);
- }
- } else {
- now = PR_IntervalNow();
- }
- elapsed = (PRIntervalTime) (now - epoch);
- if (elapsed >= timeout) {
- PR_SetError(PR_IO_TIMEOUT_ERROR, 0);
- rv = -1;
- break;
- } else {
- remaining = timeout - elapsed;
- }
- }
- } while (rv == 0 || (rv == -1 && syserror == EINTR));
- break;
- }
- return(rv);
-}
-
-PRInt32
-_MD_recv (PRFileDesc *fd, void *buf, PRInt32 amount, PRInt32 flags,
- PRIntervalTime timeout)
-{
- PRInt32 osfd = fd->secret->md.osfd;
- PRInt32 rv, err;
- PRThread *me = _PR_MD_CURRENT_THREAD();
-
-#ifndef BONE_VERSION
- if (fd->secret->md.sock_state & BE_SOCK_SHUTDOWN_READ) {
- _PR_MD_MAP_RECV_ERROR(EPIPE);
- return -1;
- }
-#endif
-
-#ifdef BONE_VERSION
- /*
- ** Gah, stupid hack. If reading a zero amount, instantly return success.
- ** BONE beta 6 returns EINVAL for reads of zero bytes, which parts of
- ** mozilla use to check for socket availability.
- */
-
- if( 0 == amount ) return(0);
-#endif
-
- while ((rv = recv(osfd, buf, amount, flags)) == -1) {
- err = _MD_ERRNO();
-
- if ((err == EAGAIN) || (err == EWOULDBLOCK)) {
- if (fd->secret->nonblocking) {
- break;
- }
- /* If socket was supposed to be blocking,
- wait a while for the condition to be
- satisfied. */
- if ((rv = socket_io_wait(osfd, READ_FD, timeout)) < 0)
- goto done;
- } else if ((err == EINTR) && (!_PR_PENDING_INTERRUPT(me))){
- continue;
-
- } else
- break;
- }
-
- if (rv < 0) {
- _PR_MD_MAP_RECV_ERROR(err);
- }
-
-done:
- return(rv);
-}
-
-PRInt32
-_MD_recvfrom (PRFileDesc *fd, void *buf, PRInt32 amount, PRIntn flags,
- PRNetAddr *addr, PRUint32 *addrlen, PRIntervalTime timeout)
-{
- PRInt32 osfd = fd->secret->md.osfd;
- PRInt32 rv, err;
- PRThread *me = _PR_MD_CURRENT_THREAD();
-
- while ((*addrlen = PR_NETADDR_SIZE(addr)),
- ((rv = recvfrom(osfd, buf, amount, flags,
- (struct sockaddr *) addr,
- (_PRSockLen_t *)addrlen)) == -1)) {
- err = _MD_ERRNO();
-
- if ((err == EAGAIN) || (err == EWOULDBLOCK)) {
- if (fd->secret->nonblocking) {
- break;
- }
- if ((rv = socket_io_wait(osfd, READ_FD, timeout)) < 0)
- goto done;
-
- } else if ((err == EINTR) && (!_PR_PENDING_INTERRUPT(me))) {
- continue;
- } else {
- break;
- }
- }
-
- if (rv < 0) {
- _PR_MD_MAP_RECVFROM_ERROR(err);
- }
-
-done:
-#ifdef _PR_HAVE_SOCKADDR_LEN
- if (rv != -1) {
- /* ignore the sa_len field of struct sockaddr */
- if (addr) {
- addr->raw.family = ((struct sockaddr *) addr)->sa_family;
- }
- }
-#endif /* _PR_HAVE_SOCKADDR_LEN */
- return(rv);
-}
-
-PRInt32
-_MD_send (PRFileDesc *fd, const void *buf, PRInt32 amount, PRInt32 flags,
- PRIntervalTime timeout)
-{
- PRInt32 osfd = fd->secret->md.osfd;
- PRInt32 rv, err;
- PRThread *me = _PR_MD_CURRENT_THREAD();
-
-#ifndef BONE_VERSION
- if (fd->secret->md.sock_state & BE_SOCK_SHUTDOWN_WRITE)
- {
- _PR_MD_MAP_SEND_ERROR(EPIPE);
- return -1;
- }
-#endif
-
- while ((rv = send(osfd, buf, amount, flags)) == -1) {
- err = _MD_ERRNO();
-
- if ((err == EAGAIN) || (err == EWOULDBLOCK)) {
- if (fd->secret->nonblocking) {
- break;
- }
-
-#ifndef BONE_VERSION
- if( _PR_PENDING_INTERRUPT(me)) {
-
- me->flags &= ~_PR_INTERRUPT;
- PR_SetError( PR_PENDING_INTERRUPT_ERROR, 0);
- return -1;
- }
-
- /* in UNIX implementations, you could do a socket_io_wait here.
- * but since BeOS doesn't yet support WRITE notification in select,
- * you're spanked.
- */
- snooze( 10000L );
- continue;
-#else /* BONE_VERSION */
- if ((rv = socket_io_wait(osfd, WRITE_FD, timeout))< 0)
- goto done;
-#endif
-
- } else if ((err == EINTR) && (!_PR_PENDING_INTERRUPT(me))) {
- continue;
-
- } else {
- break;
- }
- }
-
-#ifdef BONE_VERSION
- /*
- * optimization; if bytes sent is less than "amount" call
- * select before returning. This is because it is likely that
- * the next writev() call will return EWOULDBLOCK.
- */
- if ((!fd->secret->nonblocking) && (rv > 0) && (rv < amount)
- && (timeout != PR_INTERVAL_NO_WAIT)) {
- if (socket_io_wait(osfd, WRITE_FD, timeout) < 0) {
- rv = -1;
- goto done;
- }
- }
-#endif /* BONE_VERSION */
-
- if (rv < 0) {
- _PR_MD_MAP_SEND_ERROR(err);
- }
-
-#ifdef BONE_VERSION
-done:
-#endif
- return(rv);
-}
-
-PRInt32
-_MD_sendto (PRFileDesc *fd, const void *buf, PRInt32 amount, PRIntn flags,
- const PRNetAddr *addr, PRUint32 addrlen, PRIntervalTime timeout)
-{
- PRInt32 osfd = fd->secret->md.osfd;
- PRInt32 rv, err;
- PRThread *me = _PR_MD_CURRENT_THREAD();
-#ifdef _PR_HAVE_SOCKADDR_LEN
- PRNetAddr addrCopy;
-
- addrCopy = *addr;
- ((struct sockaddr *) &addrCopy)->sa_len = addrlen;
- ((struct sockaddr *) &addrCopy)->sa_family = addr->raw.family;
-
- while ((rv = sendto(osfd, buf, amount, flags,
- (struct sockaddr *) &addrCopy, addrlen)) == -1) {
-#else
- while ((rv = sendto(osfd, buf, amount, flags,
- (struct sockaddr *) addr, addrlen)) == -1) {
-#endif
- err = _MD_ERRNO();
-
- if ((err == EAGAIN) || (err == EWOULDBLOCK)) {
- if (fd->secret->nonblocking) {
- break;
- }
-
-#ifdef BONE_VERSION
- if ((rv = socket_io_wait(osfd, WRITE_FD, timeout))< 0)
- goto done;
-#endif
- } else if ((err == EINTR) && (!_PR_PENDING_INTERRUPT(me))) {
- continue;
-
- } else {
- break;
- }
- }
-
- if (rv < 0) {
- _PR_MD_MAP_SENDTO_ERROR(err);
- }
-
-#ifdef BONE_VERSION
-done:
-#endif
- return(rv);
-}
-
-#ifdef BONE_VERSION
-
-PRInt32 _MD_writev(
- PRFileDesc *fd, const PRIOVec *iov,
- PRInt32 iov_size, PRIntervalTime timeout)
-{
- PRInt32 rv, err;
- PRThread *me = _PR_MD_CURRENT_THREAD();
- PRInt32 index, amount = 0;
- PRInt32 osfd = fd->secret->md.osfd;
- struct iovec osiov[PR_MAX_IOVECTOR_SIZE];
-
- /* Ensured by PR_Writev */
- PR_ASSERT(iov_size <= PR_MAX_IOVECTOR_SIZE);
-
- /*
- * We can't pass iov to writev because PRIOVec and struct iovec
- * may not be binary compatible. Make osiov a copy of iov and
- * pass osiov to writev.
- */
- for (index = 0; index < iov_size; index++) {
- osiov[index].iov_base = iov[index].iov_base;
- osiov[index].iov_len = iov[index].iov_len;
- }
-
- /*
- * Calculate the total number of bytes to be sent; needed for
- * optimization later.
- * We could avoid this if this number was passed in; but it is
- * probably not a big deal because iov_size is usually small (less than
- * 3)
- */
- if (!fd->secret->nonblocking) {
- for (index=0; index<iov_size; index++) {
- amount += iov[index].iov_len;
- }
- }
-
- while ((rv = writev(osfd, osiov, iov_size)) == -1) {
- err = _MD_ERRNO();
- if ((err == EAGAIN) || (err == EWOULDBLOCK)) {
- if (fd->secret->nonblocking) {
- break;
- }
- if ((rv = socket_io_wait(osfd, WRITE_FD, timeout))<0)
- goto done;
-
- } else if ((err == EINTR) && (!_PR_PENDING_INTERRUPT(me))){
- continue;
- } else {
- break;
- }
- }
-
- /*
- * optimization; if bytes sent is less than "amount" call
- * select before returning. This is because it is likely that
- * the next writev() call will return EWOULDBLOCK.
- */
- if ((!fd->secret->nonblocking) && (rv > 0) && (rv < amount)
- && (timeout != PR_INTERVAL_NO_WAIT)) {
- if (socket_io_wait(osfd, WRITE_FD, timeout) < 0) {
- rv = -1;
- goto done;
- }
- }
-
-
- if (rv < 0) {
- _PR_MD_MAP_WRITEV_ERROR(err);
- }
-done:
- return(rv);
-}
-
-#endif /* BONE_VERSION */
-
-PRInt32
-_MD_accept (PRFileDesc *fd, PRNetAddr *addr, PRUint32 *addrlen,
- PRIntervalTime timeout)
-{
- PRInt32 osfd = fd->secret->md.osfd;
- PRInt32 rv, err;
- PRThread *me = _PR_MD_CURRENT_THREAD();
-
- while ((rv = accept(osfd, (struct sockaddr *) addr,
- (_PRSockLen_t *)addrlen)) == -1) {
- err = _MD_ERRNO();
-
- if ((err == EAGAIN) || (err == EWOULDBLOCK)) {
- if (fd->secret->nonblocking) {
- break;
- }
- /* If it's SUPPOSED to be a blocking thread, wait
- * a while to see if the triggering condition gets
- * satisfied.
- */
- /* Assume that we're always using a native thread */
- if ((rv = socket_io_wait(osfd, READ_FD, timeout)) < 0)
- goto done;
- } else if ((err == EINTR) && (!_PR_PENDING_INTERRUPT(me))) {
- continue;
- } else {
- break;
- }
- }
- if (rv < 0) {
- _PR_MD_MAP_ACCEPT_ERROR(err);
- } else if (addr != NULL) {
- /* bug 134099 */
- err = getpeername(rv, (struct sockaddr *) addr, (_PRSockLen_t *)addrlen);
- }
-done:
-#ifdef _PR_HAVE_SOCKADDR_LEN
- if (rv != -1) {
- /* Mask off the first byte of struct sockaddr (the length field) */
- if (addr) {
- addr->raw.family = ((struct sockaddr *) addr)->sa_family;
- }
- }
-#endif /* _PR_HAVE_SOCKADDR_LEN */
- return(rv);
-}
-
-PRInt32
-_MD_connect (PRFileDesc *fd, const PRNetAddr *addr, PRUint32 addrlen,
- PRIntervalTime timeout)
-{
- PRInt32 rv, err;
- PRThread *me = _PR_MD_CURRENT_THREAD();
- PRInt32 osfd = fd->secret->md.osfd;
-
-#ifndef BONE_VERSION
- fd->secret->md.connectValueValid = PR_FALSE;
-#endif
-#ifdef _PR_HAVE_SOCKADDR_LEN
- PRNetAddr addrCopy;
-
- addrCopy = *addr;
- ((struct sockaddr *) &addrCopy)->sa_len = addrlen;
- ((struct sockaddr *) &addrCopy)->sa_family = addr->raw.family;
-#endif
-
- /* (Copied from unix.c)
- * We initiate the connection setup by making a nonblocking connect()
- * call. If the connect() call fails, there are two cases we handle
- * specially:
- * 1. The connect() call was interrupted by a signal. In this case
- * we simply retry connect().
- * 2. The NSPR socket is nonblocking and connect() fails with
- * EINPROGRESS. We first wait until the socket becomes writable.
- * Then we try to find out whether the connection setup succeeded
- * or failed.
- */
-
-retry:
-#ifdef _PR_HAVE_SOCKADDR_LEN
- if ((rv = connect(osfd, (struct sockaddr *)&addrCopy, addrlen)) == -1) {
-#else
- if ((rv = connect(osfd, (struct sockaddr *)addr, addrlen)) == -1) {
-#endif
- err = _MD_ERRNO();
-#ifndef BONE_VERSION
- fd->secret->md.connectReturnValue = rv;
- fd->secret->md.connectReturnError = err;
- fd->secret->md.connectValueValid = PR_TRUE;
-#endif
- if( err == EINTR ) {
-
- if( _PR_PENDING_INTERRUPT(me)) {
-
- me->flags &= ~_PR_INTERRUPT;
- PR_SetError( PR_PENDING_INTERRUPT_ERROR, 0);
- return -1;
- }
-#ifndef BONE_VERSION
- snooze( 100000L );
-#endif
- goto retry;
- }
-
-#ifndef BONE_VERSION
- if(!fd->secret->nonblocking && ((err == EINPROGRESS) || (err==EAGAIN) || (err==EALREADY))) {
-
- /*
- ** There's no timeout on this connect, but that's not
- ** a big deal, since the connect times out anyways
- ** after 30 seconds. Just sleep for 1/10th of a second
- ** and retry until we go through or die.
- */
-
- if( _PR_PENDING_INTERRUPT(me)) {
- me->flags &= ~_PR_INTERRUPT;
- PR_SetError( PR_PENDING_INTERRUPT_ERROR, 0);
- return -1;
- }
-
- goto retry;
- }
-
- if( fd->secret->nonblocking && ((err == EAGAIN) || (err == EINPROGRESS))) {
- PR_Lock(_connectLock);
- if (connectCount < sizeof(connectList)/sizeof(connectList[0])) {
- connectList[connectCount].osfd = osfd;
- memcpy(&connectList[connectCount].addr, addr, addrlen);
- connectList[connectCount].addrlen = addrlen;
- connectList[connectCount].timeout = timeout;
- connectCount++;
- PR_Unlock(_connectLock);
- _PR_MD_MAP_CONNECT_ERROR(err);
- } else {
- PR_Unlock(_connectLock);
- PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, 0);
- }
- return rv;
- }
-#else /* BONE_VERSION */
- if(!fd->secret->nonblocking && (err == EINTR)) {
-
- rv = socket_io_wait(osfd, WRITE_FD, timeout);
- if (rv == -1) {
- return -1;
- }
-
- PR_ASSERT(rv == 1);
- if (_PR_PENDING_INTERRUPT(me)) {
- me->flags &= ~_PR_INTERRUPT;
- PR_SetError( PR_PENDING_INTERRUPT_ERROR, 0);
- return -1;
- }
- err = _MD_beos_get_nonblocking_connect_error(osfd);
- if (err != 0) {
- _PR_MD_MAP_CONNECT_ERROR(err);
- return -1;
- }
- return 0;
- }
-#endif
-
- _PR_MD_MAP_CONNECT_ERROR(err);
- }
-
- return rv;
-}
-
-PRInt32
-_MD_bind (PRFileDesc *fd, const PRNetAddr *addr, PRUint32 addrlen)
-{
- PRInt32 rv, err;
-#ifdef _PR_HAVE_SOCKADDR_LEN
- PRNetAddr addrCopy;
-
- addrCopy = *addr;
- ((struct sockaddr *) &addrCopy)->sa_len = addrlen;
- ((struct sockaddr *) &addrCopy)->sa_family = addr->raw.family;
- rv = bind(fd->secret->md.osfd, (struct sockaddr *) &addrCopy, (int )addrlen);
-#else
- rv = bind(fd->secret->md.osfd, (struct sockaddr *) addr, (int )addrlen);
-#endif
- if (rv < 0) {
- err = _MD_ERRNO();
- _PR_MD_MAP_BIND_ERROR(err);
- }
-
- return(rv);
-}
-
-PRInt32
-_MD_listen (PRFileDesc *fd, PRIntn backlog)
-{
- PRInt32 rv, err;
-
-#ifndef BONE_VERSION
- /* Bug workaround! Setting listen to 0 on Be accepts no connections.
- ** On most UN*Xes this sets the default.
- */
-
- if( backlog == 0 ) backlog = 5;
-#endif
-
- rv = listen(fd->secret->md.osfd, backlog);
- if (rv < 0) {
- err = _MD_ERRNO();
- _PR_MD_MAP_LISTEN_ERROR(err);
- }
-
- return(rv);
-}
-
-PRInt32
-_MD_shutdown (PRFileDesc *fd, PRIntn how)
-{
- PRInt32 rv, err;
-
-#ifndef BONE_VERSION
- if (how == PR_SHUTDOWN_SEND)
- fd->secret->md.sock_state = BE_SOCK_SHUTDOWN_WRITE;
- else if (how == PR_SHUTDOWN_RCV)
- fd->secret->md.sock_state = BE_SOCK_SHUTDOWN_READ;
- else if (how == PR_SHUTDOWN_BOTH) {
- fd->secret->md.sock_state = (BE_SOCK_SHUTDOWN_WRITE | BE_SOCK_SHUTDOWN_READ);
- }
-
- return 0;
-#else /* BONE_VERSION */
- rv = shutdown(fd->secret->md.osfd, how);
- if (rv < 0) {
- err = _MD_ERRNO();
- _PR_MD_MAP_SHUTDOWN_ERROR(err);
- }
- return(rv);
-#endif
-}
-
-PRInt32
-_MD_socketpair (int af, int type, int flags, PRInt32 *osfd)
-{
- return PR_NOT_IMPLEMENTED_ERROR;
-}
-
-PRInt32
-_MD_close_socket (PRInt32 osfd)
-{
-#ifdef BONE_VERSION
- close( osfd );
-#else
- closesocket( osfd );
-#endif
-}
-
-PRStatus
-_MD_getsockname (PRFileDesc *fd, PRNetAddr *addr, PRUint32 *addrlen)
-{
- PRInt32 rv, err;
-
- rv = getsockname(fd->secret->md.osfd,
- (struct sockaddr *) addr, (_PRSockLen_t *)addrlen);
-#ifdef _PR_HAVE_SOCKADDR_LEN
- if (rv == 0) {
- /* ignore the sa_len field of struct sockaddr */
- if (addr) {
- addr->raw.family = ((struct sockaddr *) addr)->sa_family;
- }
- }
-#endif /* _PR_HAVE_SOCKADDR_LEN */
- if (rv < 0) {
- err = _MD_ERRNO();
- _PR_MD_MAP_GETSOCKNAME_ERROR(err);
- }
-
- return rv==0?PR_SUCCESS:PR_FAILURE;
-}
-
-PRStatus
-_MD_getpeername (PRFileDesc *fd, PRNetAddr *addr, PRUint32 *addrlen)
-{
- PRInt32 rv, err;
-
- rv = getpeername(fd->secret->md.osfd,
- (struct sockaddr *) addr, (_PRSockLen_t *)addrlen);
-
-#ifdef _PR_HAVE_SOCKADDR_LEN
- if (rv == 0) {
- /* ignore the sa_len field of struct sockaddr */
- if (addr) {
- addr->raw.family = ((struct sockaddr *) addr)->sa_family;
- }
- }
-#endif /* _PR_HAVE_SOCKADDR_LEN */
-
- if (rv < 0) {
- err = _MD_ERRNO();
- _PR_MD_MAP_GETPEERNAME_ERROR(err);
- }
- return rv==0?PR_SUCCESS:PR_FAILURE;
-}
-
-PRStatus
-_MD_getsockopt (PRFileDesc *fd, PRInt32 level,
- PRInt32 optname, char* optval, PRInt32* optlen)
-{
- PRInt32 rv, err;
-
- rv = getsockopt(fd->secret->md.osfd, level, optname,
- optval, (_PRSockLen_t *)optlen);
- if (rv < 0) {
- err = _MD_ERRNO();
- _PR_MD_MAP_GETSOCKOPT_ERROR(err);
- }
-
- return rv==0?PR_SUCCESS:PR_FAILURE;
-}
-
-PRStatus
-_MD_setsockopt (PRFileDesc *fd, PRInt32 level,
- PRInt32 optname, const char* optval, PRInt32 optlen)
-{
- PRInt32 rv, err;
-
- rv = setsockopt(fd->secret->md.osfd, level, optname, optval, optlen);
- if (rv < 0) {
- err = _MD_ERRNO();
- _PR_MD_MAP_SETSOCKOPT_ERROR(err);
- }
- return rv==0?PR_SUCCESS:PR_FAILURE;
-}
-
-PRInt32
-_MD_accept_read (PRFileDesc *sd, PRInt32 *newSock, PRNetAddr **raddr,
- void *buf, PRInt32 amount, PRIntervalTime timeout)
-{
- return PR_NOT_IMPLEMENTED_ERROR;
-}
-
-#ifndef BONE_VERSION
-PRInt32
-_MD_socket (int af, int type, int flags)
-{
- PRInt32 osfd, err;
-
- osfd = socket( af, type, 0 );
-
- if( -1 == osfd ) {
-
- err = _MD_ERRNO();
- _PR_MD_MAP_SOCKET_ERROR( err );
- }
-
- return( osfd );
-}
-#else
-PRInt32
-_MD_socket(PRInt32 domain, PRInt32 type, PRInt32 proto)
-{
- PRInt32 osfd, err;
-
- osfd = socket(domain, type, proto);
-
- if (osfd == -1) {
- err = _MD_ERRNO();
- _PR_MD_MAP_SOCKET_ERROR(err);
- }
-
- return(osfd);
-}
-#endif
-
-PRInt32
-_MD_socketavailable (PRFileDesc *fd)
-{
-#ifdef BONE_VERSION
- PRInt32 result;
-
- if (ioctl(fd->secret->md.osfd, FIONREAD, &result) < 0) {
- _PR_MD_MAP_SOCKETAVAILABLE_ERROR(_MD_ERRNO());
- return -1;
- }
- return result;
-#else
- return PR_NOT_IMPLEMENTED_ERROR;
-#endif
-}
-
-PRInt32
-_MD_get_socket_error (void)
-{
- return PR_NOT_IMPLEMENTED_ERROR;
-}
-
-PRStatus
-_MD_gethostname (char *name, PRUint32 namelen)
-{
- PRInt32 rv, err;
-
- rv = gethostname(name, namelen);
- if (rv == 0)
- {
- err = _MD_ERRNO();
- _PR_MD_MAP_GETHOSTNAME_ERROR(err);
- return PR_FAILURE;
- }
- return PR_SUCCESS;
-}
-
-#ifndef BONE_VERSION
-PRInt32
-_MD_beos_get_nonblocking_connect_error(PRFileDesc *fd)
-{
- int rv;
- int flags = 0;
-
- rv = recv(fd->secret->md.osfd, NULL, 0, flags);
- PR_ASSERT(-1 == rv || 0 == rv);
- if (-1 == rv && errno != EAGAIN && errno != EWOULDBLOCK) {
- return errno;
- }
- return 0; /* no error */
-}
-#else
-PRInt32
-_MD_beos_get_nonblocking_connect_error(int osfd)
-{
- return PR_NOT_IMPLEMENTED_ERROR;
- // int err;
- // _PRSockLen_t optlen = sizeof(err);
- // if (getsockopt(osfd, SOL_SOCKET, SO_ERROR, (char *) &err, &optlen) == -1) {
- // return errno;
- // } else {
- // return err;
- // }
-}
-#endif /* BONE_VERSION */
diff --git a/nsprpub/pr/src/md/beos/bproc.c b/nsprpub/pr/src/md/beos/bproc.c
deleted file mode 100644
index 30ac56990..000000000
--- a/nsprpub/pr/src/md/beos/bproc.c
+++ /dev/null
@@ -1,212 +0,0 @@
-/* -*- Mode: C++; tab-width: 8; c-basic-offset: 8 -*- */
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-
-#include "primpl.h"
-#include <stdio.h>
-#include <signal.h>
-
-#define _PR_SIGNALED_EXITSTATUS 256
-
-PRProcess*
-_MD_create_process (const char *path, char *const *argv,
- char *const *envp, const PRProcessAttr *attr)
-{
- PRProcess *process;
- int nEnv, idx;
- char *const *childEnvp;
- char **newEnvp = NULL;
- int flags;
- PRBool found = PR_FALSE;
-
- process = PR_NEW(PRProcess);
- if (!process) {
- PR_SetError(PR_OUT_OF_MEMORY_ERROR, 0);
- return NULL;
- }
-
- childEnvp = envp;
- if (attr && attr->fdInheritBuffer) {
- if (NULL == childEnvp) {
- childEnvp = environ;
- }
- for (nEnv = 0; childEnvp[nEnv]; nEnv++) {
- }
- newEnvp = (char **) PR_MALLOC((nEnv + 2) * sizeof(char *));
- if (NULL == newEnvp) {
- PR_DELETE(process);
- PR_SetError(PR_OUT_OF_MEMORY_ERROR, 0);
- return NULL;
- }
- for (idx = 0; idx < nEnv; idx++) {
- newEnvp[idx] = childEnvp[idx];
- if (!found && !strncmp(newEnvp[idx], "NSPR_INHERIT_FDS=", 17)) {
- newEnvp[idx] = attr->fdInheritBuffer;
- found = PR_TRUE;
- }
- }
- if (!found) {
- newEnvp[idx++] = attr->fdInheritBuffer;
- }
- newEnvp[idx] = NULL;
- childEnvp = newEnvp;
- }
-
- process->md.pid = fork();
-
- if ((pid_t) -1 == process->md.pid) {
- PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, errno);
- PR_DELETE(process);
- if (newEnvp) {
- PR_DELETE(newEnvp);
- }
- return NULL;
- } else if (0 == process->md.pid) { /* the child process */
- /*
- * If the child process needs to exit, it must call _exit().
- * Do not call exit(), because exit() will flush and close
- * the standard I/O file descriptors, and hence corrupt
- * the parent process's standard I/O data structures.
- */
-
- if (attr) {
- /* the osfd's to redirect stdin, stdout, and stderr to */
- int in_osfd = -1, out_osfd = -1, err_osfd = -1;
-
- if (attr->stdinFd
- && attr->stdinFd->secret->md.osfd != 0) {
- in_osfd = attr->stdinFd->secret->md.osfd;
- if (dup2(in_osfd, 0) != 0) {
- _exit(1); /* failed */
- }
- flags = fcntl(0, F_GETFL, 0);
- if (flags & O_NONBLOCK) {
- fcntl(0, F_SETFL, flags & ~O_NONBLOCK);
- }
- }
- if (attr->stdoutFd
- && attr->stdoutFd->secret->md.osfd != 1) {
- out_osfd = attr->stdoutFd->secret->md.osfd;
- if (dup2(out_osfd, 1) != 1) {
- _exit(1); /* failed */
- }
- flags = fcntl(1, F_GETFL, 0);
- if (flags & O_NONBLOCK) {
- fcntl(1, F_SETFL, flags & ~O_NONBLOCK);
- }
- }
- if (attr->stderrFd
- && attr->stderrFd->secret->md.osfd != 2) {
- err_osfd = attr->stderrFd->secret->md.osfd;
- if (dup2(err_osfd, 2) != 2) {
- _exit(1); /* failed */
- }
- flags = fcntl(2, F_GETFL, 0);
- if (flags & O_NONBLOCK) {
- fcntl(2, F_SETFL, flags & ~O_NONBLOCK);
- }
- }
- if (in_osfd != -1) {
- close(in_osfd);
- }
- if (out_osfd != -1 && out_osfd != in_osfd) {
- close(out_osfd);
- }
- if (err_osfd != -1 && err_osfd != in_osfd
- && err_osfd != out_osfd) {
- close(err_osfd);
- }
- if (attr->currentDirectory) {
- if (chdir(attr->currentDirectory) < 0) {
- _exit(1); /* failed */
- }
- }
- }
-
- if (childEnvp) {
- (void)execve(path, argv, childEnvp);
- } else {
- /* Inherit the environment of the parent. */
- (void)execv(path, argv);
- }
- /* Whoops! It returned. That's a bad sign. */
- _exit(1);
- }
-
- if (newEnvp) {
- PR_DELETE(newEnvp);
- }
-
- return process;
-}
-
-PRStatus
-_MD_detach_process (PRProcess *process)
-{
- /* If we kept a process table like unix does,
- * we'd remove the entry here.
- * Since we dont', just delete the process variable
- */
- PR_DELETE(process);
- return PR_SUCCESS;
-}
-
-PRStatus
-_MD_wait_process (PRProcess *process, PRInt32 *exitCode)
-{
- PRStatus retVal = PR_SUCCESS;
- int ret, status;
-
- /* Ignore interruptions */
- do {
- ret = waitpid(process->md.pid, &status, 0);
- } while (ret == -1 && errno == EINTR);
-
- /*
- * waitpid() cannot return 0 because we did not invoke it
- * with the WNOHANG option.
- */
- PR_ASSERT(0 != ret);
-
- if (ret < 0) {
- PR_SetError(PR_UNKNOWN_ERROR, _MD_ERRNO());
- return PR_FAILURE;
- }
-
- /* If child process exited normally, return child exit code */
- if (WIFEXITED(status)) {
- *exitCode = WEXITSTATUS(status);
- } else {
- PR_ASSERT(WIFSIGNALED(status));
- *exitCode = _PR_SIGNALED_EXITSTATUS;
- }
-
- PR_DELETE(process);
- return PR_SUCCESS;
-}
-
-PRStatus
-_MD_kill_process (PRProcess *process)
-{
- PRErrorCode prerror;
- PRInt32 oserror;
-
- if (kill(process->md.pid, SIGKILL) == 0) {
- return PR_SUCCESS;
- }
- oserror = errno;
- switch (oserror) {
- case EPERM:
- prerror = PR_NO_ACCESS_RIGHTS_ERROR;
- break;
- case ESRCH:
- prerror = PR_INVALID_ARGUMENT_ERROR;
- break;
- default:
- prerror = PR_UNKNOWN_ERROR;
- break;
- }
- PR_SetError(prerror, oserror);
- return PR_FAILURE;
-}
diff --git a/nsprpub/pr/src/md/beos/brng.c b/nsprpub/pr/src/md/beos/brng.c
deleted file mode 100644
index 18a3bbf1e..000000000
--- a/nsprpub/pr/src/md/beos/brng.c
+++ /dev/null
@@ -1,40 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-
-
-#include <stdio.h>
-#include <string.h>
-#include <signal.h>
-#include <unistd.h>
-#include <errno.h>
-#include <stdlib.h>
-#include <sys/time.h>
-#include <sys/wait.h>
-#include <sys/stat.h>
-#include <assert.h>
-#include <time.h>
-#include "primpl.h"
-
-extern PRSize _PR_MD_GetRandomNoise( void *buf, PRSize size )
-{
- struct timeval tv;
- int n = 0;
- int s;
-
- GETTIMEOFDAY(&tv);
-
- if ( size > 0 ) {
- s = _pr_CopyLowBits((char*)buf+n, size, &tv.tv_usec, sizeof(tv.tv_usec));
- size -= s;
- n += s;
- }
- if ( size > 0 ) {
- s = _pr_CopyLowBits((char*)buf+n, size, &tv.tv_sec, sizeof(tv.tv_usec));
- size -= s;
- n += s;
- }
-
- return n;
-} /* end _PR_MD_GetRandomNoise() */
diff --git a/nsprpub/pr/src/md/beos/bseg.c b/nsprpub/pr/src/md/beos/bseg.c
deleted file mode 100644
index e7bb9b3d7..000000000
--- a/nsprpub/pr/src/md/beos/bseg.c
+++ /dev/null
@@ -1,22 +0,0 @@
-/* -*- Mode: C++; c-basic-offset: 4 -*- */
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-
-#include "primpl.h"
-
-PR_IMPLEMENT(void)
- _MD_init_segs (void)
-{
-}
-
-PR_IMPLEMENT(PRStatus)
- _MD_alloc_segment (PRSegment *seg, PRUint32 size, void *vaddr)
-{
- return PR_NOT_IMPLEMENTED_ERROR;
-}
-
-PR_IMPLEMENT(void)
- _MD_free_segment (PRSegment *seg)
-{
-}
diff --git a/nsprpub/pr/src/md/beos/bsrcs.mk b/nsprpub/pr/src/md/beos/bsrcs.mk
deleted file mode 100644
index 94424537f..000000000
--- a/nsprpub/pr/src/md/beos/bsrcs.mk
+++ /dev/null
@@ -1,22 +0,0 @@
-#
-# This Source Code Form is subject to the terms of the Mozilla Public
-# License, v. 2.0. If a copy of the MPL was not distributed with this
-# file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-
-# this file lists the source files to be compiled (used in Makefile) and
-# then enumerated as object files (in objs.mk) for inclusion in the NSPR
-# shared library
-
-MDCSRCS = \
- beos.c \
- beos_errors.c \
- bfile.c \
- bmisc.c \
- bnet.c \
- bproc.c \
- brng.c \
- bseg.c \
- btime.c \
- bmmap.c \
- $(NULL)
diff --git a/nsprpub/pr/src/md/beos/btime.c b/nsprpub/pr/src/md/beos/btime.c
deleted file mode 100644
index b6e02fc7d..000000000
--- a/nsprpub/pr/src/md/beos/btime.c
+++ /dev/null
@@ -1,43 +0,0 @@
-/* -*- Mode: C++; c-basic-offset: 4 -*- */
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-
-#include "primpl.h"
-#include <kernel/OS.h>
-
-static bigtime_t start;
-
-PRTime
-_MD_now (void)
-{
- return (PRTime)real_time_clock_usecs();
-}
-
-void
-_MD_interval_init (void)
-{
- /* grab the base interval time */
- start = real_time_clock_usecs();
-}
-
-PRIntervalTime
-_MD_get_interval (void)
-{
- return( (PRIntervalTime) real_time_clock_usecs() / 10 );
-
-#if 0
- /* return the number of tens of microseconds that have elapsed since
- we were initialized */
- bigtime_t now = real_time_clock_usecs();
- now -= start;
- now /= 10;
- return (PRIntervalTime)now;
-#endif
-}
-
-PRIntervalTime
-_MD_interval_per_sec (void)
-{
- return 100000L;
-}
diff --git a/nsprpub/pr/src/md/beos/objs.mk b/nsprpub/pr/src/md/beos/objs.mk
deleted file mode 100644
index 8727ee0e6..000000000
--- a/nsprpub/pr/src/md/beos/objs.mk
+++ /dev/null
@@ -1,11 +0,0 @@
-#
-# This Source Code Form is subject to the terms of the Mozilla Public
-# License, v. 2.0. If a copy of the MPL was not distributed with this
-# file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-# This makefile appends to the variable OBJS the platform-dependent
-# object modules that will be part of the nspr20 library.
-
-include $(srcdir)/md/beos/bsrcs.mk
-
-OBJS += $(MDCSRCS:%.c=md/beos/$(OBJDIR)/%.$(OBJ_SUFFIX))
generated by cgit v1.2.3 (git 2.25.1) at 2024-12-04 19:05:00 +0000