The Tor Browser: nsprpub/pr/src/md/beos/bfile.c@6474c204b198 (annotated)

nsprpub/pr/src/md/beos/bfile.c@6474c204b198 (annotated)

nsprpub/pr/src/md/beos/bfile.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: 8; c-basic-offset: 8 -*- */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 #include "primpl.h"
 /*
 ** Global lock variable used to bracket calls into rusty libraries that
 ** aren't thread safe (like libc, libX, etc).
 */
 static PRLock *_pr_rename_lock = NULL;
 void
 _MD_InitIO (void)
 {
 }
 PRStatus
 _MD_open_dir (_MDDir *md,const char *name)
 {
 int err;
 	md->d = opendir(name);
 	if (!md->d) {
 		err = _MD_ERRNO();
 		_PR_MD_MAP_OPENDIR_ERROR(err);
 		return PR_FAILURE;
 	}
 	return PR_SUCCESS;
 }
 char*
 _MD_read_dir (_MDDir *md, PRIntn flags)
 {
 struct dirent *de;
 int err;
 	for (;;) {
 		/*
 		 * XXX: readdir() is not MT-safe
 		 */
 		_MD_ERRNO() = 0;
 		de = readdir(md->d);
 		if (!de) {
 			err = _MD_ERRNO();
 			_PR_MD_MAP_READDIR_ERROR(err);
 			return 0;
 		}
 		if ((flags & PR_SKIP_DOT) &&
 		    (de->d_name[0] == '.') && (de->d_name[1] == 0))
 			continue;
 		if ((flags & PR_SKIP_DOT_DOT) &&
 		    (de->d_name[0] == '.') && (de->d_name[1] == '.') &&
 		    (de->d_name[2] == 0))
 			continue;
 		if ((flags & PR_SKIP_HIDDEN) && (de->d_name[1] == '.'))
 			continue;
 		break;
 	}
 	return de->d_name;
 }
 PRInt32
 _MD_close_dir (_MDDir *md)
 {
 int rv = 0, err;
 	if (md->d) {
 		rv = closedir(md->d);
 		if (rv == -1) {
 			err = _MD_ERRNO();
 			_PR_MD_MAP_CLOSEDIR_ERROR(err);
 		}
 	}
 	return(rv);
 }
 void
 _MD_make_nonblock (PRFileDesc *fd)
 {
 	int blocking = 1;
 	setsockopt(fd->secret->md.osfd, SOL_SOCKET, SO_NONBLOCK, &blocking, sizeof(blocking));
 }
 PRStatus
 _MD_set_fd_inheritable (PRFileDesc *fd, PRBool inheritable)
 {
         int rv;
         rv = fcntl(fd->secret->md.osfd, F_SETFD, inheritable ? 0 : FD_CLOEXEC);
         if (-1 == rv) {
                 PR_SetError(PR_UNKNOWN_ERROR, _MD_ERRNO());
                 return PR_FAILURE;
         }
         return PR_SUCCESS;
 }
 void
 _MD_init_fd_inheritable (PRFileDesc *fd, PRBool imported)
 {
 	if (imported) {
 		fd->secret->inheritable = _PR_TRI_UNKNOWN;
 	} else {
 		int flags = fcntl(fd->secret->md.osfd, F_GETFD, 0);
 		if (flags == -1) {
 			PR_SetError(PR_UNKNOWN_ERROR, _MD_ERRNO());
 			return;
 		}
 		fd->secret->inheritable = (flags & FD_CLOEXEC) ?
 			_PR_TRI_TRUE : _PR_TRI_FALSE;
 	}
 }
 void
 _MD_query_fd_inheritable (PRFileDesc *fd)
 {
 	int flags;
 	PR_ASSERT(_PR_TRI_UNKNOWN == fd->secret->inheritable);
 	flags = fcntl(fd->secret->md.osfd, F_GETFD, 0);
 	PR_ASSERT(-1 != flags);
 	fd->secret->inheritable = (flags & FD_CLOEXEC) ?
 		_PR_TRI_FALSE : _PR_TRI_TRUE;
 }
 PRInt32
 _MD_open (const char *name, PRIntn flags, PRIntn mode)
 {
 	PRInt32 osflags;
 	PRInt32 rv, err;
 	if (flags & PR_RDWR) {
 		osflags = O_RDWR;
 	} else if (flags & PR_WRONLY) {
 		osflags = O_WRONLY;
 	} else {
 		osflags = O_RDONLY;
 	}
 	if (flags & PR_EXCL)
 		osflags |= O_EXCL;
 	if (flags & PR_APPEND)
 		osflags |= O_APPEND;
 	if (flags & PR_TRUNCATE)
 		osflags |= O_TRUNC;
 	if (flags & PR_SYNC) {
 /* Ummmm.  BeOS doesn't appear to
    support sync in any way shape or
    form. */
 		return PR_NOT_IMPLEMENTED_ERROR;
 	}
 	/*
 	** On creations we hold the 'create' lock in order to enforce
 	** the semantics of PR_Rename. (see the latter for more details)
 	*/
 	if (flags & PR_CREATE_FILE)
 	{
 		osflags |= O_CREAT ;
 		if (NULL !=_pr_rename_lock)
 		    PR_Lock(_pr_rename_lock);
 	}
         rv = open(name, osflags, mode);
         if (rv < 0) {
                 err = _MD_ERRNO();
                 _PR_MD_MAP_OPEN_ERROR(err);
         }
     if ((flags & PR_CREATE_FILE) && (NULL !=_pr_rename_lock))
         PR_Unlock(_pr_rename_lock);
         return rv;
 }
 PRInt32
 _MD_close_file (PRInt32 osfd)
 {
 PRInt32 rv, err;
 	rv = close(osfd);
 	if (rv == -1) {
 		err = _MD_ERRNO();
 		_PR_MD_MAP_CLOSE_ERROR(err);
 	}
 	return(rv);
 }
 PRInt32
 _MD_read (PRFileDesc *fd, void *buf, PRInt32 amount)
 {
     PRInt32 rv, err;
     PRInt32 osfd = fd->secret->md.osfd;
     rv = read( osfd, buf, amount );
     if (rv < 0) {
 	err = _MD_ERRNO();
 	_PR_MD_MAP_READ_ERROR(err);
     }
     return(rv);
 }
 PRInt32
 _MD_write (PRFileDesc *fd, const void *buf, PRInt32 amount)
 {
     PRInt32 rv, err;
     PRInt32 osfd = fd->secret->md.osfd;
     rv = write( osfd, buf, amount );
     if( rv < 0 ) {
 	err = _MD_ERRNO();
 	_PR_MD_MAP_WRITE_ERROR(err);
     }
     return( rv );
 }
 #ifndef BONE_VERSION /* Writev moves to bnet.c with BONE */
 PRInt32
 _MD_writev (PRFileDesc *fd, const PRIOVec *iov, PRInt32 iov_size,
 	    PRIntervalTime timeout)
 {
     return PR_NOT_IMPLEMENTED_ERROR;
 }
 #endif
 PRInt32
 _MD_lseek (PRFileDesc *fd, PRInt32 offset, int whence)
 {
 PRInt32 rv, err;
     rv = lseek (fd->secret->md.osfd, offset, whence);
     if (rv == -1) {
         err = _MD_ERRNO();
 	_PR_MD_MAP_LSEEK_ERROR(err);
     }
     return( rv );
 }
 PRInt64
 _MD_lseek64 (PRFileDesc *fd, PRInt64 offset, int whence)
 {
 PRInt32 rv, err;
 /* According to the BeOS headers, lseek accepts a
  * variable of type off_t for the offset, and off_t
  * is defined to be a 64-bit value.  So no special
  * cracking needs to be done on "offset".
  */
     rv = lseek (fd->secret->md.osfd, offset, whence);
     if (rv == -1) {
         err = _MD_ERRNO();
 	_PR_MD_MAP_LSEEK_ERROR(err);
     }
     return( rv );
 }
 PRInt32
 _MD_fsync (PRFileDesc *fd)
 {
 PRInt32 rv, err;
     rv = fsync(fd->secret->md.osfd);
     if (rv == -1) {
 	err = _MD_ERRNO();
 	_PR_MD_MAP_FSYNC_ERROR(err);
     }
     return(rv);
 }
 PRInt32
 _MD_delete (const char *name)
 {
 PRInt32 rv, err;
     rv = unlink(name);
     if (rv == -1)
     {
 	err = _MD_ERRNO();
         _PR_MD_MAP_UNLINK_ERROR(err);
     }
     return (rv);
 }
 PRInt32
 _MD_getfileinfo (const char *fn, PRFileInfo *info)
 {
 struct stat sb;
 PRInt32 rv, err;
 PRInt64 s, s2us;
 	rv = stat(fn, &sb);
 	if (rv < 0) {
 		err = _MD_ERRNO();
 		_PR_MD_MAP_STAT_ERROR(err);
 	} else if (info) {
 		if (S_IFREG & sb.st_mode)
 			info->type = PR_FILE_FILE;
 		else if (S_IFDIR & sb.st_mode)
 			info->type = PR_FILE_DIRECTORY;
 		else
 			info->type = PR_FILE_OTHER;
 		/* Must truncate file size for the 32 bit
 		   version */
 		info->size = (sb.st_size & 0xffffffff);
 		LL_I2L(s, sb.st_mtime);
 		LL_I2L(s2us, PR_USEC_PER_SEC);
 		LL_MUL(s, s, s2us);
 		info->modifyTime = s;
 		LL_I2L(s, sb.st_ctime);
 		LL_MUL(s, s, s2us);
 		info->creationTime = s;
 	}
 	return rv;
 }
 PRInt32
 _MD_getfileinfo64 (const char *fn, PRFileInfo64 *info)
 {
 struct stat sb;
 PRInt32 rv, err;
 PRInt64 s, s2us;
 	rv = stat(fn, &sb);
 	if (rv < 0) {
 		err = _MD_ERRNO();
 		_PR_MD_MAP_STAT_ERROR(err);
 	} else if (info) {
 		if (S_IFREG & sb.st_mode)
 			info->type = PR_FILE_FILE;
 		else if (S_IFDIR & sb.st_mode)
 			info->type = PR_FILE_DIRECTORY;
 		else
 			info->type = PR_FILE_OTHER;
 		/* For the 64 bit version we can use
 		 * the native st_size without modification
 		 */
 		info->size = sb.st_size;
 		LL_I2L(s, sb.st_mtime);
 		LL_I2L(s2us, PR_USEC_PER_SEC);
 		LL_MUL(s, s, s2us);
 		info->modifyTime = s;
 		LL_I2L(s, sb.st_ctime);
 		LL_MUL(s, s, s2us);
 		info->creationTime = s;
 	}
 	return rv;
 }
 PRInt32
 _MD_getopenfileinfo (const PRFileDesc *fd, PRFileInfo *info)
 {
         struct stat sb;
         PRInt64 s, s2us;
         PRInt32 rv, err;
         rv = fstat(fd->secret->md.osfd, &sb);
         if (rv < 0) {
                         err = _MD_ERRNO();
                         _PR_MD_MAP_FSTAT_ERROR(err);
         } else if (info) {
                 if (info) {
                         if (S_IFREG & sb.st_mode)
                                 info->type = PR_FILE_FILE ;
                         else if (S_IFDIR & sb.st_mode)
                                 info->type = PR_FILE_DIRECTORY;
                         else
                                 info->type = PR_FILE_OTHER;
 			/* Use lower 32 bits of file size */
                         info->size = ( sb.st_size & 0xffffffff);
                         LL_I2L(s, sb.st_mtime);
                         LL_I2L(s2us, PR_USEC_PER_SEC);
                         LL_MUL(s, s, s2us);
                         info->modifyTime = s;
                         LL_I2L(s, sb.st_ctime);
                         LL_MUL(s, s, s2us);
                         info->creationTime = s;
                 }
         }
         return rv;
 }
 PRInt32
 _MD_getopenfileinfo64 (const PRFileDesc *fd, PRFileInfo64 *info)
 {
         struct stat sb;
         PRInt64 s, s2us;
         PRInt32 rv, err;
         rv = fstat(fd->secret->md.osfd, &sb);
         if (rv < 0) {
                         err = _MD_ERRNO();
                         _PR_MD_MAP_FSTAT_ERROR(err);
         } else if (info) {
                 if (info) {
                         if (S_IFREG & sb.st_mode)
                                 info->type = PR_FILE_FILE ;
                         else if (S_IFDIR & sb.st_mode)
                                 info->type = PR_FILE_DIRECTORY;
                         else
                                 info->type = PR_FILE_OTHER;
                         info->size = sb.st_size;
                         LL_I2L(s, sb.st_mtime);
                         LL_I2L(s2us, PR_USEC_PER_SEC);
                         LL_MUL(s, s, s2us);
                         info->modifyTime = s;
                         LL_I2L(s, sb.st_ctime);
                         LL_MUL(s, s, s2us);
                         info->creationTime = s;
                 }
         }
         return rv;
 }
 PRInt32
 _MD_rename (const char *from, const char *to)
 {
     PRInt32 rv = -1, err;
     /*
     ** This is trying to enforce the semantics of WINDOZE' rename
     ** operation. That means one is not allowed to rename over top
     ** of an existing file. Holding a lock across these two function
     ** and the open function is known to be a bad idea, but ....
     */
     if (NULL != _pr_rename_lock)
         PR_Lock(_pr_rename_lock);
     if (0 == access(to, F_OK))
         PR_SetError(PR_FILE_EXISTS_ERROR, 0);
     else
     {
             rv = rename(from, to);
             if (rv < 0) {
                     err = _MD_ERRNO();
                     _PR_MD_MAP_RENAME_ERROR(err);
             }
     }
     if (NULL != _pr_rename_lock)
         PR_Unlock(_pr_rename_lock);
     return rv;
 }
 PRInt32
 _MD_access (const char *name, PRIntn how)
 {
 PRInt32 rv, err;
 int checkFlags;
 struct stat buf;
 	switch (how) {
 		case PR_ACCESS_WRITE_OK:
 			checkFlags = S_IWUSR | S_IWGRP | S_IWOTH;
 			break;
 		case PR_ACCESS_READ_OK:
 			checkFlags = S_IRUSR | S_IRGRP | S_IROTH;
 			break;
 		case PR_ACCESS_EXISTS:
 			/* we don't need to examine st_mode. */
 			break;
 		default:
 			PR_SetError(PR_INVALID_ARGUMENT_ERROR, 0);
 			return -1;
 	}
 	rv = stat(name, &buf);
 	if (rv == 0 && how != PR_ACCESS_EXISTS && (!(buf.st_mode & checkFlags))) {
 		PR_SetError(PR_NO_ACCESS_RIGHTS_ERROR, 0);
 		return -1;
 	}
 	if (rv < 0) {
 		err = _MD_ERRNO();
 		_PR_MD_MAP_STAT_ERROR(err);
 	}
 	return(rv);
 }
 PRInt32
 _MD_stat (const char *name, struct stat *buf)
 {
     return PR_NOT_IMPLEMENTED_ERROR;
 }
 PRInt32
 _MD_mkdir (const char *name, PRIntn mode)
 {
     status_t rv;
     int err;
     /*
     ** This lock is used to enforce rename semantics as described
     ** in PR_Rename. Look there for more fun details.
     */
     if (NULL !=_pr_rename_lock)
         PR_Lock(_pr_rename_lock);
     rv = mkdir(name, mode);
     if (rv < 0) {
 	err = _MD_ERRNO();
 	_PR_MD_MAP_MKDIR_ERROR(err);
     }
     if (NULL !=_pr_rename_lock)
         PR_Unlock(_pr_rename_lock);
     return rv;
 }
 PRInt32
 _MD_rmdir (const char *name)
 {
 int rv, err;
         rv = rmdir(name);
         if (rv == -1) {
                         err = _MD_ERRNO();
                         _PR_MD_MAP_RMDIR_ERROR(err);
         }
         return rv;
 }
 PRInt32
 _MD_pr_poll(PRPollDesc *pds, PRIntn npds, PRIntervalTime timeout)
 {
 	PRInt32 rv = 0;
 	PRThread *me = _PR_MD_CURRENT_THREAD();
 	/*
 	 * This code is almost a duplicate of w32poll.c's _PR_MD_PR_POLL().
 	 */
 	fd_set rd, wt, ex;
 	PRFileDesc *bottom;
 	PRPollDesc *pd, *epd;
 	PRInt32 maxfd = -1, ready, err;
 	PRIntervalTime remaining, elapsed, start;
 	struct timeval tv, *tvp = NULL;
 	if (_PR_PENDING_INTERRUPT(me))
 	{
 		me->flags &= ~_PR_INTERRUPT;
 		PR_SetError(PR_PENDING_INTERRUPT_ERROR, 0);
 		return -1;
 	}
 	if (0 == npds) {
 		PR_Sleep(timeout);
 		return rv;
 	}
 	FD_ZERO(&rd);
 	FD_ZERO(&wt);
 	FD_ZERO(&ex);
 	ready = 0;
 	for (pd = pds, epd = pd + npds; pd < epd; pd++)
 	{
 		PRInt16 in_flags_read = 0, in_flags_write = 0;
 		PRInt16 out_flags_read = 0, out_flags_write = 0;
 		if ((NULL != pd->fd) && (0 != pd->in_flags))
 		{
 			if (pd->in_flags & PR_POLL_READ)
 			{
 				in_flags_read = (pd->fd->methods->poll)(pd->fd, pd->in_flags & ~PR_POLL_WRITE, &out_flags_read);
 			}
 			if (pd->in_flags & PR_POLL_WRITE)
 			{
 				in_flags_write = (pd->fd->methods->poll)(pd->fd, pd->in_flags & ~PR_POLL_READ, &out_flags_write);
 			}
 			if ((0 != (in_flags_read & out_flags_read))
 			    || (0 != (in_flags_write & out_flags_write)))
 			{
 				/* this one's ready right now */
 				if (0 == ready)
 				{
 					/*
 					 * We will have to return without calling the
 					 * system poll/select function.  So zero the
 					 * out_flags fields of all the poll descriptors
 					 * before this one.
 					 */
 					PRPollDesc *prev;
 					for (prev = pds; prev < pd; prev++)
 					{
 						prev->out_flags = 0;
 					}
 				}
 				ready += 1;
 				pd->out_flags = out_flags_read | out_flags_write;
 			}
 			else
 			{
 				pd->out_flags = 0;  /* pre-condition */
 				/* make sure this is an NSPR supported stack */
 				bottom = PR_GetIdentitiesLayer(pd->fd, PR_NSPR_IO_LAYER);
 				PR_ASSERT(NULL != bottom);  /* what to do about that? */
 				if ((NULL != bottom)
 				    && (_PR_FILEDESC_OPEN == bottom->secret->state))
 				{
 					if (0 == ready)
 					{
 						PRInt32 osfd = bottom->secret->md.osfd;
 						if (osfd > maxfd) maxfd = osfd;
 						if (in_flags_read & PR_POLL_READ)
 						{
 							pd->out_flags |= _PR_POLL_READ_SYS_READ;
 							FD_SET(osfd, &rd);
 						}
 						if (in_flags_read & PR_POLL_WRITE)
 						{
 							pd->out_flags |= _PR_POLL_READ_SYS_WRITE;
 							FD_SET(osfd, &wt);
 						}
 						if (in_flags_write & PR_POLL_READ)
 						{
 							pd->out_flags |= _PR_POLL_WRITE_SYS_READ;
 							FD_SET(osfd, &rd);
 						}
 						if (in_flags_write & PR_POLL_WRITE)
 						{
 							pd->out_flags |= _PR_POLL_WRITE_SYS_WRITE;
 							FD_SET(osfd, &wt);
 						}
 						if (pd->in_flags & PR_POLL_EXCEPT) FD_SET(osfd, &ex);
 					}
 				}
 				else
 				{
 					if (0 == ready)
 					{
 						PRPollDesc *prev;
 						for (prev = pds; prev < pd; prev++)
 						{
 							prev->out_flags = 0;
 						}
 					}
 					ready += 1;  /* this will cause an abrupt return */
 					pd->out_flags = PR_POLL_NVAL;  /* bogii */
 				}
 			}
 		}
 		else
 		{
 			pd->out_flags = 0;
 		}
 	}
 	if (0 != ready) return ready;  /* no need to block */
 	remaining = timeout;
 	start = PR_IntervalNow();
  retry:
 	if (timeout != PR_INTERVAL_NO_TIMEOUT)
 	{
 		PRInt32 ticksPerSecond = PR_TicksPerSecond();
 		tv.tv_sec = remaining / ticksPerSecond;
 		tv.tv_usec = PR_IntervalToMicroseconds( remaining % ticksPerSecond );
 		tvp = &tv;
 	}
 	ready = _MD_SELECT(maxfd + 1, &rd, &wt, &ex, tvp);
 	if (ready == -1 && errno == EINTR)
 	{
 		if (timeout == PR_INTERVAL_NO_TIMEOUT) goto retry;
 		else
 		{
 			elapsed = (PRIntervalTime) (PR_IntervalNow() - start);
 			if (elapsed > timeout) ready = 0;  /* timed out */
 			else
 			{
 				remaining = timeout - elapsed;
 				goto retry;
 			}
 		}
 	}
 	/*
 	** Now to unravel the select sets back into the client's poll
 	** descriptor list. Is this possibly an area for pissing away
 	** a few cycles or what?
 	*/
 	if (ready > 0)
 	{
 		ready = 0;
 		for (pd = pds, epd = pd + npds; pd < epd; pd++)
 		{
 			PRInt16 out_flags = 0;
 			if ((NULL != pd->fd) && (0 != pd->in_flags))
 			{
 				PRInt32 osfd;
 				bottom = PR_GetIdentitiesLayer(pd->fd, PR_NSPR_IO_LAYER);
 				PR_ASSERT(NULL != bottom);
 				osfd = bottom->secret->md.osfd;
 				if (FD_ISSET(osfd, &rd))
 				{
 					if (pd->out_flags & _PR_POLL_READ_SYS_READ)
 						out_flags |= PR_POLL_READ;
 					if (pd->out_flags & _PR_POLL_WRITE_SYS_READ)
 						out_flags |= PR_POLL_WRITE;
 				}
 				if (FD_ISSET(osfd, &wt))
 				{
 					if (pd->out_flags & _PR_POLL_READ_SYS_WRITE)
 						out_flags |= PR_POLL_READ;
 					if (pd->out_flags & _PR_POLL_WRITE_SYS_WRITE)
 						out_flags |= PR_POLL_WRITE;
 				}
 				if (FD_ISSET(osfd, &ex)) out_flags |= PR_POLL_EXCEPT;
 /* Workaround for nonblocking connects under net_server */
 #ifndef BONE_VERSION
 				if (out_flags)
 				{
 					/* check if it is a pending connect */
 					int i = 0, j = 0;
 					PR_Lock( _connectLock );
 					for( i = 0; i < connectCount; i++ )
 					{
 						if(connectList[i].osfd == osfd)
 						{
 							int connectError;
 							int connectResult;
 							connectResult = connect(connectList[i].osfd,
 							                        &connectList[i].addr,
 							                        connectList[i].addrlen);
 							connectError = errno;
 							if(connectResult < 0 )
 							{
 								if(connectError == EINTR || connectError == EWOULDBLOCK ||
 					  		   connectError == EINPROGRESS || connectError == EALREADY)
 								{
 									break;
 								}
 							}
 							if(i == (connectCount - 1))
 							{
 								connectList[i].osfd = -1;
 							} else {
 								for(j = i; j < connectCount; j++ )
 								{
 									memcpy( &connectList[j], &connectList[j+1],
 									        sizeof(connectList[j]));
 								}
 							}
 							connectCount--;
 							bottom->secret->md.connectReturnValue = connectResult;
 							bottom->secret->md.connectReturnError = connectError;
 							bottom->secret->md.connectValueValid = PR_TRUE;
 							break;
 						}
 					}
 					PR_Unlock( _connectLock );
 				}
 #endif
 			}
 			pd->out_flags = out_flags;
 			if (out_flags) ready++;
 		}
 		PR_ASSERT(ready > 0);
 	}
 	else if (ready < 0)
 	{
 		err = _MD_ERRNO();
 		if (err == EBADF)
 		{
 			/* Find the bad fds */
 			ready = 0;
 			for (pd = pds, epd = pd + npds; pd < epd; pd++)
 			{
 				pd->out_flags = 0;
 				if ((NULL != pd->fd) && (0 != pd->in_flags))
 				{
 					bottom = PR_GetIdentitiesLayer(pd->fd, PR_NSPR_IO_LAYER);
 					if (fcntl(bottom->secret->md.osfd, F_GETFL, 0) == -1)
 					{
 						pd->out_flags = PR_POLL_NVAL;
 						ready++;
 					}
 				}
 			}
 			PR_ASSERT(ready > 0);
 		}
 		else _PR_MD_MAP_SELECT_ERROR(err);
 	}
 	return ready;
 }  /* _MD_pr_poll */
 /*
  * File locking.
  */
 PRStatus
 _MD_lockfile (PRInt32 osfd)
 {
     PRInt32 rv;
     struct flock linfo;
     linfo.l_type =
     linfo.l_whence = SEEK_SET;
     linfo.l_start = 0;
     linfo.l_len = 0;
     rv = fcntl(osfd, F_SETLKW, &linfo);
     if (rv == 0)
 	return PR_SUCCESS;
     _PR_MD_MAP_FLOCK_ERROR(_MD_ERRNO());
     return PR_FAILURE;
 }
 PRStatus
 _MD_tlockfile (PRInt32 osfd)
 {
     PRInt32 rv;
     struct flock linfo;
     linfo.l_type =
     linfo.l_whence = SEEK_SET;
     linfo.l_start = 0;
     linfo.l_len = 0;
     rv = fcntl(osfd, F_SETLK, &linfo);
     if (rv == 0)
 	return PR_SUCCESS;
     _PR_MD_MAP_FLOCK_ERROR(_MD_ERRNO());
     return PR_FAILURE;
 }
 PRStatus
 _MD_unlockfile (PRInt32 osfd)
 {
     PRInt32 rv;
     struct flock linfo;
     linfo.l_type =
     linfo.l_whence = SEEK_SET;
     linfo.l_start = 0;
     linfo.l_len = 0;
     rv = fcntl(osfd, F_UNLCK, &linfo);
     if (rv == 0)
 	return PR_SUCCESS;
     _PR_MD_MAP_FLOCK_ERROR(_MD_ERRNO());
     return PR_FAILURE;
 }

The Tor Browser / annotate

nsprpub/pr/src/md/beos/bfile.c@6474c204b198 (annotated)

nsprpub/pr/src/md/beos/bfile.c