package core:net

Source

Accept_Error :: enum i32 {
	None, 
	// No network connection, or the network stack is not initialized.
	Network_Unreachable, 
	// Not enough space in internal tables/buffers to create a new socket, or an unsupported protocol is given.
	Insufficient_Resources, 
	// Invalid socket, or options.
	Invalid_Argument, 
	// The given socket does not support accepting connections.
	Unsupported_Socket, 
	// accept called on a socket which is not listening.
	Not_Listening, 
	// A connection arrived but was closed while in the listen queue.
	Aborted, 
	// Timed out before being able to accept a connection.
	Timeout, 
	// Non-blocking socket that would need to block waiting for a connection.
	Would_Block, 
	// Interrupted by a signal or other method of cancellation like WSACancelBlockingCall on Windows.
	Interrupted, 
	// An error unable to be categorized in above categories, `last_platform_error` may have more info.
	Unknown, 
}

Address :: union {
	IP4_Address, 
	IP6_Address, 
}

Address_Duplication :: enum i32 {
	Invalid    = 0, 
	Tentative  = 1, 
	Duplicate  = 2, 
	Deprecated = 3, 
	Preferred  = 4, 
}

Address_Family :: enum int {
	IP4, 
	IP6, 
}

Any_Socket :: union {
	TCP_Socket, 
	UDP_Socket, 
}

Bind_Error :: enum i32 {
	None, 
	// No network connection, or the network stack is not initialized.
	Network_Unreachable, 
	// Not enough space in internal tables/buffers to create a new socket, or an unsupported protocol is given.
	Insufficient_Resources, 
	// Invalid socket or endpoint, or invalid combination of the two.
	Invalid_Argument, 
	// The socket is already bound to an address.
	Already_Bound, 
	// The address is protected and the current user has insufficient permissions to access it.
	Insufficient_Permissions_For_Address, 
	// The address is already in use.
	Address_In_Use, 
	// An error unable to be categorized in above categories, `last_platform_error` may have more info.
	Unknown, 
}

Create_Socket_Error :: enum i32 {
	None, 
	// No network connection, or the network stack is not initialized.
	Network_Unreachable, 
	// Not enough space in internal tables/buffers to create a new socket, or an unsupported protocol is given.
	Insufficient_Resources, 
	// Invalid/unsupported family or protocol.
	Invalid_Argument, 
	// The user has no permission to create a socket of this type and/or protocol.
	Insufficient_Permissions, 
	// An error unable to be categorized in above categories, `last_platform_error` may have more info.
	Unknown, 
}

DNS_Configuration :: struct {
	// Configuration files.
	resolv_conf:        string,
	hosts_file:         string,
	// TODO: Allow loading these up with `reload_configuration()` call or the like,
	// so we don't have to do it each call.
	name_servers:       []Endpoint,
	hosts_file_entries: []DNS_Record,
}

DNS_Error :: enum u32 {
	None                        = 0, 
	Invalid_Hostname_Error      = 1, 
	Invalid_Hosts_Config_Error, 
	Invalid_Resolv_Config_Error, 
	Connection_Error, 
	Server_Error, 
	System_Error, 
}

DNS_Header :: struct {
	id:                     u16be,
	is_response:            bool,
	opcode:                 u16be,
	is_authoritative:       bool,
	is_truncated:           bool,
	is_recursion_desired:   bool,
	is_recursion_available: bool,
	response_code:          DNS_Response_Code,
}

DNS_Host_Entry :: struct {
	name: string,
	addr: Address,
}

DNS_Query :: enum u16be {
	Host_Address              = 1, 
	Authoritative_Name_Server = 2, 
	Mail_Destination          = 3, 
	Mail_Forwarder            = 4, 
	CNAME                     = 5, 
	All                       = 255, 
}

DNS_Record :: union {
	DNS_Record_IP4, 
	DNS_Record_IP6, 
	DNS_Record_CNAME, 
	DNS_Record_TXT, 
	DNS_Record_NS, 
	DNS_Record_MX, 
	DNS_Record_SRV, 
}

DNS_Record_Base :: struct {
	record_name: string,
	ttl_seconds: u32,
}

DNS_Record_CNAME :: struct {
	using base: DNS_Record_Base,
	host_name: string,
}

DNS_Record_Header :: struct #packed {
	type:   u16be,
	class:  u16be,
	ttl:    u32be,
	length: u16be,
}

DNS_Record_IP4 :: struct {
	using base: DNS_Record_Base,
	address: IP4_Address,
}

DNS_Record_IP6 :: struct {
	using base: DNS_Record_Base,
	address: IP6_Address,
}

DNS_Record_MX :: struct {
	using base: DNS_Record_Base,
	host_name:  string,
	preference: int,
}

DNS_Record_NS :: struct {
	using base: DNS_Record_Base,
	host_name: string,
}

DNS_Record_SRV :: struct {
	// base contains the full name of this record.
	// e.g: _sip._tls.example.com
	using base:    DNS_Record_Base,
	// The hostname or address where this service can be found.
	target:        string,
	// The port on which this service can be found.
	port:          int,
	service_name:  string,
	// NOTE(tetra): These are substrings of 'record_name'
	protocol_name: string,
	// Lower is higher priority
	priority:      int,
	// Relative weight of this host compared to other of same priority; the chance of using this host should be proporitional to this weight.
	// The number of seconds that it will take to update the record.
	weight:        int,
}

DNS_Record_TXT :: struct {
	using base: DNS_Record_Base,
	value: string,
}

DNS_Record_Type :: enum u16 {
	DNS_TYPE_A     = 1,  // IP4 address.
	DNS_TYPE_NS    = 2,  // IP6 address.
	DNS_TYPE_CNAME = 5,  // Another host name.
	DNS_TYPE_MX    = 15, // Arbitrary binary data or text.
	DNS_TYPE_AAAA  = 28, // Address of a name (DNS) server.
	DNS_TYPE_TEXT  = 16, // Address and preference priority of a mail exchange server.
	DNS_TYPE_SRV   = 33, // Address, port, priority, and weight of a host that provides a particular service.
	IP4            = 1, 
	IP6            = 28, 
	CNAME          = 5, 
	TXT            = 16, 
	NS             = 2, 
	MX             = 15, 
	SRV            = 33, 
}

DNS_Response_Code :: enum u16be {
	No_Error, 
	Format_Error, 
	Server_Failure, 
	Name_Error, 
	Not_Implemented, 
	Refused, 
}

Dial_Error :: enum i32 {
	None, 
	// No network connection, or the network stack is not initialized.
	Network_Unreachable, 
	// Not enough space in internal tables/buffers to create a new socket, or an unsupported protocol is given.
	Insufficient_Resources, 
	// Invalid endpoint and/or options.	
	Invalid_Argument, 
	// An attempt was made to connect to a broadcast socket on a socket that doesn't support it.
	Broadcast_Not_Supported, 
	// The socket is already connected.
	Already_Connected, 
	// The socket is already in the progress of making a connection.
	Already_Connecting, 
	// The address is already in use.
	Address_In_Use, 
	// Could not reach the remote host.
	Host_Unreachable, 
	// The remote host refused the connection or isn't listening.
	Refused, 
	// The connection was reset by the remote host.
	Reset, 
	// Timed out before making a connection.
	Timeout, 
	// Non-blocking socket that would need to block waiting to connect.
	Would_Block, 
	// Interrupted by a signal or other method of cancellation like WSACancelBlockingCall on Windows.
	Interrupted, 
	// Endpoint given without a port, which is required.
	Port_Required, 
	// An error unable to be categorized in above categories, `last_platform_error` may have more info.
	Unknown, 
}

Digit_Parse_Base :: enum u8 {
	Dec  = 0, // No prefix
	Oct  = 1, // Leading zero
	Hex  = 2, // 0x prefix
	IPv6 = 3, // Unprefixed IPv6 piece hex. Can't be used with other bases.
}

Digit_Parse_Bases :: bit_set[Digit_Parse_Base; u8]

Endpoint :: struct {
	address: Address,
	port:    int,
}

Host :: struct {
	hostname: string,
	port:     int,
}

Host_Or_Endpoint :: union {
	Host, 
	Endpoint, 
}

IP4_Address :: distinct [4]u8

IP6_Address :: distinct [8]u16be

Interfaces_Error :: enum u32 {
	None, 
	Unable_To_Enumerate_Network_Interfaces, 
	Allocation_Failure, 
	Unknown, 
}

Lease :: struct {
	address:             Address,
	netmask:             Netmask,
	lifetime:            struct {
		valid:     u32,
		preferred: u32,
		lease:     u32,
	},
	origin:              struct {
		prefix: Prefix_Origin,
		suffix: Suffix_Origin,
	},
	address_duplication: Address_Duplication,
}

Link_State :: bit_set[Link_States; u32]

Link_States :: enum u32 {
	Up               = 1, 
	Down             = 2, 
	Testing          = 3, 
	Dormant          = 4, 
	Not_Present      = 5, 
	Lower_Layer_Down = 6, 
	Loopback         = 7, 
}

Listen_Error :: enum i32 {
	None, 
	// No network connection, or the network stack is not initialized.
	Network_Unreachable, 
	// Not enough space in internal tables/buffers to create a new socket, or an unsupported protocol is given.
	Insufficient_Resources, 
	// The socket or backlog is invalid.
	Invalid_Argument, 
	// The socket is valid, but does not support listening.
	Unsupported_Socket, 
	// The socket is already connected.
	Already_Connected, 
	// The address is already in use.
	Address_In_Use, 
	// An error unable to be categorized in above categories, `last_platform_error` may have more info.
	Unknown, 
}

Maybe :: runtime.Maybe

Netmask :: union {
	IP4_Address, 
	IP6_Address, 
}

Network_Error :: union {
	Create_Socket_Error, 
	Dial_Error, 
	Listen_Error, 
	Accept_Error, 
	Bind_Error, 
	TCP_Send_Error, 
	UDP_Send_Error, 
	TCP_Recv_Error, 
	UDP_Recv_Error, 
	Shutdown_Error, 
	Interfaces_Error, 
	Socket_Option_Error, 
	Set_Blocking_Error, 
	Parse_Endpoint_Error, 
	Resolve_Error, 
	DNS_Error, 
}

Network_Interface :: struct {
	adapter_name:     string,
	// On Windows this is a GUID that we could parse back into its u128 for more compact storage.
	friendly_name:    string,
	description:      string,
	dns_suffix:       string,
	physical_address: string,
	// MAC address, etc.
	mtu:              u32,
	unicast:          [dynamic]Lease,
	multicast:        [dynamic]Address,
	anycast:          [dynamic]Address,
	gateways:         [dynamic]Address,
	dhcp_v4:          Address,
	dhcp_v6:          Address,
	tunnel_type:      Tunnel_Type,
	link:             struct {
		state:          bit_set[Link_States; u32],
		transmit_speed: u64,
		receive_speed:  u64,
	},
}

Parse_Endpoint_Error :: enum u32 {
	None         = 0, 
	Bad_Port     = 1, 
	Bad_Address, 
	Bad_Hostname, 
}

Prefix_Origin :: enum i32 {
	Other                = 0, 
	Manual               = 1, 
	Well_Known           = 2, 
	DHCP                 = 3, 
	Router_Advertisement = 4, 
	Unchanged            = 16, 
}

Resolve_Error :: enum u32 {
	None              = 0, 
	Unable_To_Resolve = 1, 
}

Set_Blocking_Error :: enum i32 {
	None, 
	// No network connection, or the network stack is not initialized.
	Network_Unreachable, 
	// Socket is invalid.
	Invalid_Argument, 
	// An error unable to be categorized in above categories, `last_platform_error` may have more info.
	Unknown, 
}

Shutdown_Error :: enum i32 {
	None, 
	// No network connection, or the network stack is not initialized.
	Network_Unreachable, 
	// Socket is invalid or not connected, or the manner given is invalid.
	Invalid_Argument, 
	// Connection was closed/aborted/shutdown.
	Connection_Closed, 
	// An error unable to be categorized in above categories, `last_platform_error` may have more info.
	Unknown, 
}

Shutdown_Manner :: enum i32 {
	Receive = 0, 
	Send    = 1, 
	Both    = 2, 
}

Socket :: distinct i64

Socket_Option :: enum i32 {
	// bool: Whether the address that this socket is bound to can be reused by other sockets.
	//       This allows you to bypass the cooldown period if a program dies while the socket is bound.
	Reuse_Address             = 4, 
	// bool: Whether other programs will be inhibited from binding the same endpoint as this socket.
	Exclusive_Addr_Use        = -5, 
	// bool: When true, keepalive packets will be automatically be sent for this connection. TODO: verify this understanding
	Keep_Alive                = 8, 
	// bool: When true, client connections will immediately be sent a TCP/IP RST response, rather than being accepted.
	Conditional_Accept        = 12290, 
	// bool: If true, when the socket is closed, but data is still waiting to be sent, discard that data.
	Dont_Linger               = -129, 
	// bool: When true, 'out-of-band' data sent over the socket will be read by a normal net.recv() call, the same as normal 'in-band' data.
	Out_Of_Bounds_Data_Inline = 256, 
	// bool: When true, disables send-coalescing, therefore reducing latency.
	TCP_Nodelay               = 1, 
	// win.LINGER: Customizes how long (if at all) the socket will remain open when there
	// is some remaining data waiting to be sent, and net.close() is called.
	Linger                    = 128, 
	// win.DWORD: The size, in bytes, of the OS-managed receive-buffer for this socket.
	Receive_Buffer_Size       = 4098, 
	// win.DWORD: The size, in bytes, of the OS-managed send-buffer for this socket.
	Send_Buffer_Size          = 4097, 
	// win.DWORD: For blocking sockets, the time in milliseconds to wait for incoming data to be received, before giving up and returning .Timeout.
	//            For non-blocking sockets, ignored.
	//            Use a value of zero to potentially wait forever.
	Receive_Timeout           = 4102, 
	// win.DWORD: For blocking sockets, the time in milliseconds to wait for outgoing data to be sent, before giving up and returning .Timeout.
	//            For non-blocking sockets, ignored.
	//            Use a value of zero to potentially wait forever.
	Send_Timeout              = 4101, 
	// bool: Allow sending to, receiving from, and binding to, a broadcast address.
	Broadcast                 = 32, 
}

Socket_Option_Error :: enum i32 {
	None, 
	// No network connection, or the network stack is not initialized.
	Network_Unreachable, 
	// Not enough space in internal tables/buffers to create a new socket, or an unsupported protocol is given.
	Insufficient_Resources, 
	// Socket is invalid, not connected, or the connection has been closed/reset/shutdown.
	Invalid_Socket, 
	// Unknown or unsupported option for the socket.
	Invalid_Option, 
	// Invalid level or value.
	Invalid_Value, 
	// An error unable to be categorized in above categories, `last_platform_error` may have more info.
	Unknown, 
}

Socket_Protocol :: enum int {
	TCP, 
	UDP, 
}

Suffix_Origin :: enum i32 {
	Other              = 0, 
	Manual             = 1, 
	Well_Known         = 2, 
	DHCP               = 3, 
	Link_Layer_Address = 4, 
	Random             = 5, 
	Unchanged          = 16, 
}

TCP_Options :: struct {
	no_delay: bool,
}

TCP_Recv_Error :: enum i32 {
	None, 
	// No network connection, or the network stack is not initialized.
	Network_Unreachable, 
	// Not enough space in internal tables/buffers to create a new socket, or an unsupported protocol is given.
	Insufficient_Resources, 
	// Invalid socket or buffer given.
	Invalid_Argument, 
	// The socket is not connected.
	Not_Connected, 
	// Connection was closed/broken/shutdown while receiving data.
	Connection_Closed, 
	// Timed out before being able to receive any data.
	Timeout, 
	// Non-blocking socket that would need to block waiting on data.
	Would_Block, 
	// Interrupted by a signal or other method of cancellation like WSACancelBlockingCall on Windows.
	Interrupted, 
	// An error unable to be categorized in above categories, `last_platform_error` may have more info.
	Unknown, 
}

TCP_Send_Error :: enum i32 {
	None, 
	// No network connection, or the network stack is not initialized.
	Network_Unreachable, 
	// Not enough space in internal tables/buffers to create a new socket, or an unsupported protocol is given.
	Insufficient_Resources, 
	// Invalid socket or buffer given.
	Invalid_Argument, 
	// Connection was closed/broken/shutdown while receiving data.
	Connection_Closed, 
	// The socket is not connected.
	Not_Connected, 
	// Could not reach the remote host.
	Host_Unreachable, 
	// Timed out before being able to send any data.
	Timeout, 
	// Non-blocking socket that would need to block waiting on the remote to be able to receive the data.
	Would_Block, 
	// Interrupted by a signal or other method of cancellation like WSACancelBlockingCall on Windows.
	Interrupted, 
	// An error unable to be categorized in above categories, `last_platform_error` may have more info.
	Unknown, 
}

TCP_Socket :: distinct i64

Tunnel_Type :: enum i32 {
	None         = 0, 
	Other        = 1, 
	Direct       = 2, 
	IPv4_To_IPv6 = 11, 
	ISA_TAP      = 13, 
	Teredo       = 14, 
	IP_HTTPS     = 15, 
}

UDP_Recv_Error :: enum i32 {
	None, 
	// No network connection, or the network stack is not initialized.
	Network_Unreachable, 
	// Not enough space in internal tables/buffers to create a new socket, or an unsupported protocol is given.
	Insufficient_Resources, 
	// Invalid socket or buffer given.
	Invalid_Argument, 
	// "Connection" was refused by remote, or closed/broken/shutdown while receiving data.
	Connection_Refused, 
	// Timed out before being able to receive any data.
	Timeout, 
	// Non-blocking socket that would need to block waiting on data.
	Would_Block, 
	// Interrupted by a signal or other method of cancellation like WSACancelBlockingCall on Windows.
	Interrupted, 
	// Linux and UDP only: indicates the buffer was too small to receive all data, and the excess is truncated and discarded.
	Excess_Truncated, 
	// An error unable to be categorized in above categories, `last_platform_error` may have more info.
	Unknown, 
}

UDP_Send_Error :: enum i32 {
	None, 
	// No network connection, or the network stack is not initialized.
	Network_Unreachable, 
	// Not enough space in internal tables/buffers to create a new socket, or an unsupported protocol is given.
	Insufficient_Resources, 
	// Invalid socket or buffer given.
	Invalid_Argument, 
	// Could not reach the remote host.
	Host_Unreachable, 
	// "Connection" was refused by remote, or closed/broken/shutdown while sending data.
	Connection_Refused, 
	// Timed out before being able to send any data.
	Timeout, 
	// Non-blocking socket that would need to block waiting on the remote to be able to receive the data.
	Would_Block, 
	// Interrupted by a signal or other method of cancellation like WSACancelBlockingCall on Windows.
	Interrupted, 
	// An error unable to be categorized in above categories, `last_platform_error` may have more info.
	Unknown, 
}

UDP_Socket :: distinct i64

DEFAULT_DIGIT_BASES: bit_set[Digit_Parse_Base; u8] : Digit_Parse_Bases{.Dec, .Oct, .Hex}

DEFAULT_DNS_CONFIGURATION :: DNS_Configuration{resolv_conf = "", hosts_file = "%WINDIR%\\system32\\drivers\\etc\\hosts"}

IP4_Loopback :: IP4_Address{127, 0, 0, 1}

IP6_Loopback :: IP6_Address{0, 0, 0, 0, 0, 0, 0, 1}

IPv6_MAX_STRING_LENGTH: int : 45

IPv6_MIN_COLONS: int : 2

IPv6_MIN_STRING_LENGTH: int : 2

IPv6_PIECE_COUNT: int : 8

LABEL_MAX: int : 63

MAX_INTERFACE_ENUMERATION_TRIES: int : 3

NAME_MAX: int : 255

ODIN_NET_TCP_NODELAY_DEFAULT: bool : #config(ODIN_NET_TCP_NODELAY_DEFAULT, true)

IP4_Any: IP4_Address = …

IP4_mDNS_Broadcast: Endpoint = …

IP6_Any: IP6_Address = …

IP6_mDNS_Broadcast: Endpoint = …

default_tcp_options: TCP_Options = …

dns_configuration: DNS_Configuration = …

accept_tcp :: proc(socket: TCP_Socket, options: TCP_Options = default_tcp_options) -> (client: TCP_Socket, source: Endpoint, err: Accept_Error) {…}

address_to_string :: proc(addr: Address, allocator := context.temp_allocator) -> string {…}

any_socket_to_socket :: proc "contextless" (socket: Any_Socket) -> Socket {…}

aton :: proc(address_and_maybe_port: string, family: Address_Family, allow_decimal_only: bool = false) -> (addr: Address, ok: bool) {…}

bind :: proc(socket: Any_Socket, ep: Endpoint) -> (err: Bind_Error) {…}

bound_endpoint :: proc(socket: Any_Socket) -> (endpoint: Endpoint, err: Listen_Error) {…}

close :: proc(socket: Any_Socket) {…}

create_socket :: proc(family: Address_Family, protocol: Socket_Protocol) -> (socket: Any_Socket, err: Create_Socket_Error) {…}

decode_hostname :: proc(packet: []u8, start_idx: int, allocator := context.allocator) -> (hostname: string, encode_size: int, ok: bool) {…}

destroy_dns_records :: proc(records: []DNS_Record, allocator := context.allocator) {…}

destroy_interfaces :: proc(interfaces: []Network_Interface, allocator := context.allocator) {…}

dial_tcp_from_address_and_port :: proc(address: Address, port: int, options: TCP_Options = default_tcp_options) -> (socket: TCP_Socket, err: Network_Error) {…}

dial_tcp_from_endpoint :: proc(endpoint: Endpoint, options: TCP_Options = default_tcp_options) -> (socket: TCP_Socket, err: Network_Error) {…}

dial_tcp_from_host :: proc(host: Host, options: TCP_Options = default_tcp_options) -> (socket: TCP_Socket, err: Network_Error) {…}

dial_tcp_from_host_or_endpoint :: proc(target: Host_Or_Endpoint, options: TCP_Options = default_tcp_options) -> (socket: TCP_Socket, err: Network_Error) {…}

dial_tcp_from_hostname_and_port_string :: proc(hostname_and_port: string, options: TCP_Options = default_tcp_options) -> (socket: TCP_Socket, err: Network_Error) {…}

dial_tcp_from_hostname_with_port_override :: proc(hostname: string, port: int, options: TCP_Options = default_tcp_options) -> (socket: TCP_Socket, err: Network_Error) {…}

encode_hostname :: proc(b: ^strings.Builder, hostname: string) -> (ok: bool) {…}

endpoint_to_string :: proc(ep: Endpoint, allocator := context.temp_allocator) -> string {…}

enumerate_interfaces :: proc(allocator := context.allocator) -> (interfaces: []Network_Interface, err: Interfaces_Error) {…}

family_from_address :: proc(addr: Address) -> Address_Family {…}

family_from_endpoint :: proc(ep: Endpoint) -> Address_Family {…}

get_dns_records_from_nameservers :: proc(hostname: string, type: DNS_Record_Type, name_servers: []Endpoint, host_overrides: []DNS_Record, allocator := context.allocator) -> (records: []DNS_Record, err: DNS_Error) {…}

get_dns_records_from_os :: proc(hostname: string, type: DNS_Record_Type, allocator := context.allocator) -> (records: []DNS_Record, err: DNS_Error) {…}

get_network_interfaces :: proc() -> []Address {…}

init_dns_configuration :: proc() {…}

join_port :: proc(address_or_host: string, port: int, allocator := context.allocator) -> string {…}

join_url :: proc(
	scheme, host, path: string, 
	queries:            map[string]string, 
	fragment:           string, 
	allocator := context.allocator, 
) -> string {…}

last_platform_error :: proc() -> i32 {…}

last_platform_error_string :: proc() -> string {…}

listen_tcp :: proc(interface_endpoint: Endpoint, backlog: int = 1000) -> (socket: TCP_Socket, err: Network_Error) {…}

load_hosts :: proc(hosts_file_path: string, allocator := context.allocator) -> (hosts: []DNS_Host_Entry, ok: bool) {…}

load_resolv_conf :: proc(resolv_conf_path: string, allocator := context.allocator) -> (name_servers: []Endpoint, ok: bool) {…}

make_bound_udp_socket :: proc(bound_address: Address, port: int) -> (socket: UDP_Socket, err: Network_Error) {…}

make_unbound_udp_socket :: proc(family: Address_Family) -> (socket: UDP_Socket, err: Create_Socket_Error) {…}

map_to_ip6 :: proc(addr: Address) -> Address {…}

pack_dns_header :: proc(hdr: DNS_Header) -> (id: u16be, bits: u16be) {…}

parse_address :: proc(address_and_maybe_port: string, non_decimal_address: bool = false) -> Address {…}

parse_endpoint :: proc(endpoint_str: string) -> (ep: Endpoint, ok: bool) {…}

parse_hostname_or_endpoint :: proc(endpoint_str: string) -> (target: Host_Or_Endpoint, err: Parse_Endpoint_Error) {…}

parse_ip4_address :: proc(address_and_maybe_port: string, allow_non_decimal: bool = false) -> (addr: IP4_Address, ok: bool) {…}

parse_ip6_address :: proc(address_and_maybe_port: string) -> (addr: IP6_Address, ok: bool) {…}

parse_ip_component :: proc(input: string, max_value: u64 = u64(max(u32)), bases: bit_set[Digit_Parse_Base; u8] = DEFAULT_DIGIT_BASES) -> (value: u64, bytes_consumed: int, ok: bool) {…}

parse_record :: proc(packet: []u8, cur_off: ^int, filter: DNS_Record_Type = nil) -> (record: DNS_Record, ok: bool) {…}

parse_response :: proc(response: []u8, filter: DNS_Record_Type = nil, allocator := context.allocator) -> (records: []DNS_Record, xid: u16be, ok: bool) {…}

parse_socket_address :: proc(addr_in: sys_windows.SOCKET_ADDRESS) -> (addr: Endpoint) {…}

percent_decode :: proc(encoded_string: string, allocator := context.allocator) -> (decoded_string: string, ok: bool) {…}

percent_encode :: proc(s: string, allocator := context.allocator) -> string {…}

physical_address_to_string :: proc(phy_addr: []u8, allocator := context.allocator) -> (phy_string: string) {…}

recv_any :: proc(socket: Any_Socket, buf: []u8) -> (bytes_read: int, remote_endpoint: runtime.Maybe($T=Endpoint), err: Network_Error) {…}

recv_tcp :: proc(socket: TCP_Socket, buf: []u8) -> (bytes_read: int, err: TCP_Recv_Error) {…}

recv_udp :: proc(socket: UDP_Socket, buf: []u8) -> (bytes_read: int, remote_endpoint: Endpoint, err: UDP_Recv_Error) {…}

replace_environment_path :: proc(path: string, allocator := context.allocator) -> (res: string, ok: bool) {…}

resolve :: proc(hostname_and_maybe_port: string) -> (ep4, ep6: Endpoint, err: Network_Error) {…}

resolve_ip4 :: proc(hostname_and_maybe_port: string) -> (ep4: Endpoint, err: Network_Error) {…}

resolve_ip6 :: proc(hostname_and_maybe_port: string) -> (ep6: Endpoint, err: Network_Error) {…}

send_any :: proc(socket: Any_Socket, buf: []u8, to: runtime.Maybe($T=Endpoint) = nil) -> (bytes_written: int, err: Network_Error) {…}

send_tcp :: proc(socket: TCP_Socket, buf: []u8) -> (bytes_written: int, err: TCP_Send_Error) {…}

send_udp :: proc(socket: UDP_Socket, buf: []u8, to: Endpoint) -> (bytes_written: int, err: UDP_Send_Error) {…}

set_blocking :: proc(socket: Any_Socket, should_block: bool) -> (err: Set_Blocking_Error) {…}

set_last_platform_error :: proc(err: i32) {…}

set_option :: proc(socket: Any_Socket, option: Socket_Option, value: any, loc := #caller_location) -> Socket_Option_Error {…}

shutdown :: proc(socket: Any_Socket, manner: Shutdown_Manner) -> (err: Shutdown_Error) {…}

skip_hostname :: proc(packet: []u8, start_idx: int) -> (encode_size: int, ok: bool) {…}

split_port :: proc(endpoint_str: string) -> (addr_or_host: string, port: int, ok: bool) {…}

split_url :: proc(url: string, allocator := context.allocator) -> (scheme, host, path: string, queries: map[string]string, fragment: string) {…}

unpack_dns_header :: proc(id: u16be, bits: u16be) -> (hdr: DNS_Header) {…}

validate_hostname :: proc(hostname: string) -> (ok: bool) {…}

dial_tcp :: proc{
	dial_tcp_from_endpoint,
	dial_tcp_from_address_and_port,
	dial_tcp_from_hostname_and_port_string,
	dial_tcp_from_hostname_with_port_override,
	dial_tcp_from_host,
	dial_tcp_from_host_or_endpoint,
}

recv :: proc{
	recv_tcp,
	recv_udp,
	recv_any,
}

send :: proc{
	send_tcp,
	send_udp,
	send_any,
}

to_string :: proc{
	address_to_string,
	endpoint_to_string,
}