Allow UDP broadcasts

[captain0xff]

SDL2_net had a way to enable or disable UDP broadcasts

SDL_net/src/SDLnetUDP.c

Line 185 in 8e1e4bf

#ifdef SO_BROADCAST

it will be nice to also have them in SDL3_net.

[icculus]

So the problem is broadcasts are an IPv4 subnet thing. This concept is entirely gone from IPv6, where they have something called "anycast" addresses, but it requires configuring entire groups of computers to use it...it's not like IPv4 where you just send a packet to the .255 address and things that care listen for it.

[captain0xff]

Oh, I was not aware of this. Ig I will have to find a better solution for server discovery. Anyways, thank you for answering. You can close the issue if you want.

[icculus]

So Wikipedia has this to say:

Internet Protocol version 6 (IPv6) does not implement this method of broadcast, and therefore does not define broadcast addresses. Instead, IPv6 uses multicast addressing to the all-hosts multicast group. No IPv6 protocols are defined to use the all-hosts address, though; instead, they send and receive on particular link-local multicast addresses. This results in higher efficiency because network hosts can filter traffic based on multicast address and do not need to process all broadcasts or all-hosts multicasts.

...so maybe this is doable? I'll leave this open for now until I research more.

[captain0xff]

Found an multicast example that seems to work for me.
https://gist.github.com/hostilefork/f7cae3dc33e7416f2dd25a402857b6c6

[icculus]

Current proposed API:

/**
 * Obtain a NET_Address usable for broadcasting.
 *
 * **WARNING**: The function exists largely for compatibility with existing
 * software. In software that doesn't have to talk to legacy programs that
 * use broadcasting, you are encouraged to use NET_CreateMulticastAddress()
 * instead.
 *
 * Broadcast packets are (more or less) sent to every machine on the LAN,
 * unconditionally. It can be used to alert everyone of the availability of
 * a service (such as a game server) without a more formal discovery
 * mechanism.
 *
 * Addresses returned from this are usable with NET_CreateDatagramSocket()
 * to listen for broadcasts on the LAN, and can be used with
 * NET_SendDatagram() to send broadcast packets.
 *
 * A successfully-returned address does not need to resolve
 * (NET_WaitUntilResolved() would not block and NET_GetAddressStatus() will
 * always report NET_SUCCESS) and can be used immediately.
 *
 * **WARNING**: It is possible to build a game where everyone is playing on
 * the same LAN, and every player is simply sending packets to the broadcast
 * address. This is absolutely the wrong thing to do, however. Broadcast
 * packets go to every device on the LAN, whether they want them or not. The
 * game DOOM, in its heyday, was capable of [bringing entire networks to their
 * knees](https://doomwiki.org/wiki/Doom_in_workplaces),
 * as many players on the same network would all be broadcasting relentlessly.
 *
 * In practice, broadcasting sparingly can be useful for certain
 * functionality: a LAN-only server reporting that it exists by broadcasting
 * a single packet every few seconds is reasonable and safe. Once clients
 * see the broadcast packet, they can talk to the server directly without
 * broadcasting. For peer-to-peer games, once connection is established, it's
 * better to either send unique packets to each known player, or use a
 * multicast address (which works like broadcast, but only routes packets to
 * devices that are explicitly listening for it).
 *
 * The `interface` parameter is meant to be an interface address to use for
 * broadcast, as different interfaces may be talking to different subnets. You
 * can get a list of valid interfaces for the system from NET_GetLocalAddresses().
 * Passing a NULL for `interface` will select a reasonable default (and/or
 * every available interface together).
 *
 * In IPv4, the broadcast address is either 255.255.255.255 (broadcast to all
 * interfaces on the machine), or XXX.XXX.XXX.255 (broadcast to a specific
 * interface's subnet). In IPv6, this is actually faked with multicast to the
 * all-nodes link-local multicast group, ff02::1, either on a specific
 * interface or letting the OS choose the default. Other protocols might fake
 * broadcast operations in similar ways in the future.
 *
 * \param interface the interface to use for broadcasting. May be NULL.
 * \returns a address that can be used for multicast transmission.
 */
extern SDL_DECLSPEC NET_Address * SDLCALL NET_CreateBroadcastAddress(NET_Address *interface);

/**
 * Obtain a NET_Address usable for multicasting.
 *
 * Multicasting sends packets to every machine on the LAN that is interested
 * in a given service. This works by choosing an address from a magic range
 * that routers know to treat differently, and individual machines reporting
 * interest in that address to the routers so packets are sent to them.
 *
 * It can be used to alert everyone of the availability of a service (such as
 * a game server) in an ad-hoc manner without sending data to every device
 * on the LAN.
 *
 * Addresses returned from this are usable with NET_CreateDatagramSocket()
 * to listen for multicasts on the LAN, and can be used with
 * NET_SendDatagram() to send multicast packets.
 *
 * A successfully-returned address does not need to resolve
 * (NET_WaitUntilResolved() would not block and NET_GetAddressStatus() will
 * always report NET_SUCCESS) and can be used immediately.
 *
 * The `interface` parameter is meant to be an interface address to use for
 * broadcast, as different interfaces may be talking to different subnets. You
 * can get a list of valid interfaces for the system from NET_GetLocalAddresses().
 * Passing a NULL for `interface` will select a reasonable default (and/or
 * every available interface together).
 *
 * Actual multicast addresses are chosen based on the "group" this function
 * requests. This is used to pick the proper multicast address in a protocol
 * independent way. In practice, SDL_Net will mask the group number against
 * the available addresses and use it as an offset from a base address.
 * There are about 28 bits in IPv4 and 112 in IPv6. This function does not make
 * the entire IPv6 range available, and is slightly larger than what IPv4 can
 * offer; a safe group number that works with both is less than 268 million,
 * but this is plenty of space; unrelated things can join the same multicast
 * address and use a different port without collisions.
 *
 * \param group a group number to join, which will decide the actual address.
 * \param interface the interface to use for broadcasting. May be NULL.
 * \returns a address that can be used for multicast transmission.
 */
extern SDL_DECLSPEC NET_Address * SDLCALL NET_CreateMulticastAddress(Uint32 group, NET_Address *interface);

[slouken]

This actually doesn't work for broadcast. There's no single address that you can send to, unless we have an internal magic address that we interpret specially. On iOS and Windows you have to enumerate network devices and send to each broadcast address individually.

Check out a proposed (very prototype) implementation here:
https://github.com/slouken/Maelstrom/blob/96322d2d9c50b27df5a26c0589177ccec1e86b2d/game/lobby.cpp#L522

[icculus]

Yeah, the plan is to track which addresses are broadcast/multicast internally and do the right thing with them (join the multicast group, broadcast on all interfaces, etc).

We'll see if it works out when I implement it.

[slouken]

Yeah, the plan is to track which addresses are broadcast/multicast internally and do the right thing with them (join the multicast group, broadcast on all interfaces, etc).

Oh yeah, that makes sense.

[icculus]

Man, this adds so much platform-specific code to deal with managing network interfaces. :/

I'm generalizing things to enumerate network interfaces, starting from the NET_GetLocalAddresses() implementation, and then update it if the system reports the interfaces changed in some way. Should be efficient, doesn't need to poll for changes so far. If someone uses NET_GetLocalAddresses or a broadcast/multicast, it'll enable that code, otherwise it never runs.

We need this for more than working around 255.255.255.255 not working on some platforms. IPv6 will need it always, and on IPv4, x.x.x.255 might not be the broadcast address!

So this is the right thing to do. But this is becoming a whole dang thing. :/

[slouken]

So this is the right thing to do. But this is becoming a whole dang thing. :/

Yup!