1 /*
   2  * Copyright (c) 2000, 2009, 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 sun.nio.ch;
  27 
  28 import java.io.FileDescriptor;
  29 import java.io.IOException;
  30 import java.net.*;
  31 import java.nio.ByteBuffer;
  32 import java.nio.channels.*;
  33 import java.nio.channels.spi.*;
  34 import java.util.*;
  35 import sun.net.NetHooks;
  36 
  37 
  38 /**
  39  * An implementation of SocketChannels
  40  */
  41 
  42 class SocketChannelImpl
  43     extends SocketChannel
  44     implements SelChImpl
  45 {
  46 
  47     // Used to make native read and write calls
  48     private static NativeDispatcher nd;
  49 
  50     // Our file descriptor object
  51     private final FileDescriptor fd;
  52 
  53     // fd value needed for dev/poll. This value will remain valid
  54     // even after the value in the file descriptor object has been set to -1
  55     private final int fdVal;
  56 
  57     // IDs of native threads doing reads and writes, for signalling
  58     private volatile long readerThread = 0;
  59     private volatile long writerThread = 0;
  60 
  61     // Lock held by current reading or connecting thread
  62     private final Object readLock = new Object();
  63 
  64     // Lock held by current writing or connecting thread
  65     private final Object writeLock = new Object();
  66 
  67     // Lock held by any thread that modifies the state fields declared below
  68     // DO NOT invoke a blocking I/O operation while holding this lock!
  69     private final Object stateLock = new Object();
  70 
  71     // -- The following fields are protected by stateLock
  72 
  73     // State, increases monotonically
  74     private static final int ST_UNINITIALIZED = -1;
  75     private static final int ST_UNCONNECTED = 0;
  76     private static final int ST_PENDING = 1;
  77     private static final int ST_CONNECTED = 2;
  78     private static final int ST_KILLPENDING = 3;
  79     private static final int ST_KILLED = 4;
  80     private int state = ST_UNINITIALIZED;
  81 
  82     // Binding
  83     private SocketAddress localAddress;
  84     private SocketAddress remoteAddress;
  85 
  86     // Input/Output open
  87     private boolean isInputOpen = true;
  88     private boolean isOutputOpen = true;
  89     private boolean readyToConnect = false;
  90 
  91     // Socket adaptor, created on demand
  92     private Socket socket;
  93 
  94     // -- End of fields protected by stateLock
  95 
  96 
  97     // Constructor for normal connecting sockets
  98     //
  99     SocketChannelImpl(SelectorProvider sp) throws IOException {
 100         super(sp);
 101         this.fd = Net.socket(true);
 102         this.fdVal = IOUtil.fdVal(fd);
 103         this.state = ST_UNCONNECTED;
 104     }
 105 
 106     SocketChannelImpl(SelectorProvider sp,
 107                       FileDescriptor fd,
 108                       boolean bound)
 109         throws IOException
 110     {
 111         super(sp);
 112         this.fd = fd;
 113         this.fdVal = IOUtil.fdVal(fd);
 114         this.state = ST_UNCONNECTED;
 115         if (bound)
 116             this.localAddress = Net.localAddress(fd);
 117     }
 118 
 119     // Constructor for sockets obtained from server sockets
 120     //
 121     SocketChannelImpl(SelectorProvider sp,
 122                       FileDescriptor fd, InetSocketAddress remote)
 123         throws IOException
 124     {
 125         super(sp);
 126         this.fd = fd;
 127         this.fdVal = IOUtil.fdVal(fd);
 128         this.state = ST_CONNECTED;
 129         this.localAddress = Net.localAddress(fd);
 130         this.remoteAddress = remote;
 131     }
 132 
 133     public Socket socket() {
 134         synchronized (stateLock) {
 135             if (socket == null)
 136                 socket = SocketAdaptor.create(this);
 137             return socket;
 138         }
 139     }
 140 
 141     @Override
 142     public SocketAddress getLocalAddress() throws IOException {
 143         synchronized (stateLock) {
 144             if (!isOpen())
 145                 throw new ClosedChannelException();
 146             return localAddress;
 147         }
 148     }
 149 
 150     @Override
 151     public SocketAddress getRemoteAddress() throws IOException {
 152         synchronized (stateLock) {
 153             if (!isOpen())
 154                 throw new ClosedChannelException();
 155             return remoteAddress;
 156         }
 157     }
 158 
 159     @Override
 160     public <T> SocketChannel setOption(SocketOption<T> name, T value)
 161         throws IOException
 162     {
 163         if (name == null)
 164             throw new NullPointerException();
 165         if (!supportedOptions().contains(name))
 166             throw new UnsupportedOperationException("'" + name + "' not supported");
 167 
 168         synchronized (stateLock) {
 169             if (!isOpen())
 170                 throw new ClosedChannelException();
 171 
 172             // special handling for IP_TOS: no-op when IPv6
 173             if (name == StandardSocketOption.IP_TOS) {
 174                 if (!Net.isIPv6Available())
 175                     Net.setSocketOption(fd, StandardProtocolFamily.INET, name, value);
 176                 return this;
 177             }
 178 
 179             // no options that require special handling
 180             Net.setSocketOption(fd, Net.UNSPEC, name, value);
 181             return this;
 182         }
 183     }
 184 
 185     @Override
 186     @SuppressWarnings("unchecked")
 187     public <T> T getOption(SocketOption<T> name)
 188         throws IOException
 189     {
 190         if (name == null)
 191             throw new NullPointerException();
 192         if (!supportedOptions().contains(name))
 193             throw new UnsupportedOperationException("'" + name + "' not supported");
 194 
 195         synchronized (stateLock) {
 196             if (!isOpen())
 197                 throw new ClosedChannelException();
 198 
 199             // special handling for IP_TOS: always return 0 when IPv6
 200             if (name == StandardSocketOption.IP_TOS) {
 201                 return (Net.isIPv6Available()) ? (T) Integer.valueOf(0) :
 202                     (T) Net.getSocketOption(fd, StandardProtocolFamily.INET, name);
 203             }
 204 
 205             // no options that require special handling
 206             return (T) Net.getSocketOption(fd, Net.UNSPEC, name);
 207         }
 208     }
 209 
 210     private static class DefaultOptionsHolder {
 211         static final Set<SocketOption<?>> defaultOptions = defaultOptions();
 212 
 213         private static Set<SocketOption<?>> defaultOptions() {
 214             HashSet<SocketOption<?>> set = new HashSet<SocketOption<?>>(8);
 215             set.add(StandardSocketOption.SO_SNDBUF);
 216             set.add(StandardSocketOption.SO_RCVBUF);
 217             set.add(StandardSocketOption.SO_KEEPALIVE);
 218             set.add(StandardSocketOption.SO_REUSEADDR);
 219             set.add(StandardSocketOption.SO_LINGER);
 220             set.add(StandardSocketOption.TCP_NODELAY);
 221             // additional options required by socket adaptor
 222             set.add(StandardSocketOption.IP_TOS);
 223             set.add(ExtendedSocketOption.SO_OOBINLINE);
 224             return Collections.unmodifiableSet(set);
 225         }
 226     }
 227 
 228     @Override
 229     public final Set<SocketOption<?>> supportedOptions() {
 230         return DefaultOptionsHolder.defaultOptions;
 231     }
 232 
 233     private boolean ensureReadOpen() throws ClosedChannelException {
 234         synchronized (stateLock) {
 235             if (!isOpen())
 236                 throw new ClosedChannelException();
 237             if (!isConnected())
 238                 throw new NotYetConnectedException();
 239             if (!isInputOpen)
 240                 return false;
 241             else
 242                 return true;
 243         }
 244     }
 245 
 246     private void ensureWriteOpen() throws ClosedChannelException {
 247         synchronized (stateLock) {
 248             if (!isOpen())
 249                 throw new ClosedChannelException();
 250             if (!isOutputOpen)
 251                 throw new ClosedChannelException();
 252             if (!isConnected())
 253                 throw new NotYetConnectedException();
 254         }
 255     }
 256 
 257     private void readerCleanup() throws IOException {
 258         synchronized (stateLock) {
 259             readerThread = 0;
 260             if (state == ST_KILLPENDING)
 261                 kill();
 262         }
 263     }
 264 
 265     private void writerCleanup() throws IOException {
 266         synchronized (stateLock) {
 267             writerThread = 0;
 268             if (state == ST_KILLPENDING)
 269                 kill();
 270         }
 271     }
 272 
 273     public int read(ByteBuffer buf) throws IOException {
 274 
 275         if (buf == null)
 276             throw new NullPointerException();
 277 
 278         synchronized (readLock) {
 279             if (!ensureReadOpen())
 280                 return -1;
 281             int n = 0;
 282             try {
 283 
 284                 // Set up the interruption machinery; see
 285                 // AbstractInterruptibleChannel for details
 286                 //
 287                 begin();
 288 
 289                 synchronized (stateLock) {
 290                     if (!isOpen()) {
 291                     // Either the current thread is already interrupted, so
 292                     // begin() closed the channel, or another thread closed the
 293                     // channel since we checked it a few bytecodes ago.  In
 294                     // either case the value returned here is irrelevant since
 295                     // the invocation of end() in the finally block will throw
 296                     // an appropriate exception.
 297                     //
 298                         return 0;
 299 
 300                     }
 301 
 302                     // Save this thread so that it can be signalled on those
 303                     // platforms that require it
 304                     //
 305                     readerThread = NativeThread.current();
 306                 }
 307 
 308                 // Between the previous test of isOpen() and the return of the
 309                 // IOUtil.read invocation below, this channel might be closed
 310                 // or this thread might be interrupted.  We rely upon the
 311                 // implicit synchronization point in the kernel read() call to
 312                 // make sure that the right thing happens.  In either case the
 313                 // implCloseSelectableChannel method is ultimately invoked in
 314                 // some other thread, so there are three possibilities:
 315                 //
 316                 //   - implCloseSelectableChannel() invokes nd.preClose()
 317                 //     before this thread invokes read(), in which case the
 318                 //     read returns immediately with either EOF or an error,
 319                 //     the latter of which will cause an IOException to be
 320                 //     thrown.
 321                 //
 322                 //   - implCloseSelectableChannel() invokes nd.preClose() after
 323                 //     this thread is blocked in read().  On some operating
 324                 //     systems (e.g., Solaris and Windows) this causes the read
 325                 //     to return immediately with either EOF or an error
 326                 //     indication.
 327                 //
 328                 //   - implCloseSelectableChannel() invokes nd.preClose() after
 329                 //     this thread is blocked in read() but the operating
 330                 //     system (e.g., Linux) doesn't support preemptive close,
 331                 //     so implCloseSelectableChannel() proceeds to signal this
 332                 //     thread, thereby causing the read to return immediately
 333                 //     with IOStatus.INTERRUPTED.
 334                 //
 335                 // In all three cases the invocation of end() in the finally
 336                 // clause will notice that the channel has been closed and
 337                 // throw an appropriate exception (AsynchronousCloseException
 338                 // or ClosedByInterruptException) if necessary.
 339                 //
 340                 // *There is A fourth possibility. implCloseSelectableChannel()
 341                 // invokes nd.preClose(), signals reader/writer thred and quickly
 342                 // moves on to nd.close() in kill(), which does a real close.
 343                 // Then a third thread accepts a new connection, opens file or
 344                 // whatever that causes the released "fd" to be recycled. All
 345                 // above happens just between our last isOpen() check and the
 346                 // next kernel read reached, with the recycled "fd". The solution
 347                 // is to postpone the real kill() if there is a reader or/and
 348                 // writer thread(s) over there "waiting", leave the cleanup/kill
 349                 // to the reader or writer thread. (the preClose() still happens
 350                 // so the connection gets cut off as usual).
 351                 //
 352                 // For socket channels there is the additional wrinkle that
 353                 // asynchronous shutdown works much like asynchronous close,
 354                 // except that the channel is shutdown rather than completely
 355                 // closed.  This is analogous to the first two cases above,
 356                 // except that the shutdown operation plays the role of
 357                 // nd.preClose().
 358                 for (;;) {
 359                     n = IOUtil.read(fd, buf, -1, nd, readLock);
 360                     if ((n == IOStatus.INTERRUPTED) && isOpen()) {
 361                         // The system call was interrupted but the channel
 362                         // is still open, so retry
 363                         continue;
 364                     }
 365                     return IOStatus.normalize(n);
 366                 }
 367 
 368             } finally {
 369                 readerCleanup();        // Clear reader thread
 370                 // The end method, which is defined in our superclass
 371                 // AbstractInterruptibleChannel, resets the interruption
 372                 // machinery.  If its argument is true then it returns
 373                 // normally; otherwise it checks the interrupt and open state
 374                 // of this channel and throws an appropriate exception if
 375                 // necessary.
 376                 //
 377                 // So, if we actually managed to do any I/O in the above try
 378                 // block then we pass true to the end method.  We also pass
 379                 // true if the channel was in non-blocking mode when the I/O
 380                 // operation was initiated but no data could be transferred;
 381                 // this prevents spurious exceptions from being thrown in the
 382                 // rare event that a channel is closed or a thread is
 383                 // interrupted at the exact moment that a non-blocking I/O
 384                 // request is made.
 385                 //
 386                 end(n > 0 || (n == IOStatus.UNAVAILABLE));
 387 
 388                 // Extra case for socket channels: Asynchronous shutdown
 389                 //
 390                 synchronized (stateLock) {
 391                     if ((n <= 0) && (!isInputOpen))
 392                         return IOStatus.EOF;
 393                 }
 394 
 395                 assert IOStatus.check(n);
 396 
 397             }
 398         }
 399     }
 400 
 401     public long read(ByteBuffer[] dsts, int offset, int length)
 402         throws IOException
 403     {
 404         if ((offset < 0) || (length < 0) || (offset > dsts.length - length))
 405             throw new IndexOutOfBoundsException();
 406         synchronized (readLock) {
 407             if (!ensureReadOpen())
 408                 return -1;
 409             long n = 0;
 410             try {
 411                 begin();
 412                 synchronized (stateLock) {
 413                     if (!isOpen())
 414                         return 0;
 415                     readerThread = NativeThread.current();
 416                 }
 417 
 418                 for (;;) {
 419                     n = IOUtil.read(fd, dsts, offset, length, nd);
 420                     if ((n == IOStatus.INTERRUPTED) && isOpen())
 421                         continue;
 422                     return IOStatus.normalize(n);
 423                 }
 424             } finally {
 425                 readerCleanup();
 426                 end(n > 0 || (n == IOStatus.UNAVAILABLE));
 427                 synchronized (stateLock) {
 428                     if ((n <= 0) && (!isInputOpen))
 429                         return IOStatus.EOF;
 430                 }
 431                 assert IOStatus.check(n);
 432             }
 433         }
 434     }
 435 
 436     public int write(ByteBuffer buf) throws IOException {
 437         if (buf == null)
 438             throw new NullPointerException();
 439         synchronized (writeLock) {
 440             ensureWriteOpen();
 441             int n = 0;
 442             try {
 443                 begin();
 444                 synchronized (stateLock) {
 445                     if (!isOpen())
 446                         return 0;
 447                     writerThread = NativeThread.current();
 448                 }
 449                 for (;;) {
 450                     n = IOUtil.write(fd, buf, -1, nd, writeLock);
 451                     if ((n == IOStatus.INTERRUPTED) && isOpen())
 452                         continue;
 453                     return IOStatus.normalize(n);
 454                 }
 455             } finally {
 456                 writerCleanup();
 457                 end(n > 0 || (n == IOStatus.UNAVAILABLE));
 458                 synchronized (stateLock) {
 459                     if ((n <= 0) && (!isOutputOpen))
 460                         throw new AsynchronousCloseException();
 461                 }
 462                 assert IOStatus.check(n);
 463             }
 464         }
 465     }
 466 
 467     public long write(ByteBuffer[] srcs, int offset, int length)
 468         throws IOException
 469     {
 470         if ((offset < 0) || (length < 0) || (offset > srcs.length - length))
 471             throw new IndexOutOfBoundsException();
 472         synchronized (writeLock) {
 473             ensureWriteOpen();
 474             long n = 0;
 475             try {
 476                 begin();
 477                 synchronized (stateLock) {
 478                     if (!isOpen())
 479                         return 0;
 480                     writerThread = NativeThread.current();
 481                 }
 482                 for (;;) {
 483                     n = IOUtil.write(fd, srcs, offset, length, nd);
 484                     if ((n == IOStatus.INTERRUPTED) && isOpen())
 485                         continue;
 486                     return IOStatus.normalize(n);
 487                 }
 488             } finally {
 489                 writerCleanup();
 490                 end((n > 0) || (n == IOStatus.UNAVAILABLE));
 491                 synchronized (stateLock) {
 492                     if ((n <= 0) && (!isOutputOpen))
 493                         throw new AsynchronousCloseException();
 494                 }
 495                 assert IOStatus.check(n);
 496             }
 497         }
 498     }
 499 
 500     // package-private
 501     int sendOutOfBandData(byte b) throws IOException {
 502         synchronized (writeLock) {
 503             ensureWriteOpen();
 504             int n = 0;
 505             try {
 506                 begin();
 507                 synchronized (stateLock) {
 508                     if (!isOpen())
 509                         return 0;
 510                     writerThread = NativeThread.current();
 511                 }
 512                 for (;;) {
 513                     n = sendOutOfBandData(fd, b);
 514                     if ((n == IOStatus.INTERRUPTED) && isOpen())
 515                         continue;
 516                     return IOStatus.normalize(n);
 517                 }
 518             } finally {
 519                 writerCleanup();
 520                 end((n > 0) || (n == IOStatus.UNAVAILABLE));
 521                 synchronized (stateLock) {
 522                     if ((n <= 0) && (!isOutputOpen))
 523                         throw new AsynchronousCloseException();
 524                 }
 525                 assert IOStatus.check(n);
 526             }
 527         }
 528     }
 529 
 530     protected void implConfigureBlocking(boolean block) throws IOException {
 531         IOUtil.configureBlocking(fd, block);
 532     }
 533 
 534     public SocketAddress localAddress() {
 535         synchronized (stateLock) {
 536             return localAddress;
 537         }
 538     }
 539 
 540     public SocketAddress remoteAddress() {
 541         synchronized (stateLock) {
 542             return remoteAddress;
 543         }
 544     }
 545 
 546     @Override
 547     public SocketChannel bind(SocketAddress local) throws IOException {
 548         synchronized (readLock) {
 549             synchronized (writeLock) {
 550                 synchronized (stateLock) {
 551                     if (!isOpen())
 552                         throw new ClosedChannelException();
 553                     if (state == ST_PENDING)
 554                         throw new ConnectionPendingException();
 555                     if (localAddress != null)
 556                         throw new AlreadyBoundException();
 557                     InetSocketAddress isa = (local == null) ?
 558                         new InetSocketAddress(0) : Net.checkAddress(local);
 559                     NetHooks.beforeTcpBind(fd, isa.getAddress(), isa.getPort());
 560                     Net.bind(fd, isa.getAddress(), isa.getPort());
 561                     localAddress = Net.localAddress(fd);
 562                 }
 563             }
 564         }
 565         return this;
 566     }
 567 
 568     public boolean isConnected() {
 569         synchronized (stateLock) {
 570             return (state == ST_CONNECTED);
 571         }
 572     }
 573 
 574     public boolean isConnectionPending() {
 575         synchronized (stateLock) {
 576             return (state == ST_PENDING);
 577         }
 578     }
 579 
 580     void ensureOpenAndUnconnected() throws IOException { // package-private
 581         synchronized (stateLock) {
 582             if (!isOpen())
 583                 throw new ClosedChannelException();
 584             if (state == ST_CONNECTED)
 585                 throw new AlreadyConnectedException();
 586             if (state == ST_PENDING)
 587                 throw new ConnectionPendingException();
 588         }
 589     }
 590 
 591     public boolean connect(SocketAddress sa) throws IOException {
 592         int localPort = 0;
 593 
 594         synchronized (readLock) {
 595             synchronized (writeLock) {
 596                 ensureOpenAndUnconnected();
 597                 InetSocketAddress isa = Net.checkAddress(sa);
 598                 SecurityManager sm = System.getSecurityManager();
 599                 if (sm != null)
 600                     sm.checkConnect(isa.getAddress().getHostAddress(),
 601                                     isa.getPort());
 602                 synchronized (blockingLock()) {
 603                     int n = 0;
 604                     try {
 605                         try {
 606                             begin();
 607                             synchronized (stateLock) {
 608                                 if (!isOpen()) {
 609                                     return false;
 610                                 }
 611                                 // notify hook only if unbound
 612                                 if (localAddress == null) {
 613                                     NetHooks.beforeTcpConnect(fd,
 614                                                            isa.getAddress(),
 615                                                            isa.getPort());
 616                                 }
 617                                 readerThread = NativeThread.current();
 618                             }
 619                             for (;;) {
 620                                 InetAddress ia = isa.getAddress();
 621                                 if (ia.isAnyLocalAddress())
 622                                     ia = InetAddress.getLocalHost();
 623                                 n = Net.connect(fd,
 624                                                 ia,
 625                                                 isa.getPort());
 626                                 if (  (n == IOStatus.INTERRUPTED)
 627                                       && isOpen())
 628                                     continue;
 629                                 break;
 630                             }
 631 
 632                             synchronized (stateLock) {
 633                                 if (isOpen() && (localAddress == null) ||
 634                                     ((InetSocketAddress)localAddress)
 635                                         .getAddress().isAnyLocalAddress())
 636                                 {
 637                                     // Socket was not bound before connecting or
 638                                     // Socket was bound with an "anyLocalAddress"
 639                                     localAddress = Net.localAddress(fd);
 640                                 }
 641                             }
 642 
 643                         } finally {
 644                             readerCleanup();
 645                             end((n > 0) || (n == IOStatus.UNAVAILABLE));
 646                             assert IOStatus.check(n);
 647                         }
 648                     } catch (IOException x) {
 649                         // If an exception was thrown, close the channel after
 650                         // invoking end() so as to avoid bogus
 651                         // AsynchronousCloseExceptions
 652                         close();
 653                         throw x;
 654                     }
 655                     synchronized (stateLock) {
 656                         remoteAddress = isa;
 657                         if (n > 0) {
 658 
 659                             // Connection succeeded; disallow further
 660                             // invocation
 661                             state = ST_CONNECTED;
 662                             return true;
 663                         }
 664                         // If nonblocking and no exception then connection
 665                         // pending; disallow another invocation
 666                         if (!isBlocking())
 667                             state = ST_PENDING;
 668                         else
 669                             assert false;
 670                     }
 671                 }
 672                 return false;
 673             }
 674         }
 675     }
 676 
 677     public boolean finishConnect() throws IOException {
 678         synchronized (readLock) {
 679             synchronized (writeLock) {
 680                 synchronized (stateLock) {
 681                     if (!isOpen())
 682                         throw new ClosedChannelException();
 683                     if (state == ST_CONNECTED)
 684                         return true;
 685                     if (state != ST_PENDING)
 686                         throw new NoConnectionPendingException();
 687                 }
 688                 int n = 0;
 689                 try {
 690                     try {
 691                         begin();
 692                         synchronized (blockingLock()) {
 693                             synchronized (stateLock) {
 694                                 if (!isOpen()) {
 695                                     return false;
 696                                 }
 697                                 readerThread = NativeThread.current();
 698                             }
 699                             if (!isBlocking()) {
 700                                 for (;;) {
 701                                     n = checkConnect(fd, false,
 702                                                      readyToConnect);
 703                                     if (  (n == IOStatus.INTERRUPTED)
 704                                           && isOpen())
 705                                         continue;
 706                                     break;
 707                                 }
 708                             } else {
 709                                 for (;;) {
 710                                     n = checkConnect(fd, true,
 711                                                      readyToConnect);
 712                                     if (n == 0) {
 713                                         // Loop in case of
 714                                         // spurious notifications
 715                                         continue;
 716                                     }
 717                                     if (  (n == IOStatus.INTERRUPTED)
 718                                           && isOpen())
 719                                         continue;
 720                                     break;
 721                                 }
 722                             }
 723                         }
 724                     } finally {
 725                         synchronized (stateLock) {
 726                             readerThread = 0;
 727                             if (state == ST_KILLPENDING) {
 728                                 kill();
 729                                 // poll()/getsockopt() does not report
 730                                 // error (throws exception, with n = 0)
 731                                 // on Linux platform after dup2 and
 732                                 // signal-wakeup. Force n to 0 so the
 733                                 // end() can throw appropriate exception
 734                                 n = 0;
 735                             }
 736                         }
 737                         end((n > 0) || (n == IOStatus.UNAVAILABLE));
 738                         assert IOStatus.check(n);
 739                     }
 740                 } catch (IOException x) {
 741                 
   1 /*
   2  * Copyright (c) 2000, 2010, 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 sun.nio.ch;
  27 
  28 import java.io.FileDescriptor;
  29 import java.io.IOException;
  30 import java.net.*;
  31 import java.nio.ByteBuffer;
  32 import java.nio.channels.*;
  33 import java.nio.channels.spi.*;
  34 import java.util.*;
  35 import sun.net.NetHooks;
  36 
  37 
  38 /**
  39  * An implementation of SocketChannels
  40  */
  41 
  42 class SocketChannelImpl
  43     extends SocketChannel
  44     implements SelChImpl
  45 {
  46 
  47     // Used to make native read and write calls
  48     private static NativeDispatcher nd;
  49 
  50     // Our file descriptor object
  51     private final FileDescriptor fd;
  52 
  53     // fd value needed for dev/poll. This value will remain valid
  54     // even after the value in the file descriptor object has been set to -1
  55     private final int fdVal;
  56 
  57     // IDs of native threads doing reads and writes, for signalling
  58     private volatile long readerThread = 0;
  59     private volatile long writerThread = 0;
  60 
  61     // Lock held by current reading or connecting thread
  62     private final Object readLock = new Object();
  63 
  64     // Lock held by current writing or connecting thread
  65     private final Object writeLock = new Object();
  66 
  67     // Lock held by any thread that modifies the state fields declared below
  68     // DO NOT invoke a blocking I/O operation while holding this lock!
  69     private final Object stateLock = new Object();
  70 
  71     // -- The following fields are protected by stateLock
  72 
  73     // State, increases monotonically
  74     private static final int ST_UNINITIALIZED = -1;
  75     private static final int ST_UNCONNECTED = 0;
  76     private static final int ST_PENDING = 1;
  77     private static final int ST_CONNECTED = 2;
  78     private static final int ST_KILLPENDING = 3;
  79     private static final int ST_KILLED = 4;
  80     private int state = ST_UNINITIALIZED;
  81 
  82     // Binding
  83     private SocketAddress localAddress;
  84     private SocketAddress remoteAddress;
  85 
  86     // Input/Output open
  87     private boolean isInputOpen = true;
  88     private boolean isOutputOpen = true;
  89     private boolean readyToConnect = false;
  90 
  91     // Socket adaptor, created on demand
  92     private Socket socket;
  93 
  94     // -- End of fields protected by stateLock
  95 
  96 
  97     // Constructor for normal connecting sockets
  98     //
  99     SocketChannelImpl(SelectorProvider sp) throws IOException {
 100         super(sp);
 101         this.fd = Net.socket(true);
 102         this.fdVal = IOUtil.fdVal(fd);
 103         this.state = ST_UNCONNECTED;
 104     }
 105 
 106     SocketChannelImpl(SelectorProvider sp,
 107                       FileDescriptor fd,
 108                       boolean bound)
 109         throws IOException
 110     {
 111         super(sp);
 112         this.fd = fd;
 113         this.fdVal = IOUtil.fdVal(fd);
 114         this.state = ST_UNCONNECTED;
 115         if (bound)
 116             this.localAddress = Net.localAddress(fd);
 117     }
 118 
 119     // Constructor for sockets obtained from server sockets
 120     //
 121     SocketChannelImpl(SelectorProvider sp,
 122                       FileDescriptor fd, InetSocketAddress remote)
 123         throws IOException
 124     {
 125         super(sp);
 126         this.fd = fd;
 127         this.fdVal = IOUtil.fdVal(fd);
 128         this.state = ST_CONNECTED;
 129         this.localAddress = Net.localAddress(fd);
 130         this.remoteAddress = remote;
 131     }
 132 
 133     public Socket socket() {
 134         synchronized (stateLock) {
 135             if (socket == null)
 136                 socket = SocketAdaptor.create(this);
 137             return socket;
 138         }
 139     }
 140 
 141     @Override
 142     public SocketAddress getLocalAddress() throws IOException {
 143         synchronized (stateLock) {
 144             if (!isOpen())
 145                 throw new ClosedChannelException();
 146             return localAddress;
 147         }
 148     }
 149 
 150     @Override
 151     public SocketAddress getRemoteAddress() throws IOException {
 152         synchronized (stateLock) {
 153             if (!isOpen())
 154                 throw new ClosedChannelException();
 155             return remoteAddress;
 156         }
 157     }
 158 
 159     @Override
 160     public <T> SocketChannel setOption(SocketOption<T> name, T value)
 161         throws IOException
 162     {
 163         if (name == null)
 164             throw new NullPointerException();
 165         if (!supportedOptions().contains(name))
 166             throw new UnsupportedOperationException("'" + name + "' not supported");
 167 
 168         synchronized (stateLock) {
 169             if (!isOpen())
 170                 throw new ClosedChannelException();
 171 
 172             // special handling for IP_TOS: no-op when IPv6
 173             if (name == StandardSocketOption.IP_TOS) {
 174                 if (!Net.isIPv6Available())
 175                     Net.setSocketOption(fd, StandardProtocolFamily.INET, name, value);
 176                 return this;
 177             }
 178 
 179             // no options that require special handling
 180             Net.setSocketOption(fd, Net.UNSPEC, name, value);
 181             return this;
 182         }
 183     }
 184 
 185     @Override
 186     @SuppressWarnings("unchecked")
 187     public <T> T getOption(SocketOption<T> name)
 188         throws IOException
 189     {
 190         if (name == null)
 191             throw new NullPointerException();
 192         if (!supportedOptions().contains(name))
 193             throw new UnsupportedOperationException("'" + name + "' not supported");
 194 
 195         synchronized (stateLock) {
 196             if (!isOpen())
 197                 throw new ClosedChannelException();
 198 
 199             // special handling for IP_TOS: always return 0 when IPv6
 200             if (name == StandardSocketOption.IP_TOS) {
 201                 return (Net.isIPv6Available()) ? (T) Integer.valueOf(0) :
 202                     (T) Net.getSocketOption(fd, StandardProtocolFamily.INET, name);
 203             }
 204 
 205             // no options that require special handling
 206             return (T) Net.getSocketOption(fd, Net.UNSPEC, name);
 207         }
 208     }
 209 
 210     private static class DefaultOptionsHolder {
 211         static final Set<SocketOption<?>> defaultOptions = defaultOptions();
 212 
 213         private static Set<SocketOption<?>> defaultOptions() {
 214             HashSet<SocketOption<?>> set = new HashSet<SocketOption<?>>(8);
 215             set.add(StandardSocketOption.SO_SNDBUF);
 216             set.add(StandardSocketOption.SO_RCVBUF);
 217             set.add(StandardSocketOption.SO_KEEPALIVE);
 218             set.add(StandardSocketOption.SO_REUSEADDR);
 219             set.add(StandardSocketOption.SO_LINGER);
 220             set.add(StandardSocketOption.TCP_NODELAY);
 221             // additional options required by socket adaptor
 222             set.add(StandardSocketOption.IP_TOS);
 223             set.add(ExtendedSocketOption.SO_OOBINLINE);
 224             return Collections.unmodifiableSet(set);
 225         }
 226     }
 227 
 228     @Override
 229     public final Set<SocketOption<?>> supportedOptions() {
 230         return DefaultOptionsHolder.defaultOptions;
 231     }
 232 
 233     private boolean ensureReadOpen() throws ClosedChannelException {
 234         synchronized (stateLock) {
 235             if (!isOpen())
 236                 throw new ClosedChannelException();
 237             if (!isConnected())
 238                 throw new NotYetConnectedException();
 239             if (!isInputOpen)
 240                 return false;
 241             else
 242                 return true;
 243         }
 244     }
 245 
 246     private void ensureWriteOpen() throws ClosedChannelException {
 247         synchronized (stateLock) {
 248             if (!isOpen())
 249                 throw new ClosedChannelException();
 250             if (!isOutputOpen)
 251                 throw new ClosedChannelException();
 252             if (!isConnected())
 253                 throw new NotYetConnectedException();
 254         }
 255     }
 256 
 257     private void readerCleanup() throws IOException {
 258         synchronized (stateLock) {
 259             readerThread = 0;
 260             if (state == ST_KILLPENDING)
 261                 kill();
 262         }
 263     }
 264 
 265     private void writerCleanup() throws IOException {
 266         synchronized (stateLock) {
 267             writerThread = 0;
 268             if (state == ST_KILLPENDING)
 269                 kill();
 270         }
 271     }
 272 
 273     public int read(ByteBuffer buf) throws IOException {
 274 
 275         if (buf == null)
 276             throw new NullPointerException();
 277 
 278         synchronized (readLock) {
 279             if (!ensureReadOpen())
 280                 return -1;
 281             int n = 0;
 282             try {
 283 
 284                 // Set up the interruption machinery; see
 285                 // AbstractInterruptibleChannel for details
 286                 //
 287                 begin();
 288 
 289                 synchronized (stateLock) {
 290                     if (!isOpen()) {
 291                     // Either the current thread is already interrupted, so
 292                     // begin() closed the channel, or another thread closed the
 293                     // channel since we checked it a few bytecodes ago.  In
 294                     // either case the value returned here is irrelevant since
 295                     // the invocation of end() in the finally block will throw
 296                     // an appropriate exception.
 297                     //
 298                         return 0;
 299 
 300                     }
 301 
 302                     // Save this thread so that it can be signalled on those
 303                     // platforms that require it
 304                     //
 305                     readerThread = NativeThread.current();
 306                 }
 307 
 308                 // Between the previous test of isOpen() and the return of the
 309                 // IOUtil.read invocation below, this channel might be closed
 310                 // or this thread might be interrupted.  We rely upon the
 311                 // implicit synchronization point in the kernel read() call to
 312                 // make sure that the right thing happens.  In either case the
 313                 // implCloseSelectableChannel method is ultimately invoked in
 314                 // some other thread, so there are three possibilities:
 315                 //
 316                 //   - implCloseSelectableChannel() invokes nd.preClose()
 317                 //     before this thread invokes read(), in which case the
 318                 //     read returns immediately with either EOF or an error,
 319                 //     the latter of which will cause an IOException to be
 320                 //     thrown.
 321                 //
 322                 //   - implCloseSelectableChannel() invokes nd.preClose() after
 323                 //     this thread is blocked in read().  On some operating
 324                 //     systems (e.g., Solaris and Windows) this causes the read
 325                 //     to return immediately with either EOF or an error
 326                 //     indication.
 327                 //
 328                 //   - implCloseSelectableChannel() invokes nd.preClose() after
 329                 //     this thread is blocked in read() but the operating
 330                 //     system (e.g., Linux) doesn't support preemptive close,
 331                 //     so implCloseSelectableChannel() proceeds to signal this
 332                 //     thread, thereby causing the read to return immediately
 333                 //     with IOStatus.INTERRUPTED.
 334                 //
 335                 // In all three cases the invocation of end() in the finally
 336                 // clause will notice that the channel has been closed and
 337                 // throw an appropriate exception (AsynchronousCloseException
 338                 // or ClosedByInterruptException) if necessary.
 339                 //
 340                 // *There is A fourth possibility. implCloseSelectableChannel()
 341                 // invokes nd.preClose(), signals reader/writer thred and quickly
 342                 // moves on to nd.close() in kill(), which does a real close.
 343                 // Then a third thread accepts a new connection, opens file or
 344                 // whatever that causes the released "fd" to be recycled. All
 345                 // above happens just between our last isOpen() check and the
 346                 // next kernel read reached, with the recycled "fd". The solution
 347                 // is to postpone the real kill() if there is a reader or/and
 348                 // writer thread(s) over there "waiting", leave the cleanup/kill
 349                 // to the reader or writer thread. (the preClose() still happens
 350                 // so the connection gets cut off as usual).
 351                 //
 352                 // For socket channels there is the additional wrinkle that
 353                 // asynchronous shutdown works much like asynchronous close,
 354                 // except that the channel is shutdown rather than completely
 355                 // closed.  This is analogous to the first two cases above,
 356                 // except that the shutdown operation plays the role of
 357                 // nd.preClose().
 358                 for (;;) {
 359                     n = IOUtil.read(fd, buf, -1, nd, readLock);
 360                     if ((n == IOStatus.INTERRUPTED) && isOpen()) {
 361                         // The system call was interrupted but the channel
 362                         // is still open, so retry
 363                         continue;
 364                     }
 365                     return IOStatus.normalize(n);
 366                 }
 367 
 368             } finally {
 369                 readerCleanup();        // Clear reader thread
 370                 // The end method, which is defined in our superclass
 371                 // AbstractInterruptibleChannel, resets the interruption
 372                 // machinery.  If its argument is true then it returns
 373                 // normally; otherwise it checks the interrupt and open state
 374                 // of this channel and throws an appropriate exception if
 375                 // necessary.
 376                 //
 377                 // So, if we actually managed to do any I/O in the above try
 378                 // block then we pass true to the end method.  We also pass
 379                 // true if the channel was in non-blocking mode when the I/O
 380                 // operation was initiated but no data could be transferred;
 381                 // this prevents spurious exceptions from being thrown in the
 382                 // rare event that a channel is closed or a thread is
 383                 // interrupted at the exact moment that a non-blocking I/O
 384                 // request is made.
 385                 //
 386                 end(n > 0 || (n == IOStatus.UNAVAILABLE));
 387 
 388                 // Extra case for socket channels: Asynchronous shutdown
 389                 //
 390                 synchronized (stateLock) {
 391                     if ((n <= 0) && (!isInputOpen))
 392                         return IOStatus.EOF;
 393                 }
 394 
 395                 assert IOStatus.check(n);
 396 
 397             }
 398         }
 399     }
 400 
 401     public long read(ByteBuffer[] dsts, int offset, int length)
 402         throws IOException
 403     {
 404         if ((offset < 0) || (length < 0) || (offset > dsts.length - length))
 405             throw new IndexOutOfBoundsException();
 406         synchronized (readLock) {
 407             if (!ensureReadOpen())
 408                 return -1;
 409             long n = 0;
 410             try {
 411                 begin();
 412                 synchronized (stateLock) {
 413                     if (!isOpen())
 414                         return 0;
 415                     readerThread = NativeThread.current();
 416                 }
 417 
 418                 for (;;) {
 419                     n = IOUtil.read(fd, dsts, offset, length, nd);
 420                     if ((n == IOStatus.INTERRUPTED) && isOpen())
 421                         continue;
 422                     return IOStatus.normalize(n);
 423                 }
 424             } finally {
 425                 readerCleanup();
 426                 end(n > 0 || (n == IOStatus.UNAVAILABLE));
 427                 synchronized (stateLock) {
 428                     if ((n <= 0) && (!isInputOpen))
 429                         return IOStatus.EOF;
 430                 }
 431                 assert IOStatus.check(n);
 432             }
 433         }
 434     }
 435 
 436     public int write(ByteBuffer buf) throws IOException {
 437         if (buf == null)
 438             throw new NullPointerException();
 439         synchronized (writeLock) {
 440             ensureWriteOpen();
 441             int n = 0;
 442             try {
 443                 begin();
 444                 synchronized (stateLock) {
 445                     if (!isOpen())
 446                         return 0;
 447                     writerThread = NativeThread.current();
 448                 }
 449                 for (;;) {
 450                     n = IOUtil.write(fd, buf, -1, nd, writeLock);
 451                     if ((n == IOStatus.INTERRUPTED) && isOpen())
 452                         continue;
 453                     return IOStatus.normalize(n);
 454                 }
 455             } finally {
 456                 writerCleanup();
 457                 end(n > 0 || (n == IOStatus.UNAVAILABLE));
 458                 synchronized (stateLock) {
 459                     if ((n <= 0) && (!isOutputOpen))
 460                         throw new AsynchronousCloseException();
 461                 }
 462                 assert IOStatus.check(n);
 463             }
 464         }
 465     }
 466 
 467     public long write(ByteBuffer[] srcs, int offset, int length)
 468         throws IOException
 469     {
 470         if ((offset < 0) || (length < 0) || (offset > srcs.length - length))
 471             throw new IndexOutOfBoundsException();
 472         synchronized (writeLock) {
 473             ensureWriteOpen();
 474             long n = 0;
 475             try {
 476                 begin();
 477                 synchronized (stateLock) {
 478                     if (!isOpen())
 479                         return 0;
 480                     writerThread = NativeThread.current();
 481                 }
 482                 for (;;) {
 483                     n = IOUtil.write(fd, srcs, offset, length, nd);
 484                     if ((n == IOStatus.INTERRUPTED) && isOpen())
 485                         continue;
 486                     return IOStatus.normalize(n);
 487                 }
 488             } finally {
 489                 writerCleanup();
 490                 end((n > 0) || (n == IOStatus.UNAVAILABLE));
 491                 synchronized (stateLock) {
 492                     if ((n <= 0) && (!isOutputOpen))
 493                         throw new AsynchronousCloseException();
 494                 }
 495                 assert IOStatus.check(n);
 496             }
 497         }
 498     }
 499 
 500     // package-private
 501     int sendOutOfBandData(byte b) throws IOException {
 502         synchronized (writeLock) {
 503             ensureWriteOpen();
 504             int n = 0;
 505             try {
 506                 begin();
 507                 synchronized (stateLock) {
 508                     if (!isOpen())
 509                         return 0;
 510                     writerThread = NativeThread.current();
 511                 }
 512                 for (;;) {
 513                     n = sendOutOfBandData(fd, b);
 514                     if ((n == IOStatus.INTERRUPTED) && isOpen())
 515                         continue;
 516                     return IOStatus.normalize(n);
 517                 }
 518             } finally {
 519                 writerCleanup();
 520                 end((n > 0) || (n == IOStatus.UNAVAILABLE));
 521                 synchronized (stateLock) {
 522                     if ((n <= 0) && (!isOutputOpen))
 523                         throw new AsynchronousCloseException();
 524                 }
 525                 assert IOStatus.check(n);
 526             }
 527         }
 528     }
 529 
 530     protected void implConfigureBlocking(boolean block) throws IOException {
 531         IOUtil.configureBlocking(fd, block);
 532     }
 533 
 534     public SocketAddress localAddress() {
 535         synchronized (stateLock) {
 536             return localAddress;
 537         }
 538     }
 539 
 540     public SocketAddress remoteAddress() {
 541         synchronized (stateLock) {
 542             return remoteAddress;
 543         }
 544     }
 545 
 546     @Override
 547     public SocketChannel bind(SocketAddress local) throws IOException {
 548         synchronized (readLock) {
 549             synchronized (writeLock) {
 550                 synchronized (stateLock) {
 551                     if (!isOpen())
 552                         throw new ClosedChannelException();
 553                     if (state == ST_PENDING)
 554                         throw new ConnectionPendingException();
 555                     if (localAddress != null)
 556                         throw new AlreadyBoundException();
 557                     InetSocketAddress isa = (local == null) ?
 558                         new InetSocketAddress(0) : Net.checkAddress(local);
 559                     NetHooks.beforeTcpBind(fd, isa.getAddress(), isa.getPort());
 560                     Net.bind(fd, isa.getAddress(), isa.getPort());
 561                     localAddress = Net.localAddress(fd);
 562                 }
 563             }
 564         }
 565         return this;
 566     }
 567 
 568     public boolean isConnected() {
 569         synchronized (stateLock) {
 570             return (state == ST_CONNECTED);
 571         }
 572     }
 573 
 574     public boolean isConnectionPending() {
 575         synchronized (stateLock) {
 576             return (state == ST_PENDING);
 577         }
 578     }
 579 
 580     void ensureOpenAndUnconnected() throws IOException { // package-private
 581         synchronized (stateLock) {
 582             if (!isOpen())
 583                 throw new ClosedChannelException();
 584             if (state == ST_CONNECTED)
 585                 throw new AlreadyConnectedException();
 586             if (state == ST_PENDING)
 587                 throw new ConnectionPendingException();
 588         }
 589     }
 590 
 591     public boolean connect(SocketAddress sa) throws IOException {
 592         int localPort = 0;
 593 
 594         synchronized (readLock) {
 595             synchronized (writeLock) {
 596                 ensureOpenAndUnconnected();
 597                 InetSocketAddress isa = Net.checkAddress(sa);
 598                 SecurityManager sm = System.getSecurityManager();
 599                 if (sm != null)
 600                     sm.checkConnect(isa.getAddress().getHostAddress(),
 601                                     isa.getPort());
 602                 synchronized (blockingLock()) {
 603                     int n = 0;
 604                     try {
 605                         try {
 606                             begin();
 607                             synchronized (stateLock) {
 608                                 if (!isOpen()) {
 609                                     return false;
 610                                 }
 611                                 // notify hook only if unbound
 612                                 if (localAddress == null) {
 613                                     NetHooks.beforeTcpConnect(fd,
 614                                                            isa.getAddress(),
 615                                                            isa.getPort());
 616                                 }
 617                                 readerThread = NativeThread.current();
 618                             }
 619                             for (;;) {
 620                                 InetAddress ia = isa.getAddress();
 621                                 if (ia.isAnyLocalAddress())
 622                                     ia = InetAddress.getLocalHost();
 623                                 n = Net.connect(fd,
 624                                                 ia,
 625                                                 isa.getPort());
 626                                 if (  (n == IOStatus.INTERRUPTED)
 627                                       && isOpen())
 628                                     continue;
 629                                 break;
 630                             }
 631 
 632                             synchronized (stateLock) {
 633                                 if (isOpen() && (localAddress == null) ||
 634                                     ((InetSocketAddress)localAddress)
 635                                         .getAddress().isAnyLocalAddress())
 636                                 {
 637                                     // Socket was not bound before connecting or
 638                                     // Socket was bound with an "anyLocalAddress"
 639                                     localAddress = Net.localAddress(fd);
 640                                 }
 641                             }
 642 
 643                         } finally {
 644                             readerCleanup();
 645                             end((n > 0) || (n == IOStatus.UNAVAILABLE));
 646                             assert IOStatus.check(n);
 647                         }
 648                     } catch (IOException x) {
 649                         // If an exception was thrown, close the channel after
 650                         // invoking end() so as to avoid bogus
 651                         // AsynchronousCloseExceptions
 652                         close();
 653                         throw x;
 654                     }
 655                     synchronized (stateLock) {
 656                         remoteAddress = isa;
 657                         if (n > 0) {
 658 
 659                             // Connection succeeded; disallow further
 660                             // invocation
 661                             state = ST_CONNECTED;
 662                             return true;
 663                         }
 664                         // If nonblocking and no exception then connection
 665                         // pending; disallow another invocation
 666                         if (!isBlocking())
 667                             state = ST_PENDING;
 668                         else
 669                             assert false;
 670                     }
 671                 }
 672                 return false;
 673             }
 674         }
 675     }
 676 
 677     public boolean finishConnect() throws IOException {
 678         synchronized (readLock) {
 679             synchronized (writeLock) {
 680                 synchronized (stateLock) {
 681                     if (!isOpen())
 682                         throw new ClosedChannelException();
 683                     if (state == ST_CONNECTED)
 684                         return true;
 685                     if (state != ST_PENDING)
 686                         throw new NoConnectionPendingException();
 687                 }
 688                 int n = 0;
 689                 try {
 690                     try {
 691                         begin();
 692                         synchronized (blockingLock()) {
 693                             synchronized (stateLock) {
 694                                 if (!isOpen()) {
 695                                     return false;
 696                                 }
 697                                 readerThread = NativeThread.current();
 698                             }
 699                             if (!isBlocking()) {
 700                                 for (;;) {
 701                                     n = checkConnect(fd, false,
 702                                                      readyToConnect);
 703                                     if (  (n == IOStatus.INTERRUPTED)
 704                                           && isOpen())
 705                                         continue;
 706                                     break;
 707                                 }
 708                             } else {
 709                                 for (;;) {
 710                                     n = checkConnect(fd, true,
 711                                                      readyToConnect);
 712                                     if (n == 0) {
 713                                         // Loop in case of
 714                                         // spurious notifications
 715                                         continue;
 716                                     }
 717                                     if (  (n == IOStatus.INTERRUPTED)
 718                                           && isOpen())
 719                                         continue;
 720                                     break;
 721                                 }
 722                             }
 723                         }
 724                     } finally {
 725                         synchronized (stateLock) {
 726                             readerThread = 0;
 727                             if (state == ST_KILLPENDING) {
 728                                 kill();
 729                                 // poll()/getsockopt() does not report
 730                                 // error (throws exception, with n = 0)
 731                                 // on Linux platform after dup2 and
 732                                 // signal-wakeup. Force n to 0 so the
 733                                 // end() can throw appropriate exception
 734                                 n = 0;
 735                             }
 736                         }
 737                         end((n > 0) || (n == IOStatus.UNAVAILABLE));
 738                         assert IOStatus.check(n);
 739                     }
 740                 } catch (IOException x) {
 741                     // If an exception was thrown, close the channel after
 742                     // invoking end() so as to avoid bogus
 743                     // AsynchronousCloseExceptions
 744                     close();
 745                     throw x;
 746                 }
 747                 if (n > 0) {
 748                     synchronized (stateLock) {
 749                         state = ST_CONNECTED;
 750                     }
 751                     return true;
 752                 }
 753                 return false;
 754             }
 755         }
 756     }
 757 
 758     @Override
 759     public SocketChannel shutdownInput() throws IOException {
 760         synchronized (stateLock) {
 761             if (!isOpen())
 762                 throw new ClosedChannelException();
 763             if (!isConnected())
 764                 throw new NotYetConnectedException();
 765             if (isInputOpen) {
 766                 Net.shutdown(fd, Net.SHUT_RD);
 767                 if (readerThread != 0)
 768                     NativeThread.signal(readerThread);
 769                 isInputOpen = false;
 770             }
 771             return this;
 772         }
 773     }
 774 
 775     @Override
 776     public SocketChannel shutdownOutput() throws IOException {
 777         synchronized (stateLock) {
 778             if (!isOpen())
 779                 throw new ClosedChannelException();
 780             if (!isConnected())
 781                 throw new NotYetConnectedException();
 782             if (isOutputOpen) {
 783                 Net.shutdown(fd, Net.SHUT_WR);
 784                 if (writerThread != 0)
 785                     NativeThread.signal(writerThread);
 786                 isOutputOpen = false;
 787             }
 788             return this;
 789         }
 790     }
 791 
 792     public boolean isInputOpen() {
 793         synchronized (stateLock) {
 794             return isInputOpen;
 795         }
 796     }
 797 
 798     public boolean isOutputOpen() {
 799         synchronized (stateLock) {
 800             return isOutputOpen;
 801         }
 802     }
 803 
 804     // AbstractInterruptibleChannel synchronizes invocations of this method
 805     // using AbstractInterruptibleChannel.closeLock, and also ensures that this
 806     // method is only ever invoked once.  Before we get to this method, isOpen
 807     // (which is volatile) will have been set to false.
 808     //
 809     protected void implCloseSelectableChannel() throws IOException {
 810         synchronized (stateLock) {
 811             isInputOpen = false;
 812             isOutputOpen = false;
 813 
 814             // Close the underlying file descriptor and dup it to a known fd
 815             // that's already closed.  This prevents other operations on this
 816             // channel from using the old fd, which might be recycled in the
 817             // meantime and allocated to an entirely different channel.
 818             //
 819             nd.preClose(fd);
 820 
 821             // Signal native threads, if needed.  If a target thread is not
 822             // currently blocked in an I/O operation then no harm is done since
 823             // the signal handler doesn't actually do anything.
 824             //
 825             if (readerThread != 0)
 826                 NativeThread.signal(readerThread);
 827 
 828             if (writerThread != 0)
 829                 NativeThread.signal(writerThread);
 830 
 831             // If this channel is not registered then it's safe to close the fd
 832             // immediately since we know at this point that no thread is
 833             // blocked in an I/O operation upon the channel and, since the
 834             // channel is marked closed, no thread will start another such
 835             // operation.  If this channel is registered then we don't close
 836             // the fd since it might be in use by a selector.  In that case
 837             // closing this channel caused its keys to be cancelled, so the
 838             // last selector to deregister a key for this channel will invoke
 839             // kill() to close the fd.
 840             //
 841             if (!isRegistered())
 842                 kill();
 843         }
 844     }
 845 
 846     public void kill() throws IOException {
 847         synchronized (stateLock) {
 848             if (state == ST_KILLED)
 849                 return;
 850             if (state == ST_UNINITIALIZED) {
 851                 state = ST_KILLED;
 852                 return;
 853             }
 854             assert !isOpen() && !isRegistered();
 855 
 856             // Postpone the kill if there is a waiting reader
 857             // or writer thread. See the comments in read() for
 858             // more detailed explanation.
 859             if (readerThread == 0 && writerThread == 0) {
 860                 nd.close(fd);
 861                 state = ST_KILLED;
 862             } else {
 863                 state = ST_KILLPENDING;
 864             }
 865         }
 866     }
 867 
 868     /**
 869      * Translates native poll revent ops into a ready operation ops
 870      */
 871     public boolean translateReadyOps(int ops, int initialOps,
 872                                      SelectionKeyImpl sk) {
 873         int intOps = sk.nioInterestOps(); // Do this just once, it synchronizes
 874         int oldOps = sk.nioReadyOps();
 875         int newOps = initialOps;
 876 
 877         if ((ops & PollArrayWrapper.POLLNVAL) != 0) {
 878             // This should only happen if this channel is pre-closed while a
 879             // selection operation is in progress
 880             // ## Throw an error if this channel has not been pre-closed
 881             return false;
 882         }
 883 
 884         if ((ops & (PollArrayWrapper.POLLERR
 885                     | PollArrayWrapper.POLLHUP)) != 0) {
 886             newOps = intOps;
 887             sk.nioReadyOps(newOps);
 888             // No need to poll again in checkConnect,
 889             // the error will be detected there
 890             readyToConnect = true;
 891             return (newOps & ~oldOps) != 0;
 892         }
 893 
 894         if (((ops & PollArrayWrapper.POLLIN) != 0) &&
 895             ((intOps & SelectionKey.OP_READ) != 0) &&
 896             (state == ST_CONNECTED))
 897             newOps |= SelectionKey.OP_READ;
 898 
 899         if (((ops & PollArrayWrapper.POLLCONN) != 0) &&
 900             ((intOps & SelectionKey.OP_CONNECT) != 0) &&
 901             ((state == ST_UNCONNECTED) || (state == ST_PENDING))) {
 902             newOps |= SelectionKey.OP_CONNECT;
 903             readyToConnect = true;
 904         }
 905 
 906         if (((ops & PollArrayWrapper.POLLOUT) != 0) &&
 907             ((intOps & SelectionKey.OP_WRITE) != 0) &&
 908             (state == ST_CONNECTED))
 909             newOps |= SelectionKey.OP_WRITE;
 910 
 911         sk.nioReadyOps(newOps);
 912         return (newOps & ~oldOps) != 0;
 913     }
 914 
 915     public boolean translateAndUpdateReadyOps(int ops, SelectionKeyImpl sk) {
 916         return translateReadyOps(ops, sk.nioReadyOps(), sk);
 917     }
 918 
 919     public boolean translateAndSetReadyOps(int ops, SelectionKeyImpl sk) {
 920         return translateReadyOps(ops, 0, sk);
 921     }
 922 
 923     /**
 924      * Translates an interest operation set into a native poll event set
 925      */
 926     public void translateAndSetInterestOps(int ops, SelectionKeyImpl sk) {
 927         int newOps = 0;
 928         if ((ops & SelectionKey.OP_READ) != 0)
 929             newOps |= PollArrayWrapper.POLLIN;
 930         if ((ops & SelectionKey.OP_WRITE) != 0)
 931             newOps |= PollArrayWrapper.POLLOUT;
 932         if ((ops & SelectionKey.OP_CONNECT) != 0)
 933             newOps |= PollArrayWrapper.POLLCONN;
 934         sk.selector.putEventOps(sk, newOps);
 935     }
 936 
 937     public FileDescriptor getFD() {
 938         return fd;
 939     }
 940 
 941     public int getFDVal() {
 942         return fdVal;
 943     }
 944 
 945     public String toString() {
 946         StringBuffer sb = new StringBuffer();
 947         sb.append(this.getClass().getSuperclass().getName());
 948         sb.append('[');
 949         if (!isOpen())
 950             sb.append("closed");
 951         else {
 952             synchronized (stateLock) {
 953                 switch (state) {
 954                 case ST_UNCONNECTED:
 955                     sb.append("unconnected");
 956                     break;
 957                 case ST_PENDING:
 958                     sb.append("connection-pending");
 959                     break;
 960                 case ST_CONNECTED:
 961                     sb.append("connected");
 962                     if (!isInputOpen)
 963                         sb.append(" ishut");
 964                     if (!isOutputOpen)
 965                         sb.append(" oshut");
 966                     break;
 967                 }
 968                 if (localAddress() != null) {
 969                     sb.append(" local=");
 970                     sb.append(localAddress().toString());
 971                 }
 972                 if (remoteAddress() != null) {
 973                     sb.append(" remote=");
 974                     sb.append(remoteAddress().toString());
 975                 }
 976             }
 977         }
 978         sb.append(']');
 979         return sb.toString();
 980     }
 981 
 982 
 983     // -- Native methods --
 984 
 985     private static native int checkConnect(FileDescriptor fd,
 986                                            boolean block, boolean ready)
 987         throws IOException;
 988 
 989     private static native int sendOutOfBandData(FileDescriptor fd, byte data)
 990         throws IOException;
 991 
 992     static {
 993         Util.load();
 994         nd = new SocketDispatcher();
 995     }
 996 
 997 }
--- EOF ---