/* javanio.h -- reference implementation of native functions.
   Copyright (C) 2006  Free Software Foundation, Inc.

This file is a part of GNU Classpath.

GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or (at
your option) any later version.

GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
General Public License for more details.

You should have received a copy of the GNU General Public License
along with GNU Classpath; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
USA

Linking this library statically or dynamically with other modules is
making a combined work based on this library.  Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.

As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module.  An independent module is a module which is not derived from
or based on this library.  If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so.  If you do not wish to do so, delete this
exception statement from your version.  */


#ifndef __JAVANIO_H__
#define __JAVANIO_H__

#include <sys/time.h>

/**
 * This header defines functions that are called by our JNI reference
 * implementation of java.nio.*. In our reference implementation, these
 * functions map exactly to their counterparts in POSIX; in implementations
 * that can't use these functions directly (such as systems that use user-land
 * threads, and thus can't call blocking system calls directly) can provide
 * their own implementations suitable for their system.
 */

/**
 * This macro is used in all function prototypes below; if any additional
 * keywords need to be added to a prototype, declare them in this macro.
 */
//#define CPNIO_EXPORT static inline
#define CPNIO_EXPORT 

/**
 * Read bytes from the given file descriptor into the given memory address, which
 * has sufficient space for NBYTES bytes.
 *
 * \param fd     The file descriptor to read from.
 * \param buf    The memory address to read bytes into.
 * \param nbytes The number of bytes available to store in BUF.
 * \return The number of bytes read, possibly zero, on success; return -1 on failure,
 *  and set ERRNO to an appropriate value.
 * \see read(2)
 *
 * Allowed errno values:
 *   [EBADF]   If FD is not a valid file descriptor, or is not open for reading.
 *   [EFAULT]  If BUF points outside the process's address space.
 *   [EIO]     An I/O error occurrs.
 *   [EINTR]   If the read is interrupted by a signal.
 *   [EINVAL]  If FD is negative.
 *   [EAGAIN]  If FD was marked for non-blocking I/O, and no data were ready to
 *             be read.
 */
CPNIO_EXPORT ssize_t cpnio_read (int fd, void *buf, size_t nbytes);

/*
 * Read bytes from a file descriptor into a sequence of IO buffers.
 *
 * The iovec structure is defined as:
 *
 *   struct iovec {
 *     char   *iov_base;
 *     size_t  iov_len;
 *   };
 *
 * The call to _cp_readv should do a scattering read, where for each struct iovec
 * in the supplied list, up to IOV_LEN bytes are read into IOV_BASE. The function
 * returns the total number of bytes read into all supplied buffers.
 *
 * \param fd     The file descriptor.
 * \param iov    A pointer to the head of a list of iovec structures.
 * \param iovcnt The number of iovec structures pointed to by IOV.
 * \return The total number of bytes read accross all buffers, possibly zero. On
 *  error, -1 is returned and ERRNO is set.
 * \see readv(2)
 *
 * Allowed ERRNO values include all of those listed for _cp_read, as well as the
 * following:
 *   [EINVAL] If IOVCNT overflows the maximum number of iovec structures
 *            this platform supports (usually 16), if any IOV_LEN value
 *            is negative, or if the sum of all IOV_LEN values is too
 *            large to be stored in a ssize_t (usually a 32-bit integer).
 *   [EFAULT] If part of IOV points outside the process's address space.
 */
CPNIO_EXPORT ssize_t cpnio_readv (int fd, const struct iovec *iov, int iovcnt);

/*
 * Write NBYTES bytes from BUF to the file descriptor FD, returning the number
 * of bytes successfully written.
 *
 * \param fd     The file descriptor.
 * \param buf    A pointer to the bytes to write.
 * \param nbytes The maximum number of bytes to write.
 * \return The number of bytes written to the file descriptor, possibly zero. -1
 *  is returned if an error is encountered, and ERRNO will be set.
 * \see write(2)
 *
 * Allowed ERRNO values:
 *   [EBADF]   If FD is not a valid file descriptor or is not open for writing.
 *   [EPIPE]   If FD is a pipe, when the other side is disconnected; if FD is a
 *             socket, when the peer is not connected.
 *   [EFBIG]   When FD is a file, and writing to it overflows the process's
 *             or the system's maximim file size.
 *   [EFAULT]  If the buffer to write points outside the process's address
 *             space.
 *   [EINVAL]  If the descriptor FD is negative.
 *   [ENOSPC]  If FD is a file, and there is insufficient space on the
 *             filesystem.
 *   [EDQUOT]  If FD is a file, and the user's disk quota has been exceeded.
 *   [EIO]     If an I/O error occurs.
 *   [EINTR]   If the call is interrupted by a signal.
 *   [EAGAIN]  If FD is in non-blocking mode, and no bytes could be immediately
 *             written.
 */
CPNIO_EXPORT ssize_t cpnio_write (int fd, const void *buf, size_t nbytes);

/*
 * Write data from a sequence of IOVCNT buffers IOV to a file descriptor FD.
 *
 * \param fd     The file descriptor.
 * \param iov    The list of buffers to write.
 * \param iovcnt The number of iovec structures pointed to by IOV.
 * \return The total number of bytes written from the given buffers, possibly
 *   zero. -1 if an error occurs, and ERRNO will be set.
 * \see writev(2)
 *
 * Allowed ERRNO values include those mentioned in _cp_write, as well as:
 *  [EDESTADDRREQ]  If the descriptor is a datagram socket, and the peer is
 *                  no longer available.
 *  [EINVAL]        If IOVCNT is out of range, if any IOV_LEN value is
 *                  negative, or if the sum of all IOVCNT IOV_LEN values
 *                  will overflow a ssize_t.
 *  [ENOBUFS]       If the mbuf pool is exhausted (???).
 */
CPNIO_EXPORT ssize_t cpnio_writev (int fd, const struct iovec *iov, size_t iovcnt);

/**
 * Open a new, unbound and unconnected socket.
 *
 * \param domain The socket domain. Implementations need only handle AF_INET.
 * \param type   The socket type; implementations need only handle types
 *  SOCK_STREAM (for streaming sockets) and SOCK_DGRAM (for datagram sockets).
 * \param protocol This should always be 0. It can be ignored.
 * \return A new file descriptor pointing to a newly created socket, or -1 on
 *  error, and ERRNO set.
 *
 * Allowed ERRNO values:
 *  [EPROTONOSUPPORT]  If TYPE is unrecognized.
 *  [EMFILE]           If a new file descriptor cannot be allocated, because
 *                     the process's descriptor table is full.
 *  [ENFILE]           Likewise, but when the system table is full.
 *  [EACCES]           If this operation is not allowed.
 *  [ENOBUFS]          If there is not enough buffer space available for the
 *                     new socket.
 */
CPNIO_EXPORT int cpnio_socket (int domain, int type, int protocol);

/**
 * Connect a socket to a remote address.
 *
 * \param fd      The file descriptor of the socket to connect.
 * \param addr    The address to connect to. In practice, this should be
 *                either a `struct sockaddr_in' or a `struct sockaddr_in6'.
 * \param addrlen The size of the address structure passed by ADDR.
 * \return Zero if the connect succeeds. -1 on error, and ERRNO should be set.
 *
 * Allowed ERRNO values:
 *  [EBADF]         If FD is not a valid file descriptor.
 *  [ENOTSOCK]      If FD is not a socket descriptor.
 *  [EADDRNOTAVAIL] If ADDR is not available for use to this process.
 *  [EAFNOSUPPORT]  If the address family of ADDR is not supported.
 *  [EISCONN]       If the socket is already connected.
 *  [ETIMEDOUT]     If the connection could not be made in a reasonable
 *                  amount of time.
 *  [ECONNREFUSED]  If the connection attempt was rejected.
 *  [ENETUNREACH]   If the network ADDR is on is unreachable.
 *  [EADDRINUSE]    If the address is already in use.
 *  [EFAULT]        If ADDR points outside the addressable space.
 *  [EINPROGRESS]   If FD is in non-blocking mode, and the connection could
 *                  not be completed immediately.
 *  [EALREADY]      If FD is in non-blocking mode, and a connection attempt
 *                  is still pending.
 *  [EACCESS]       If ADDR is the broadcast address, and the socket option
 *                  SO_BROADCAST is not set.
 */
CPNIO_EXPORT int cpnio_connect (int fd, const struct sockaddr *addr, socklen_t addrlen);

/**
 * Accept an incoming connection on a socket, returning a new socket for
 * the connection, and storing the peer address in ADDR.
 *
 * \param fd      The socket file descriptor.
 * \param addr    The structure to store the peer address in.
 * \param addrlen The size of the data available in ADDR; upon return, the
 *                number of bytes stored in ADDR will be placed here.
 * \return The new socket file descriptor, or -1 on error, and ERRNO set.
 *
 * Allowed ERRNO values:
 *  [EBADF]         If FD is not a valid file descriptor.
 *  [ENOTSOCK]      If FD in not a socket descriptor.
 *  [EOPNOTSUPP]    If the socket is not a SOCK_STREAM socket.
 *  [EFAULT]        If ADDR points outside the process's addressable space.
 *  [EWOULDBLOCK]   If the socket is in non-blocking mode, and no connection
 *                  attempt is currently ready.
 *  [EMFILE]        If the process's descriptor table is full.
 *  [ENFILE]        If the system's descriptor table is full.
 */
CPNIO_EXPORT int cpnio_accept (int fd, struct sockaddr *addr, socklen_t *addrlen);

/**
 * Send a datagram to the given address.
 *
 * \param fd    The socket file descriptor.
 * \param msg   A pointer to the message to send.
 * \param len   The size of the message to send.
 * \param flags Flags for sending.
 * \param to    The remote address to send the message to.
 * \param tolen The size of the TO address structure.
 * \return The number of bytes written, possibly zero, on success. Returns
 *  -1 on failure, and sets ERRNO.
 * \see sendto(2)
 *
 * Allowed ERRNO values:
 *  [EBADF]
 *  [ENOTSOCK]
 *  [EFAULT]
 *  [EMSGSIZE]
 *  [EAGAIN]
 *  [ENOBUFS]
 *  [EACCES]
 *  [EHOSTUNREACH]
 */
CPNIO_EXPORT ssize_t cpnio_sendto (int fd, const void *msg, size_t len, int flags,
                                   const struct sockaddr *to, socklen_t tolen);

/**
 * Receive a message on a socket, storing the remote host's address in
 * FROM.
 *
 * \param fd      The socket file descriptor.
 * \param buf     The buffer to store received bytes in.
 * \param flags   Flags to control the receive.
 * \param from    Where to store the remote address.
 * \param fromlen Pointer to the size of FROM; on return, it will contain the
 *  size of the structure placed in FROM.
 * \return The number of bytes received on success. -1 on error, and ERRNO will
 *  be set.
 * \see recvfrom(2)
 *
 * Allewed ERRNO values:
 *  [EBADF]    FD is not a valid file descriptor.
 *  [ENOTCONN] If the socket is stream-oriented, and no prior call to
 *             connect(2) was made.
 *  [ENOTSOCK] FD is not a socket.
 *  [EAGAIN]   FD is in non-blocking mode, and no message was
 *             immediately available.
 *  [EINTR]    The system call was interrupted by a signal.
 *  [EFAULT]   BUF, FROM, or FROMLEN lie outside the process's address
 *             space.
 */
CPNIO_EXPORT ssize_t cpnio_recvfrom (int fd, void *buf, size_t len, int flags,
                                     struct sockaddr *from, socklen_t *fromlen);


/**
 * Control file descriptor properties.
 *
 * \param fd  The file descriptor to control.
 * \param cmd The command to execute.
 * \param arg The command argument.
 * \return A value other than -1, specific to CMD. On error, -1 is
 *  returned, and ERRNO is set.
 *
 * Allowed ERRNO values:
 *  FIXME
 */
CPNIO_EXPORT int cpnio_fcntl (int fd, int cmd, long arg);


/**
 * Select from one of the given file descriptor sets a descriptor that
 * is ready for the given operation (read, write, etc.).
 *
 * \param nfds      A value one larger than the largest file
 *                  descriptor.
 * \param readfds   A set of file descriptors to select for
 *                  readability.
 * \param writefds  A set of file descriptors to select for
 *                  writability.
 * \param exceptfds A set of file descriptors to select for
 *                  exceptional conditions.
 * \param tm        The selection timeout.
 * \return The number of file descriptors selected, possibly zero, or
 *                  -1 on error (and with ERRNO set).
 */
CPNIO_EXPORT int cpnio_select (int nfds, fd_set *readfds, fd_set *writefds,
                               fd_set *exceptfds, struct timeval *tm);

/*
 * We include the implementation file here, because our reference
 * implementation is trivial, and the functions are declared extern
 * inline.
 *
 * Implementations that need different implementations of these functions
 * SHOULD remove this line, and compile javanio.c as a separate unit.
 */
//#include "javanio.c"

#endif /* __JAVANIO_H__ */
