http.bend fails

raw source on the hub · import 0x28323c0ff43793bdde97698829f13788/http.bend as Http

4 imports

import Base
import ./wire.bend as Wire
import ./dns/dns.bend as Dns
import ./url/url.bend as Url

Types

type Req source · line 13 · raw

Data

Req

@method:String -> @path:String -> @headers:Map<&2, String> -> @body:String -> Req

type Res source · line 16 · raw

Data

Res

@status:U32 -> @headers:Map<&2, String> -> @body:String -> Res

type Fields source · line 19 · raw

Data

FieldsBad
```
Fields
```
FieldsOk
```
@m:Map<&2, String> -> Fields
```

type HexSize source · line 215 · raw

Data

HexSize
```
@n:U32 -> @rest:String -> HexSize
```

type Step source · line 218 · raw

Data

StepFail
```
Step
```
StepDone
```
@body:String -> Step
```
StepNext
```
@rest:String -> @acc:String -> Step
```

type Took source · line 320 · raw

Data

Took
```
@racc:String -> @rest:String -> Took
```

type Frame source · line 505 · raw

Data

Bad: never a message. More: a valid prefix; read on. Done: a whole response.

FrameBad
```
Frame
```
FrameMore
```
Frame
```
FrameDone
```
@res:Res -> Frame
```

type Need source · line 611 · raw

Data

When can a response be whole? fetch uses this to skip re-framing a growing buffer after every read. Head: the header block is not in yet. Len: the message is total bytes long. Chunk: it ends with CRLF CRLF. Close: only at close. Now: frame it at once (no body, or already malformed).

NeedHead
```
Need
```
NeedLen
```
@total:Nat -> Need
```
NeedChunk
```
Need
```
NeedClose
```
Need
```
NeedNow
```
Need
```

type Hop source · line 769 · raw

Data

One request to make: headers are already lowercased (see req.put).

Hop

@method:String -> @url:0x28323c0ff43793bdde97698829f13788/url/url.Abs -> @headers:Map<&2, String> -> @body:String -> Hop

type Rd source · line 859 · raw

Data

Read state: bytes so far reversed (appends are cheap), their count, the framing hint, and the last verdict.

Rd

@rbuf:String -> @n:Nat -> @need:Need -> @f:Frame -> Rd

type Next source · line 1010 · raw

Data

NDone
```
@res:Maybe<&2, Res> -> Next
```
NHop
```
@hop:Hop -> Next
```

Definitions

def empty source · line 23 · raw

Map<&2, String>

def sanitize.cons source · line 26 · raw

@ch:Char -> @rest:String -> @drop:Bool -> String

def sanitize source · line 33 · raw

@s:String -> String

def drop_cr.if source · line 40 · raw

@+s:String -> @cr:Bool -> String

def drop_cr source · line 47 · raw

@+s:String -> String

def take_sp.go source · line 50 · raw

@s:String -> @+acc:String -> Pair(String, String)

def take_sp source · line 57 · raw

@s:String -> Pair(String, String)

def start_line.ver source · line 60 · raw

@m:String -> @pv:Pair(String, String) -> Pair(String, Pair(String, String))

def start_line.rest source · line 64 · raw

@mr:Pair(String, String) -> Pair(String, Pair(String, String))

def start_line source · line 68 · raw

@s:String -> Pair(String, Pair(String, String))

def split_at_blank.go source · line 71 · raw

@s:String -> @e:Bool -> @w:U32 -> @acc:String -> Pair(String, String)

def split_at_blank source · line 83 · raw

@s:String -> Pair(String, String)

def split_colon.go source · line 86 · raw

@s:String -> @+acc:String -> Pair(String, String)

def split_colon source · line 93 · raw

@s:String -> Pair(String, String)

def has_header.of source · line 96 · raw

@r:Pair(Map<&2, String>, Bool) -> Bool

def has_header source · line 100 · raw

@+h:Map<&2, String> -> @k:String -> Bool

@r:Pair(Map<&2, String>, String) -> String

def header source · line 107 · raw

@+h:Map<&2, String> -> @k:String -> String

def folded source · line 110 · raw

@+line:String -> Bool

def tracked source · line 113 · raw

@+k:String -> Bool

def fields_put.dup source · line 116 · raw

@m:Map<&2, String> -> @k:String -> @v:String -> @bad:Bool -> Fields

def fields_put.key source · line 123 · raw

@+m:Map<&2, String> -> @+k:String -> @v:String -> Fields

def fields_put.kv source · line 126 · raw

@m:Map<&2, String> -> @kv:Pair(String, String) -> Fields

def fields_put.fold source · line 130 · raw

@m:Map<&2, String> -> @line:String -> @fold:Bool -> Fields

def fields_put.empty source · line 137 · raw

@m:Map<&2, String> -> @+line:String -> @e:Bool -> Fields

def fields_put.ok source · line 144 · raw

@m:Map<&2, String> -> @+line:String -> Fields

def fields_put source · line 147 · raw

@acc:Fields -> @line:String -> Fields

def parse.headers.done source · line 154 · raw

@acc:Fields -> Maybe<&2, Map<&2, String>>

def parse.headers source · line 161 · raw

@xs:List<&2, String> -> @acc:Fields -> Maybe<&2, Map<&2, String>>

def parse_u32.digit source · line 168 · raw

@+c:U32 -> Bool

def parse_u32.add source · line 171 · raw

@acc:U32 -> @c:U32 -> U32

def parse_u32.done source · line 174 · raw

@acc:U32 -> @bad:Bool -> Maybe<&2, U32>

def parse_u32.go source · line 181 · raw

@s:String -> @acc:U32 -> @bad:Bool -> Maybe<&2, U32>

def parse_u32 source · line 188 · raw

@s:String -> Maybe<&2, U32>

def parse.take.if source · line 197 · raw

@+rest:String -> @+k:Nat -> @short:Bool -> Maybe<&2, String>

def parse.take.have source · line 205 · raw

@+rest:String -> @+k:Nat -> Maybe<&2, String>

RFC 9112 §8: fewer bytes than Content-Length is an incomplete message.

def parse.take source · line 208 · raw

@rest:String -> @n:Maybe<&2, U32> -> Maybe<&2, String>

def is_hex source · line 223 · raw

@+c:U32 -> Bool

def hexv source · line 226 · raw

@+c:U32 -> U32

def chunk.lf1 source · line 229 · raw

@r:String -> @n:U32 -> @lf:Bool -> Maybe<&2, HexSize>

def chunk.lf source · line 236 · raw

@t:String -> @n:U32 -> Maybe<&2, HexSize>

def chunk.ext.go source · line 247 · raw

@t:String -> @+c:U32 -> @+n:U32 -> @stop:Bool -> Maybe<&2, HexSize>

def chunk.ext source · line 259 · raw

@s:String -> @n:U32 -> Maybe<&2, HexSize>

RFC 9112 §7.1.1: recipients ignore unknown chunk extensions; a bare LF is not CRLF.

def chunk.size.end source · line 266 · raw

@+c:U32 -> @+t:String -> @+n:U32 -> @seen:Bool -> Maybe<&2, HexSize>

def chunk.digit source · line 274 · raw

@+c:U32 -> @+acc:U32 -> Bool

A size that would overflow 32 bits ends the digits, and size.end then refuses it.

def chunk.size.go source · line 277 · raw

@t:String -> @+c:U32 -> @+acc:U32 -> @seen:Bool -> @digit:Bool -> Maybe<&2, HexSize>

def chunk.size source · line 289 · raw

@s:String -> Maybe<&2, HexSize>

def chunk.trailer.ok source · line 298 · raw

@racc:String -> @ok:Bool -> Step

def chunk.trailer.end source · line 305 · raw

@hb:Pair(String, String) -> @racc:String -> Step

def chunk.trailer.if source · line 309 · raw

@rest:String -> @racc:String -> @blank:Bool -> Step

def chunk.trailer source · line 317 · raw

@+rest:String -> @racc:String -> Step

ponytail: trailer fields are dropped unparsed (§7.1.2 allows discarding)

def take.exact source · line 324 · raw

@s:String -> @k:Nat -> @racc:String -> Maybe<&2, Took>

Moves exactly k chars onto racc; None if s runs out first. O(k), no length scan.

def chunk.crlf.if source · line 339 · raw

@racc:String -> @+after:String -> @ok:Bool -> Step

def chunk.data source · line 346 · raw

@m:Maybe<&2, Took> -> Step

def chunk.step.n source · line 353 · raw

@+n:U32 -> @rest:String -> @racc:String -> @zero:Bool -> Step

def chunk.step.got source · line 360 · raw

@got:Maybe<&2, HexSize> -> @racc:String -> Step

def chunk.step source · line 367 · raw

@s:String -> @racc:String -> Step

def chunk.go source · line 370 · raw

@fuel:Nat -> @st:Step -> Maybe<&2, String>

def chunk.decode source · line 384 · raw

@+s:String -> Maybe<&2, String>

Every chunk eats at least 3 bytes, so length(s) steps always suffice.

def parse.body.cl source · line 387 · raw

@+h:Map<&2, String> -> @rest:String -> @hascl:Bool -> Maybe<&2, String>

def parse.body.chunked.eq source · line 394 · raw

@rest:String -> @ok:Bool -> Maybe<&2, String>

def parse.body.chunked.val source · line 401 · raw

@te:String -> @rest:String -> Maybe<&2, String>

def parse.body.chunked source · line 404 · raw

@+h:Map<&2, String> -> @rest:String -> @hascl:Bool -> Maybe<&2, String>

def parse.body.te source · line 411 · raw

@+h:Map<&2, String> -> @rest:String -> @te:Bool -> Maybe<&2, String>

def parse.body source · line 418 · raw

@+h:Map<&2, String> -> @rest:String -> Maybe<&2, String>

def parse.finish source · line 421 · raw

@method:String -> @path:String -> @h:Map<&2, String> -> @body:Maybe<&2, String> -> Maybe<&2, Req>

def parse.host source · line 428 · raw

@method:String -> @path:String -> @+h:Map<&2, String> -> @rest:String -> @has:Bool -> Maybe<&2, Req>

def parse.fields source · line 435 · raw

@method:String -> @path:String -> @rest:String -> @fs:Maybe<&2, Map<&2, String>> -> Maybe<&2, Req>

def target_ok source · line 442 · raw

@+p:String -> Bool

def parse.target source · line 445 · raw

@method:String -> @+path:String -> @headers:List<&2, String> -> @rest:String -> @ok:Bool -> Maybe<&2, Req>

def parse.ver source · line 452 · raw

@method:String -> @+path:String -> @v:String -> @headers:List<&2, String> -> @rest:String -> @ok:Bool -> Maybe<&2, Req>

def parse.empty_method source · line 459 · raw

@method:String -> @path:String -> @+v:String -> @headers:List<&2, String> -> @rest:String -> @empty:Bool -> Maybe<&2, Req>

def parse.start3 source · line 466 · raw

@mpv:Pair(String, Pair(String, String)) -> @headers:List<&2, String> -> @rest:String -> Maybe<&2, Req>

def parse.lines source · line 470 · raw

@xs:List<&2, String> -> @rest:String -> Maybe<&2, Req>

def parse.head source · line 477 · raw

@head:String -> @rest:String -> Maybe<&2, Req>

def parse.of source · line 480 · raw

@hb:Pair(String, String) -> Maybe<&2, Req>

def parse source · line 484 · raw

@raw:String -> Maybe<&2, Req>

def parse.res.cl source · line 487 · raw

@+h:Map<&2, String> -> @rest:String -> @hascl:Bool -> Maybe<&2, String>

def parse.res.te source · line 494 · raw

@+h:Map<&2, String> -> @rest:String -> @te:Bool -> Maybe<&2, String>

def parse.res.body source · line 501 · raw

@+h:Map<&2, String> -> @rest:String -> Maybe<&2, String>

def frame.cut source · line 511 · raw

@closed:Bool -> Frame

RFC 9112 §8: a message cut short by close is incomplete, not valid.

def frame.wait source · line 518 · raw

@res:Res -> @wait:Bool -> Frame

def frame.done source · line 525 · raw

@status:U32 -> @h:Map<&2, String> -> @body:Maybe<&2, String> -> @+closed:Bool -> @open:Bool -> Frame

def frame.open source · line 533 · raw

@+h:Map<&2, String> -> Bool

RFC 9112 §6.3 (8): no TE and no CL ⇒ the body runs until the server closes.

def frame.nobody source · line 538 · raw

@+status:U32 -> @head:Bool -> Bool

RFC 9112 §6.3 (1): HEAD, 1xx, 204 and 304 responses end at the blank line. ponytail: 1xx is returned as final; skip interim responses if a server sends 103

def frame.status source · line 541 · raw

@status:U32 -> @+h:Map<&2, String> -> @rest:String -> @closed:Bool -> @nobody:Bool -> Frame

def parse.res.fields source · line 548 · raw

@+status:U32 -> @rest:String -> @fs:Maybe<&2, Map<&2, String>> -> @closed:Bool -> @head:Bool -> Frame

def parse.res.num source · line 555 · raw

@code:Maybe<&2, U32> -> @headers:List<&2, String> -> @rest:String -> @closed:Bool -> @head:Bool -> Frame

def parse.res.ver source · line 562 · raw

@code:String -> @headers:List<&2, String> -> @rest:String -> @closed:Bool -> @head:Bool -> @ok:Bool -> Frame

def parse.res.start3 source · line 569 · raw

@mpv:Pair(String, Pair(String, String)) -> @headers:List<&2, String> -> @rest:String -> @closed:Bool -> @head:Bool -> Frame

def parse.res.lines source · line 573 · raw

@xs:List<&2, String> -> @rest:String -> @closed:Bool -> @head:Bool -> Frame

def parse.res.blank source · line 580 · raw

@hd:String -> @rest:String -> @+closed:Bool -> @head:Bool -> @ok:Bool -> Frame

def parse.res.of source · line 587 · raw

@hb:Pair(String, String) -> @closed:Bool -> @head:Bool -> Frame

def frame source · line 592 · raw

@raw:String -> @closed:Bool -> @head:Bool -> Frame

frame(bytes so far, server closed?, request was HEAD?)

def frame.res source · line 595 · raw

@f:Frame -> Maybe<&2, Res>

def parse_res source · line 604 · raw

@raw:String -> Maybe<&2, Res>

def need.cl source · line 618 · raw

@hlen:Nat -> @n:Maybe<&2, U32> -> Need

def need.framing source · line 625 · raw

@+h:Map<&2, String> -> @hlen:Nat -> @te:Bool -> @cl:Bool -> Need

def need.fields source · line 636 · raw

@hlen:Nat -> @nobody:Bool -> @fs:Maybe<&2, Map<&2, String>> -> Need

def need.num source · line 647 · raw

@code:Maybe<&2, U32> -> @headers:List<&2, String> -> @hlen:Nat -> @head:Bool -> Need

def need.start3 source · line 654 · raw

@mpv:Pair(String, Pair(String, String)) -> @headers:List<&2, String> -> @hlen:Nat -> @head:Bool -> Need

def need.lines source · line 658 · raw

@xs:List<&2, String> -> @hlen:Nat -> @head:Bool -> Need

def need.blank source · line 665 · raw

@+hd:String -> @head:Bool -> @ok:Bool -> Need

def need.of source · line 672 · raw

@hb:Pair(String, String) -> @head:Bool -> Need

def need source · line 677 · raw

@raw:String -> @head:Bool -> Need

A hint only: frame() stays the judge of every byte.

def res_body.res source · line 680 · raw

@res:Res -> String

def res_body source · line 684 · raw

@m:Maybe<&2, Res> -> String

def got_body.req source · line 691 · raw

@req:Req -> String

def got_body source · line 695 · raw

@m:Maybe<&2, Req> -> String

def body.of source · line 702 · raw

@hb:Pair(String, String) -> String

def body source · line 706 · raw

@s:String -> String

def headers_block.go source · line 709 · raw

@xs:List<&2, Sigma<&2, &2, String, _ => String>> -> @acc:String -> String

def headers_block source · line 716 · raw

@h:Map<&2, String> -> String

def response source · line 719 · raw

@status:U32 -> @headers:Map<&2, String> -> @body:String -> String

def nat_u32 source · line 722 · raw

@n:Nat -> U32

def encode source · line 729 · raw

@r:Res -> String

def request source · line 733 · raw

@method:String -> @path:String -> @headers:Map<&2, String> -> @body:String -> String

def req.reserved source · line 736 · raw

@+k:String -> Bool

def req.put.one source · line 739 · raw

@m:Map<&2, String> -> @+k:String -> @v:String -> @skip:Bool -> Map<&2, String>

def req.put source · line 746 · raw

@xs:List<&2, Sigma<&2, &2, String, _ => String>> -> @m:Map<&2, String> -> Map<&2, String>

def req.cl source · line 755 · raw

@+m:Map<&2, String> -> @+method:String -> @+body:String -> Map<&2, String>

RFC 9110 §8.6: no Content-Length on a bodiless request whose method gives a body no meaning.

def encode_req source · line 761 · raw

@+method:String -> @target:String -> @host:String -> @headers:Map<&2, String> -> @+body:String -> String

Caller headers are lowercased so they cannot duplicate ours; host, connection, content-length and transfer-encoding are always ours (no smuggling through them).

def redirect.code source · line 772 · raw

@+s:U32 -> Bool

def redirect.origin source · line 775 · raw

@a:0x28323c0ff43793bdde97698829f13788/url/url.Abs -> String

def redirect.del source · line 779 · raw

@ks:List<&2, String> -> @m:Map<&2, String> -> Map<&2, String>

def redirect.hdrs source · line 786 · raw

@+h:Map<&2, String> -> @drop:Bool -> @cross:Bool -> Map<&2, String>

def redirect.to source · line 793 · raw

@+status:U32 -> @+method:String -> @+from:0x28323c0ff43793bdde97698829f13788/url/url.Abs -> @headers:Map<&2, String> -> @+body:String -> @next:Maybe<&2, 0x28323c0ff43793bdde97698829f13788/url/url.Abs> -> Maybe<&2, Hop>

303 turns any method but HEAD into GET; 301 and 302 turn POST into GET; 307 and 308 keep method and body. A GET carries no body or body headers. Credentials do not follow a hop to another origin.

def redirect.hop source · line 801 · raw

@status:U32 -> @h:Hop -> @loc:String -> Maybe<&2, Hop>

def redirect.if source · line 805 · raw

@status:U32 -> @h:Hop -> @loc:String -> @ok:Bool -> Maybe<&2, Hop>

def redirect source · line 813 · raw

@+status:U32 -> @+headers:Map<&2, String> -> @h:Hop -> Maybe<&2, Hop>

The next request after a response, or None when it is not a redirect we follow.

def io.recv source · line 817 · raw

@tls:Bool -> @s:Socket -> @max:U32 -> @ms:U32 -> IO(Pair(Socket, Result<&1, &1, Pair(U32, String), String>))

Transport: plain TCP or TLS over the same socket.

def io.send source · line 824 · raw

@tls:Bool -> @s:Socket -> @data:String -> IO(Pair(Socket, Result<&1, &1, Pair(U32, String), Unit>))

def io.close source · line 831 · raw

@tls:Bool -> @s:Socket -> IO(Unit)

def fetch.close source · line 838 · raw

@tls:Bool -> @s:Socket -> @r:Maybe<&2, Res> -> IO(Maybe<&2, Res>)

def fetch.none source · line 843 · raw

IO(Maybe<&2, Res>)

def fetch.cap source · line 846 · raw

@f:Frame -> @over:Bool -> Frame

def fetch.max source · line 854 · raw

Nat

Untrusted servers must not grow the buffer without bound.

def fetch.need source · line 863 · raw

@hint:Need -> @+rbuf:String -> @head:Bool -> Need

The hint is worked out once, when the header block has arrived.

def fetch.gate source · line 878 · raw

@closed:Bool -> @need:Need -> @+n:Nat -> @+got:String -> Bool

Could the buffer hold a whole response now? A yes may be wrong (frame then says More); a no must never be.

def fetch.try source · line 895 · raw

@gate:Bool -> @rbuf:String -> @closed:Bool -> @head:Bool -> Frame

def fetch.step source · line 902 · raw

@+head:Bool -> @s:Socket -> @rd:Rd -> @+got:String -> @+closed:Bool -> Pair(Socket, Rd)

def fetch.bad source · line 909 · raw

@rd:Rd -> Rd

def fetch.next.r source · line 913 · raw

@head:Bool -> @s:Socket -> @rd:Rd -> @r:Result<&1, &1, Pair(U32, String), String> -> Pair(Socket, Rd)

def fetch.next source · line 920 · raw

@head:Bool -> @rd:Rd -> @m:Pair(Socket, Result<&1, &1, Pair(U32, String), String>) -> Pair(Socket, Rd)

def fetch.sent source · line 939 · raw

@head:Bool -> @tls:Bool -> @ms:U32 -> @m:Pair(Socket, Result<&1, &1, Pair(U32, String), Unit>) -> IO(Maybe<&2, Res>)

def fetch.send source · line 947 · raw

@head:Bool -> @+tls:Bool -> @ms:U32 -> @s:Socket -> @wire:String -> IO(Maybe<&2, Res>)

def fetch.shook source · line 953 · raw

@head:Bool -> @ms:U32 -> @wire:String -> @m:Pair(Socket, Result<&1, &1, Pair(U32, String), Unit>) -> IO(Maybe<&2, Res>)

A failed handshake (bad chain, wrong host, no OpenSSL) is None, never plaintext.

def fetch.secure source · line 961 · raw

@head:Bool -> @+ms:U32 -> @sni:String -> @wire:String -> @c:Socket -> @tls:Bool -> IO(Maybe<&2, Res>)

def fetch.conn source · line 970 · raw

@head:Bool -> @ms:U32 -> @sni:String -> @wire:String -> @tls:Bool -> @r:Result<&1, &1, Pair(U32, String), Socket> -> IO(Maybe<&2, Res>)

def fetch.ip source · line 978 · raw

@+method:String -> @ip:String -> @port:U32 -> @sni:String -> @hf:String -> @target:String -> @headers:Map<&2, String> -> @body:String -> @tls:Bool -> @+ms:U32 -> IO(Maybe<&2, Res>)

One request on one connection to an IPv4 address. Bodies are byte strings.

def fetch.addr source · line 983 · raw

@method:String -> @port:U32 -> @sni:String -> @hf:String -> @target:String -> @headers:Map<&2, String> -> @body:String -> @tls:Bool -> @ms:U32 -> @ip:Maybe<&2, String> -> IO(Maybe<&2, Res>)

def fetch.dns source · line 990 · raw

@method:String -> @+host:String -> @port:U32 -> @hf:String -> @target:String -> @headers:Map<&2, String> -> @body:String -> @tls:Bool -> @ms:U32 -> IO(Maybe<&2, Res>)

def fetch.scheme source · line 995 · raw

@method:String -> @host:String -> @port:U32 -> @hf:String -> @target:String -> @headers:Map<&2, String> -> @body:String -> @ms:U32 -> @+scheme:String -> @known:Bool -> IO(Maybe<&2, Res>)

def fetch.abs source · line 1002 · raw

@method:String -> @headers:Map<&2, String> -> @body:String -> @ms:U32 -> @hf:String -> @a:0x28323c0ff43793bdde97698829f13788/url/url.Abs -> IO(Maybe<&2, Res>)

def fetch.one source · line 1006 · raw

@h:Hop -> @ms:U32 -> IO(Maybe<&2, Res>)

def fetch.decide.r source · line 1014 · raw

@+r:Res -> @next:Maybe<&2, Hop> -> Next

def fetch.decide.res source · line 1021 · raw

@h:Hop -> @+r:Res -> Next

def fetch.decide source · line 1025 · raw

@h:Hop -> @m:Maybe<&2, Res> -> Next

def fetch.hops source · line 1033 · raw

@fuel:Nat -> @+ms:U32 -> @st:Next -> IO(Maybe<&2, Res>)

fuel: the first request plus up to 20 redirects (WHATWG fetch's limit); past that, None.

def fetch.start source · line 1046 · raw

@method:String -> @headers:Map<&2, String> -> @body:String -> @u:Maybe<&2, 0x28323c0ff43793bdde97698829f13788/url/url.Abs> -> Next

def fetch.with source · line 1057 · raw

@method:String -> @url:String -> @headers:Map<&2, String> -> @body:String -> @ms:U32 -> IO(Maybe<&2, Res>)

fetch("GET", "https://example.com/x?y=1", headers, body) follows redirects. None on a bad URL, a failed lookup, connect or handshake, a malformed response, more than 20 redirects, or a step (connect, handshake, one read) that takes longer than ms. Body and response body are bytes.

def fetch source · line 1061 · raw

@method:String -> @url:String -> @headers:Map<&2, String> -> @body:String -> IO(Maybe<&2, Res>)

fetch.with and a 30 s step timeout.

def get source · line 1064 · raw

@url:String -> IO(String)

def sent_fin source · line 1069 · raw

@m:Pair(Socket, Result<&1, &1, Pair(U32, String), Unit>) -> IO(Unit)

def reply_send source · line 1073 · raw

@s:Socket -> @res:Res -> IO(Unit)

Templates

template reply_handle source · line 1078 · raw

@-h:(@_:Req -> IO(Res)) -> @s:Socket -> @req:Req -> IO(Unit)

template reply_parsed source · line 1083 · raw

@-h:(@_:Req -> IO(Res)) -> @s:Socket -> @m:Maybe<&2, Req> -> IO(Unit)

template reply_ok source · line 1090 · raw

@-h:(@_:Req -> IO(Res)) -> @s:Socket -> @raw:String -> IO(Unit)

template reply source · line 1093 · raw

@-h:(@_:Req -> IO(Res)) -> @m:Pair(Socket, Result<&1, &1, Pair(U32, String), String>) -> IO(Unit)

template talk source · line 1101 · raw

@-h:(@_:Req -> IO(Res)) -> @s:Socket -> IO(Unit)

template conn source · line 1106 · raw

@-h:(@_:Req -> IO(Res)) -> @m:Pair(Listener, Result<&1, &1, Pair(U32, String), Socket>) -> IO(Listener)

template serve source · line 1120 · raw

@-h:(@_:Req -> IO(Res)) -> @+port:U32 -> IO(Unit)

Unsafe

unsafe fetch.read source · line 926 · raw

@+head:Bool -> @+tls:Bool -> @+ms:U32 -> @st:Pair(Socket, Rd) -> IO(Maybe<&2, Res>)

Reads until frame says Done or Bad; an empty recv means the server closed.

unsafe loop source · line 1114 · raw

@-h:(@_:Req -> IO(Res)) -> @l:Listener -> IO(Unit)