/*
 *  Licensed to the Apache Software Foundation (ASF) under one or more
 *  contributor license agreements.  See the NOTICE file distributed with
 *  this work for additional information regarding copyright ownership.
 *  The ASF licenses this file to You under the Apache License, Version 2.0
 *  (the "License"); you may not use this file except in compliance with
 *  the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 */

package org.apache.tomcat.jni;

/* Import needed classes */
import java.nio.ByteBuffer;

Socket
Author:Mladen Turk
Deprecated: The scope of the APR/Native Library will be reduced in Tomcat 10.1.x onwards to only those components required to provide OpenSSL integration with the NIO and NIO2 connectors.
/** Socket * * @author Mladen Turk * * @deprecated The scope of the APR/Native Library will be reduced in Tomcat * 10.1.x onwards to only those components required to provide * OpenSSL integration with the NIO and NIO2 connectors. */
@Deprecated public class Socket { /* Standard socket defines */ public static final int SOCK_STREAM = 0; public static final int SOCK_DGRAM = 1; /* * apr_sockopt Socket option definitions */ public static final int APR_SO_LINGER = 1;
Linger
/** Linger */
public static final int APR_SO_KEEPALIVE = 2;
Keepalive
/** Keepalive */
public static final int APR_SO_DEBUG = 4;
Debug
/** Debug */
public static final int APR_SO_NONBLOCK = 8;
Non-blocking IO
/** Non-blocking IO */
public static final int APR_SO_REUSEADDR = 16;
Reuse addresses
/** Reuse addresses */
public static final int APR_SO_SNDBUF = 64;
Send buffer
/** Send buffer */
public static final int APR_SO_RCVBUF = 128;
Receive buffer
/** Receive buffer */
public static final int APR_SO_DISCONNECTED = 256; /** Disconnected */
For SCTP sockets, this is mapped to STCP_NODELAY internally.
/** For SCTP sockets, this is mapped to STCP_NODELAY internally. */
public static final int APR_TCP_NODELAY = 512; public static final int APR_TCP_NOPUSH = 1024; /** No push */
This flag is ONLY set internally when we set APR_TCP_NOPUSH with APR_TCP_NODELAY set to tell us that APR_TCP_NODELAY should be turned on again when NOPUSH is turned off
/** This flag is ONLY set internally when we set APR_TCP_NOPUSH with * APR_TCP_NODELAY set to tell us that APR_TCP_NODELAY should be turned on * again when NOPUSH is turned off */
public static final int APR_RESET_NODELAY = 2048;
Set on non-blocking sockets (timeout != 0) on which the previous read() did not fill a buffer completely. the next apr_socket_recv() will first call select()/poll() rather than going straight into read(). (Can also be set by an application to force a select()/poll() call before the next read, in cases where the app expects that an immediate read would fail.)
/** Set on non-blocking sockets (timeout != 0) on which the * previous read() did not fill a buffer completely. the next * apr_socket_recv() will first call select()/poll() rather than * going straight into read(). (Can also be set by an application to * force a select()/poll() call before the next read, in cases where * the app expects that an immediate read would fail.) */
public static final int APR_INCOMPLETE_READ = 4096;
like APR_INCOMPLETE_READ, but for write
/** like APR_INCOMPLETE_READ, but for write */
public static final int APR_INCOMPLETE_WRITE = 8192;
Don't accept IPv4 connections on an IPv6 listening socket.
/** Don't accept IPv4 connections on an IPv6 listening socket. */
public static final int APR_IPV6_V6ONLY = 16384;
Delay accepting of new connections until data is available.
/** Delay accepting of new connections until data is available. */
public static final int APR_TCP_DEFER_ACCEPT = 32768;
Define what type of socket shutdown should occur. apr_shutdown_how_e enum
/** Define what type of socket shutdown should occur. * apr_shutdown_how_e enum */
public static final int APR_SHUTDOWN_READ = 0;
no longer allow read request
/** no longer allow read request */
public static final int APR_SHUTDOWN_WRITE = 1;
no longer allow write requests
/** no longer allow write requests */
public static final int APR_SHUTDOWN_READWRITE = 2;
no longer allow read or write requests
/** no longer allow read or write requests */
public static final int APR_IPV4_ADDR_OK = 0x01; public static final int APR_IPV6_ADDR_OK = 0x02; public static final int APR_UNSPEC = 0; public static final int APR_INET = 1; public static final int APR_INET6 = 2; public static final int APR_PROTO_TCP = 6;
TCP
/** TCP */
public static final int APR_PROTO_UDP = 17;
UDP
/** UDP */
public static final int APR_PROTO_SCTP = 132; /** SCTP */
Enum to tell us if we're interested in remote or local socket apr_interface_e
/** * Enum to tell us if we're interested in remote or local socket * apr_interface_e */
public static final int APR_LOCAL = 0; public static final int APR_REMOTE = 1; /* Socket.get types */ public static final int SOCKET_GET_POOL = 0; public static final int SOCKET_GET_IMPL = 1; public static final int SOCKET_GET_APRS = 2; public static final int SOCKET_GET_TYPE = 3;
Create a socket.
Params:
  • family – The address family of the socket (e.g., APR_INET).
  • type – The type of the socket (e.g., SOCK_STREAM).
  • protocol – The protocol of the socket (e.g., APR_PROTO_TCP).
  • cont – The parent pool to use
Throws:
Returns:The new socket that has been set up.
/** * Create a socket. * @param family The address family of the socket (e.g., APR_INET). * @param type The type of the socket (e.g., SOCK_STREAM). * @param protocol The protocol of the socket (e.g., APR_PROTO_TCP). * @param cont The parent pool to use * @return The new socket that has been set up. * @throws Exception Error creating socket */
public static native long create(int family, int type, int protocol, long cont) throws Exception;
Shutdown either reading, writing, or both sides of a socket.
This does not actually close the socket descriptor, it just controls which calls are still valid on the socket.
Params:
  • thesocket – The socket to close
  • how – How to shutdown the socket. One of:
    APR_SHUTDOWN_READ         no longer allow read requests
    APR_SHUTDOWN_WRITE        no longer allow write requests
    APR_SHUTDOWN_READWRITE    no longer allow read or write requests
    
Returns:the operation status
/** * Shutdown either reading, writing, or both sides of a socket. * <br> * This does not actually close the socket descriptor, it just * controls which calls are still valid on the socket. * @param thesocket The socket to close * @param how How to shutdown the socket. One of: * <PRE> * APR_SHUTDOWN_READ no longer allow read requests * APR_SHUTDOWN_WRITE no longer allow write requests * APR_SHUTDOWN_READWRITE no longer allow read or write requests * </PRE> * @return the operation status */
public static native int shutdown(long thesocket, int how);
Close a socket.
Params:
  • thesocket – The socket to close
Returns:the operation status
/** * Close a socket. * @param thesocket The socket to close * @return the operation status */
public static native int close(long thesocket);
Destroy a pool associated with socket
Params:
  • thesocket – The destroy
/** * Destroy a pool associated with socket * @param thesocket The destroy */
public static native void destroy(long thesocket);
Bind the socket to its associated port
Params:
  • sock – The socket to bind
  • sa – The socket address to bind to This may be where we will find out if there is any other process using the selected port.
Returns:the operation status
/** * Bind the socket to its associated port * @param sock The socket to bind * @param sa The socket address to bind to * This may be where we will find out if there is any other process * using the selected port. * @return the operation status */
public static native int bind(long sock, long sa);
Listen to a bound socket for connections.
Params:
  • sock – The socket to listen on
  • backlog – The number of outstanding connections allowed in the sockets listen queue. If this value is less than zero, the listen queue size is set to zero.
Returns:the operation status
/** * Listen to a bound socket for connections. * @param sock The socket to listen on * @param backlog The number of outstanding connections allowed in the sockets * listen queue. If this value is less than zero, the listen * queue size is set to zero. * @return the operation status */
public static native int listen(long sock, int backlog);
Accept a new connection request
Params:
  • sock – The socket we are listening on.
  • pool – The pool for the new socket.
Throws:
Returns: A copy of the socket that is connected to the socket that made the connection request. This is the socket which should be used for all future communication.
/** * Accept a new connection request * @param sock The socket we are listening on. * @param pool The pool for the new socket. * @return A copy of the socket that is connected to the socket that * made the connection request. This is the socket which should * be used for all future communication. * @throws Exception Socket accept error */
public static native long acceptx(long sock, long pool) throws Exception;
Accept a new connection request
Params:
  • sock – The socket we are listening on.
Throws:
Returns: A copy of the socket that is connected to the socket that made the connection request. This is the socket which should be used for all future communication.
/** * Accept a new connection request * @param sock The socket we are listening on. * @return A copy of the socket that is connected to the socket that * made the connection request. This is the socket which should * be used for all future communication. * @throws Exception Socket accept error */
public static native long accept(long sock) throws Exception;
Set an OS level accept filter.
Params:
  • sock – The socket to put the accept filter on.
  • name – The accept filter
  • args – Any extra args to the accept filter. Passing NULL here removes the accept filter.
Returns:the operation status
/** * Set an OS level accept filter. * @param sock The socket to put the accept filter on. * @param name The accept filter * @param args Any extra args to the accept filter. Passing NULL here removes * the accept filter. * @return the operation status */
public static native int acceptfilter(long sock, String name, String args);
Query the specified socket if at the OOB/Urgent data mark
Params:
  • sock – The socket to query
Returns:true if socket is at the OOB/urgent mark, otherwise false.
/** * Query the specified socket if at the OOB/Urgent data mark * @param sock The socket to query * @return <code>true</code> if socket is at the OOB/urgent mark, * otherwise <code>false</code>. */
public static native boolean atmark(long sock);
Issue a connection request to a socket either on the same machine or a different one.
Params:
  • sock – The socket we wish to use for our side of the connection
  • sa – The address of the machine we wish to connect to.
Returns:the operation status
/** * Issue a connection request to a socket either on the same machine * or a different one. * @param sock The socket we wish to use for our side of the connection * @param sa The address of the machine we wish to connect to. * @return the operation status */
public static native int connect(long sock, long sa);
Send data over a network.
This functions acts like a blocking write by default.  To change
this behavior, use apr_socket_timeout_set() or the APR_SO_NONBLOCK
socket option.
It is possible for both bytes to be sent and an error to be returned.
APR_EINTR is never returned.
Params:
  • sock – The socket to send the data over.
  • buf – The buffer which contains the data to be sent.
  • offset – Offset in the byte buffer.
  • len – The number of bytes to write; (-1) for full array.
Returns:The number of bytes sent
/** * Send data over a network. * <PRE> * This functions acts like a blocking write by default. To change * this behavior, use apr_socket_timeout_set() or the APR_SO_NONBLOCK * socket option. * * It is possible for both bytes to be sent and an error to be returned. * * APR_EINTR is never returned. * </PRE> * @param sock The socket to send the data over. * @param buf The buffer which contains the data to be sent. * @param offset Offset in the byte buffer. * @param len The number of bytes to write; (-1) for full array. * @return The number of bytes sent */
public static native int send(long sock, byte[] buf, int offset, int len);
Send data over a network.
This functions acts like a blocking write by default.  To change
this behavior, use apr_socket_timeout_set() or the APR_SO_NONBLOCK
socket option.
It is possible for both bytes to be sent and an error to be returned.
APR_EINTR is never returned.
Params:
  • sock – The socket to send the data over.
  • buf – The Byte buffer which contains the data to be sent.
  • offset – The offset within the buffer array of the first buffer from which bytes are to be retrieved; must be non-negative and no larger than buf.length
  • len – The maximum number of buffers to be accessed; must be non-negative and no larger than buf.length - offset
Returns:The number of bytes sent
/** * Send data over a network. * <PRE> * This functions acts like a blocking write by default. To change * this behavior, use apr_socket_timeout_set() or the APR_SO_NONBLOCK * socket option. * * It is possible for both bytes to be sent and an error to be returned. * * APR_EINTR is never returned. * </PRE> * @param sock The socket to send the data over. * @param buf The Byte buffer which contains the data to be sent. * @param offset The offset within the buffer array of the first buffer from * which bytes are to be retrieved; must be non-negative * and no larger than buf.length * @param len The maximum number of buffers to be accessed; must be non-negative * and no larger than buf.length - offset * @return The number of bytes sent */
public static native int sendb(long sock, ByteBuffer buf, int offset, int len);
Send data over a network without retry
This functions acts like a blocking write by default.  To change
this behavior, use apr_socket_timeout_set() or the APR_SO_NONBLOCK
socket option.
It is possible for both bytes to be sent and an error to be returned.
Params:
  • sock – The socket to send the data over.
  • buf – The Byte buffer which contains the data to be sent.
  • offset – The offset within the buffer array of the first buffer from which bytes are to be retrieved; must be non-negative and no larger than buf.length
  • len – The maximum number of buffers to be accessed; must be non-negative and no larger than buf.length - offset
Returns:The number of bytes sent
/** * Send data over a network without retry * <PRE> * This functions acts like a blocking write by default. To change * this behavior, use apr_socket_timeout_set() or the APR_SO_NONBLOCK * socket option. * * It is possible for both bytes to be sent and an error to be returned. * * </PRE> * @param sock The socket to send the data over. * @param buf The Byte buffer which contains the data to be sent. * @param offset The offset within the buffer array of the first buffer from * which bytes are to be retrieved; must be non-negative * and no larger than buf.length * @param len The maximum number of buffers to be accessed; must be non-negative * and no larger than buf.length - offset * @return The number of bytes sent */
public static native int sendib(long sock, ByteBuffer buf, int offset, int len);
Send data over a network using internally set ByteBuffer
Params:
  • sock – The socket to send the data over.
  • offset – The offset within the buffer array of the first buffer from which bytes are to be retrieved; must be non-negative and no larger than buf.length
  • len – The maximum number of buffers to be accessed; must be non-negative and no larger than buf.length - offset
Returns:The number of bytes sent
/** * Send data over a network using internally set ByteBuffer * @param sock The socket to send the data over. * @param offset The offset within the buffer array of the first buffer from * which bytes are to be retrieved; must be non-negative * and no larger than buf.length * @param len The maximum number of buffers to be accessed; must be non-negative * and no larger than buf.length - offset * @return The number of bytes sent */
public static native int sendbb(long sock, int offset, int len);
Send data over a network using internally set ByteBuffer without internal retry.
Params:
  • sock – The socket to send the data over.
  • offset – The offset within the buffer array of the first buffer from which bytes are to be retrieved; must be non-negative and no larger than buf.length
  • len – The maximum number of buffers to be accessed; must be non-negative and no larger than buf.length - offset
Returns:The number of bytes sent
/** * Send data over a network using internally set ByteBuffer * without internal retry. * @param sock The socket to send the data over. * @param offset The offset within the buffer array of the first buffer from * which bytes are to be retrieved; must be non-negative * and no larger than buf.length * @param len The maximum number of buffers to be accessed; must be non-negative * and no larger than buf.length - offset * @return The number of bytes sent */
public static native int sendibb(long sock, int offset, int len);
Send multiple packets of data over a network.
This functions acts like a blocking write by default.  To change
this behavior, use apr_socket_timeout_set() or the APR_SO_NONBLOCK
socket option.
The number of bytes actually sent is stored in argument 3.
It is possible for both bytes to be sent and an error to be returned.
APR_EINTR is never returned.
Params:
  • sock – The socket to send the data over.
  • vec – The array from which to get the data to send.
Returns:The number of bytes sent
/** * Send multiple packets of data over a network. * <PRE> * This functions acts like a blocking write by default. To change * this behavior, use apr_socket_timeout_set() or the APR_SO_NONBLOCK * socket option. * The number of bytes actually sent is stored in argument 3. * * It is possible for both bytes to be sent and an error to be returned. * * APR_EINTR is never returned. * </PRE> * @param sock The socket to send the data over. * @param vec The array from which to get the data to send. * @return The number of bytes sent */
public static native int sendv(long sock, byte[][] vec);
Params:
  • sock – The socket to send from
  • where – The apr_sockaddr_t describing where to send the data
  • flags – The flags to use
  • buf – The data to send
  • offset – Offset in the byte buffer.
  • len – The length of the data to send
Returns:The number of bytes sent
/** * @param sock The socket to send from * @param where The apr_sockaddr_t describing where to send the data * @param flags The flags to use * @param buf The data to send * @param offset Offset in the byte buffer. * @param len The length of the data to send * @return The number of bytes sent */
public static native int sendto(long sock, long where, int flags, byte[] buf, int offset, int len);
Read data from a network.
This functions acts like a blocking read by default.  To change
this behavior, use apr_socket_timeout_set() or the APR_SO_NONBLOCK
socket option.
The number of bytes actually received is stored in argument 3.
It is possible for both bytes to be received and an APR_EOF or
other error to be returned.
APR_EINTR is never returned.
Params:
  • sock – The socket to read the data from.
  • buf – The buffer to store the data in.
  • offset – Offset in the byte buffer.
  • nbytes – The number of bytes to read (-1) for full array.
Returns:the number of bytes received.
/** * Read data from a network. * * <PRE> * This functions acts like a blocking read by default. To change * this behavior, use apr_socket_timeout_set() or the APR_SO_NONBLOCK * socket option. * The number of bytes actually received is stored in argument 3. * * It is possible for both bytes to be received and an APR_EOF or * other error to be returned. * * APR_EINTR is never returned. * </PRE> * @param sock The socket to read the data from. * @param buf The buffer to store the data in. * @param offset Offset in the byte buffer. * @param nbytes The number of bytes to read (-1) for full array. * @return the number of bytes received. */
public static native int recv(long sock, byte[] buf, int offset, int nbytes);
Read data from a network with timeout.
This functions acts like a blocking read by default.  To change
this behavior, use apr_socket_timeout_set() or the APR_SO_NONBLOCK
socket option.
The number of bytes actually received is stored in argument 3.
It is possible for both bytes to be received and an APR_EOF or
other error to be returned.
APR_EINTR is never returned.
Params:
  • sock – The socket to read the data from.
  • buf – The buffer to store the data in.
  • offset – Offset in the byte buffer.
  • nbytes – The number of bytes to read (-1) for full array.
  • timeout – The socket timeout in microseconds.
Returns:the number of bytes received.
/** * Read data from a network with timeout. * * <PRE> * This functions acts like a blocking read by default. To change * this behavior, use apr_socket_timeout_set() or the APR_SO_NONBLOCK * socket option. * The number of bytes actually received is stored in argument 3. * * It is possible for both bytes to be received and an APR_EOF or * other error to be returned. * * APR_EINTR is never returned. * </PRE> * @param sock The socket to read the data from. * @param buf The buffer to store the data in. * @param offset Offset in the byte buffer. * @param nbytes The number of bytes to read (-1) for full array. * @param timeout The socket timeout in microseconds. * @return the number of bytes received. */
public static native int recvt(long sock, byte[] buf, int offset, int nbytes, long timeout);
Read data from a network.
This functions acts like a blocking read by default.  To change
this behavior, use apr_socket_timeout_set() or the APR_SO_NONBLOCK
socket option.
The number of bytes actually received is stored in argument 3.
It is possible for both bytes to be received and an APR_EOF or
other error to be returned.
APR_EINTR is never returned.
Params:
  • sock – The socket to read the data from.
  • buf – The buffer to store the data in.
  • offset – Offset in the byte buffer.
  • nbytes – The number of bytes to read (-1) for full array.
Returns:If ≥ 0, the return value is the number of bytes read. Note a non-blocking read with no data current available will return Status.EAGAIN and EOF will return Status.APR_EOF.
/** * Read data from a network. * * <PRE> * This functions acts like a blocking read by default. To change * this behavior, use apr_socket_timeout_set() or the APR_SO_NONBLOCK * socket option. * The number of bytes actually received is stored in argument 3. * * It is possible for both bytes to be received and an APR_EOF or * other error to be returned. * * APR_EINTR is never returned. * </PRE> * @param sock The socket to read the data from. * @param buf The buffer to store the data in. * @param offset Offset in the byte buffer. * @param nbytes The number of bytes to read (-1) for full array. * @return If &ge; 0, the return value is the number of bytes read. Note a * non-blocking read with no data current available will return * {@link Status#EAGAIN} and EOF will return {@link Status#APR_EOF}. */
public static native int recvb(long sock, ByteBuffer buf, int offset, int nbytes);
Read data from a network using internally set ByteBuffer.
Params:
  • sock – The socket to read the data from.
  • offset – Offset in the byte buffer.
  • nbytes – The number of bytes to read (-1) for full array.
Returns:If > 0, the return value is the number of bytes read. If == 0, the return value indicates EOF and if < 0 the return value is the error code. Note a non-blocking read with no data current available will return Status.EAGAIN not zero.
/** * Read data from a network using internally set ByteBuffer. * * @param sock The socket to read the data from. * @param offset Offset in the byte buffer. * @param nbytes The number of bytes to read (-1) for full array. * @return If &gt; 0, the return value is the number of bytes read. If == 0, * the return value indicates EOF and if &lt; 0 the return value is the * error code. Note a non-blocking read with no data current * available will return {@link Status#EAGAIN} not zero. */
public static native int recvbb(long sock, int offset, int nbytes);
Read data from a network with timeout.
This functions acts like a blocking read by default.  To change
this behavior, use apr_socket_timeout_set() or the APR_SO_NONBLOCK
socket option.
The number of bytes actually received is stored in argument 3.
It is possible for both bytes to be received and an APR_EOF or
other error to be returned.
APR_EINTR is never returned.
Params:
  • sock – The socket to read the data from.
  • buf – The buffer to store the data in.
  • offset – Offset in the byte buffer.
  • nbytes – The number of bytes to read (-1) for full array.
  • timeout – The socket timeout in microseconds.
Returns:the number of bytes received.
/** * Read data from a network with timeout. * * <PRE> * This functions acts like a blocking read by default. To change * this behavior, use apr_socket_timeout_set() or the APR_SO_NONBLOCK * socket option. * The number of bytes actually received is stored in argument 3. * * It is possible for both bytes to be received and an APR_EOF or * other error to be returned. * * APR_EINTR is never returned. * </PRE> * @param sock The socket to read the data from. * @param buf The buffer to store the data in. * @param offset Offset in the byte buffer. * @param nbytes The number of bytes to read (-1) for full array. * @param timeout The socket timeout in microseconds. * @return the number of bytes received. */
public static native int recvbt(long sock, ByteBuffer buf, int offset, int nbytes, long timeout);
Read data from a network with timeout using internally set ByteBuffer
Params:
  • sock – The socket to read the data from.
  • offset – Offset in the byte buffer.
  • nbytes – The number of bytes to read (-1) for full array.
  • timeout – The socket timeout in microseconds.
Returns:the number of bytes received.
/** * Read data from a network with timeout using internally set ByteBuffer * @param sock The socket to read the data from. * @param offset Offset in the byte buffer. * @param nbytes The number of bytes to read (-1) for full array. * @param timeout The socket timeout in microseconds. * @return the number of bytes received. */
public static native int recvbbt(long sock, int offset, int nbytes, long timeout);
Params:
  • from – The apr_sockaddr_t to fill in the recipient info
  • sock – The socket to use
  • flags – The flags to use
  • buf – The buffer to use
  • offset – Offset in the byte buffer.
  • nbytes – The number of bytes to read (-1) for full array.
Returns:the number of bytes received.
/** * @param from The apr_sockaddr_t to fill in the recipient info * @param sock The socket to use * @param flags The flags to use * @param buf The buffer to use * @param offset Offset in the byte buffer. * @param nbytes The number of bytes to read (-1) for full array. * @return the number of bytes received. */
public static native int recvfrom(long from, long sock, int flags, byte[] buf, int offset, int nbytes);
Setup socket options for the specified socket
Params:
  • sock – The socket to set up.
  • opt – The option we would like to configure. One of:
    APR_SO_DEBUG      --  turn on debugging information
    APR_SO_KEEPALIVE  --  keep connections active
    APR_SO_LINGER     --  lingers on close if data is present
    APR_SO_NONBLOCK   --  Turns blocking on/off for socket
                          When this option is enabled, use
                          the APR_STATUS_IS_EAGAIN() macro to
                          see if a send or receive function
                          could not transfer data without
                          blocking.
    APR_SO_REUSEADDR  --  The rules used in validating addresses
                          supplied to bind should allow reuse
                          of local addresses.
    APR_SO_SNDBUF     --  Set the SendBufferSize
    APR_SO_RCVBUF     --  Set the ReceiveBufferSize
    
  • on – Value for the option.
Returns:the operation status
/** * Setup socket options for the specified socket * @param sock The socket to set up. * @param opt The option we would like to configure. One of: * <PRE> * APR_SO_DEBUG -- turn on debugging information * APR_SO_KEEPALIVE -- keep connections active * APR_SO_LINGER -- lingers on close if data is present * APR_SO_NONBLOCK -- Turns blocking on/off for socket * When this option is enabled, use * the APR_STATUS_IS_EAGAIN() macro to * see if a send or receive function * could not transfer data without * blocking. * APR_SO_REUSEADDR -- The rules used in validating addresses * supplied to bind should allow reuse * of local addresses. * APR_SO_SNDBUF -- Set the SendBufferSize * APR_SO_RCVBUF -- Set the ReceiveBufferSize * </PRE> * @param on Value for the option. * @return the operation status */
public static native int optSet(long sock, int opt, int on);
Query socket options for the specified socket
Params:
  • sock – The socket to query
  • opt – The option we would like to query. One of:
    APR_SO_DEBUG      --  turn on debugging information
    APR_SO_KEEPALIVE  --  keep connections active
    APR_SO_LINGER     --  lingers on close if data is present
    APR_SO_NONBLOCK   --  Turns blocking on/off for socket
    APR_SO_REUSEADDR  --  The rules used in validating addresses
                          supplied to bind should allow reuse
                          of local addresses.
    APR_SO_SNDBUF     --  Set the SendBufferSize
    APR_SO_RCVBUF     --  Set the ReceiveBufferSize
    APR_SO_DISCONNECTED -- Query the disconnected state of the socket.
                          (Currently only used on Windows)
    
Throws:
Returns:Socket option returned on the call.
/** * Query socket options for the specified socket * @param sock The socket to query * @param opt The option we would like to query. One of: * <PRE> * APR_SO_DEBUG -- turn on debugging information * APR_SO_KEEPALIVE -- keep connections active * APR_SO_LINGER -- lingers on close if data is present * APR_SO_NONBLOCK -- Turns blocking on/off for socket * APR_SO_REUSEADDR -- The rules used in validating addresses * supplied to bind should allow reuse * of local addresses. * APR_SO_SNDBUF -- Set the SendBufferSize * APR_SO_RCVBUF -- Set the ReceiveBufferSize * APR_SO_DISCONNECTED -- Query the disconnected state of the socket. * (Currently only used on Windows) * </PRE> * @return Socket option returned on the call. * @throws Exception An error occurred */
public static native int optGet(long sock, int opt) throws Exception;
Setup socket timeout for the specified socket
Params:
  • sock – The socket to set up.
  • t – Value for the timeout in microseconds.
    t > 0  -- read and write calls return APR_TIMEUP if specified time
              elapses with no data read or written
    t == 0 -- read and write calls never block
    t < 0  -- read and write calls block
    
Returns:the operation status
/** * Setup socket timeout for the specified socket * @param sock The socket to set up. * @param t Value for the timeout in microseconds. * <PRE> * t &gt; 0 -- read and write calls return APR_TIMEUP if specified time * elapses with no data read or written * t == 0 -- read and write calls never block * t &lt; 0 -- read and write calls block * </PRE> * @return the operation status */
public static native int timeoutSet(long sock, long t);
Query socket timeout for the specified socket
Params:
  • sock – The socket to query
Throws:
Returns:Socket timeout returned from the query.
/** * Query socket timeout for the specified socket * @param sock The socket to query * @return Socket timeout returned from the query. * @throws Exception An error occurred */
public static native long timeoutGet(long sock) throws Exception;
Send a file from an open file descriptor to a socket, along with optional headers and trailers.
This functions acts like a blocking write by default. To change this behavior, use apr_socket_timeout_set() or the APR_SO_NONBLOCK socket option. The number of bytes actually sent is stored in the len parameter. The offset parameter is passed by reference for no reason; its value will never be modified by the apr_socket_sendfile() function.
Params:
  • sock – The socket to which we're writing
  • file – The open file from which to read
  • headers – Array containing the headers to send
  • trailers – Array containing the trailers to send
  • offset – Offset into the file where we should begin writing
  • len – Number of bytes to send from the file
  • flags – APR flags that are mapped to OS specific flags
Returns:Number of bytes actually sent, including headers, file, and trailers
/** * Send a file from an open file descriptor to a socket, along with * optional headers and trailers. * <br> * This functions acts like a blocking write by default. To change * this behavior, use apr_socket_timeout_set() or the * APR_SO_NONBLOCK socket option. * The number of bytes actually sent is stored in the len parameter. * The offset parameter is passed by reference for no reason; its * value will never be modified by the apr_socket_sendfile() function. * @param sock The socket to which we're writing * @param file The open file from which to read * @param headers Array containing the headers to send * @param trailers Array containing the trailers to send * @param offset Offset into the file where we should begin writing * @param len Number of bytes to send from the file * @param flags APR flags that are mapped to OS specific flags * @return Number of bytes actually sent, including headers, * file, and trailers */
public static native long sendfile(long sock, long file, byte [][] headers, byte[][] trailers, long offset, long len, int flags);
Send a file without header and trailer arrays.
Params:
  • sock – The socket to which we're writing
  • file – The open file from which to read
  • offset – Offset into the file where we should begin writing
  • len – Number of bytes to send from the file
  • flags – APR flags that are mapped to OS specific flags
Returns:Number of bytes actually sent
/** * Send a file without header and trailer arrays. * @param sock The socket to which we're writing * @param file The open file from which to read * @param offset Offset into the file where we should begin writing * @param len Number of bytes to send from the file * @param flags APR flags that are mapped to OS specific flags * @return Number of bytes actually sent */
public static native long sendfilen(long sock, long file, long offset, long len, int flags);
Create a child pool from associated socket pool.
Params:
  • thesocket – The socket to use
Throws:
Returns:a pointer to the pool
/** * Create a child pool from associated socket pool. * @param thesocket The socket to use * @return a pointer to the pool * @throws Exception An error occurred */
public static native long pool(long thesocket) throws Exception;
Private method for getting the socket struct members
Params:
  • socket – The socket to use
  • what – Struct member to obtain
    SOCKET_GET_POOL  - The socket pool
    SOCKET_GET_IMPL  - The socket implementation object
    SOCKET_GET_APRS  - APR socket
    SOCKET_GET_TYPE  - Socket type
    
Returns:The structure member address
/** * Private method for getting the socket struct members * @param socket The socket to use * @param what Struct member to obtain * <PRE> * SOCKET_GET_POOL - The socket pool * SOCKET_GET_IMPL - The socket implementation object * SOCKET_GET_APRS - APR socket * SOCKET_GET_TYPE - Socket type * </PRE> * @return The structure member address */
private static native long get(long socket, int what);
Set internal send ByteBuffer. This function will preset internal Java ByteBuffer for consecutive sendbb calls.
Params:
  • sock – The socket to use
  • buf – The ByteBuffer
/** * Set internal send ByteBuffer. * This function will preset internal Java ByteBuffer for * consecutive sendbb calls. * @param sock The socket to use * @param buf The ByteBuffer */
public static native void setsbb(long sock, ByteBuffer buf);
Set internal receive ByteBuffer. This function will preset internal Java ByteBuffer for consecutive revcvbb/recvbbt calls.
Params:
  • sock – The socket to use
  • buf – The ByteBuffer
/** * Set internal receive ByteBuffer. * This function will preset internal Java ByteBuffer for * consecutive revcvbb/recvbbt calls. * @param sock The socket to use * @param buf The ByteBuffer */
public static native void setrbb(long sock, ByteBuffer buf);
Set the data associated with the current socket.
Params:
  • sock – The currently open socket.
  • data – The user data to associate with the socket.
  • key – The key to associate with the data.
Returns:the operation status
/** * Set the data associated with the current socket. * @param sock The currently open socket. * @param data The user data to associate with the socket. * @param key The key to associate with the data. * @return the operation status */
public static native int dataSet(long sock, String key, Object data);
Return the data associated with the current socket
Params:
  • sock – The currently open socket.
  • key – The key to associate with the user data.
Returns:Data or null in case of error.
/** * Return the data associated with the current socket * @param sock The currently open socket. * @param key The key to associate with the user data. * @return Data or null in case of error. */
public static native Object dataGet(long sock, String key); }