net/core

sourcenet/core.sx

curl_easy_init

private
extern (C) fn curl_easy_init() ref void = trust { ... } = "curl_easy_init"

curl_easy_cleanup

private
extern (C) fn curl_easy_cleanup(handle: ref void) void = trust { ... } = "curl_easy_cleanup"

curl_easy_setopt

private
extern (C) fn curl_easy_setopt(handle: ref void, opt: i32, ...) i64 = trust { ... } = "curl_easy_setopt"

curl_easy_perform

private
extern (C) fn curl_easy_perform(handle: ref void) i64 = trust { ... } = "curl_easy_perform"

curl_easy_getinfo

private
extern (C) fn curl_easy_getinfo(handle: ref void, info: i32, ...) i64 = trust { ... } = "curl_easy_getinfo"

curl_slist_append

private
extern (C) fn curl_slist_append(list: ref void, str: ref u8) ref void = trust { ... } = "curl_slist_append"

curl_slist_free_all

private
extern (C) fn curl_slist_free_all(list: ref void) void = trust { ... } = "curl_slist_free_all"

curl_global_init

private
extern (C) fn curl_global_init(flags: i64) i64 = trust { ... } = "curl_global_init"

curl_global_cleanup

private
extern (C) fn curl_global_cleanup() void = trust { ... } = "curl_global_cleanup"

socket

private
extern (C) fn socket(domain: i32, type_: i32, protocol: i32) i32 = trust { ... } = "socket"

bind

private
extern (C) fn bind(fd: i32, addr: ref void, addrlen: i32) i32 = trust { ... } = "bind"

listen

private
extern (C) fn listen(fd: i32, backlog: i32) i32 = trust { ... } = "listen"

accept

private
extern (C) fn accept(fd: i32, addr: ref void, addrlen: ref void) i32 = trust { ... } = "accept"

send

private
extern (C) fn send(fd: i32, buf: ref void, len: i64, flags: i32) i64 = trust { ... } = "send"

recv

private
extern (C) fn recv(fd: i32, buf: ref void, len: i64, flags: i32) i64 = trust { ... } = "recv"

close

private
extern (C) fn close(fd: i32) i32 = trust { ... } = "close"

htons

private
extern (C) fn htons(port: i32) i32 = trust { ... } = "htons"

setsockopt

private
extern (C) fn setsockopt(fd: i32, level: i32, opt: i32, vl: ref void, len: i32) i32 = trust { ... } = "setsockopt"

memset

private
extern (C) fn memset(ptr: ref void, vl: i32, len: i64) ref void = trust { ... } = "memset"

memcpy

private
extern (C) fn memcpy(dst: ref void, src: ref void, len: i64) ref void = trust { ... } = "memcpy"

CURLOPT_URL

pub val CURLOPT_URL = 10002

CURLOPT_WRITEFUNCTION

pub val CURLOPT_WRITEFUNCTION = 20011

CURLOPT_WRITEDATA

pub val CURLOPT_WRITEDATA = 10001

CURLOPT_HTTPHEADER

pub val CURLOPT_HTTPHEADER = 10023

CURLOPT_POSTFIELDS

pub val CURLOPT_POSTFIELDS = 10015

CURLOPT_CUSTOMREQUEST

pub val CURLOPT_CUSTOMREQUEST = 10036

CURLINFO_RESPONSE_CODE

pub val CURLINFO_RESPONSE_CODE = 2097154

CURL_GLOBAL_DEFAULT

pub val CURL_GLOBAL_DEFAULT = 3

AF_INET

pub val AF_INET = 2

IPPROTO_TCP

pub val IPPROTO_TCP = 6

Buffer

type Buffer = { data: mut ref void, len: mut i64, cap: mut i64, failed: mut bool }

Fields

NameType
datamut ref void
lenmut i64
capmut i64
failedmut bool

Response

type Response = { body: mut ref u8, status: mut i64, len: mut i64 }

An owned HTTP response.

Fields

NameType
bodymut ref u8
statusmut i64
lenmut i64

I32Slot

type I32Slot = { value: mut i32 }

Fields

NameType
valuemut i32

I64Slot

type I64Slot = { value: mut i64 }

Fields

NameType
valuemut i64

curl_write_cb

pub fn curl_write_cb(ptr: ref void, size: i64, nmemb: i64, userdata: ref void) i64 = trust { ... }

Internal write callback for curl. Signature matches: size_t write_fn(u8 *ptr, size_t size, size_t nmemb, void *userdata)

buf_new

private
fn buf_new() ref Buffer = trust { ... }

do_request

private
fn do_request[A: allocators.GeneralAllocator](ac: A, handle: ref void) ref Response

Perform a curl request, capturing the response body via the write callback. Returns a Response allocated with the provided allocator.

Http

type Http = {  }

ServerHandle

type ServerHandle = { port: mut i64, fd: mut i32 }

Fields

NameType
portmut i64
fdmut i32

init

pub fn (Http) init() void

Initialise the curl global state. Call once at program start.

cleanup

pub fn (Http) cleanup() void = trust { ... }

Clean up the curl global state. Call once at program end.

get

pub fn (Http) get[A: allocators.GeneralAllocator](ac: A, url: ref u8) ref Response

Perform an HTTP GET request. Returns a Response allocated with the provided allocator; caller must call Http.free_response().

post_request

pub fn (Http) post_request[A: allocators.GeneralAllocator](ac: A, url: ref u8, body: ref u8, content_type: ref u8) ref Response

Perform an HTTP POST request with a body string. Returns a Response allocated with the provided allocator; caller must call Http.free_response().

request

pub fn (Http) request[A: allocators.GeneralAllocator](ac: A, method: ref u8, url: ref u8, body: ref u8, headers: ref void) ref Response

Perform an arbitrary HTTP request (GET, POST, PUT, DELETE, PATCH …).

free_response

pub fn (Http) free_response[A: allocators.GeneralAllocator](ac: A, resp: ref Response) void

Free a Response returned by Http.get / Http.post / Http.request with the same allocator used to create it.

status

pub fn (Http) status(resp: ref Response) i64

Read the HTTP status code from a Response.

body

pub fn (Http) body(resp: ref Response) ref u8

Read the body pointer from a Response.

body_len

pub fn (Http) body_len(resp: ref Response) i64

Read the body length from a Response.

make_headers

pub fn (Http) make_headers(header: ref u8) ref void = trust { ... }

Build a curl slist header list from a single "Key: Value" string.

append_header

pub fn (Http) append_header(list: ref void, header: ref u8) ref void = trust { ... }

Append a header to an existing slist.

free_headers

pub fn (Http) free_headers(list: ref void) void = trust { ... }

Free a header list created with Http.make_headers / Http.append_header.

TcpServer

type TcpServer = {  }

listen

pub fn (TcpServer) listen[A: allocators.GeneralAllocator](ac: A, port: i32) ref ServerHandle

Create a TCP server bound to `port` and start listening. Returns a server handle allocated with the provided allocator; caller must call TcpServer.close().

accept

pub fn (TcpServer) accept(server: ref ServerHandle) i32 = trust { ... }

Accept the next incoming connection. Returns the client socket fd, or -1 on error.

send

pub fn (TcpServer) send(client_fd: i32, data: ref u8, len: i64) i64 = trust { ... }

Send bytes over a client socket fd. Returns the number of bytes sent, or -1 on error.

recv

pub fn (TcpServer) recv(client_fd: i32, buf: ref u8, max_len: i64) i64 = trust { ... }

Receive bytes from a client socket fd into buf (at most max_len bytes). Returns the number of bytes received, or -1 on error / 0 on close.

close_client

pub fn (TcpServer) close_client(client_fd: i32) void = trust { ... }

Close a client socket fd.

close

pub fn (TcpServer) close[A: allocators.GeneralAllocator](ac: A, server: ref ServerHandle) void

Shut down and free the server handle.

port

pub fn (TcpServer) port(server: ref ServerHandle) i64

Read the listening port from a server handle.

fd

pub fn (TcpServer) fd(server: ref ServerHandle) i32

Read the listening fd from a server handle.