Field `client` of type `net.Endpoint` on `http.Request` struct is never initalized in route handlers

[sachahjkl]

When running on Windows 11 or latest Arch linux (probably also on other platforms), the value of req.client is systematically nil/0

Here's a minimal example for reproduction:

package main

import http "./odin-http/"
import "core:fmt"
import "core:log"
import "core:net"


main :: proc() {
	context.logger = log.create_console_logger(.Info)

	s: http.Server
	http.server_shutdown_on_interrupt(&s)

	router: http.Router
	http.router_init(&router)
	defer http.router_destroy(&router)

	http.route_get(&router, "/", http.handler(ip_echo))


	routed := http.router_handler(&router)

	endpoint := net.Endpoint {
		address = net.IP4_Loopback,
		port    = 6969,
	}

	log.infof("listening on http://%v", net.endpoint_to_string(endpoint))
	err := http.listen_and_serve(&s, routed, endpoint)

	fmt.assertf(err == nil, "server stopped with error: %v", err)
}


ip_echo :: proc(req: ^http.Request, res: ^http.Response) {
	log.infof("IP: %v:%v", req.client.address, req.client.port)
	ip := net.endpoint_to_string(req.client)
	http.respond_plain(res, fmt.tprintf("Your IP is: %v", ip))
}

Running this program and hitting the http://localhost:6969/ endpoint returns a response with the body Your IP is: and logs out

[INFO ] --- [2025-10-16 09:59:35] [main.odin:37:ip_echo()] IP: nil:0

[sachahjkl]

Tried to look into it (windows only) and "fixed" it with a quick hack

in nbio_internal_windows.odin - both the local address and the remote address (in that order) get written in op.addr but it seems that we're using the former instead of the latter when we pass it to sockaddr_to_endpoint at the end of the proc, which gives us the local Endpoint instead of the remote one.

accept_callback :: proc(io: ^IO, comp: ^Completion, op: ^Op_Accept) -> (source: net.Endpoint, err: net.Network_Error) {
	ok: win.BOOL
	if op.pending {
		// Get status update, we've already initiated the accept.
		flags: win.DWORD
		transferred: win.DWORD
		ok = win.WSAGetOverlappedResult(op.socket, &comp.over, &transferred, win.FALSE, &flags)
	} else {
		op.pending = true

		oclient: net.Any_Socket
		oclient, err = open_socket(io, .IP4, .TCP)

		if err != nil {return}

		op.client = win.SOCKET(net.any_socket_to_socket(oclient))

		accept_ex: LPFN_ACCEPTEX
		load_socket_fn(op.socket, win.WSAID_ACCEPTEX, &accept_ex)

		#assert(size_of(win.SOCKADDR_STORAGE_LH) >= size_of(win.sockaddr_in) + 16)
		bytes_read: win.DWORD
		ok = accept_ex(
			op.socket,
			op.client,
			&op.addr,
			0,
			size_of(win.sockaddr_in) + 16,
			size_of(win.sockaddr_in) + 16,
			&bytes_read,
			&comp.over,
		)
	}

	if !ok {
		err = net._accept_error()
		return
	}

	// enables getsockopt, setsockopt, getsockname, getpeername.
	win.setsockopt(op.client, win.SOL_SOCKET, SO_UPDATE_ACCEPT_CONTEXT, nil, 0)

+     // SOCKADDR_STORAGE_LH stores 2 * (sockaddr_in + 16 bytes). we want to get a pointer to the 2nd sockaddr_in.
+      tmp := cast(^win.SOCKADDR_STORAGE_LH)(rawptr(uintptr(&op.addr) + size_of(win.sockaddr_in) + 16))

+     op.addr = tmp^

	source = sockaddr_to_endpoint(&op.addr)
	return
}

And then I also added a field on the Connectionin server.odin to actually save the source and eventually assign it back to the request when the request handling proc is called.

Connection :: struct {
	server:         ^Server,
	socket:         net.TCP_Socket,
	state:          Connection_State,
+   source:         net.Endpoint,
	scanner:        Scanner,
	temp_allocator: virtual.Arena,
	loop:           Loop,
}



.......

on_accept :: proc(server: rawptr, sock: net.TCP_Socket, source: net.Endpoint, err: net.Network_Error) {
	server := cast(^Server)server

	if err != nil {
		#partial switch e in err {
		case net.Accept_Error:
			#partial switch e {
			case .Insufficient_Resources:
				log.error("Connection limit reached, trying again in a bit")
				nbio.timeout(&td.io, time.Second, server, proc(server: rawptr) {
					server := cast(^Server)server
					nbio.accept(&td.io, server.tcp_sock, server, on_accept)
				})
				return
			}
		}

		fmt.panicf("accept error: %v", err)
	}

	// Accept next connection.
	nbio.accept(&td.io, server.tcp_sock, server, on_accept)

	c := new(Connection, server.conn_allocator)
	c.state = .New
	c.server = server
	c.socket = sock
+   c.source = source

	td.conns[c.socket] = c

	log.debugf("new connection with thread, got %d conns", len(td.conns))
	conn_handle_reqs(c)
}


conn_handle_req :: proc(c: ^Connection, allocator := context.temp_allocator) {

..........

// I'm reassigning the value of the source to the newly created request value at the end of conn_handle_req

	c.loop.conn = c
	c.loop.res._conn = c
	c.loop.req._scanner = &c.scanner
+   c.loop.req.client = c.source
	request_init(&c.loop.req, allocator)
	response_init(&c.loop.res, allocator)

	c.scanner.max_token_size = c.server.opts.limit_request_line
	scanner_scan(&c.scanner, &c.loop, on_rline1)
}

I think that this "solution" is pretty busted (especially the whole pointer manipulation, I was to lazy to actually redefine a proper type to wrap the value) but at least it's a start off point.

After doing all that, I get in the log, for example:

[INFO ] --- [2025-10-16 15:04:02] [main.odin:37:ip_echo()] IP: [127, 0, 0, 1]:50756