/* -*- 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>

/*****************************************************************************/

/************************** 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 */