The Tor Browser: nsprpub/pr/src/io/prfile.c@6474c204b198 (annotated)

nsprpub/pr/src/io/prfile.c@6474c204b198 (annotated)

nsprpub/pr/src/io/prfile.c

Wed, 31 Dec 2014 06:09:35 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:09:35 +0100
changeset 0: 6474c204b198
permissions: -rw-r--r--

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 #include "primpl.h"
 #include <string.h>
 #include <fcntl.h>
 #ifdef XP_UNIX
 #if defined(AIX) || defined(QNX)
 /* To pick up sysconf */
 #include <unistd.h>
 #else
 /* To pick up getrlimit, setrlimit */
 #include <sys/time.h>
 #include <sys/resource.h>
 #endif
 #endif /* XP_UNIX */
 extern PRLock *_pr_flock_lock;
 extern PRCondVar *_pr_flock_cv;
 static PRInt32 PR_CALLBACK FileRead(PRFileDesc *fd, void *buf, PRInt32 amount)
 {
     PRInt32 rv = 0;
     PRThread *me = _PR_MD_CURRENT_THREAD();
     if (_PR_PENDING_INTERRUPT(me)) {
  		me->flags &= ~_PR_INTERRUPT;
 		PR_SetError(PR_PENDING_INTERRUPT_ERROR, 0);
 		rv = -1;
     }
     if (_PR_IO_PENDING(me)) {
         PR_SetError(PR_IO_PENDING_ERROR, 0);
 	rv = -1;
     }
     if (rv == -1)
     	return rv;
 	rv = _PR_MD_READ(fd, buf, amount);
 	if (rv < 0) {
 		PR_ASSERT(rv == -1);
 	}
     PR_LOG(_pr_io_lm, PR_LOG_MAX, ("read -> %d", rv));
     return rv;
 }
 static PRInt32 PR_CALLBACK FileWrite(PRFileDesc *fd, const void *buf, PRInt32 amount)
 {
     PRInt32 rv = 0;
     PRInt32 temp, count;
     PRThread *me = _PR_MD_CURRENT_THREAD();
     if (_PR_PENDING_INTERRUPT(me)) {
         me->flags &= ~_PR_INTERRUPT;
         PR_SetError(PR_PENDING_INTERRUPT_ERROR, 0);
 	    rv = -1;
     }
     if (_PR_IO_PENDING(me)) {
         PR_SetError(PR_IO_PENDING_ERROR, 0);
 	    rv = -1;
     }
     if (rv != 0)
     	return rv;
     count = 0;
 #if !defined(_PR_HAVE_O_APPEND)  /* Bugzilla: 4090, 276330 */
     if (fd->secret->appendMode) {
         if (PR_Seek64(fd, 0, PR_SEEK_END) == -1) {
             return -1;
         }
     } /* if (fd->secret->appendMode...) */
 #endif /* _PR_HAVE_O_APPEND */
     while (amount > 0) {
 		temp = _PR_MD_WRITE(fd, buf, amount);
 		if (temp < 0) {
 			count = -1;
 			break;
 		}
 		count += temp;
 		if (fd->secret->nonblocking) {
 			break;
 		}
 		buf = (const void*) ((const char*)buf + temp);
 		amount -= temp;
     }
     PR_LOG(_pr_io_lm, PR_LOG_MAX, ("write -> %d", count));
     return count;
 }
 static PROffset32 PR_CALLBACK FileSeek(PRFileDesc *fd, PROffset32 offset, PRSeekWhence whence)
 {
     PROffset32 result;
     result = _PR_MD_LSEEK(fd, offset, whence);
     return result;
 }
 static PROffset64 PR_CALLBACK FileSeek64(PRFileDesc *fd, PROffset64 offset, PRSeekWhence whence)
 {
     PROffset64 result;
     result = _PR_MD_LSEEK64(fd, offset, whence);
     return result;
 }
 static PRInt32 PR_CALLBACK FileAvailable(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;
 }
 static PRInt64 PR_CALLBACK FileAvailable64(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;
 }
 static PRInt32 PR_CALLBACK PipeAvailable(PRFileDesc *fd)
 {
 	PRInt32 rv;
 	rv =  _PR_MD_PIPEAVAILABLE(fd);
 	return rv;
 }
 static PRInt64 PR_CALLBACK PipeAvailable64(PRFileDesc *fd)
 {
     PRInt64 rv;
     LL_I2L(rv, _PR_MD_PIPEAVAILABLE(fd));
 	return rv;
 }
 static PRStatus PR_CALLBACK PipeSync(PRFileDesc *fd)
 {
 	return PR_SUCCESS;
 }
 static PRStatus PR_CALLBACK FileGetInfo(PRFileDesc *fd, PRFileInfo *info)
 {
 	PRInt32 rv;
     rv = _PR_MD_GETOPENFILEINFO(fd, info);
     if (rv < 0) {
 	return PR_FAILURE;
     } else
 	return PR_SUCCESS;
 }
 static PRStatus PR_CALLBACK FileGetInfo64(PRFileDesc *fd, PRFileInfo64 *info)
 {
     /* $$$$ NOT YET IMPLEMENTED */
 	PRInt32 rv;
     rv = _PR_MD_GETOPENFILEINFO64(fd, info);
     if (rv < 0) return PR_FAILURE;
     else return PR_SUCCESS;
 }
 static PRStatus PR_CALLBACK FileSync(PRFileDesc *fd)
 {
     PRInt32 result;
     result = _PR_MD_FSYNC(fd);
     if (result < 0) {
 		return PR_FAILURE;
     }
     return PR_SUCCESS;
 }
 static PRStatus PR_CALLBACK FileClose(PRFileDesc *fd)
 {
     if (!fd || !fd->secret
             || (fd->secret->state != _PR_FILEDESC_OPEN
             && fd->secret->state != _PR_FILEDESC_CLOSED)) {
         PR_SetError(PR_BAD_DESCRIPTOR_ERROR, 0);
         return PR_FAILURE;
     }
     if (fd->secret->state == _PR_FILEDESC_OPEN) {
         if (_PR_MD_CLOSE_FILE(fd->secret->md.osfd) < 0) {
             return PR_FAILURE;
         }
         fd->secret->state = _PR_FILEDESC_CLOSED;
     }
     PR_FreeFileDesc(fd);
     return PR_SUCCESS;
 }
 static PRInt16 PR_CALLBACK FilePoll(
     PRFileDesc *fd, PRInt16 in_flags, PRInt16 *out_flags)
 {
     *out_flags = 0;
     return in_flags;
 }  /* FilePoll */
 static PRIOMethods _pr_fileMethods = {
     PR_DESC_FILE,
     FileClose,
     FileRead,
     FileWrite,
     FileAvailable,
     FileAvailable64,
     FileSync,
     FileSeek,
     FileSeek64,
     FileGetInfo,
     FileGetInfo64,
     (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,
     FilePoll,
     (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
 };
 PR_IMPLEMENT(const PRIOMethods*) PR_GetFileMethods(void)
 {
     return &_pr_fileMethods;
 }
 static PRIOMethods _pr_pipeMethods = {
     PR_DESC_PIPE,
     FileClose,
     FileRead,
     FileWrite,
     PipeAvailable,
     PipeAvailable64,
     PipeSync,
     (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,
     FilePoll,
     (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
 };
 PR_IMPLEMENT(const PRIOMethods*) PR_GetPipeMethods(void)
 {
     return &_pr_pipeMethods;
 }
 PR_IMPLEMENT(PRFileDesc*) PR_Open(const char *name, PRIntn flags, PRIntn mode)
 {
     PROsfd osfd;
     PRFileDesc *fd = 0;
 #if !defined(_PR_HAVE_O_APPEND)
     PRBool  appendMode = ( PR_APPEND & flags )? PR_TRUE : PR_FALSE;
 #endif
     if (!_pr_initialized) _PR_ImplicitInitialization();
     /* Map pr open flags and mode to os specific flags */
     osfd = _PR_MD_OPEN(name, flags, mode);
     if (osfd != -1) {
         fd = PR_AllocFileDesc(osfd, &_pr_fileMethods);
         if (!fd) {
             (void) _PR_MD_CLOSE_FILE(osfd);
         } else {
 #if !defined(_PR_HAVE_O_APPEND)
             fd->secret->appendMode = appendMode;
 #endif
             _PR_MD_INIT_FD_INHERITABLE(fd, PR_FALSE);
         }
     }
     return fd;
 }
 PR_IMPLEMENT(PRFileDesc*) PR_OpenFile(
     const char *name, PRIntn flags, PRIntn mode)
 {
     PROsfd osfd;
     PRFileDesc *fd = 0;
 #if !defined(_PR_HAVE_O_APPEND)
     PRBool  appendMode = ( PR_APPEND & flags )? PR_TRUE : PR_FALSE;
 #endif
     if (!_pr_initialized) _PR_ImplicitInitialization();
     /* Map pr open flags and mode to os specific flags */
     osfd = _PR_MD_OPEN_FILE(name, flags, mode);
     if (osfd != -1) {
         fd = PR_AllocFileDesc(osfd, &_pr_fileMethods);
         if (!fd) {
             (void) _PR_MD_CLOSE_FILE(osfd);
         } else {
 #if !defined(_PR_HAVE_O_APPEND)
             fd->secret->appendMode = appendMode;
 #endif
             _PR_MD_INIT_FD_INHERITABLE(fd, PR_FALSE);
         }
     }
     return fd;
 }
 PR_IMPLEMENT(PRInt32) PR_GetSysfdTableMax(void)
 {
 #if defined(XP_UNIX) && !defined(AIX) && !defined(QNX)
     struct rlimit rlim;
     if ( getrlimit(RLIMIT_NOFILE, &rlim) < 0) {
        /* XXX need to call PR_SetError() */
        return -1;
     }
     return rlim.rlim_max;
 #elif defined(AIX) || defined(QNX)
     return sysconf(_SC_OPEN_MAX);
 #elif defined(WIN32)
     /*
      * There is a systemwide limit of 65536 user handles.
      */
     return 16384;
 #elif defined (WIN16)
     return FOPEN_MAX;
 #elif defined(XP_OS2)
     ULONG ulReqCount = 0;
     ULONG ulCurMaxFH = 0;
     DosSetRelMaxFH(&ulReqCount, &ulCurMaxFH);
     return ulCurMaxFH;
 #elif defined(XP_BEOS)
     PR_SetError(PR_NOT_IMPLEMENTED_ERROR, 0);
    return -1;
 #else
     write me;
 #endif
 }
 PR_IMPLEMENT(PRInt32) PR_SetSysfdTableSize(int table_size)
 {
 #if defined(XP_UNIX) && !defined(AIX) && !defined(QNX)
     struct rlimit rlim;
     PRInt32 tableMax = PR_GetSysfdTableMax();
     if (tableMax < 0)
         return -1;
     if (tableMax > FD_SETSIZE)
         tableMax = FD_SETSIZE;
     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) {
         /* XXX need to call PR_SetError() */
         return -1;
     }
     return rlim.rlim_cur;
 #elif defined(XP_OS2)
     PRInt32 tableMax = PR_GetSysfdTableMax();
     if (table_size > tableMax) {
       APIRET rc = NO_ERROR;
       rc = DosSetMaxFH(table_size);
       if (rc == NO_ERROR)
         return table_size;
       else
         return -1;
     }
     return tableMax;
 #elif defined(AIX) || defined(QNX) \
         || defined(WIN32) || defined(WIN16) || defined(XP_BEOS)
     PR_SetError(PR_NOT_IMPLEMENTED_ERROR, 0);
     return -1;
 #else
     write me;
 #endif
 }
 PR_IMPLEMENT(PRStatus) PR_Delete(const char *name)
 {
 	PRInt32 rv;
 	rv = _PR_MD_DELETE(name);
 	if (rv < 0) {
 		return PR_FAILURE;
 	} else
 		return PR_SUCCESS;
 }
 PR_IMPLEMENT(PRStatus) PR_GetFileInfo(const char *fn, PRFileInfo *info)
 {
 	PRInt32 rv;
 	rv = _PR_MD_GETFILEINFO(fn, info);
 	if (rv < 0) {
 		return PR_FAILURE;
 	} else
 		return PR_SUCCESS;
 }
 PR_IMPLEMENT(PRStatus) PR_GetFileInfo64(const char *fn, PRFileInfo64 *info)
 {
     PRInt32 rv;
     if (!_pr_initialized) _PR_ImplicitInitialization();
     rv = _PR_MD_GETFILEINFO64(fn, info);
     if (rv < 0) {
         return PR_FAILURE;
     } else {
         return PR_SUCCESS;
     }
 }
 PR_IMPLEMENT(PRStatus) PR_Rename(const char *from, const char *to)
 {
 	PRInt32 rv;
 	rv = _PR_MD_RENAME(from, to);
 	if (rv < 0) {
 		return PR_FAILURE;
 	} else
 		return PR_SUCCESS;
 }
 PR_IMPLEMENT(PRStatus) PR_Access(const char *name, PRAccessHow how)
 {
 PRInt32 rv;
 	rv = _PR_MD_ACCESS(name, how);
 	if (rv < 0) {
 		return PR_FAILURE;
 	} else
 		return PR_SUCCESS;
 }
 /*
 ** Import an existing OS file to NSPR
 */
 PR_IMPLEMENT(PRFileDesc*) PR_ImportFile(PROsfd osfd)
 {
     PRFileDesc *fd = NULL;
     if (!_pr_initialized) _PR_ImplicitInitialization();
     fd = PR_AllocFileDesc(osfd, &_pr_fileMethods);
     if( !fd ) {
         (void) _PR_MD_CLOSE_FILE(osfd);
     } else {
         _PR_MD_INIT_FD_INHERITABLE(fd, PR_TRUE);
     }
     return fd;
 }
 /*
 ** Import an existing OS pipe to NSPR
 */
 PR_IMPLEMENT(PRFileDesc*) PR_ImportPipe(PROsfd osfd)
 {
     PRFileDesc *fd = NULL;
     if (!_pr_initialized) _PR_ImplicitInitialization();
     fd = PR_AllocFileDesc(osfd, &_pr_pipeMethods);
     if( !fd ) {
         (void) _PR_MD_CLOSE_FILE(osfd);
     } else {
         _PR_MD_INIT_FD_INHERITABLE(fd, PR_TRUE);
 #ifdef WINNT
         fd->secret->md.sync_file_io = PR_TRUE;
 #endif
     }
     return fd;
 }
 #ifndef NO_NSPR_10_SUPPORT
 /*
 ** PR_Stat() for Win16 is defined in w16io.c
 ** it is a hack to circumvent problems in Gromit and Java
 ** See also: BugSplat: 98516.
 */
 #if !defined(WIN16)
 /*
  * This function is supposed to be for backward compatibility with
  * nspr 1.0.  Therefore, it still uses the nspr 1.0 error-reporting
  * mechanism -- returns a PRInt32, which is the error code when the call
  * fails.
  *
  * If we need this function in nspr 2.0, it should be changed to
  * return PRStatus, as follows:
  *
  * PR_IMPLEMENT(PRStatus) PR_Stat(const char *name, struct stat *buf)
  * {
  *     PRInt32 rv;
  *
  *     rv = _PR_MD_STAT(name, buf);
  *     if (rv < 0)
  *         return PR_FAILURE;
  *     else
  *         return PR_SUCCESS;
  * }
  *
  * -- wtc, 2/14/97.
  */
 PR_IMPLEMENT(PRInt32) PR_Stat(const char *name, struct stat *buf)
 {
     PRInt32 rv;
     rv = _PR_MD_STAT(name, buf);
 	return rv;
 }
 #endif /* !defined(WIN16)  */
 #endif /* ! NO_NSPR_10_SUPPORT */
 PR_IMPLEMENT(PRStatus) PR_LockFile(PRFileDesc *fd)
 {
     PRStatus status = PR_SUCCESS;
 #ifdef WINNT
     if (!fd->secret->md.io_model_committed) {
         PRInt32 rv;
         rv = _md_Associate((HANDLE)fd->secret->md.osfd);
         PR_ASSERT(0 != rv);
         fd->secret->md.io_model_committed = PR_TRUE;
     }
 #endif
     PR_Lock(_pr_flock_lock);
     while (fd->secret->lockCount == -1)
         PR_WaitCondVar(_pr_flock_cv, PR_INTERVAL_NO_TIMEOUT);
     if (fd->secret->lockCount == 0) {
         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 = (status == PR_SUCCESS) ? 1 : 0;
         PR_NotifyAllCondVar(_pr_flock_cv);
     } else {
         fd->secret->lockCount++;
     }
     PR_Unlock(_pr_flock_lock);
     return status;
 }
 PR_IMPLEMENT(PRStatus) PR_TLockFile(PRFileDesc *fd)
 {
     PRStatus status = PR_SUCCESS;
 #ifdef WINNT
     if (!fd->secret->md.io_model_committed) {
         PRInt32 rv;
         rv = _md_Associate((HANDLE)fd->secret->md.osfd);
         PR_ASSERT(0 != rv);
         fd->secret->md.io_model_committed = PR_TRUE;
     }
 #endif
     PR_Lock(_pr_flock_lock);
     if (fd->secret->lockCount == 0) {
         status = _PR_MD_TLOCKFILE(fd->secret->md.osfd);
         PR_ASSERT(status == PR_SUCCESS || fd->secret->lockCount == 0);
         if (status == PR_SUCCESS)
             fd->secret->lockCount = 1;
     } else {
         fd->secret->lockCount++;
     }
     PR_Unlock(_pr_flock_lock);
     return status;
 }
 PR_IMPLEMENT(PRStatus) PR_UnlockFile(PRFileDesc *fd)
 {
     PRStatus rv = PR_SUCCESS;
     PR_Lock(_pr_flock_lock);
     if (fd->secret->lockCount == 1) {
         rv = _PR_MD_UNLOCKFILE(fd->secret->md.osfd);
         if (rv == PR_SUCCESS)
             fd->secret->lockCount = 0;
     } else {
         fd->secret->lockCount--;
     }
     PR_Unlock(_pr_flock_lock);
     return rv;
 }
 PR_IMPLEMENT(PRStatus) PR_CreatePipe(
     PRFileDesc **readPipe,
     PRFileDesc **writePipe
 )
 {
 #if defined(WIN32) && !defined(WINCE)
     HANDLE readEnd, writeEnd;
     SECURITY_ATTRIBUTES pipeAttributes;
     if (!_pr_initialized) _PR_ImplicitInitialization();
     ZeroMemory(&pipeAttributes, sizeof(pipeAttributes));
     pipeAttributes.nLength = sizeof(pipeAttributes);
     pipeAttributes.bInheritHandle = TRUE;
     if (CreatePipe(&readEnd, &writeEnd, &pipeAttributes, 0) == 0) {
         PR_SetError(PR_UNKNOWN_ERROR, GetLastError());
         return PR_FAILURE;
     }
     *readPipe = PR_AllocFileDesc((PROsfd)readEnd, &_pr_pipeMethods);
     if (NULL == *readPipe) {
         CloseHandle(readEnd);
         CloseHandle(writeEnd);
         return PR_FAILURE;
     }
     *writePipe = PR_AllocFileDesc((PROsfd)writeEnd, &_pr_pipeMethods);
     if (NULL == *writePipe) {
         PR_Close(*readPipe);
         CloseHandle(writeEnd);
         return PR_FAILURE;
     }
 #ifdef WINNT
     (*readPipe)->secret->md.sync_file_io = PR_TRUE;
     (*writePipe)->secret->md.sync_file_io = PR_TRUE;
 #endif
     (*readPipe)->secret->inheritable = _PR_TRI_TRUE;
     (*writePipe)->secret->inheritable = _PR_TRI_TRUE;
     return PR_SUCCESS;
 #elif defined(XP_UNIX) || defined(XP_OS2) || defined(XP_BEOS)
 #ifdef XP_OS2
     HFILE pipefd[2];
 #else
     int pipefd[2];
 #endif
     if (!_pr_initialized) _PR_ImplicitInitialization();
 #ifdef XP_OS2
     if (DosCreatePipe(&pipefd[0], &pipefd[1], 4096) != 0) {
 #else
     if (pipe(pipefd) == -1) {
 #endif
         /* XXX map pipe error */
         PR_SetError(PR_UNKNOWN_ERROR, errno);
         return PR_FAILURE;
     }
     *readPipe = PR_AllocFileDesc(pipefd[0], &_pr_pipeMethods);
     if (NULL == *readPipe) {
         close(pipefd[0]);
         close(pipefd[1]);
         return PR_FAILURE;
     }
     *writePipe = PR_AllocFileDesc(pipefd[1], &_pr_pipeMethods);
     if (NULL == *writePipe) {
         PR_Close(*readPipe);
         close(pipefd[1]);
         return PR_FAILURE;
     }
 #ifndef XP_BEOS /* Pipes are nonblocking on BeOS */
     _PR_MD_MAKE_NONBLOCK(*readPipe);
 #endif
     _PR_MD_INIT_FD_INHERITABLE(*readPipe, PR_FALSE);
 #ifndef XP_BEOS /* Pipes are nonblocking on BeOS */
     _PR_MD_MAKE_NONBLOCK(*writePipe);
 #endif
     _PR_MD_INIT_FD_INHERITABLE(*writePipe, PR_FALSE);
     return PR_SUCCESS;
 #else
     PR_SetError(PR_NOT_IMPLEMENTED_ERROR, 0);
     return PR_FAILURE;
 #endif
 }
 #ifdef MOZ_UNICODE
 /* ================ UTF16 Interfaces ================================ */
 PR_IMPLEMENT(PRFileDesc*) PR_OpenFileUTF16(
     const PRUnichar *name, PRIntn flags, PRIntn mode)
 {
     PROsfd osfd;
     PRFileDesc *fd = 0;
 #if !defined(_PR_HAVE_O_APPEND)
     PRBool  appendMode = ( PR_APPEND & flags )? PR_TRUE : PR_FALSE;
 #endif
     if (!_pr_initialized) _PR_ImplicitInitialization();
     /* Map pr open flags and mode to os specific flags */
     osfd = _PR_MD_OPEN_FILE_UTF16(name, flags, mode);
     if (osfd != -1) {
         fd = PR_AllocFileDesc(osfd, &_pr_fileMethods);
         if (!fd) {
             (void) _PR_MD_CLOSE_FILE(osfd);
         } else {
 #if !defined(_PR_HAVE_O_APPEND)
             fd->secret->appendMode = appendMode;
 #endif
             _PR_MD_INIT_FD_INHERITABLE(fd, PR_FALSE);
         }
     }
     return fd;
 }
 PR_IMPLEMENT(PRStatus) PR_GetFileInfo64UTF16(const PRUnichar *fn, PRFileInfo64 *info)
 {
     PRInt32 rv;
     if (!_pr_initialized) _PR_ImplicitInitialization();
     rv = _PR_MD_GETFILEINFO64_UTF16(fn, info);
     if (rv < 0) {
         return PR_FAILURE;
     } else {
         return PR_SUCCESS;
     }
 }
 /* ================ UTF16 Interfaces ================================ */
 #endif /* MOZ_UNICODE */

The Tor Browser / annotate

nsprpub/pr/src/io/prfile.c@6474c204b198 (annotated)

nsprpub/pr/src/io/prfile.c