class UDPSocket


A User Datagram Protocol socket. UDP runs on top of the Internet Protocol (IP) and was developed for applications that do not require reliability, acknowledgement, or flow control features at the transport layer. This simple protocol provides transport layer addressing in the form of UDP ports and an optional checksum capability.

UDP is a very simple protocol. Messages, so called datagrams, are sent to other hosts on an IP network without the need to set up special transmission channels or data paths beforehand. The UDP socket only needs to be opened for communication. It listens for incoming messages and sends outgoing messages on request.

This implementation supports both IPv4 and IPv6 addresses. For IPv4 addresses you need use Socket::Family::INET family (used by default). And Socket::Family::INET6 for IPv6 addresses accordingly.

Usage example:

require "socket"

# Create server
server =
server.bind "localhost", 1234

# Create client and connect to server
client =
client.connect "localhost", 1234

client.puts "message" # send message to server
server.gets           # => "message\n"

# Close client and server

The #send methods may sporadically fail with Errno::ECONNREFUSED when sending datagrams to a non-listening server. Wrap with an exception handler to prevent raising. Example:

  client.send(message, @destination)
rescue ex : Errno
  if ex.errno == Errno::ECONNREFUSED
    p ex.inspect

Defined in:


Class Method Summary

Instance Method Summary

Instance methods inherited from class IPSocket

local_address local_address, remote_address remote_address

Class methods inherited from class IPSocket

getaddrinfo(host, port, family, socktype, protocol = LibC::IPPROTO_IP, timeout = nil, &block) getaddrinfo

Instance methods inherited from class Socket

broadcast=(val : Bool) broadcast=, broadcast? broadcast?, close_read close_read, close_write close_write, getsockopt(optname, optval, level = LibC::SOL_SOCKET) getsockopt, inspect(io) inspect, keepalive=(val : Bool) keepalive=, keepalive? keepalive?, linger linger, linger=(val : Int | Nil) linger=, recv_buffer_size recv_buffer_size, recv_buffer_size=(val : Int32) recv_buffer_size=, reuse_address=(val : Bool) reuse_address=, reuse_address? reuse_address?, send_buffer_size send_buffer_size, send_buffer_size=(val : Int32) send_buffer_size=, setsockopt(optname, optval, level = LibC::SOL_SOCKET) setsockopt

Class methods inherited from class Socket

new(fd, blocking = false) new

Instance methods inherited from class IO::FileDescriptor

blocking blocking, blocking=(value) blocking=, close_on_exec=(arg : Bool) close_on_exec=, close_on_exec? close_on_exec?, closed? : Bool closed?, fcntl(cmd, arg = 0) fcntl, fd : Int32 fd, finalize finalize, pos pos, pos=(value) pos=, read_timed_out : Bool read_timed_out, read_timed_out=(read_timed_out : Bool) read_timed_out=, read_timeout=(read_timeout : Number)
read_timeout=(read_timeout : Time::Span)
read_timeout=(read_timeout : Nil)
, reopen(other : IO::FileDescriptor) reopen, seek(offset, whence : Seek = Seek::Set) seek, stat stat, tell tell, to_fd_io to_fd_io, tty? tty?, write_timed_out : Bool write_timed_out, write_timed_out=(write_timed_out : Bool) write_timed_out=, write_timeout=(write_timeout : Number)
write_timeout=(write_timeout : Time::Span)
write_timeout=(write_timeout : Nil)

Class methods inherited from class IO::FileDescriptor

fcntl(fd, cmd, arg = 0) fcntl, new(fd : Int32, blocking = false, edge_triggerable = false) new

Instance methods inherited from module IO::Buffered

close close, flush flush, flush_on_newline=(flush_on_newline) flush_on_newline=, flush_on_newline? flush_on_newline?, read(slice : Slice(UInt8)) read, rewind rewind, sync=(sync) sync=, sync? sync?, unbuffered_close unbuffered_close, unbuffered_flush unbuffered_flush, unbuffered_read(slice : Slice(UInt8)) unbuffered_read, unbuffered_rewind unbuffered_rewind, unbuffered_write(slice : Slice(UInt8)) unbuffered_write, write(slice : Slice(UInt8)) write

Instance methods inherited from module IO

<<(obj) : self <<, close close, closed? closed?, cooked(&block) cooked, cooked! cooked!, each_byte
, each_char(&block)
, each_line(*args)
each_line(*args, &block)
, encoding : String encoding, flush flush, gets(limit : Int) : String | Nil
gets(delimiter : Char, limit : Int) : String | Nil
gets(delimiter : Char) : String | Nil
gets : String | Nil
gets(delimiter : String) : String | Nil
, gets_to_end : String gets_to_end, print(obj) : Nil
print(*objects : _) : Nil
, printf(format_string, *args) : Nil
printf(format_string, args : Array | Tuple) : Nil
, puts : Nil
puts(*objects : _) : Nil
puts(string : String) : Nil
puts(obj) : Nil
, raw(&block) raw, raw! raw!, read(slice : Slice(UInt8)) read, read_byte : UInt8 | Nil read_byte, read_bytes(type, format : IO::ByteFormat = IO::ByteFormat::SystemEndian) read_bytes, read_char : Char | Nil read_char, read_fully(slice : Slice(UInt8)) read_fully, read_line(*args) : String | Nil read_line, read_nonblock(size) read_nonblock, read_utf8(slice : Slice(UInt8)) read_utf8, read_utf8_byte read_utf8_byte, rewind rewind, set_encoding(encoding : String, invalid : Symbol | Nil = nil) set_encoding, skip(bytes_count : Int) : Nil skip, tty? : Bool tty?, write(slice : Slice(UInt8)) : Nil write, write_byte(byte : UInt8) write_byte, write_bytes(object, format : IO::ByteFormat = IO::ByteFormat::SystemEndian) write_bytes, write_utf8(slice : Slice(UInt8)) write_utf8

Class methods inherited from module IO

copy(src, dst) copy, pipe(read_blocking = false, write_blocking = false, &block)
pipe(read_blocking = false, write_blocking = false)
, select(read_ios, write_ios, error_ios, timeout_sec : LibC::TimeT | Int | Float | Nil)
select(read_ios, write_ios = nil, error_ios = nil)

Instance methods inherited from module JSON::Builder

json_array(&block) json_array, json_object(&block) json_object

Instance methods inherited from class Reference

==(other : self)
, hash hash, inspect(io : IO) : Nil inspect, object_id : UInt64 object_id, same?(other : Reference)
same?(other : Nil)
, to_s(io : IO) : Nil to_s

Instance methods inherited from class Object

!=(other) !=, !~(other) !~, ==(other) ==, ===(other)
===(other : YAML::Any)
===(other : JSON::Any)
, =~(other) =~, class class, clone clone, crystal_type_id crystal_type_id, dup dup, hash hash, inspect
inspect(io : IO)
, itself itself, not_nil! not_nil!, tap(&block) tap, to_json to_json, to_pretty_json(io : IO)
, to_s
to_s(io : IO)
, to_yaml(io : IO)
, try(&block) try

Class methods inherited from class Object

==(other : Class) ==, ===(other) ===, cast(other) : self cast, from_json(string_or_io) : self from_json, from_yaml(string : String) : self from_yaml, hash hash, inspect(io) inspect, name : String name, to_s(io) to_s, |(other : U.class) |

Class Method Detail

def : Socket::Family = Socket::Family::INET) #

[View source]

Instance Method Detail

def bind(host, port, dns_timeout = nil) #

Creates a UDP socket from the given address.

server =
server.bind "localhost", 1234

[View source]
def connect(host, port, dns_timeout = nil, connect_timeout = nil) #

Attempts to connect the socket to a remote address and port for this socket.

client =
client.connect "localhost", 1234

[View source]
def receive(slice : Slice(UInt8)) : Tuple(Int32, IPAddress) #

[View source]
def send(slice : Slice(UInt8)) #

[View source]
def send(string : String) #

[View source]
def send(string : String, addr : IPAddress) #

[View source]
def send(slice : Slice(UInt8), addr : IPAddress) #

[View source]