| Methods Summary |
|---|
| public synchronized void | bind(java.net.SocketAddress addr)Binds this DatagramSocket to a specific address & port.
If the address is null, then the system will pick up
an ephemeral port and a valid local address to bind the socket.
if (isClosed())
throw new SocketException("Socket is closed");
if (isBound())
throw new SocketException("already bound");
if (addr == null)
addr = new InetSocketAddress(0);
if (!(addr instanceof InetSocketAddress))
throw new IllegalArgumentException("Unsupported address type!");
InetSocketAddress epoint = (InetSocketAddress) addr;
if (epoint.isUnresolved())
throw new SocketException("Unresolved address");
SecurityManager sec = System.getSecurityManager();
if (sec != null) {
sec.checkListen(epoint.getPort());
}
try {
getImpl().bind(epoint.getPort(),
epoint.getAddress());
} catch (SocketException e) {
getImpl().close();
throw e;
}
bound = true;
|
| private void | checkOldImpl()
if (impl == null)
return;
// DatagramSocketImpl.peekdata() is a protected method, therefore we need to use
// getDeclaredMethod, therefore we need permission to access the member
try {
AccessController.doPrivileged(new PrivilegedExceptionAction() {
public Object run() throws NoSuchMethodException {
Class[] cl = new Class[1];
cl[0] = DatagramPacket.class;
impl.getClass().getDeclaredMethod("peekData", cl);
return null;
}
});
} catch (java.security.PrivilegedActionException e) {
oldImpl = true;
}
|
| public void | close()Closes this datagram socket.
Any thread currently blocked in {@link #receive} upon this socket
will throw a {@link SocketException}.
If this socket has an associated channel then the channel is closed
as well.
synchronized(closeLock) {
if (isClosed())
return;
impl.close();
closed = true;
}
|
| public void | connect(java.net.InetAddress address, int port)Connects the socket to a remote address for this socket. When a
socket is connected to a remote address, packets may only be
sent to or received from that address. By default a datagram
socket is not connected.
If the remote destination to which the socket is connected does not
exist, or is otherwise unreachable, and if an ICMP destination unreachable
packet has been received for that address, then a subsequent call to
send or receive may throw a PortUnreachableException. Note, there is no
guarantee that the exception will be thrown.
A caller's permission to send and receive datagrams to a
given host and port are checked at connect time. When a socket
is connected, receive and send will not
perform any security checks on incoming and outgoing
packets, other than matching the packet's and the socket's
address and port. On a send operation, if the packet's address
is set and the packet's address and the socket's address do not
match, an IllegalArgumentException will be thrown. A socket
connected to a multicast address may only be used to send packets.
try {
connectInternal(address, port);
} catch (SocketException se) {
throw new Error("connect failed", se);
}
|
| public void | connect(java.net.SocketAddress addr)Connects this socket to a remote socket address (IP address + port number).
if (addr == null)
throw new IllegalArgumentException("Address can't be null");
if (!(addr instanceof InetSocketAddress))
throw new IllegalArgumentException("Unsupported address type");
InetSocketAddress epoint = (InetSocketAddress) addr;
if (epoint.isUnresolved())
throw new SocketException("Unresolved address");
connectInternal(epoint.getAddress(), epoint.getPort());
|
| private synchronized void | connectInternal(java.net.InetAddress address, int port)Connects this socket to a remote socket address (IP address + port number).
Binds socket if not already bound.
if (port < 0 || port > 0xFFFF) {
throw new IllegalArgumentException("connect: " + port);
}
if (address == null) {
throw new IllegalArgumentException("connect: null address");
}
if (isClosed())
return;
SecurityManager security = System.getSecurityManager();
if (security != null) {
if (address.isMulticastAddress()) {
security.checkMulticast(address);
} else {
security.checkConnect(address.getHostAddress(), port);
security.checkAccept(address.getHostAddress(), port);
}
}
if (!isBound())
bind(new InetSocketAddress(0));
// old impls do not support connect/disconnect
if (oldImpl) {
connectState = ST_CONNECTED_NO_IMPL;
} else {
try {
getImpl().connect(address, port);
// socket is now connected by the impl
connectState = ST_CONNECTED;
} catch (SocketException se) {
// connection will be emulated by DatagramSocket
connectState = ST_CONNECTED_NO_IMPL;
}
}
connectedAddress = address;
connectedPort = port;
|
| void | createImpl()
if (impl == null) {
if (factory != null) {
impl = factory.createDatagramSocketImpl();
checkOldImpl();
} else {
if (implClass == null) {
String prefix = null;
try {
prefix = (String) AccessController.doPrivileged(
new sun.security.action.GetPropertyAction("impl.prefix", "Plain"));
implClass = Class.forName("java.net."+prefix+"DatagramSocketImpl");
} catch (Exception e) {
System.err.println("Can't find class: java.net." +
prefix +
"DatagramSocketImpl: check impl.prefix property");
}
if (implClass == null)
implClass = java.net.PlainDatagramSocketImpl.class;
}
try {
impl = (DatagramSocketImpl) implClass.newInstance();
} catch (Exception e) {
throw new SocketException("can't instantiate DatagramSocketImpl");
}
// No need to do a checkOldImpl() here, we know it's an up to date
// SocketImpl!
if (!(impl instanceof java.net.PlainDatagramSocketImpl))
checkOldImpl();
}
}
// creates a udp socket
impl.create();
created = true;
|
| public void | disconnect()Disconnects the socket. This does nothing if the socket is not
connected.
synchronized (this) {
if (isClosed())
return;
if (connectState == ST_CONNECTED) {
impl.disconnect ();
}
connectedAddress = null;
connectedPort = -1;
connectState = ST_NOT_CONNECTED;
}
|
| public synchronized boolean | getBroadcast()Tests if SO_BROADCAST is enabled.
if (isClosed())
throw new SocketException("Socket is closed");
return ((Boolean)(getImpl().getOption(SocketOptions.SO_BROADCAST))).booleanValue();
|
| public java.nio.channels.DatagramChannel | getChannel()Returns the unique {@link java.nio.channels.DatagramChannel} object
associated with this datagram socket, if any.
A datagram socket will have a channel if, and only if, the channel
itself was created via the {@link java.nio.channels.DatagramChannel#open
DatagramChannel.open} method.
return null;
|
| java.net.DatagramSocketImpl | getImpl()Get the DatagramSocketImpl attached to this socket,
creating it if necessary.
if (!created)
createImpl();
return impl;
|
| public java.net.InetAddress | getInetAddress()Returns the address to which this socket is connected. Returns null
if the socket is not connected.
return connectedAddress;
|
| public java.net.InetAddress | getLocalAddress()Gets the local address to which the socket is bound.
If there is a security manager, its
checkConnect method is first called
with the host address and -1
as its arguments to see if the operation is allowed.
if (isClosed())
return null;
InetAddress in = null;
try {
in = (InetAddress) getImpl().getOption(SocketOptions.SO_BINDADDR);
if (in.isAnyLocalAddress()) {
in = InetAddress.anyLocalAddress();
}
SecurityManager s = System.getSecurityManager();
if (s != null) {
s.checkConnect(in.getHostAddress(), -1);
}
} catch (Exception e) {
in = InetAddress.anyLocalAddress(); // "0.0.0.0"
}
return in;
|
| public int | getLocalPort()Returns the port number on the local host to which this socket is bound.
if (isClosed())
return -1;
try {
return getImpl().getLocalPort();
} catch (Exception e) {
return 0;
}
|
| public java.net.SocketAddress | getLocalSocketAddress()Returns the address of the endpoint this socket is bound to, or
null if it is not bound yet.
if (!isBound())
return null;
return new InetSocketAddress(getLocalAddress(), getLocalPort());
|
| public int | getPort()Returns the port for this socket. Returns -1 if the socket is not
connected.
return connectedPort;
|
| public synchronized int | getReceiveBufferSize()Get value of the SO_RCVBUF option for this DatagramSocket, that is the
buffer size used by the platform for input on this DatagramSocket.
if (isClosed())
throw new SocketException("Socket is closed");
int result = 0;
Object o = getImpl().getOption(SocketOptions.SO_RCVBUF);
if (o instanceof Integer) {
result = ((Integer)o).intValue();
}
return result;
|
| public java.net.SocketAddress | getRemoteSocketAddress()Returns the address of the endpoint this socket is connected to, or
null if it is unconnected.
if (!isConnected())
return null;
return new InetSocketAddress(getInetAddress(), getPort());
|
| public synchronized boolean | getReuseAddress()Tests if SO_REUSEADDR is enabled.
if (isClosed())
throw new SocketException("Socket is closed");
Object o = getImpl().getOption(SocketOptions.SO_REUSEADDR);
return ((Boolean)o).booleanValue();
|
| public synchronized int | getSendBufferSize()Get value of the SO_SNDBUF option for this DatagramSocket, that is the
buffer size used by the platform for output on this DatagramSocket.
if (isClosed())
throw new SocketException("Socket is closed");
int result = 0;
Object o = getImpl().getOption(SocketOptions.SO_SNDBUF);
if (o instanceof Integer) {
result = ((Integer)o).intValue();
}
return result;
|
| public synchronized int | getSoTimeout()Retrieve setting for SO_TIMEOUT. 0 returns implies that the
option is disabled (i.e., timeout of infinity).
if (isClosed())
throw new SocketException("Socket is closed");
if (getImpl() == null)
return 0;
Object o = getImpl().getOption(SocketOptions.SO_TIMEOUT);
/* extra type safety */
if (o instanceof Integer) {
return ((Integer) o).intValue();
} else {
return 0;
}
|
| public synchronized int | getTrafficClass()Gets traffic class or type-of-service in the IP datagram
header for packets sent from this DatagramSocket.
As the underlying network implementation may ignore the
traffic class or type-of-service set using {@link #setTrafficClass(int)}
this method may return a different value than was previously
set using the {@link #setTrafficClass(int)} method on this
DatagramSocket.
if (isClosed())
throw new SocketException("Socket is closed");
return ((Integer)(getImpl().getOption(SocketOptions.IP_TOS))).intValue();
|
| public boolean | isBound()Returns the binding state of the socket.
return bound;
|
| public boolean | isClosed()Returns whether the socket is closed or not.
synchronized(closeLock) {
return closed;
}
|
| public boolean | isConnected()Returns the connection state of the socket.
return connectState != ST_NOT_CONNECTED;
|
| public synchronized void | receive(java.net.DatagramPacket p)Receives a datagram packet from this socket. When this method
returns, the DatagramPacket's buffer is filled with
the data received. The datagram packet also contains the sender's
IP address, and the port number on the sender's machine.
This method blocks until a datagram is received. The
length field of the datagram packet object contains
the length of the received message. If the message is longer than
the packet's length, the message is truncated.
If there is a security manager, a packet cannot be received if the
security manager's checkAccept method
does not allow it.
synchronized (p) {
if (!isBound())
bind(new InetSocketAddress(0));
if (connectState == ST_NOT_CONNECTED) {
// check the address is ok with the security manager before every recv.
SecurityManager security = System.getSecurityManager();
if (security != null) {
while(true) {
String peekAd = null;
int peekPort = 0;
// peek at the packet to see who it is from.
if (!oldImpl) {
// We can use the new peekData() API
DatagramPacket peekPacket = new DatagramPacket(new byte[1], 1);
peekPort = getImpl().peekData(peekPacket);
peekAd = peekPacket.getAddress().getHostAddress();
} else {
InetAddress adr = new InetAddress();
peekPort = getImpl().peek(adr);
peekAd = adr.getHostAddress();
}
try {
security.checkAccept(peekAd, peekPort);
// security check succeeded - so now break
// and recv the packet.
break;
} catch (SecurityException se) {
// Throw away the offending packet by consuming
// it in a tmp buffer.
DatagramPacket tmp = new DatagramPacket(new byte[1], 1);
getImpl().receive(tmp);
// silently discard the offending packet
// and continue: unknown/malicious
// entities on nets should not make
// runtime throw security exception and
// disrupt the applet by sending random
// datagram packets.
continue;
}
} // end of while
}
}
if (connectState == ST_CONNECTED_NO_IMPL) {
// We have to do the filtering the old fashioned way since
// the native impl doesn't support connect or the connect
// via the impl failed.
boolean stop = false;
while (!stop) {
// peek at the packet to see who it is from.
InetAddress peekAddress = new InetAddress();
int peekPort = getImpl().peek(peekAddress);
if ((!connectedAddress.equals(peekAddress)) ||
(connectedPort != peekPort)) {
// throw the packet away and silently continue
DatagramPacket tmp = new DatagramPacket(new byte[1], 1);
getImpl().receive(tmp);
} else {
stop = true;
}
}
}
// If the security check succeeds, or the datagram is
// connected then receive the packet
getImpl().receive(p);
}
|
| public void | send(java.net.DatagramPacket p)Sends a datagram packet from this socket. The
DatagramPacket includes information indicating the
data to be sent, its length, the IP address of the remote host,
and the port number on the remote host.
If there is a security manager, and the socket is not currently
connected to a remote address, this method first performs some
security checks. First, if p.getAddress().isMulticastAddress()
is true, this method calls the
security manager's checkMulticast method
with p.getAddress() as its argument.
If the evaluation of that expression is false,
this method instead calls the security manager's
checkConnect method with arguments
p.getAddress().getHostAddress() and
p.getPort(). Each call to a security manager method
could result in a SecurityException if the operation is not allowed.
InetAddress packetAddress = null;
synchronized (p) {
if (isClosed())
throw new SocketException("Socket is closed");
if (connectState == ST_NOT_CONNECTED) {
// check the address is ok wiht the security manager on every send.
SecurityManager security = System.getSecurityManager();
// The reason you want to synchronize on datagram packet
// is because you dont want an applet to change the address
// while you are trying to send the packet for example
// after the security check but before the send.
if (security != null) {
if (p.getAddress().isMulticastAddress()) {
security.checkMulticast(p.getAddress());
} else {
security.checkConnect(p.getAddress().getHostAddress(),
p.getPort());
}
}
} else {
// we're connected
packetAddress = p.getAddress();
if (packetAddress == null) {
p.setAddress(connectedAddress);
p.setPort(connectedPort);
} else if ((!packetAddress.equals(connectedAddress)) ||
p.getPort() != connectedPort) {
throw new IllegalArgumentException("connected address " +
"and packet address" +
" differ");
}
}
// Check whether the socket is bound
if (!isBound())
bind(new InetSocketAddress(0));
// call the method to send
getImpl().send(p);
}
|
| public synchronized void | setBroadcast(boolean on)Enable/disable SO_BROADCAST.
if (isClosed())
throw new SocketException("Socket is closed");
getImpl().setOption(SocketOptions.SO_BROADCAST, Boolean.valueOf(on));
|
| public static synchronized void | setDatagramSocketImplFactory(java.net.DatagramSocketImplFactory fac)Sets the datagram socket implementation factory for the
application. The factory can be specified only once.
When an application creates a new datagram socket, the socket
implementation factory's createDatagramSocketImpl method is
called to create the actual datagram socket implementation.
Passing null to the method is a no-op unless the factory
was already set.
If there is a security manager, this method first calls
the security manager's checkSetFactory method
to ensure the operation is allowed.
This could result in a SecurityException.
if (factory != null) {
throw new SocketException("factory already defined");
}
SecurityManager security = System.getSecurityManager();
if (security != null) {
security.checkSetFactory();
}
factory = fac;
|
| public synchronized void | setReceiveBufferSize(int size)Sets the SO_RCVBUF option to the specified value for this
DatagramSocket. The SO_RCVBUF option is used by the
the network implementation as a hint to size the underlying
network I/O buffers. The SO_RCVBUF setting may also be used
by the network implementation to determine the maximum size
of the packet that can be received on this socket.
Because SO_RCVBUF is a hint, applications that want to
verify what size the buffers were set to should call
{@link #getReceiveBufferSize()}.
Increasing SO_RCVBUF may allow the network implementation
to buffer multiple packets when packets arrive faster than
are being received using {@link #receive(DatagramPacket)}.
Note: It is implementation specific if a packet larger
than SO_RCVBUF can be received.
if (size <= 0) {
throw new IllegalArgumentException("invalid receive size");
}
if (isClosed())
throw new SocketException("Socket is closed");
getImpl().setOption(SocketOptions.SO_RCVBUF, new Integer(size));
|
| public synchronized void | setReuseAddress(boolean on)Enable/disable the SO_REUSEADDR socket option.
For UDP sockets it may be necessary to bind more than one
socket to the same socket address. This is typically for the
purpose of receiving multicast packets
(See {@link java.net.MulticastSocket}). The
SO_REUSEADDR socket option allows multiple
sockets to be bound to the same socket address if the
SO_REUSEADDR socket option is enabled prior
to binding the socket using {@link #bind(SocketAddress)}.
Note: This functionality is not supported by all existing platforms,
so it is implementation specific whether this option will be ignored
or not. However, if it is not supported then
{@link #getReuseAddress()} will always return false.
When a DatagramSocket is created the initial setting
of SO_REUSEADDR is disabled.
The behaviour when SO_REUSEADDR is enabled or
disabled after a socket is bound (See {@link #isBound()})
is not defined.
if (isClosed())
throw new SocketException("Socket is closed");
// Integer instead of Boolean for compatibility with older DatagramSocketImpl
if (oldImpl)
getImpl().setOption(SocketOptions.SO_REUSEADDR, new Integer(on?-1:0));
else
getImpl().setOption(SocketOptions.SO_REUSEADDR, Boolean.valueOf(on));
|
| public synchronized void | setSendBufferSize(int size)Sets the SO_SNDBUF option to the specified value for this
DatagramSocket. The SO_SNDBUF option is used by the
network implementation as a hint to size the underlying
network I/O buffers. The SO_SNDBUF setting may also be used
by the network implementation to determine the maximum size
of the packet that can be sent on this socket.
As SO_SNDBUF is a hint, applications that want to verify
what size the buffer is should call {@link #getSendBufferSize()}.
Increasing the buffer size may allow multiple outgoing packets
to be queued by the network implementation when the send rate
is high.
Note: If {@link #send(DatagramPacket)} is used to send a
DatagramPacket that is larger than the setting
of SO_SNDBUF then it is implementation specific if the
packet is sent or discarded.
if (!(size > 0)) {
throw new IllegalArgumentException("negative send size");
}
if (isClosed())
throw new SocketException("Socket is closed");
getImpl().setOption(SocketOptions.SO_SNDBUF, new Integer(size));
|
| public synchronized void | setSoTimeout(int timeout)Enable/disable SO_TIMEOUT with the specified timeout, in
milliseconds. With this option set to a non-zero timeout,
a call to receive() for this DatagramSocket
will block for only this amount of time. If the timeout expires,
a java.net.SocketTimeoutException is raised, though the
DatagramSocket is still valid. The option must be enabled
prior to entering the blocking operation to have effect. The
timeout must be > 0.
A timeout of zero is interpreted as an infinite timeout.
if (isClosed())
throw new SocketException("Socket is closed");
getImpl().setOption(SocketOptions.SO_TIMEOUT, new Integer(timeout));
|
| public synchronized void | setTrafficClass(int tc)Sets traffic class or type-of-service octet in the IP
datagram header for datagrams sent from this DatagramSocket.
As the underlying network implementation may ignore this
value applications should consider it a hint.
The tc must be in the range 0 <= tc <=
255 or an IllegalArgumentException will be thrown.
Notes:
for Internet Protocol v4 the value consists of an octet
with precedence and TOS fields as detailed in RFC 1349. The
TOS field is bitset created by bitwise-or'ing values such
the following :-
IPTOS_LOWCOST (0x02)IPTOS_RELIABILITY (0x04)IPTOS_THROUGHPUT (0x08)IPTOS_LOWDELAY (0x10)
The last low order bit is always ignored as this
corresponds to the MBZ (must be zero) bit.
Setting bits in the precedence field may result in a
SocketException indicating that the operation is not
permitted.
for Internet Protocol v6 tc is the value that
would be placed into the sin6_flowinfo field of the IP header.
if (tc < 0 || tc > 255)
throw new IllegalArgumentException("tc is not in range 0 -- 255");
if (isClosed())
throw new SocketException("Socket is closed");
getImpl().setOption(SocketOptions.IP_TOS, new Integer(tc));
|
