At a high level this is how UDP servers work:
Create a socket
Bind the socket to a specific address and port (through the OS)
Listen for messages at that specific address and port
Here's how we do these steps in Zig:
Create a socket
We need to tell the OS to create a socket via the std.os.socket function.
Here's its signature:
fn socket(domain: u32, socket_type: u32, protocol: u32) SocketError!socket_t
domain refers to the IP address family: i.e. IPv4, or IPv6.
socket_type is exactly what it sounds like. We'll use DGRAM (datagram) to signal we're making a UDP socket.
protocol is for when we support multiple protocols for our server. For our simple one we only support 1 protocol: UDP. By passing a 0 we're telling the system to use the inferred protocol.
We get a socket_t from this to represent a socket.
const sock = try std.os.socket(std.os.AF.INET, std.os.SOCK.DGRAM, 0);
bind the socket
Next we need to tell the OS to bind the socket to a specific port and address so we can listen for messages.
Here's the function signature for bind
fn bind(sock: socket_t, addr: *const sockaddr, len: socklen_t) BindError!void
sock is the socket we created from earlier (remember the socket_t )
addr is a pointer to a sockaddr struct
len is the size of the Address struct. Use the getOsSockLen method from our Address instance.
Let's talk about how to get the sockaddr instance:
First we need to give the socket an address via: parseIP4 Here's the function signature:
fn parseIp4(buf: []const u8, port: u16) !Address
the buf is the IP (idk why it's called a buf here)
From this we get an Address instance.
Address looks like this:
pub const Address = extern union {
any: os.sockaddr,
in: Ip4Address,
in6: Ip6Address,
....
We can use the .any to access the socket address!
It needs a pointer so be sure to pass the address (via & )
We have this so far:
const std = @import("std");
const os = std.os;
pub fn main() !void {
const sock = try std.os.socket(std.os.AF.INET, std.os.SOCK.DGRAM, 0);
const parsed_address = try std.net.Address.parseIp4("127.0.0.1", 3000);
try os.bind(socket, address.any, address.getOsSockLen());
}
Listen for messages
We'll use the recvfrom provided by the OS. This will get us the data from the socket without the address from the client.
The signature looks like this:
fn recvfrom(
sockfd: socket_t,
buf: []u8,
flags: u32,
src_addr: ?*sockaddr,
addrlen: ?*socklen_t,
) RecvFromError!usize
It needs a few things:
what socket we're wanting to listen to (sockfd)
A buffer to put the bytes it gets from the stream
The rest of the args from the signature aren't needed in this example.
Be sure to stick recvfrom in a persisted loop to keep listening for data.
Code example
const std = @import("std");
const expect = std.testing.expect;
const net = std.net;
const os = std.os;
test "create a socket" {
var socket = try Socket.init("127.0.0.1", 3000);
try expect(@TypeOf(socket.socket) == std.os.socket_t);
}
const Socket = struct {
address: std.net.Address,
socket: std.os.socket_t,
fn init(ip: []const u8, port: u16) !Socket {
const parsed_address = try std.net.Address.parseIp4(ip, port);
const sock = try std.os.socket(std.os.AF.INET, std.os.SOCK.DGRAM, 0);
errdefer os.closeSocket(sock);
return Socket{ .address = parsed_address, .socket = sock };
}
fn bind(self: *Socket) !void {
try os.bind(self.socket, &self.address.any, self.address.getOsSockLen());
}
fn listen(self: *Socket) !void {
var buffer: [1024]u8 = undefined;
while (true) {
const received_bytes = try std.os.recvfrom(self.socket, buffer[0..], 0, null, null);
std.debug.print("Received {d} bytes: {s}\n", .{ received_bytes, buffer[0..received_bytes] });
}
}
};
Interacting with the server
We can run nc -u 127.0.0.1 3000 to interact with the UDP server. Be sure to pass the -u flag to tell netcat that this is a UDP connection as it defaults to TCP.
Thanks for reading :)
