1 /*
   2  * Copyright (c) 2001, 2019, 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.IOException;

  29 import java.lang.invoke.MethodHandles;
  30 import java.lang.invoke.MethodHandles.Lookup;
  31 import java.lang.invoke.VarHandle;
  32 import java.net.DatagramPacket;
  33 import java.net.DatagramSocket;
  34 import java.net.DatagramSocketImpl;
  35 import java.net.InetAddress;
  36 import java.net.InetSocketAddress;
  37 import java.net.NetworkInterface;
  38 import java.net.SocketAddress;
  39 import java.net.SocketException;
  40 import java.net.SocketOption;
  41 import java.net.StandardSocketOptions;
  42 import java.nio.ByteBuffer;
  43 import java.nio.channels.AlreadyConnectedException;
  44 import java.nio.channels.ClosedChannelException;
  45 import java.nio.channels.DatagramChannel;
  46 import java.security.AccessController;
  47 import java.security.PrivilegedAction;
  48 import java.util.Set;
  49 
  50 import static java.util.concurrent.TimeUnit.MILLISECONDS;
  51 
  52 // Make a datagram-socket channel look like a datagram socket.
  53 //
  54 // The methods in this class are defined in exactly the same order as in
  55 // java.net.DatagramSocket so as to simplify tracking future changes to that
  56 // class.
  57 //
  58 
  59 class DatagramSocketAdaptor
  60     extends DatagramSocket
  61 {
  62     // The channel being adapted
  63     private final DatagramChannelImpl dc;
  64 
  65     // Timeout "option" value for receives
  66     private volatile int timeout;
  67 
  68     // create DatagramSocket with useless impl
  69     private DatagramSocketAdaptor(DatagramChannelImpl dc) {
  70         super(new DummyDatagramSocketImpl());
  71         this.dc = dc;
  72     }
  73 
  74     static DatagramSocket create(DatagramChannelImpl dc) {
  75         return new DatagramSocketAdaptor(dc);
  76     }
  77 
  78     private void connectInternal(SocketAddress remote) throws SocketException {
  79         try {
  80             dc.connect(remote, false); // skips check for already connected
  81         } catch (ClosedChannelException e) {
  82             // ignore
  83         } catch (Exception x) {
  84             Net.translateToSocketException(x);
  85         }
  86     }
  87 
  88     @Override
  89     public void bind(SocketAddress local) throws SocketException {
  90         if (local != null) {
  91             local = Net.asInetSocketAddress(local);
  92         } else {
  93             local = new InetSocketAddress(0);
  94         }
  95         try {
  96             dc.bind(local);
  97         } catch (Exception x) {
  98             Net.translateToSocketException(x);
  99         }
 100     }
 101 
 102     @Override
 103     public void connect(InetAddress address, int port) {
 104         if (address == null)
 105             throw new IllegalArgumentException("Address can't be null");
 106         try {
 107             connectInternal(new InetSocketAddress(address, port));
 108         } catch (SocketException x) {
 109             throw new Error(x);
 110         }
 111     }
 112 
 113     @Override
 114     public void connect(SocketAddress remote) throws SocketException {
 115         if (remote == null)
 116             throw new IllegalArgumentException("Address can't be null");
 117         connectInternal(Net.asInetSocketAddress(remote));
 118     }
 119 
 120     @Override
 121     public void disconnect() {
 122         try {
 123             dc.disconnect();
 124         } catch (IOException x) {
 125             throw new Error(x);
 126         }
 127     }
 128 
 129     @Override
 130     public boolean isBound() {
 131         return dc.localAddress() != null;
 132     }
 133 
 134     @Override
 135     public boolean isConnected() {
 136         return dc.remoteAddress() != null;
 137     }
 138 
 139     @Override
 140     public InetAddress getInetAddress() {
 141         InetSocketAddress remote = dc.remoteAddress();
 142         return (remote != null) ? remote.getAddress() : null;
 143     }
 144 
 145     @Override
 146     public int getPort() {
 147         InetSocketAddress remote = dc.remoteAddress();
 148         return (remote != null) ? remote.getPort() : -1;
 149     }
 150 
 151     @Override
 152     public SocketAddress getRemoteSocketAddress() {
 153         return dc.remoteAddress();
 154     }
 155 
 156     @Override
 157     public SocketAddress getLocalSocketAddress() {
 158         try {
 159             return dc.getLocalAddress();
 160         } catch (ClosedChannelException e) {
 161             return null;
 162         } catch (Exception x) {
 163             throw new Error(x);
 164         }
 165     }
 166 
 167     @Override
 168     public void send(DatagramPacket p) throws IOException {
 169         ByteBuffer bb = null;
 170         try {
 171             InetSocketAddress target;
 172             synchronized (p) {
 173                 // copy bytes to temporary direct buffer
 174                 int len = p.getLength();
 175                 bb = Util.getTemporaryDirectBuffer(len);
 176                 bb.put(p.getData(), p.getOffset(), len);
 177                 bb.flip();
 178 
 179                 // target address
 180                 if (p.getAddress() == null) {
 181                     InetSocketAddress remote = dc.remoteAddress();
 182                     if (remote == null) {
 183                         // not specified by DatagramSocket
 184                         throw new IllegalArgumentException("Address not set");
 185                     }
 186                     // set address/port to maintain compatibility with DatagramSocket
 187                     p.setAddress(remote.getAddress());
 188                     p.setPort(remote.getPort());
 189                     target = remote;
 190                 } else {
 191                     // throws IllegalArgumentException if port not set
 192                     target = (InetSocketAddress) p.getSocketAddress();
 193                 }
 194             }
 195             // send datagram
 196             try {
 197                 dc.blockingSend(bb, target);
 198             } catch (AlreadyConnectedException e) {
 199                 throw new IllegalArgumentException("Connected and packet address differ");
 200             } catch (ClosedChannelException e) {
 201                 var exc = new SocketException("Socket closed");
 202                 exc.initCause(e);
 203                 throw exc;
 204             }
 205         } finally {
 206             if (bb != null) {
 207                 Util.offerFirstTemporaryDirectBuffer(bb);
 208             }
 209         }
 210     }
 211 
 212     @Override
 213     public void receive(DatagramPacket p) throws IOException {
 214         // get temporary direct buffer with a capacity of p.bufLength
 215         int bufLength = DatagramPackets.getBufLength(p);
 216         ByteBuffer bb = Util.getTemporaryDirectBuffer(bufLength);
 217         try {
 218             long nanos = MILLISECONDS.toNanos(timeout);
 219             SocketAddress sender = dc.blockingReceive(bb, nanos);
 220             bb.flip();
 221             synchronized (p) {
 222                 // copy bytes to the DatagramPacket and set length
 223                 int len = Math.min(bb.limit(), DatagramPackets.getBufLength(p));
 224                 bb.get(p.getData(), p.getOffset(), len);
 225                 DatagramPackets.setLength(p, len);
 226 
 227                 // sender address
 228                 p.setSocketAddress(sender);
 229             }
 230         } catch (ClosedChannelException e) {
 231             var exc = new SocketException("Socket closed");
 232             exc.initCause(e);
 233             throw exc;
 234         } finally {
 235             Util.offerFirstTemporaryDirectBuffer(bb);
 236         }
 237     }
 238 
 239     @Override
 240     public InetAddress getLocalAddress() {
 241         if (isClosed())
 242             return null;
 243         InetSocketAddress local = dc.localAddress();
 244         if (local == null)
 245             local = new InetSocketAddress(0);
 246         InetAddress result = local.getAddress();
 247         SecurityManager sm = System.getSecurityManager();
 248         if (sm != null) {
 249             try {
 250                 sm.checkConnect(result.getHostAddress(), -1);
 251             } catch (SecurityException x) {
 252                 return new InetSocketAddress(0).getAddress();
 253             }
 254         }
 255         return result;
 256     }
 257 
 258     @Override
 259     public int getLocalPort() {
 260         if (isClosed())
 261             return -1;
 262         InetSocketAddress local = dc.localAddress();
 263         if (local != null) {
 264             return local.getPort();
 265         }
 266         return 0;
 267     }
 268 
 269     @Override
 270     public void setSoTimeout(int timeout) throws SocketException {
 271         if (isClosed())
 272             throw new SocketException("Socket is closed");
 273         if (timeout < 0)
 274             throw new IllegalArgumentException("timeout < 0");
 275         this.timeout = timeout;
 276     }
 277 
 278     @Override
 279     public int getSoTimeout() throws SocketException {
 280         if (isClosed())
 281             throw new SocketException("Socket is closed");
 282         return timeout;
 283     }
 284 
 285     private void setBooleanOption(SocketOption<Boolean> name, boolean value)
 286         throws SocketException
 287     {
 288         try {
 289             dc.setOption(name, value);
 290         } catch (IOException x) {
 291             Net.translateToSocketException(x);
 292         }
 293     }
 294 
 295     private void setIntOption(SocketOption<Integer> name, int value)
 296         throws SocketException
 297     {
 298         try {
 299             dc.setOption(name, value);
 300         } catch (IOException x) {
 301             Net.translateToSocketException(x);
 302         }
 303     }
 304 
 305     private boolean getBooleanOption(SocketOption<Boolean> name) throws SocketException {
 306         try {
 307             return dc.getOption(name).booleanValue();
 308         } catch (IOException x) {
 309             Net.translateToSocketException(x);
 310             return false;       // keep compiler happy
 311         }
 312     }
 313 
 314     private int getIntOption(SocketOption<Integer> name) throws SocketException {
 315         try {
 316             return dc.getOption(name).intValue();
 317         } catch (IOException x) {
 318             Net.translateToSocketException(x);
 319             return -1;          // keep compiler happy
 320         }
 321     }
 322 
 323     @Override
 324     public void setSendBufferSize(int size) throws SocketException {
 325         if (size <= 0)
 326             throw new IllegalArgumentException("Invalid send size");
 327         setIntOption(StandardSocketOptions.SO_SNDBUF, size);
 328     }
 329 
 330     @Override
 331     public int getSendBufferSize() throws SocketException {
 332         return getIntOption(StandardSocketOptions.SO_SNDBUF);
 333     }
 334 
 335     @Override
 336     public void setReceiveBufferSize(int size) throws SocketException {
 337         if (size <= 0)
 338             throw new IllegalArgumentException("Invalid receive size");
 339         setIntOption(StandardSocketOptions.SO_RCVBUF, size);
 340     }
 341 
 342     @Override
 343     public int getReceiveBufferSize() throws SocketException {
 344         return getIntOption(StandardSocketOptions.SO_RCVBUF);
 345     }
 346 
 347     @Override
 348     public void setReuseAddress(boolean on) throws SocketException {
 349         setBooleanOption(StandardSocketOptions.SO_REUSEADDR, on);
 350     }
 351 
 352     @Override
 353     public boolean getReuseAddress() throws SocketException {
 354         return getBooleanOption(StandardSocketOptions.SO_REUSEADDR);
 355     }
 356 
 357     @Override
 358     public void setBroadcast(boolean on) throws SocketException {
 359         setBooleanOption(StandardSocketOptions.SO_BROADCAST, on);
 360     }
 361 
 362     @Override
 363     public boolean getBroadcast() throws SocketException {
 364         return getBooleanOption(StandardSocketOptions.SO_BROADCAST);
 365     }
 366 
 367     @Override
 368     public void setTrafficClass(int tc) throws SocketException {
 369         setIntOption(StandardSocketOptions.IP_TOS, tc);
 370     }
 371 
 372     @Override
 373     public int getTrafficClass() throws SocketException {
 374         return getIntOption(StandardSocketOptions.IP_TOS);
 375     }
 376 
 377     @Override
 378     public void close() {
 379         try {
 380             dc.close();
 381         } catch (IOException x) {
 382             throw new Error(x);
 383         }
 384     }
 385 
 386     @Override
 387     public boolean isClosed() {
 388         return !dc.isOpen();
 389     }
 390 
 391     @Override
 392     public DatagramChannel getChannel() {
 393         return dc;
 394     }
 395 
 396     @Override
 397     public <T> DatagramSocket setOption(SocketOption<T> name, T value) throws IOException {
 398         dc.setOption(name, value);
 399         return this;
 400     }
 401 
 402     @Override
 403     public <T> T getOption(SocketOption<T> name) throws IOException {
 404         return dc.getOption(name);
 405     }
 406 
 407     @Override
 408     public Set<SocketOption<?>> supportedOptions() {
 409         return dc.supportedOptions();
 410     }
 411 
 412 
 413     /**
 414      * DatagramSocketImpl implementation where all methods throw an error.
 415      */
 416     private static class DummyDatagramSocketImpl extends DatagramSocketImpl {
 417         private static <T> T shouldNotGetHere() {
 418             throw new InternalError("Should not get here");
 419         }
 420 
 421         @Override
 422         protected void create() {
 423             shouldNotGetHere();
 424         }
 425 
 426         @Override
 427         protected void bind(int lport, InetAddress laddr) {
 428             shouldNotGetHere();
 429         }
 430 
 431         @Override
 432         protected void send(DatagramPacket p) {
 433             shouldNotGetHere();
 434         }
 435 
 436         @Override
 437         protected int peek(InetAddress address) {
 438             return shouldNotGetHere();
 439         }
 440 
 441         @Override
 442         protected int peekData(DatagramPacket p) {
 443             return shouldNotGetHere();
 444         }
 445 
 446         @Override
 447         protected void receive(DatagramPacket p) {
 448             shouldNotGetHere();
 449         }
 450 
 451         @Deprecated
 452         protected void setTTL(byte ttl) {
 453             shouldNotGetHere();
 454         }
 455 
 456         @Deprecated
 457         protected byte getTTL() {
 458             return shouldNotGetHere();
 459         }
 460 
 461         @Override
 462         protected void setTimeToLive(int ttl) {
 463             shouldNotGetHere();
 464         }
 465 
 466         @Override
 467         protected int getTimeToLive() {
 468             return shouldNotGetHere();
 469         }
 470 
 471         @Override
 472         protected void join(InetAddress group) {
 473             shouldNotGetHere();
 474         }
 475 
 476         @Override
 477         protected void leave(InetAddress inetaddr) {
 478             shouldNotGetHere();
 479         }
 480 
 481         @Override
 482         protected void joinGroup(SocketAddress group, NetworkInterface netIf) {
 483             shouldNotGetHere();
 484         }
 485 
 486         @Override
 487         protected void leaveGroup(SocketAddress mcastaddr, NetworkInterface netIf) {
 488             shouldNotGetHere();
 489         }
 490 
 491         @Override
 492         protected void close() {
 493             shouldNotGetHere();
 494         }
 495 
 496         @Override
 497         public Object getOption(int optID) {
 498             return shouldNotGetHere();
 499         }
 500 
 501         @Override
 502         public void setOption(int optID, Object value) {
 503             shouldNotGetHere();
 504         }
 505 
 506         @Override
 507         protected <T> void setOption(SocketOption<T> name, T value) {
 508             shouldNotGetHere();
 509         }
 510 
 511         @Override
 512         protected <T> T getOption(SocketOption<T> name) {
 513             return shouldNotGetHere();
 514         }
 515 
 516         @Override
 517         protected Set<SocketOption<?>> supportedOptions() {
 518             return shouldNotGetHere();
 519         }
 520     }
 521 
 522     /**
 523      * Defines static methods to get/set DatagramPacket fields and workaround
 524      * DatagramPacket deficiencies.
 525      */
 526     private static class DatagramPackets {
 527         private static final VarHandle LENGTH;
 528         private static final VarHandle BUF_LENGTH;
 529         static {
 530             try {
 531                 PrivilegedAction<Lookup> pa = () -> {
 532                     try {
 533                         return MethodHandles.privateLookupIn(DatagramPacket.class, MethodHandles.lookup());
 534                     } catch (Exception e) {
 535                         throw new ExceptionInInitializerError(e);
 536                     }
 537                 };
 538                 MethodHandles.Lookup l = AccessController.doPrivileged(pa);
 539                 LENGTH = l.findVarHandle(DatagramPacket.class, "length", int.class);
 540                 BUF_LENGTH = l.findVarHandle(DatagramPacket.class, "bufLength", int.class);
 541             } catch (Exception e) {
 542                 throw new ExceptionInInitializerError(e);
 543             }
 544         }
 545 
 546         /**
 547          * Sets the DatagramPacket.length field. DatagramPacket.setLength cannot be
 548          * used at this time because it sets both the length and bufLength fields.
 549          */
 550         static void setLength(DatagramPacket p, int value) {
 551             synchronized (p) {
 552                 LENGTH.set(p, value);
 553             }
 554         }
 555 
 556         /**
 557          * Returns the value of the DatagramPacket.bufLength field.
 558          */
 559         static int getBufLength(DatagramPacket p) {
 560             synchronized (p) {
 561                 return (int) BUF_LENGTH.get(p);
 562             }
 563         }
 564     }
 565 }
--- EOF ---