mirror of git://gcc.gnu.org/git/gcc.git
335 lines
14 KiB
C
335 lines
14 KiB
C
/* 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
|
|
|
|
/**
|
|
* 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__ */
|