The local address to which the socket is bound.
The local address to which the socket is bound.
the address
Whether or not the socket's broadcast flag is set.
Whether or not the socket's broadcast flag is set. The broadcast
flag corresponds to the SO_BROADCAST
socket option. When
this option is enabled, datagram sockets will receive packets sent
to a broadcast address, and they are permitted to send packets to a
broadcast address.
whether or not the broadcast flag is set
Change the value of the socket's broadcast flag.
Change the value of the socket's broadcast flag. The broadcast flag
corresponds to the SO_BROADCAST
socket option. When this
option is enabled, datagram sockets will receive packets sent to a
broadcast address, and they are permitted to send packets to a
broadcast address.
true
to enable broadcast, false
to disable it.
Close the socket.
The local port to which the socket is bound.
Receive a buffer of bytes from the socket, writing them into a caller-supplied fixed-size buffer.
Receive a buffer of bytes from the socket, writing them into a caller-supplied fixed-size buffer. One simple way to create such a buffer:
// Create a 512-byte buffer initialized to zeros. val buf = Array.make[Byte](512, 0)
the buf into which to read the data
actual number of bytes read
Send data over the socket.
Send data over the socket. Accepts any sequence of bytes (e.g.,
Array[Byte]
, List[Byte]
).
the bytes to send
Receive a buffer of bytes from the socket.
Receive a buffer of bytes from the socket. The buffer is dynamically
allocated and returned. For more efficiency, use the version of
receive()
that takes a caller-supplied buffer.
maximum number of bytes to receive
a tuple containing the buffer of data (of size length
)
and the actual number of bytes read. The buffer might be longer
than the number of bytes read.
Receive a string from the socket, using a caller-supplied receive buffer to hold the bytes actually received over the wire.
Receive a string from the socket, using a caller-supplied receive buffer to hold the bytes actually received over the wire. The string is assumed to have been encoded in UTF-8 for transmission and is decoded accordingly.
the buf into which to read the data
the string
Receive a string from the socket, using a caller-supplied receive buffer to hold the bytes actually received over the wire.
Receive a string from the socket, using a caller-supplied receive buffer to hold the bytes actually received over the wire. The string is assumed to have been encoded in the specified encoding and is decoded accordingly.
the buf into which to read the data
the encoding to use when decoding the string
the string
Receive a string from the socket.
Receive a string from the socket. The string is assumed to have been encoded in UTF-8 for transmission and is decoded accordingly.
maximum number of bytes (not characters) expected
the string
Receive a string from the socket.
Receive a string from the socket. The string is assumed to have been encoded in the specified encoding and is decoded accordingly.
maximum number of bytes (not characters) expected
the encoding to use when decoding the string
the string
Send string data over the socket.
Send string data over the socket. Converts the string to UTF-8 bytes, then sends the bytes.
the string to send
the IP address to receive the string
the destination port on the remote machine
Send string data over the socket.
Send string data over the socket. The internal UTF-16 strings are converted to the specified encoding before being sent.
the string to send
the encoding to use
the IP address to receive the string
the destination port on the remote machine
A
UDPDatagramSocket
object represents a UDP datagram socket, providing a simpler interface to sending and receiving UDP packets than the one provided by the Java JDK.Sending UDP Datagrams
The easiest way to explain how to use this API is with some code. So, without further ado, the following example shows how you might send the string "foo" to port 2003 on host "foo.example.com".
That's pretty simple. However, using the utility methods provided by the
UDPDatagramSocket
companion object, we can further simplify the above code:The
sendString()
method in the companion object takes care of allocating the socket, sending the packet, and closing the socket. Obviously, if you're planning on sending multiple packets at once, you'll want to use the first example (perhaps in a loop), so you're not constantly allocating and deallocating sockets. But sending a one-shot UDP packet can be as simple as one line of code, as shown in the second example.Sending binary data is not much more complicated. You have to convert the data to a stream of bytes, which the server must then decode. After that, however, sending the bytes isn't much more difficult than sending a string. Here's an example, which assumes that you have already encoded the data to be send into an array of bytes.
Once again, there's a simple utility method that does most of the work for you:
Receiving UDP Datagrams
When receiving UDP datagrams, you must first bind to an incoming socket. That is, you must listen on the port to which clients are sending their packets. In this example, we create the socket object with the receiving port, and we allow the wildcard address to be used on the local machine (permitting us to receive packets on any interface).
Next, we want to receive and process the incoming data. Let's assume that we're receiving the "foo" string (or, for that matter, any string) being sent by the sample sender, above.
That code says, "Wait for incoming strings, using a 1024-byte buffer. Then, decode the strings and print them to standard output.
Receiving bytes isn't much more difficult.
The above loop can be made even simpler (though a little more obscure), since the
receive()
method is filling our buffer and returning a count of the number of bytes it put into the buffer: