From 554fd8c5195424bdbcabf5de30fdc183aba391bd Mon Sep 17 00:00:00 2001 From: upstream source tree Date: Sun, 15 Mar 2015 20:14:05 -0400 Subject: obtained gcc-4.6.4.tar.bz2 from upstream website; verified gcc-4.6.4.tar.bz2.sig; imported gcc-4.6.4 source tree from verified upstream tarball. downloading a git-generated archive based on the 'upstream' tag should provide you with a source tree that is binary identical to the one extracted from the above tarball. if you have obtained the source via the command 'git clone', however, do note that line-endings of files in your working directory might differ from line-endings of the respective files in the upstream repository. --- libjava/classpath/native/jni/java-nio/javanio.h | 334 ++++++++++++++++++++++++ 1 file changed, 334 insertions(+) create mode 100644 libjava/classpath/native/jni/java-nio/javanio.h (limited to 'libjava/classpath/native/jni/java-nio/javanio.h') diff --git a/libjava/classpath/native/jni/java-nio/javanio.h b/libjava/classpath/native/jni/java-nio/javanio.h new file mode 100644 index 000000000..cc31cf3c1 --- /dev/null +++ b/libjava/classpath/native/jni/java-nio/javanio.h @@ -0,0 +1,334 @@ +/* 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 + +/** + * 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__ */ -- cgit v1.2.3