Added: tomcat/sandbox/tomcat-lite/coyote-apr/org/apache/tomcat/jni/Socket.java URL: http://svn.apache.org/viewvc/tomcat/sandbox/tomcat-lite/coyote-apr/org/apache/tomcat/jni/Socket.java?rev=640860&view=auto ============================================================================== --- tomcat/sandbox/tomcat-lite/coyote-apr/org/apache/tomcat/jni/Socket.java (added) +++ tomcat/sandbox/tomcat-lite/coyote-apr/org/apache/tomcat/jni/Socket.java Tue Mar 25 08:26:26 2008 @@ -0,0 +1,529 @@ +/* + * 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 + * @version $Revision: 467222 $, $Date: 2006-10-23 20:17:11 -0700 (Mon, 23 Oct 2006) $ + */ + +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 */ + public static final int APR_SO_KEEPALIVE = 2; /** Keepalive */ + public static final int APR_SO_DEBUG = 4; /** Debug */ + public static final int APR_SO_NONBLOCK = 8; /** Non-blocking IO */ + public static final int APR_SO_REUSEADDR = 16; /** Reuse addresses */ + public static final int APR_SO_SNDBUF = 64; /** Send buffer */ + public static final int APR_SO_RCVBUF = 128; /** Receive buffer */ + public static final int APR_SO_DISCONNECTED = 256; /** Disconnected */ + /** 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 + */ + 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.) + */ + public static final int APR_INCOMPLETE_READ = 4096; + /** 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. + */ + public static final int APR_IPV6_V6ONLY = 16384; + /** 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 + */ + public static final int APR_SHUTDOWN_READ = 0; /** no longer allow read request */ + public static final int APR_SHUTDOWN_WRITE = 1; /** no longer allow write requests */ + public static final int APR_SHUTDOWN_READWRITE = 2; /** 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; + + /* TODO: Missing: + * APR_INET + * APR_UNSPEC + * APR_INET6 + */ + 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 */ + public static final int APR_PROTO_UDP = 17; /** 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 + */ + 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. + * @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. + */ + 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. + * <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> + */ + public static native int shutdown(long thesocket, int how); + + /** + * Close a socket. + * @param thesocket The socket to close + */ + public static native int close(long thesocket); + + /** + * Destroy a pool associated with socket + * @param thesocket The destroy + */ + public static native void destroy(long thesocket); + + /** + * 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. + */ + public static native int bind(long sock, long sa); + + /** + * 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. + */ + public static native int listen(long sock, int backlog); + + /** + * 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. + */ + public static native long accept(long sock) + throws Exception; + + /** + * 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. + */ + public static native int acceptfilter(long sock, String name, String args); + + /** + * Query the specified socket if at the OOB/Urgent data mark + * @param sock The socket to query + * @return True if socket is at the OOB/urgent mark, + * otherwise return false. + */ + public static native boolean atmark(long sock); + + /** + * 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. + */ + public static native int connect(long sock, long sa); + + /** + * 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 send. + * + */ + public static native int send(long sock, byte[] buf, int offset, int len); + + /** + * 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 send. + * + */ + public static native int sendb(long sock, ByteBuffer buf, + int offset, int len); + /** + * Send data over a network using internally set ByteBuffer + */ + public static native int sendbb(long sock, + int offset, int len); + + /** + * 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. + * + */ + public static native int sendv(long sock, byte[][] vec); + + /** + * @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 + */ + public static native int sendto(long sock, long where, int flags, + byte[] buf, int offset, int len); + + /** + * 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. + * + * <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. + * + * <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 recvb(long sock, ByteBuffer buf, + int offset, int nbytes); + /** + * Read data from a network using internally set ByteBuffer + */ + public static native int recvbb(long sock, + int offset, int nbytes); + /** + * 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 + */ + public static native int recvbbt(long sock, + int offset, int nbytes, long timeout); + + /** + * @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 + * @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. + */ + public static native int optSet(long sock, int opt, int on); + + /** + * 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. + */ + public static native int optGet(long sock, int opt) + throws Exception; + + /** + * Setup socket timeout for the specified socket + * @param sock The socket to set up. + * @param t Value for the timeout in microseconds. + * <PRE> + * t > 0 -- read and write calls return APR_TIMEUP if specified time + * elapsess with no data read or written + * t == 0 -- read and write calls never block + * t < 0 -- read and write calls block + * </PRE> + */ + public static native int timeoutSet(long sock, long t); + + /** + * Query socket timeout for the specified socket + * @param sock The socket to query + * @return Socket timeout returned from the query. + */ + 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. + * <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. + */ + public static native long sendfilen(long sock, long file, long offset, + long len, int flags); + + /** + * Create a child pool from associated socket pool. + * @param thesocket The socket to use + */ + public static native long pool(long thesocket) + throws Exception; + + /** + * Private method for geting the socket struct members + * @param socket The soocket 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 stucture 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. + * @param thesocket 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. + * @param thesocket The socket to use + * @param buf The ByteBuffer + */ + public static native void setrbb(long sock, ByteBuffer buf); +}
Added: tomcat/sandbox/tomcat-lite/coyote-apr/org/apache/tomcat/jni/Status.java URL: http://svn.apache.org/viewvc/tomcat/sandbox/tomcat-lite/coyote-apr/org/apache/tomcat/jni/Status.java?rev=640860&view=auto ============================================================================== --- tomcat/sandbox/tomcat-lite/coyote-apr/org/apache/tomcat/jni/Status.java (added) +++ tomcat/sandbox/tomcat-lite/coyote-apr/org/apache/tomcat/jni/Status.java Tue Mar 25 08:26:26 2008 @@ -0,0 +1,265 @@ +/* + * 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; + +/** Status + * + * @author Mladen Turk + * @version $Revision: 467222 $, $Date: 2006-10-23 20:17:11 -0700 (Mon, 23 Oct 2006) $ + */ + +public class Status { + + /** + * APR_OS_START_ERROR is where the APR specific error values start. + */ + public static final int APR_OS_START_ERROR = 20000; + /** + * APR_OS_ERRSPACE_SIZE is the maximum number of errors you can fit + * into one of the error/status ranges below -- except for + * APR_OS_START_USERERR, which see. + */ + public static final int APR_OS_ERRSPACE_SIZE = 50000; + /** + * APR_OS_START_STATUS is where the APR specific status codes start. + */ + public static final int APR_OS_START_STATUS = (APR_OS_START_ERROR + APR_OS_ERRSPACE_SIZE); + + /** + * APR_OS_START_USERERR are reserved for applications that use APR that + * layer their own error codes along with APR's. Note that the + * error immediately following this one is set ten times farther + * away than usual, so that users of apr have a lot of room in + * which to declare custom error codes. + */ + public static final int APR_OS_START_USERERR = (APR_OS_START_STATUS + APR_OS_ERRSPACE_SIZE); + /** + * APR_OS_START_USEERR is obsolete, defined for compatibility only. + * Use APR_OS_START_USERERR instead. + */ + public static final int APR_OS_START_USEERR = APR_OS_START_USERERR; + /** + * APR_OS_START_CANONERR is where APR versions of errno values are defined + * on systems which don't have the corresponding errno. + */ + public static final int APR_OS_START_CANONERR = (APR_OS_START_USERERR + (APR_OS_ERRSPACE_SIZE * 10)); + + /** + * APR_OS_START_EAIERR folds EAI_ error codes from getaddrinfo() into + * apr_status_t values. + */ + public static final int APR_OS_START_EAIERR = (APR_OS_START_CANONERR + APR_OS_ERRSPACE_SIZE); + /** + * APR_OS_START_SYSERR folds platform-specific system error values into + * apr_status_t values. + */ + public static final int APR_OS_START_SYSERR = (APR_OS_START_EAIERR + APR_OS_ERRSPACE_SIZE); + + /** no error. */ + public static final int APR_SUCCESS = 0; + + /** + * APR Error Values + * <PRE> + * <b>APR ERROR VALUES</b> + * APR_ENOSTAT APR was unable to perform a stat on the file + * APR_ENOPOOL APR was not provided a pool with which to allocate memory + * APR_EBADDATE APR was given an invalid date + * APR_EINVALSOCK APR was given an invalid socket + * APR_ENOPROC APR was not given a process structure + * APR_ENOTIME APR was not given a time structure + * APR_ENODIR APR was not given a directory structure + * APR_ENOLOCK APR was not given a lock structure + * APR_ENOPOLL APR was not given a poll structure + * APR_ENOSOCKET APR was not given a socket + * APR_ENOTHREAD APR was not given a thread structure + * APR_ENOTHDKEY APR was not given a thread key structure + * APR_ENOSHMAVAIL There is no more shared memory available + * APR_EDSOOPEN APR was unable to open the dso object. For more + * information call apr_dso_error(). + * APR_EGENERAL General failure (specific information not available) + * APR_EBADIP The specified IP address is invalid + * APR_EBADMASK The specified netmask is invalid + * APR_ESYMNOTFOUND Could not find the requested symbol + * </PRE> + * + */ + public static final int APR_ENOSTAT = (APR_OS_START_ERROR + 1); + public static final int APR_ENOPOOL = (APR_OS_START_ERROR + 2); + public static final int APR_EBADDATE = (APR_OS_START_ERROR + 4); + public static final int APR_EINVALSOCK = (APR_OS_START_ERROR + 5); + public static final int APR_ENOPROC = (APR_OS_START_ERROR + 6); + public static final int APR_ENOTIME = (APR_OS_START_ERROR + 7); + public static final int APR_ENODIR = (APR_OS_START_ERROR + 8); + public static final int APR_ENOLOCK = (APR_OS_START_ERROR + 9); + public static final int APR_ENOPOLL = (APR_OS_START_ERROR + 10); + public static final int APR_ENOSOCKET = (APR_OS_START_ERROR + 11); + public static final int APR_ENOTHREAD = (APR_OS_START_ERROR + 12); + public static final int APR_ENOTHDKEY = (APR_OS_START_ERROR + 13); + public static final int APR_EGENERAL = (APR_OS_START_ERROR + 14); + public static final int APR_ENOSHMAVAIL = (APR_OS_START_ERROR + 15); + public static final int APR_EBADIP = (APR_OS_START_ERROR + 16); + public static final int APR_EBADMASK = (APR_OS_START_ERROR + 17); + public static final int APR_EDSOOPEN = (APR_OS_START_ERROR + 19); + public static final int APR_EABSOLUTE = (APR_OS_START_ERROR + 20); + public static final int APR_ERELATIVE = (APR_OS_START_ERROR + 21); + public static final int APR_EINCOMPLETE = (APR_OS_START_ERROR + 22); + public static final int APR_EABOVEROOT = (APR_OS_START_ERROR + 23); + public static final int APR_EBADPATH = (APR_OS_START_ERROR + 24); + public static final int APR_EPATHWILD = (APR_OS_START_ERROR + 25); + public static final int APR_ESYMNOTFOUND = (APR_OS_START_ERROR + 26); + public static final int APR_EPROC_UNKNOWN = (APR_OS_START_ERROR + 27); + public static final int APR_ENOTENOUGHENTROPY = (APR_OS_START_ERROR + 28); + + /** APR Status Values + * <PRE> + * <b>APR STATUS VALUES</b> + * APR_INCHILD Program is currently executing in the child + * APR_INPARENT Program is currently executing in the parent + * APR_DETACH The thread is detached + * APR_NOTDETACH The thread is not detached + * APR_CHILD_DONE The child has finished executing + * APR_CHILD_NOTDONE The child has not finished executing + * APR_TIMEUP The operation did not finish before the timeout + * APR_INCOMPLETE The operation was incomplete although some processing + * was performed and the results are partially valid + * APR_BADCH Getopt found an option not in the option string + * APR_BADARG Getopt found an option that is missing an argument + * and an argument was specified in the option string + * APR_EOF APR has encountered the end of the file + * APR_NOTFOUND APR was unable to find the socket in the poll structure + * APR_ANONYMOUS APR is using anonymous shared memory + * APR_FILEBASED APR is using a file name as the key to the shared memory + * APR_KEYBASED APR is using a shared key as the key to the shared memory + * APR_EINIT Ininitalizer value. If no option has been found, but + * the status variable requires a value, this should be used + * APR_ENOTIMPL The APR function has not been implemented on this + * platform, either because nobody has gotten to it yet, + * or the function is impossible on this platform. + * APR_EMISMATCH Two passwords do not match. + * APR_EBUSY The given lock was busy. + * </PRE> + * + */ + public static final int APR_INCHILD = (APR_OS_START_STATUS + 1); + public static final int APR_INPARENT = (APR_OS_START_STATUS + 2); + public static final int APR_DETACH = (APR_OS_START_STATUS + 3); + public static final int APR_NOTDETACH = (APR_OS_START_STATUS + 4); + public static final int APR_CHILD_DONE = (APR_OS_START_STATUS + 5); + public static final int APR_CHILD_NOTDONE = (APR_OS_START_STATUS + 6); + public static final int APR_TIMEUP = (APR_OS_START_STATUS + 7); + public static final int APR_INCOMPLETE = (APR_OS_START_STATUS + 8); + public static final int APR_BADCH = (APR_OS_START_STATUS + 12); + public static final int APR_BADARG = (APR_OS_START_STATUS + 13); + public static final int APR_EOF = (APR_OS_START_STATUS + 14); + public static final int APR_NOTFOUND = (APR_OS_START_STATUS + 15); + public static final int APR_ANONYMOUS = (APR_OS_START_STATUS + 19); + public static final int APR_FILEBASED = (APR_OS_START_STATUS + 20); + public static final int APR_KEYBASED = (APR_OS_START_STATUS + 21); + public static final int APR_EINIT = (APR_OS_START_STATUS + 22); + public static final int APR_ENOTIMPL = (APR_OS_START_STATUS + 23); + public static final int APR_EMISMATCH = (APR_OS_START_STATUS + 24); + public static final int APR_EBUSY = (APR_OS_START_STATUS + 25); + + public static final int TIMEUP = (APR_OS_START_USERERR + 1); + public static final int EAGAIN = (APR_OS_START_USERERR + 2); + public static final int EINTR = (APR_OS_START_USERERR + 3); + public static final int EINPROGRESS = (APR_OS_START_USERERR + 4); + public static final int ETIMEDOUT = (APR_OS_START_USERERR + 5); + + private static native boolean is(int err, int idx); + /** + * APR_STATUS_IS Status Value Tests + * <br /><b>Warning :</b> For any particular error condition, more than one of these tests + * may match. This is because platform-specific error codes may not + * always match the semantics of the POSIX codes these tests (and the + * corresponding APR error codes) are named after. A notable example + * are the APR_STATUS_IS_ENOENT and APR_STATUS_IS_ENOTDIR tests on + * Win32 platforms. The programmer should always be aware of this and + * adjust the order of the tests accordingly. + * + */ + public static final boolean APR_STATUS_IS_ENOSTAT(int s) { return is(s, 1); } + public static final boolean APR_STATUS_IS_ENOPOOL(int s) { return is(s, 2); } + /* empty slot: +3 */ + public static final boolean APR_STATUS_IS_EBADDATE(int s) { return is(s, 4); } + public static final boolean APR_STATUS_IS_EINVALSOCK(int s) { return is(s, 5); } + public static final boolean APR_STATUS_IS_ENOPROC(int s) { return is(s, 6); } + public static final boolean APR_STATUS_IS_ENOTIME(int s) { return is(s, 7); } + public static final boolean APR_STATUS_IS_ENODIR(int s) { return is(s, 8); } + public static final boolean APR_STATUS_IS_ENOLOCK(int s) { return is(s, 9); } + public static final boolean APR_STATUS_IS_ENOPOLL(int s) { return is(s, 10); } + public static final boolean APR_STATUS_IS_ENOSOCKET(int s) { return is(s, 11); } + public static final boolean APR_STATUS_IS_ENOTHREAD(int s) { return is(s, 12); } + public static final boolean APR_STATUS_IS_ENOTHDKEY(int s) { return is(s, 13); } + public static final boolean APR_STATUS_IS_EGENERAL(int s) { return is(s, 14); } + public static final boolean APR_STATUS_IS_ENOSHMAVAIL(int s){ return is(s, 15); } + public static final boolean APR_STATUS_IS_EBADIP(int s) { return is(s, 16); } + public static final boolean APR_STATUS_IS_EBADMASK(int s) { return is(s, 17); } + /* empty slot: +18 */ + public static final boolean APR_STATUS_IS_EDSOPEN(int s) { return is(s, 19); } + public static final boolean APR_STATUS_IS_EABSOLUTE(int s) { return is(s, 20); } + public static final boolean APR_STATUS_IS_ERELATIVE(int s) { return is(s, 21); } + public static final boolean APR_STATUS_IS_EINCOMPLETE(int s){ return is(s, 22); } + public static final boolean APR_STATUS_IS_EABOVEROOT(int s) { return is(s, 23); } + public static final boolean APR_STATUS_IS_EBADPATH(int s) { return is(s, 24); } + public static final boolean APR_STATUS_IS_EPATHWILD(int s) { return is(s, 25); } + public static final boolean APR_STATUS_IS_ESYMNOTFOUND(int s) { return is(s, 26); } + public static final boolean APR_STATUS_IS_EPROC_UNKNOWN(int s) { return is(s, 27); } + public static final boolean APR_STATUS_IS_ENOTENOUGHENTROPY(int s) { return is(s, 28); } + + /* + * APR_Error + */ + public static final boolean APR_STATUS_IS_INCHILD(int s) { return is(s, 51); } + public static final boolean APR_STATUS_IS_INPARENT(int s) { return is(s, 52); } + public static final boolean APR_STATUS_IS_DETACH(int s) { return is(s, 53); } + public static final boolean APR_STATUS_IS_NOTDETACH(int s) { return is(s, 54); } + public static final boolean APR_STATUS_IS_CHILD_DONE(int s) { return is(s, 55); } + public static final boolean APR_STATUS_IS_CHILD_NOTDONE(int s) { return is(s, 56); } + public static final boolean APR_STATUS_IS_TIMEUP(int s) { return is(s, 57); } + public static final boolean APR_STATUS_IS_INCOMPLETE(int s) { return is(s, 58); } + /* empty slot: +9 */ + /* empty slot: +10 */ + /* empty slot: +11 */ + public static final boolean APR_STATUS_IS_BADCH(int s) { return is(s, 62); } + public static final boolean APR_STATUS_IS_BADARG(int s) { return is(s, 63); } + public static final boolean APR_STATUS_IS_EOF(int s) { return is(s, 64); } + public static final boolean APR_STATUS_IS_NOTFOUND(int s) { return is(s, 65); } + /* empty slot: +16 */ + /* empty slot: +17 */ + /* empty slot: +18 */ + public static final boolean APR_STATUS_IS_ANONYMOUS(int s) { return is(s, 69); } + public static final boolean APR_STATUS_IS_FILEBASED(int s) { return is(s, 70); } + public static final boolean APR_STATUS_IS_KEYBASED(int s) { return is(s, 71); } + public static final boolean APR_STATUS_IS_EINIT(int s) { return is(s, 72); } + public static final boolean APR_STATUS_IS_ENOTIMPL(int s) { return is(s, 73); } + public static final boolean APR_STATUS_IS_EMISMATCH(int s) { return is(s, 74); } + public static final boolean APR_STATUS_IS_EBUSY(int s) { return is(s, 75); } + + /* Socket errors */ + public static final boolean APR_STATUS_IS_EAGAIN(int s) { return is(s, 90); } + public static final boolean APR_STATUS_IS_ETIMEDOUT(int s) { return is(s, 91); } + public static final boolean APR_STATUS_IS_ECONNABORTED(int s) { return is(s, 92); } + public static final boolean APR_STATUS_IS_ECONNRESET(int s) { return is(s, 93); } + public static final boolean APR_STATUS_IS_EINPROGRESS(int s) { return is(s, 94); } + public static final boolean APR_STATUS_IS_EINTR(int s) { return is(s, 95); } + public static final boolean APR_STATUS_IS_ENOTSOCK(int s) { return is(s, 96); } + public static final boolean APR_STATUS_IS_EINVAL(int s) { return is(s, 97); } + +} Added: tomcat/sandbox/tomcat-lite/coyote-apr/org/apache/tomcat/jni/Stdlib.java URL: http://svn.apache.org/viewvc/tomcat/sandbox/tomcat-lite/coyote-apr/org/apache/tomcat/jni/Stdlib.java?rev=640860&view=auto ============================================================================== --- tomcat/sandbox/tomcat-lite/coyote-apr/org/apache/tomcat/jni/Stdlib.java (added) +++ tomcat/sandbox/tomcat-lite/coyote-apr/org/apache/tomcat/jni/Stdlib.java Tue Mar 25 08:26:26 2008 @@ -0,0 +1,90 @@ +/* + * 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; + +/** Stdlib + * + * @author Mladen Turk + * @version $Revision: 467222 $, $Date: 2006-10-23 20:17:11 -0700 (Mon, 23 Oct 2006) $ + */ + +public class Stdlib { + + /** + * Read from plain memory + * @param dst Destination byte array + * @param src Source memory address + * @param sz Number of bytes to copy. + */ + public static native boolean memread(byte [] dst, long src, int sz); + + /** + * Write to plain memory + * @param dst Destination memory address + * @param src Source byte array + * @param sz Number of bytes to copy. + */ + public static native boolean memwrite(long dst, byte [] src, int sz); + + /** + * Sets buffers to a specified character + * @param dst Destination memory address + * @param c Character to set. + * @param sz Number of characters. + */ + public static native boolean memset(long dst, int c, int sz); + + /** + * Allocates memory blocks. + * @param sz Bytes to allocate. + */ + public static native long malloc(int sz); + + /** + * Reallocate memory blocks. + * @param mem Pointer to previously allocated memory block. + * @param sz New size in bytes. + */ + public static native long realloc(long mem, int sz); + + /** + * Allocates an array in memory with elements initialized to 0. + * @param num Number of elements. + * @param sz Length in bytes of each element. + */ + public static native long calloc(long num, int sz); + + /** + * Deallocates or frees a memory block. + * @param mem Previously allocated memory block to be freed. + */ + public static native void free(long mem); + + /** + * Get current process pid. + * @return current pid or < 1 in case of error. + */ + public static native int getpid(); + + /** + * Get current process parent pid. + * @return parent pid or < 1 in case of error. + */ + public static native int getppid(); + +} Added: tomcat/sandbox/tomcat-lite/coyote-apr/org/apache/tomcat/jni/Thread.java URL: http://svn.apache.org/viewvc/tomcat/sandbox/tomcat-lite/coyote-apr/org/apache/tomcat/jni/Thread.java?rev=640860&view=auto ============================================================================== --- tomcat/sandbox/tomcat-lite/coyote-apr/org/apache/tomcat/jni/Thread.java (added) +++ tomcat/sandbox/tomcat-lite/coyote-apr/org/apache/tomcat/jni/Thread.java Tue Mar 25 08:26:26 2008 @@ -0,0 +1,33 @@ +/* + * 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; + +/** Thread + * + * @author Mladen Turk + * @version $Revision: 467206 $, $Date: 2006-10-23 19:45:46 -0700 (Mon, 23 Oct 2006) $ + */ + +public class Thread { + + /** + * Get the current thread ID handle. + */ + public static native long current(); + +} Added: tomcat/sandbox/tomcat-lite/coyote-apr/org/apache/tomcat/jni/Time.java URL: http://svn.apache.org/viewvc/tomcat/sandbox/tomcat-lite/coyote-apr/org/apache/tomcat/jni/Time.java?rev=640860&view=auto ============================================================================== --- tomcat/sandbox/tomcat-lite/coyote-apr/org/apache/tomcat/jni/Time.java (added) +++ tomcat/sandbox/tomcat-lite/coyote-apr/org/apache/tomcat/jni/Time.java Tue Mar 25 08:26:26 2008 @@ -0,0 +1,74 @@ +/* + * 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; + +/** Time + * + * @author Mladen Turk + * @version $Revision: 467222 $, $Date: 2006-10-23 20:17:11 -0700 (Mon, 23 Oct 2006) $ + */ + +public class Time { + + /** number of microseconds per second */ + public static final long APR_USEC_PER_SEC = 1000000L; + /** number of miliseconds per microsecond */ + public static final long APR_MSEC_PER_USEC = 1000L; + + /** @return apr_time_t as a second */ + public static long sec(long t) + { + return t / APR_USEC_PER_SEC; + } + + /** @return apr_time_t as a msec */ + public static long msec(long t) + { + return t / APR_MSEC_PER_USEC; + } + + /** + * number of microseconds since 00:00:00 january 1, 1970 UTC + * @return the current time + */ + public static native long now(); + + /** + * Formats dates in the RFC822 + * format in an efficient manner. + * @param t the time to convert + */ + public static native String rfc822(long t); + + /** + * Formats dates in the ctime() format + * in an efficient manner. + * Unlike ANSI/ISO C ctime(), apr_ctime() does not include + * a \n at the end of the string. + * @param t the time to convert + */ + public static native String ctime(long t); + + /** + * Sleep for the specified number of micro-seconds. + * <br /><b>Warning :</b> May sleep for longer than the specified time. + * @param t desired amount of time to sleep. + */ + public static native void sleep(long t); + +} Added: tomcat/sandbox/tomcat-lite/coyote-apr/org/apache/tomcat/jni/User.java URL: http://svn.apache.org/viewvc/tomcat/sandbox/tomcat-lite/coyote-apr/org/apache/tomcat/jni/User.java?rev=640860&view=auto ============================================================================== --- tomcat/sandbox/tomcat-lite/coyote-apr/org/apache/tomcat/jni/User.java (added) +++ tomcat/sandbox/tomcat-lite/coyote-apr/org/apache/tomcat/jni/User.java Tue Mar 25 08:26:26 2008 @@ -0,0 +1,127 @@ +/* + * 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; + +/** User + * + * @author Mladen Turk + * @version $Revision: 467222 $, $Date: 2006-10-23 20:17:11 -0700 (Mon, 23 Oct 2006) $ + */ + +public class User { + + /** + * Get the userid (and groupid) of the calling process + * This function is available only if APR_HAS_USER is defined. + * @param p The pool from which to allocate working space + * @return Returns the user id + */ + public static native long uidCurrent(long p) + throws Error; + + /** + * Get the groupid of the calling process + * This function is available only if APR_HAS_USER is defined. + * @param p The pool from which to allocate working space + * @return Returns the group id + */ + public static native long gidCurrent(long p) + throws Error; + + + /** + * Get the userid for the specified username + * This function is available only if APR_HAS_USER is defined. + * @param username The username to lookup + * @param p The pool from which to allocate working space + * @return Returns the user id + */ + public static native long uid(String username, long p) + throws Error; + + /** + * Get the groupid for the specified username + * This function is available only if APR_HAS_USER is defined. + * @param username The username to lookup + * @param p The pool from which to allocate working space + * @return Returns the user's group id + */ + public static native long usergid(String username, long p) + throws Error; + + /** + * Get the groupid for a specified group name + * This function is available only if APR_HAS_USER is defined. + * @param groupname The group name to look up + * @param p The pool from which to allocate working space + * @return Returns the user's group id + */ + public static native long gid(String groupname, long p) + throws Error; + + /** + * Get the user name for a specified userid + * This function is available only if APR_HAS_USER is defined. + * @param userid The userid + * @param p The pool from which to allocate the string + * @return New string containing user name + */ + public static native String username(long userid, long p) + throws Error; + + /** + * Get the group name for a specified groupid + * This function is available only if APR_HAS_USER is defined. + * @param groupid The groupid + * @param p The pool from which to allocate the string + * @return New string containing group name + */ + public static native String groupname(long groupid, long p) + throws Error; + + /** + * Compare two user identifiers for equality. + * This function is available only if APR_HAS_USER is defined. + * @param left One uid to test + * @param right Another uid to test + * @return APR_SUCCESS if the apr_uid_t strutures identify the same user, + * APR_EMISMATCH if not, APR_BADARG if an apr_uid_t is invalid. + */ + public static native int uidcompare(long left, long right); + + /** + * Compare two group identifiers for equality. + * This function is available only if APR_HAS_USER is defined. + * @param left One gid to test + * @param right Another gid to test + * @return APR_SUCCESS if the apr_gid_t strutures identify the same group, + * APR_EMISMATCH if not, APR_BADARG if an apr_gid_t is invalid. + */ + public static native int gidcompare(long left, long right); + + /** + * Get the home directory for the named user + * This function is available only if APR_HAS_USER is defined. + * @param username The named user + * @param p The pool from which to allocate the string + * @return New string containing directory name + */ + public static native String homepath(String username, long p) + throws Error; + +} --------------------------------------------------------------------- To unsubscribe, e-mail: [EMAIL PROTECTED] For additional commands, e-mail: [EMAIL PROTECTED]
