| OLD | NEW |
|---|
| (Empty) |
| 1 /* | |
| 2 * Licensed to the Apache Software Foundation (ASF) under one or more | |
| 3 * contributor license agreements. See the NOTICE file distributed with | |
| 4 * this work for additional information regarding copyright ownership. | |
| 5 * The ASF licenses this file to You under the Apache License, Version 2.0 | |
| 6 * (the "License"); you may not use this file except in compliance with | |
| 7 * the License. You may obtain a copy of the License at | |
| 8 * | |
| 9 * http://www.apache.org/licenses/LICENSE-2.0 | |
| 10 * | |
| 11 * Unless required by applicable law or agreed to in writing, software | |
| 12 * distributed under the License is distributed on an "AS IS" BASIS, | |
| 13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |
| 14 * See the License for the specific language governing permissions and | |
| 15 * limitations under the License. | |
| 16 */ | |
| 17 | |
| 18 package org.apache.tomcat.jni; | |
| 19 | |
| 20 /* Import needed classes */ | |
| 21 import java.nio.ByteBuffer; | |
| 22 | |
| 23 /** Socket | |
| 24 * | |
| 25 * @author Mladen Turk | |
| 26 */ | |
| 27 public class Socket { | |
| 28 | |
| 29 /* Standard socket defines */ | |
| 30 public static final int SOCK_STREAM = 0; | |
| 31 public static final int SOCK_DGRAM = 1; | |
| 32 /* | |
| 33 * apr_sockopt Socket option definitions | |
| 34 */ | |
| 35 public static final int APR_SO_LINGER = 1; /** Linger */ | |
| 36 public static final int APR_SO_KEEPALIVE = 2; /** Keepalive */ | |
| 37 public static final int APR_SO_DEBUG = 4; /** Debug */ | |
| 38 public static final int APR_SO_NONBLOCK = 8; /** Non-blocking IO */ | |
| 39 public static final int APR_SO_REUSEADDR = 16; /** Reuse addresses */ | |
| 40 public static final int APR_SO_SNDBUF = 64; /** Send buffer */ | |
| 41 public static final int APR_SO_RCVBUF = 128; /** Receive buffer */ | |
| 42 public static final int APR_SO_DISCONNECTED = 256; /** Disconnected */ | |
| 43 /** For SCTP sockets, this is mapped to STCP_NODELAY internally. */ | |
| 44 public static final int APR_TCP_NODELAY = 512; | |
| 45 public static final int APR_TCP_NOPUSH = 1024; /** No push */ | |
| 46 /** This flag is ONLY set internally when we set APR_TCP_NOPUSH with | |
| 47 * APR_TCP_NODELAY set to tell us that APR_TCP_NODELAY should be turned on | |
| 48 * again when NOPUSH is turned off | |
| 49 */ | |
| 50 public static final int APR_RESET_NODELAY = 2048; | |
| 51 /** Set on non-blocking sockets (timeout != 0) on which the | |
| 52 * previous read() did not fill a buffer completely. the next | |
| 53 * apr_socket_recv() will first call select()/poll() rather than | |
| 54 * going straight into read(). (Can also be set by an application to | |
| 55 * force a select()/poll() call before the next read, in cases where | |
| 56 * the app expects that an immediate read would fail.) | |
| 57 */ | |
| 58 public static final int APR_INCOMPLETE_READ = 4096; | |
| 59 /** like APR_INCOMPLETE_READ, but for write | |
| 60 */ | |
| 61 public static final int APR_INCOMPLETE_WRITE = 8192; | |
| 62 /** Don't accept IPv4 connections on an IPv6 listening socket. | |
| 63 */ | |
| 64 public static final int APR_IPV6_V6ONLY = 16384; | |
| 65 /** Delay accepting of new connections until data is available. | |
| 66 */ | |
| 67 public static final int APR_TCP_DEFER_ACCEPT = 32768; | |
| 68 | |
| 69 /** Define what type of socket shutdown should occur. | |
| 70 * apr_shutdown_how_e enum | |
| 71 */ | |
| 72 public static final int APR_SHUTDOWN_READ = 0; /** no longer allow read
request */ | |
| 73 public static final int APR_SHUTDOWN_WRITE = 1; /** no longer allow writ
e requests */ | |
| 74 public static final int APR_SHUTDOWN_READWRITE = 2; /** no longer allow read
or write requests */ | |
| 75 | |
| 76 public static final int APR_IPV4_ADDR_OK = 0x01; | |
| 77 public static final int APR_IPV6_ADDR_OK = 0x02; | |
| 78 | |
| 79 /* TODO: Missing: | |
| 80 * APR_INET | |
| 81 * APR_UNSPEC | |
| 82 * APR_INET6 | |
| 83 */ | |
| 84 public static final int APR_UNSPEC = 0; | |
| 85 public static final int APR_INET = 1; | |
| 86 public static final int APR_INET6 = 2; | |
| 87 | |
| 88 public static final int APR_PROTO_TCP = 6; /** TCP */ | |
| 89 public static final int APR_PROTO_UDP = 17; /** UDP */ | |
| 90 public static final int APR_PROTO_SCTP = 132; /** SCTP */ | |
| 91 | |
| 92 /** | |
| 93 * Enum to tell us if we're interested in remote or local socket | |
| 94 * apr_interface_e | |
| 95 */ | |
| 96 public static final int APR_LOCAL = 0; | |
| 97 public static final int APR_REMOTE = 1; | |
| 98 | |
| 99 /* Socket.get types */ | |
| 100 public static final int SOCKET_GET_POOL = 0; | |
| 101 public static final int SOCKET_GET_IMPL = 1; | |
| 102 public static final int SOCKET_GET_APRS = 2; | |
| 103 public static final int SOCKET_GET_TYPE = 3; | |
| 104 | |
| 105 /** | |
| 106 * Create a socket. | |
| 107 * @param family The address family of the socket (e.g., APR_INET). | |
| 108 * @param type The type of the socket (e.g., SOCK_STREAM). | |
| 109 * @param protocol The protocol of the socket (e.g., APR_PROTO_TCP). | |
| 110 * @param cont The parent pool to use | |
| 111 * @return The new socket that has been set up. | |
| 112 */ | |
| 113 public static native long create(int family, int type, | |
| 114 int protocol, long cont) | |
| 115 throws Exception; | |
| 116 | |
| 117 | |
| 118 /** | |
| 119 * Shutdown either reading, writing, or both sides of a socket. | |
| 120 * <br> | |
| 121 * This does not actually close the socket descriptor, it just | |
| 122 * controls which calls are still valid on the socket. | |
| 123 * @param thesocket The socket to close | |
| 124 * @param how How to shutdown the socket. One of: | |
| 125 * <PRE> | |
| 126 * APR_SHUTDOWN_READ no longer allow read requests | |
| 127 * APR_SHUTDOWN_WRITE no longer allow write requests | |
| 128 * APR_SHUTDOWN_READWRITE no longer allow read or write requests | |
| 129 * </PRE> | |
| 130 */ | |
| 131 public static native int shutdown(long thesocket, int how); | |
| 132 | |
| 133 /** | |
| 134 * Close a socket. | |
| 135 * @param thesocket The socket to close | |
| 136 */ | |
| 137 public static native int close(long thesocket); | |
| 138 | |
| 139 /** | |
| 140 * Destroy a pool associated with socket | |
| 141 * @param thesocket The destroy | |
| 142 */ | |
| 143 public static native void destroy(long thesocket); | |
| 144 | |
| 145 /** | |
| 146 * Bind the socket to its associated port | |
| 147 * @param sock The socket to bind | |
| 148 * @param sa The socket address to bind to | |
| 149 * This may be where we will find out if there is any other process | |
| 150 * using the selected port. | |
| 151 */ | |
| 152 public static native int bind(long sock, long sa); | |
| 153 | |
| 154 /** | |
| 155 * Listen to a bound socket for connections. | |
| 156 * @param sock The socket to listen on | |
| 157 * @param backlog The number of outstanding connections allowed in the socke
ts | |
| 158 * listen queue. If this value is less than zero, the listen | |
| 159 * queue size is set to zero. | |
| 160 */ | |
| 161 public static native int listen(long sock, int backlog); | |
| 162 | |
| 163 /** | |
| 164 * Accept a new connection request | |
| 165 * @param sock The socket we are listening on. | |
| 166 * @param pool The pool for the new socket. | |
| 167 * @return A copy of the socket that is connected to the socket that | |
| 168 * made the connection request. This is the socket which should | |
| 169 * be used for all future communication. | |
| 170 */ | |
| 171 public static native long acceptx(long sock, long pool) | |
| 172 throws Exception; | |
| 173 | |
| 174 /** | |
| 175 * Accept a new connection request | |
| 176 * @param sock The socket we are listening on. | |
| 177 * @return A copy of the socket that is connected to the socket that | |
| 178 * made the connection request. This is the socket which should | |
| 179 * be used for all future communication. | |
| 180 */ | |
| 181 public static native long accept(long sock) | |
| 182 throws Exception; | |
| 183 | |
| 184 /** | |
| 185 * Set an OS level accept filter. | |
| 186 * @param sock The socket to put the accept filter on. | |
| 187 * @param name The accept filter | |
| 188 * @param args Any extra args to the accept filter. Passing NULL here remov
es | |
| 189 * the accept filter. | |
| 190 */ | |
| 191 public static native int acceptfilter(long sock, String name, String args); | |
| 192 | |
| 193 /** | |
| 194 * Query the specified socket if at the OOB/Urgent data mark | |
| 195 * @param sock The socket to query | |
| 196 * @return True if socket is at the OOB/urgent mark, | |
| 197 * otherwise return false. | |
| 198 */ | |
| 199 public static native boolean atmark(long sock); | |
| 200 | |
| 201 /** | |
| 202 * Issue a connection request to a socket either on the same machine | |
| 203 * or a different one. | |
| 204 * @param sock The socket we wish to use for our side of the connection | |
| 205 * @param sa The address of the machine we wish to connect to. | |
| 206 */ | |
| 207 public static native int connect(long sock, long sa); | |
| 208 | |
| 209 /** | |
| 210 * Send data over a network. | |
| 211 * <PRE> | |
| 212 * This functions acts like a blocking write by default. To change | |
| 213 * this behavior, use apr_socket_timeout_set() or the APR_SO_NONBLOCK | |
| 214 * socket option. | |
| 215 * | |
| 216 * It is possible for both bytes to be sent and an error to be returned. | |
| 217 * | |
| 218 * APR_EINTR is never returned. | |
| 219 * </PRE> | |
| 220 * @param sock The socket to send the data over. | |
| 221 * @param buf The buffer which contains the data to be sent. | |
| 222 * @param offset Offset in the byte buffer. | |
| 223 * @param len The number of bytes to write; (-1) for full array. | |
| 224 * @return The number of bytes send. | |
| 225 * | |
| 226 */ | |
| 227 public static native int send(long sock, byte[] buf, int offset, int len); | |
| 228 | |
| 229 /** | |
| 230 * Send data over a network. | |
| 231 * <PRE> | |
| 232 * This functions acts like a blocking write by default. To change | |
| 233 * this behavior, use apr_socket_timeout_set() or the APR_SO_NONBLOCK | |
| 234 * socket option. | |
| 235 * | |
| 236 * It is possible for both bytes to be sent and an error to be returned. | |
| 237 * | |
| 238 * APR_EINTR is never returned. | |
| 239 * </PRE> | |
| 240 * @param sock The socket to send the data over. | |
| 241 * @param buf The Byte buffer which contains the data to be sent. | |
| 242 * @param offset The offset within the buffer array of the first buffer from | |
| 243 * which bytes are to be retrieved; must be non-negative | |
| 244 * and no larger than buf.length | |
| 245 * @param len The maximum number of buffers to be accessed; must be non-nega
tive | |
| 246 * and no larger than buf.length - offset | |
| 247 * @return The number of bytes send. | |
| 248 * | |
| 249 */ | |
| 250 public static native int sendb(long sock, ByteBuffer buf, | |
| 251 int offset, int len); | |
| 252 | |
| 253 /** | |
| 254 * Send data over a network without retry | |
| 255 * <PRE> | |
| 256 * This functions acts like a blocking write by default. To change | |
| 257 * this behavior, use apr_socket_timeout_set() or the APR_SO_NONBLOCK | |
| 258 * socket option. | |
| 259 * | |
| 260 * It is possible for both bytes to be sent and an error to be returned. | |
| 261 * | |
| 262 * </PRE> | |
| 263 * @param sock The socket to send the data over. | |
| 264 * @param buf The Byte buffer which contains the data to be sent. | |
| 265 * @param offset The offset within the buffer array of the first buffer from | |
| 266 * which bytes are to be retrieved; must be non-negative | |
| 267 * and no larger than buf.length | |
| 268 * @param len The maximum number of buffers to be accessed; must be non-nega
tive | |
| 269 * and no larger than buf.length - offset | |
| 270 * @return The number of bytes send. | |
| 271 * | |
| 272 */ | |
| 273 public static native int sendib(long sock, ByteBuffer buf, | |
| 274 int offset, int len); | |
| 275 | |
| 276 /** | |
| 277 * Send data over a network using internally set ByteBuffer | |
| 278 */ | |
| 279 public static native int sendbb(long sock, | |
| 280 int offset, int len); | |
| 281 | |
| 282 /** | |
| 283 * Send data over a network using internally set ByteBuffer | |
| 284 * without internal retry. | |
| 285 */ | |
| 286 public static native int sendibb(long sock, | |
| 287 int offset, int len); | |
| 288 | |
| 289 /** | |
| 290 * Send multiple packets of data over a network. | |
| 291 * <PRE> | |
| 292 * This functions acts like a blocking write by default. To change | |
| 293 * this behavior, use apr_socket_timeout_set() or the APR_SO_NONBLOCK | |
| 294 * socket option. | |
| 295 * The number of bytes actually sent is stored in argument 3. | |
| 296 * | |
| 297 * It is possible for both bytes to be sent and an error to be returned. | |
| 298 * | |
| 299 * APR_EINTR is never returned. | |
| 300 * </PRE> | |
| 301 * @param sock The socket to send the data over. | |
| 302 * @param vec The array from which to get the data to send. | |
| 303 * | |
| 304 */ | |
| 305 public static native int sendv(long sock, byte[][] vec); | |
| 306 | |
| 307 /** | |
| 308 * @param sock The socket to send from | |
| 309 * @param where The apr_sockaddr_t describing where to send the data | |
| 310 * @param flags The flags to use | |
| 311 * @param buf The data to send | |
| 312 * @param offset Offset in the byte buffer. | |
| 313 * @param len The length of the data to send | |
| 314 */ | |
| 315 public static native int sendto(long sock, long where, int flags, | |
| 316 byte[] buf, int offset, int len); | |
| 317 | |
| 318 /** | |
| 319 * Read data from a network. | |
| 320 * | |
| 321 * <PRE> | |
| 322 * This functions acts like a blocking read by default. To change | |
| 323 * this behavior, use apr_socket_timeout_set() or the APR_SO_NONBLOCK | |
| 324 * socket option. | |
| 325 * The number of bytes actually received is stored in argument 3. | |
| 326 * | |
| 327 * It is possible for both bytes to be received and an APR_EOF or | |
| 328 * other error to be returned. | |
| 329 * | |
| 330 * APR_EINTR is never returned. | |
| 331 * </PRE> | |
| 332 * @param sock The socket to read the data from. | |
| 333 * @param buf The buffer to store the data in. | |
| 334 * @param offset Offset in the byte buffer. | |
| 335 * @param nbytes The number of bytes to read (-1) for full array. | |
| 336 * @return the number of bytes received. | |
| 337 */ | |
| 338 public static native int recv(long sock, byte[] buf, int offset, int nbytes)
; | |
| 339 | |
| 340 /** | |
| 341 * Read data from a network with timeout. | |
| 342 * | |
| 343 * <PRE> | |
| 344 * This functions acts like a blocking read by default. To change | |
| 345 * this behavior, use apr_socket_timeout_set() or the APR_SO_NONBLOCK | |
| 346 * socket option. | |
| 347 * The number of bytes actually received is stored in argument 3. | |
| 348 * | |
| 349 * It is possible for both bytes to be received and an APR_EOF or | |
| 350 * other error to be returned. | |
| 351 * | |
| 352 * APR_EINTR is never returned. | |
| 353 * </PRE> | |
| 354 * @param sock The socket to read the data from. | |
| 355 * @param buf The buffer to store the data in. | |
| 356 * @param offset Offset in the byte buffer. | |
| 357 * @param nbytes The number of bytes to read (-1) for full array. | |
| 358 * @param timeout The socket timeout in microseconds. | |
| 359 * @return the number of bytes received. | |
| 360 */ | |
| 361 public static native int recvt(long sock, byte[] buf, int offset, | |
| 362 int nbytes, long timeout); | |
| 363 | |
| 364 /** | |
| 365 * Read data from a network. | |
| 366 * | |
| 367 * <PRE> | |
| 368 * This functions acts like a blocking read by default. To change | |
| 369 * this behavior, use apr_socket_timeout_set() or the APR_SO_NONBLOCK | |
| 370 * socket option. | |
| 371 * The number of bytes actually received is stored in argument 3. | |
| 372 * | |
| 373 * It is possible for both bytes to be received and an APR_EOF or | |
| 374 * other error to be returned. | |
| 375 * | |
| 376 * APR_EINTR is never returned. | |
| 377 * </PRE> | |
| 378 * @param sock The socket to read the data from. | |
| 379 * @param buf The buffer to store the data in. | |
| 380 * @param offset Offset in the byte buffer. | |
| 381 * @param nbytes The number of bytes to read (-1) for full array. | |
| 382 * @return the number of bytes received. | |
| 383 */ | |
| 384 public static native int recvb(long sock, ByteBuffer buf, | |
| 385 int offset, int nbytes); | |
| 386 /** | |
| 387 * Read data from a network using internally set ByteBuffer | |
| 388 */ | |
| 389 public static native int recvbb(long sock, | |
| 390 int offset, int nbytes); | |
| 391 /** | |
| 392 * Read data from a network with timeout. | |
| 393 * | |
| 394 * <PRE> | |
| 395 * This functions acts like a blocking read by default. To change | |
| 396 * this behavior, use apr_socket_timeout_set() or the APR_SO_NONBLOCK | |
| 397 * socket option. | |
| 398 * The number of bytes actually received is stored in argument 3. | |
| 399 * | |
| 400 * It is possible for both bytes to be received and an APR_EOF or | |
| 401 * other error to be returned. | |
| 402 * | |
| 403 * APR_EINTR is never returned. | |
| 404 * </PRE> | |
| 405 * @param sock The socket to read the data from. | |
| 406 * @param buf The buffer to store the data in. | |
| 407 * @param offset Offset in the byte buffer. | |
| 408 * @param nbytes The number of bytes to read (-1) for full array. | |
| 409 * @param timeout The socket timeout in microseconds. | |
| 410 * @return the number of bytes received. | |
| 411 */ | |
| 412 public static native int recvbt(long sock, ByteBuffer buf, | |
| 413 int offset, int nbytes, long timeout); | |
| 414 /** | |
| 415 * Read data from a network with timeout using internally set ByteBuffer | |
| 416 */ | |
| 417 public static native int recvbbt(long sock, | |
| 418 int offset, int nbytes, long timeout); | |
| 419 | |
| 420 /** | |
| 421 * @param from The apr_sockaddr_t to fill in the recipient info | |
| 422 * @param sock The socket to use | |
| 423 * @param flags The flags to use | |
| 424 * @param buf The buffer to use | |
| 425 * @param offset Offset in the byte buffer. | |
| 426 * @param nbytes The number of bytes to read (-1) for full array. | |
| 427 * @return the number of bytes received. | |
| 428 */ | |
| 429 public static native int recvfrom(long from, long sock, int flags, | |
| 430 byte[] buf, int offset, int nbytes); | |
| 431 | |
| 432 /** | |
| 433 * Setup socket options for the specified socket | |
| 434 * @param sock The socket to set up. | |
| 435 * @param opt The option we would like to configure. One of: | |
| 436 * <PRE> | |
| 437 * APR_SO_DEBUG -- turn on debugging information | |
| 438 * APR_SO_KEEPALIVE -- keep connections active | |
| 439 * APR_SO_LINGER -- lingers on close if data is present | |
| 440 * APR_SO_NONBLOCK -- Turns blocking on/off for socket | |
| 441 * When this option is enabled, use | |
| 442 * the APR_STATUS_IS_EAGAIN() macro to | |
| 443 * see if a send or receive function | |
| 444 * could not transfer data without | |
| 445 * blocking. | |
| 446 * APR_SO_REUSEADDR -- The rules used in validating addresses | |
| 447 * supplied to bind should allow reuse | |
| 448 * of local addresses. | |
| 449 * APR_SO_SNDBUF -- Set the SendBufferSize | |
| 450 * APR_SO_RCVBUF -- Set the ReceiveBufferSize | |
| 451 * </PRE> | |
| 452 * @param on Value for the option. | |
| 453 */ | |
| 454 public static native int optSet(long sock, int opt, int on); | |
| 455 | |
| 456 /** | |
| 457 * Query socket options for the specified socket | |
| 458 * @param sock The socket to query | |
| 459 * @param opt The option we would like to query. One of: | |
| 460 * <PRE> | |
| 461 * APR_SO_DEBUG -- turn on debugging information | |
| 462 * APR_SO_KEEPALIVE -- keep connections active | |
| 463 * APR_SO_LINGER -- lingers on close if data is present | |
| 464 * APR_SO_NONBLOCK -- Turns blocking on/off for socket | |
| 465 * APR_SO_REUSEADDR -- The rules used in validating addresses | |
| 466 * supplied to bind should allow reuse | |
| 467 * of local addresses. | |
| 468 * APR_SO_SNDBUF -- Set the SendBufferSize | |
| 469 * APR_SO_RCVBUF -- Set the ReceiveBufferSize | |
| 470 * APR_SO_DISCONNECTED -- Query the disconnected state of the socket. | |
| 471 * (Currently only used on Windows) | |
| 472 * </PRE> | |
| 473 * @return Socket option returned on the call. | |
| 474 */ | |
| 475 public static native int optGet(long sock, int opt) | |
| 476 throws Exception; | |
| 477 | |
| 478 /** | |
| 479 * Setup socket timeout for the specified socket | |
| 480 * @param sock The socket to set up. | |
| 481 * @param t Value for the timeout in microseconds. | |
| 482 * <PRE> | |
| 483 * t > 0 -- read and write calls return APR_TIMEUP if specified time | |
| 484 * elapses with no data read or written | |
| 485 * t == 0 -- read and write calls never block | |
| 486 * t < 0 -- read and write calls block | |
| 487 * </PRE> | |
| 488 */ | |
| 489 public static native int timeoutSet(long sock, long t); | |
| 490 | |
| 491 /** | |
| 492 * Query socket timeout for the specified socket | |
| 493 * @param sock The socket to query | |
| 494 * @return Socket timeout returned from the query. | |
| 495 */ | |
| 496 public static native long timeoutGet(long sock) | |
| 497 throws Exception; | |
| 498 | |
| 499 /** | |
| 500 * Send a file from an open file descriptor to a socket, along with | |
| 501 * optional headers and trailers. | |
| 502 * <br> | |
| 503 * This functions acts like a blocking write by default. To change | |
| 504 * this behavior, use apr_socket_timeout_set() or the | |
| 505 * APR_SO_NONBLOCK socket option. | |
| 506 * The number of bytes actually sent is stored in the len parameter. | |
| 507 * The offset parameter is passed by reference for no reason; its | |
| 508 * value will never be modified by the apr_socket_sendfile() function. | |
| 509 * @param sock The socket to which we're writing | |
| 510 * @param file The open file from which to read | |
| 511 * @param headers Array containing the headers to send | |
| 512 * @param trailers Array containing the trailers to send | |
| 513 * @param offset Offset into the file where we should begin writing | |
| 514 * @param len Number of bytes to send from the file | |
| 515 * @param flags APR flags that are mapped to OS specific flags | |
| 516 * @return Number of bytes actually sent, including headers, | |
| 517 * file, and trailers | |
| 518 * | |
| 519 */ | |
| 520 public static native long sendfile(long sock, long file, byte [][] headers, | |
| 521 byte[][] trailers, long offset, | |
| 522 long len, int flags); | |
| 523 | |
| 524 /** | |
| 525 * Send a file without header and trailer arrays. | |
| 526 */ | |
| 527 public static native long sendfilen(long sock, long file, long offset, | |
| 528 long len, int flags); | |
| 529 | |
| 530 /** | |
| 531 * Create a child pool from associated socket pool. | |
| 532 * @param thesocket The socket to use | |
| 533 */ | |
| 534 public static native long pool(long thesocket) | |
| 535 throws Exception; | |
| 536 | |
| 537 /** | |
| 538 * Private method for getting the socket struct members | |
| 539 * @param socket The socket to use | |
| 540 * @param what Struct member to obtain | |
| 541 * <PRE> | |
| 542 * SOCKET_GET_POOL - The socket pool | |
| 543 * SOCKET_GET_IMPL - The socket implementation object | |
| 544 * SOCKET_GET_APRS - APR socket | |
| 545 * SOCKET_GET_TYPE - Socket type | |
| 546 * </PRE> | |
| 547 * @return The structure member address | |
| 548 */ | |
| 549 private static native long get(long socket, int what); | |
| 550 | |
| 551 /** | |
| 552 * Set internal send ByteBuffer. | |
| 553 * This function will preset internal Java ByteBuffer for | |
| 554 * consecutive sendbb calls. | |
| 555 * @param sock The socket to use | |
| 556 * @param buf The ByteBuffer | |
| 557 */ | |
| 558 public static native void setsbb(long sock, ByteBuffer buf); | |
| 559 | |
| 560 /** | |
| 561 * Set internal receive ByteBuffer. | |
| 562 * This function will preset internal Java ByteBuffer for | |
| 563 * consecutive revcvbb/recvbbt calls. | |
| 564 * @param sock The socket to use | |
| 565 * @param buf The ByteBuffer | |
| 566 */ | |
| 567 public static native void setrbb(long sock, ByteBuffer buf); | |
| 568 | |
| 569 /** | |
| 570 * Set the data associated with the current socket. | |
| 571 * @param sock The currently open socket. | |
| 572 * @param data The user data to associate with the socket. | |
| 573 * @param key The key to associate with the data. | |
| 574 */ | |
| 575 public static native int dataSet(long sock, String key, Object data); | |
| 576 | |
| 577 /** | |
| 578 * Return the data associated with the current socket | |
| 579 * @param key The key to associate with the user data. | |
| 580 * @param sock The currently open socket. | |
| 581 * @return Data or null in case of error. | |
| 582 */ | |
| 583 public static native Object dataGet(long sock, String key); | |
| 584 } | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2842333002:
Updated netty-tcnative to version 2.0.0.Final (Closed)
