1 /*
2 * Copyright (c) 2000, 2020, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26 package java.nio.channels;
27
28 import java.io.IOException;
29 import java.net.InetSocketAddress;
30 import java.net.NetPermission;
31 import java.net.ProtocolFamily;
32 import java.net.StandardProtocolFamily;
33 import java.net.Socket;
34 import java.net.SocketOption;
35 import java.net.SocketAddress;
36 import java.net.UnixDomainSocketAddress;
37 import java.nio.ByteBuffer;
38 import java.nio.channels.spi.AbstractSelectableChannel;
39 import java.nio.channels.spi.SelectorProvider;
40 import static java.util.Objects.requireNonNull;
41
42 /**
43 * A selectable channel for stream-oriented connecting sockets.
44 *
45 * <p> A socket channel is created by invoking one of the {@code open} methods of
46 * this class. The no-arg {@link #open() open} method opens a socket channel
47 * for an <i>Internet protocol</i> socket. The {@link #open(ProtocolFamily)}
48 * method is used to open a socket channel for a socket of a specified protocol
49 * family. It is not possible to create a channel for an arbitrary, pre-existing
50 * socket. A newly-created socket channel is open but not yet connected. An
51 * attempt to invoke an I/O operation upon an unconnected channel will cause a
52 * {@link NotYetConnectedException} to be thrown. A socket channel can be
53 * connected by invoking its {@link #connect connect} method; once connected,
54 * a socket channel remains connected until it is closed. Whether or not a
55 * socket channel is connected may be determined by invoking its {@link #isConnected()
56 * isConnected} method.
57 *
58 * <p> Socket channels support <i>non-blocking connection:</i> A socket
59 * channel may be created and the process of establishing the link to the
60 * remote socket may be initiated via the {@link #connect connect} method for
61 * later completion by the {@link #finishConnect finishConnect} method.
62 * Whether or not a connection operation is in progress may be determined by
63 * invoking the {@link #isConnectionPending isConnectionPending} method.
64 *
65 * <p> Socket channels support <i>asynchronous shutdown</i>, which is similar
66 * to the asynchronous close operation specified in the {@link Channel} class.
67 * If the input side of a socket is shut down by one thread while another
68 * thread is blocked in a read operation on the socket's channel, then the read
69 * operation in the blocked thread will complete without reading any bytes and
70 * will return {@code -1}. If the output side of a socket is shut down by one
71 * thread while another thread is blocked in a write operation on the socket's
72 * channel, then the blocked thread will receive an {@link
73 * AsynchronousCloseException}.
74 *
75 * <p> Socket options are configured using the {@link #setOption(SocketOption,Object)
76 * setOption} method. Socket channels for <i>Internet protocol</i> sockets support
77 * following options:
78 * <blockquote>
79 * <table class="striped">
80 * <caption style="display:none">Socket options</caption>
81 * <thead>
82 * <tr>
83 * <th scope="col">Option Name</th>
84 * <th scope="col">Description</th>
85 * </tr>
86 * </thead>
87 * <tbody>
88 * <tr>
89 * <th scope="row"> {@link java.net.StandardSocketOptions#SO_SNDBUF SO_SNDBUF} </th>
90 * <td> The size of the socket send buffer </td>
91 * </tr>
92 * <tr>
93 * <th scope="row"> {@link java.net.StandardSocketOptions#SO_RCVBUF SO_RCVBUF} </th>
94 * <td> The size of the socket receive buffer </td>
95 * </tr>
96 * <tr>
97 * <th scope="row"> {@link java.net.StandardSocketOptions#SO_KEEPALIVE SO_KEEPALIVE} </th>
98 * <td> Keep connection alive </td>
99 * </tr>
100 * <tr>
101 * <th scope="row"> {@link java.net.StandardSocketOptions#SO_REUSEADDR SO_REUSEADDR} </th>
102 * <td> Re-use address </td>
103 * </tr>
104 * <tr>
105 * <th scope="row"> {@link java.net.StandardSocketOptions#SO_LINGER SO_LINGER} </th>
106 * <td> Linger on close if data is present (when configured in blocking mode
107 * only) </td>
108 * </tr>
109 * <tr>
110 * <th scope="row"> {@link java.net.StandardSocketOptions#TCP_NODELAY TCP_NODELAY} </th>
111 * <td> Disable the Nagle algorithm </td>
112 * </tr>
113 * </tbody>
114 * </table>
115 * </blockquote>
116 *
117 * <p> Socket channels for <i>Unix domain</i> sockets support:
118 * <blockquote>
119 * <table class="striped">
120 * <caption style="display:none">Socket options</caption>
121 * <thead>
122 * <tr>
123 * <th scope="col">Option Name</th>
124 * <th scope="col">Description</th>
125 * </tr>
126 * </thead>
127 * <tbody>
128 * <tr>
129 * <th scope="row"> {@link java.net.StandardSocketOptions#SO_SNDBUF SO_SNDBUF} </th>
130 * <td> The size of the socket send buffer </td>
131 * </tr>
132 * <tr>
133 * <th scope="row"> {@link java.net.StandardSocketOptions#SO_RCVBUF SO_RCVBUF} </th>
134 * <td> The size of the socket receive buffer </td>
135 * </tr>
136 * <tr>
137 * <th scope="row"> {@link java.net.StandardSocketOptions#SO_LINGER SO_LINGER} </th>
138 * <td> Linger on close if data is present (when configured in blocking mode
139 * only) </td>
140 * </tr>
141 * </tbody>
142 * </table>
143 * </blockquote>
144 *
145 * <p> Additional (implementation specific) options may also be supported.
146 *
147 * <p> Socket channels are safe for use by multiple concurrent threads. They
148 * support concurrent reading and writing, though at most one thread may be
149 * reading and at most one thread may be writing at any given time. The {@link
150 * #connect connect} and {@link #finishConnect finishConnect} methods are
151 * mutually synchronized against each other, and an attempt to initiate a read
152 * or write operation while an invocation of one of these methods is in
153 * progress will block until that invocation is complete. </p>
154 *
155 * @author Mark Reinhold
156 * @author JSR-51 Expert Group
157 * @since 1.4
158 */
159
160 public abstract class SocketChannel
161 extends AbstractSelectableChannel
162 implements ByteChannel, ScatteringByteChannel, GatheringByteChannel, NetworkChannel
163 {
164
165 /**
166 * Initializes a new instance of this class.
167 *
168 * @param provider
169 * The provider that created this channel
170 */
171 protected SocketChannel(SelectorProvider provider) {
172 super(provider);
173 }
174
175 /**
176 * Opens a socket channel for an <i>Internet protocol</i> socket.
177 *
178 * <p> The new channel is created by invoking the {@link
179 * java.nio.channels.spi.SelectorProvider#openSocketChannel
180 * openSocketChannel} method of the system-wide default {@link
181 * java.nio.channels.spi.SelectorProvider} object. </p>
182 *
183 * @return A new socket channel
184 *
185 * @throws IOException
186 * If an I/O error occurs
187 *
188 * @see <a href="../../net/doc-files/net-properties.html#Ipv4IPv6">
189 * java.net.preferIPv4Stack</a> system property
190 */
191 public static SocketChannel open() throws IOException {
192 return SelectorProvider.provider().openSocketChannel();
193 }
194
195 /**
196 * Opens a socket channel. The {@code family} parameter specifies the
197 * {@link ProtocolFamily protocol family} of the channel's socket.
198 *
199 * <p> The new channel is created by invoking the {@link
200 * java.nio.channels.spi.SelectorProvider#openSocketChannel(ProtocolFamily)
201 * openSocketChannel(ProtocolFamily)} method of the system-wide default.
202 * {@link java.nio.channels.spi.SelectorProvider} object.</p>
203 *
204 * @param family
205 * The protocol family
206 *
207 * @return A new socket channel
208 *
209 * @throws UnsupportedOperationException
210 * If the specified protocol family is not supported. For example,
211 * suppose the parameter is specified as {@link
212 * java.net.StandardProtocolFamily#INET6 StandardProtocolFamily.INET6}
213 * but IPv6 is not enabled on the platform.
214 * @throws IOException
215 * If an I/O error occurs
216 *
217 * @see <a href="../../net/doc-files/net-properties.html#Ipv4IPv6">
218 * java.net.preferIPv4Stack</a> system property
219 *
220 * @since 15
221 */
222 public static SocketChannel open(ProtocolFamily family) throws IOException {
223 return SelectorProvider.provider().openSocketChannel(requireNonNull(family));
224 }
225
226 /**
227 * Opens a socket channel and connects it to a remote address.
228 *
229 * <p> If the remote address is an {@link InetSocketAddress} then this
230 * method works as if by invoking the {@link #open()} method, invoking the
231 * {@link #connect(SocketAddress) connect} method upon the resulting socket
232 * channel, passing it {@code remote}, and then returning that channel.
233 *
234 * <p> If the remote address is a {@link UnixDomainSocketAddress} then this
235 * works by invoking the {@link #open(ProtocolFamily)} method with {@link
236 * StandardProtocolFamily#UNIX} as parameter, invoking the {@link
237 * #connect(SocketAddress) connect} method upon the resulting socket channel,
238 * passing it {@code remote}, then returning that channel. </p>
239 *
240 * @param remote
241 * The remote address to which the new channel is to be connected
242 *
243 * @return A new, and connected, socket channel
244 *
245 * @throws AsynchronousCloseException
246 * If another thread closes this channel
247 * while the connect operation is in progress
248 *
249 * @throws ClosedByInterruptException
250 * If another thread interrupts the current thread
251 * while the connect operation is in progress, thereby
252 * closing the channel and setting the current thread's
253 * interrupt status
254 *
255 * @throws UnresolvedAddressException
256 * If the given remote address is an InetSocketAddress that is not fully
257 * resolved
258 *
259 * @throws UnsupportedAddressTypeException
260 * If the type of the given remote address is not supported
261 *
262 * @throws SecurityException
263 * If a security manager has been installed
264 * and it does not permit access to the given remote endpoint
265 *
266 * @throws IOException
267 * If some other I/O error occurs
268 *
269 * @see <a href="../../net/doc-files/net-properties.html#Ipv4IPv6">
270 * java.net.preferIPv4Stack</a> system property
271 */
272 public static SocketChannel open(SocketAddress remote)
273 throws IOException
274 {
275 SocketChannel sc;
276 if (remote instanceof InetSocketAddress)
277 sc = open();
278 else if (remote instanceof UnixDomainSocketAddress)
279 sc = open(StandardProtocolFamily.UNIX);
280 else
281 throw new UnsupportedAddressTypeException();
282
283 try {
284 sc.connect(remote);
285 } catch (Throwable x) {
286 try {
287 sc.close();
288 } catch (Throwable suppressed) {
289 x.addSuppressed(suppressed);
290 }
291 throw x;
292 }
293 assert sc.isConnected();
294 return sc;
295 }
296
297 /**
298 * Returns an operation set identifying this channel's supported
299 * operations.
300 *
301 * <p> Socket channels support connecting, reading, and writing, so this
302 * method returns {@code (}{@link SelectionKey#OP_CONNECT}
303 * {@code |} {@link SelectionKey#OP_READ} {@code |} {@link
304 * SelectionKey#OP_WRITE}{@code )}.
305 *
306 * @return The valid-operation set
307 */
308 public final int validOps() {
309 return (SelectionKey.OP_READ
310 | SelectionKey.OP_WRITE
311 | SelectionKey.OP_CONNECT);
312 }
313
314
315 // -- Socket-specific operations --
316
317 /**
318 * Binds the channel's socket to a local address.
319 *
320 * <p> This method is used to establish an association between the socket
321 * and a local address. For <i>Internet Protocol</i> sockets, once an
322 * association is established then the socket remains bound until the
323 * channel is closed. If the {@code local} parameter has the value {@code
324 * null} then the socket will be bound to an address that is assigned
325 * automatically.
326 *
327 * @apiNote
328 * Binding a socket channel to a <i>Unix Domain</i> socket creates a file
329 * corresponding to the file path in the {@link UnixDomainSocketAddress}. This
330 * file persists after the channel is closed, and must be removed before
331 * another socket can bind to the same name. If a socket channel to a Unix
332 * Domain socket is <i>implicitly</i> bound by connecting it without calling
333 * bind first, then its socket is
334 * <a href="../../java/net/UnixDomainSocketAddress.html#unnamed">unnamed</a>
335 * with no corresponding socket file in the file-system. If a socket channel
336 * to a Unix Domain socket is <i>automatically</i> bound by calling {@code
337 * bind(null)} this results in an unnamed socket also.
338 *
339 * @implNote
340 * Each platform enforces an implementation specific maximum length for the
341 * name of a <i>Unix Domain</i> socket. This limitation is enforced when a
342 * channel is bound. The maximum length is typically close to and generally
343 * not less than 100 bytes.
344 *
345 * @param local The address to bind the socket, or {@code null} to bind
346 * the socket to an automatically assigned socket address
347 *
348 * @return This channel
349 *
350 * @throws ConnectionPendingException
351 * If a non-blocking connect operation is already in progress on
352 * this channel
353 * @throws AlreadyBoundException {@inheritDoc}
354 * @throws UnsupportedAddressTypeException {@inheritDoc}
355 * @throws ClosedChannelException {@inheritDoc}
356 * @throws IOException {@inheritDoc}
357 * @throws SecurityException
358 * If a security manager has been installed and its {@link
359 * SecurityManager#checkListen checkListen} method denies
360 * the operation for an <i>Internet protocol</i> socket address,
361 * or for a <i>Unix domain</i> socket address if it denies
362 * {@link NetPermission}{@code("accessUnixDomainSocket")}.
363 *
364 * @since 1.7
365 */
366 @Override
367 public abstract SocketChannel bind(SocketAddress local)
368 throws IOException;
369
370 /**
371 * @throws UnsupportedOperationException {@inheritDoc}
372 * @throws IllegalArgumentException {@inheritDoc}
373 * @throws ClosedChannelException {@inheritDoc}
374 * @throws IOException {@inheritDoc}
375 *
376 * @since 1.7
377 */
378 @Override
379 public abstract <T> SocketChannel setOption(SocketOption<T> name, T value)
380 throws IOException;
381
382 /**
383 * Shutdown the connection for reading without closing the channel.
384 *
385 * <p> Once shutdown for reading then further reads on the channel will
386 * return {@code -1}, the end-of-stream indication. If the input side of the
387 * connection is already shutdown then invoking this method has no effect.
388 *
389 * @return The channel
390 *
391 * @throws NotYetConnectedException
392 * If this channel is not yet connected
393 * @throws ClosedChannelException
394 * If this channel is closed
395 * @throws IOException
396 * If some other I/O error occurs
397 *
398 * @since 1.7
399 */
400 public abstract SocketChannel shutdownInput() throws IOException;
401
402 /**
403 * Shutdown the connection for writing without closing the channel.
404 *
405 * <p> Once shutdown for writing then further attempts to write to the
406 * channel will throw {@link ClosedChannelException}. If the output side of
407 * the connection is already shutdown then invoking this method has no
408 * effect.
409 *
410 * @return The channel
411 *
412 * @throws NotYetConnectedException
413 * If this channel is not yet connected
414 * @throws ClosedChannelException
415 * If this channel is closed
416 * @throws IOException
417 * If some other I/O error occurs
418 *
419 * @since 1.7
420 */
421 public abstract SocketChannel shutdownOutput() throws IOException;
422
423 /**
424 * Retrieves a socket associated with this channel.
425 *
426 * @return A socket associated with this channel
427 *
428 * @throws UnsupportedOperationException
429 * If the channel's socket is not an <i>Internet protocol</i> socket
430 */
431 public abstract Socket socket();
432
433 /**
434 * Tells whether or not this channel's network socket is connected.
435 *
436 * @return {@code true} if, and only if, this channel's network socket
437 * is {@link #isOpen open} and connected
438 */
439 public abstract boolean isConnected();
440
441 /**
442 * Tells whether or not a connection operation is in progress on this
443 * channel.
444 *
445 * @return {@code true} if, and only if, a connection operation has been
446 * initiated on this channel but not yet completed by invoking the
447 * {@link #finishConnect finishConnect} method
448 */
449 public abstract boolean isConnectionPending();
450
451 /**
452 * Connects this channel's socket.
453 *
454 * <p> If this channel is in non-blocking mode then an invocation of this
455 * method initiates a non-blocking connection operation. If the connection
456 * is established immediately, as can happen with a local connection, then
457 * this method returns {@code true}. Otherwise this method returns
458 * {@code false} and the connection operation must later be completed by
459 * invoking the {@link #finishConnect finishConnect} method.
460 *
461 * <p> If this channel is in blocking mode then an invocation of this
462 * method will block until the connection is established or an I/O error
463 * occurs.
464 *
465 * <p> For channels to <i>Internet protocol</i> sockets, this method performs
466 * exactly the same security checks as the {@link java.net.Socket} class.
467 * That is, if a security manager has been
468 * installed then this method verifies that its {@link
469 * java.lang.SecurityManager#checkConnect checkConnect} method permits
470 * connecting to the address and port number of the given remote endpoint.
471 *
472 * <p> For channels to <i>Unix Domain</i> sockets, this method checks
473 * {@link java.net.NetPermission NetPermission}{@code
474 * ("accessUnixDomainSocket")} with the security manager's {@link
475 * SecurityManager#checkPermission(java.security.Permission)
476 * checkPermission} method.
477 *
478 * <p> This method may be invoked at any time. If a read or write
479 * operation upon this channel is invoked while an invocation of this
480 * method is in progress then that operation will first block until this
481 * invocation is complete. If a connection attempt is initiated but fails,
482 * that is, if an invocation of this method throws a checked exception,
483 * then the channel will be closed. </p>
484 *
485 * @param remote
486 * The remote address to which this channel is to be connected
487 *
488 * @return {@code true} if a connection was established,
489 * {@code false} if this channel is in non-blocking mode
490 * and the connection operation is in progress
491 *
492 * @throws AlreadyConnectedException
493 * If this channel is already connected
494 *
495 * @throws ConnectionPendingException
496 * If a non-blocking connection operation is already in progress
497 * on this channel
498 *
499 * @throws ClosedChannelException
500 * If this channel is closed
501 *
502 * @throws AsynchronousCloseException
503 * If another thread closes this channel
504 * while the connect operation is in progress
505 *
506 * @throws ClosedByInterruptException
507 * If another thread interrupts the current thread
508 * while the connect operation is in progress, thereby
509 * closing the channel and setting the current thread's
510 * interrupt status
511 *
512 * @throws UnresolvedAddressException
513 * If the given remote address is an InetSocketAddress that is not fully resolved
514 *
515 * @throws UnsupportedAddressTypeException
516 * If the type of the given remote address is not supported
517 *
518 * @throws SecurityException
519 * If a security manager has been installed
520 * and it does not permit access to the given remote endpoint
521 *
522 * @throws IOException
523 * If some other I/O error occurs
524 */
525 public abstract boolean connect(SocketAddress remote) throws IOException;
526
527 /**
528 * Finishes the process of connecting a socket channel.
529 *
530 * <p> A non-blocking connection operation is initiated by placing a socket
531 * channel in non-blocking mode and then invoking its {@link #connect
532 * connect} method. Once the connection is established, or the attempt has
533 * failed, the socket channel will become connectable and this method may
534 * be invoked to complete the connection sequence. If the connection
535 * operation failed then invoking this method will cause an appropriate
536 * {@link java.io.IOException} to be thrown.
537 *
538 * <p> If this channel is already connected then this method will not block
539 * and will immediately return {@code true}. If this channel is in
540 * non-blocking mode then this method will return {@code false} if the
541 * connection process is not yet complete. If this channel is in blocking
542 * mode then this method will block until the connection either completes
543 * or fails, and will always either return {@code true} or throw a checked
544 * exception describing the failure.
545 *
546 * <p> This method may be invoked at any time. If a read or write
547 * operation upon this channel is invoked while an invocation of this
548 * method is in progress then that operation will first block until this
549 * invocation is complete. If a connection attempt fails, that is, if an
550 * invocation of this method throws a checked exception, then the channel
551 * will be closed. </p>
552 *
553 * @return {@code true} if, and only if, this channel's socket is now
554 * connected
555 *
556 * @throws NoConnectionPendingException
557 * If this channel is not connected and a connection operation
558 * has not been initiated
559 *
560 * @throws ClosedChannelException
561 * If this channel is closed
562 *
563 * @throws AsynchronousCloseException
564 * If another thread closes this channel
565 * while the connect operation is in progress
566 *
567 * @throws ClosedByInterruptException
568 * If another thread interrupts the current thread
569 * while the connect operation is in progress, thereby
570 * closing the channel and setting the current thread's
571 * interrupt status
572 *
573 * @throws IOException
574 * If some other I/O error occurs
575 */
576 public abstract boolean finishConnect() throws IOException;
577
578 /**
579 * Returns the remote address to which this channel's socket is connected.
580 *
581 * <p> Where the channel's socket is bound and connected to an <i>Internet
582 * Protocol</i> socket address then the return value is of type
583 * {@link java.net.InetSocketAddress}.
584 *
585 * <p> Where the channel's socket is bound and connected to a <i>Unix Domain</i>
586 * socket address, the returned address is a {@link UnixDomainSocketAddress}.
587 *
588 * @return The remote address; {@code null} if the channel's socket is not
589 * connected
590 *
591 * @throws ClosedChannelException
592 * If the channel is closed
593 * @throws IOException
594 * If an I/O error occurs
595 *
596 * @since 1.7
597 */
598 public abstract SocketAddress getRemoteAddress() throws IOException;
599
600 // -- ByteChannel operations --
601
602 /**
603 * @throws NotYetConnectedException
604 * If this channel is not yet connected
605 */
606 public abstract int read(ByteBuffer dst) throws IOException;
607
608 /**
609 * @throws NotYetConnectedException
610 * If this channel is not yet connected
611 */
612 public abstract long read(ByteBuffer[] dsts, int offset, int length)
613 throws IOException;
614
615 /**
616 * @throws NotYetConnectedException
617 * If this channel is not yet connected
618 */
619 public final long read(ByteBuffer[] dsts) throws IOException {
620 return read(dsts, 0, dsts.length);
621 }
622
623 /**
624 * @throws NotYetConnectedException
625 * If this channel is not yet connected
626 */
627 public abstract int write(ByteBuffer src) throws IOException;
628
629 /**
630 * @throws NotYetConnectedException
631 * If this channel is not yet connected
632 */
633 public abstract long write(ByteBuffer[] srcs, int offset, int length)
634 throws IOException;
635
636 /**
637 * @throws NotYetConnectedException
638 * If this channel is not yet connected
639 */
640 public final long write(ByteBuffer[] srcs) throws IOException {
641 return write(srcs, 0, srcs.length);
642 }
643
644 /**
645 * {@inheritDoc}
646 *
647 * If there is a security manager set, its {@code checkConnect} method is
648 * called with the local address and {@code -1} as its arguments to see
649 * if the operation is allowed. If the operation is not allowed,
650 * a {@code SocketAddress} representing the
651 * {@link java.net.InetAddress#getLoopbackAddress loopback} address and the
652 * local port of the channel's socket is returned.
653 *
654 * <p> Where the channel is bound to a Unix Domain socket address, the socket
655 * address is a {@link UnixDomainSocketAddress}. If there is a security manager
656 * set, its {@link SecurityManager#checkPermission(java.security.Permission)
657 * checkPermission} method is called with {@link NetPermission}{@code
658 * ("accessUnixDomainSocket")}. If the operation is not allowed an unnamed
659 * {@link UnixDomainSocketAddress} is returned.
660 *
661 * @return The {@code SocketAddress} that the socket is bound to, or the
662 * {@code SocketAddress} representing the loopback address or empty
663 * path if denied by the security manager, or {@code null} if the
664 * channel's socket is not bound
665 *
666 * @throws ClosedChannelException {@inheritDoc}
667 * @throws IOException {@inheritDoc}
668 */
669 @Override
670 public abstract SocketAddress getLocalAddress() throws IOException;
671 }