| /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; 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/. */ |
| |
| /* |
| ** File: ptio.c |
| ** Descritpion: Implemenation of I/O methods for pthreads |
| */ |
| |
| #if defined(_PR_PTHREADS) |
| |
| #if defined(_PR_POLL_WITH_SELECT) |
| #if !(defined(HPUX) && defined(_USE_BIG_FDS)) |
| /* set fd limit for select(), before including system header files */ |
| #define FD_SETSIZE (16 * 1024) |
| #endif |
| #endif |
| |
| #include <pthread.h> |
| #include <string.h> /* for memset() */ |
| #include <sys/types.h> |
| #include <dirent.h> |
| #include <fcntl.h> |
| #include <unistd.h> |
| #include <sys/socket.h> |
| #include <sys/stat.h> |
| #include <sys/uio.h> |
| #include <sys/file.h> |
| #include <sys/ioctl.h> |
| #if defined(DARWIN) |
| #include <sys/utsname.h> /* for uname */ |
| #endif |
| #if defined(SOLARIS) || defined(UNIXWARE) |
| #include <sys/filio.h> /* to pick up FIONREAD */ |
| #endif |
| #ifdef _PR_POLL_AVAILABLE |
| #include <poll.h> |
| #endif |
| #ifdef AIX |
| /* To pick up sysconf() */ |
| #include <unistd.h> |
| #include <dlfcn.h> /* for dlopen */ |
| #else |
| /* To pick up getrlimit() etc. */ |
| #include <sys/time.h> |
| #include <sys/resource.h> |
| #endif |
| |
| #ifdef SOLARIS |
| /* |
| * Define HAVE_SENDFILEV if the system has the sendfilev() system call. |
| * Code built this way won't run on a system without sendfilev(). |
| * We can define HAVE_SENDFILEV by default when the minimum release |
| * of Solaris that NSPR supports has sendfilev(). |
| */ |
| #ifdef HAVE_SENDFILEV |
| |
| #include <sys/sendfile.h> |
| |
| #define SOLARIS_SENDFILEV(a, b, c, d) sendfilev((a), (b), (c), (d)) |
| |
| #else |
| |
| #include <dlfcn.h> /* for dlopen */ |
| |
| /* |
| * Match the definitions in <sys/sendfile.h>. |
| */ |
| typedef struct sendfilevec { |
| int sfv_fd; /* input fd */ |
| uint_t sfv_flag; /* flags */ |
| off_t sfv_off; /* offset to start reading from */ |
| size_t sfv_len; /* amount of data */ |
| } sendfilevec_t; |
| |
| #define SFV_FD_SELF (-2) |
| |
| /* |
| * extern ssize_t sendfilev(int, const struct sendfilevec *, int, size_t *); |
| */ |
| static ssize_t (*pt_solaris_sendfilev_fptr)() = NULL; |
| |
| #define SOLARIS_SENDFILEV(a, b, c, d) \ |
| (*pt_solaris_sendfilev_fptr)((a), (b), (c), (d)) |
| |
| #endif /* HAVE_SENDFILEV */ |
| #endif /* SOLARIS */ |
| |
| /* |
| * The send_file() system call is available in AIX 4.3.2 or later. |
| * If this file is compiled on an older AIX system, it attempts to |
| * look up the send_file symbol at run time to determine whether |
| * we can use the faster PR_SendFile/PR_TransmitFile implementation based on |
| * send_file(). On AIX 4.3.2 or later, we can safely skip this |
| * runtime function dispatching and just use the send_file based |
| * implementation. |
| */ |
| #ifdef AIX |
| #ifdef SF_CLOSE |
| #define HAVE_SEND_FILE |
| #endif |
| |
| #ifdef HAVE_SEND_FILE |
| |
| #define AIX_SEND_FILE(a, b, c) send_file(a, b, c) |
| |
| #else /* HAVE_SEND_FILE */ |
| |
| /* |
| * The following definitions match those in <sys/socket.h> |
| * on AIX 4.3.2. |
| */ |
| |
| /* |
| * Structure for the send_file() system call |
| */ |
| struct sf_parms { |
| /* --------- header parms ---------- */ |
| void *header_data; /* Input/Output. Points to header buf */ |
| uint_t header_length; /* Input/Output. Length of the header */ |
| /* --------- file parms ------------ */ |
| int file_descriptor; /* Input. File descriptor of the file */ |
| unsigned long long file_size; /* Output. Size of the file */ |
| unsigned long long file_offset; /* Input/Output. Starting offset */ |
| long long file_bytes; /* Input/Output. no. of bytes to send */ |
| /* --------- trailer parms --------- */ |
| void *trailer_data; /* Input/Output. Points to trailer buf */ |
| uint_t trailer_length; /* Input/Output. Length of the trailer */ |
| /* --------- return info ----------- */ |
| unsigned long long bytes_sent; /* Output. no. of bytes sent */ |
| }; |
| |
| /* |
| * Flags for the send_file() system call |
| */ |
| #define SF_CLOSE 0x00000001 /* close the socket after completion */ |
| #define SF_REUSE 0x00000002 /* reuse socket. not supported */ |
| #define SF_DONT_CACHE 0x00000004 /* don't apply network buffer cache */ |
| #define SF_SYNC_CACHE 0x00000008 /* sync/update network buffer cache */ |
| |
| /* |
| * prototype: size_t send_file(int *, struct sf_parms *, uint_t); |
| */ |
| static ssize_t (*pt_aix_sendfile_fptr)() = NULL; |
| |
| #define AIX_SEND_FILE(a, b, c) (*pt_aix_sendfile_fptr)(a, b, c) |
| |
| #endif /* HAVE_SEND_FILE */ |
| #endif /* AIX */ |
| |
| #ifdef LINUX |
| #include <sys/sendfile.h> |
| #endif |
| |
| #include "primpl.h" |
| |
| #ifdef HAVE_NETINET_TCP_H |
| #include <netinet/tcp.h> /* TCP_NODELAY, TCP_MAXSEG */ |
| #endif |
| |
| #ifdef LINUX |
| /* TCP_CORK is not defined in <netinet/tcp.h> on Red Hat Linux 6.0 */ |
| #ifndef TCP_CORK |
| #define TCP_CORK 3 |
| #endif |
| #endif |
| |
| #ifdef _PR_IPV6_V6ONLY_PROBE |
| static PRBool _pr_ipv6_v6only_on_by_default; |
| #endif |
| |
| #if (defined(HPUX) && !defined(HPUX10_30) && !defined(HPUX11)) |
| #define _PRSelectFdSetArg_t int * |
| #elif defined(AIX4_1) |
| #define _PRSelectFdSetArg_t void * |
| #elif defined(IRIX) || (defined(AIX) && !defined(AIX4_1)) \ |
| || defined(OSF1) || defined(SOLARIS) \ |
| || defined(HPUX10_30) || defined(HPUX11) \ |
| || defined(LINUX) || defined(__GNU__) || defined(__GLIBC__) \ |
| || defined(FREEBSD) || defined(NETBSD) || defined(OPENBSD) \ |
| || defined(BSDI) || defined(NTO) || defined(DARWIN) \ |
| || defined(UNIXWARE) || defined(RISCOS) || defined(SYMBIAN) |
| #define _PRSelectFdSetArg_t fd_set * |
| #else |
| #error "Cannot determine architecture" |
| #endif |
| |
| #if defined(SOLARIS) |
| #ifndef PROTO_SDP |
| /* on solaris, SDP is a new type of protocol */ |
| #define PROTO_SDP 257 |
| #endif |
| #define _PR_HAVE_SDP |
| #elif defined(LINUX) |
| #ifndef AF_INET_SDP |
| /* on linux, SDP is a new type of address family */ |
| #define AF_INET_SDP 27 |
| #endif |
| #define _PR_HAVE_SDP |
| #endif /* LINUX */ |
| |
| static PRFileDesc *pt_SetMethods( |
| PRIntn osfd, PRDescType type, PRBool isAcceptedSocket, PRBool imported); |
| |
| static PRLock *_pr_flock_lock; /* For PR_LockFile() etc. */ |
| static PRCondVar *_pr_flock_cv; /* For PR_LockFile() etc. */ |
| static PRLock *_pr_rename_lock; /* For PR_Rename() */ |
| |
| /**************************************************************************/ |
| |
| /* These two functions are only used in assertions. */ |
| #if defined(DEBUG) |
| |
| PRBool IsValidNetAddr(const PRNetAddr *addr) |
| { |
| if ((addr != NULL) |
| && (addr->raw.family != AF_UNIX) |
| && (addr->raw.family != PR_AF_INET6) |
| && (addr->raw.family != AF_INET)) { |
| return PR_FALSE; |
| } |
| return PR_TRUE; |
| } |
| |
| static PRBool IsValidNetAddrLen(const PRNetAddr *addr, PRInt32 addr_len) |
| { |
| /* |
| * The definition of the length of a Unix domain socket address |
| * is not uniform, so we don't check it. |
| */ |
| if ((addr != NULL) |
| && (addr->raw.family != AF_UNIX) |
| && (PR_NETADDR_SIZE(addr) != addr_len)) { |
| #if defined(LINUX) && __GLIBC__ == 2 && __GLIBC_MINOR__ == 1 |
| /* |
| * In glibc 2.1, struct sockaddr_in6 is 24 bytes. In glibc 2.2 |
| * and in the 2.4 kernel, struct sockaddr_in6 has the scope_id |
| * field and is 28 bytes. It is possible for socket functions |
| * to return an addr_len greater than sizeof(struct sockaddr_in6). |
| * We need to allow that. (Bugzilla bug #77264) |
| */ |
| if ((PR_AF_INET6 == addr->raw.family) |
| && (sizeof(addr->ipv6) == addr_len)) { |
| return PR_TRUE; |
| } |
| #endif |
| return PR_FALSE; |
| } |
| return PR_TRUE; |
| } |
| |
| #endif /* DEBUG */ |
| |
| /*****************************************************************************/ |
| /************************* I/O Continuation machinery ************************/ |
| /*****************************************************************************/ |
| |
| /* |
| * The polling interval defines the maximum amount of time that a thread |
| * might hang up before an interrupt is noticed. |
| */ |
| #define PT_DEFAULT_POLL_MSEC 5000 |
| #if defined(_PR_POLL_WITH_SELECT) |
| #define PT_DEFAULT_SELECT_SEC (PT_DEFAULT_POLL_MSEC/PR_MSEC_PER_SEC) |
| #define PT_DEFAULT_SELECT_USEC \ |
| ((PT_DEFAULT_POLL_MSEC % PR_MSEC_PER_SEC) * PR_USEC_PER_MSEC) |
| #endif |
| |
| /* |
| * pt_SockLen is the type for the length of a socket address |
| * structure, used in the address length argument to bind, |
| * connect, accept, getsockname, getpeername, etc. Posix.1g |
| * defines this type as socklen_t. It is size_t or int on |
| * most current systems. |
| */ |
| #if defined(HAVE_SOCKLEN_T) \ |
| || (defined(__GLIBC__) && __GLIBC__ >= 2) |
| typedef socklen_t pt_SockLen; |
| #elif (defined(AIX) && !defined(AIX4_1)) |
| typedef PRSize pt_SockLen; |
| #else |
| typedef PRIntn pt_SockLen; |
| #endif |
| |
| typedef struct pt_Continuation pt_Continuation; |
| typedef PRBool (*ContinuationFn)(pt_Continuation *op, PRInt16 revents); |
| |
| typedef enum pr_ContuationStatus |
| { |
| pt_continuation_pending, |
| pt_continuation_done |
| } pr_ContuationStatus; |
| |
| struct pt_Continuation |
| { |
| /* The building of the continuation operation */ |
| ContinuationFn function; /* what function to continue */ |
| union { PRIntn osfd; } arg1; /* #1 - the op's fd */ |
| union { void* buffer; } arg2; /* #2 - primary transfer buffer */ |
| union { |
| PRSize amount; /* #3 - size of 'buffer', or */ |
| pt_SockLen *addr_len; /* - length of address */ |
| #ifdef HPUX11 |
| /* |
| * For sendfile() |
| */ |
| struct file_spec { |
| off_t offset; /* offset in file to send */ |
| size_t nbytes; /* length of file data to send */ |
| size_t st_size; /* file size */ |
| } file_spec; |
| #endif |
| } arg3; |
| union { PRIntn flags; } arg4; /* #4 - read/write flags */ |
| union { PRNetAddr *addr; } arg5; /* #5 - send/recv address */ |
| |
| #ifdef HPUX11 |
| /* |
| * For sendfile() |
| */ |
| int filedesc; /* descriptor of file to send */ |
| int nbytes_to_send; /* size of header and file */ |
| #endif /* HPUX11 */ |
| |
| #ifdef SOLARIS |
| /* |
| * For sendfilev() |
| */ |
| int nbytes_to_send; /* size of header and file */ |
| #endif /* SOLARIS */ |
| |
| #ifdef LINUX |
| /* |
| * For sendfile() |
| */ |
| int in_fd; /* descriptor of file to send */ |
| off_t offset; |
| size_t count; |
| #endif /* LINUX */ |
| |
| PRIntervalTime timeout; /* client (relative) timeout */ |
| |
| PRInt16 event; /* flags for poll()'s events */ |
| |
| /* |
| ** The representation and notification of the results of the operation. |
| ** These function can either return an int return code or a pointer to |
| ** some object. |
| */ |
| union { PRSize code; void *object; } result; |
| |
| PRIntn syserrno; /* in case it failed, why (errno) */ |
| pr_ContuationStatus status; /* the status of the operation */ |
| }; |
| |
| #if defined(DEBUG) |
| |
| PTDebug pt_debug; /* this is shared between several modules */ |
| |
| PR_IMPLEMENT(void) PT_FPrintStats(PRFileDesc *debug_out, const char *msg) |
| { |
| PTDebug stats; |
| char buffer[100]; |
| PRExplodedTime tod; |
| PRInt64 elapsed, aMil; |
| stats = pt_debug; /* a copy */ |
| PR_ExplodeTime(stats.timeStarted, PR_LocalTimeParameters, &tod); |
| (void)PR_FormatTime(buffer, sizeof(buffer), "%T", &tod); |
| |
| LL_SUB(elapsed, PR_Now(), stats.timeStarted); |
| LL_I2L(aMil, 1000000); |
| LL_DIV(elapsed, elapsed, aMil); |
| |
| if (NULL != msg) PR_fprintf(debug_out, "%s", msg); |
| PR_fprintf( |
| debug_out, "\tstarted: %s[%lld]\n", buffer, elapsed); |
| PR_fprintf( |
| debug_out, "\tlocks [created: %u, destroyed: %u]\n", |
| stats.locks_created, stats.locks_destroyed); |
| PR_fprintf( |
| debug_out, "\tlocks [acquired: %u, released: %u]\n", |
| stats.locks_acquired, stats.locks_released); |
| PR_fprintf( |
| debug_out, "\tcvars [created: %u, destroyed: %u]\n", |
| stats.cvars_created, stats.cvars_destroyed); |
| PR_fprintf( |
| debug_out, "\tcvars [notified: %u, delayed_delete: %u]\n", |
| stats.cvars_notified, stats.delayed_cv_deletes); |
| } /* PT_FPrintStats */ |
| |
| #else |
| |
| PR_IMPLEMENT(void) PT_FPrintStats(PRFileDesc *debug_out, const char *msg) |
| { |
| /* do nothing */ |
| } /* PT_FPrintStats */ |
| |
| #endif /* DEBUG */ |
| |
| #if defined(_PR_POLL_WITH_SELECT) |
| /* |
| * OSF1 and HPUX report the POLLHUP event for a socket when the |
| * shutdown(SHUT_WR) operation is called for the remote end, even though |
| * the socket is still writeable. Use select(), instead of poll(), to |
| * workaround this problem. |
| */ |
| static void pt_poll_now_with_select(pt_Continuation *op) |
| { |
| PRInt32 msecs; |
| fd_set rd, wr, *rdp, *wrp; |
| struct timeval tv; |
| PRIntervalTime epoch, now, elapsed, remaining; |
| PRBool wait_for_remaining; |
| PRThread *self = PR_GetCurrentThread(); |
| |
| PR_ASSERT(PR_INTERVAL_NO_WAIT != op->timeout); |
| PR_ASSERT(op->arg1.osfd < FD_SETSIZE); |
| |
| switch (op->timeout) { |
| case PR_INTERVAL_NO_TIMEOUT: |
| tv.tv_sec = PT_DEFAULT_SELECT_SEC; |
| tv.tv_usec = PT_DEFAULT_SELECT_USEC; |
| do |
| { |
| PRIntn rv; |
| |
| if (op->event & POLLIN) { |
| FD_ZERO(&rd); |
| FD_SET(op->arg1.osfd, &rd); |
| rdp = &rd; |
| } else |
| rdp = NULL; |
| if (op->event & POLLOUT) { |
| FD_ZERO(&wr); |
| FD_SET(op->arg1.osfd, &wr); |
| wrp = ≀ |
| } else |
| wrp = NULL; |
| |
| rv = select(op->arg1.osfd + 1, rdp, wrp, NULL, &tv); |
| |
| if (_PT_THREAD_INTERRUPTED(self)) |
| { |
| self->state &= ~PT_THREAD_ABORTED; |
| op->result.code = -1; |
| op->syserrno = EINTR; |
| op->status = pt_continuation_done; |
| return; |
| } |
| |
| if ((-1 == rv) && ((errno == EINTR) || (errno == EAGAIN))) |
| continue; /* go around the loop again */ |
| |
| if (rv > 0) |
| { |
| PRInt16 revents = 0; |
| |
| if ((op->event & POLLIN) && FD_ISSET(op->arg1.osfd, &rd)) |
| revents |= POLLIN; |
| if ((op->event & POLLOUT) && FD_ISSET(op->arg1.osfd, &wr)) |
| revents |= POLLOUT; |
| |
| if (op->function(op, revents)) |
| op->status = pt_continuation_done; |
| } else if (rv == -1) { |
| op->result.code = -1; |
| op->syserrno = errno; |
| op->status = pt_continuation_done; |
| } |
| /* else, select timed out */ |
| } while (pt_continuation_done != op->status); |
| break; |
| default: |
| now = epoch = PR_IntervalNow(); |
| remaining = op->timeout; |
| do |
| { |
| PRIntn rv; |
| |
| if (op->event & POLLIN) { |
| FD_ZERO(&rd); |
| FD_SET(op->arg1.osfd, &rd); |
| rdp = &rd; |
| } else |
| rdp = NULL; |
| if (op->event & POLLOUT) { |
| FD_ZERO(&wr); |
| FD_SET(op->arg1.osfd, &wr); |
| wrp = ≀ |
| } else |
| wrp = NULL; |
| |
| wait_for_remaining = PR_TRUE; |
| msecs = (PRInt32)PR_IntervalToMilliseconds(remaining); |
| if (msecs > PT_DEFAULT_POLL_MSEC) { |
| wait_for_remaining = PR_FALSE; |
| msecs = PT_DEFAULT_POLL_MSEC; |
| } |
| tv.tv_sec = msecs/PR_MSEC_PER_SEC; |
| tv.tv_usec = (msecs % PR_MSEC_PER_SEC) * PR_USEC_PER_MSEC; |
| rv = select(op->arg1.osfd + 1, rdp, wrp, NULL, &tv); |
| |
| if (_PT_THREAD_INTERRUPTED(self)) |
| { |
| self->state &= ~PT_THREAD_ABORTED; |
| op->result.code = -1; |
| op->syserrno = EINTR; |
| op->status = pt_continuation_done; |
| return; |
| } |
| |
| if (rv > 0) { |
| PRInt16 revents = 0; |
| |
| if ((op->event & POLLIN) && FD_ISSET(op->arg1.osfd, &rd)) |
| revents |= POLLIN; |
| if ((op->event & POLLOUT) && FD_ISSET(op->arg1.osfd, &wr)) |
| revents |= POLLOUT; |
| |
| if (op->function(op, revents)) |
| op->status = pt_continuation_done; |
| |
| } else if ((rv == 0) || |
| ((errno == EINTR) || (errno == EAGAIN))) { |
| if (rv == 0) { /* select timed out */ |
| if (wait_for_remaining) |
| now += remaining; |
| else |
| now += PR_MillisecondsToInterval(msecs); |
| } else |
| now = PR_IntervalNow(); |
| elapsed = (PRIntervalTime) (now - epoch); |
| if (elapsed >= op->timeout) { |
| op->result.code = -1; |
| op->syserrno = ETIMEDOUT; |
| op->status = pt_continuation_done; |
| } else |
| remaining = op->timeout - elapsed; |
| } else { |
| op->result.code = -1; |
| op->syserrno = errno; |
| op->status = pt_continuation_done; |
| } |
| } while (pt_continuation_done != op->status); |
| break; |
| } |
| |
| } /* pt_poll_now_with_select */ |
| |
| #endif /* _PR_POLL_WITH_SELECT */ |
| |
| static void pt_poll_now(pt_Continuation *op) |
| { |
| PRInt32 msecs; |
| PRIntervalTime epoch, now, elapsed, remaining; |
| PRBool wait_for_remaining; |
| PRThread *self = PR_GetCurrentThread(); |
| |
| PR_ASSERT(PR_INTERVAL_NO_WAIT != op->timeout); |
| #if defined (_PR_POLL_WITH_SELECT) |
| /* |
| * If the fd is small enough call the select-based poll operation |
| */ |
| if (op->arg1.osfd < FD_SETSIZE) { |
| pt_poll_now_with_select(op); |
| return; |
| } |
| #endif |
| |
| switch (op->timeout) { |
| case PR_INTERVAL_NO_TIMEOUT: |
| msecs = PT_DEFAULT_POLL_MSEC; |
| do |
| { |
| PRIntn rv; |
| struct pollfd tmp_pfd; |
| |
| tmp_pfd.revents = 0; |
| tmp_pfd.fd = op->arg1.osfd; |
| tmp_pfd.events = op->event; |
| |
| rv = poll(&tmp_pfd, 1, msecs); |
| |
| if (_PT_THREAD_INTERRUPTED(self)) |
| { |
| self->state &= ~PT_THREAD_ABORTED; |
| op->result.code = -1; |
| op->syserrno = EINTR; |
| op->status = pt_continuation_done; |
| return; |
| } |
| |
| if ((-1 == rv) && ((errno == EINTR) || (errno == EAGAIN))) |
| continue; /* go around the loop again */ |
| |
| if (rv > 0) |
| { |
| PRInt16 events = tmp_pfd.events; |
| PRInt16 revents = tmp_pfd.revents; |
| |
| if ((revents & POLLNVAL) /* busted in all cases */ |
| || ((events & POLLOUT) && (revents & POLLHUP))) |
| /* write op & hup */ |
| { |
| op->result.code = -1; |
| if (POLLNVAL & revents) op->syserrno = EBADF; |
| else if (POLLHUP & revents) op->syserrno = EPIPE; |
| op->status = pt_continuation_done; |
| } else { |
| if (op->function(op, revents)) |
| op->status = pt_continuation_done; |
| } |
| } else if (rv == -1) { |
| op->result.code = -1; |
| op->syserrno = errno; |
| op->status = pt_continuation_done; |
| } |
| /* else, poll timed out */ |
| } while (pt_continuation_done != op->status); |
| break; |
| default: |
| now = epoch = PR_IntervalNow(); |
| remaining = op->timeout; |
| do |
| { |
| PRIntn rv; |
| struct pollfd tmp_pfd; |
| |
| tmp_pfd.revents = 0; |
| tmp_pfd.fd = op->arg1.osfd; |
| tmp_pfd.events = op->event; |
| |
| wait_for_remaining = PR_TRUE; |
| msecs = (PRInt32)PR_IntervalToMilliseconds(remaining); |
| if (msecs > PT_DEFAULT_POLL_MSEC) |
| { |
| wait_for_remaining = PR_FALSE; |
| msecs = PT_DEFAULT_POLL_MSEC; |
| } |
| rv = poll(&tmp_pfd, 1, msecs); |
| |
| if (_PT_THREAD_INTERRUPTED(self)) |
| { |
| self->state &= ~PT_THREAD_ABORTED; |
| op->result.code = -1; |
| op->syserrno = EINTR; |
| op->status = pt_continuation_done; |
| return; |
| } |
| |
| if (rv > 0) |
| { |
| PRInt16 events = tmp_pfd.events; |
| PRInt16 revents = tmp_pfd.revents; |
| |
| if ((revents & POLLNVAL) /* busted in all cases */ |
| || ((events & POLLOUT) && (revents & POLLHUP))) |
| /* write op & hup */ |
| { |
| op->result.code = -1; |
| if (POLLNVAL & revents) op->syserrno = EBADF; |
| else if (POLLHUP & revents) op->syserrno = EPIPE; |
| op->status = pt_continuation_done; |
| } else { |
| if (op->function(op, revents)) |
| { |
| op->status = pt_continuation_done; |
| } |
| } |
| } else if ((rv == 0) || |
| ((errno == EINTR) || (errno == EAGAIN))) { |
| if (rv == 0) /* poll timed out */ |
| { |
| if (wait_for_remaining) |
| now += remaining; |
| else |
| now += PR_MillisecondsToInterval(msecs); |
| } |
| else |
| now = PR_IntervalNow(); |
| elapsed = (PRIntervalTime) (now - epoch); |
| if (elapsed >= op->timeout) { |
| op->result.code = -1; |
| op->syserrno = ETIMEDOUT; |
| op->status = pt_continuation_done; |
| } else |
| remaining = op->timeout - elapsed; |
| } else { |
| op->result.code = -1; |
| op->syserrno = errno; |
| op->status = pt_continuation_done; |
| } |
| } while (pt_continuation_done != op->status); |
| break; |
| } |
| |
| } /* pt_poll_now */ |
| |
| static PRIntn pt_Continue(pt_Continuation *op) |
| { |
| op->status = pt_continuation_pending; /* set default value */ |
| /* |
| * let each thread call poll directly |
| */ |
| pt_poll_now(op); |
| PR_ASSERT(pt_continuation_done == op->status); |
| return op->result.code; |
| } /* pt_Continue */ |
| |
| /*****************************************************************************/ |
| /*********************** specific continuation functions *********************/ |
| /*****************************************************************************/ |
| static PRBool pt_connect_cont(pt_Continuation *op, PRInt16 revents) |
| { |
| op->syserrno = _MD_unix_get_nonblocking_connect_error(op->arg1.osfd); |
| if (op->syserrno != 0) { |
| op->result.code = -1; |
| } else { |
| op->result.code = 0; |
| } |
| return PR_TRUE; /* this one is cooked */ |
| } /* pt_connect_cont */ |
| |
| static PRBool pt_accept_cont(pt_Continuation *op, PRInt16 revents) |
| { |
| op->syserrno = 0; |
| op->result.code = accept( |
| op->arg1.osfd, op->arg2.buffer, op->arg3.addr_len); |
| if (-1 == op->result.code) |
| { |
| op->syserrno = errno; |
| if (EWOULDBLOCK == errno || EAGAIN == errno || ECONNABORTED == errno) |
| return PR_FALSE; /* do nothing - this one ain't finished */ |
| } |
| return PR_TRUE; |
| } /* pt_accept_cont */ |
| |
| static PRBool pt_read_cont(pt_Continuation *op, PRInt16 revents) |
| { |
| /* |
| * Any number of bytes will complete the operation. It need |
| * not (and probably will not) satisfy the request. The only |
| * error we continue is EWOULDBLOCK|EAGAIN. |
| */ |
| op->result.code = read( |
| op->arg1.osfd, op->arg2.buffer, op->arg3.amount); |
| op->syserrno = errno; |
| return ((-1 == op->result.code) && |
| (EWOULDBLOCK == op->syserrno || EAGAIN == op->syserrno)) ? |
| PR_FALSE : PR_TRUE; |
| } /* pt_read_cont */ |
| |
| static PRBool pt_recv_cont(pt_Continuation *op, PRInt16 revents) |
| { |
| /* |
| * Any number of bytes will complete the operation. It need |
| * not (and probably will not) satisfy the request. The only |
| * error we continue is EWOULDBLOCK|EAGAIN. |
| */ |
| #if defined(SOLARIS) |
| if (0 == op->arg4.flags) |
| op->result.code = read( |
| op->arg1.osfd, op->arg2.buffer, op->arg3.amount); |
| else |
| op->result.code = recv( |
| op->arg1.osfd, op->arg2.buffer, op->arg3.amount, op->arg4.flags); |
| #else |
| op->result.code = recv( |
| op->arg1.osfd, op->arg2.buffer, op->arg3.amount, op->arg4.flags); |
| #endif |
| op->syserrno = errno; |
| return ((-1 == op->result.code) && |
| (EWOULDBLOCK == op->syserrno || EAGAIN == op->syserrno)) ? |
| PR_FALSE : PR_TRUE; |
| } /* pt_recv_cont */ |
| |
| static PRBool pt_send_cont(pt_Continuation *op, PRInt16 revents) |
| { |
| PRIntn bytes; |
| #if defined(SOLARIS) |
| PRInt32 tmp_amount = op->arg3.amount; |
| #endif |
| /* |
| * We want to write the entire amount out, no matter how many |
| * tries it takes. Keep advancing the buffer and the decrementing |
| * the amount until the amount goes away. Return the total bytes |
| * (which should be the original amount) when finished (or an |
| * error). |
| */ |
| #if defined(SOLARIS) |
| retry: |
| bytes = write(op->arg1.osfd, op->arg2.buffer, tmp_amount); |
| #else |
| bytes = send( |
| op->arg1.osfd, op->arg2.buffer, op->arg3.amount, op->arg4.flags); |
| #endif |
| op->syserrno = errno; |
| |
| #if defined(SOLARIS) |
| /* |
| * The write system call has been reported to return the ERANGE error |
| * on occasion. Try to write in smaller chunks to workaround this bug. |
| */ |
| if ((bytes == -1) && (op->syserrno == ERANGE)) |
| { |
| if (tmp_amount > 1) |
| { |
| tmp_amount = tmp_amount/2; /* half the bytes */ |
| goto retry; |
| } |
| } |
| #endif |
| |
| if (bytes >= 0) /* this is progress */ |
| { |
| char *bp = (char*)op->arg2.buffer; |
| bp += bytes; /* adjust the buffer pointer */ |
| op->arg2.buffer = bp; |
| op->result.code += bytes; /* accumulate the number sent */ |
| op->arg3.amount -= bytes; /* and reduce the required count */ |
| return (0 == op->arg3.amount) ? PR_TRUE : PR_FALSE; |
| } |
| else if ((EWOULDBLOCK != op->syserrno) && (EAGAIN != op->syserrno)) |
| { |
| op->result.code = -1; |
| return PR_TRUE; |
| } |
| else return PR_FALSE; |
| } /* pt_send_cont */ |
| |
| static PRBool pt_write_cont(pt_Continuation *op, PRInt16 revents) |
| { |
| PRIntn bytes; |
| /* |
| * We want to write the entire amount out, no matter how many |
| * tries it takes. Keep advancing the buffer and the decrementing |
| * the amount until the amount goes away. Return the total bytes |
| * (which should be the original amount) when finished (or an |
| * error). |
| */ |
| bytes = write(op->arg1.osfd, op->arg2.buffer, op->arg3.amount); |
| op->syserrno = errno; |
| if (bytes >= 0) /* this is progress */ |
| { |
| char *bp = (char*)op->arg2.buffer; |
| bp += bytes; /* adjust the buffer pointer */ |
| op->arg2.buffer = bp; |
| op->result.code += bytes; /* accumulate the number sent */ |
| op->arg3.amount -= bytes; /* and reduce the required count */ |
| return (0 == op->arg3.amount) ? PR_TRUE : PR_FALSE; |
| } |
| else if ((EWOULDBLOCK != op->syserrno) && (EAGAIN != op->syserrno)) |
| { |
| op->result.code = -1; |
| return PR_TRUE; |
| } |
| else return PR_FALSE; |
| } /* pt_write_cont */ |
| |
| static PRBool pt_writev_cont(pt_Continuation *op, PRInt16 revents) |
| { |
| PRIntn bytes; |
| struct iovec *iov = (struct iovec*)op->arg2.buffer; |
| /* |
| * Same rules as write, but continuing seems to be a bit more |
| * complicated. As the number of bytes sent grows, we have to |
| * redefine the vector we're pointing at. We might have to |
| * modify an individual vector parms or we might have to eliminate |
| * a pair altogether. |
| */ |
| bytes = writev(op->arg1.osfd, iov, op->arg3.amount); |
| op->syserrno = errno; |
| if (bytes >= 0) /* this is progress */ |
| { |
| PRIntn iov_index; |
| op->result.code += bytes; /* accumulate the number sent */ |
| for (iov_index = 0; iov_index < op->arg3.amount; ++iov_index) |
| { |
| /* how much progress did we make in the i/o vector? */ |
| if (bytes < iov[iov_index].iov_len) |
| { |
| /* this element's not done yet */ |
| char **bp = (char**)&(iov[iov_index].iov_base); |
| iov[iov_index].iov_len -= bytes; /* there's that much left */ |
| *bp += bytes; /* starting there */ |
| break; /* go off and do that */ |
| } |
| bytes -= iov[iov_index].iov_len; /* that element's consumed */ |
| } |
| op->arg2.buffer = &iov[iov_index]; /* new start of array */ |
| op->arg3.amount -= iov_index; /* and array length */ |
| return (0 == op->arg3.amount) ? PR_TRUE : PR_FALSE; |
| } |
| else if ((EWOULDBLOCK != op->syserrno) && (EAGAIN != op->syserrno)) |
| { |
| op->result.code = -1; |
| return PR_TRUE; |
| } |
| else return PR_FALSE; |
| } /* pt_writev_cont */ |
| |
| static PRBool pt_sendto_cont(pt_Continuation *op, PRInt16 revents) |
| { |
| PRIntn bytes = sendto( |
| op->arg1.osfd, op->arg2.buffer, op->arg3.amount, op->arg4.flags, |
| (struct sockaddr*)op->arg5.addr, PR_NETADDR_SIZE(op->arg5.addr)); |
| op->syserrno = errno; |
| if (bytes >= 0) /* this is progress */ |
| { |
| char *bp = (char*)op->arg2.buffer; |
| bp += bytes; /* adjust the buffer pointer */ |
| op->arg2.buffer = bp; |
| op->result.code += bytes; /* accumulate the number sent */ |
| op->arg3.amount -= bytes; /* and reduce the required count */ |
| return (0 == op->arg3.amount) ? PR_TRUE : PR_FALSE; |
| } |
| else if ((EWOULDBLOCK != op->syserrno) && (EAGAIN != op->syserrno)) |
| { |
| op->result.code = -1; |
| return PR_TRUE; |
| } |
| else return PR_FALSE; |
| } /* pt_sendto_cont */ |
| |
| static PRBool pt_recvfrom_cont(pt_Continuation *op, PRInt16 revents) |
| { |
| pt_SockLen addr_len = sizeof(PRNetAddr); |
| op->result.code = recvfrom( |
| op->arg1.osfd, op->arg2.buffer, op->arg3.amount, |
| op->arg4.flags, (struct sockaddr*)op->arg5.addr, &addr_len); |
| op->syserrno = errno; |
| return ((-1 == op->result.code) && |
| (EWOULDBLOCK == op->syserrno || EAGAIN == op->syserrno)) ? |
| PR_FALSE : PR_TRUE; |
| } /* pt_recvfrom_cont */ |
| |
| #ifdef AIX |
| static PRBool pt_aix_sendfile_cont(pt_Continuation *op, PRInt16 revents) |
| { |
| struct sf_parms *sf_struct = (struct sf_parms *) op->arg2.buffer; |
| ssize_t rv; |
| unsigned long long saved_file_offset; |
| long long saved_file_bytes; |
| |
| saved_file_offset = sf_struct->file_offset; |
| saved_file_bytes = sf_struct->file_bytes; |
| sf_struct->bytes_sent = 0; |
| |
| if ((sf_struct->file_bytes > 0) && (sf_struct->file_size > 0)) |
| PR_ASSERT((sf_struct->file_bytes + sf_struct->file_offset) <= |
| sf_struct->file_size); |
| rv = AIX_SEND_FILE(&op->arg1.osfd, sf_struct, op->arg4.flags); |
| op->syserrno = errno; |
| |
| if (rv != -1) { |
| op->result.code += sf_struct->bytes_sent; |
| /* |
| * A bug in AIX 4.3.2 prevents the 'file_bytes' field from |
| * being updated. So, 'file_bytes' is maintained by NSPR to |
| * avoid conflict when this bug is fixed in AIX, in the future. |
| */ |
| if (saved_file_bytes != -1) |
| saved_file_bytes -= (sf_struct->file_offset - saved_file_offset); |
| sf_struct->file_bytes = saved_file_bytes; |
| } else if (op->syserrno != EWOULDBLOCK && op->syserrno != EAGAIN) { |
| op->result.code = -1; |
| } else { |
| return PR_FALSE; |
| } |
| |
| if (rv == 1) { /* more data to send */ |
| return PR_FALSE; |
| } |
| |
| return PR_TRUE; |
| } |
| #endif /* AIX */ |
| |
| #ifdef HPUX11 |
| static PRBool pt_hpux_sendfile_cont(pt_Continuation *op, PRInt16 revents) |
| { |
| struct iovec *hdtrl = (struct iovec *) op->arg2.buffer; |
| int count; |
| |
| count = sendfile(op->arg1.osfd, op->filedesc, op->arg3.file_spec.offset, |
| op->arg3.file_spec.nbytes, hdtrl, op->arg4.flags); |
| PR_ASSERT(count <= op->nbytes_to_send); |
| op->syserrno = errno; |
| |
| if (count != -1) { |
| op->result.code += count; |
| } else if (op->syserrno != EWOULDBLOCK && op->syserrno != EAGAIN) { |
| op->result.code = -1; |
| } else { |
| return PR_FALSE; |
| } |
| if (count != -1 && count < op->nbytes_to_send) { |
| if (count < hdtrl[0].iov_len) { |
| /* header not sent */ |
| |
| hdtrl[0].iov_base = ((char *) hdtrl[0].iov_base) + count; |
| hdtrl[0].iov_len -= count; |
| |
| } else if (count < (hdtrl[0].iov_len + op->arg3.file_spec.nbytes)) { |
| /* header sent, file not sent */ |
| PRUint32 file_nbytes_sent = count - hdtrl[0].iov_len; |
| |
| hdtrl[0].iov_base = NULL; |
| hdtrl[0].iov_len = 0; |
| |
| op->arg3.file_spec.offset += file_nbytes_sent; |
| op->arg3.file_spec.nbytes -= file_nbytes_sent; |
| } else if (count < (hdtrl[0].iov_len + op->arg3.file_spec.nbytes + |
| hdtrl[1].iov_len)) { |
| PRUint32 trailer_nbytes_sent = count - (hdtrl[0].iov_len + |
| op->arg3.file_spec.nbytes); |
| |
| /* header sent, file sent, trailer not sent */ |
| |
| hdtrl[0].iov_base = NULL; |
| hdtrl[0].iov_len = 0; |
| /* |
| * set file offset and len so that no more file data is |
| * sent |
| */ |
| op->arg3.file_spec.offset = op->arg3.file_spec.st_size; |
| op->arg3.file_spec.nbytes = 0; |
| |
| hdtrl[1].iov_base =((char *) hdtrl[1].iov_base)+ trailer_nbytes_sent; |
| hdtrl[1].iov_len -= trailer_nbytes_sent; |
| } |
| op->nbytes_to_send -= count; |
| return PR_FALSE; |
| } |
| |
| return PR_TRUE; |
| } |
| #endif /* HPUX11 */ |
| |
| #ifdef SOLARIS |
| static PRBool pt_solaris_sendfile_cont(pt_Continuation *op, PRInt16 revents) |
| { |
| struct sendfilevec *vec = (struct sendfilevec *) op->arg2.buffer; |
| size_t xferred; |
| ssize_t count; |
| |
| count = SOLARIS_SENDFILEV(op->arg1.osfd, vec, op->arg3.amount, &xferred); |
| op->syserrno = errno; |
| PR_ASSERT((count == -1) || (count == xferred)); |
| |
| if (count == -1) { |
| if (op->syserrno != EWOULDBLOCK && op->syserrno != EAGAIN |
| && op->syserrno != EINTR) { |
| op->result.code = -1; |
| return PR_TRUE; |
| } |
| count = xferred; |
| } else if (count == 0) { |
| /* |
| * We are now at EOF. The file was truncated. Solaris sendfile is |
| * supposed to return 0 and no error in this case, though some versions |
| * may return -1 and EINVAL . |
| */ |
| op->result.code = -1; |
| op->syserrno = 0; /* will be treated as EOF */ |
| return PR_TRUE; |
| } |
| PR_ASSERT(count <= op->nbytes_to_send); |
| |
| op->result.code += count; |
| if (count < op->nbytes_to_send) { |
| op->nbytes_to_send -= count; |
| |
| while (count >= vec->sfv_len) { |
| count -= vec->sfv_len; |
| vec++; |
| op->arg3.amount--; |
| } |
| PR_ASSERT(op->arg3.amount > 0); |
| |
| vec->sfv_off += count; |
| vec->sfv_len -= count; |
| PR_ASSERT(vec->sfv_len > 0); |
| op->arg2.buffer = vec; |
| |
| return PR_FALSE; |
| } |
| |
| return PR_TRUE; |
| } |
| #endif /* SOLARIS */ |
| |
| #ifdef LINUX |
| static PRBool pt_linux_sendfile_cont(pt_Continuation *op, PRInt16 revents) |
| { |
| ssize_t rv; |
| off_t oldoffset; |
| |
| oldoffset = op->offset; |
| rv = sendfile(op->arg1.osfd, op->in_fd, &op->offset, op->count); |
| op->syserrno = errno; |
| |
| if (rv == -1) { |
| if (op->syserrno != EWOULDBLOCK && op->syserrno != EAGAIN) { |
| op->result.code = -1; |
| return PR_TRUE; |
| } |
| rv = 0; |
| } |
| PR_ASSERT(rv == op->offset - oldoffset); |
| op->result.code += rv; |
| if (rv < op->count) { |
| op->count -= rv; |
| return PR_FALSE; |
| } |
| return PR_TRUE; |
| } |
| #endif /* LINUX */ |
| |
| void _PR_InitIO(void) |
| { |
| #if defined(DEBUG) |
| memset(&pt_debug, 0, sizeof(PTDebug)); |
| pt_debug.timeStarted = PR_Now(); |
| #endif |
| |
| _pr_flock_lock = PR_NewLock(); |
| PR_ASSERT(NULL != _pr_flock_lock); |
| _pr_flock_cv = PR_NewCondVar(_pr_flock_lock); |
| PR_ASSERT(NULL != _pr_flock_cv); |
| _pr_rename_lock = PR_NewLock(); |
| PR_ASSERT(NULL != _pr_rename_lock); |
| |
| _PR_InitFdCache(); /* do that */ |
| |
| _pr_stdin = pt_SetMethods(0, PR_DESC_FILE, PR_FALSE, PR_TRUE); |
| _pr_stdout = pt_SetMethods(1, PR_DESC_FILE, PR_FALSE, PR_TRUE); |
| _pr_stderr = pt_SetMethods(2, PR_DESC_FILE, PR_FALSE, PR_TRUE); |
| PR_ASSERT(_pr_stdin && _pr_stdout && _pr_stderr); |
| |
| #ifdef _PR_IPV6_V6ONLY_PROBE |
| /* In Mac OS X v10.3 Panther Beta the IPV6_V6ONLY socket option |
| * is turned on by default, contrary to what RFC 3493, Section |
| * 5.3 says. So we have to turn it off. Find out whether we |
| * are running on such a system. |
| */ |
| { |
| int osfd; |
| osfd = socket(AF_INET6, SOCK_STREAM, 0); |
| if (osfd != -1) { |
| int on; |
| socklen_t optlen = sizeof(on); |
| if (getsockopt(osfd, IPPROTO_IPV6, IPV6_V6ONLY, |
| &on, &optlen) == 0) { |
| _pr_ipv6_v6only_on_by_default = on; |
| } |
| close(osfd); |
| } |
| } |
| #endif |
| } /* _PR_InitIO */ |
| |
| void _PR_CleanupIO(void) |
| { |
| _PR_Putfd(_pr_stdin); |
| _pr_stdin = NULL; |
| _PR_Putfd(_pr_stdout); |
| _pr_stdout = NULL; |
| _PR_Putfd(_pr_stderr); |
| _pr_stderr = NULL; |
| |
| _PR_CleanupFdCache(); |
| |
| if (_pr_flock_cv) |
| { |
| PR_DestroyCondVar(_pr_flock_cv); |
| _pr_flock_cv = NULL; |
| } |
| if (_pr_flock_lock) |
| { |
| PR_DestroyLock(_pr_flock_lock); |
| _pr_flock_lock = NULL; |
| } |
| if (_pr_rename_lock) |
| { |
| PR_DestroyLock(_pr_rename_lock); |
| _pr_rename_lock = NULL; |
| } |
| } /* _PR_CleanupIO */ |
| |
| PR_IMPLEMENT(PRFileDesc*) PR_GetSpecialFD(PRSpecialFD osfd) |
| { |
| PRFileDesc *result = NULL; |
| PR_ASSERT(osfd >= PR_StandardInput && osfd <= PR_StandardError); |
| |
| if (!_pr_initialized) _PR_ImplicitInitialization(); |
| |
| switch (osfd) |
| { |
| case PR_StandardInput: result = _pr_stdin; break; |
| case PR_StandardOutput: result = _pr_stdout; break; |
| case PR_StandardError: result = _pr_stderr; break; |
| default: |
| (void)PR_SetError(PR_INVALID_ARGUMENT_ERROR, 0); |
| } |
| return result; |
| } /* PR_GetSpecialFD */ |
| |
| /*****************************************************************************/ |
| /***************************** I/O private methods ***************************/ |
| /*****************************************************************************/ |
| |
| static PRBool pt_TestAbort(void) |
| { |
| PRThread *me = PR_GetCurrentThread(); |
| if(_PT_THREAD_INTERRUPTED(me)) |
| { |
| PR_SetError(PR_PENDING_INTERRUPT_ERROR, 0); |
| me->state &= ~PT_THREAD_ABORTED; |
| return PR_TRUE; |
| } |
| return PR_FALSE; |
| } /* pt_TestAbort */ |
| |
| static void pt_MapError(void (*mapper)(PRIntn), PRIntn syserrno) |
| { |
| switch (syserrno) |
| { |
| case EINTR: |
| PR_SetError(PR_PENDING_INTERRUPT_ERROR, 0); break; |
| case ETIMEDOUT: |
| PR_SetError(PR_IO_TIMEOUT_ERROR, 0); break; |
| default: |
| mapper(syserrno); |
| } |
| } /* pt_MapError */ |
| |
| static PRStatus pt_Close(PRFileDesc *fd) |
| { |
| if ((NULL == fd) || (NULL == fd->secret) |
| || ((_PR_FILEDESC_OPEN != fd->secret->state) |
| && (_PR_FILEDESC_CLOSED != fd->secret->state))) |
| { |
| PR_SetError(PR_BAD_DESCRIPTOR_ERROR, 0); |
| return PR_FAILURE; |
| } |
| if (pt_TestAbort()) return PR_FAILURE; |
| |
| if (_PR_FILEDESC_OPEN == fd->secret->state) |
| { |
| if (-1 == close(fd->secret->md.osfd)) |
| { |
| #ifdef OSF1 |
| /* |
| * Bug 86941: On Tru64 UNIX V5.0A and V5.1, the close() |
| * system call, when called to close a TCP socket, may |
| * return -1 with errno set to EINVAL but the system call |
| * does close the socket successfully. An application |
| * may safely ignore the EINVAL error. This bug is fixed |
| * on Tru64 UNIX V5.1A and later. The defect tracking |
| * number is QAR 81431. |
| */ |
| if (PR_DESC_SOCKET_TCP != fd->methods->file_type |
| || EINVAL != errno) |
| { |
| pt_MapError(_PR_MD_MAP_CLOSE_ERROR, errno); |
| return PR_FAILURE; |
| } |
| #else |
| pt_MapError(_PR_MD_MAP_CLOSE_ERROR, errno); |
| return PR_FAILURE; |
| #endif |
| } |
| fd->secret->state = _PR_FILEDESC_CLOSED; |
| } |
| _PR_Putfd(fd); |
| return PR_SUCCESS; |
| } /* pt_Close */ |
| |
| static PRInt32 pt_Read(PRFileDesc *fd, void *buf, PRInt32 amount) |
| { |
| PRInt32 syserrno, bytes = -1; |
| |
| if (pt_TestAbort()) return bytes; |
| |
| bytes = read(fd->secret->md.osfd, buf, amount); |
| syserrno = errno; |
| |
| if ((bytes == -1) && (syserrno == EWOULDBLOCK || syserrno == EAGAIN) |
| && (!fd->secret->nonblocking)) |
| { |
| pt_Continuation op; |
| op.arg1.osfd = fd->secret->md.osfd; |
| op.arg2.buffer = buf; |
| op.arg3.amount = amount; |
| op.timeout = PR_INTERVAL_NO_TIMEOUT; |
| op.function = pt_read_cont; |
| op.event = POLLIN | POLLPRI; |
| bytes = pt_Continue(&op); |
| syserrno = op.syserrno; |
| } |
| if (bytes < 0) |
| pt_MapError(_PR_MD_MAP_READ_ERROR, syserrno); |
| return bytes; |
| } /* pt_Read */ |
| |
| static PRInt32 pt_Write(PRFileDesc *fd, const void *buf, PRInt32 amount) |
| { |
| PRInt32 syserrno, bytes = -1; |
| PRBool fNeedContinue = PR_FALSE; |
| |
| if (pt_TestAbort()) return bytes; |
| |
| bytes = write(fd->secret->md.osfd, buf, amount); |
| syserrno = errno; |
| |
| if ( (bytes >= 0) && (bytes < amount) && (!fd->secret->nonblocking) ) |
| { |
| buf = (char *) buf + bytes; |
| amount -= bytes; |
| fNeedContinue = PR_TRUE; |
| } |
| if ( (bytes == -1) && (syserrno == EWOULDBLOCK || syserrno == EAGAIN) |
| && (!fd->secret->nonblocking) ) |
| { |
| bytes = 0; |
| fNeedContinue = PR_TRUE; |
| } |
| |
| if (fNeedContinue == PR_TRUE) |
| { |
| pt_Continuation op; |
| op.arg1.osfd = fd->secret->md.osfd; |
| op.arg2.buffer = (void*)buf; |
| op.arg3.amount = amount; |
| op.timeout = PR_INTERVAL_NO_TIMEOUT; |
| op.result.code = bytes; /* initialize the number sent */ |
| op.function = pt_write_cont; |
| op.event = POLLOUT | POLLPRI; |
| bytes = pt_Continue(&op); |
| syserrno = op.syserrno; |
| } |
| if (bytes == -1) |
| pt_MapError(_PR_MD_MAP_WRITE_ERROR, syserrno); |
| return bytes; |
| } /* pt_Write */ |
| |
| static PRInt32 pt_Writev( |
| PRFileDesc *fd, const PRIOVec *iov, PRInt32 iov_len, PRIntervalTime timeout) |
| { |
| PRIntn iov_index; |
| PRBool fNeedContinue = PR_FALSE; |
| PRInt32 syserrno, bytes, rv = -1; |
| struct iovec osiov_local[PR_MAX_IOVECTOR_SIZE], *osiov; |
| int osiov_len; |
| |
| if (pt_TestAbort()) return rv; |
| |
| /* Ensured by PR_Writev */ |
| PR_ASSERT(iov_len <= 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. We can modify osiov if we need to |
| * continue the operation. |
| */ |
| osiov = osiov_local; |
| osiov_len = iov_len; |
| for (iov_index = 0; iov_index < osiov_len; iov_index++) |
| { |
| osiov[iov_index].iov_base = iov[iov_index].iov_base; |
| osiov[iov_index].iov_len = iov[iov_index].iov_len; |
| } |
| |
| rv = bytes = writev(fd->secret->md.osfd, osiov, osiov_len); |
| syserrno = errno; |
| |
| if (!fd->secret->nonblocking) |
| { |
| if (bytes >= 0) |
| { |
| /* |
| * If we moved some bytes, how does that implicate the |
| * i/o vector list? In other words, exactly where are |
| * we within that array? What are the parameters for |
| * resumption? Maybe we're done! |
| */ |
| for ( ;osiov_len > 0; osiov++, osiov_len--) |
| { |
| if (bytes < osiov->iov_len) |
| { |
| /* this one's not done yet */ |
| osiov->iov_base = (char*)osiov->iov_base + bytes; |
| osiov->iov_len -= bytes; |
| break; /* go off and do that */ |
| } |
| bytes -= osiov->iov_len; /* this one's done cooked */ |
| } |
| PR_ASSERT(osiov_len > 0 || bytes == 0); |
| if (osiov_len > 0) |
| { |
| if (PR_INTERVAL_NO_WAIT == timeout) |
| { |
| rv = -1; |
| syserrno = ETIMEDOUT; |
| } |
| else fNeedContinue = PR_TRUE; |
| } |
| } |
| else if (syserrno == EWOULDBLOCK || syserrno == EAGAIN) |
| { |
| if (PR_INTERVAL_NO_WAIT == timeout) syserrno = ETIMEDOUT; |
| else |
| { |
| rv = 0; |
| fNeedContinue = PR_TRUE; |
| } |
| } |
| } |
| |
| if (fNeedContinue == PR_TRUE) |
| { |
| pt_Continuation op; |
| |
| op.arg1.osfd = fd->secret->md.osfd; |
| op.arg2.buffer = (void*)osiov; |
| op.arg3.amount = osiov_len; |
| op.timeout = timeout; |
| op.result.code = rv; |
| op.function = pt_writev_cont; |
| op.event = POLLOUT | POLLPRI; |
| rv = pt_Continue(&op); |
| syserrno = op.syserrno; |
| } |
| if (rv == -1) pt_MapError(_PR_MD_MAP_WRITEV_ERROR, syserrno); |
| return rv; |
| } /* pt_Writev */ |
| |
| static PRInt32 pt_Seek(PRFileDesc *fd, PRInt32 offset, PRSeekWhence whence) |
| { |
| return _PR_MD_LSEEK(fd, offset, whence); |
| } /* pt_Seek */ |
| |
| static PRInt64 pt_Seek64(PRFileDesc *fd, PRInt64 offset, PRSeekWhence whence) |
| { |
| return _PR_MD_LSEEK64(fd, offset, whence); |
| } /* pt_Seek64 */ |
| |
| static PRInt32 pt_Available_f(PRFileDesc *fd) |
| { |
| PRInt32 result, cur, end; |
| |
| cur = _PR_MD_LSEEK(fd, 0, PR_SEEK_CUR); |
| |
| if (cur >= 0) |
| end = _PR_MD_LSEEK(fd, 0, PR_SEEK_END); |
| |
| if ((cur < 0) || (end < 0)) { |
| return -1; |
| } |
| |
| result = end - cur; |
| _PR_MD_LSEEK(fd, cur, PR_SEEK_SET); |
| |
| return result; |
| } /* pt_Available_f */ |
| |
| static PRInt64 pt_Available64_f(PRFileDesc *fd) |
| { |
| PRInt64 result, cur, end; |
| PRInt64 minus_one; |
| |
| LL_I2L(minus_one, -1); |
| cur = _PR_MD_LSEEK64(fd, LL_ZERO, PR_SEEK_CUR); |
| |
| if (LL_GE_ZERO(cur)) |
| end = _PR_MD_LSEEK64(fd, LL_ZERO, PR_SEEK_END); |
| |
| if (!LL_GE_ZERO(cur) || !LL_GE_ZERO(end)) return minus_one; |
| |
| LL_SUB(result, end, cur); |
| (void)_PR_MD_LSEEK64(fd, cur, PR_SEEK_SET); |
| |
| return result; |
| } /* pt_Available64_f */ |
| |
| static PRInt32 pt_Available_s(PRFileDesc *fd) |
| { |
| PRInt32 rv, bytes = -1; |
| if (pt_TestAbort()) return bytes; |
| |
| rv = ioctl(fd->secret->md.osfd, FIONREAD, &bytes); |
| |
| if (rv == -1) |
| pt_MapError(_PR_MD_MAP_SOCKETAVAILABLE_ERROR, errno); |
| return bytes; |
| } /* pt_Available_s */ |
| |
| static PRInt64 pt_Available64_s(PRFileDesc *fd) |
| { |
| PRInt64 rv; |
| LL_I2L(rv, pt_Available_s(fd)); |
| return rv; |
| } /* pt_Available64_s */ |
| |
| static PRStatus pt_FileInfo(PRFileDesc *fd, PRFileInfo *info) |
| { |
| PRInt32 rv = _PR_MD_GETOPENFILEINFO(fd, info); |
| return (-1 == rv) ? PR_FAILURE : PR_SUCCESS; |
| } /* pt_FileInfo */ |
| |
| static PRStatus pt_FileInfo64(PRFileDesc *fd, PRFileInfo64 *info) |
| { |
| PRInt32 rv = _PR_MD_GETOPENFILEINFO64(fd, info); |
| return (-1 == rv) ? PR_FAILURE : PR_SUCCESS; |
| } /* pt_FileInfo64 */ |
| |
| static PRStatus pt_Synch(PRFileDesc *fd) |
| { |
| return (NULL == fd) ? PR_FAILURE : PR_SUCCESS; |
| } /* pt_Synch */ |
| |
| static PRStatus pt_Fsync(PRFileDesc *fd) |
| { |
| PRIntn rv = -1; |
| if (pt_TestAbort()) return PR_FAILURE; |
| |
| rv = fsync(fd->secret->md.osfd); |
| if (rv < 0) { |
| pt_MapError(_PR_MD_MAP_FSYNC_ERROR, errno); |
| return PR_FAILURE; |
| } |
| return PR_SUCCESS; |
| } /* pt_Fsync */ |
| |
| static PRStatus pt_Connect( |
| PRFileDesc *fd, const PRNetAddr *addr, PRIntervalTime timeout) |
| { |
| PRIntn rv = -1, syserrno; |
| pt_SockLen addr_len; |
| const PRNetAddr *addrp = addr; |
| #if defined(_PR_HAVE_SOCKADDR_LEN) || defined(_PR_INET6) |
| PRUint16 md_af = addr->raw.family; |
| PRNetAddr addrCopy; |
| #endif |
| |
| if (pt_TestAbort()) return PR_FAILURE; |
| |
| PR_ASSERT(IsValidNetAddr(addr) == PR_TRUE); |
| addr_len = PR_NETADDR_SIZE(addr); |
| #if defined(_PR_INET6) |
| if (addr->raw.family == PR_AF_INET6) { |
| md_af = AF_INET6; |
| #ifndef _PR_HAVE_SOCKADDR_LEN |
| addrCopy = *addr; |
| addrCopy.raw.family = AF_INET6; |
| addrp = &addrCopy; |
| #endif |
| } |
| #endif |
| |
| #ifdef _PR_HAVE_SOCKADDR_LEN |
| addrCopy = *addr; |
| ((struct sockaddr*)&addrCopy)->sa_len = addr_len; |
| ((struct sockaddr*)&addrCopy)->sa_family = md_af; |
| addrp = &addrCopy; |
| #endif |
| rv = connect(fd->secret->md.osfd, (struct sockaddr*)addrp, addr_len); |
| syserrno = errno; |
| if ((-1 == rv) && (EINPROGRESS == syserrno) && (!fd->secret->nonblocking)) |
| { |
| if (PR_INTERVAL_NO_WAIT == timeout) syserrno = ETIMEDOUT; |
| else |
| { |
| pt_Continuation op; |
| op.arg1.osfd = fd->secret->md.osfd; |
| op.arg2.buffer = (void*)addrp; |
| op.arg3.amount = addr_len; |
| op.timeout = timeout; |
| op.function = pt_connect_cont; |
| op.event = POLLOUT | POLLPRI; |
| rv = pt_Continue(&op); |
| syserrno = op.syserrno; |
| } |
| } |
| if (-1 == rv) { |
| pt_MapError(_PR_MD_MAP_CONNECT_ERROR, syserrno); |
| return PR_FAILURE; |
| } |
| return PR_SUCCESS; |
| } /* pt_Connect */ |
| |
| static PRStatus pt_ConnectContinue( |
| PRFileDesc *fd, PRInt16 out_flags) |
| { |
| int err; |
| PRInt32 osfd; |
| |
| if (out_flags & PR_POLL_NVAL) |
| { |
| PR_SetError(PR_BAD_DESCRIPTOR_ERROR, 0); |
| return PR_FAILURE; |
| } |
| if ((out_flags & (PR_POLL_WRITE | PR_POLL_EXCEPT | PR_POLL_ERR |
| | PR_POLL_HUP)) == 0) |
| { |
| PR_ASSERT(out_flags == 0); |
| PR_SetError(PR_IN_PROGRESS_ERROR, 0); |
| return PR_FAILURE; |
| } |
| |
| osfd = fd->secret->md.osfd; |
| |
| err = _MD_unix_get_nonblocking_connect_error(osfd); |
| if (err != 0) |
| { |
| _PR_MD_MAP_CONNECT_ERROR(err); |
| return PR_FAILURE; |
| } |
| return PR_SUCCESS; |
| } /* pt_ConnectContinue */ |
| |
| PR_IMPLEMENT(PRStatus) PR_GetConnectStatus(const PRPollDesc *pd) |
| { |
| /* Find the NSPR layer and invoke its connectcontinue method */ |
| PRFileDesc *bottom = PR_GetIdentitiesLayer(pd->fd, PR_NSPR_IO_LAYER); |
| |
| if (NULL == bottom) |
| { |
| PR_SetError(PR_INVALID_ARGUMENT_ERROR, 0); |
| return PR_FAILURE; |
| } |
| return pt_ConnectContinue(bottom, pd->out_flags); |
| } /* PR_GetConnectStatus */ |
| |
| static PRFileDesc* pt_Accept( |
| PRFileDesc *fd, PRNetAddr *addr, PRIntervalTime timeout) |
| { |
| PRFileDesc *newfd = NULL; |
| PRIntn syserrno, osfd = -1; |
| pt_SockLen addr_len = sizeof(PRNetAddr); |
| #ifdef SYMBIAN |
| PRNetAddr dummy_addr; |
| #endif |
| |
| if (pt_TestAbort()) return newfd; |
| |
| #ifdef SYMBIAN |
| /* On Symbian OS, accept crashes if addr is NULL. */ |
| if (!addr) |
| addr = &dummy_addr; |
| #endif |
| |
| #ifdef _PR_STRICT_ADDR_LEN |
| if (addr) |
| { |
| /* |
| * Set addr->raw.family just so that we can use the |
| * PR_NETADDR_SIZE macro. |
| */ |
| addr->raw.family = fd->secret->af; |
| addr_len = PR_NETADDR_SIZE(addr); |
| } |
| #endif |
| |
| osfd = accept(fd->secret->md.osfd, (struct sockaddr*)addr, &addr_len); |
| syserrno = errno; |
| |
| if (osfd == -1) |
| { |
| if (fd->secret->nonblocking) goto failed; |
| |
| if (EWOULDBLOCK != syserrno && EAGAIN != syserrno |
| && ECONNABORTED != syserrno) |
| goto failed; |
| else |
| { |
| if (PR_INTERVAL_NO_WAIT == timeout) syserrno = ETIMEDOUT; |
| else |
| { |
| pt_Continuation op; |
| op.arg1.osfd = fd->secret->md.osfd; |
| op.arg2.buffer = addr; |
| op.arg3.addr_len = &addr_len; |
| op.timeout = timeout; |
| op.function = pt_accept_cont; |
| op.event = POLLIN | POLLPRI; |
| osfd = pt_Continue(&op); |
| syserrno = op.syserrno; |
| } |
| if (osfd < 0) goto failed; |
| } |
| } |
| #ifdef _PR_HAVE_SOCKADDR_LEN |
| /* ignore the sa_len field of struct sockaddr */ |
| if (addr) |
| { |
| addr->raw.family = ((struct sockaddr*)addr)->sa_family; |
| } |
| #endif /* _PR_HAVE_SOCKADDR_LEN */ |
| #ifdef _PR_INET6 |
| if (addr && (AF_INET6 == addr->raw.family)) |
| addr->raw.family = PR_AF_INET6; |
| #endif |
| newfd = pt_SetMethods(osfd, PR_DESC_SOCKET_TCP, PR_TRUE, PR_FALSE); |
| if (newfd == NULL) close(osfd); /* $$$ whoops! this doesn't work $$$ */ |
| else |
| { |
| PR_ASSERT(IsValidNetAddr(addr) == PR_TRUE); |
| PR_ASSERT(IsValidNetAddrLen(addr, addr_len) == PR_TRUE); |
| #ifdef LINUX |
| /* |
| * On Linux, experiments showed that the accepted sockets |
| * inherit the TCP_NODELAY socket option of the listening |
| * socket. |
| */ |
| newfd->secret->md.tcp_nodelay = fd->secret->md.tcp_nodelay; |
| #endif |
| } |
| return newfd; |
| |
| failed: |
| pt_MapError(_PR_MD_MAP_ACCEPT_ERROR, syserrno); |
| return NULL; |
| } /* pt_Accept */ |
| |
| static PRStatus pt_Bind(PRFileDesc *fd, const PRNetAddr *addr) |
| { |
| PRIntn rv; |
| pt_SockLen addr_len; |
| const PRNetAddr *addrp = addr; |
| #if defined(_PR_HAVE_SOCKADDR_LEN) || defined(_PR_INET6) |
| PRUint16 md_af = addr->raw.family; |
| PRNetAddr addrCopy; |
| #endif |
| |
| if (pt_TestAbort()) return PR_FAILURE; |
| |
| PR_ASSERT(IsValidNetAddr(addr) == PR_TRUE); |
| if (addr->raw.family == AF_UNIX) |
| { |
| /* Disallow relative pathnames */ |
| if (addr->local.path[0] != '/') |
| { |
| PR_SetError(PR_INVALID_ARGUMENT_ERROR, 0); |
| return PR_FAILURE; |
| } |
| } |
| |
| #if defined(_PR_INET6) |
| if (addr->raw.family == PR_AF_INET6) { |
| md_af = AF_INET6; |
| #ifndef _PR_HAVE_SOCKADDR_LEN |
| addrCopy = *addr; |
| addrCopy.raw.family = AF_INET6; |
| addrp = &addrCopy; |
| #endif |
| } |
| #endif |
| |
| addr_len = PR_NETADDR_SIZE(addr); |
| #ifdef _PR_HAVE_SOCKADDR_LEN |
| addrCopy = *addr; |
| ((struct sockaddr*)&addrCopy)->sa_len = addr_len; |
| ((struct sockaddr*)&addrCopy)->sa_family = md_af; |
| addrp = &addrCopy; |
| #endif |
| rv = bind(fd->secret->md.osfd, (struct sockaddr*)addrp, addr_len); |
| |
| if (rv == -1) { |
| pt_MapError(_PR_MD_MAP_BIND_ERROR, errno); |
| return PR_FAILURE; |
| } |
| return PR_SUCCESS; |
| } /* pt_Bind */ |
| |
| static PRStatus pt_Listen(PRFileDesc *fd, PRIntn backlog) |
| { |
| PRIntn rv; |
| |
| if (pt_TestAbort()) return PR_FAILURE; |
| |
| rv = listen(fd->secret->md.osfd, backlog); |
| if (rv == -1) { |
| pt_MapError(_PR_MD_MAP_LISTEN_ERROR, errno); |
| return PR_FAILURE; |
| } |
| return PR_SUCCESS; |
| } /* pt_Listen */ |
| |
| static PRStatus pt_Shutdown(PRFileDesc *fd, PRIntn how) |
| { |
| PRIntn rv = -1; |
| if (pt_TestAbort()) return PR_FAILURE; |
| |
| rv = shutdown(fd->secret->md.osfd, how); |
| |
| if (rv == -1) { |
| pt_MapError(_PR_MD_MAP_SHUTDOWN_ERROR, errno); |
| return PR_FAILURE; |
| } |
| return PR_SUCCESS; |
| } /* pt_Shutdown */ |
| |
| static PRInt16 pt_Poll(PRFileDesc *fd, PRInt16 in_flags, PRInt16 *out_flags) |
| { |
| *out_flags = 0; |
| return in_flags; |
| } /* pt_Poll */ |
| |
| static PRInt32 pt_Recv( |
| PRFileDesc *fd, void *buf, PRInt32 amount, |
| PRIntn flags, PRIntervalTime timeout) |
| { |
| PRInt32 syserrno, bytes = -1; |
| PRIntn osflags; |
| |
| if (0 == flags) |
| osflags = 0; |
| else if (PR_MSG_PEEK == flags) |
| { |
| #ifdef SYMBIAN |
| /* MSG_PEEK doesn't work as expected. */ |
| PR_SetError(PR_NOT_IMPLEMENTED_ERROR, 0); |
| return bytes; |
| #else |
| osflags = MSG_PEEK; |
| #endif |
| } |
| else |
| { |
| PR_SetError(PR_INVALID_ARGUMENT_ERROR, 0); |
| return bytes; |
| } |
| |
| if (pt_TestAbort()) return bytes; |
| |
| /* recv() is a much slower call on pre-2.6 Solaris than read(). */ |
| #if defined(SOLARIS) |
| if (0 == osflags) |
| bytes = read(fd->secret->md.osfd, buf, amount); |
| else |
| bytes = recv(fd->secret->md.osfd, buf, amount, osflags); |
| #else |
| bytes = recv(fd->secret->md.osfd, buf, amount, osflags); |
| #endif |
| syserrno = errno; |
| |
| if ((bytes == -1) && (syserrno == EWOULDBLOCK || syserrno == EAGAIN) |
| && (!fd->secret->nonblocking)) |
| { |
| if (PR_INTERVAL_NO_WAIT == timeout) syserrno = ETIMEDOUT; |
| else |
| { |
| pt_Continuation op; |
| op.arg1.osfd = fd->secret->md.osfd; |
| op.arg2.buffer = buf; |
| op.arg3.amount = amount; |
| op.arg4.flags = osflags; |
| op.timeout = timeout; |
| op.function = pt_recv_cont; |
| op.event = POLLIN | POLLPRI; |
| bytes = pt_Continue(&op); |
| syserrno = op.syserrno; |
| } |
| } |
| if (bytes < 0) |
| pt_MapError(_PR_MD_MAP_RECV_ERROR, syserrno); |
| return bytes; |
| } /* pt_Recv */ |
| |
| static PRInt32 pt_SocketRead(PRFileDesc *fd, void *buf, PRInt32 amount) |
| { |
| return pt_Recv(fd, buf, amount, 0, PR_INTERVAL_NO_TIMEOUT); |
| } /* pt_SocketRead */ |
| |
| static PRInt32 pt_Send( |
| PRFileDesc *fd, const void *buf, PRInt32 amount, |
| PRIntn flags, PRIntervalTime timeout) |
| { |
| PRInt32 syserrno, bytes = -1; |
| PRBool fNeedContinue = PR_FALSE; |
| #if defined(SOLARIS) |
| PRInt32 tmp_amount = amount; |
| #endif |
| |
| /* |
| * Under HP-UX DCE threads, pthread.h includes dce/cma_ux.h, |
| * which has the following: |
| * # define send cma_send |
| * extern int cma_send (int , void *, int, int ); |
| * So we need to cast away the 'const' of argument #2 for send(). |
| */ |
| #if defined (HPUX) && defined(_PR_DCETHREADS) |
| #define PT_SENDBUF_CAST (void *) |
| #else |
| #define PT_SENDBUF_CAST |
| #endif |
| |
| if (pt_TestAbort()) return bytes; |
| |
| /* |
| * On pre-2.6 Solaris, send() is much slower than write(). |
| * On 2.6 and beyond, with in-kernel sockets, send() and |
| * write() are fairly equivalent in performance. |
| */ |
| #if defined(SOLARIS) |
| PR_ASSERT(0 == flags); |
| retry: |
| bytes = write(fd->secret->md.osfd, PT_SENDBUF_CAST buf, tmp_amount); |
| #else |
| bytes = send(fd->secret->md.osfd, PT_SENDBUF_CAST buf, amount, flags); |
| #endif |
| syserrno = errno; |
| |
| #if defined(SOLARIS) |
| /* |
| * The write system call has been reported to return the ERANGE error |
| * on occasion. Try to write in smaller chunks to workaround this bug. |
| */ |
| if ((bytes == -1) && (syserrno == ERANGE)) |
| { |
| if (tmp_amount > 1) |
| { |
| tmp_amount = tmp_amount/2; /* half the bytes */ |
| goto retry; |
| } |
| } |
| #endif |
| |
| if ( (bytes >= 0) && (bytes < amount) && (!fd->secret->nonblocking) ) |
| { |
| if (PR_INTERVAL_NO_WAIT == timeout) |
| { |
| bytes = -1; |
| syserrno = ETIMEDOUT; |
| } |
| else |
| { |
| buf = (char *) buf + bytes; |
| amount -= bytes; |
| fNeedContinue = PR_TRUE; |
| } |
| } |
| if ( (bytes == -1) && (syserrno == EWOULDBLOCK || syserrno == EAGAIN) |
| && (!fd->secret->nonblocking) ) |
| { |
| if (PR_INTERVAL_NO_WAIT == timeout) syserrno = ETIMEDOUT; |
| else |
| { |
| bytes = 0; |
| fNeedContinue = PR_TRUE; |
| } |
| } |
| |
| if (fNeedContinue == PR_TRUE) |
| { |
| pt_Continuation op; |
| op.arg1.osfd = fd->secret->md.osfd; |
| op.arg2.buffer = (void*)buf; |
| op.arg3.amount = amount; |
| op.arg4.flags = flags; |
| op.timeout = timeout; |
| op.result.code = bytes; /* initialize the number sent */ |
| op.function = pt_send_cont; |
| op.event = POLLOUT | POLLPRI; |
| bytes = pt_Continue(&op); |
| syserrno = op.syserrno; |
| } |
| if (bytes == -1) |
| pt_MapError(_PR_MD_MAP_SEND_ERROR, syserrno); |
| return bytes; |
| } /* pt_Send */ |
| |
| static PRInt32 pt_SocketWrite(PRFileDesc *fd, const void *buf, PRInt32 amount) |
| { |
| return pt_Send(fd, buf, amount, 0, PR_INTERVAL_NO_TIMEOUT); |
| } /* pt_SocketWrite */ |
| |
| static PRInt32 pt_SendTo( |
| PRFileDesc *fd, const void *buf, |
| PRInt32 amount, PRIntn flags, const PRNetAddr *addr, |
| PRIntervalTime timeout) |
| { |
| PRInt32 syserrno, bytes = -1; |
| PRBool fNeedContinue = PR_FALSE; |
| pt_SockLen addr_len; |
| const PRNetAddr *addrp = addr; |
| #if defined(_PR_HAVE_SOCKADDR_LEN) || defined(_PR_INET6) |
| PRUint16 md_af = addr->raw.family; |
| PRNetAddr addrCopy; |
| #endif |
| |
| if (pt_TestAbort()) return bytes; |
| |
| PR_ASSERT(IsValidNetAddr(addr) == PR_TRUE); |
| #if defined(_PR_INET6) |
| if (addr->raw.family == PR_AF_INET6) { |
| md_af = AF_INET6; |
| #ifndef _PR_HAVE_SOCKADDR_LEN |
| addrCopy = *addr; |
| addrCopy.raw.family = AF_INET6; |
| addrp = &addrCopy; |
| #endif |
| } |
| #endif |
| |
| addr_len = PR_NETADDR_SIZE(addr); |
| #ifdef _PR_HAVE_SOCKADDR_LEN |
| addrCopy = *addr; |
| ((struct sockaddr*)&addrCopy)->sa_len = addr_len; |
| ((struct sockaddr*)&addrCopy)->sa_family = md_af; |
| addrp = &addrCopy; |
| #endif |
| bytes = sendto( |
| fd->secret->md.osfd, buf, amount, flags, |
| (struct sockaddr*)addrp, addr_len); |
| syserrno = errno; |
| if ( (bytes == -1) && (syserrno == EWOULDBLOCK || syserrno == EAGAIN) |
| && (!fd->secret->nonblocking) ) |
| { |
| if (PR_INTERVAL_NO_WAIT == timeout) syserrno = ETIMEDOUT; |
| else fNeedContinue = PR_TRUE; |
| } |
| if (fNeedContinue == PR_TRUE) |
| { |
| pt_Continuation op; |
| op.arg1.osfd = fd->secret->md.osfd; |
| op.arg2.buffer = (void*)buf; |
| op.arg3.amount = amount; |
| op.arg4.flags = flags; |
| op.arg5.addr = (PRNetAddr*)addrp; |
| op.timeout = timeout; |
| op.result.code = 0; /* initialize the number sent */ |
| op.function = pt_sendto_cont; |
| op.event = POLLOUT | POLLPRI; |
| bytes = pt_Continue(&op); |
| syserrno = op.syserrno; |
| } |
| if (bytes < 0) |
| pt_MapError(_PR_MD_MAP_SENDTO_ERROR, syserrno); |
| return bytes; |
| } /* pt_SendTo */ |
| |
| static PRInt32 pt_RecvFrom(PRFileDesc *fd, void *buf, PRInt32 amount, |
| PRIntn flags, PRNetAddr *addr, PRIntervalTime timeout) |
| { |
| PRBool fNeedContinue = PR_FALSE; |
| PRInt32 syserrno, bytes = -1; |
| pt_SockLen addr_len = sizeof(PRNetAddr); |
| |
| if (pt_TestAbort()) return bytes; |
| |
| bytes = recvfrom( |
| fd->secret->md.osfd, buf, amount, flags, |
| (struct sockaddr*)addr, &addr_len); |
| syserrno = errno; |
| |
| if ( (bytes == -1) && (syserrno == EWOULDBLOCK || syserrno == EAGAIN) |
| && (!fd->secret->nonblocking) ) |
| { |
| if (PR_INTERVAL_NO_WAIT == timeout) syserrno = ETIMEDOUT; |
| else fNeedContinue = PR_TRUE; |
| } |
| |
| if (fNeedContinue == PR_TRUE) |
| { |
| pt_Continuation op; |
| op.arg1.osfd = fd->secret->md.osfd; |
| op.arg2.buffer = buf; |
| op.arg3.amount = amount; |
| op.arg4.flags = flags; |
| op.arg5.addr = addr; |
| op.timeout = timeout; |
| op.function = pt_recvfrom_cont; |
| op.event = POLLIN | POLLPRI; |
| bytes = pt_Continue(&op); |
| syserrno = op.syserrno; |
| } |
| if (bytes >= 0) |
| { |
| #ifdef _PR_HAVE_SOCKADDR_LEN |
| /* ignore the sa_len field of struct sockaddr */ |
| if (addr) |
| { |
| addr->raw.family = ((struct sockaddr*)addr)->sa_family; |
| } |
| #endif /* _PR_HAVE_SOCKADDR_LEN */ |
| #ifdef _PR_INET6 |
| if (addr && (AF_INET6 == addr->raw.family)) |
| addr->raw.family = PR_AF_INET6; |
| #endif |
| } |
| else |
| pt_MapError(_PR_MD_MAP_RECVFROM_ERROR, syserrno); |
| return bytes; |
| } /* pt_RecvFrom */ |
| |
| #ifdef AIX |
| #ifndef HAVE_SEND_FILE |
| static pthread_once_t pt_aix_sendfile_once_block = PTHREAD_ONCE_INIT; |
| |
| static void pt_aix_sendfile_init_routine(void) |
| { |
| void *handle = dlopen(NULL, RTLD_NOW | RTLD_GLOBAL); |
| pt_aix_sendfile_fptr = (ssize_t (*)()) dlsym(handle, "send_file"); |
| dlclose(handle); |
| } |
| |
| /* |
| * pt_AIXDispatchSendFile |
| */ |
| static PRInt32 pt_AIXDispatchSendFile(PRFileDesc *sd, PRSendFileData *sfd, |
| PRTransmitFileFlags flags, PRIntervalTime timeout) |
| { |
| int rv; |
| |
| rv = pthread_once(&pt_aix_sendfile_once_block, |
| pt_aix_sendfile_init_routine); |
| PR_ASSERT(0 == rv); |
| if (pt_aix_sendfile_fptr) { |
| return pt_AIXSendFile(sd, sfd, flags, timeout); |
| } else { |
| return PR_EmulateSendFile(sd, sfd, flags, timeout); |
| } |
| } |
| #endif /* !HAVE_SEND_FILE */ |
| |
| |
| /* |
| * pt_AIXSendFile |
| * |
| * Send file sfd->fd across socket sd. If specified, header and trailer |
| * buffers are sent before and after the file, respectively. |
| * |
| * PR_TRANSMITFILE_CLOSE_SOCKET flag - close socket after sending file |
| * |
| * return number of bytes sent or -1 on error |
| * |
| * This implementation takes advantage of the send_file() system |
| * call available in AIX 4.3.2. |
| */ |
| |
| static PRInt32 pt_AIXSendFile(PRFileDesc *sd, PRSendFileData *sfd, |
| PRTransmitFileFlags flags, PRIntervalTime timeout) |
| { |
| struct sf_parms sf_struct; |
| uint_t send_flags; |
| ssize_t rv; |
| int syserrno; |
| PRInt32 count; |
| unsigned long long saved_file_offset; |
| long long saved_file_bytes; |
| |
| sf_struct.header_data = (void *) sfd->header; /* cast away the 'const' */ |
| sf_struct.header_length = sfd->hlen; |
| sf_struct.file_descriptor = sfd->fd->secret->md.osfd; |
| sf_struct.file_size = 0; |
| sf_struct.file_offset = sfd->file_offset; |
| if (sfd->file_nbytes == 0) |
| sf_struct.file_bytes = -1; |
| else |
| sf_struct.file_bytes = sfd->file_nbytes; |
| sf_struct.trailer_data = (void *) sfd->trailer; |
| sf_struct.trailer_length = sfd->tlen; |
| sf_struct.bytes_sent = 0; |
| |
| saved_file_offset = sf_struct.file_offset; |
| saved_file_bytes = sf_struct.file_bytes; |
| |
| send_flags = 0; /* flags processed at the end */ |
| |
| /* The first argument to send_file() is int*. */ |
| PR_ASSERT(sizeof(int) == sizeof(sd->secret->md.osfd)); |
| do { |
| rv = AIX_SEND_FILE(&sd->secret->md.osfd, &sf_struct, send_flags); |
| } while (rv == -1 && (syserrno = errno) == EINTR); |
| |
| if (rv == -1) { |
| if (syserrno == EAGAIN || syserrno == EWOULDBLOCK) { |
| count = 0; /* Not a real error. Need to continue. */ |
| } else { |
| count = -1; |
| } |
| } else { |
| count = sf_struct.bytes_sent; |
| /* |
| * A bug in AIX 4.3.2 prevents the 'file_bytes' field from |
| * being updated. So, 'file_bytes' is maintained by NSPR to |
| * avoid conflict when this bug is fixed in AIX, in the future. |
| */ |
| if (saved_file_bytes != -1) |
| saved_file_bytes -= (sf_struct.file_offset - saved_file_offset); |
| sf_struct.file_bytes = saved_file_bytes; |
| } |
| |
| if ((rv == 1) || ((rv == -1) && (count == 0))) { |
| pt_Continuation op; |
| |
| op.arg1.osfd = sd->secret->md.osfd; |
| op.arg2.buffer = &sf_struct; |
| op.arg4.flags = send_flags; |
| op.result.code = count; |
| op.timeout = timeout; |
| op.function = pt_aix_sendfile_cont; |
| op.event = POLLOUT | POLLPRI; |
| count = pt_Continue(&op); |
| syserrno = op.syserrno; |
| } |
| |
| if (count == -1) { |
| pt_MapError(_MD_aix_map_sendfile_error, syserrno); |
| return -1; |
| } |
| if (flags & PR_TRANSMITFILE_CLOSE_SOCKET) { |
| PR_Close(sd); |
| } |
| PR_ASSERT(count == (sfd->hlen + sfd->tlen + |
| ((sfd->file_nbytes == 0) ? |
| sf_struct.file_size - sfd->file_offset : |
| sfd->file_nbytes))); |
| return count; |
| } |
| #endif /* AIX */ |
| |
| #ifdef HPUX11 |
| /* |
| * pt_HPUXSendFile |
| * |
| * Send file sfd->fd across socket sd. If specified, header and trailer |
| * buffers are sent before and after the file, respectively. |
| * |
| * PR_TRANSMITFILE_CLOSE_SOCKET flag - close socket after sending file |
| * |
| * return number of bytes sent or -1 on error |
| * |
| * This implementation takes advantage of the sendfile() system |
| * call available in HP-UX B.11.00. |
| */ |
| |
| static PRInt32 pt_HPUXSendFile(PRFileDesc *sd, PRSendFileData *sfd, |
| PRTransmitFileFlags flags, PRIntervalTime timeout) |
| { |
| struct stat statbuf; |
| size_t nbytes_to_send, file_nbytes_to_send; |
| struct iovec hdtrl[2]; /* optional header and trailer buffers */ |
| int send_flags; |
| PRInt32 count; |
| int syserrno; |
| |
| if (sfd->file_nbytes == 0) { |
| /* Get file size */ |
| if (fstat(sfd->fd->secret->md.osfd, &statbuf) == -1) { |
| _PR_MD_MAP_FSTAT_ERROR(errno); |
| return -1; |
| } |
| file_nbytes_to_send = statbuf.st_size - sfd->file_offset; |
| } else { |
| file_nbytes_to_send = sfd->file_nbytes; |
| } |
| nbytes_to_send = sfd->hlen + sfd->tlen + file_nbytes_to_send; |
| |
| hdtrl[0].iov_base = (void *) sfd->header; /* cast away the 'const' */ |
| hdtrl[0].iov_len = sfd->hlen; |
| hdtrl[1].iov_base = (void *) sfd->trailer; |
| hdtrl[1].iov_len = sfd->tlen; |
| /* |
| * SF_DISCONNECT seems to close the socket even if sendfile() |
| * only does a partial send on a nonblocking socket. This |
| * would prevent the subsequent sendfile() calls on that socket |
| * from working. So we don't use the SD_DISCONNECT flag. |
| */ |
| send_flags = 0; |
| |
| do { |
| count = sendfile(sd->secret->md.osfd, sfd->fd->secret->md.osfd, |
| sfd->file_offset, file_nbytes_to_send, hdtrl, send_flags); |
| } while (count == -1 && (syserrno = errno) == EINTR); |
| |
| if (count == -1 && (syserrno == EAGAIN || syserrno == EWOULDBLOCK)) { |
| count = 0; |
| } |
| if (count != -1 && count < nbytes_to_send) { |
| pt_Continuation op; |
| |
| if (count < sfd->hlen) { |
| /* header not sent */ |
| |
| hdtrl[0].iov_base = ((char *) sfd->header) + count; |
| hdtrl[0].iov_len = sfd->hlen - count; |
| op.arg3.file_spec.offset = sfd->file_offset; |
| op.arg3.file_spec.nbytes = file_nbytes_to_send; |
| } else if (count < (sfd->hlen + file_nbytes_to_send)) { |
| /* header sent, file not sent */ |
| |
| hdtrl[0].iov_base = NULL; |
| hdtrl[0].iov_len = 0; |
| |
| op.arg3.file_spec.offset = sfd->file_offset + count - sfd->hlen; |
| op.arg3.file_spec.nbytes = file_nbytes_to_send - (count - sfd->hlen); |
| } else if (count < (sfd->hlen + file_nbytes_to_send + sfd->tlen)) { |
| PRUint32 trailer_nbytes_sent; |
| |
| /* header sent, file sent, trailer not sent */ |
| |
| hdtrl[0].iov_base = NULL; |
| hdtrl[0].iov_len = 0; |
| /* |
| * set file offset and len so that no more file data is |
| * sent |
| */ |
| op.arg3.file_spec.offset = statbuf.st_size; |
| op.arg3.file_spec.nbytes = 0; |
| |
| trailer_nbytes_sent = count - sfd->hlen - file_nbytes_to_send; |
| hdtrl[1].iov_base = ((char *) sfd->trailer) + trailer_nbytes_sent; |
| hdtrl[1].iov_len = sfd->tlen - trailer_nbytes_sent; |
| } |
| |
| op.arg1.osfd = sd->secret->md.osfd; |
| op.filedesc = sfd->fd->secret->md.osfd; |
| op.arg2.buffer = hdtrl; |
| op.arg3.file_spec.st_size = statbuf.st_size; |
| op.arg4.flags = send_flags; |
| op.nbytes_to_send = nbytes_to_send - count; |
| op.result.code = count; |
| op.timeout = timeout; |
| op.function = pt_hpux_sendfile_cont; |
| op.event = POLLOUT | POLLPRI; |
| count = pt_Continue(&op); |
| syserrno = op.syserrno; |
| } |
| |
| if (count == -1) { |
| pt_MapError(_MD_hpux_map_sendfile_error, syserrno); |
| return -1; |
| } |
| if (flags & PR_TRANSMITFILE_CLOSE_SOCKET) { |
| PR_Close(sd); |
| } |
| PR_ASSERT(count == nbytes_to_send); |
| return count; |
| } |
| |
| #endif /* HPUX11 */ |
| |
| #ifdef SOLARIS |
| |
| /* |
| * pt_SolarisSendFile |
| * |
| * Send file sfd->fd across socket sd. If specified, header and trailer |
| * buffers are sent before and after the file, respectively. |
| * |
| * PR_TRANSMITFILE_CLOSE_SOCKET flag - close socket after sending file |
| * |
| * return number of bytes sent or -1 on error |
| * |
| * This implementation takes advantage of the sendfilev() system |
| * call available in Solaris 8. |
| */ |
| |
| static PRInt32 pt_SolarisSendFile(PRFileDesc *sd, PRSendFileData *sfd, |
| PRTransmitFileFlags flags, PRIntervalTime timeout) |
| { |
| struct stat statbuf; |
| size_t nbytes_to_send, file_nbytes_to_send; |
| struct sendfilevec sfv_struct[3]; |
| int sfvcnt = 0; |
| size_t xferred; |
| PRInt32 count; |
| int syserrno; |
| |
| if (sfd->file_nbytes == 0) { |
| /* Get file size */ |
| if (fstat(sfd->fd->secret->md.osfd, &statbuf) == -1) { |
| _PR_MD_MAP_FSTAT_ERROR(errno); |
| return -1; |
| } |
| file_nbytes_to_send = statbuf.st_size - sfd->file_offset; |
| } else { |
| file_nbytes_to_send = sfd->file_nbytes; |
| } |
| |
| nbytes_to_send = sfd->hlen + sfd->tlen + file_nbytes_to_send; |
| |
| if (sfd->hlen != 0) { |
| sfv_struct[sfvcnt].sfv_fd = SFV_FD_SELF; |
| sfv_struct[sfvcnt].sfv_flag = 0; |
| sfv_struct[sfvcnt].sfv_off = (off_t) sfd->header; |
| sfv_struct[sfvcnt].sfv_len = sfd->hlen; |
| sfvcnt++; |
| } |
| |
| if (file_nbytes_to_send != 0) { |
| sfv_struct[sfvcnt].sfv_fd = sfd->fd->secret->md.osfd; |
| sfv_struct[sfvcnt].sfv_flag = 0; |
| sfv_struct[sfvcnt].sfv_off = sfd->file_offset; |
| sfv_struct[sfvcnt].sfv_len = file_nbytes_to_send; |
| sfvcnt++; |
| } |
| |
| if (sfd->tlen != 0) { |
| sfv_struct[sfvcnt].sfv_fd = SFV_FD_SELF; |
| sfv_struct[sfvcnt].sfv_flag = 0; |
| sfv_struct[sfvcnt].sfv_off = (off_t) sfd->trailer; |
| sfv_struct[sfvcnt].sfv_len = sfd->tlen; |
| sfvcnt++; |
| } |
| |
| if (0 == sfvcnt) { |
| count = 0; |
| goto done; |
| } |
| |
| /* |
| * Strictly speaking, we may have sent some bytes when the |
| * sendfilev() is interrupted and we should retry it from an |
| * updated offset. We are not doing that here. |
| */ |
| count = SOLARIS_SENDFILEV(sd->secret->md.osfd, sfv_struct, |
| sfvcnt, &xferred); |
| |
| PR_ASSERT((count == -1) || (count == xferred)); |
| |
| if (count == -1) { |
| syserrno = errno; |
| if (syserrno == EINTR |
| || syserrno == EAGAIN || syserrno == EWOULDBLOCK) { |
| count = xferred; |
| } |
| } else if (count == 0) { |
| /* |
| * We are now at EOF. The file was truncated. Solaris sendfile is |
| * supposed to return 0 and no error in this case, though some versions |
| * may return -1 and EINVAL . |
| */ |
| count = -1; |
| syserrno = 0; /* will be treated as EOF */ |
| } |
| |
| if (count != -1 && count < nbytes_to_send) { |
| pt_Continuation op; |
| struct sendfilevec *vec = sfv_struct; |
| PRInt32 rem = count; |
| |
| while (rem >= vec->sfv_len) { |
| rem -= vec->sfv_len; |
| vec++; |
| sfvcnt--; |
| } |
| PR_ASSERT(sfvcnt > 0); |
| |
| vec->sfv_off += rem; |
| vec->sfv_len -= rem; |
| PR_ASSERT(vec->sfv_len > 0); |
| |
| op.arg1.osfd = sd->secret->md.osfd; |
| op.arg2.buffer = vec; |
| op.arg3.amount = sfvcnt; |
| op.arg4.flags = 0; |
| op.nbytes_to_send = nbytes_to_send - count; |
| op.result.code = count; |
| op.timeout = timeout; |
| op.function = pt_solaris_sendfile_cont; |
| op.event = POLLOUT | POLLPRI; |
| count = pt_Continue(&op); |
| syserrno = op.syserrno; |
| } |
| |
| done: |
| if (count == -1) { |
| pt_MapError(_MD_solaris_map_sendfile_error, syserrno); |
| return -1; |
| } |
| if (flags & PR_TRANSMITFILE_CLOSE_SOCKET) { |
| PR_Close(sd); |
| } |
| PR_ASSERT(count == nbytes_to_send); |
| return count; |
| } |
| |
| #ifndef HAVE_SENDFILEV |
| static pthread_once_t pt_solaris_sendfilev_once_block = PTHREAD_ONCE_INIT; |
| |
| static void pt_solaris_sendfilev_init_routine(void) |
| { |
| void *handle; |
| PRBool close_it = PR_FALSE; |
| |
| /* |
| * We do not want to unload libsendfile.so. This handle is leaked |
| * intentionally. |
| */ |
| handle = dlopen("libsendfile.so", RTLD_LAZY | RTLD_GLOBAL); |
| PR_LOG(_pr_io_lm, PR_LOG_DEBUG, |
| ("dlopen(libsendfile.so) returns %p", handle)); |
| |
| if (NULL == handle) { |
| /* |
| * The dlopen(0, mode) call is to allow for the possibility that |
| * sendfilev() may become part of a standard system library in a |
| * future Solaris release. |
| */ |
| handle = dlopen(0, RTLD_LAZY | RTLD_GLOBAL); |
| PR_LOG(_pr_io_lm, PR_LOG_DEBUG, |
| ("dlopen(0) returns %p", handle)); |
| close_it = PR_TRUE; |
| } |
| pt_solaris_sendfilev_fptr = (ssize_t (*)()) dlsym(handle, "sendfilev"); |
| PR_LOG(_pr_io_lm, PR_LOG_DEBUG, |
| ("dlsym(sendfilev) returns %p", pt_solaris_sendfilev_fptr)); |
| |
| if (close_it) { |
| dlclose(handle); |
| } |
| } |
| |
| /* |
| * pt_SolarisDispatchSendFile |
| */ |
| static PRInt32 pt_SolarisDispatchSendFile(PRFileDesc *sd, PRSendFileData *sfd, |
| PRTransmitFileFlags flags, PRIntervalTime timeout) |
| { |
| int rv; |
| |
| rv = pthread_once(&pt_solaris_sendfilev_once_block, |
| pt_solaris_sendfilev_init_routine); |
| PR_ASSERT(0 == rv); |
| if (pt_solaris_sendfilev_fptr) { |
| return pt_SolarisSendFile(sd, sfd, flags, timeout); |
| } else { |
| return PR_EmulateSendFile(sd, sfd, flags, timeout); |
| } |
| } |
| #endif /* !HAVE_SENDFILEV */ |
| |
| #endif /* SOLARIS */ |
| |
| #ifdef LINUX |
| /* |
| * pt_LinuxSendFile |
| * |
| * Send file sfd->fd across socket sd. If specified, header and trailer |
| * buffers are sent before and after the file, respectively. |
| * |
| * PR_TRANSMITFILE_CLOSE_SOCKET flag - close socket after sending file |
| * |
| * return number of bytes sent or -1 on error |
| * |
| * This implementation takes advantage of the sendfile() system |
| * call available in Linux kernel 2.2 or higher. |
| */ |
| |
| static PRInt32 pt_LinuxSendFile(PRFileDesc *sd, PRSendFileData *sfd, |
| PRTransmitFileFlags flags, PRIntervalTime timeout) |
| { |
| struct stat statbuf; |
| size_t file_nbytes_to_send; |
| PRInt32 count = 0; |
| ssize_t rv; |
| int syserrno; |
| off_t offset; |
| PRBool tcp_cork_enabled = PR_FALSE; |
| int tcp_cork; |
| |
| if (sfd->file_nbytes == 0) { |
| /* Get file size */ |
| if (fstat(sfd->fd->secret->md.osfd, &statbuf) == -1) { |
| _PR_MD_MAP_FSTAT_ERROR(errno); |
| return -1; |
| } |
| file_nbytes_to_send = statbuf.st_size - sfd->file_offset; |
| } else { |
| file_nbytes_to_send = sfd->file_nbytes; |
| } |
| |
| if ((sfd->hlen != 0 || sfd->tlen != 0) |
| && sd->secret->md.tcp_nodelay == 0) { |
| tcp_cork = 1; |
| if (setsockopt(sd->secret->md.osfd, SOL_TCP, TCP_CORK, |
| &tcp_cork, sizeof tcp_cork) == 0) { |
| tcp_cork_enabled = PR_TRUE; |
| } else { |
| syserrno = errno; |
| if (syserrno != EINVAL) { |
| _PR_MD_MAP_SETSOCKOPT_ERROR(syserrno); |
| return -1; |
| } |
| /* |
| * The most likely reason for the EINVAL error is that |
| * TCP_NODELAY is set (with a function other than |
| * PR_SetSocketOption). This is not fatal, so we keep |
| * on going. |
| */ |
| PR_LOG(_pr_io_lm, PR_LOG_WARNING, |
| ("pt_LinuxSendFile: " |
| "setsockopt(TCP_CORK) failed with EINVAL\n")); |
| } |
| } |
| |
| if (sfd->hlen != 0) { |
| count = PR_Send(sd, sfd->header, sfd->hlen, 0, timeout); |
| if (count == -1) { |
| goto failed; |
| } |
| } |
| |
| if (file_nbytes_to_send != 0) { |
| offset = sfd->file_offset; |
| do { |
| rv = sendfile(sd->secret->md.osfd, sfd->fd->secret->md.osfd, |
| &offset, file_nbytes_to_send); |
| } while (rv == -1 && (syserrno = errno) == EINTR); |
| if (rv == -1) { |
| if (syserrno != EAGAIN && syserrno != EWOULDBLOCK) { |
| _MD_linux_map_sendfile_error(syserrno); |
| count = -1; |
| goto failed; |
| } |
| rv = 0; |
| } |
| PR_ASSERT(rv == offset - sfd->file_offset); |
| count += rv; |
| |
| if (rv < file_nbytes_to_send) { |
| pt_Continuation op; |
| |
| op.arg1.osfd = sd->secret->md.osfd; |
| op.in_fd = sfd->fd->secret->md.osfd; |
| op.offset = offset; |
| op.count = file_nbytes_to_send - rv; |
| op.result.code = count; |
| op.timeout = timeout; |
| op.function = pt_linux_sendfile_cont; |
| op.event = POLLOUT | POLLPRI; |
| count = pt_Continue(&op); |
| syserrno = op.syserrno; |
| if (count == -1) { |
| pt_MapError(_MD_linux_map_sendfile_error, syserrno); |
| goto failed; |
| } |
| } |
| } |
| |
| if (sfd->tlen != 0) { |
| rv = PR_Send(sd, sfd->trailer, sfd->tlen, 0, timeout); |
| if (rv == -1) { |
| count = -1; |
| goto failed; |
| } |
| count += rv; |
| } |
| |
| failed: |
| if (tcp_cork_enabled) { |
| tcp_cork = 0; |
| if (setsockopt(sd->secret->md.osfd, SOL_TCP, TCP_CORK, |
| &tcp_cork, sizeof tcp_cork) == -1 && count != -1) { |
| _PR_MD_MAP_SETSOCKOPT_ERROR(errno); |
| count = -1; |
| } |
| } |
| if (count != -1) { |
| if (flags & PR_TRANSMITFILE_CLOSE_SOCKET) { |
| PR_Close(sd); |
| } |
| PR_ASSERT(count == sfd->hlen + sfd->tlen + file_nbytes_to_send); |
| } |
| return count; |
| } |
| #endif /* LINUX */ |
| |
| #ifdef AIX |
| extern int _pr_aix_send_file_use_disabled; |
| #endif |
| |
| static PRInt32 pt_SendFile( |
| PRFileDesc *sd, PRSendFileData *sfd, |
| PRTransmitFileFlags flags, PRIntervalTime timeout) |
| { |
| if (pt_TestAbort()) return -1; |
| /* The socket must be in blocking mode. */ |
| if (sd->secret->nonblocking) |
| { |
| PR_SetError(PR_INVALID_ARGUMENT_ERROR, 0); |
| return -1; |
| } |
| #ifdef HPUX11 |
| return(pt_HPUXSendFile(sd, sfd, flags, timeout)); |
| #elif defined(AIX) |
| #ifdef HAVE_SEND_FILE |
| /* |
| * A bug in AIX 4.3.2 results in corruption of data transferred by |
| * send_file(); AIX patch PTF U463956 contains the fix. A user can |
| * disable the use of send_file function in NSPR, when this patch is |
| * not installed on the system, by setting the envionment variable |
| * NSPR_AIX_SEND_FILE_USE_DISABLED to 1. |
| */ |
| if (_pr_aix_send_file_use_disabled) |
| return(PR_EmulateSendFile(sd, sfd, flags, timeout)); |
| else |
| return(pt_AIXSendFile(sd, sfd, flags, timeout)); |
| #else |
| return(PR_EmulateSendFile(sd, sfd, flags, timeout)); |
| /* return(pt_AIXDispatchSendFile(sd, sfd, flags, timeout));*/ |
| #endif /* HAVE_SEND_FILE */ |
| #elif defined(SOLARIS) |
| #ifdef HAVE_SENDFILEV |
| return(pt_SolarisSendFile(sd, sfd, flags, timeout)); |
| #else |
| return(pt_SolarisDispatchSendFile(sd, sfd, flags, timeout)); |
| #endif /* HAVE_SENDFILEV */ |
| #elif defined(LINUX) |
| return(pt_LinuxSendFile(sd, sfd, flags, timeout)); |
| #else |
| return(PR_EmulateSendFile(sd, sfd, flags, timeout)); |
| #endif |
| } |
| |
| static PRInt32 pt_TransmitFile( |
| PRFileDesc *sd, PRFileDesc *fd, const void *headers, |
| PRInt32 hlen, PRTransmitFileFlags flags, PRIntervalTime timeout) |
| { |
| PRSendFileData sfd; |
| |
| sfd.fd = fd; |
| sfd.file_offset = 0; |
| sfd.file_nbytes = 0; |
| sfd.header = headers; |
| sfd.hlen = hlen; |
| sfd.trailer = NULL; |
| sfd.tlen = 0; |
| |
| return(pt_SendFile(sd, &sfd, flags, timeout)); |
| } /* pt_TransmitFile */ |
| |
| static PRInt32 pt_AcceptRead( |
| PRFileDesc *sd, PRFileDesc **nd, PRNetAddr **raddr, |
| void *buf, PRInt32 amount, PRIntervalTime timeout) |
| { |
| PRInt32 rv = -1; |
| |
| if (pt_TestAbort()) return rv; |
| /* The socket must be in blocking mode. */ |
| if (sd->secret->nonblocking) |
| { |
| PR_SetError(PR_INVALID_ARGUMENT_ERROR, 0); |
| return rv; |
| } |
| |
| rv = PR_EmulateAcceptRead(sd, nd, raddr, buf, amount, timeout); |
| return rv; |
| } /* pt_AcceptRead */ |
| |
| static PRStatus pt_GetSockName(PRFileDesc *fd, PRNetAddr *addr) |
| { |
| PRIntn rv = -1; |
| pt_SockLen addr_len = sizeof(PRNetAddr); |
| |
| if (pt_TestAbort()) return PR_FAILURE; |
| |
| rv = getsockname( |
| fd->secret->md.osfd, (struct sockaddr*)addr, &addr_len); |
| if (rv == -1) { |
| pt_MapError(_PR_MD_MAP_GETSOCKNAME_ERROR, errno); |
| return PR_FAILURE; |
| } else { |
| #ifdef _PR_HAVE_SOCKADDR_LEN |
| /* ignore the sa_len field of struct sockaddr */ |
| if (addr) |
| { |
| addr->raw.family = ((struct sockaddr*)addr)->sa_family; |
| } |
| #endif /* _PR_HAVE_SOCKADDR_LEN */ |
| #ifdef _PR_INET6 |
| if (AF_INET6 == addr->raw.family) |
| addr->raw.family = PR_AF_INET6; |
| #endif |
| PR_ASSERT(IsValidNetAddr(addr) == PR_TRUE); |
| PR_ASSERT(IsValidNetAddrLen(addr, addr_len) == PR_TRUE); |
| return PR_SUCCESS; |
| } |
| } /* pt_GetSockName */ |
| |
| static PRStatus pt_GetPeerName(PRFileDesc *fd, PRNetAddr *addr) |
| { |
| PRIntn rv = -1; |
| pt_SockLen addr_len = sizeof(PRNetAddr); |
| |
| if (pt_TestAbort()) return PR_FAILURE; |
| |
| rv = getpeername( |
| fd->secret->md.osfd, (struct sockaddr*)addr, &addr_len); |
| |
| if (rv == -1) { |
| pt_MapError(_PR_MD_MAP_GETPEERNAME_ERROR, errno); |
| return PR_FAILURE; |
| } else { |
| #ifdef _PR_HAVE_SOCKADDR_LEN |
| /* ignore the sa_len field of struct sockaddr */ |
| if (addr) |
| { |
| addr->raw.family = ((struct sockaddr*)addr)->sa_family; |
| } |
| #endif /* _PR_HAVE_SOCKADDR_LEN */ |
| #ifdef _PR_INET6 |
| if (AF_INET6 == addr->raw.family) |
| addr->raw.family = PR_AF_INET6; |
| #endif |
| PR_ASSERT(IsValidNetAddr(addr) == PR_TRUE); |
| PR_ASSERT(IsValidNetAddrLen(addr, addr_len) == PR_TRUE); |
| return PR_SUCCESS; |
| } |
| } /* pt_GetPeerName */ |
| |
| static PRStatus pt_GetSocketOption(PRFileDesc *fd, PRSocketOptionData *data) |
| { |
| PRIntn rv; |
| pt_SockLen length; |
| PRInt32 level, name; |
| |
| /* |
| * PR_SockOpt_Nonblocking is a special case that does not |
| * translate to a getsockopt() call |
| */ |
| if (PR_SockOpt_Nonblocking == data->option) |
| { |
| data->value.non_blocking = fd->secret->nonblocking; |
| return PR_SUCCESS; |
| } |
| |
| rv = _PR_MapOptionName(data->option, &level, &name); |
| if (PR_SUCCESS == rv) |
| { |
| switch (data->option) |
| { |
| case PR_SockOpt_Linger: |
| { |
| struct linger linger; |
| length = sizeof(linger); |
| rv = getsockopt( |
| fd->secret->md.osfd, level, name, (char *) &linger, &length); |
| PR_ASSERT((-1 == rv) || (sizeof(linger) == length)); |
| data->value.linger.polarity = |
| (linger.l_onoff) ? PR_TRUE : PR_FALSE; |
| data->value.linger.linger = |
| PR_SecondsToInterval(linger.l_linger); |
| break; |
| } |
| case PR_SockOpt_Reuseaddr: |
| case PR_SockOpt_Keepalive: |
| case PR_SockOpt_NoDelay: |
| case PR_SockOpt_Broadcast: |
| case PR_SockOpt_Reuseport: |
| { |
| PRIntn value; |
| length = sizeof(PRIntn); |
| rv = getsockopt( |
| fd->secret->md.osfd, level, name, (char*)&value, &length); |
| PR_ASSERT((-1 == rv) || (sizeof(PRIntn) == length)); |
| data->value.reuse_addr = (0 == value) ? PR_FALSE : PR_TRUE; |
| break; |
| } |
| case PR_SockOpt_McastLoopback: |
| { |
| PRUint8 xbool; |
| length = sizeof(xbool); |
| rv = getsockopt( |
| fd->secret->md.osfd, level, name, |
| (char*)&xbool, &length); |
| PR_ASSERT((-1 == rv) || (sizeof(xbool) == length)); |
| data->value.mcast_loopback = (0 == xbool) ? PR_FALSE : PR_TRUE; |
| break; |
| } |
| case PR_SockOpt_RecvBufferSize: |
| case PR_SockOpt_SendBufferSize: |
| case PR_SockOpt_MaxSegment: |
| { |
| PRIntn value; |
| length = sizeof(PRIntn); |
| rv = getsockopt( |
| fd->secret->md.osfd, level, name, (char*)&value, &length); |
| PR_ASSERT((-1 == rv) || (sizeof(PRIntn) == length)); |
| data->value.recv_buffer_size = value; |
| break; |
| } |
| case PR_SockOpt_IpTimeToLive: |
| case PR_SockOpt_IpTypeOfService: |
| { |
| length = sizeof(PRUintn); |
| rv = getsockopt( |
| fd->secret->md.osfd, level, name, |
| (char*)&data->value.ip_ttl, &length); |
| PR_ASSERT((-1 == rv) || (sizeof(PRIntn) == length)); |
| break; |
| } |
| case PR_SockOpt_McastTimeToLive: |
| { |
| PRUint8 ttl; |
| length = sizeof(ttl); |
| rv = getsockopt( |
| fd->secret->md.osfd, level, name, |
| (char*)&ttl, &length); |
| PR_ASSERT((-1 == rv) || (sizeof(ttl) == length)); |
| data->value.mcast_ttl = ttl; |
| break; |
| } |
| case PR_SockOpt_AddMember: |
| case PR_SockOpt_DropMember: |
| { |
| struct ip_mreq mreq; |
| length = sizeof(mreq); |
| rv = getsockopt( |
| fd->secret->md.osfd, level, name, (char*)&mreq, &length); |
| PR_ASSERT((-1 == rv) || (sizeof(mreq) == length)); |
| data->value.add_member.mcaddr.inet.ip = |
| mreq.imr_multiaddr.s_addr; |
| data->value.add_member.ifaddr.inet.ip = |
| mreq.imr_interface.s_addr; |
| break; |
| } |
| case PR_SockOpt_McastInterface: |
| { |
| length = sizeof(data->value.mcast_if.inet.ip); |
| rv = getsockopt( |
| fd->secret->md.osfd, level, name, |
| (char*)&data->value.mcast_if.inet.ip, &length); |
| PR_ASSERT((-1 == rv) |
| || (sizeof(data->value.mcast_if.inet.ip) == length)); |
| break; |
| } |
| default: |
| PR_NOT_REACHED("Unknown socket option"); |
| break; |
| } |
| if (-1 == rv) _PR_MD_MAP_GETSOCKOPT_ERROR(errno); |
| } |
| return (-1 == rv) ? PR_FAILURE : PR_SUCCESS; |
| } /* pt_GetSocketOption */ |
| |
| static PRStatus pt_SetSocketOption(PRFileDesc *fd, const PRSocketOptionData *data) |
| { |
| PRIntn rv; |
| PRInt32 level, name; |
| |
| /* |
| * PR_SockOpt_Nonblocking is a special case that does not |
| * translate to a setsockopt call. |
| */ |
| if (PR_SockOpt_Nonblocking == data->option) |
| { |
| fd->secret->nonblocking = data->value.non_blocking; |
| return PR_SUCCESS; |
| } |
| |
| rv = _PR_MapOptionName(data->option, &level, &name); |
| if (PR_SUCCESS == rv) |
| { |
| switch (data->option) |
| { |
| case PR_SockOpt_Linger: |
| { |
| struct linger linger; |
| linger.l_onoff = data->value.linger.polarity; |
| linger.l_linger = PR_IntervalToSeconds(data->value.linger.linger); |
| rv = setsockopt( |
| fd->secret->md.osfd, level, name, (char*)&linger, sizeof(linger)); |
| break; |
| } |
| case PR_SockOpt_Reuseaddr: |
| case PR_SockOpt_Keepalive: |
| case PR_SockOpt_NoDelay: |
| case PR_SockOpt_Broadcast: |
| case PR_SockOpt_Reuseport: |
| { |
| PRIntn value = (data->value.reuse_addr) ? 1 : 0; |
| rv = setsockopt( |
| fd->secret->md.osfd, level, name, |
| (char*)&value, sizeof(PRIntn)); |
| #ifdef LINUX |
| /* for pt_LinuxSendFile */ |
| if (name == TCP_NODELAY && rv == 0) { |
| fd->secret->md.tcp_nodelay = value; |
| } |
| #endif |
| break; |
| } |
| case PR_SockOpt_McastLoopback: |
| { |
| PRUint8 xbool = data->value.mcast_loopback ? 1 : 0; |
| rv = setsockopt( |
| fd->secret->md.osfd, level, name, |
| (char*)&xbool, sizeof(xbool)); |
| break; |
| } |
| case PR_SockOpt_RecvBufferSize: |
| case PR_SockOpt_SendBufferSize: |
| case PR_SockOpt_MaxSegment: |
| { |
| PRIntn value = data->value.recv_buffer_size; |
| rv = setsockopt( |
| fd->secret->md.osfd, level, name, |
| (char*)&value, sizeof(PRIntn)); |
| break; |
| } |
| case PR_SockOpt_IpTimeToLive: |
| case PR_SockOpt_IpTypeOfService: |
| { |
| rv = setsockopt( |
| fd->secret->md.osfd, level, name, |
| (char*)&data->value.ip_ttl, sizeof(PRUintn)); |
| break; |
| } |
| case PR_SockOpt_McastTimeToLive: |
| { |
| PRUint8 ttl = data->value.mcast_ttl; |
| rv = setsockopt( |
| fd->secret->md.osfd, level, name, |
| (char*)&ttl, sizeof(ttl)); |
| break; |
| } |
| case PR_SockOpt_AddMember: |
| case PR_SockOpt_DropMember: |
| { |
| struct ip_mreq mreq; |
| mreq.imr_multiaddr.s_addr = |
| data->value.add_member.mcaddr.inet.ip; |
| mreq.imr_interface.s_addr = |
| data->value.add_member.ifaddr.inet.ip; |
| rv = setsockopt( |
| fd->secret->md.osfd, level, name, |
| (char*)&mreq, sizeof(mreq)); |
| break; |
| } |
| case PR_SockOpt_McastInterface: |
| { |
| rv = setsockopt( |
| fd->secret->md.osfd, level, name, |
| (char*)&data->value.mcast_if.inet.ip, |
| sizeof(data->value.mcast_if.inet.ip)); |
| break; |
| } |
| default: |
| PR_NOT_REACHED("Unknown socket option"); |
| break; |
| } |
| if (-1 == rv) _PR_MD_MAP_SETSOCKOPT_ERROR(errno); |
| } |
| return (-1 == rv) ? PR_FAILURE : PR_SUCCESS; |
| } /* pt_SetSocketOption */ |
| |
| /*****************************************************************************/ |
| /****************************** I/O method objects ***************************/ |
| /*****************************************************************************/ |
| |
| static PRIOMethods _pr_file_methods = { |
| PR_DESC_FILE, |
| pt_Close, |
| pt_Read, |
| pt_Write, |
| pt_Available_f, |
| pt_Available64_f, |
| pt_Fsync, |
| pt_Seek, |
| pt_Seek64, |
| pt_FileInfo, |
| pt_FileInfo64, |
| (PRWritevFN)_PR_InvalidInt, |
| (PRConnectFN)_PR_InvalidStatus, |
| (PRAcceptFN)_PR_InvalidDesc, |
| (PRBindFN)_PR_InvalidStatus, |
| (PRListenFN)_PR_InvalidStatus, |
| (PRShutdownFN)_PR_InvalidStatus, |
| (PRRecvFN)_PR_InvalidInt, |
| (PRSendFN)_PR_InvalidInt, |
| (PRRecvfromFN)_PR_InvalidInt, |
| (PRSendtoFN)_PR_InvalidInt, |
| pt_Poll, |
| (PRAcceptreadFN)_PR_InvalidInt, |
| (PRTransmitfileFN)_PR_InvalidInt, |
| (PRGetsocknameFN)_PR_InvalidStatus, |
| (PRGetpeernameFN)_PR_InvalidStatus, |
| (PRReservedFN)_PR_InvalidInt, |
| (PRReservedFN)_PR_InvalidInt, |
| (PRGetsocketoptionFN)_PR_InvalidStatus, |
| (PRSetsocketoptionFN)_PR_InvalidStatus, |
| (PRSendfileFN)_PR_InvalidInt, |
| (PRConnectcontinueFN)_PR_InvalidStatus, |
| (PRReservedFN)_PR_InvalidInt, |
| (PRReservedFN)_PR_InvalidInt, |
| (PRReservedFN)_PR_InvalidInt, |
| (PRReservedFN)_PR_InvalidInt |
| }; |
| |
| static PRIOMethods _pr_pipe_methods = { |
| PR_DESC_PIPE, |
| pt_Close, |
| pt_Read, |
| pt_Write, |
| pt_Available_s, |
| pt_Available64_s, |
| pt_Synch, |
| (PRSeekFN)_PR_InvalidInt, |
| (PRSeek64FN)_PR_InvalidInt64, |
| (PRFileInfoFN)_PR_InvalidStatus, |
| (PRFileInfo64FN)_PR_InvalidStatus, |
| (PRWritevFN)_PR_InvalidInt, |
| (PRConnectFN)_PR_InvalidStatus, |
| (PRAcceptFN)_PR_InvalidDesc, |
| (PRBindFN)_PR_InvalidStatus, |
| (PRListenFN)_PR_InvalidStatus, |
| (PRShutdownFN)_PR_InvalidStatus, |
| (PRRecvFN)_PR_InvalidInt, |
| (PRSendFN)_PR_InvalidInt, |
| (PRRecvfromFN)_PR_InvalidInt, |
| (PRSendtoFN)_PR_InvalidInt, |
| pt_Poll, |
| (PRAcceptreadFN)_PR_InvalidInt, |
| (PRTransmitfileFN)_PR_InvalidInt, |
| (PRGetsocknameFN)_PR_InvalidStatus, |
| (PRGetpeernameFN)_PR_InvalidStatus, |
| (PRReservedFN)_PR_InvalidInt, |
| (PRReservedFN)_PR_InvalidInt, |
| (PRGetsocketoptionFN)_PR_InvalidStatus, |
| (PRSetsocketoptionFN)_PR_InvalidStatus, |
| (PRSendfileFN)_PR_InvalidInt, |
| (PRConnectcontinueFN)_PR_InvalidStatus, |
| (PRReservedFN)_PR_InvalidInt, |
| (PRReservedFN)_PR_InvalidInt, |
| (PRReservedFN)_PR_InvalidInt, |
| (PRReservedFN)_PR_InvalidInt |
| }; |
| |
| static PRIOMethods _pr_tcp_methods = { |
| PR_DESC_SOCKET_TCP, |
| pt_Close, |
| pt_SocketRead, |
| pt_SocketWrite, |
| pt_Available_s, |
| pt_Available64_s, |
| pt_Synch, |
| (PRSeekFN)_PR_InvalidInt, |
| (PRSeek64FN)_PR_InvalidInt64, |
| (PRFileInfoFN)_PR_InvalidStatus, |
| (PRFileInfo64FN)_PR_InvalidStatus, |
| pt_Writev, |
| pt_Connect, |
| pt_Accept, |
| pt_Bind, |
| pt_Listen, |
| pt_Shutdown, |
| pt_Recv, |
| pt_Send, |
| (PRRecvfromFN)_PR_InvalidInt, |
| (PRSendtoFN)_PR_InvalidInt, |
| pt_Poll, |
| pt_AcceptRead, |
| pt_TransmitFile, |
| pt_GetSockName, |
| pt_GetPeerName, |
| (PRReservedFN)_PR_InvalidInt, |
| (PRReservedFN)_PR_InvalidInt, |
| pt_GetSocketOption, |
| pt_SetSocketOption, |
| pt_SendFile, |
| pt_ConnectContinue, |
| (PRReservedFN)_PR_InvalidInt, |
| (PRReservedFN)_PR_InvalidInt, |
| (PRReservedFN)_PR_InvalidInt, |
| (PRReservedFN)_PR_InvalidInt |
| }; |
| |
| static PRIOMethods _pr_udp_methods = { |
| PR_DESC_SOCKET_UDP, |
| pt_Close, |
| pt_SocketRead, |
| pt_SocketWrite, |
| pt_Available_s, |
| pt_Available64_s, |
| pt_Synch, |
| (PRSeekFN)_PR_InvalidInt, |
| (PRSeek64FN)_PR_InvalidInt64, |
| (PRFileInfoFN)_PR_InvalidStatus, |
| (PRFileInfo64FN)_PR_InvalidStatus, |
| pt_Writev, |
| pt_Connect, |
| (PRAcceptFN)_PR_InvalidDesc, |
| pt_Bind, |
| pt_Listen, |
| pt_Shutdown, |
| pt_Recv, |
| pt_Send, |
| pt_RecvFrom, |
| pt_SendTo, |
| pt_Poll, |
| (PRAcceptreadFN)_PR_InvalidInt, |
| (PRTransmitfileFN)_PR_InvalidInt, |
| pt_GetSockName, |
| pt_GetPeerName, |
| (PRReservedFN)_PR_InvalidInt, |
| (PRReservedFN)_PR_InvalidInt, |
| pt_GetSocketOption, |
| pt_SetSocketOption, |
| (PRSendfileFN)_PR_InvalidInt, |
| (PRConnectcontinueFN)_PR_InvalidStatus, |
| (PRReservedFN)_PR_InvalidInt, |
| (PRReservedFN)_PR_InvalidInt, |
| (PRReservedFN)_PR_InvalidInt, |
| (PRReservedFN)_PR_InvalidInt |
| }; |
| |
| static PRIOMethods _pr_socketpollfd_methods = { |
| (PRDescType) 0, |
| (PRCloseFN)_PR_InvalidStatus, |
| (PRReadFN)_PR_InvalidInt, |
| (PRWriteFN)_PR_InvalidInt, |
| (PRAvailableFN)_PR_InvalidInt, |
| (PRAvailable64FN)_PR_InvalidInt64, |
| (PRFsyncFN)_PR_InvalidStatus, |
| (PRSeekFN)_PR_InvalidInt, |
| (PRSeek64FN)_PR_InvalidInt64, |
| (PRFileInfoFN)_PR_InvalidStatus, |
| (PRFileInfo64FN)_PR_InvalidStatus, |
| (PRWritevFN)_PR_InvalidInt, |
| (PRConnectFN)_PR_InvalidStatus, |
| (PRAcceptFN)_PR_InvalidDesc, |
| (PRBindFN)_PR_InvalidStatus, |
| (PRListenFN)_PR_InvalidStatus, |
| (PRShutdownFN)_PR_InvalidStatus, |
| (PRRecvFN)_PR_InvalidInt, |
| (PRSendFN)_PR_InvalidInt, |
| (PRRecvfromFN)_PR_InvalidInt, |
| (PRSendtoFN)_PR_InvalidInt, |
| pt_Poll, |
| (PRAcceptreadFN)_PR_InvalidInt, |
| (PRTransmitfileFN)_PR_InvalidInt, |
| (PRGetsocknameFN)_PR_InvalidStatus, |
| (PRGetpeernameFN)_PR_InvalidStatus, |
| (PRReservedFN)_PR_InvalidInt, |
| (PRReservedFN)_PR_InvalidInt, |
| (PRGetsocketoptionFN)_PR_InvalidStatus, |
| (PRSetsocketoptionFN)_PR_InvalidStatus, |
| (PRSendfileFN)_PR_InvalidInt, |
| (PRConnectcontinueFN)_PR_InvalidStatus, |
| (PRReservedFN)_PR_InvalidInt, |
| (PRReservedFN)_PR_InvalidInt, |
| (PRReservedFN)_PR_InvalidInt, |
| (PRReservedFN)_PR_InvalidInt |
| }; |
| |
| #if defined(HPUX) || defined(OSF1) || defined(SOLARIS) || defined (IRIX) \ |
| || defined(LINUX) || defined(__GNU__) || defined(__GLIBC__) \ |
| || defined(AIX) || defined(FREEBSD) || defined(NETBSD) \ |
| || defined(OPENBSD) || defined(BSDI) || defined(NTO) \ |
| || defined(DARWIN) || defined(UNIXWARE) || defined(RISCOS) \ |
| || defined(SYMBIAN) |
| #define _PR_FCNTL_FLAGS O_NONBLOCK |
| #else |
| #error "Can't determine architecture" |
| #endif |
| |
| /* |
| * Put a Unix file descriptor in non-blocking mode. |
| */ |
| static void pt_MakeFdNonblock(PRIntn osfd) |
| { |
| PRIntn flags; |
| flags = fcntl(osfd, F_GETFL, 0); |
| flags |= _PR_FCNTL_FLAGS; |
| (void)fcntl(osfd, F_SETFL, flags); |
| } |
| |
| /* |
| * Put a Unix socket fd in non-blocking mode that can |
| * ideally be inherited by an accepted socket. |
| * |
| * Why doesn't pt_MakeFdNonblock do? This is to deal with |
| * the special case of HP-UX. HP-UX has three kinds of |
| * non-blocking modes for sockets: the fcntl() O_NONBLOCK |
| * and O_NDELAY flags and ioctl() FIOSNBIO request. Only |
| * the ioctl() FIOSNBIO form of non-blocking mode is |
| * inherited by an accepted socket. |
| * |
| * Other platforms just use the generic pt_MakeFdNonblock |
| * to put a socket in non-blocking mode. |
| */ |
| #ifdef HPUX |
| static void pt_MakeSocketNonblock(PRIntn osfd) |
| { |
| PRIntn one = 1; |
| (void)ioctl(osfd, FIOSNBIO, &one); |
| } |
| #else |
| #define pt_MakeSocketNonblock pt_MakeFdNonblock |
| #endif |
| |
| static PRFileDesc *pt_SetMethods( |
| PRIntn osfd, PRDescType type, PRBool isAcceptedSocket, PRBool imported) |
| { |
| PRFileDesc *fd = _PR_Getfd(); |
| |
| if (fd == NULL) PR_SetError(PR_OUT_OF_MEMORY_ERROR, 0); |
| else |
| { |
| fd->secret->md.osfd = osfd; |
| fd->secret->state = _PR_FILEDESC_OPEN; |
| if (imported) fd->secret->inheritable = _PR_TRI_UNKNOWN; |
| else |
| { |
| /* By default, a Unix fd is not closed on exec. */ |
| #ifdef DEBUG |
| PRIntn flags; |
| flags = fcntl(osfd, F_GETFD, 0); |
| PR_ASSERT(0 == flags); |
| #endif |
| fd->secret->inheritable = _PR_TRI_TRUE; |
| } |
| switch (type) |
| { |
| case PR_DESC_FILE: |
| fd->methods = PR_GetFileMethods(); |
| break; |
| case PR_DESC_SOCKET_TCP: |
| fd->methods = PR_GetTCPMethods(); |
| #ifdef _PR_ACCEPT_INHERIT_NONBLOCK |
| if (!isAcceptedSocket) pt_MakeSocketNonblock(osfd); |
| #else |
| pt_MakeSocketNonblock(osfd); |
| #endif |
| break; |
| case PR_DESC_SOCKET_UDP: |
| fd->methods = PR_GetUDPMethods(); |
| pt_MakeFdNonblock(osfd); |
| break; |
| case PR_DESC_PIPE: |
| fd->methods = PR_GetPipeMethods(); |
| pt_MakeFdNonblock(osfd); |
| break; |
| default: |
| break; |
| } |
| } |
| return fd; |
| } /* pt_SetMethods */ |
| |
| PR_IMPLEMENT(const PRIOMethods*) PR_GetFileMethods(void) |
| { |
| return &_pr_file_methods; |
| } /* PR_GetFileMethods */ |
| |
| PR_IMPLEMENT(const PRIOMethods*) PR_GetPipeMethods(void) |
| { |
| return &_pr_pipe_methods; |
| } /* PR_GetPipeMethods */ |
| |
| PR_IMPLEMENT(const PRIOMethods*) PR_GetTCPMethods(void) |
| { |
| return &_pr_tcp_methods; |
| } /* PR_GetTCPMethods */ |
| |
| PR_IMPLEMENT(const PRIOMethods*) PR_GetUDPMethods(void) |
| { |
| return &_pr_udp_methods; |
| } /* PR_GetUDPMethods */ |
| |
| static const PRIOMethods* PR_GetSocketPollFdMethods(void) |
| { |
| return &_pr_socketpollfd_methods; |
| } /* PR_GetSocketPollFdMethods */ |
| |
| PR_IMPLEMENT(PRFileDesc*) PR_AllocFileDesc( |
| PRInt32 osfd, const PRIOMethods *methods) |
| { |
| PRFileDesc *fd = _PR_Getfd(); |
| |
| if (NULL == fd) goto failed; |
| |
| fd->methods = methods; |
| fd->secret->md.osfd = osfd; |
| /* Make fd non-blocking */ |
| if (osfd > 2) |
| { |
| /* Don't mess around with stdin, stdout or stderr */ |
| if (&_pr_tcp_methods == methods) pt_MakeSocketNonblock(osfd); |
| else pt_MakeFdNonblock(osfd); |
| } |
| fd->secret->state = _PR_FILEDESC_OPEN; |
| fd->secret->inheritable = _PR_TRI_UNKNOWN; |
| return fd; |
| |
| failed: |
| PR_SetError(PR_OUT_OF_MEMORY_ERROR, 0); |
| return fd; |
| } /* PR_AllocFileDesc */ |
| |
| #if !defined(_PR_INET6) || defined(_PR_INET6_PROBE) |
| PR_EXTERN(PRStatus) _pr_push_ipv6toipv4_layer(PRFileDesc *fd); |
| #if defined(_PR_INET6_PROBE) |
| extern PRBool _pr_ipv6_is_present(void); |
| PR_IMPLEMENT(PRBool) _pr_test_ipv6_socket() |
| { |
| int osfd; |
| |
| #if defined(DARWIN) |
| /* |
| * Disable IPv6 if Darwin version is less than 7.0.0 (OS X 10.3). IPv6 on |
| * lesser versions is not ready for general use (see bug 222031). |
| */ |
| { |
| struct utsname u; |
| if (uname(&u) != 0 || atoi(u.release) < 7) |
| return PR_FALSE; |
| } |
| #endif |
| |
| /* |
| * HP-UX only: HP-UX IPv6 Porting Guide (dated February 2001) |
| * suggests that we call open("/dev/ip6", O_RDWR) to determine |
| * whether IPv6 APIs and the IPv6 stack are on the system. |
| * Our portable test below seems to work fine, so I am using it. |
| */ |
| osfd = socket(AF_INET6, SOCK_STREAM, 0); |
| if (osfd != -1) { |
| close(osfd); |
| return PR_TRUE; |
| } |
| return PR_FALSE; |
| } |
| #endif /* _PR_INET6_PROBE */ |
| #endif |
| |
| PR_IMPLEMENT(PRFileDesc*) PR_Socket(PRInt32 domain, PRInt32 type, PRInt32 proto) |
| { |
| PRIntn osfd; |
| PRDescType ftype; |
| PRFileDesc *fd = NULL; |
| #if defined(_PR_INET6_PROBE) || !defined(_PR_INET6) |
| PRInt32 tmp_domain = domain; |
| #endif |
| |
| if (!_pr_initialized) _PR_ImplicitInitialization(); |
| |
| if (pt_TestAbort()) return NULL; |
| |
| if (PF_INET != domain |
| && PR_AF_INET6 != domain |
| #if defined(_PR_HAVE_SDP) |
| && PR_AF_INET_SDP != domain |
| #if defined(SOLARIS) |
| && PR_AF_INET6_SDP != domain |
| #endif /* SOLARIS */ |
| #endif /* _PR_HAVE_SDP */ |
| && PF_UNIX != domain) |
| { |
| PR_SetError(PR_ADDRESS_NOT_SUPPORTED_ERROR, 0); |
| return fd; |
| } |
| if (type == SOCK_STREAM) ftype = PR_DESC_SOCKET_TCP; |
| else if (type == SOCK_DGRAM) ftype = PR_DESC_SOCKET_UDP; |
| else |
| { |
| (void)PR_SetError(PR_ADDRESS_NOT_SUPPORTED_ERROR, 0); |
| return fd; |
| } |
| #if defined(_PR_HAVE_SDP) |
| #if defined(LINUX) |
| if (PR_AF_INET_SDP == domain) |
| domain = AF_INET_SDP; |
| #elif defined(SOLARIS) |
| if (PR_AF_INET_SDP == domain) { |
| domain = AF_INET; |
| proto = PROTO_SDP; |
| } else if(PR_AF_INET6_SDP == domain) { |
| domain = AF_INET6; |
| proto = PROTO_SDP; |
| } |
| #endif /* SOLARIS */ |
| #endif /* _PR_HAVE_SDP */ |
| #if defined(_PR_INET6_PROBE) |
| if (PR_AF_INET6 == domain) |
| domain = _pr_ipv6_is_present() ? AF_INET6 : AF_INET; |
| #elif defined(_PR_INET6) |
| if (PR_AF_INET6 == domain) |
| domain = AF_INET6; |
| #else |
| if (PR_AF_INET6 == domain) |
| domain = AF_INET; |
| #endif |
| |
| osfd = socket(domain, type, proto); |
| if (osfd == -1) pt_MapError(_PR_MD_MAP_SOCKET_ERROR, errno); |
| else |
| { |
| #ifdef _PR_IPV6_V6ONLY_PROBE |
| if ((domain == AF_INET6) && _pr_ipv6_v6only_on_by_default) |
| { |
| int on = 0; |
| (void)setsockopt(osfd, IPPROTO_IPV6, IPV6_V6ONLY, |
| &on, sizeof(on)); |
| } |
| #endif |
| fd = pt_SetMethods(osfd, ftype, PR_FALSE, PR_FALSE); |
| if (fd == NULL) close(osfd); |
| } |
| #ifdef _PR_NEED_SECRET_AF |
| if (fd != NULL) fd->secret->af = domain; |
| #endif |
| #if defined(_PR_INET6_PROBE) || !defined(_PR_INET6) |
| if (fd != NULL) { |
| /* |
| * For platforms with no support for IPv6 |
| * create layered socket for IPv4-mapped IPv6 addresses |
| */ |
| if (PR_AF_INET6 == tmp_domain && PR_AF_INET == domain) { |
| if (PR_FAILURE == _pr_push_ipv6toipv4_layer(fd)) { |
| PR_Close(fd); |
| fd = NULL; |
| } |
| } |
| } |
| #endif |
| return fd; |
| } /* PR_Socket */ |
| |
| /*****************************************************************************/ |
| /****************************** I/O public methods ***************************/ |
| /*****************************************************************************/ |
| |
| PR_IMPLEMENT(PRFileDesc*) PR_OpenFile( |
| const char *name, PRIntn flags, PRIntn mode) |
| { |
| PRFileDesc *fd = NULL; |
| PRIntn syserrno, osfd = -1, osflags = 0;; |
| |
| if (!_pr_initialized) _PR_ImplicitInitialization(); |
| |
| if (pt_TestAbort()) return NULL; |
| |
| if (flags & PR_RDONLY) osflags |= O_RDONLY; |
| if (flags & PR_WRONLY) osflags |= O_WRONLY; |
| if (flags & PR_RDWR) osflags |= O_RDWR; |
| if (flags & PR_APPEND) osflags |= O_APPEND; |
| if (flags & PR_TRUNCATE) osflags |= O_TRUNC; |
| if (flags & PR_EXCL) osflags |= O_EXCL; |
| if (flags & PR_SYNC) |
| { |
| #if defined(O_SYNC) |
| osflags |= O_SYNC; |
| #elif defined(O_FSYNC) |
| osflags |= O_FSYNC; |
| #else |
| #error "Neither O_SYNC nor O_FSYNC is defined on this platform" |
| #endif |
| } |
| |
| /* |
| ** We have to hold the lock across the creation in order to |
| ** enforce the sematics 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); |
| } |
| |
| osfd = _md_iovector._open64(name, osflags, mode); |
| syserrno = errno; |
| |
| if ((flags & PR_CREATE_FILE) && (NULL !=_pr_rename_lock)) |
| PR_Unlock(_pr_rename_lock); |
| |
| if (osfd == -1) |
| pt_MapError(_PR_MD_MAP_OPEN_ERROR, syserrno); |
| else |
| { |
| fd = pt_SetMethods(osfd, PR_DESC_FILE, PR_FALSE, PR_FALSE); |
| if (fd == NULL) close(osfd); /* $$$ whoops! this is bad $$$ */ |
| } |
| return fd; |
| } /* PR_OpenFile */ |
| |
| PR_IMPLEMENT(PRFileDesc*) PR_Open(const char *name, PRIntn flags, PRIntn mode) |
| { |
| return PR_OpenFile(name, flags, mode); |
| } /* PR_Open */ |
| |
| PR_IMPLEMENT(PRStatus) PR_Delete(const char *name) |
| { |
| PRIntn rv = -1; |
| |
| if (!_pr_initialized) _PR_ImplicitInitialization(); |
| |
| if (pt_TestAbort()) return PR_FAILURE; |
| |
| rv = unlink(name); |
| |
| if (rv == -1) { |
| pt_MapError(_PR_MD_MAP_UNLINK_ERROR, errno); |
| return PR_FAILURE; |
| } else |
| return PR_SUCCESS; |
| } /* PR_Delete */ |
| |
| PR_IMPLEMENT(PRStatus) PR_Access(const char *name, PRAccessHow how) |
| { |
| PRIntn rv; |
| |
| if (pt_TestAbort()) return PR_FAILURE; |
| |
| switch (how) |
| { |
| case PR_ACCESS_READ_OK: |
| rv = access(name, R_OK); |
| break; |
| case PR_ACCESS_WRITE_OK: |
| rv = access(name, W_OK); |
| break; |
| case PR_ACCESS_EXISTS: |
| default: |
| rv = access(name, F_OK); |
| } |
| if (0 == rv) return PR_SUCCESS; |
| pt_MapError(_PR_MD_MAP_ACCESS_ERROR, errno); |
| return PR_FAILURE; |
| |
| } /* PR_Access */ |
| |
| PR_IMPLEMENT(PRStatus) PR_GetFileInfo(const char *fn, PRFileInfo *info) |
| { |
| PRInt32 rv = _PR_MD_GETFILEINFO(fn, info); |
| return (0 == rv) ? PR_SUCCESS : PR_FAILURE; |
| } /* PR_GetFileInfo */ |
| |
| PR_IMPLEMENT(PRStatus) PR_GetFileInfo64(const char *fn, PRFileInfo64 *info) |
| { |
| PRInt32 rv; |
| |
| if (!_pr_initialized) _PR_ImplicitInitialization(); |
| rv = _PR_MD_GETFILEINFO64(fn, info); |
| return (0 == rv) ? PR_SUCCESS : PR_FAILURE; |
| } /* PR_GetFileInfo64 */ |
| |
| PR_IMPLEMENT(PRStatus) PR_Rename(const char *from, const char *to) |
| { |
| PRIntn rv = -1; |
| |
| if (pt_TestAbort()) return PR_FAILURE; |
| |
| /* |
| ** We have to acquire a lock here to stiffle anybody trying to create |
| ** a new file at the same time. And we have to hold that lock while we |
| ** test to see if the file exists and do the rename. The other place |
| ** where the lock is held is in PR_Open() when possibly creating a |
| ** new file. |
| */ |
| |
| PR_Lock(_pr_rename_lock); |
| rv = access(to, F_OK); |
| if (0 == rv) |
| { |
| PR_SetError(PR_FILE_EXISTS_ERROR, 0); |
| rv = -1; |
| } |
| else |
| { |
| rv = rename(from, to); |
| if (rv == -1) |
| pt_MapError(_PR_MD_MAP_RENAME_ERROR, errno); |
| } |
| PR_Unlock(_pr_rename_lock); |
| return (-1 == rv) ? PR_FAILURE : PR_SUCCESS; |
| } /* PR_Rename */ |
| |
| PR_IMPLEMENT(PRStatus) PR_CloseDir(PRDir *dir) |
| { |
| if (pt_TestAbort()) return PR_FAILURE; |
| |
| if (NULL != dir->md.d) |
| { |
| if (closedir(dir->md.d) == -1) |
| { |
| _PR_MD_MAP_CLOSEDIR_ERROR(errno); |
| return PR_FAILURE; |
| } |
| dir->md.d = NULL; |
| PR_DELETE(dir); |
| } |
| return PR_SUCCESS; |
| } /* PR_CloseDir */ |
| |
| PR_IMPLEMENT(PRStatus) PR_MakeDir(const char *name, PRIntn mode) |
| { |
| PRInt32 rv = -1; |
| |
| if (pt_TestAbort()) return PR_FAILURE; |
| |
| /* |
| ** This lock is used to enforce rename semantics as described |
| ** in PR_Rename. |
| */ |
| if (NULL !=_pr_rename_lock) |
| PR_Lock(_pr_rename_lock); |
| rv = mkdir(name, mode); |
| if (-1 == rv) |
| pt_MapError(_PR_MD_MAP_MKDIR_ERROR, errno); |
| if (NULL !=_pr_rename_lock) |
| PR_Unlock(_pr_rename_lock); |
| |
| return (-1 == rv) ? PR_FAILURE : PR_SUCCESS; |
| } /* PR_Makedir */ |
| |
| PR_IMPLEMENT(PRStatus) PR_MkDir(const char *name, PRIntn mode) |
| { |
| return PR_MakeDir(name, mode); |
| } /* PR_Mkdir */ |
| |
| PR_IMPLEMENT(PRStatus) PR_RmDir(const char *name) |
| { |
| PRInt32 rv; |
| |
| if (pt_TestAbort()) return PR_FAILURE; |
| |
| rv = rmdir(name); |
| if (0 == rv) { |
| return PR_SUCCESS; |
| } else { |
| pt_MapError(_PR_MD_MAP_RMDIR_ERROR, errno); |
| return PR_FAILURE; |
| } |
| } /* PR_Rmdir */ |
| |
| |
| PR_IMPLEMENT(PRDir*) PR_OpenDir(const char *name) |
| { |
| DIR *osdir; |
| PRDir *dir = NULL; |
| |
| if (pt_TestAbort()) return dir; |
| |
| osdir = opendir(name); |
| if (osdir == NULL) |
| pt_MapError(_PR_MD_MAP_OPENDIR_ERROR, errno); |
| else |
| { |
| dir = PR_NEWZAP(PRDir); |
| if (dir) |
| dir->md.d = osdir; |
| else |
| (void)closedir(osdir); |
| } |
| return dir; |
| } /* PR_OpenDir */ |
| |
| static PRInt32 _pr_poll_with_poll( |
| PRPollDesc *pds, PRIntn npds, PRIntervalTime timeout) |
| { |
| PRInt32 ready = 0; |
| /* |
| * For restarting poll() if it is interrupted by a signal. |
| * We use these variables to figure out how much time has |
| * elapsed and how much of the timeout still remains. |
| */ |
| PRIntervalTime start = 0, elapsed, remaining; |
| |
| if (pt_TestAbort()) return -1; |
| |
| if (0 == npds) PR_Sleep(timeout); |
| else |
| { |
| #define STACK_POLL_DESC_COUNT 64 |
| struct pollfd stack_syspoll[STACK_POLL_DESC_COUNT]; |
| struct pollfd *syspoll; |
| PRIntn index, msecs; |
| |
| if (npds <= STACK_POLL_DESC_COUNT) |
| { |
| syspoll = stack_syspoll; |
| } |
| else |
| { |
| PRThread *me = PR_GetCurrentThread(); |
| if (npds > me->syspoll_count) |
| { |
| PR_Free(me->syspoll_list); |
| me->syspoll_list = |
| (struct pollfd*)PR_MALLOC(npds * sizeof(struct pollfd)); |
| if (NULL == me->syspoll_list) |
| { |
| me->syspoll_count = 0; |
| PR_SetError(PR_OUT_OF_MEMORY_ERROR, 0); |
| return -1; |
| } |
| me->syspoll_count = npds; |
| } |
| syspoll = me->syspoll_list; |
| } |
| |
| for (index = 0; index < npds; ++index) |
| { |
| PRInt16 in_flags_read = 0, in_flags_write = 0; |
| PRInt16 out_flags_read = 0, out_flags_write = 0; |
| |
| if ((NULL != pds[index].fd) && (0 != pds[index].in_flags)) |
| { |
| if (pds[index].in_flags & PR_POLL_READ) |
| { |
| in_flags_read = (pds[index].fd->methods->poll)( |
| pds[index].fd, |
| pds[index].in_flags & ~PR_POLL_WRITE, |
| &out_flags_read); |
| } |
| if (pds[index].in_flags & PR_POLL_WRITE) |
| { |
| in_flags_write = (pds[index].fd->methods->poll)( |
| pds[index].fd, |
| pds[index].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 is ready right now */ |
| if (0 == ready) |
| { |
| /* |
| * We will return without calling the system |
| * poll function. So zero the out_flags |
| * fields of all the poll descriptors before |
| * this one. |
| */ |
| int i; |
| for (i = 0; i < index; i++) |
| { |
| pds[i].out_flags = 0; |
| } |
| } |
| ready += 1; |
| pds[index].out_flags = out_flags_read | out_flags_write; |
| } |
| else |
| { |
| /* now locate the NSPR layer at the bottom of the stack */ |
| PRFileDesc *bottom = PR_GetIdentitiesLayer( |
| pds[index].fd, PR_NSPR_IO_LAYER); |
| PR_ASSERT(NULL != bottom); /* what to do about that? */ |
| pds[index].out_flags = 0; /* pre-condition */ |
| if ((NULL != bottom) |
| && (_PR_FILEDESC_OPEN == bottom->secret->state)) |
| { |
| if (0 == ready) |
| { |
| syspoll[index].fd = bottom->secret->md.osfd; |
| syspoll[index].events = 0; |
| if (in_flags_read & PR_POLL_READ) |
| { |
| pds[index].out_flags |= |
| _PR_POLL_READ_SYS_READ; |
| syspoll[index].events |= POLLIN; |
| } |
| if (in_flags_read & PR_POLL_WRITE) |
| { |
| pds[index].out_flags |= |
| _PR_POLL_READ_SYS_WRITE; |
| syspoll[index].events |= POLLOUT; |
| } |
| if (in_flags_write & PR_POLL_READ) |
| { |
| pds[index].out_flags |= |
| _PR_POLL_WRITE_SYS_READ; |
| syspoll[index].events |= POLLIN; |
| } |
| if (in_flags_write & PR_POLL_WRITE) |
| { |
| pds[index].out_flags |= |
| _PR_POLL_WRITE_SYS_WRITE; |
| syspoll[index].events |= POLLOUT; |
| } |
| if (pds[index].in_flags & PR_POLL_EXCEPT) |
| syspoll[index].events |= POLLPRI; |
| } |
| } |
| else |
| { |
| if (0 == ready) |
| { |
| int i; |
| for (i = 0; i < index; i++) |
| { |
| pds[i].out_flags = 0; |
| } |
| } |
| ready += 1; /* this will cause an abrupt return */ |
| pds[index].out_flags = PR_POLL_NVAL; /* bogii */ |
| } |
| } |
| } |
| else |
| { |
| /* make poll() ignore this entry */ |
| syspoll[index].fd = -1; |
| syspoll[index].events = 0; |
| pds[index].out_flags = 0; |
| } |
| } |
| if (0 == ready) |
| { |
| switch (timeout) |
| { |
| case PR_INTERVAL_NO_WAIT: msecs = 0; break; |
| case PR_INTERVAL_NO_TIMEOUT: msecs = -1; break; |
| default: |
| msecs = PR_IntervalToMilliseconds(timeout); |
| start = PR_IntervalNow(); |
| } |
| |
| retry: |
| ready = poll(syspoll, npds, msecs); |
| if (-1 == ready) |
| { |
| PRIntn oserror = errno; |
| |
| if (EINTR == oserror) |
| { |
| if (timeout == PR_INTERVAL_NO_TIMEOUT) |
| goto retry; |
| else if (timeout == PR_INTERVAL_NO_WAIT) |
| ready = 0; /* don't retry, just time out */ |
| else |
| { |
| elapsed = (PRIntervalTime) (PR_IntervalNow() |
| - start); |
| if (elapsed > timeout) |
| ready = 0; /* timed out */ |
| else |
| { |
| remaining = timeout - elapsed; |
| msecs = PR_IntervalToMilliseconds(remaining); |
| goto retry; |
| } |
| } |
| } |
| else |
| { |
| _PR_MD_MAP_POLL_ERROR(oserror); |
| } |
| } |
| else if (ready > 0) |
| { |
| for (index = 0; index < npds; ++index) |
| { |
| PRInt16 out_flags = 0; |
| if ((NULL != pds[index].fd) && (0 != pds[index].in_flags)) |
| { |
| if (0 != syspoll[index].revents) |
| { |
| if (syspoll[index].revents & POLLIN) |
| { |
| if (pds[index].out_flags |
| & _PR_POLL_READ_SYS_READ) |
| { |
| out_flags |= PR_POLL_READ; |
| } |
| if (pds[index].out_flags |
| & _PR_POLL_WRITE_SYS_READ) |
| { |
| out_flags |= PR_POLL_WRITE; |
| } |
| } |
| if (syspoll[index].revents & POLLOUT) |
| { |
| if (pds[index].out_flags |
| & _PR_POLL_READ_SYS_WRITE) |
| { |
| out_flags |= PR_POLL_READ; |
| } |
| if (pds[index].out_flags |
| & _PR_POLL_WRITE_SYS_WRITE) |
| { |
| out_flags |= PR_POLL_WRITE; |
| } |
| } |
| if (syspoll[index].revents & POLLPRI) |
| out_flags |= PR_POLL_EXCEPT; |
| if (syspoll[index].revents & POLLERR) |
| out_flags |= PR_POLL_ERR; |
| if (syspoll[index].revents & POLLNVAL) |
| out_flags |= PR_POLL_NVAL; |
| if (syspoll[index].revents & POLLHUP) |
| out_flags |= PR_POLL_HUP; |
| } |
| } |
| pds[index].out_flags = out_flags; |
| } |
| } |
| } |
| } |
| return ready; |
| |
| } /* _pr_poll_with_poll */ |
| |
| #if defined(_PR_POLL_WITH_SELECT) |
| /* |
| * OSF1 and HPUX report the POLLHUP event for a socket when the |
| * shutdown(SHUT_WR) operation is called for the remote end, even though |
| * the socket is still writeable. Use select(), instead of poll(), to |
| * workaround this problem. |
| */ |
| static PRInt32 _pr_poll_with_select( |
| PRPollDesc *pds, PRIntn npds, PRIntervalTime timeout) |
| { |
| PRInt32 ready = 0; |
| /* |
| * For restarting select() if it is interrupted by a signal. |
| * We use these variables to figure out how much time has |
| * elapsed and how much of the timeout still remains. |
| */ |
| PRIntervalTime start = 0, elapsed, remaining; |
| |
| if (pt_TestAbort()) return -1; |
| |
| if (0 == npds) PR_Sleep(timeout); |
| else |
| { |
| #define STACK_POLL_DESC_COUNT 64 |
| int stack_selectfd[STACK_POLL_DESC_COUNT]; |
| int *selectfd; |
| fd_set rd, wr, ex, *rdp = NULL, *wrp = NULL, *exp = NULL; |
| struct timeval tv, *tvp; |
| PRIntn index, msecs, maxfd = 0; |
| |
| if (npds <= STACK_POLL_DESC_COUNT) |
| { |
| selectfd = stack_selectfd; |
| } |
| else |
| { |
| PRThread *me = PR_GetCurrentThread(); |
| if (npds > me->selectfd_count) |
| { |
| PR_Free(me->selectfd_list); |
| me->selectfd_list = (int *)PR_MALLOC(npds * sizeof(int)); |
| if (NULL == me->selectfd_list) |
| { |
| me->selectfd_count = 0; |
| PR_SetError(PR_OUT_OF_MEMORY_ERROR, 0); |
| return -1; |
| } |
| me->selectfd_count = npds; |
| } |
| selectfd = me->selectfd_list; |
| } |
| FD_ZERO(&rd); |
| FD_ZERO(&wr); |
| FD_ZERO(&ex); |
| |
| for (index = 0; index < npds; ++index) |
| { |
| PRInt16 in_flags_read = 0, in_flags_write = 0; |
| PRInt16 out_flags_read = 0, out_flags_write = 0; |
| |
| if ((NULL != pds[index].fd) && (0 != pds[index].in_flags)) |
| { |
| if (pds[index].in_flags & PR_POLL_READ) |
| { |
| in_flags_read = (pds[index].fd->methods->poll)( |
| pds[index].fd, |
| pds[index].in_flags & ~PR_POLL_WRITE, |
| &out_flags_read); |
| } |
| if (pds[index].in_flags & PR_POLL_WRITE) |
| { |
| in_flags_write = (pds[index].fd->methods->poll)( |
| pds[index].fd, |
| pds[index].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 is ready right now */ |
| if (0 == ready) |
| { |
| /* |
| * We will return without calling the system |
| * poll function. So zero the out_flags |
| * fields of all the poll descriptors before |
| * this one. |
| */ |
| int i; |
| for (i = 0; i < index; i++) |
| { |
| pds[i].out_flags = 0; |
| } |
| } |
| ready += 1; |
| pds[index].out_flags = out_flags_read | out_flags_write; |
| } |
| else |
| { |
| /* now locate the NSPR layer at the bottom of the stack */ |
| PRFileDesc *bottom = PR_GetIdentitiesLayer( |
| pds[index].fd, PR_NSPR_IO_LAYER); |
| PR_ASSERT(NULL != bottom); /* what to do about that? */ |
| pds[index].out_flags = 0; /* pre-condition */ |
| if ((NULL != bottom) |
| && (_PR_FILEDESC_OPEN == bottom->secret->state)) |
| { |
| if (0 == ready) |
| { |
| PRBool add_to_rd = PR_FALSE; |
| PRBool add_to_wr = PR_FALSE; |
| PRBool add_to_ex = PR_FALSE; |
| |
| selectfd[index] = bottom->secret->md.osfd; |
| if (in_flags_read & PR_POLL_READ) |
| { |
| pds[index].out_flags |= |
| _PR_POLL_READ_SYS_READ; |
| add_to_rd = PR_TRUE; |
| } |
| if (in_flags_read & PR_POLL_WRITE) |
| { |
| pds[index].out_flags |= |
| _PR_POLL_READ_SYS_WRITE; |
| add_to_wr = PR_TRUE; |
| } |
| if (in_flags_write & PR_POLL_READ) |
| { |
| pds[index].out_flags |= |
| _PR_POLL_WRITE_SYS_READ; |
| add_to_rd = PR_TRUE; |
| } |
| if (in_flags_write & PR_POLL_WRITE) |
| { |
| pds[index].out_flags |= |
| _PR_POLL_WRITE_SYS_WRITE; |
| add_to_wr = PR_TRUE; |
| } |
| if (pds[index].in_flags & PR_POLL_EXCEPT) |
| { |
| add_to_ex = PR_TRUE; |
| } |
| if ((selectfd[index] > maxfd) && |
| (add_to_rd || add_to_wr || add_to_ex)) |
| { |
| maxfd = selectfd[index]; |
| /* |
| * If maxfd is too large to be used with |
| * select, fall back to calling poll. |
| */ |
| if (maxfd >= FD_SETSIZE) |
| break; |
| } |
| if (add_to_rd) |
| { |
| FD_SET(bottom->secret->md.osfd, &rd); |
| rdp = &rd; |
| } |
| if (add_to_wr) |
| { |
| FD_SET(bottom->secret->md.osfd, &wr); |
| wrp = ≀ |
| } |
| if (add_to_ex) |
| { |
| FD_SET(bottom->secret->md.osfd, &ex); |
| exp = &ex; |
| } |
| } |
| } |
| else |
| { |
| if (0 == ready) |
| { |
| int i; |
| for (i = 0; i < index; i++) |
| { |
| pds[i].out_flags = 0; |
| } |
| } |
| ready += 1; /* this will cause an abrupt return */ |
| pds[index].out_flags = PR_POLL_NVAL; /* bogii */ |
| } |
| } |
| } |
| else |
| { |
| pds[index].out_flags = 0; |
| } |
| } |
| if (0 == ready) |
| { |
| if (maxfd >= FD_SETSIZE) |
| { |
| /* |
| * maxfd too large to be used with select, fall back to |
| * calling poll |
| */ |
| return(_pr_poll_with_poll(pds, npds, timeout)); |
| } |
| switch (timeout) |
| { |
| case PR_INTERVAL_NO_WAIT: |
| tv.tv_sec = 0; |
| tv.tv_usec = 0; |
| tvp = &tv; |
| break; |
| case PR_INTERVAL_NO_TIMEOUT: |
| tvp = NULL; |
| break; |
| default: |
| msecs = PR_IntervalToMilliseconds(timeout); |
| tv.tv_sec = msecs/PR_MSEC_PER_SEC; |
| tv.tv_usec = (msecs % PR_MSEC_PER_SEC) * PR_USEC_PER_MSEC; |
| tvp = &tv; |
| start = PR_IntervalNow(); |
| } |
| |
| retry: |
| ready = select(maxfd + 1, rdp, wrp, exp, tvp); |
| if (-1 == ready) |
| { |
| PRIntn oserror = errno; |
| |
| if ((EINTR == oserror) || (EAGAIN == oserror)) |
| { |
| if (timeout == PR_INTERVAL_NO_TIMEOUT) |
| goto retry; |
| else if (timeout == PR_INTERVAL_NO_WAIT) |
| ready = 0; /* don't retry, just time out */ |
| else |
| { |
| elapsed = (PRIntervalTime) (PR_IntervalNow() |
| - start); |
| if (elapsed > timeout) |
| ready = 0; /* timed out */ |
| else |
| { |
| remaining = timeout - elapsed; |
| msecs = PR_IntervalToMilliseconds(remaining); |
| tv.tv_sec = msecs/PR_MSEC_PER_SEC; |
| tv.tv_usec = (msecs % PR_MSEC_PER_SEC) * |
| PR_USEC_PER_MSEC; |
| goto retry; |
| } |
| } |
| } else if (EBADF == oserror) |
| { |
| /* find all the bad fds */ |
| ready = 0; |
| for (index = 0; index < npds; ++index) |
| { |
| pds[index].out_flags = 0; |
| if ((NULL != pds[index].fd) && |
| (0 != pds[index].in_flags)) |
| { |
| if (fcntl(selectfd[index], F_GETFL, 0) == -1) |
| { |
| pds[index].out_flags = PR_POLL_NVAL; |
| ready++; |
| } |
| } |
| } |
| } else |
| _PR_MD_MAP_SELECT_ERROR(oserror); |
| } |
| else if (ready > 0) |
| { |
| for (index = 0; index < npds; ++index) |
| { |
| PRInt16 out_flags = 0; |
| if ((NULL != pds[index].fd) && (0 != pds[index].in_flags)) |
| { |
| if (FD_ISSET(selectfd[index], &rd)) |
| { |
| if (pds[index].out_flags |
| & _PR_POLL_READ_SYS_READ) |
| { |
| out_flags |= PR_POLL_READ; |
| } |
| if (pds[index].out_flags |
| & _PR_POLL_WRITE_SYS_READ) |
| { |
| out_flags |= PR_POLL_WRITE; |
| } |
| } |
| if (FD_ISSET(selectfd[index], &wr)) |
| { |
| if (pds[index].out_flags |
| & _PR_POLL_READ_SYS_WRITE) |
| { |
| out_flags |= PR_POLL_READ; |
| } |
| if (pds[index].out_flags |
| & _PR_POLL_WRITE_SYS_WRITE) |
| { |
| out_flags |= PR_POLL_WRITE; |
| } |
| } |
| if (FD_ISSET(selectfd[index], &ex)) |
| out_flags |= PR_POLL_EXCEPT; |
| } |
| pds[index].out_flags = out_flags; |
| } |
| } |
| } |
| } |
| return ready; |
| |
| } /* _pr_poll_with_select */ |
| #endif /* _PR_POLL_WITH_SELECT */ |
| |
| PR_IMPLEMENT(PRInt32) PR_Poll( |
| PRPollDesc *pds, PRIntn npds, PRIntervalTime timeout) |
| { |
| #if defined(_PR_POLL_WITH_SELECT) |
| return(_pr_poll_with_select(pds, npds, timeout)); |
| #else |
| return(_pr_poll_with_poll(pds, npds, timeout)); |
| #endif |
| } |
| |
| PR_IMPLEMENT(PRDirEntry*) PR_ReadDir(PRDir *dir, PRDirFlags flags) |
| { |
| struct dirent *dp; |
| |
| if (pt_TestAbort()) return NULL; |
| |
| for (;;) |
| { |
| errno = 0; |
| dp = readdir(dir->md.d); |
| if (NULL == dp) |
| { |
| pt_MapError(_PR_MD_MAP_READDIR_ERROR, errno); |
| return NULL; |
| } |
| if ((flags & PR_SKIP_DOT) |
| && ('.' == dp->d_name[0]) |
| && (0 == dp->d_name[1])) continue; |
| if ((flags & PR_SKIP_DOT_DOT) |
| && ('.' == dp->d_name[0]) |
| && ('.' == dp->d_name[1]) |
| && (0 == dp->d_name[2])) continue; |
| if ((flags & PR_SKIP_HIDDEN) && ('.' == dp->d_name[0])) |
| continue; |
| break; |
| } |
| dir->d.name = dp->d_name; |
| return &dir->d; |
| } /* PR_ReadDir */ |
| |
| PR_IMPLEMENT(PRFileDesc*) PR_NewUDPSocket(void) |
| { |
| PRIntn domain = PF_INET; |
| |
| return PR_Socket(domain, SOCK_DGRAM, 0); |
| } /* PR_NewUDPSocket */ |
| |
| PR_IMPLEMENT(PRFileDesc*) PR_NewTCPSocket(void) |
| { |
| PRIntn domain = PF_INET; |
| |
| return PR_Socket(domain, SOCK_STREAM, 0); |
| } /* PR_NewTCPSocket */ |
| |
| PR_IMPLEMENT(PRFileDesc*) PR_OpenUDPSocket(PRIntn af) |
| { |
| return PR_Socket(af, SOCK_DGRAM, 0); |
| } /* PR_NewUDPSocket */ |
| |
| PR_IMPLEMENT(PRFileDesc*) PR_OpenTCPSocket(PRIntn af) |
| { |
| return PR_Socket(af, SOCK_STREAM, 0); |
| } /* PR_NewTCPSocket */ |
| |
| PR_IMPLEMENT(PRStatus) PR_NewTCPSocketPair(PRFileDesc *fds[2]) |
| { |
| #ifdef SYMBIAN |
| /* |
| * For the platforms that don't have socketpair. |
| * |
| * Copied from prsocket.c, with the parameter f[] renamed fds[] and the |
| * _PR_CONNECT_DOES_NOT_BIND code removed. |
| */ |
| PRFileDesc *listenSock; |
| PRNetAddr selfAddr, peerAddr; |
| PRUint16 port; |
| |
| fds[0] = fds[1] = NULL; |
| listenSock = PR_NewTCPSocket(); |
| if (listenSock == NULL) { |
| goto failed; |
| } |
| PR_InitializeNetAddr(PR_IpAddrLoopback, 0, &selfAddr); /* BugZilla: 35408 */ |
| if (PR_Bind(listenSock, &selfAddr) == PR_FAILURE) { |
| goto failed; |
| } |
| if (PR_GetSockName(listenSock, &selfAddr) == PR_FAILURE) { |
| goto failed; |
| } |
| port = ntohs(selfAddr.inet.port); |
| if (PR_Listen(listenSock, 5) == PR_FAILURE) { |
| goto failed; |
| } |
| fds[0] = PR_NewTCPSocket(); |
| if (fds[0] == NULL) { |
| goto failed; |
| } |
| PR_InitializeNetAddr(PR_IpAddrLoopback, port, &selfAddr); |
| |
| /* |
| * Only a thread is used to do the connect and accept. |
| * I am relying on the fact that PR_Connect returns |
| * successfully as soon as the connect request is put |
| * into the listen queue (but before PR_Accept is called). |
| * This is the behavior of the BSD socket code. If |
| * connect does not return until accept is called, we |
| * will need to create another thread to call connect. |
| */ |
| if (PR_Connect(fds[0], &selfAddr, PR_INTERVAL_NO_TIMEOUT) |
| == PR_FAILURE) { |
| goto failed; |
| } |
| /* |
| * A malicious local process may connect to the listening |
| * socket, so we need to verify that the accepted connection |
| * is made from our own socket fds[0]. |
| */ |
| if (PR_GetSockName(fds[0], &selfAddr) == PR_FAILURE) { |
| goto failed; |
| } |
| fds[1] = PR_Accept(listenSock, &peerAddr, PR_INTERVAL_NO_TIMEOUT); |
| if (fds[1] == NULL) { |
| goto failed; |
| } |
| if (peerAddr.inet.port != selfAddr.inet.port) { |
| /* the connection we accepted is not from fds[0] */ |
| PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, 0); |
| goto failed; |
| } |
| PR_Close(listenSock); |
| return PR_SUCCESS; |
| |
| failed: |
| if (listenSock) { |
| PR_Close(listenSock); |
| } |
| if (fds[0]) { |
| PR_Close(fds[0]); |
| } |
| if (fds[1]) { |
| PR_Close(fds[1]); |
| } |
| return PR_FAILURE; |
| #else |
| PRInt32 osfd[2]; |
| |
| if (pt_TestAbort()) return PR_FAILURE; |
| |
| if (socketpair(AF_UNIX, SOCK_STREAM, 0, osfd) == -1) { |
| pt_MapError(_PR_MD_MAP_SOCKETPAIR_ERROR, errno); |
| return PR_FAILURE; |
| } |
| |
| fds[0] = pt_SetMethods(osfd[0], PR_DESC_SOCKET_TCP, PR_FALSE, PR_FALSE); |
| if (fds[0] == NULL) { |
| close(osfd[0]); |
| close(osfd[1]); |
| return PR_FAILURE; |
| } |
| fds[1] = pt_SetMethods(osfd[1], PR_DESC_SOCKET_TCP, PR_FALSE, PR_FALSE); |
| if (fds[1] == NULL) { |
| PR_Close(fds[0]); |
| close(osfd[1]); |
| return PR_FAILURE; |
| } |
| return PR_SUCCESS; |
| #endif |
| } /* PR_NewTCPSocketPair */ |
| |
| PR_IMPLEMENT(PRStatus) PR_CreatePipe( |
| PRFileDesc **readPipe, |
| PRFileDesc **writePipe |
| ) |
| { |
| int pipefd[2]; |
| |
| if (pt_TestAbort()) return PR_FAILURE; |
| |
| if (pipe(pipefd) == -1) |
| { |
| /* XXX map pipe error */ |
| PR_SetError(PR_UNKNOWN_ERROR, errno); |
| return PR_FAILURE; |
| } |
| *readPipe = pt_SetMethods(pipefd[0], PR_DESC_PIPE, PR_FALSE, PR_FALSE); |
| if (NULL == *readPipe) |
| { |
| close(pipefd[0]); |
| close(pipefd[1]); |
| return PR_FAILURE; |
| } |
| *writePipe = pt_SetMethods(pipefd[1], PR_DESC_PIPE, PR_FALSE, PR_FALSE); |
| if (NULL == *writePipe) |
| { |
| PR_Close(*readPipe); |
| close(pipefd[1]); |
| return PR_FAILURE; |
| } |
| return PR_SUCCESS; |
| } |
| |
| /* |
| ** Set the inheritance attribute of a file descriptor. |
| */ |
| PR_IMPLEMENT(PRStatus) PR_SetFDInheritable( |
| PRFileDesc *fd, |
| PRBool inheritable) |
| { |
| /* |
| * Only a non-layered, NSPR file descriptor can be inherited |
| * by a child process. |
| */ |
| if (fd->identity != PR_NSPR_IO_LAYER) |
| { |
| PR_SetError(PR_INVALID_ARGUMENT_ERROR, 0); |
| return PR_FAILURE; |
| } |
| if (fd->secret->inheritable != inheritable) |
| { |
| if (fcntl(fd->secret->md.osfd, F_SETFD, |
| inheritable ? 0 : FD_CLOEXEC) == -1) |
| { |
| _PR_MD_MAP_DEFAULT_ERROR(errno); |
| return PR_FAILURE; |
| } |
| fd->secret->inheritable = (_PRTriStateBool) inheritable; |
| } |
| return PR_SUCCESS; |
| } |
| |
| /*****************************************************************************/ |
| /***************************** I/O friends methods ***************************/ |
| /*****************************************************************************/ |
| |
| PR_IMPLEMENT(PRFileDesc*) PR_ImportFile(PRInt32 osfd) |
| { |
| PRFileDesc *fd; |
| |
| if (!_pr_initialized) _PR_ImplicitInitialization(); |
| fd = pt_SetMethods(osfd, PR_DESC_FILE, PR_FALSE, PR_TRUE); |
| if (NULL == fd) close(osfd); |
| return fd; |
| } /* PR_ImportFile */ |
| |
| PR_IMPLEMENT(PRFileDesc*) PR_ImportPipe(PRInt32 osfd) |
| { |
| PRFileDesc *fd; |
| |
| if (!_pr_initialized) _PR_ImplicitInitialization(); |
| fd = pt_SetMethods(osfd, PR_DESC_PIPE, PR_FALSE, PR_TRUE); |
| if (NULL == fd) close(osfd); |
| return fd; |
| } /* PR_ImportPipe */ |
| |
| PR_IMPLEMENT(PRFileDesc*) PR_ImportTCPSocket(PRInt32 osfd) |
| { |
| PRFileDesc *fd; |
| |
| if (!_pr_initialized) _PR_ImplicitInitialization(); |
| fd = pt_SetMethods(osfd, PR_DESC_SOCKET_TCP, PR_FALSE, PR_TRUE); |
| if (NULL == fd) close(osfd); |
| #ifdef _PR_NEED_SECRET_AF |
| if (NULL != fd) fd->secret->af = PF_INET; |
| #endif |
| return fd; |
| } /* PR_ImportTCPSocket */ |
| |
| PR_IMPLEMENT(PRFileDesc*) PR_ImportUDPSocket(PRInt32 osfd) |
| { |
| PRFileDesc *fd; |
| |
| if (!_pr_initialized) _PR_ImplicitInitialization(); |
| fd = pt_SetMethods(osfd, PR_DESC_SOCKET_UDP, PR_FALSE, PR_TRUE); |
| if (NULL == fd) close(osfd); |
| return fd; |
| } /* PR_ImportUDPSocket */ |
| |
| PR_IMPLEMENT(PRFileDesc*) PR_CreateSocketPollFd(PRInt32 osfd) |
| { |
| PRFileDesc *fd; |
| |
| if (!_pr_initialized) _PR_ImplicitInitialization(); |
| |
| fd = _PR_Getfd(); |
| |
| if (fd == NULL) PR_SetError(PR_OUT_OF_MEMORY_ERROR, 0); |
| else |
| { |
| fd->secret->md.osfd = osfd; |
| fd->secret->inheritable = _PR_TRI_FALSE; |
| fd->secret->state = _PR_FILEDESC_OPEN; |
| fd->methods = PR_GetSocketPollFdMethods(); |
| } |
| |
| return fd; |
| } /* PR_CreateSocketPollFD */ |
| |
| PR_IMPLEMENT(PRStatus) PR_DestroySocketPollFd(PRFileDesc *fd) |
| { |
| if (NULL == fd) |
| { |
| PR_SetError(PR_BAD_DESCRIPTOR_ERROR, 0); |
| return PR_FAILURE; |
| } |
| fd->secret->state = _PR_FILEDESC_CLOSED; |
| _PR_Putfd(fd); |
| return PR_SUCCESS; |
| } /* PR_DestroySocketPollFd */ |
| |
| PR_IMPLEMENT(PRInt32) PR_FileDesc2NativeHandle(PRFileDesc *bottom) |
| { |
| PRInt32 osfd = -1; |
| bottom = (NULL == bottom) ? |
| NULL : PR_GetIdentitiesLayer(bottom, PR_NSPR_IO_LAYER); |
| if (NULL == bottom) PR_SetError(PR_INVALID_ARGUMENT_ERROR, 0); |
| else osfd = bottom->secret->md.osfd; |
| return osfd; |
| } /* PR_FileDesc2NativeHandle */ |
| |
| PR_IMPLEMENT(void) PR_ChangeFileDescNativeHandle(PRFileDesc *fd, |
| PRInt32 handle) |
| { |
| if (fd) fd->secret->md.osfd = handle; |
| } /* PR_ChangeFileDescNativeHandle*/ |
| |
| PR_IMPLEMENT(PRStatus) PR_LockFile(PRFileDesc *fd) |
| { |
| PRStatus status = PR_SUCCESS; |
| |
| if (pt_TestAbort()) return PR_FAILURE; |
| |
| PR_Lock(_pr_flock_lock); |
| while (-1 == fd->secret->lockCount) |
| PR_WaitCondVar(_pr_flock_cv, PR_INTERVAL_NO_TIMEOUT); |
| if (0 == fd->secret->lockCount) |
| { |
| fd->secret->lockCount = -1; |
| PR_Unlock(_pr_flock_lock); |
| status = _PR_MD_LOCKFILE(fd->secret->md.osfd); |
| PR_Lock(_pr_flock_lock); |
| fd->secret->lockCount = (PR_SUCCESS == status) ? 1 : 0; |
| PR_NotifyAllCondVar(_pr_flock_cv); |
| } |
| else |
| { |
| fd->secret->lockCount += 1; |
| } |
| PR_Unlock(_pr_flock_lock); |
| |
| return status; |
| } /* PR_LockFile */ |
| |
| PR_IMPLEMENT(PRStatus) PR_TLockFile(PRFileDesc *fd) |
| { |
| PRStatus status = PR_SUCCESS; |
| |
| if (pt_TestAbort()) return PR_FAILURE; |
| |
| PR_Lock(_pr_flock_lock); |
| if (0 == fd->secret->lockCount) |
| { |
| status = _PR_MD_TLOCKFILE(fd->secret->md.osfd); |
| if (PR_SUCCESS == status) fd->secret->lockCount = 1; |
| } |
| else fd->secret->lockCount += 1; |
| PR_Unlock(_pr_flock_lock); |
| |
| return status; |
| } /* PR_TLockFile */ |
| |
| PR_IMPLEMENT(PRStatus) PR_UnlockFile(PRFileDesc *fd) |
| { |
| PRStatus status = PR_SUCCESS; |
| |
| if (pt_TestAbort()) return PR_FAILURE; |
| |
| PR_Lock(_pr_flock_lock); |
| if (fd->secret->lockCount == 1) |
| { |
| status = _PR_MD_UNLOCKFILE(fd->secret->md.osfd); |
| if (PR_SUCCESS == status) fd->secret->lockCount = 0; |
| } |
| else fd->secret->lockCount -= 1; |
| PR_Unlock(_pr_flock_lock); |
| |
| return status; |
| } |
| |
| /* |
| * The next two entry points should not be in the API, but they are |
| * defined here for historical (or hysterical) reasons. |
| */ |
| |
| PR_IMPLEMENT(PRInt32) PR_GetSysfdTableMax(void) |
| { |
| #if defined(AIX) || defined(SYMBIAN) |
| return sysconf(_SC_OPEN_MAX); |
| #else |
| struct rlimit rlim; |
| |
| if ( getrlimit(RLIMIT_NOFILE, &rlim) < 0) |
| return -1; |
| |
| return rlim.rlim_max; |
| #endif |
| } |
| |
| PR_IMPLEMENT(PRInt32) PR_SetSysfdTableSize(PRIntn table_size) |
| { |
| #if defined(AIX) || defined(SYMBIAN) |
| return -1; |
| #else |
| struct rlimit rlim; |
| PRInt32 tableMax = PR_GetSysfdTableMax(); |
| |
| if (tableMax < 0) return -1; |
| rlim.rlim_max = tableMax; |
| |
| /* Grow as much as we can; even if too big */ |
| if ( rlim.rlim_max < table_size ) |
| rlim.rlim_cur = rlim.rlim_max; |
| else |
| rlim.rlim_cur = table_size; |
| |
| if ( setrlimit(RLIMIT_NOFILE, &rlim) < 0) |
| return -1; |
| |
| return rlim.rlim_cur; |
| #endif |
| } |
| |
| /* |
| * PR_Stat is supported for backward compatibility; some existing Java |
| * code uses it. New code should use PR_GetFileInfo. |
| */ |
| |
| #ifndef NO_NSPR_10_SUPPORT |
| PR_IMPLEMENT(PRInt32) PR_Stat(const char *name, struct stat *buf) |
| { |
| static PRBool unwarned = PR_TRUE; |
| if (unwarned) unwarned = _PR_Obsolete("PR_Stat", "PR_GetFileInfo"); |
| |
| if (pt_TestAbort()) return -1; |
| |
| if (-1 == stat(name, buf)) { |
| pt_MapError(_PR_MD_MAP_STAT_ERROR, errno); |
| return -1; |
| } else { |
| return 0; |
| } |
| } |
| #endif /* ! NO_NSPR_10_SUPPORT */ |
| |
| |
| PR_IMPLEMENT(void) PR_FD_ZERO(PR_fd_set *set) |
| { |
| static PRBool unwarned = PR_TRUE; |
| if (unwarned) unwarned = _PR_Obsolete("PR_FD_ZERO (PR_Select)", "PR_Poll"); |
| memset(set, 0, sizeof(PR_fd_set)); |
| } |
| |
| PR_IMPLEMENT(void) PR_FD_SET(PRFileDesc *fh, PR_fd_set *set) |
| { |
| static PRBool unwarned = PR_TRUE; |
| if (unwarned) unwarned = _PR_Obsolete("PR_FD_SET (PR_Select)", "PR_Poll"); |
| PR_ASSERT( set->hsize < PR_MAX_SELECT_DESC ); |
| |
| set->harray[set->hsize++] = fh; |
| } |
| |
| PR_IMPLEMENT(void) PR_FD_CLR(PRFileDesc *fh, PR_fd_set *set) |
| { |
| PRUint32 index, index2; |
| static PRBool unwarned = PR_TRUE; |
| if (unwarned) unwarned = _PR_Obsolete("PR_FD_CLR (PR_Select)", "PR_Poll"); |
| |
| for (index = 0; index<set->hsize; index++) |
| if (set->harray[index] == fh) { |
| for (index2=index; index2 < (set->hsize-1); index2++) { |
| set->harray[index2] = set->harray[index2+1]; |
| } |
| set->hsize--; |
| break; |
| } |
| } |
| |
| PR_IMPLEMENT(PRInt32) PR_FD_ISSET(PRFileDesc *fh, PR_fd_set *set) |
| { |
| PRUint32 index; |
| static PRBool unwarned = PR_TRUE; |
| if (unwarned) unwarned = _PR_Obsolete("PR_FD_ISSET (PR_Select)", "PR_Poll"); |
| for (index = 0; index<set->hsize; index++) |
| if (set->harray[index] == fh) { |
| return 1; |
| } |
| return 0; |
| } |
| |
| PR_IMPLEMENT(void) PR_FD_NSET(PRInt32 fd, PR_fd_set *set) |
| { |
| static PRBool unwarned = PR_TRUE; |
| if (unwarned) unwarned = _PR_Obsolete("PR_FD_NSET (PR_Select)", "PR_Poll"); |
| PR_ASSERT( set->nsize < PR_MAX_SELECT_DESC ); |
| |
| set->narray[set->nsize++] = fd; |
| } |
| |
| PR_IMPLEMENT(void) PR_FD_NCLR(PRInt32 fd, PR_fd_set *set) |
| { |
| PRUint32 index, index2; |
| static PRBool unwarned = PR_TRUE; |
| if (unwarned) unwarned = _PR_Obsolete("PR_FD_NCLR (PR_Select)", "PR_Poll"); |
| |
| for (index = 0; index<set->nsize; index++) |
| if (set->narray[index] == fd) { |
| for (index2=index; index2 < (set->nsize-1); index2++) { |
| set->narray[index2] = set->narray[index2+1]; |
| } |
| set->nsize--; |
| break; |
| } |
| } |
| |
| PR_IMPLEMENT(PRInt32) PR_FD_NISSET(PRInt32 fd, PR_fd_set *set) |
| { |
| PRUint32 index; |
| static PRBool unwarned = PR_TRUE; |
| if (unwarned) unwarned = _PR_Obsolete("PR_FD_NISSET (PR_Select)", "PR_Poll"); |
| for (index = 0; index<set->nsize; index++) |
| if (set->narray[index] == fd) { |
| return 1; |
| } |
| return 0; |
| } |
| |
| #include <sys/types.h> |
| #include <sys/time.h> |
| #if !defined(HPUX) \ |
| && !defined(LINUX) && !defined(__GNU__) && !defined(__GLIBC__) |
| #include <sys/select.h> |
| #endif |
| |
| static PRInt32 |
| _PR_getset(PR_fd_set *pr_set, fd_set *set) |
| { |
| PRUint32 index; |
| PRInt32 max = 0; |
| |
| if (!pr_set) |
| return 0; |
| |
| FD_ZERO(set); |
| |
| /* First set the pr file handle osfds */ |
| for (index=0; index<pr_set->hsize; index++) { |
| FD_SET(pr_set->harray[index]->secret->md.osfd, set); |
| if (pr_set->harray[index]->secret->md.osfd > max) |
| max = pr_set->harray[index]->secret->md.osfd; |
| } |
| /* Second set the native osfds */ |
| for (index=0; index<pr_set->nsize; index++) { |
| FD_SET(pr_set->narray[index], set); |
| if (pr_set->narray[index] > max) |
| max = pr_set->narray[index]; |
| } |
| return max; |
| } |
| |
| static void |
| _PR_setset(PR_fd_set *pr_set, fd_set *set) |
| { |
| PRUint32 index, last_used; |
| |
| if (!pr_set) |
| return; |
| |
| for (last_used=0, index=0; index<pr_set->hsize; index++) { |
| if ( FD_ISSET(pr_set->harray[index]->secret->md.osfd, set) ) { |
| pr_set->harray[last_used++] = pr_set->harray[index]; |
| } |
| } |
| pr_set->hsize = last_used; |
| |
| for (last_used=0, index=0; index<pr_set->nsize; index++) { |
| if ( FD_ISSET(pr_set->narray[index], set) ) { |
| pr_set->narray[last_used++] = pr_set->narray[index]; |
| } |
| } |
| pr_set->nsize = last_used; |
| } |
| |
| PR_IMPLEMENT(PRInt32) PR_Select( |
| PRInt32 unused, PR_fd_set *pr_rd, PR_fd_set *pr_wr, |
| PR_fd_set *pr_ex, PRIntervalTime timeout) |
| { |
| fd_set rd, wr, ex; |
| struct timeval tv, *tvp; |
| PRInt32 max, max_fd; |
| PRInt32 rv; |
| /* |
| * For restarting select() if it is interrupted by a Unix signal. |
| * We use these variables to figure out how much time has elapsed |
| * and how much of the timeout still remains. |
| */ |
| PRIntervalTime start = 0, elapsed, remaining; |
| |
| static PRBool unwarned = PR_TRUE; |
| if (unwarned) unwarned = _PR_Obsolete( "PR_Select", "PR_Poll"); |
| |
| FD_ZERO(&rd); |
| FD_ZERO(&wr); |
| FD_ZERO(&ex); |
| |
| max_fd = _PR_getset(pr_rd, &rd); |
| max_fd = (max = _PR_getset(pr_wr, &wr))>max_fd?max:max_fd; |
| max_fd = (max = _PR_getset(pr_ex, &ex))>max_fd?max:max_fd; |
| |
| if (timeout == PR_INTERVAL_NO_TIMEOUT) { |
| tvp = NULL; |
| } else { |
| tv.tv_sec = (PRInt32)PR_IntervalToSeconds(timeout); |
| tv.tv_usec = (PRInt32)PR_IntervalToMicroseconds( |
| timeout - PR_SecondsToInterval(tv.tv_sec)); |
| tvp = &tv; |
| start = PR_IntervalNow(); |
| } |
| |
| retry: |
| rv = select(max_fd + 1, (_PRSelectFdSetArg_t) &rd, |
| (_PRSelectFdSetArg_t) &wr, (_PRSelectFdSetArg_t) &ex, tvp); |
| |
| if (rv == -1 && errno == EINTR) { |
| if (timeout == PR_INTERVAL_NO_TIMEOUT) { |
| goto retry; |
| } else { |
| elapsed = (PRIntervalTime) (PR_IntervalNow() - start); |
| if (elapsed > timeout) { |
| rv = 0; /* timed out */ |
| } else { |
| remaining = timeout - elapsed; |
| tv.tv_sec = (PRInt32)PR_IntervalToSeconds(remaining); |
| tv.tv_usec = (PRInt32)PR_IntervalToMicroseconds( |
| remaining - PR_SecondsToInterval(tv.tv_sec)); |
| goto retry; |
| } |
| } |
| } |
| |
| if (rv > 0) { |
| _PR_setset(pr_rd, &rd); |
| _PR_setset(pr_wr, &wr); |
| _PR_setset(pr_ex, &ex); |
| } else if (rv == -1) { |
| pt_MapError(_PR_MD_MAP_SELECT_ERROR, errno); |
| } |
| return rv; |
| } |
| #endif /* defined(_PR_PTHREADS) */ |
| |
| #ifdef MOZ_UNICODE |
| /* ================ UTF16 Interfaces ================================ */ |
| PR_IMPLEMENT(PRFileDesc*) PR_OpenFileUTF16( |
| const PRUnichar *name, PRIntn flags, PRIntn mode) |
| { |
| PR_SetError(PR_NOT_IMPLEMENTED_ERROR, 0); |
| return NULL; |
| } |
| |
| PR_IMPLEMENT(PRStatus) PR_CloseDirUTF16(PRDir *dir) |
| { |
| PR_SetError(PR_NOT_IMPLEMENTED_ERROR, 0); |
| return PR_FAILURE; |
| } |
| |
| PR_IMPLEMENT(PRDirUTF16*) PR_OpenDirUTF16(const PRUnichar *name) |
| { |
| PR_SetError(PR_NOT_IMPLEMENTED_ERROR, 0); |
| return NULL; |
| } |
| |
| PR_IMPLEMENT(PRDirEntryUTF16*) PR_ReadDirUTF16(PRDirUTF16 *dir, PRDirFlags flags) |
| { |
| PR_SetError(PR_NOT_IMPLEMENTED_ERROR, 0); |
| return NULL; |
| } |
| |
| PR_IMPLEMENT(PRStatus) PR_GetFileInfo64UTF16(const PRUnichar *fn, PRFileInfo64 *info) |
| { |
| PR_SetError(PR_NOT_IMPLEMENTED_ERROR, 0); |
| return PR_FAILURE; |
| } |
| /* ================ UTF16 Interfaces ================================ */ |
| #endif /* MOZ_UNICODE */ |
| |
| /* ptio.c */ |