libjava/java/net/DatagramSocket.java

   1 /* DatagramSocket.java -- A class to model UDP sockets
   2    Copyright (C) 1998, 1999, 2000, 2002, 2003 Free Software Foundation, Inc.
   3
   4 This file is part of GNU Classpath.
   5
   6 GNU Classpath is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2, or (at your option)
   9 any later version.
  10
  11 GNU Classpath is distributed in the hope that it will be useful, but
  12 WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU Classpath; see the file COPYING.  If not, write to the
  18 Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  19 02111-1307 USA.
  20
  21 Linking this library statically or dynamically with other modules is
  22 making a combined work based on this library.  Thus, the terms and
  23 conditions of the GNU General Public License cover the whole
  24 combination.
  25
  26 As a special exception, the copyright holders of this library give you
  27 permission to link this library with independent modules to produce an
  28 executable, regardless of the license terms of these independent
  29 modules, and to copy and distribute the resulting executable under
  30 terms of your choice, provided that you also meet, for each linked
  31 independent module, the terms and conditions of the license of that
  32 module.  An independent module is a module which is not derived from
  33 or based on this library.  If you modify this library, you may extend
  34 this exception to your version of the library, but you are not
  35 obligated to do so.  If you do not wish to do so, delete this
  36 exception statement from your version. */
  37
  38
  39 package java.net;
  40
  41 import gnu.java.net.PlainDatagramSocketImpl;
  42 import java.io.IOException;
  43 import java.nio.channels.DatagramChannel;
  44 import java.nio.channels.IllegalBlockingModeException;
  45
  46 /**
  47  * Written using on-line Java Platform 1.2 API Specification, as well
  48  * as "The Java Class Libraries", 2nd edition (Addison-Wesley, 1998).
  49  * Status:  Believed complete and correct.
  50  */
  51
  52 /**
  53  * This class models a connectionless datagram socket that sends
  54  * individual packets of data across the network.  In the TCP/IP world,
  55  * this means UDP.  Datagram packets do not have guaranteed delivery,
  56  * or any guarantee about the order the data will be received on the
  57  * remote host.
  58  *
  59  * @author Aaron M. Renn (arenn@urbanophile.com)
  60  * @author Warren Levy (warrenl@cygnus.com)
  61  * @date May 3, 1999.
  62  */
  63
  64 public class DatagramSocket
  65 {
  66   /**
  67    * This is the user DatagramSocketImplFactory for this class.  If this
  68    * variable is null, a default factory is used.
  69    */
  70   private static DatagramSocketImplFactory factory;
  71
  72   /**
  73    * This is the implementation object used by this socket.
  74    */
  75   private DatagramSocketImpl impl;
  76
  77   /**
  78    * True if socket implementation was created.
  79    */
  80   private boolean implCreated;
  81
  82   /**
  83    * This is the address we are "connected" to
  84    */
  85   private InetAddress remoteAddress;
  86
  87   /**
  88    * This is the port we are "connected" to
  89    */
  90   private int remotePort = -1;
  91
  92   /**
  93    * True if socket is bound.
  94    */
  95   private boolean bound;
  96
  97   /**
  98    * Creates a <code>DatagramSocket</code> from a specified
  99    * <code>DatagramSocketImpl</code> instance
 100    *
 101    * @param impl The <code>DatagramSocketImpl</code> the socket will be
 102    * created from
 103    *
 104    * @since 1.4
 105    */
 106   protected DatagramSocket (DatagramSocketImpl impl)
 107   {
 108     if (impl == null)
 109       throw new NullPointerException("impl may not be null");
 110
 111     this.impl = impl;
 112     this.remoteAddress = null;
 113     this.remotePort = -1;
 114   }
 115
 116   /**
 117    * Initializes a new instance of <code>DatagramSocket</code> that binds to
 118    * a random port and every address on the local machine.
 119    *
 120    * @exception SocketException If an error occurs.
 121    * @exception SecurityException If a security manager exists and
 122    * its <code>checkListen</code> method doesn't allow the operation.
 123    */
 124   public DatagramSocket() throws SocketException
 125   {
 126     this(new InetSocketAddress(0));
 127   }
 128
 129   /**
 130    * Initializes a new instance of <code>DatagramSocket</code> that binds to
 131    * the specified port and every address on the local machine.
 132    *
 133    * @param port The local port number to bind to.
 134    *
 135    * @exception SecurityException If a security manager exists and its
 136    * <code>checkListen</code> method doesn't allow the operation.
 137    * @exception SocketException If an error occurs.
 138    */
 139   public DatagramSocket(int port) throws SocketException
 140   {
 141     this(new InetSocketAddress(port));
 142   }
 143
 144   /**
 145    * Initializes a new instance of <code>DatagramSocket</code> that binds to
 146    * the specified local port and address.
 147    *
 148    * @param port The local port number to bind to.
 149    * @param addr The local address to bind to.
 150    *
 151    * @exception SecurityException If a security manager exists and its
 152    * checkListen method doesn't allow the operation.
 153    * @exception SocketException If an error occurs.
 154    */
 155   public DatagramSocket(int port, InetAddress addr) throws SocketException
 156   {
 157     this(new InetSocketAddress(addr, port));
 158   }
 159
 160   /**
 161    * Initializes a new instance of <code>DatagramSocket</code> that binds to
 162    * the specified local port and address.
 163    *
 164    * @param address The local address and port number to bind to.
 165    *
 166    * @exception SecurityException If a security manager exists and its
 167    * <code>checkListen</code> method doesn't allow the operation.
 168    * @exception SocketException If an error occurs.
 169    *
 170    * @since 1.4
 171    */
 172   public DatagramSocket (SocketAddress address) throws SocketException
 173   {
 174     String propVal = System.getProperty("impl.prefix");
 175     if (propVal == null || propVal.equals(""))
 176       impl = new PlainDatagramSocketImpl();
 177     else
 178       try
 179         {
 180           impl = (DatagramSocketImpl) Class.forName
 181             ("java.net." + propVal + "DatagramSocketImpl").newInstance();
 182         }
 183       catch (Exception e)
 184         {
 185           System.err.println("Could not instantiate class: java.net." +
 186             propVal + "DatagramSocketImpl");
 187           impl = new PlainDatagramSocketImpl();
 188         }
 189
 190     if (address != null)
 191       bind(address);
 192   }
 193
 194   // This needs to be accessible from java.net.MulticastSocket
 195   DatagramSocketImpl getImpl()
 196     throws SocketException
 197   {
 198     try
 199       {
 200         if (!implCreated)
 201           {
 202             impl.create();
 203             implCreated = true;
 204           }
 205
 206         return impl;
 207       }
 208     catch (IOException e)
 209       {
 210         throw new SocketException(e.getMessage());
 211       }
 212   }
 213
 214   /**
 215    * Closes this datagram socket.
 216    */
 217   public void close()
 218   {
 219     if (isClosed())
 220       return;
 221
 222     try
 223       {
 224         getImpl().close();
 225       }
 226     catch (SocketException e)
 227       {
 228         // Ignore this case, just close the socket in finally clause.
 229       }
 230     finally
 231       {
 232         remoteAddress = null;
 233         remotePort = -1;
 234         impl = null;
 235       }
 236
 237     try
 238       {
 239         if (getChannel() != null)
 240           getChannel().close();
 241       }
 242     catch (IOException e)
 243       {
 244         // Do nothing.
 245       }
 246   }
 247
 248   /**
 249    * This method returns the remote address to which this socket is
 250    * connected.  If this socket is not connected, then this method will
 251    * return <code>null</code>.
 252    *
 253    * @return The remote address.
 254    *
 255    * @since 1.2
 256    */
 257   public InetAddress getInetAddress()
 258   {
 259     return remoteAddress;
 260   }
 261
 262   /**
 263    * This method returns the remote port to which this socket is
 264    * connected.  If this socket is not connected, then this method will
 265    * return -1.
 266    *
 267    * @return The remote port.
 268    *
 269    * @since 1.2
 270    */
 271   public int getPort()
 272   {
 273     return remotePort;
 274   }
 275
 276   /**
 277    * Returns the local address this datagram socket is bound to.
 278    *
 279    * @return The local address is the socket is bound or null
 280    *
 281    * @since 1.1
 282    */
 283   public InetAddress getLocalAddress()
 284   {
 285     if (isClosed())
 286       return null;
 287
 288     InetAddress localAddr;
 289
 290     try
 291       {
 292         localAddr = (InetAddress) getImpl().getOption(SocketOptions.SO_BINDADDR);
 293
 294         SecurityManager s = System.getSecurityManager();
 295         if (s != null)
 296           s.checkConnect (localAddr.getHostName(), -1);
 297       }
 298     catch (SecurityException e)
 299       {
 300         localAddr = InetAddress.ANY_IF;
 301       }
 302     catch (SocketException e)
 303       {
 304         // This cannot happen as we are bound.
 305         return null;
 306       }
 307
 308     return localAddr;
 309   }
 310
 311   /**
 312    * Returns the local port this socket is bound to.
 313    *
 314    * @return The local port number.
 315    */
 316   public int getLocalPort()
 317   {
 318     if (isClosed())
 319       return -1;
 320
 321     try
 322       {
 323         return getImpl().getLocalPort();
 324       }
 325     catch (SocketException e)
 326       {
 327         // This cannot happen as we are bound.
 328         return 0;
 329       }
 330   }
 331
 332   /**
 333    * Returns the value of the socket's SO_TIMEOUT setting.  If this method
 334    * returns 0 then SO_TIMEOUT is disabled.
 335    *
 336    * @return The current timeout in milliseconds.
 337    *
 338    * @exception SocketException If an error occurs.
 339    *
 340    * @since 1.1
 341    */
 342   public synchronized int getSoTimeout() throws SocketException
 343   {
 344     if (isClosed())
 345       throw new SocketException("socket is closed");
 346
 347     Object buf = getImpl().getOption(SocketOptions.SO_TIMEOUT);
 348
 349     if (buf instanceof Integer)
 350       return ((Integer) buf).intValue();
 351
 352     throw new SocketException("unexpected type");
 353   }
 354
 355   /**
 356    * Sets the value of the socket's SO_TIMEOUT value.  A value of 0 will
 357    * disable SO_TIMEOUT.  Any other value is the number of milliseconds
 358    * a socket read/write will block before timing out.
 359    *
 360    * @param timeout The new SO_TIMEOUT value in milliseconds.
 361    *
 362    * @exception SocketException If an error occurs.
 363    *
 364    * @since 1.1
 365    */
 366   public synchronized void setSoTimeout(int timeout) throws SocketException
 367   {
 368     if (isClosed())
 369       throw new SocketException("socket is closed");
 370
 371     if (timeout < 0)
 372       throw new IllegalArgumentException("Invalid timeout: " + timeout);
 373
 374     getImpl().setOption(SocketOptions.SO_TIMEOUT, new Integer(timeout));
 375   }
 376
 377   /**
 378    * This method returns the value of the system level socket option
 379    * SO_SNDBUF, which is used by the operating system to tune buffer
 380    * sizes for data transfers.
 381    *
 382    * @return The send buffer size.
 383    *
 384    * @exception SocketException If an error occurs.
 385    *
 386    * @since 1.2
 387    */
 388   public int getSendBufferSize() throws SocketException
 389   {
 390     if (isClosed())
 391       throw new SocketException("socket is closed");
 392
 393     Object buf = getImpl().getOption(SocketOptions.SO_SNDBUF);
 394
 395     if (buf instanceof Integer)
 396       return ((Integer) buf).intValue();
 397
 398     throw new SocketException("unexpected type");
 399   }
 400
 401   /**
 402    * This method sets the value for the system level socket option
 403    * SO_SNDBUF to the specified value.  Note that valid values for this
 404    * option are specific to a given operating system.
 405    *
 406    * @param size The new send buffer size.
 407    *
 408    * @exception SocketException If an error occurs.
 409    * @exception IllegalArgumentException If size is 0 or negative.
 410    *
 411    * @since 1.2
 412    */
 413   public void setSendBufferSize(int size) throws SocketException
 414   {
 415     if (isClosed())
 416       throw new SocketException("socket is closed");
 417
 418     if (size < 0)
 419       throw new IllegalArgumentException("Buffer size is less than 0");
 420
 421     getImpl().setOption(SocketOptions.SO_SNDBUF, new Integer(size));
 422   }
 423
 424   /**
 425    * This method returns the value of the system level socket option
 426    * SO_RCVBUF, which is used by the operating system to tune buffer
 427    * sizes for data transfers.
 428    *
 429    * @return The receive buffer size.
 430    *
 431    * @exception SocketException If an error occurs.
 432    *
 433    * @since 1.2
 434    */
 435   public int getReceiveBufferSize() throws SocketException
 436   {
 437     if (isClosed())
 438       throw new SocketException("socket is closed");
 439
 440     Object buf = getImpl().getOption(SocketOptions.SO_RCVBUF);
 441
 442     if (buf instanceof Integer)
 443       return ((Integer) buf).intValue();
 444
 445     throw new SocketException("unexpected type");
 446   }
 447
 448   /**
 449    * This method sets the value for the system level socket option
 450    * SO_RCVBUF to the specified value.  Note that valid values for this
 451    * option are specific to a given operating system.
 452    *
 453    * @param size The new receive buffer size.
 454    *
 455    * @exception SocketException If an error occurs.
 456    * @exception IllegalArgumentException If size is 0 or negative.
 457    *
 458    * @since 1.2
 459    */
 460   public void setReceiveBufferSize(int size) throws SocketException
 461   {
 462     if (isClosed())
 463       throw new SocketException("socket is closed");
 464
 465     if (size < 0)
 466       throw new IllegalArgumentException("Buffer size is less than 0");
 467
 468     getImpl().setOption(SocketOptions.SO_RCVBUF, new Integer(size));
 469   }
 470
 471   /**
 472    * This method connects this socket to the specified address and port.
 473    * When a datagram socket is connected, it will only send or receive
 474    * packets to and from the host to which it is connected. A multicast
 475    * socket that is connected may only send and not receive packets.
 476    *
 477    * @param address The address to connect this socket to.
 478    * @param port The port to connect this socket to.
 479    *
 480    * @exception SocketException If an error occurs.
 481    * @exception IllegalArgumentException If address or port are invalid.
 482    * @exception SecurityException If the caller is not allowed to send
 483    * datagrams to or receive from this address and port.
 484    *
 485    * @since 1.2
 486    */
 487   public void connect(InetAddress address, int port)
 488   {
 489     if (address == null)
 490       throw new IllegalArgumentException ("Connect address may not be null");
 491
 492     if ((port < 1) || (port > 65535))
 493       throw new IllegalArgumentException ("Port number is illegal: " + port);
 494
 495     SecurityManager sm = System.getSecurityManager();
 496     if (sm != null)
 497       sm.checkConnect(address.getHostName(), port);
 498
 499     try
 500       {
 501         getImpl().connect (address, port);
 502         remoteAddress = address;
 503         remotePort = port;
 504       }
 505     catch (SocketException e)
 506       {
 507         // This means simply not connected or connect not implemented.
 508       }
 509   }
 510
 511   /**
 512    * This method disconnects this socket from the address/port it was
 513    * connected to.  If the socket was not connected in the first place,
 514    * this method does nothing.
 515    *
 516    * @since 1.2
 517    */
 518   public void disconnect()
 519   {
 520     if (!isConnected())
 521       return;
 522
 523     try
 524       {
 525         getImpl().disconnect();
 526       }
 527     catch (SocketException e)
 528       {
 529         // This cannot happen as we are connected.
 530       }
 531     finally
 532       {
 533         remoteAddress = null;
 534         remotePort = -1;
 535       }
 536   }
 537
 538   /**
 539    * Reads a datagram packet from the socket.  Note that this method
 540    * will block until a packet is received from the network.  On return,
 541    * the passed in <code>DatagramPacket</code> is populated with the data
 542    * received and all the other information about the packet.
 543    *
 544    * @param p A <code>DatagramPacket</code> for storing the data
 545    *
 546    * @exception IOException If an error occurs.
 547    * @exception SocketTimeoutException If setSoTimeout was previously called
 548    * and the timeout has expired.
 549    * @exception PortUnreachableException If the socket is connected to a
 550    * currently unreachable destination. Note, there is no guarantee that the
 551    * exception will be thrown.
 552    * @exception IllegalBlockingModeException If this socket has an associated
 553    * channel, and the channel is in non-blocking mode.
 554    * @exception SecurityException If a security manager exists and its
 555    * checkAccept ethod doesn't allow the receive.
 556    */
 557   public synchronized void receive(DatagramPacket p) throws IOException
 558   {
 559     if (isClosed())
 560       throw new SocketException("socket is closed");
 561
 562     if (remoteAddress != null
 563         && remoteAddress.isMulticastAddress())
 564       throw new IOException
 565         ("Socket connected to a multicast address my not receive");
 566
 567     if (getChannel() != null
 568         && !getChannel().isBlocking ())
 569       throw new IllegalBlockingModeException ();
 570
 571     getImpl().receive(p);
 572
 573     SecurityManager s = System.getSecurityManager();
 574     if (s != null && isConnected ())
 575       s.checkAccept (p.getAddress().getHostName (), p.getPort ());
 576   }
 577
 578   /**
 579    * Sends the specified packet.  The host and port to which the packet
 580    * are to be sent should be set inside the packet.
 581    *
 582    * @param p The datagram packet to send.
 583    *
 584    * @exception IOException If an error occurs.
 585    * @exception SecurityException If a security manager exists and its
 586    * checkMulticast or checkConnect method doesn't allow the send.
 587    * @exception PortUnreachableException If the socket is connected to a
 588    * currently unreachable destination. Note, there is no guarantee that the
 589    * exception will be thrown.
 590    * @exception IllegalBlockingModeException If this socket has an associated
 591    * channel, and the channel is in non-blocking mode.
 592    */
 593   public void send(DatagramPacket p) throws IOException
 594   {
 595     if (isClosed())
 596       throw new SocketException("socket is closed");
 597
 598     // JDK1.2: Don't do security checks if socket is connected; see jdk1.2 api.
 599     SecurityManager s = System.getSecurityManager();
 600     if (s != null && !isConnected ())
 601       {
 602         InetAddress addr = p.getAddress();
 603         if (addr.isMulticastAddress())
 604           s.checkMulticast(addr);
 605         else
 606           s.checkConnect(addr.getHostAddress(), p.getPort());
 607       }
 608
 609     if (isConnected ())
 610       {
 611         if (p.getAddress () != null && (remoteAddress != p.getAddress () ||
 612                                         remotePort != p.getPort ()))
 613           throw new IllegalArgumentException (
 614             "DatagramPacket address does not match remote address" );
 615       }
 616
 617     // FIXME: if this is a subclass of MulticastSocket,
 618     // use getTimeToLive for TTL val.
 619
 620     if (getChannel() != null
 621         && !getChannel().isBlocking ())
 622       throw new IllegalBlockingModeException ();
 623
 624     getImpl().send(p);
 625   }
 626
 627   /**
 628    * Binds the socket to the given socket address.
 629    *
 630    * @param address The socket address to bind to.
 631    *
 632    * @exception SocketException If an error occurs.
 633    * @exception SecurityException If a security manager exists and
 634    * its checkListen method doesn't allow the operation.
 635    * @exception IllegalArgumentException If address type is not supported.
 636    *
 637    * @since 1.4
 638    */
 639   public void bind (SocketAddress address)
 640     throws SocketException
 641   {
 642     if (isClosed())
 643       throw new SocketException("socket is closed");
 644
 645     if (! (address instanceof InetSocketAddress))
 646       throw new IllegalArgumentException("unsupported address type");
 647
 648     InetAddress addr = ((InetSocketAddress) address).getAddress();
 649     int port = ((InetSocketAddress) address).getPort();
 650
 651     if (port < 0 || port > 65535)
 652       throw new IllegalArgumentException("Invalid port: " + port);
 653
 654     SecurityManager s = System.getSecurityManager ();
 655     if (s != null)
 656       s.checkListen(port);
 657
 658     if (addr == null)
 659       addr = InetAddress.ANY_IF;
 660
 661     try
 662       {
 663         getImpl().bind(port, addr);
 664         bound = true;
 665       }
 666     catch (SocketException exception)
 667       {
 668         getImpl().close();
 669         throw exception;
 670       }
 671     catch (RuntimeException exception)
 672       {
 673         getImpl().close();
 674         throw exception;
 675       }
 676     catch (Error error)
 677       {
 678         getImpl().close();
 679         throw error;
 680       }
 681   }
 682
 683   /**
 684    * Checks if the datagram socket is closed.
 685    *
 686    * @return True if socket is closed, false otherwise.
 687    *
 688    * @since 1.4
 689    */
 690   public boolean isClosed()
 691   {
 692     return impl == null;
 693   }
 694
 695   /**
 696    * Returns the datagram channel assoziated with this datagram socket.
 697    *
 698    * @return The associated <code>DatagramChannel</code> object or null
 699    *
 700    * @since 1.4
 701    */
 702   public DatagramChannel getChannel()
 703   {
 704     return null;
 705   }
 706
 707   /**
 708    * Connects the datagram socket to a specified socket address.
 709    *
 710    * @param address The socket address to connect to.
 711    *
 712    * @exception SocketException If an error occurs.
 713    * @exception IllegalArgumentException If address type is not supported.
 714    *
 715    * @since 1.4
 716    */
 717   public void connect (SocketAddress address) throws SocketException
 718   {
 719     if (isClosed())
 720       throw new SocketException("socket is closed");
 721
 722     if ( !(address instanceof InetSocketAddress) )
 723       throw new IllegalArgumentException("unsupported address type");
 724
 725     InetSocketAddress tmp = (InetSocketAddress) address;
 726     connect(tmp.getAddress(), tmp.getPort());
 727   }
 728
 729   /**
 730    * Returns the binding state of the socket.
 731    *
 732    * @return True if socket bound, false otherwise.
 733    *
 734    * @since 1.4
 735    */
 736   public boolean isBound()
 737   {
 738     return bound;
 739   }
 740
 741   /**
 742    * Returns the connection state of the socket.
 743    *
 744    * @return True if socket is connected, false otherwise.
 745    *
 746    * @since 1.4
 747    */
 748   public boolean isConnected()
 749   {
 750     return remoteAddress != null;
 751   }
 752
 753   /**
 754    * Returns the SocketAddress of the host this socket is conneted to
 755    * or null if this socket is not connected.
 756    *
 757    * @return The socket address of the remote host if connected or null
 758    *
 759    * @since 1.4
 760    */
 761   public SocketAddress getRemoteSocketAddress()
 762   {
 763     if (!isConnected ())
 764       return null;
 765
 766     return new InetSocketAddress (remoteAddress, remotePort);
 767   }
 768
 769   /**
 770    * Returns the local SocketAddress this socket is bound to.
 771    *
 772    * @return The local SocketAddress or null if the socket is not bound.
 773    *
 774    * @since 1.4
 775    */
 776   public SocketAddress getLocalSocketAddress()
 777   {
 778     if (!isBound())
 779       return null;
 780
 781     return new InetSocketAddress (getLocalAddress(), getLocalPort());
 782   }
 783
 784   /**
 785    * Enables/Disables SO_REUSEADDR.
 786    *
 787    * @param on Whether or not to have SO_REUSEADDR turned on.
 788    *
 789    * @exception SocketException If an error occurs.
 790    *
 791    * @since 1.4
 792    */
 793   public void setReuseAddress(boolean on) throws SocketException
 794   {
 795     if (isClosed())
 796       throw new SocketException("socket is closed");
 797
 798     getImpl().setOption (SocketOptions.SO_REUSEADDR, new Boolean (on));
 799   }
 800
 801   /**
 802    * Checks if SO_REUSEADDR is enabled.
 803    *
 804    * @return True if SO_REUSEADDR is set on the socket, false otherwise.
 805    *
 806    * @exception SocketException If an error occurs.
 807    *
 808    * @since 1.4
 809    */
 810   public boolean getReuseAddress() throws SocketException
 811   {
 812     if (isClosed())
 813       throw new SocketException("socket is closed");
 814
 815     Object buf = getImpl().getOption (SocketOptions.SO_REUSEADDR);
 816
 817     if (buf instanceof Boolean)
 818       return ((Boolean) buf).booleanValue();
 819
 820     throw new SocketException("unexpected type");
 821   }
 822
 823   /**
 824    * Enables/Disables SO_BROADCAST
 825    *
 826    * @param enable True if SO_BROADCAST should be enabled, false otherwise.
 827    *
 828    * @exception SocketException If an error occurs
 829    *
 830    * @since 1.4
 831    */
 832   public void setBroadcast(boolean enable) throws SocketException
 833   {
 834     if (isClosed())
 835       throw new SocketException("socket is closed");
 836
 837     getImpl().setOption(SocketOptions.SO_BROADCAST, new Boolean(enable));
 838   }
 839
 840   /**
 841    * Checks if SO_BROADCAST is enabled
 842    *
 843    * @return Whether SO_BROADCAST is set
 844    *
 845    * @exception SocketException If an error occurs
 846    *
 847    * @since 1.4
 848    */
 849   public boolean getBroadcast() throws SocketException
 850   {
 851     if (isClosed())
 852       throw new SocketException("socket is closed");
 853
 854     Object buf = getImpl().getOption(SocketOptions.SO_BROADCAST);
 855
 856     if (buf instanceof Boolean)
 857       return ((Boolean) buf).booleanValue();
 858
 859     throw new SocketException("unexpected type");
 860   }
 861
 862   /**
 863    * Sets the traffic class value
 864    *
 865    * @param tc The traffic class
 866    *
 867    * @exception SocketException If an error occurs
 868    * @exception IllegalArgumentException If tc value is illegal
 869    *
 870    * @see DatagramSocket#getTrafficClass()
 871    *
 872    * @since 1.4
 873    */
 874   public void setTrafficClass(int tc)
 875     throws SocketException
 876   {
 877     if (isClosed())
 878       throw new SocketException("socket is closed");
 879
 880     if (tc < 0 || tc > 255)
 881       throw new IllegalArgumentException();
 882
 883     getImpl().setOption (SocketOptions.IP_TOS, new Integer (tc));
 884   }
 885
 886   /**
 887    * Returns the current traffic class
 888    *
 889    * @return The current traffic class.
 890    *
 891    * @see DatagramSocket#setTrafficClass(int tc)
 892    *
 893    * @exception SocketException If an error occurs
 894    *
 895    * @since 1.4
 896    */
 897   public int getTrafficClass() throws SocketException
 898   {
 899     if (isClosed())
 900       throw new SocketException("socket is closed");
 901
 902     Object buf = getImpl().getOption(SocketOptions.IP_TOS);
 903
 904     if (buf instanceof Integer)
 905       return ((Integer) buf).intValue();
 906
 907     throw new SocketException("unexpected type");
 908   }
 909
 910   /**
 911    * Sets the datagram socket implementation factory for the application
 912    *
 913    * @param fac The factory to set
 914    *
 915    * @exception IOException If an error occurs
 916    * @exception SocketException If the factory is already defined
 917    * @exception SecurityException If a security manager exists and its
 918    * checkSetFactory method doesn't allow the operation
 919    */
 920   public static void setDatagramSocketImplFactory
 921     (DatagramSocketImplFactory fac) throws IOException
 922   {
 923     if (factory != null)
 924       throw new SocketException ("DatagramSocketImplFactory already defined");
 925
 926     SecurityManager sm = System.getSecurityManager();
 927     if (sm != null)
 928       sm.checkSetFactory();
 929
 930     factory = fac;
 931   }
 932 }