|
1 /* |
|
2 * Copyright (C) 2009 The Sipdroid Open Source Project |
|
3 * |
|
4 * This file is part of Sipdroid (http://www.sipdroid.org) |
|
5 * |
|
6 * Sipdroid is free software; you can redistribute it and/or modify |
|
7 * it under the terms of the GNU General Public License as published by |
|
8 * the Free Software Foundation; either version 3 of the License, or |
|
9 * (at your option) any later version. |
|
10 * |
|
11 * This source code is distributed in the hope that it will be useful, |
|
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of |
|
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|
14 * GNU General Public License for more details. |
|
15 * |
|
16 * You should have received a copy of the GNU General Public License |
|
17 * along with this source code; if not, write to the Free Software |
|
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
|
19 */ |
|
20 |
|
21 // BEGIN android-note |
|
22 // address length was changed from long to int for performance reasons. |
|
23 // END android-note |
|
24 |
|
25 package org.sipdroid.net.impl; |
|
26 |
|
27 import java.io.FileDescriptor; |
|
28 import java.io.IOException; |
|
29 import java.net.DatagramPacket; |
|
30 import java.net.InetAddress; |
|
31 import java.net.SocketException; |
|
32 import java.net.SocketImpl; |
|
33 import java.net.UnknownHostException; |
|
34 import java.nio.channels.Channel; |
|
35 // BEGIN android-removed |
|
36 // import java.nio.channels.SelectableChannel; |
|
37 // END android-removed |
|
38 /* |
|
39 * |
|
40 * This Class is used for native code wrap, the implement class of |
|
41 * INetworkSystem. |
|
42 * |
|
43 */ |
|
44 public final class OSNetworkSystem { |
|
45 |
|
46 // ---------------------------------------------------- |
|
47 // Class Variables |
|
48 // ---------------------------------------------------- |
|
49 |
|
50 private static final int ERRORCODE_SOCKET_TIMEOUT = -209; |
|
51 |
|
52 private static OSNetworkSystem ref = new OSNetworkSystem(); |
|
53 |
|
54 private static final int INETADDR_REACHABLE = 0; |
|
55 |
|
56 private static boolean isNetworkInited = false; |
|
57 |
|
58 // ---------------------------------------------------- |
|
59 // Class Constructor |
|
60 // ---------------------------------------------------- |
|
61 |
|
62 // can not be instantiated. |
|
63 private OSNetworkSystem() { |
|
64 super(); |
|
65 } |
|
66 |
|
67 /* |
|
68 * @return a static ref of this class |
|
69 */ |
|
70 public static OSNetworkSystem getOSNetworkSystem() { |
|
71 return ref; |
|
72 } |
|
73 |
|
74 // Useing when cache set/get is OK |
|
75 // public static native void oneTimeInitializationDatagram( |
|
76 // boolean jcl_IPv6_support); |
|
77 // |
|
78 // public static native void oneTimeInitializationSocket( |
|
79 // boolean jcl_IPv6_support); |
|
80 |
|
81 // -------------------------------------------------- |
|
82 // java codes that wrap native codes |
|
83 // -------------------------------------------------- |
|
84 |
|
85 public void createSocket(FileDescriptor fd, boolean preferIPv4Stack) |
|
86 throws IOException { |
|
87 createSocketImpl(fd, preferIPv4Stack); |
|
88 } |
|
89 |
|
90 public void createDatagramSocket(FileDescriptor fd, boolean preferIPv4Stack) |
|
91 throws SocketException { |
|
92 createDatagramSocketImpl(fd, preferIPv4Stack); |
|
93 } |
|
94 |
|
95 public int read(FileDescriptor aFD, byte[] data, int offset, int count, |
|
96 int timeout) throws IOException { |
|
97 return readSocketImpl(aFD, data, offset, count, timeout); |
|
98 } |
|
99 |
|
100 public int readDirect(FileDescriptor aFD, int address, int offset, int count, |
|
101 int timeout) throws IOException { |
|
102 return readSocketDirectImpl(aFD, address, offset, count, timeout); |
|
103 } |
|
104 |
|
105 public int write(FileDescriptor aFD, byte[] data, int offset, int count) |
|
106 throws IOException { |
|
107 return writeSocketImpl(aFD, data, offset, count); |
|
108 } |
|
109 |
|
110 public int writeDirect(FileDescriptor aFD, int address, int offset, |
|
111 int count) throws IOException { |
|
112 return writeSocketDirectImpl(aFD, address, offset, count); |
|
113 } |
|
114 |
|
115 public void setNonBlocking(FileDescriptor aFD, boolean block) |
|
116 throws IOException { |
|
117 setNonBlockingImpl(aFD, block); |
|
118 } |
|
119 |
|
120 public void connectDatagram(FileDescriptor aFD, int port, int trafficClass, |
|
121 InetAddress inetAddress) throws SocketException { |
|
122 connectDatagramImpl2(aFD, port, trafficClass, inetAddress); |
|
123 } |
|
124 |
|
125 public int connect(FileDescriptor aFD, int trafficClass, |
|
126 InetAddress inetAddress, int port) throws IOException{ |
|
127 return connectSocketImpl(aFD, trafficClass, inetAddress, port); |
|
128 } |
|
129 |
|
130 // BEGIN android-changed |
|
131 public int connectWithTimeout(FileDescriptor aFD, int timeout, |
|
132 int trafficClass, InetAddress inetAddress, int port, int step, |
|
133 byte[] context) throws IOException{ |
|
134 return connectWithTimeoutSocketImpl(aFD, timeout, trafficClass, |
|
135 inetAddress, port, step, context); |
|
136 } |
|
137 // END android-changed |
|
138 |
|
139 public void connectStreamWithTimeoutSocket(FileDescriptor aFD, int aport, |
|
140 int timeout, int trafficClass, InetAddress inetAddress) |
|
141 throws IOException { |
|
142 connectStreamWithTimeoutSocketImpl(aFD, aport, timeout, trafficClass, |
|
143 inetAddress); |
|
144 } |
|
145 |
|
146 public void bind(FileDescriptor aFD, int port, InetAddress inetAddress) |
|
147 throws SocketException { |
|
148 socketBindImpl(aFD, port, inetAddress); |
|
149 } |
|
150 |
|
151 public boolean bind2(FileDescriptor aFD, int port, boolean bindToDevice, |
|
152 InetAddress inetAddress) throws SocketException { |
|
153 return socketBindImpl2(aFD, port, bindToDevice, inetAddress); |
|
154 } |
|
155 |
|
156 public void accept(FileDescriptor fdServer, SocketImpl newSocket, |
|
157 FileDescriptor fdnewSocket, int timeout) throws IOException { |
|
158 acceptSocketImpl(fdServer, newSocket, fdnewSocket, timeout); |
|
159 } |
|
160 |
|
161 public int sendDatagram(FileDescriptor fd, byte[] data, int offset, |
|
162 int length, int port, boolean bindToDevice, int trafficClass, |
|
163 InetAddress inetAddress) throws IOException { |
|
164 return sendDatagramImpl(fd, data, offset, length, port, bindToDevice, |
|
165 trafficClass, inetAddress); |
|
166 } |
|
167 |
|
168 public int sendDatagramDirect(FileDescriptor fd, int address, int offset, |
|
169 int length, int port, boolean bindToDevice, int trafficClass, |
|
170 InetAddress inetAddress) throws IOException { |
|
171 return sendDatagramDirectImpl(fd, address, offset, length, port, bindToDevice, |
|
172 trafficClass, inetAddress); |
|
173 } |
|
174 |
|
175 public int sendDatagram2(FileDescriptor fd, byte[] data, int offset, |
|
176 int length, int port, InetAddress inetAddress) throws IOException { |
|
177 return sendDatagramImpl2(fd, data, offset, length, port, inetAddress); |
|
178 } |
|
179 |
|
180 public int receiveDatagram(FileDescriptor aFD, DatagramPacket packet, |
|
181 byte[] data, int offset, int length, int receiveTimeout, |
|
182 boolean peek) throws IOException { |
|
183 return receiveDatagramImpl(aFD, packet, data, offset, length, |
|
184 receiveTimeout, peek); |
|
185 } |
|
186 |
|
187 public int receiveDatagramDirect(FileDescriptor aFD, DatagramPacket packet, |
|
188 int address, int offset, int length, int receiveTimeout, |
|
189 boolean peek) throws IOException { |
|
190 return receiveDatagramDirectImpl(aFD, packet, address, offset, length, |
|
191 receiveTimeout, peek); |
|
192 } |
|
193 |
|
194 public int recvConnectedDatagram(FileDescriptor aFD, DatagramPacket packet, |
|
195 byte[] data, int offset, int length, int receiveTimeout, |
|
196 boolean peek) throws IOException { |
|
197 return recvConnectedDatagramImpl(aFD, packet, data, offset, length, |
|
198 receiveTimeout, peek); |
|
199 } |
|
200 |
|
201 public int recvConnectedDatagramDirect(FileDescriptor aFD, DatagramPacket packet, int address, |
|
202 int offset, int length, int receiveTimeout, boolean peek) |
|
203 throws IOException { |
|
204 return recvConnectedDatagramDirectImpl(aFD, packet, address, offset, length, receiveTimeout, peek); |
|
205 } |
|
206 |
|
207 public int peekDatagram(FileDescriptor aFD, InetAddress sender, |
|
208 int receiveTimeout) throws IOException { |
|
209 return peekDatagramImpl(aFD, sender, receiveTimeout); |
|
210 } |
|
211 |
|
212 public int sendConnectedDatagram(FileDescriptor fd, byte[] data, |
|
213 int offset, int length, boolean bindToDevice) throws IOException { |
|
214 return sendConnectedDatagramImpl(fd, data, offset, length, bindToDevice); |
|
215 } |
|
216 |
|
217 public int sendConnectedDatagramDirect(FileDescriptor fd, int address, |
|
218 int offset, int length, boolean bindToDevice) throws IOException { |
|
219 return sendConnectedDatagramDirectImpl(fd, address, offset, length, bindToDevice); |
|
220 } |
|
221 |
|
222 public void disconnectDatagram(FileDescriptor aFD) throws SocketException { |
|
223 disconnectDatagramImpl(aFD); |
|
224 } |
|
225 |
|
226 public void createMulticastSocket(FileDescriptor aFD, |
|
227 boolean preferIPv4Stack) throws SocketException { |
|
228 createMulticastSocketImpl(aFD, preferIPv4Stack); |
|
229 } |
|
230 |
|
231 public void createServerStreamSocket(FileDescriptor aFD, |
|
232 boolean preferIPv4Stack) throws SocketException { |
|
233 createServerStreamSocketImpl(aFD, preferIPv4Stack); |
|
234 } |
|
235 |
|
236 public int receiveStream(FileDescriptor aFD, byte[] data, int offset, |
|
237 int count, int timeout) throws IOException { |
|
238 return receiveStreamImpl(aFD, data, offset, count, timeout); |
|
239 } |
|
240 |
|
241 public int sendStream(FileDescriptor fd, byte[] data, int offset, int count) |
|
242 throws IOException { |
|
243 return sendStreamImpl(fd, data, offset, count); |
|
244 } |
|
245 |
|
246 public void shutdownInput(FileDescriptor descriptor) throws IOException { |
|
247 shutdownInputImpl(descriptor); |
|
248 } |
|
249 |
|
250 public void shutdownOutput(FileDescriptor descriptor) throws IOException { |
|
251 shutdownOutputImpl(descriptor); |
|
252 } |
|
253 |
|
254 public boolean supportsUrgentData(FileDescriptor fd) { |
|
255 return supportsUrgentDataImpl(fd); |
|
256 } |
|
257 |
|
258 public void sendUrgentData(FileDescriptor fd, byte value) { |
|
259 sendUrgentDataImpl(fd, value); |
|
260 } |
|
261 |
|
262 public int availableStream(FileDescriptor aFD) throws SocketException { |
|
263 return availableStreamImpl(aFD); |
|
264 } |
|
265 |
|
266 // BEGIN android-removed |
|
267 // public void acceptStreamSocket(FileDescriptor fdServer, |
|
268 // SocketImpl newSocket, FileDescriptor fdnewSocket, int timeout) |
|
269 // throws IOException { |
|
270 // acceptStreamSocketImpl(fdServer, newSocket, fdnewSocket, timeout); |
|
271 // } |
|
272 // |
|
273 // public void createStreamSocket(FileDescriptor aFD, boolean preferIPv4Stack) |
|
274 // throws SocketException { |
|
275 // createStreamSocketImpl(aFD, preferIPv4Stack); |
|
276 // } |
|
277 // END android-removed |
|
278 |
|
279 public void listenStreamSocket(FileDescriptor aFD, int backlog) |
|
280 throws SocketException { |
|
281 listenStreamSocketImpl(aFD, backlog); |
|
282 } |
|
283 |
|
284 // BEGIN android-removed |
|
285 // public boolean isReachableByICMP(final InetAddress dest, |
|
286 // InetAddress source, final int ttl, final int timeout) { |
|
287 // return INETADDR_REACHABLE == isReachableByICMPImpl(dest, source, ttl, |
|
288 // timeout); |
|
289 // } |
|
290 // END android-removed |
|
291 |
|
292 /* |
|
293 * |
|
294 * @param |
|
295 * readChannels all channels interested in read and accept |
|
296 * @param |
|
297 * writeChannels all channels interested in write and connect |
|
298 * @param timeout |
|
299 * timeout in millis @return a set of channels that are ready for operation |
|
300 * @throws |
|
301 * SocketException @return int array, each int approve one of the * channel if OK |
|
302 */ |
|
303 |
|
304 public int[] select(FileDescriptor[] readFDs, |
|
305 FileDescriptor[] writeFDs, long timeout) |
|
306 throws SocketException { |
|
307 int countRead = readFDs.length; |
|
308 int countWrite = writeFDs.length; |
|
309 int result = 0; |
|
310 if (0 == countRead + countWrite) { |
|
311 return (new int[0]); |
|
312 } |
|
313 int[] flags = new int[countRead + countWrite]; |
|
314 |
|
315 // handle timeout in native |
|
316 result = selectImpl(readFDs, writeFDs, countRead, countWrite, flags, |
|
317 timeout); |
|
318 |
|
319 if (0 <= result) { |
|
320 return flags; |
|
321 } |
|
322 if (ERRORCODE_SOCKET_TIMEOUT == result) { |
|
323 return new int[0]; |
|
324 } |
|
325 throw new SocketException(); |
|
326 |
|
327 } |
|
328 |
|
329 public InetAddress getSocketLocalAddress(FileDescriptor aFD, |
|
330 boolean preferIPv6Addresses) { |
|
331 return getSocketLocalAddressImpl(aFD, preferIPv6Addresses); |
|
332 } |
|
333 |
|
334 /* |
|
335 * Query the IP stack for the local port to which this socket is bound. |
|
336 * |
|
337 * @param aFD the socket descriptor @param preferIPv6Addresses address |
|
338 * preference for nodes that support both IPv4 and IPv6 @return int the |
|
339 * local port to which the socket is bound |
|
340 */ |
|
341 public int getSocketLocalPort(FileDescriptor aFD, |
|
342 boolean preferIPv6Addresses) { |
|
343 return getSocketLocalPortImpl(aFD, preferIPv6Addresses); |
|
344 } |
|
345 |
|
346 /* |
|
347 * Query the IP stack for the nominated socket option. |
|
348 * |
|
349 * @param aFD the socket descriptor @param opt the socket option type |
|
350 * @return the nominated socket option value |
|
351 * |
|
352 * @throws SocketException if the option is invalid |
|
353 */ |
|
354 public Object getSocketOption(FileDescriptor aFD, int opt) |
|
355 throws SocketException { |
|
356 return getSocketOptionImpl(aFD, opt); |
|
357 } |
|
358 |
|
359 /* |
|
360 * Set the nominated socket option in the IP stack. |
|
361 * |
|
362 * @param aFD the socket descriptor @param opt the option selector @param |
|
363 * optVal the nominated option value |
|
364 * |
|
365 * @throws SocketException if the option is invalid or cannot be set |
|
366 */ |
|
367 public void setSocketOption(FileDescriptor aFD, int opt, Object optVal) |
|
368 throws SocketException { |
|
369 setSocketOptionImpl(aFD, opt, optVal); |
|
370 } |
|
371 |
|
372 public int getSocketFlags() { |
|
373 return getSocketFlagsImpl(); |
|
374 } |
|
375 |
|
376 /* |
|
377 * Close the socket in the IP stack. |
|
378 * |
|
379 * @param aFD the socket descriptor |
|
380 */ |
|
381 public void socketClose(FileDescriptor aFD) throws IOException { |
|
382 socketCloseImpl(aFD); |
|
383 } |
|
384 |
|
385 public InetAddress getHostByAddr(byte[] addr) throws UnknownHostException { |
|
386 return getHostByAddrImpl(addr); |
|
387 } |
|
388 |
|
389 public InetAddress getHostByName(String addr, boolean preferIPv6Addresses) |
|
390 throws UnknownHostException { |
|
391 return getHostByNameImpl(addr, preferIPv6Addresses); |
|
392 } |
|
393 |
|
394 public void setInetAddress(InetAddress sender, byte[] address) { |
|
395 setInetAddressImpl(sender, address); |
|
396 } |
|
397 |
|
398 // --------------------------------------------------- |
|
399 // Native Codes |
|
400 // --------------------------------------------------- |
|
401 |
|
402 static native void createSocketImpl(FileDescriptor fd, |
|
403 boolean preferIPv4Stack); |
|
404 |
|
405 /* |
|
406 * Allocate a datagram socket in the IP stack. The socket is associated with |
|
407 * the <code>aFD</code>. |
|
408 * |
|
409 * @param aFD the FileDescriptor to associate with the socket @param |
|
410 * preferIPv4Stack IP stack preference if underlying platform is V4/V6 |
|
411 * @exception SocketException upon an allocation error |
|
412 */ |
|
413 static native void createDatagramSocketImpl(FileDescriptor aFD, |
|
414 boolean preferIPv4Stack) throws SocketException; |
|
415 |
|
416 static native int readSocketImpl(FileDescriptor aFD, byte[] data, |
|
417 int offset, int count, int timeout) throws IOException; |
|
418 |
|
419 static native int readSocketDirectImpl(FileDescriptor aFD, int address, |
|
420 int offset, int count, int timeout) throws IOException; |
|
421 |
|
422 static native int writeSocketImpl(FileDescriptor fd, byte[] data, |
|
423 int offset, int count) throws IOException; |
|
424 |
|
425 static native int writeSocketDirectImpl(FileDescriptor fd, int address, |
|
426 int offset, int count) throws IOException; |
|
427 |
|
428 static native void setNonBlockingImpl(FileDescriptor aFD, |
|
429 boolean block); |
|
430 |
|
431 static native int connectSocketImpl(FileDescriptor aFD, |
|
432 int trafficClass, InetAddress inetAddress, int port); |
|
433 |
|
434 // BEGIN android-changed |
|
435 static native int connectWithTimeoutSocketImpl( |
|
436 FileDescriptor aFD, int timeout, int trafficClass, |
|
437 InetAddress hostname, int port, int step, byte[] context); |
|
438 // END android-changed |
|
439 |
|
440 static native void connectStreamWithTimeoutSocketImpl(FileDescriptor aFD, |
|
441 int aport, int timeout, int trafficClass, InetAddress inetAddress) |
|
442 throws IOException; |
|
443 |
|
444 static native void socketBindImpl(FileDescriptor aFD, int port, |
|
445 InetAddress inetAddress) throws SocketException; |
|
446 |
|
447 static native void listenStreamSocketImpl(FileDescriptor aFD, int backlog) |
|
448 throws SocketException; |
|
449 |
|
450 static native int availableStreamImpl(FileDescriptor aFD) |
|
451 throws SocketException; |
|
452 |
|
453 static native void acceptSocketImpl(FileDescriptor fdServer, |
|
454 SocketImpl newSocket, FileDescriptor fdnewSocket, int timeout) |
|
455 throws IOException; |
|
456 |
|
457 static native boolean supportsUrgentDataImpl(FileDescriptor fd); |
|
458 |
|
459 static native void sendUrgentDataImpl(FileDescriptor fd, byte value); |
|
460 |
|
461 /* |
|
462 * Connect the socket to a port and address |
|
463 * |
|
464 * @param aFD the FileDescriptor to associate with the socket @param port |
|
465 * the port to connect to @param trafficClass the traffic Class to be used |
|
466 * then the connection is made @param inetAddress address to connect to. |
|
467 * |
|
468 * @exception SocketException if the connect fails |
|
469 */ |
|
470 static native void connectDatagramImpl2(FileDescriptor aFD, |
|
471 int port, int trafficClass, InetAddress inetAddress) |
|
472 throws SocketException; |
|
473 |
|
474 /* |
|
475 * Disconnect the socket to a port and address |
|
476 * |
|
477 * @param aFD the FileDescriptor to associate with the socket |
|
478 * |
|
479 * @exception SocketException if the disconnect fails |
|
480 */ |
|
481 static native void disconnectDatagramImpl(FileDescriptor aFD) |
|
482 throws SocketException; |
|
483 |
|
484 /* |
|
485 * Allocate a datagram socket in the IP stack. The socket is associated with |
|
486 * the <code>aFD</code>. |
|
487 * |
|
488 * @param aFD the FileDescriptor to associate with the socket @param |
|
489 * preferIPv4Stack IP stack preference if underlying platform is V4/V6 |
|
490 * @exception SocketException upon an allocation error |
|
491 */ |
|
492 |
|
493 /* |
|
494 * Bind the socket to the port/localhost in the IP stack. |
|
495 * |
|
496 * @param aFD the socket descriptor @param port the option selector @param |
|
497 * bindToDevice bind the socket to the specified interface @param |
|
498 * inetAddress address to connect to. @return if bind successful @exception |
|
499 * SocketException thrown if bind operation fails |
|
500 */ |
|
501 static native boolean socketBindImpl2(FileDescriptor aFD, |
|
502 int port, boolean bindToDevice, InetAddress inetAddress) |
|
503 throws SocketException; |
|
504 |
|
505 /* |
|
506 * Peek on the socket, update <code>sender</code> address and answer the |
|
507 * sender port. |
|
508 * |
|
509 * @param aFD the socket FileDescriptor @param sender an InetAddress, to be |
|
510 * updated with the sender's address @param receiveTimeout the maximum |
|
511 * length of time the socket should block, reading @return int the sender |
|
512 * port |
|
513 * |
|
514 * @exception IOException upon an read error or timeout |
|
515 */ |
|
516 static native int peekDatagramImpl(FileDescriptor aFD, |
|
517 InetAddress sender, int receiveTimeout) throws IOException; |
|
518 |
|
519 /* |
|
520 * Recieve data on the socket into the specified buffer. The packet fields |
|
521 * <code>data</code> & <code>length</code> are passed in addition to |
|
522 * <code>packet</code> to eliminate the JNI field access calls. |
|
523 * |
|
524 * @param aFD the socket FileDescriptor @param packet the DatagramPacket to |
|
525 * receive into @param data the data buffer of the packet @param offset the |
|
526 * offset in the data buffer @param length the length of the data buffer in |
|
527 * the packet @param receiveTimeout the maximum length of time the socket |
|
528 * should block, reading @param peek indicates to peek at the data @return |
|
529 * number of data received @exception IOException upon an read error or |
|
530 * timeout |
|
531 */ |
|
532 static native int receiveDatagramImpl(FileDescriptor aFD, |
|
533 DatagramPacket packet, byte[] data, int offset, int length, |
|
534 int receiveTimeout, boolean peek) throws IOException; |
|
535 |
|
536 static native int receiveDatagramDirectImpl(FileDescriptor aFD, |
|
537 DatagramPacket packet, int address, int offset, int length, |
|
538 int receiveTimeout, boolean peek) throws IOException; |
|
539 |
|
540 /* |
|
541 * Recieve data on the connected socket into the specified buffer. The |
|
542 * packet fields <code>data</code> & <code>length</code> are passed in |
|
543 * addition to <code>packet</code> to eliminate the JNI field access |
|
544 * calls. |
|
545 * |
|
546 * @param aFD the socket FileDescriptor @param packet the DatagramPacket to |
|
547 * receive into @param data the data buffer of the packet @param offset the |
|
548 * offset in the data buffer @param length the length of the data buffer in |
|
549 * the packet @param receiveTimeout the maximum length of time the socket |
|
550 * should block, reading @param peek indicates to peek at the data @return |
|
551 * number of data received @exception IOException upon an read error or |
|
552 * timeout |
|
553 */ |
|
554 static native int recvConnectedDatagramImpl(FileDescriptor aFD, |
|
555 DatagramPacket packet, byte[] data, int offset, int length, |
|
556 int receiveTimeout, boolean peek) throws IOException; |
|
557 |
|
558 static native int recvConnectedDatagramDirectImpl(FileDescriptor aFD, |
|
559 DatagramPacket packet, int address, int offset, int length, |
|
560 int receiveTimeout, boolean peek) throws IOException; |
|
561 |
|
562 /* |
|
563 * Send the <code>data</code> to the nominated target <code>address</code> |
|
564 * and <code>port</code>. These values are derived from the |
|
565 * DatagramPacket to reduce the field calls within JNI. |
|
566 * |
|
567 * @param fd the socket FileDescriptor @param data the data buffer of the |
|
568 * packet @param offset the offset in the data buffer @param length the |
|
569 * length of the data buffer in the packet @param port the target host port |
|
570 * @param bindToDevice if bind to device @param trafficClass the traffic |
|
571 * class to be used when the datagram is sent @param inetAddress address to |
|
572 * connect to. @return number of data send |
|
573 * |
|
574 * @exception IOException upon an read error or timeout |
|
575 */ |
|
576 static native int sendDatagramImpl(FileDescriptor fd, |
|
577 byte[] data, int offset, int length, int port, |
|
578 boolean bindToDevice, int trafficClass, InetAddress inetAddress) |
|
579 throws IOException; |
|
580 |
|
581 static native int sendDatagramDirectImpl(FileDescriptor fd, |
|
582 int address, int offset, int length, int port, |
|
583 boolean bindToDevice, int trafficClass, InetAddress inetAddress) |
|
584 throws IOException; |
|
585 |
|
586 /* |
|
587 * Send the <code>data</code> to the address and port to which the was |
|
588 * connnected and <code>port</code>. |
|
589 * |
|
590 * @param fd the socket FileDescriptor @param data the data buffer of the |
|
591 * packet @param offset the offset in the data buffer @param length the |
|
592 * length of the data buffer in the packet @param bindToDevice not used, |
|
593 * current kept in case needed as was the case for sendDatagramImpl @return |
|
594 * number of data send @exception IOException upon an read error or timeout |
|
595 */ |
|
596 static native int sendConnectedDatagramImpl(FileDescriptor fd, |
|
597 byte[] data, int offset, int length, boolean bindToDevice) |
|
598 throws IOException; |
|
599 |
|
600 static native int sendConnectedDatagramDirectImpl(FileDescriptor fd, |
|
601 int address, int offset, int length, boolean bindToDevice) |
|
602 throws IOException; |
|
603 |
|
604 /* |
|
605 * Answer the result of attempting to create a server stream socket in the |
|
606 * IP stack. Any special options required for server sockets will be set by |
|
607 * this method. |
|
608 * |
|
609 * @param aFD the socket FileDescriptor @param preferIPv4Stack if use IPV4 |
|
610 * @exception SocketException if an error occurs while creating the socket |
|
611 */ |
|
612 static native void createServerStreamSocketImpl(FileDescriptor aFD, |
|
613 boolean preferIPv4Stack) throws SocketException; |
|
614 |
|
615 /* |
|
616 * Answer the result of attempting to create a multicast socket in the IP |
|
617 * stack. Any special options required for server sockets will be set by |
|
618 * this method. |
|
619 * |
|
620 * @param aFD the socket FileDescriptor @param preferIPv4Stack if use IPV4 |
|
621 * @exception SocketException if an error occurs while creating the socket |
|
622 */ |
|
623 static native void createMulticastSocketImpl(FileDescriptor aFD, |
|
624 boolean preferIPv4Stack) throws SocketException; |
|
625 |
|
626 /* |
|
627 * Recieve at most <code>count</code> bytes into the buffer <code>data</code> |
|
628 * at the <code>offset</code> on the socket. |
|
629 * |
|
630 * @param aFD the socket FileDescriptor @param data the receive buffer |
|
631 * @param offset the offset into the buffer @param count the max number of |
|
632 * bytes to receive @param timeout the max time the read operation should |
|
633 * block waiting for data @return int the actual number of bytes read |
|
634 * @throws IOException @exception SocketException if an error occurs while |
|
635 * reading |
|
636 */ |
|
637 static native int receiveStreamImpl(FileDescriptor aFD, byte[] data, |
|
638 int offset, int count, int timeout) throws IOException; |
|
639 |
|
640 /* |
|
641 * Send <code>count</code> bytes from the buffer <code>data</code> at |
|
642 * the <code>offset</code>, on the socket. |
|
643 * |
|
644 * @param fd |
|
645 * |
|
646 * @param data the send buffer @param offset the offset into the buffer |
|
647 * @param count the number of bytes to receive @return int the actual number |
|
648 * of bytes sent @throws IOException @exception SocketException if an error |
|
649 * occurs while writing |
|
650 */ |
|
651 static native int sendStreamImpl(FileDescriptor fd, byte[] data, |
|
652 int offset, int count) throws IOException; |
|
653 |
|
654 private native void shutdownInputImpl(FileDescriptor descriptor) |
|
655 throws IOException; |
|
656 |
|
657 private native void shutdownOutputImpl(FileDescriptor descriptor) |
|
658 throws IOException; |
|
659 |
|
660 // BEGIN android-removed |
|
661 // static native void acceptStreamSocketImpl(FileDescriptor fdServer, |
|
662 // SocketImpl newSocket, FileDescriptor fdnewSocket, int timeout) |
|
663 // throws IOException; |
|
664 // |
|
665 // static native void createStreamSocketImpl(FileDescriptor aFD, |
|
666 // boolean preferIPv4Stack) throws SocketException; |
|
667 // END android-removed |
|
668 |
|
669 static native int sendDatagramImpl2(FileDescriptor fd, byte[] data, |
|
670 int offset, int length, int port, InetAddress inetAddress) |
|
671 throws IOException; |
|
672 |
|
673 static native int selectImpl(FileDescriptor[] readfd, |
|
674 FileDescriptor[] writefd, int cread, int cwirte, int[] flags, |
|
675 long timeout); |
|
676 |
|
677 static native InetAddress getSocketLocalAddressImpl(FileDescriptor aFD, |
|
678 boolean preferIPv6Addresses); |
|
679 |
|
680 /* |
|
681 * Query the IP stack for the local port to which this socket is bound. |
|
682 * |
|
683 * @param aFD the socket descriptor @param preferIPv6Addresses address |
|
684 * preference for nodes that support both IPv4 and IPv6 @return int the |
|
685 * local port to which the socket is bound |
|
686 */ |
|
687 static native int getSocketLocalPortImpl(FileDescriptor aFD, |
|
688 boolean preferIPv6Addresses); |
|
689 |
|
690 /* |
|
691 * Query the IP stack for the nominated socket option. |
|
692 * |
|
693 * @param aFD the socket descriptor @param opt the socket option type |
|
694 * @return the nominated socket option value |
|
695 * |
|
696 * @throws SocketException if the option is invalid |
|
697 */ |
|
698 static native Object getSocketOptionImpl(FileDescriptor aFD, int opt) |
|
699 throws SocketException; |
|
700 |
|
701 /* |
|
702 * Set the nominated socket option in the IP stack. |
|
703 * |
|
704 * @param aFD the socket descriptor @param opt the option selector @param |
|
705 * optVal the nominated option value |
|
706 * |
|
707 * @throws SocketException if the option is invalid or cannot be set |
|
708 */ |
|
709 static native void setSocketOptionImpl(FileDescriptor aFD, int opt, |
|
710 Object optVal) throws SocketException; |
|
711 |
|
712 static native int getSocketFlagsImpl(); |
|
713 |
|
714 /* |
|
715 * Close the socket in the IP stack. |
|
716 * |
|
717 * @param aFD the socket descriptor |
|
718 */ |
|
719 static native void socketCloseImpl(FileDescriptor aFD); |
|
720 |
|
721 static native InetAddress getHostByAddrImpl(byte[] addr) |
|
722 throws UnknownHostException; |
|
723 |
|
724 static native InetAddress getHostByNameImpl(String addr, |
|
725 boolean preferIPv6Addresses) throws UnknownHostException; |
|
726 |
|
727 native void setInetAddressImpl(InetAddress sender, byte[] address); |
|
728 |
|
729 // BEGIN android-removed |
|
730 // native int isReachableByICMPImpl(InetAddress addr, InetAddress local, |
|
731 // int ttl, int timeout); |
|
732 // END android-removed |
|
733 |
|
734 native Channel inheritedChannelImpl(); |
|
735 |
|
736 public Channel inheritedChannel() { |
|
737 return inheritedChannelImpl(); |
|
738 } |
|
739 |
|
740 public void oneTimeInitialization(boolean jcl_supports_ipv6){ |
|
741 if (!isNetworkInited){ |
|
742 oneTimeInitializationImpl(jcl_supports_ipv6); |
|
743 isNetworkInited = true; |
|
744 } |
|
745 } |
|
746 |
|
747 native void oneTimeInitializationImpl (boolean jcl_supports_ipv6); |
|
748 } |