Urbit Developers
  • Hoon

    • Overview
    • Cheat Sheet
    • Irregular forms
    • Hoon Errors
    • Hoon Style Guide
    • Basic Types
    • Advanced Types
    • Auras
    • Arvo
    • Standard Library

      • 1a: Basic Arithmetic
      • 1b: Tree Addressing
      • 1c: Molds and Mold-Builders
      • 2a: Unit Logic
      • 2b: List Logic
      • 2c: Bit Arithmetic
      • 2d: Bit Logic
      • 2e: Insecure Hashing
      • 2f: Noun Ordering
      • 2g: Unsigned Powers
      • 2h: Set Logic
      • 2i: Map Logic
      • 2j: Jar and Jug Logic
      • 2k: Queue Logic
      • 2l: Container from Container
      • 2m: Container from Noun
      • 2n: Functional Hacks
      • 2o: Normalizing Containers
      • 2p: Serialization
      • 2q: Molds and Mold-Builders
      • 3a: Modular and Signed Ints
      • 3b: Floating Point
      • 3c: Urbit Time
      • 3d: SHA Hash Family
      • 3e: AES encryption (Removed)
      • 3f: Scrambling
      • 3g: Molds and Mold-Builders
      • 4a: Exotic Bases
      • 4b: Text Processing
      • 4c: Tank Printer
      • 4d: Parsing (Tracing)
      • 4e: Parsing (Combinators)
      • 4f: Parsing (Rule-Builders)
      • 4g: Parsing (Outside Caller)
      • 4h: Parsing (ASCII Glyphs)
      • 4i: Parsing (Useful Idioms)
      • 4j: Parsing (Bases and Base Digits)
      • 4k: Atom Printing
      • 4l: Atom Parsing
      • 4m: Formatting Functions
      • 4n: Virtualization
      • 4o: Molds
      • 5a: Compiler Utilities
      • 5b: Macro Expansion
      • 5c: Compiler Backend & Prettyprinter
      • 5d: Parser
      • 5e: Molds and mold builders
      • 5f: Profiling support
      • Runes

        • Constants (Atoms and Strings)
        • + lus · Arms
        • | bar · Cores
        • $ buc · Structures
        • % cen · Calls
        • : col · Cells
        • . dot · Nock
        • / fas · Imports
        • ^ ket · Casts
        • ; mic · Make
        • ~ sig · Hints
        • = tis · Subject
        • ? wut · Conditionals
        • ! zap · Wild
        • --, == Terminators
        • Limbs and wings

          • Limbs
          • Wings
          • Zuse

            • 2d(1-5): To JSON, Wains
            • 2d(6): From JSON
            • 2d(7): From JSON (unit)
            • 2e(2-3): Print & Parse JSON
            • 2m: Ordered Maps
          • Arvo

            • Overview
            • Ames

              • Overview
              • Cryptography
              • API Reference
              • Scry Reference
              • Data Types
              • Behn

                • Overview
                • API Reference
                • Scry Reference
                • Examples
                • Clay

                  • Overview
                  • Architecture
                  • Using Clay
                  • Data Types
                  • Scry Reference
                  • API Reference
                  • Examples
                  • Marks

                    • Overview
                    • Writing Marks
                    • Using Marks
                    • Examples
                  • Dill

                    • Overview
                    • API Reference
                    • Scry Reference
                    • Data Types
                    • Eyre

                      • Overview
                      • External API Reference
                      • Internal API Reference
                      • Scry Reference
                      • Data Types
                      • Guide
                      • Gall

                        • Overview
                        • API Reference
                        • Data Types
                        • Threads Reference
                        • Iris

                          • Overview
                          • API Reference
                          • Data Types
                          • Example
                          • Jael

                            • Overview
                            • API Reference
                            • Scry Reference
                            • Data Types
                            • Examples
                            • Khan

                              • Overview
                              • API Reference
                              • Data Types
                              • Example
                              • Threads

                                • Overview
                                • HTTP API
                                • Reference
                                • Gall

                                  • Start Thread
                                  • Take Result
                                  • Take Facts
                                  • Stop Thread
                                  • Poke Thread
                                  • Examples

                                    • Fetch JSON
                                    • Child Thread
                                    • Main-loop
                                    • Poke Agent
                                    • Scry
                                    • Take Fact
                                  • Concepts

                                    • Scries
                                    • Subscriptions
                                    • Tutorials

                                      • Move Trace
                                      • Reference

                                        • Cryptography
                                        • Filesystem Hierarchy
                                      • Nock

                                        • Nock Definition
                                        • Explanation
                                        • Example
                                        • Implementations
                                        • Vere

                                          • C Runtime System
                                          • Land of Nouns
                                          • API overview by prefix
                                          • C in Urbit
                                          • Writing Jets
                                          • Cryptography
                                          • Azimuth

                                            • Overview
                                            • Urbit HD Wallet
                                            • Azimuth Data Flow
                                            • Azimuth.eth
                                            • Ecliptic.eth
                                            • Advanced Azimuth Tools
                                            • Life and Rift
                                            • Layer 2

                                              • Layer 2 Overview
                                              • Layer 2 Actions
                                              • Transaction Format
                                              • Rollers
                                              • Roller HTTP RPC-API
                                              • Custom Roller Tutorial
                                            • Glossary

                                              • Agent
                                              • Ames
                                              • API
                                              • Aqua
                                              • Arm
                                              • Arvo
                                              • Atom
                                              • Aura
                                              • Aural ASCII
                                              • Azimuth
                                              • Battery
                                              • Behn
                                              • Bowl
                                              • Bridge
                                              • Bunt
                                              • Card
                                              • Case
                                              • Cask
                                              • Cell
                                              • Censures
                                              • Claims
                                              • Clay
                                              • Cold atom
                                              • Comet
                                              • Commit
                                              • Cons
                                              • Context
                                              • Cord
                                              • Core
                                              • Delegated Sending
                                              • Desk
                                              • Dill
                                              • Document Proposal
                                              • Dojo
                                              • Door
                                              • Double-boot
                                              • Dry Gate
                                              • Duct
                                              • Ecliptic
                                              • Entropy
                                              • Event Log
                                              • Eyre
                                              • Face
                                              • Fact
                                              • Foo Bar Baz
                                              • Galaxy
                                              • Gall
                                              • Garden
                                              • Gate
                                              • Generator
                                              • Gift
                                              • Glob
                                              • HD Wallet
                                              • Helm
                                              • Hood
                                              • Hoon
                                              • Invite Tree
                                              • Iris
                                              • Jael
                                              • Jet
                                              • Kelvin versioning
                                              • Kelvin versioning
                                              • Keyfile
                                              • Keywords
                                              • Khan
                                              • Kiln
                                              • Landscape
                                              • Leg
                                              • List
                                              • Loobean
                                              • Lull
                                              • Mark
                                              • Metals
                                              • Mold
                                              • Monad
                                              • Moon
                                              • Move
                                              • Nock
                                              • Noun
                                              • ~
                                              • OTA Updates
                                              • Path Prefix
                                              • Path
                                              • @p
                                              • Payload
                                              • Peek
                                              • pH
                                              • Pier
                                              • Pill
                                              • Planet
                                              • Poke
                                              • Proxies
                                              • Replay
                                              • Factory Reset
                                              • Roller
                                              • Naive rollups
                                              • Rune
                                              • Runtime
                                              • Sail
                                              • Sample
                                              • Scry
                                              • Senate
                                              • Ship
                                              • Slam
                                              • Spider
                                              • Sponsor
                                              • Star
                                              • String
                                              • Subject Oriented Programming
                                              • Subject
                                              • Subscription
                                              • Tape
                                              • Thread
                                              • Trap
                                              • Udon
                                              • Upgrade Proposal
                                              • Userspace
                                              • Vane
                                              • Vase
                                              • Vere
                                              • Voting
                                              • Warm atom
                                              • Wet Gate
                                              • Wing
                                              • Wire
                                              • Wrapper
                                              • ~zod
                                              • Zuse
                                              • Additional

                                                • Cryptography
                                                • Mips (Maps of Maps)
                                                • Software Distribution

                                                  • Overview
                                                  • Docket File
                                                  • Glob
                                                Urbit Developers
                                                • Hoon

                                                  • Overview
                                                  • Cheat Sheet
                                                  • Irregular forms
                                                  • Hoon Errors
                                                  • Hoon Style Guide
                                                  • Basic Types
                                                  • Advanced Types
                                                  • Auras
                                                  • Arvo
                                                  • Standard Library

                                                    • 1a: Basic Arithmetic
                                                    • 1b: Tree Addressing
                                                    • 1c: Molds and Mold-Builders
                                                    • 2a: Unit Logic
                                                    • 2b: List Logic
                                                    • 2c: Bit Arithmetic
                                                    • 2d: Bit Logic
                                                    • 2e: Insecure Hashing
                                                    • 2f: Noun Ordering
                                                    • 2g: Unsigned Powers
                                                    • 2h: Set Logic
                                                    • 2i: Map Logic
                                                    • 2j: Jar and Jug Logic
                                                    • 2k: Queue Logic
                                                    • 2l: Container from Container
                                                    • 2m: Container from Noun
                                                    • 2n: Functional Hacks
                                                    • 2o: Normalizing Containers
                                                    • 2p: Serialization
                                                    • 2q: Molds and Mold-Builders
                                                    • 3a: Modular and Signed Ints
                                                    • 3b: Floating Point
                                                    • 3c: Urbit Time
                                                    • 3d: SHA Hash Family
                                                    • 3e: AES encryption (Removed)
                                                    • 3f: Scrambling
                                                    • 3g: Molds and Mold-Builders
                                                    • 4a: Exotic Bases
                                                    • 4b: Text Processing
                                                    • 4c: Tank Printer
                                                    • 4d: Parsing (Tracing)
                                                    • 4e: Parsing (Combinators)
                                                    • 4f: Parsing (Rule-Builders)
                                                    • 4g: Parsing (Outside Caller)
                                                    • 4h: Parsing (ASCII Glyphs)
                                                    • 4i: Parsing (Useful Idioms)
                                                    • 4j: Parsing (Bases and Base Digits)
                                                    • 4k: Atom Printing
                                                    • 4l: Atom Parsing
                                                    • 4m: Formatting Functions
                                                    • 4n: Virtualization
                                                    • 4o: Molds
                                                    • 5a: Compiler Utilities
                                                    • 5b: Macro Expansion
                                                    • 5c: Compiler Backend & Prettyprinter
                                                    • 5d: Parser
                                                    • 5e: Molds and mold builders
                                                    • 5f: Profiling support
                                                    • Runes

                                                      • Constants (Atoms and Strings)
                                                      • + lus · Arms
                                                      • | bar · Cores
                                                      • $ buc · Structures
                                                      • % cen · Calls
                                                      • : col · Cells
                                                      • . dot · Nock
                                                      • / fas · Imports
                                                      • ^ ket · Casts
                                                      • ; mic · Make
                                                      • ~ sig · Hints
                                                      • = tis · Subject
                                                      • ? wut · Conditionals
                                                      • ! zap · Wild
                                                      • --, == Terminators
                                                      • Limbs and wings

                                                        • Limbs
                                                        • Wings
                                                        • Zuse

                                                          • 2d(1-5): To JSON, Wains
                                                          • 2d(6): From JSON
                                                          • 2d(7): From JSON (unit)
                                                          • 2e(2-3): Print & Parse JSON
                                                          • 2m: Ordered Maps
                                                        • Arvo

                                                          • Overview
                                                          • Ames

                                                            • Overview
                                                            • Cryptography
                                                            • API Reference
                                                            • Scry Reference
                                                            • Data Types
                                                            • Behn

                                                              • Overview
                                                              • API Reference
                                                              • Scry Reference
                                                              • Examples
                                                              • Clay

                                                                • Overview
                                                                • Architecture
                                                                • Using Clay
                                                                • Data Types
                                                                • Scry Reference
                                                                • API Reference
                                                                • Examples
                                                                • Marks

                                                                  • Overview
                                                                  • Writing Marks
                                                                  • Using Marks
                                                                  • Examples
                                                                • Dill

                                                                  • Overview
                                                                  • API Reference
                                                                  • Scry Reference
                                                                  • Data Types
                                                                  • Eyre

                                                                    • Overview
                                                                    • External API Reference
                                                                    • Internal API Reference
                                                                    • Scry Reference
                                                                    • Data Types
                                                                    • Guide
                                                                    • Gall

                                                                      • Overview
                                                                      • API Reference
                                                                      • Data Types
                                                                      • Threads Reference
                                                                      • Iris

                                                                        • Overview
                                                                        • API Reference
                                                                        • Data Types
                                                                        • Example
                                                                        • Jael

                                                                          • Overview
                                                                          • API Reference
                                                                          • Scry Reference
                                                                          • Data Types
                                                                          • Examples
                                                                          • Khan

                                                                            • Overview
                                                                            • API Reference
                                                                            • Data Types
                                                                            • Example
                                                                            • Threads

                                                                              • Overview
                                                                              • HTTP API
                                                                              • Reference
                                                                              • Gall

                                                                                • Start Thread
                                                                                • Take Result
                                                                                • Take Facts
                                                                                • Stop Thread
                                                                                • Poke Thread
                                                                                • Examples

                                                                                  • Fetch JSON
                                                                                  • Child Thread
                                                                                  • Main-loop
                                                                                  • Poke Agent
                                                                                  • Scry
                                                                                  • Take Fact
                                                                                • Concepts

                                                                                  • Scries
                                                                                  • Subscriptions
                                                                                  • Tutorials

                                                                                    • Move Trace
                                                                                    • Reference

                                                                                      • Cryptography
                                                                                      • Filesystem Hierarchy
                                                                                    • Nock

                                                                                      • Nock Definition
                                                                                      • Explanation
                                                                                      • Example
                                                                                      • Implementations
                                                                                      • Vere

                                                                                        • C Runtime System
                                                                                        • Land of Nouns
                                                                                        • API overview by prefix
                                                                                        • C in Urbit
                                                                                        • Writing Jets
                                                                                        • Cryptography
                                                                                        • Azimuth

                                                                                          • Overview
                                                                                          • Urbit HD Wallet
                                                                                          • Azimuth Data Flow
                                                                                          • Azimuth.eth
                                                                                          • Ecliptic.eth
                                                                                          • Advanced Azimuth Tools
                                                                                          • Life and Rift
                                                                                          • Layer 2

                                                                                            • Layer 2 Overview
                                                                                            • Layer 2 Actions
                                                                                            • Transaction Format
                                                                                            • Rollers
                                                                                            • Roller HTTP RPC-API
                                                                                            • Custom Roller Tutorial
                                                                                          • Glossary

                                                                                            • Agent
                                                                                            • Ames
                                                                                            • API
                                                                                            • Aqua
                                                                                            • Arm
                                                                                            • Arvo
                                                                                            • Atom
                                                                                            • Aura
                                                                                            • Aural ASCII
                                                                                            • Azimuth
                                                                                            • Battery
                                                                                            • Behn
                                                                                            • Bowl
                                                                                            • Bridge
                                                                                            • Bunt
                                                                                            • Card
                                                                                            • Case
                                                                                            • Cask
                                                                                            • Cell
                                                                                            • Censures
                                                                                            • Claims
                                                                                            • Clay
                                                                                            • Cold atom
                                                                                            • Comet
                                                                                            • Commit
                                                                                            • Cons
                                                                                            • Context
                                                                                            • Cord
                                                                                            • Core
                                                                                            • Delegated Sending
                                                                                            • Desk
                                                                                            • Dill
                                                                                            • Document Proposal
                                                                                            • Dojo
                                                                                            • Door
                                                                                            • Double-boot
                                                                                            • Dry Gate
                                                                                            • Duct
                                                                                            • Ecliptic
                                                                                            • Entropy
                                                                                            • Event Log
                                                                                            • Eyre
                                                                                            • Face
                                                                                            • Fact
                                                                                            • Foo Bar Baz
                                                                                            • Galaxy
                                                                                            • Gall
                                                                                            • Garden
                                                                                            • Gate
                                                                                            • Generator
                                                                                            • Gift
                                                                                            • Glob
                                                                                            • HD Wallet
                                                                                            • Helm
                                                                                            • Hood
                                                                                            • Hoon
                                                                                            • Invite Tree
                                                                                            • Iris
                                                                                            • Jael
                                                                                            • Jet
                                                                                            • Kelvin versioning
                                                                                            • Kelvin versioning
                                                                                            • Keyfile
                                                                                            • Keywords
                                                                                            • Khan
                                                                                            • Kiln
                                                                                            • Landscape
                                                                                            • Leg
                                                                                            • List
                                                                                            • Loobean
                                                                                            • Lull
                                                                                            • Mark
                                                                                            • Metals
                                                                                            • Mold
                                                                                            • Monad
                                                                                            • Moon
                                                                                            • Move
                                                                                            • Nock
                                                                                            • Noun
                                                                                            • ~
                                                                                            • OTA Updates
                                                                                            • Path Prefix
                                                                                            • Path
                                                                                            • @p
                                                                                            • Payload
                                                                                            • Peek
                                                                                            • pH
                                                                                            • Pier
                                                                                            • Pill
                                                                                            • Planet
                                                                                            • Poke
                                                                                            • Proxies
                                                                                            • Replay
                                                                                            • Factory Reset
                                                                                            • Roller
                                                                                            • Naive rollups
                                                                                            • Rune
                                                                                            • Runtime
                                                                                            • Sail
                                                                                            • Sample
                                                                                            • Scry
                                                                                            • Senate
                                                                                            • Ship
                                                                                            • Slam
                                                                                            • Spider
                                                                                            • Sponsor
                                                                                            • Star
                                                                                            • String
                                                                                            • Subject Oriented Programming
                                                                                            • Subject
                                                                                            • Subscription
                                                                                            • Tape
                                                                                            • Thread
                                                                                            • Trap
                                                                                            • Udon
                                                                                            • Upgrade Proposal
                                                                                            • Userspace
                                                                                            • Vane
                                                                                            • Vase
                                                                                            • Vere
                                                                                            • Voting
                                                                                            • Warm atom
                                                                                            • Wet Gate
                                                                                            • Wing
                                                                                            • Wire
                                                                                            • Wrapper
                                                                                            • ~zod
                                                                                            • Zuse
                                                                                            • Additional

                                                                                              • Cryptography
                                                                                              • Mips (Maps of Maps)
                                                                                              • Software Distribution

                                                                                                • Overview
                                                                                                • Docket File
                                                                                                • Glob
                                                                                              Reference/Arvo/Eyre

                                                                                              Data Types

                                                                                              This document describes the data types used by Eyre as defined in /sys/lull.hoon. It's separated into two sections:

                                                                                              Eyre - Eyre-specific data types.

                                                                                              HTTP - HTTP data types shared between Eyre and Iris.

                                                                                              Eyre

                                                                                              $origin

                                                                                              +$ origin @torigin

                                                                                              A single CORS origin as used in an HTTP Origin header and the $cors-registry.

                                                                                              $cors-registry

                                                                                              +$ cors-registry
                                                                                              $: requests=(set origin)
                                                                                              approved=(set origin)
                                                                                              rejected=(set origin)
                                                                                              ==

                                                                                              CORS origins categorised by approval status. The requests set contains all $origins Eyre has received in the headers of HTTP requests that have not been explicitly approved or rejected. The approved and rejected sets are those that have been explicitly approved or rejected.

                                                                                              $outstanding-connection

                                                                                              +$ outstanding-connection
                                                                                              $: =action
                                                                                              =inbound-request
                                                                                              response-header=(unit response-header:http)
                                                                                              bytes-sent=@ud
                                                                                              ==

                                                                                              An HTTP connection that is currently open. The $action is how it's being handled (e.g. by a Gall app, the channel system, etc). The $inbound-request is the original request which opened the connection. The response-header contains the status code and headers. The bytes-sent is the total bytes sent so far in response.

                                                                                              $authentication-state

                                                                                              +$ authentication-state sessions=(map @uv session)

                                                                                              This represents the authentication state of all sessions. It maps session cookies (without the urbauth-{SHIP}= prefix) to $sessions.

                                                                                              $session

                                                                                              +$ session
                                                                                              $: expiry-time=@da
                                                                                              channels=(set @t)
                                                                                              ==

                                                                                              This represents server-side data about a session. The expiry-time is when the session expires and channels is the set of $channel names opened by the session.

                                                                                              $channel-state

                                                                                              +$ channel-state
                                                                                              $: session=(map @t channel)
                                                                                              duct-to-key=(map duct @t)
                                                                                              ==

                                                                                              The state used by the channel system. The session is a map between channel names and $channels and the duct-to-key maps ducts to channel names.

                                                                                              $timer

                                                                                              +$ timer
                                                                                              $: date=@da
                                                                                              =duct
                                                                                              ==

                                                                                              A reference to a timer so it can be cancelled or updated. The date is when it will fire and the duct is what set the timer.

                                                                                              $channel-event

                                                                                              +$ channel-event
                                                                                              $% $>(%poke-ack sign:agent:gall)
                                                                                              $>(%watch-ack sign:agent:gall)
                                                                                              $>(%kick sign:agent:gall)
                                                                                              [%fact =mark =noun]
                                                                                              ==

                                                                                              An unacknowledged event in the channel system.

                                                                                              $channel

                                                                                              +$ channel
                                                                                              $: state=(each timer duct)
                                                                                              next-id=@ud
                                                                                              last-ack=@da
                                                                                              events=(qeu [id=@ud request-id=@ud =channel-event])
                                                                                              unacked=(map @ud @ud)
                                                                                              subscriptions=(map @ud [ship=@p app=term =path duc=duct])
                                                                                              heartbeat=(unit timer)
                                                                                              ==

                                                                                              This is the state of a particular channel in the channel system. The state is either the expiration time or the duct currently listening. The next-id is the next event ID to be used in the event stream. The last-ack is the date of the last client ack and is used for clog calculations in combination with unacked. The events queue contains all unacked events - id is the server-set event ID, request-id is the client-set request ID and the $channel-event is the event itself. The unacked map contains the unacked event count per request-id and is used for clog calculations. The subscriptions map contains gall subscriptions by request-id. The heartbeat is the SSE heartbeat $timer.

                                                                                              $binding

                                                                                              +$ binding
                                                                                              $: site=(unit @t)
                                                                                              path=(list @t)
                                                                                              ==

                                                                                              A binding is a rule to match a URL path and optional site domain which can then be tied to an $action. A path of /foo will also match /foo/bar, /foo/bar/baz, etc. If the site is ~ it will be determined implicitly. A binding must be unique.

                                                                                              $action

                                                                                              +$ action
                                                                                              $% [%gen =generator] :: dispatch to a generator
                                                                                              [%app app=term] :: dispatch to an application
                                                                                              [%authentication ~] :: internal authentication page
                                                                                              [%logout ~] :: internal logout page
                                                                                              [%channel ~] :: gall channel system
                                                                                              [%scry ~] :: gall scry endpoint
                                                                                              [%four-oh-four ~] :: respond with the default file not found page
                                                                                              ==

                                                                                              The action to take when a $binding matches an incoming HTTP request.

                                                                                              $generator

                                                                                              +$ generator
                                                                                              $: =desk :: desk on current ship that contains the generator
                                                                                              path=(list @t) :: path on :desk to the generator's hoon file
                                                                                              args=* :: args: arguments passed to the gate
                                                                                              ==

                                                                                              This refers to a generator on a local ship that can handle requests. Note that serving generators via Eyre is not fully implmented and should not be used.

                                                                                              $http-config

                                                                                              +$ http-config
                                                                                              $: secure=(unit [key=wain cert=wain])
                                                                                              proxy=_|
                                                                                              log=?
                                                                                              redirect=?
                                                                                              ==

                                                                                              The configuration of the runtime HTTP server itself. The secure field contains the PEM-encoded RSA private key and certificate or certificate chain when using HTTPS, and otherwise is ~ when using plain HTTP. The proxy field is not currently used. The log field turns on HTTP(S) access logs but is not currently implemented. The redirect field turns on 301 redirects to upgrade HTTP to HTTPS if the key and cert are set in secure.

                                                                                              $http-rule

                                                                                              +$ http-rule
                                                                                              $% [%cert cert=(unit [key=wain cert=wain])]
                                                                                              [%turf action=?(%put %del) =turf]
                                                                                              ==

                                                                                              This is for updating the server configuration. In the case of %cert, a cert of ~ clears the HTTPS cert & key, otherwise cert contains the PEM-encoded RSA private key and certificate or certificate chain. In the case of %turf, a %put action sets a domain name and a %del action removes it. The $turf contains the domain name.

                                                                                              $address

                                                                                              +$ address
                                                                                              $% [%ipv4 @if]
                                                                                              [%ipv6 @is]
                                                                                              ==

                                                                                              A client IP address.

                                                                                              $inbound-request

                                                                                              +$ inbound-request
                                                                                              $: authenticated=?
                                                                                              secure=?
                                                                                              =address
                                                                                              =request:http
                                                                                              ==

                                                                                              An inbound HTTP request and metadata. The authenticated field says whether the request was made with a valid session cookie. The secure field says whether it was made with HTTPS. The $address is the IP address from which the request originated, except if it came from localhost and included a Forwarded header, in which case it's the address specified in that header. The $request:http contains the HTTP request itself.

                                                                                              HTTP

                                                                                              $header-list:http

                                                                                              +$ header-list (list [key=@t value=@t])

                                                                                              An ordered list of HTTP headers. The key is the header name e.g 'Content-Type' and the value is the value e.g. text/html.

                                                                                              $method:http

                                                                                              +$ method
                                                                                              $? %'CONNECT'
                                                                                              %'DELETE'
                                                                                              %'GET'
                                                                                              %'HEAD'
                                                                                              %'OPTIONS'
                                                                                              %'POST'
                                                                                              %'PUT'
                                                                                              %'TRACE'
                                                                                              ==

                                                                                              An HTTP method.

                                                                                              $request:http

                                                                                              +$ request
                                                                                              $: method=method
                                                                                              url=@t
                                                                                              =header-list
                                                                                              body=(unit octs)
                                                                                              ==

                                                                                              A single HTTP request. The $method:http is the HTTP method, the url is the unescaped URL, the $header-list:http contains the HTTP headers of the request and the body is the actual data. An octs is just [[email protected] [email protected]] where p is the byte-length of q, the data.

                                                                                              $response-header:http

                                                                                              +$ response-header
                                                                                              $: status-code=@ud
                                                                                              headers=header-list
                                                                                              ==

                                                                                              The status code and $header-list:http of an HTTP response.

                                                                                              $http-event:http

                                                                                              +$ http-event
                                                                                              $% $: %start
                                                                                              =response-header
                                                                                              data=(unit octs)
                                                                                              complete=?
                                                                                              ==
                                                                                              $: %continue
                                                                                              data=(unit octs)
                                                                                              complete=?
                                                                                              ==
                                                                                              [%cancel ~]
                                                                                              ==

                                                                                              Packetized HTTP.

                                                                                              Urbit treats Earth's HTTP servers as pipes, where Urbit sends or receives one or more http-events. The first of these will be a %start, and the last will always be %cancel or will have complete set to %.y to finish the connection.

                                                                                              Calculation of control headers such as 'Content-Length' or 'Transfer-Encoding' should be performed at a higher level; this structure is merely for what gets sent to or received from Earth.

                                                                                              $simple-payload:http

                                                                                              +$ simple-payload
                                                                                              $: =response-header
                                                                                              data=(unit octs)
                                                                                              ==
                                                                                              --

                                                                                              A simple, one-event response used for generators. The $reponse-header:http contains the status code and HTTP headers. The octs in the data contains the body of the response and is a [[email protected] [email protected]] where p is the byte-length of q, the data.

                                                                                              <-

                                                                                              Scry Reference

                                                                                              Guide

                                                                                              ->

                                                                                              Edit this page on GitHub

                                                                                              Last modified March 17, 2023