Source code
Revision control
Copy as Markdown
Other Tools
/* -*- 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
#include "primpl.h"
#include <string.h>
/*****************************************************************************/
/************************** Invalid I/O method object ************************/
/*****************************************************************************/
PRIOMethods _pr_faulty_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,
(PRPollFN)_PR_InvalidInt16,
(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};
PRIntn _PR_InvalidInt(void) {
PR_NOT_REACHED("I/O method is invalid");
PR_SetError(PR_INVALID_METHOD_ERROR, 0);
return -1;
} /* _PR_InvalidInt */
PRInt16 _PR_InvalidInt16(void) {
PR_NOT_REACHED("I/O method is invalid");
PR_SetError(PR_INVALID_METHOD_ERROR, 0);
return -1;
} /* _PR_InvalidInt */
PRInt64 _PR_InvalidInt64(void) {
PRInt64 rv;
LL_I2L(rv, -1);
PR_NOT_REACHED("I/O method is invalid");
PR_SetError(PR_INVALID_METHOD_ERROR, 0);
return rv;
} /* _PR_InvalidInt */
/*
* An invalid method that returns PRStatus
*/
PRStatus _PR_InvalidStatus(void) {
PR_NOT_REACHED("I/O method is invalid");
PR_SetError(PR_INVALID_METHOD_ERROR, 0);
return PR_FAILURE;
} /* _PR_InvalidDesc */
/*
* An invalid method that returns a pointer
*/
PRFileDesc* _PR_InvalidDesc(void) {
PR_NOT_REACHED("I/O method is invalid");
PR_SetError(PR_INVALID_METHOD_ERROR, 0);
return NULL;
} /* _PR_InvalidDesc */
PR_IMPLEMENT(PRDescType) PR_GetDescType(PRFileDesc* file) {
return file->methods->file_type;
}
PR_IMPLEMENT(PRStatus) PR_Close(PRFileDesc* fd) {
return (fd->methods->close)(fd);
}
PR_IMPLEMENT(PRInt32) PR_Read(PRFileDesc* fd, void* buf, PRInt32 amount) {
return ((fd->methods->read)(fd, buf, amount));
}
PR_IMPLEMENT(PRInt32)
PR_Write(PRFileDesc* fd, const void* buf, PRInt32 amount) {
return ((fd->methods->write)(fd, buf, amount));
}
PR_IMPLEMENT(PRInt32)
PR_Seek(PRFileDesc* fd, PRInt32 offset, PRSeekWhence whence) {
return ((fd->methods->seek)(fd, offset, whence));
}
PR_IMPLEMENT(PRInt64)
PR_Seek64(PRFileDesc* fd, PRInt64 offset, PRSeekWhence whence) {
return ((fd->methods->seek64)(fd, offset, whence));
}
PR_IMPLEMENT(PRInt32) PR_Available(PRFileDesc* fd) {
return ((fd->methods->available)(fd));
}
PR_IMPLEMENT(PRInt64) PR_Available64(PRFileDesc* fd) {
return ((fd->methods->available64)(fd));
}
PR_IMPLEMENT(PRStatus) PR_GetOpenFileInfo(PRFileDesc* fd, PRFileInfo* info) {
return ((fd->methods->fileInfo)(fd, info));
}
PR_IMPLEMENT(PRStatus)
PR_GetOpenFileInfo64(PRFileDesc* fd, PRFileInfo64* info) {
return ((fd->methods->fileInfo64)(fd, info));
}
PR_IMPLEMENT(PRStatus) PR_Sync(PRFileDesc* fd) {
return ((fd->methods->fsync)(fd));
}
PR_IMPLEMENT(PRStatus)
PR_Connect(PRFileDesc* fd, const PRNetAddr* addr, PRIntervalTime timeout) {
return ((fd->methods->connect)(fd, addr, timeout));
}
PR_IMPLEMENT(PRStatus) PR_ConnectContinue(PRFileDesc* fd, PRInt16 out_flags) {
return ((fd->methods->connectcontinue)(fd, out_flags));
}
PR_IMPLEMENT(PRFileDesc*)
PR_Accept(PRFileDesc* fd, PRNetAddr* addr, PRIntervalTime timeout) {
return ((fd->methods->accept)(fd, addr, timeout));
}
PR_IMPLEMENT(PRStatus) PR_Bind(PRFileDesc* fd, const PRNetAddr* addr) {
return ((fd->methods->bind)(fd, addr));
}
PR_IMPLEMENT(PRStatus) PR_Shutdown(PRFileDesc* fd, PRShutdownHow how) {
return ((fd->methods->shutdown)(fd, how));
}
PR_IMPLEMENT(PRStatus) PR_Listen(PRFileDesc* fd, PRIntn backlog) {
return ((fd->methods->listen)(fd, backlog));
}
PR_IMPLEMENT(PRInt32)
PR_Recv(PRFileDesc* fd, void* buf, PRInt32 amount, PRIntn flags,
PRIntervalTime timeout) {
return ((fd->methods->recv)(fd, buf, amount, flags, timeout));
}
PR_IMPLEMENT(PRInt32)
PR_Send(PRFileDesc* fd, const void* buf, PRInt32 amount, PRIntn flags,
PRIntervalTime timeout) {
return ((fd->methods->send)(fd, buf, amount, flags, timeout));
}
PR_IMPLEMENT(PRInt32)
PR_Writev(PRFileDesc* fd, const PRIOVec* iov, PRInt32 iov_size,
PRIntervalTime timeout) {
if (iov_size > PR_MAX_IOVECTOR_SIZE) {
PR_SetError(PR_BUFFER_OVERFLOW_ERROR, 0);
return -1;
}
return ((fd->methods->writev)(fd, iov, iov_size, timeout));
}
PR_IMPLEMENT(PRInt32)
PR_RecvFrom(PRFileDesc* fd, void* buf, PRInt32 amount, PRIntn flags,
PRNetAddr* addr, PRIntervalTime timeout) {
return ((fd->methods->recvfrom)(fd, buf, amount, flags, addr, timeout));
}
PR_IMPLEMENT(PRInt32)
PR_SendTo(PRFileDesc* fd, const void* buf, PRInt32 amount, PRIntn flags,
const PRNetAddr* addr, PRIntervalTime timeout) {
return ((fd->methods->sendto)(fd, buf, amount, flags, addr, timeout));
}
PR_IMPLEMENT(PRInt32)
PR_TransmitFile(PRFileDesc* sd, PRFileDesc* fd, const void* hdr, PRInt32 hlen,
PRTransmitFileFlags flags, PRIntervalTime timeout) {
return ((sd->methods->transmitfile)(sd, fd, hdr, hlen, flags, timeout));
}
PR_IMPLEMENT(PRInt32)
PR_AcceptRead(PRFileDesc* sd, PRFileDesc** nd, PRNetAddr** raddr, void* buf,
PRInt32 amount, PRIntervalTime timeout) {
return ((sd->methods->acceptread)(sd, nd, raddr, buf, amount, timeout));
}
PR_IMPLEMENT(PRStatus) PR_GetSockName(PRFileDesc* fd, PRNetAddr* addr) {
return ((fd->methods->getsockname)(fd, addr));
}
PR_IMPLEMENT(PRStatus) PR_GetPeerName(PRFileDesc* fd, PRNetAddr* addr) {
return ((fd->methods->getpeername)(fd, addr));
}
PR_IMPLEMENT(PRStatus)
PR_GetSocketOption(PRFileDesc* fd, PRSocketOptionData* data) {
return ((fd->methods->getsocketoption)(fd, data));
}
PR_IMPLEMENT(PRStatus)
PR_SetSocketOption(PRFileDesc* fd, const PRSocketOptionData* data) {
return ((fd->methods->setsocketoption)(fd, data));
}
PR_IMPLEMENT(PRInt32)
PR_SendFile(PRFileDesc* sd, PRSendFileData* sfd, PRTransmitFileFlags flags,
PRIntervalTime timeout) {
return ((sd->methods->sendfile)(sd, sfd, flags, timeout));
}
PR_IMPLEMENT(PRInt32)
PR_EmulateAcceptRead(PRFileDesc* sd, PRFileDesc** nd, PRNetAddr** raddr,
void* buf, PRInt32 amount, PRIntervalTime timeout) {
PRInt32 rv = -1;
PRNetAddr remote;
PRFileDesc* accepted = NULL;
/*
** The timeout does not apply to the accept portion of the
** operation - it waits indefinitely.
*/
accepted = PR_Accept(sd, &remote, PR_INTERVAL_NO_TIMEOUT);
if (NULL == accepted) {
return rv;
}
rv = PR_Recv(accepted, buf, amount, 0, timeout);
if (rv >= 0) {
/* copy the new info out where caller can see it */
#define AMASK ((PRPtrdiff)7) /* mask for alignment of PRNetAddr */
PRPtrdiff aligned = (PRPtrdiff)buf + amount + AMASK;
*raddr = (PRNetAddr*)(aligned & ~AMASK);
memcpy(*raddr, &remote, PR_NETADDR_SIZE(&remote));
*nd = accepted;
return rv;
}
PR_Close(accepted);
return rv;
}
/*
* PR_EmulateSendFile
*
* Send file sfd->fd across socket sd. If header/trailer are specified
* they 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
*
*/
#if defined(XP_UNIX) || defined(WIN32)
/*
* An implementation based on memory-mapped files
*/
# define SENDFILE_MMAP_CHUNK (256 * 1024)
PR_IMPLEMENT(PRInt32)
PR_EmulateSendFile(PRFileDesc* sd, PRSendFileData* sfd,
PRTransmitFileFlags flags, PRIntervalTime timeout) {
PRInt32 rv, count = 0;
PRInt32 len, file_bytes, index = 0;
PRFileInfo info;
PRIOVec iov[3];
PRFileMap* mapHandle = NULL;
void* addr = (void*)0; /* initialized to some arbitrary value. Keeps compiler
warnings down. */
PRUint32 file_mmap_offset, alignment;
PRInt64 zero64;
PROffset64 file_mmap_offset64;
PRUint32 addr_offset, mmap_len;
/* Get file size */
if (PR_SUCCESS != PR_GetOpenFileInfo(sfd->fd, &info)) {
count = -1;
goto done;
}
if (sfd->file_nbytes && (info.size < (sfd->file_offset + sfd->file_nbytes))) {
/*
* there are fewer bytes in file to send than specified
*/
PR_SetError(PR_INVALID_ARGUMENT_ERROR, 0);
count = -1;
goto done;
}
if (sfd->file_nbytes) {
file_bytes = sfd->file_nbytes;
} else {
file_bytes = info.size - sfd->file_offset;
}
alignment = PR_GetMemMapAlignment();
/* number of initial bytes to skip in mmap'd segment */
addr_offset = sfd->file_offset % alignment;
/* find previous mmap alignment boundary */
file_mmap_offset = sfd->file_offset - addr_offset;
/*
* If the file is large, mmap and send the file in chunks so as
* to not consume too much virtual address space
*/
mmap_len = PR_MIN(file_bytes + addr_offset, SENDFILE_MMAP_CHUNK);
len = mmap_len - addr_offset;
/*
* Map in (part of) file. Take care of zero-length files.
*/
if (len) {
LL_I2L(zero64, 0);
mapHandle = PR_CreateFileMap(sfd->fd, zero64, PR_PROT_READONLY);
if (!mapHandle) {
count = -1;
goto done;
}
LL_I2L(file_mmap_offset64, file_mmap_offset);
addr = PR_MemMap(mapHandle, file_mmap_offset64, mmap_len);
if (!addr) {
count = -1;
goto done;
}
}
/*
* send headers first, followed by the file
*/
if (sfd->hlen) {
iov[index].iov_base = (char*)sfd->header;
iov[index].iov_len = sfd->hlen;
index++;
}
if (len) {
iov[index].iov_base = (char*)addr + addr_offset;
iov[index].iov_len = len;
index++;
}
if ((file_bytes == len) && (sfd->tlen)) {
/*
* all file data is mapped in; send the trailer too
*/
iov[index].iov_base = (char*)sfd->trailer;
iov[index].iov_len = sfd->tlen;
index++;
}
rv = PR_Writev(sd, iov, index, timeout);
if (len) {
PR_MemUnmap(addr, mmap_len);
}
if (rv < 0) {
count = -1;
goto done;
}
PR_ASSERT(rv == sfd->hlen + len + ((len == file_bytes) ? sfd->tlen : 0));
file_bytes -= len;
count += rv;
if (!file_bytes) { /* header, file and trailer are sent */
goto done;
}
/*
* send remaining bytes of the file, if any
*/
len = PR_MIN(file_bytes, SENDFILE_MMAP_CHUNK);
while (len > 0) {
/*
* Map in (part of) file
*/
file_mmap_offset = sfd->file_offset + count - sfd->hlen;
PR_ASSERT((file_mmap_offset % alignment) == 0);
LL_I2L(file_mmap_offset64, file_mmap_offset);
addr = PR_MemMap(mapHandle, file_mmap_offset64, len);
if (!addr) {
count = -1;
goto done;
}
rv = PR_Send(sd, addr, len, 0, timeout);
PR_MemUnmap(addr, len);
if (rv < 0) {
count = -1;
goto done;
}
PR_ASSERT(rv == len);
file_bytes -= rv;
count += rv;
len = PR_MIN(file_bytes, SENDFILE_MMAP_CHUNK);
}
PR_ASSERT(0 == file_bytes);
if (sfd->tlen) {
rv = PR_Send(sd, sfd->trailer, sfd->tlen, 0, timeout);
if (rv >= 0) {
PR_ASSERT(rv == sfd->tlen);
count += rv;
} else {
count = -1;
}
}
done:
if (mapHandle) {
PR_CloseFileMap(mapHandle);
}
if ((count >= 0) && (flags & PR_TRANSMITFILE_CLOSE_SOCKET)) {
PR_Close(sd);
}
return count;
}
#else
PR_IMPLEMENT(PRInt32)
PR_EmulateSendFile(PRFileDesc* sd, PRSendFileData* sfd,
PRTransmitFileFlags flags, PRIntervalTime timeout) {
PRInt32 rv, count = 0;
PRInt32 rlen;
const void* buffer;
PRInt32 buflen;
PRInt32 sendbytes, readbytes;
char* buf;
# define _SENDFILE_BUFSIZE (16 * 1024)
buf = (char*)PR_MALLOC(_SENDFILE_BUFSIZE);
if (buf == NULL) {
PR_SetError(PR_OUT_OF_MEMORY_ERROR, 0);
return -1;
}
/*
* send header first
*/
buflen = sfd->hlen;
buffer = sfd->header;
while (buflen) {
rv = PR_Send(sd, buffer, buflen, 0, timeout);
if (rv < 0) {
/* PR_Send() has invoked PR_SetError(). */
rv = -1;
goto done;
} else {
count += rv;
buffer = (const void*)((const char*)buffer + rv);
buflen -= rv;
}
}
/*
* send file next
*/
if (PR_Seek(sfd->fd, sfd->file_offset, PR_SEEK_SET) < 0) {
rv = -1;
goto done;
}
sendbytes = sfd->file_nbytes;
if (sendbytes == 0) {
/* send entire file */
while ((rlen = PR_Read(sfd->fd, buf, _SENDFILE_BUFSIZE)) > 0) {
while (rlen) {
char* bufptr = buf;
rv = PR_Send(sd, bufptr, rlen, 0, timeout);
if (rv < 0) {
/* PR_Send() has invoked PR_SetError(). */
rv = -1;
goto done;
} else {
count += rv;
bufptr = ((char*)bufptr + rv);
rlen -= rv;
}
}
}
if (rlen < 0) {
/* PR_Read() has invoked PR_SetError(). */
rv = -1;
goto done;
}
} else {
readbytes = PR_MIN(sendbytes, _SENDFILE_BUFSIZE);
while (readbytes && ((rlen = PR_Read(sfd->fd, buf, readbytes)) > 0)) {
while (rlen) {
char* bufptr = buf;
rv = PR_Send(sd, bufptr, rlen, 0, timeout);
if (rv < 0) {
/* PR_Send() has invoked PR_SetError(). */
rv = -1;
goto done;
} else {
count += rv;
sendbytes -= rv;
bufptr = ((char*)bufptr + rv);
rlen -= rv;
}
}
readbytes = PR_MIN(sendbytes, _SENDFILE_BUFSIZE);
}
if (rlen < 0) {
/* PR_Read() has invoked PR_SetError(). */
rv = -1;
goto done;
} else if (sendbytes != 0) {
/*
* there are fewer bytes in file to send than specified
*/
PR_SetError(PR_INVALID_ARGUMENT_ERROR, 0);
rv = -1;
goto done;
}
}
/*
* send trailer last
*/
buflen = sfd->tlen;
buffer = sfd->trailer;
while (buflen) {
rv = PR_Send(sd, buffer, buflen, 0, timeout);
if (rv < 0) {
/* PR_Send() has invoked PR_SetError(). */
rv = -1;
goto done;
} else {
count += rv;
buffer = (const void*)((const char*)buffer + rv);
buflen -= rv;
}
}
rv = count;
done:
if (buf) {
PR_DELETE(buf);
}
if ((rv >= 0) && (flags & PR_TRANSMITFILE_CLOSE_SOCKET)) {
PR_Close(sd);
}
return rv;
}
#endif
/* priometh.c */