From 568553394d0a8b34668a75c9839a0f1f426469b2 Mon Sep 17 00:00:00 2001 From: Dimitri Staessens Date: Sun, 6 Oct 2019 21:10:46 +0200 Subject: theme: Switch to docsy theme --- content/en/docs/Concepts/_index.md | 12 + content/en/docs/Concepts/aschenbrenner.png | Bin 0 -> 53954 bytes content/en/docs/Concepts/creating_layers.jpg | Bin 0 -> 54903 bytes content/en/docs/Concepts/dependencies.jpg | Bin 0 -> 12970 bytes content/en/docs/Concepts/elements.md | 96 +++++ content/en/docs/Concepts/layers.jpg | Bin 0 -> 104947 bytes content/en/docs/Concepts/layers.md | 90 +++++ content/en/docs/Concepts/protocols.md | 130 ++++++ content/en/docs/Concepts/rec_netw.jpg | Bin 0 -> 63370 bytes content/en/docs/Concepts/what.md | 146 +++++++ content/en/docs/Contributions/_index.md | 11 + content/en/docs/Examples/_index.md | 13 + content/en/docs/Examples/dev-1.md | 76 ++++ content/en/docs/Extra/_index.md | 7 + content/en/docs/Extra/ioq3.md | 101 +++++ content/en/docs/Extra/raptor.md | 63 +++ content/en/docs/Extra/rumba.md | 13 + content/en/docs/Faq/_index.md | 124 ++++++ content/en/docs/Overview/_index.md | 11 + content/en/docs/Reference/_index.md | 11 + content/en/docs/Reference/compopt.html | 435 +++++++++++++++++++++ content/en/docs/Start/_index.md | 7 + content/en/docs/Start/download.md | 29 ++ content/en/docs/Start/install.md | 57 +++ content/en/docs/Start/requirements.md | 76 ++++ content/en/docs/Tutorials/_index.md | 13 + .../en/docs/Tutorials/ouroboros_tut1_overview.png | Bin 0 -> 35029 bytes .../en/docs/Tutorials/ouroboros_tut2_enrolled.png | Bin 0 -> 10816 bytes .../en/docs/Tutorials/ouroboros_tut2_overview.png | Bin 0 -> 9310 bytes content/en/docs/Tutorials/ovpn-tut.md | 216 ++++++++++ content/en/docs/Tutorials/ovpn_tut.png | Bin 0 -> 25023 bytes content/en/docs/Tutorials/tut-2-1.jpg | Bin 0 -> 18903 bytes content/en/docs/Tutorials/tutorial-1.md | 160 ++++++++ content/en/docs/Tutorials/tutorial-2.md | 304 ++++++++++++++ content/en/docs/Tutorials/tutorial-3.md | 216 ++++++++++ content/en/docs/Tutorials/tutorial-4.md | 129 ++++++ content/en/docs/_index.md | 13 + 37 files changed, 2559 insertions(+) create mode 100644 content/en/docs/Concepts/_index.md create mode 100644 content/en/docs/Concepts/aschenbrenner.png create mode 100644 content/en/docs/Concepts/creating_layers.jpg create mode 100644 content/en/docs/Concepts/dependencies.jpg create mode 100644 content/en/docs/Concepts/elements.md create mode 100644 content/en/docs/Concepts/layers.jpg create mode 100644 content/en/docs/Concepts/layers.md create mode 100644 content/en/docs/Concepts/protocols.md create mode 100644 content/en/docs/Concepts/rec_netw.jpg create mode 100644 content/en/docs/Concepts/what.md create mode 100644 content/en/docs/Contributions/_index.md create mode 100755 content/en/docs/Examples/_index.md create mode 100644 content/en/docs/Examples/dev-1.md create mode 100644 content/en/docs/Extra/_index.md create mode 100644 content/en/docs/Extra/ioq3.md create mode 100644 content/en/docs/Extra/raptor.md create mode 100644 content/en/docs/Extra/rumba.md create mode 100644 content/en/docs/Faq/_index.md create mode 100644 content/en/docs/Overview/_index.md create mode 100644 content/en/docs/Reference/_index.md create mode 100644 content/en/docs/Reference/compopt.html create mode 100644 content/en/docs/Start/_index.md create mode 100644 content/en/docs/Start/download.md create mode 100644 content/en/docs/Start/install.md create mode 100644 content/en/docs/Start/requirements.md create mode 100755 content/en/docs/Tutorials/_index.md create mode 100644 content/en/docs/Tutorials/ouroboros_tut1_overview.png create mode 100644 content/en/docs/Tutorials/ouroboros_tut2_enrolled.png create mode 100644 content/en/docs/Tutorials/ouroboros_tut2_overview.png create mode 100644 content/en/docs/Tutorials/ovpn-tut.md create mode 100644 content/en/docs/Tutorials/ovpn_tut.png create mode 100644 content/en/docs/Tutorials/tut-2-1.jpg create mode 100644 content/en/docs/Tutorials/tutorial-1.md create mode 100644 content/en/docs/Tutorials/tutorial-2.md create mode 100644 content/en/docs/Tutorials/tutorial-3.md create mode 100644 content/en/docs/Tutorials/tutorial-4.md create mode 100755 content/en/docs/_index.md (limited to 'content/en/docs') diff --git a/content/en/docs/Concepts/_index.md b/content/en/docs/Concepts/_index.md new file mode 100644 index 0000000..ea9b33c --- /dev/null +++ b/content/en/docs/Concepts/_index.md @@ -0,0 +1,12 @@ +--- +title: "Concepts" +linkTitle: "Concepts" +weight: 40 +description: > + The concepts underpinning recursive networks in general + and Ouroboros in particular. +--- + +{{% pageinfo %}} +Under construction, subpages are accessible. +{{% /pageinfo %}} diff --git a/content/en/docs/Concepts/aschenbrenner.png b/content/en/docs/Concepts/aschenbrenner.png new file mode 100644 index 0000000..b9b11f6 Binary files /dev/null and b/content/en/docs/Concepts/aschenbrenner.png differ diff --git a/content/en/docs/Concepts/creating_layers.jpg b/content/en/docs/Concepts/creating_layers.jpg new file mode 100644 index 0000000..fe60019 Binary files /dev/null and b/content/en/docs/Concepts/creating_layers.jpg differ diff --git a/content/en/docs/Concepts/dependencies.jpg b/content/en/docs/Concepts/dependencies.jpg new file mode 100644 index 0000000..eaa9e79 Binary files /dev/null and b/content/en/docs/Concepts/dependencies.jpg differ diff --git a/content/en/docs/Concepts/elements.md b/content/en/docs/Concepts/elements.md new file mode 100644 index 0000000..bfc7fab --- /dev/null +++ b/content/en/docs/Concepts/elements.md @@ -0,0 +1,96 @@ +--- +title: "Elements of a recursive network" +author: "Dimitri Staessens" +date: 2019-07-11 +weight: 2 +description: > + The building blocks for recursive networks. +--- + +This section describes the high-level concepts and building blocks are +used to construct a decentralized [recursive network](/docs/what): +layers and flows. (Ouroboros has two different kinds of layers, but +we will dig into all the fine details in later posts). + +A __layer__ in a recursive network embodies all of the functionalities +that are currently in layers 3 and 4 of the OSI model (along with some +other functions). The difference is subtle and takes a while to get +used to (not unlike the differences in the term *variable* in +imperative versus functional programming languages). A recursive +network layer handles requests for communication to some remote +process and, as a result, it either provides a handle to a +communication channel -- a __flow__ endpoint --, or it raises some +error that no such flow could be provided. + +A layer in Ouroboros is built up from a bunch of (identical) programs +that work together, called Inter-Process Communication (IPC) Processes +(__IPCPs__). The name "IPCP" was first coined for a component of the +[LINCS] +(https://www.osti.gov/biblio/5542785-delta-protocol-specification-working-draft) +hierarchical network architecture built at Lawrence Livermore National +Laboratories and was taken over in the RINA architecture. These IPCPs +implement the core functionalities (such as routing, a dictionary) and +can be seen as small virtual routers for the recursive network. + +{{
}} + +In the illustration, a small 5-node recursive network is shown. It +consists of two hosts that connect via edge routers to a small core. +There are 6 layers in this network, labelled __A__ to __F__. + +On the right-hand end-host, a server program __Y__ is running (think a +mail server program), and the (mail) client __X__ establishes a flow +to __Y__ over layer __F__ (only the endpoints are drawn to avoid +cluttering the image). + +Now, how does the layer __F__ get the messages from __X__ to __Y__? +There are 4 IPCPs (__F1__ to __F4__) in layer __F__, that work +together to provide the flow between the applications __X__ and +__Y__. And how does __F3__ get the info to __F4__? That is where the +recursion comes in. A layer at some level (its __rank__), will use +flows from another layer at a lower level. The rank of a layer is a +local value. In the hosts, layer __F__ is at rank 1, just above layer +__C__ or layer __E_. In the edge router, layer __F__ is at rank 2, +because there is also layer __D__ in that router. So the flow between +__X__ and __Y__ is supported by flows in layer __C__, __D__ and __E__, +and the flows in layer __D__ are supported by flows in layers __A__ +and __B__. + +Of course these dependencies can't go on forever. At the lowest level, +layers __A__, __B__, __C__ and __E__ don't depend on a lower layer +anymore, and are sometimes called 0-layers. They only implement the +functions to provide flows, but internally, they are specifically +tailored to a transmission technology or a legacy network +technology. Ouroboros supports such layers over (local) shared memory, +over the User Datagram Protocol, over Ethernet and a prototype that +supports flows over an Ethernet FPGA device. This allows Ouroboros to +integrate with existing networks at OSI layers 4, 2 and 1. + +If we then complete the picture above, when __X__ sends a packet to +__Y__, it passes it to __F3__, which uses a flow to __F1__ that is +implemented as a direct flow between __C2__ and __C1__. __F1__ then +forwards the packet to __F2__ over a flow that is supported by layer +__D__. This flow is implemented by two flows, one from __D2__ to +__D1__, which is supported by layer A, and one from __D1__ to __D3__, +which is supported by layer __B__. __F2__ will forward the packet to +__F4__, using a flow provided by layer __E__, and __F4__ then delivers +the packet to __Y__. So the packet moves along the following chain of +IPCPs: __F3__ --> __C2__ --> __C1__ --> __F1__ --> __D2__ --> __A1__ +--> __A2__ --> __D1__ --> __B1__ --> __B2__ --> __D3__ --> __F2__ --> +__E1__ --> __E2__ --> __F4__. + +{{
}} + +A recursive network has __dependencies__ between layers in the +network, and between IPCPs in a __system__. These dependencies can be +represented as a directed acyclic graph (DAG). To avoid problems, +these dependencies should never contain cycles (so a layer I should +not directly or indirectly depend on itself). The rank of a layer is +defined (either locally or globally) as the maximum depth of this +layer in the DAG. + +--- +Changelog: + +2019 07 11: Initial version.
+2019 07 23: Added dependency graph figure diff --git a/content/en/docs/Concepts/layers.jpg b/content/en/docs/Concepts/layers.jpg new file mode 100644 index 0000000..5d3020c Binary files /dev/null and b/content/en/docs/Concepts/layers.jpg differ diff --git a/content/en/docs/Concepts/layers.md b/content/en/docs/Concepts/layers.md new file mode 100644 index 0000000..e7c1441 --- /dev/null +++ b/content/en/docs/Concepts/layers.md @@ -0,0 +1,90 @@ +--- +title: "Recursive layers" +author: "Dimitri Staessens" +#description: "IRMd" +date: 2019-07-23 +weight: 20 +#type: page +draft: false +description: > + How to build a recursive network. +--- + +The most important structure in recursive networks are the layers, +that are built op from [elements](/docs/elements/) called +Inter-Process Communication Processes (IPCPs). (Note again that the +layers in recursive networks are not the same as layers in the OSI +model). + +{{
}} + +Now, the question is, how do we build these up these layers? IPCPs are +small programs (think of small virtual routers) that need to be +started, configured and managed. This functionality is usually +implemented in some sort of management daemon. Current RINA +implementations call it the *IPC manager*, Ouroboros calls it the +__IPC Resource Management daemon__ or __IRMd__ for short. The IRMd +lies at the heart of each system that is participating in an Ouroboros +network, implementing the core function primitives. It serves as the +entry point for the system/network administrator to manage the network +resources. + +We will describe the functions of the Ouroboros IRMd with the +Ouroboros commands for illustration and to make things a bit more +tangible. + +The first set of primitives, __create__ (and __destroy__), allow +creating IPCPs of a given *type*. This just runs the process without +any further configuration. At this point, that process is not part of +any layer. + +``` +$ irm ipcp create type unicast name my_ipcp +$ irm ipcp list ++---------+----------------------+------------+----------------------+ +| pid | name | type | layer | ++---------+----------------------+------------+----------------------+ +| 7224 | my_ipcp | unicast | Not enrolled | ++---------+----------------------+------------+----------------------+ +``` + +The example above creates a unicast IPCP and gives that IPCP a name +(we called it "my_ipcp"). A listing of the IPCPs in the system shows +that the IPCP is running as process 7224, and it is not part of a +layer ("*Not enrolled*"). + +To create a new functioning network layer, we need to configure the +IPCP, using a primitive called __bootstrapping__. Bootstrapping sets a +number of configuration optionss for the layer (such as the routing +algorithm to use) and activates the IPCP to allow it to start +providing flows. The Ouroboros command line allows creating an IPCP +with some default values, that are a bit like a vanilla IPv4 network: +32-bit addresses and shortest-path link-state routing. + +``` +$ irm ipcp bootstrap name my_ipcp layer my_layer +$ irm ipcp list ++---------+----------------------+------------+----------------------+ +| pid | name | type | layer | ++---------+----------------------+------------+----------------------+ +| 7224 | my_ipcp | unicast | my_layer | ++---------+----------------------+------------+----------------------+ +``` + +Now we have a single node-network. In order to create a larger +network, we connect and configure new IPCPs using a third primitive +called __enrollment__. When enrolling an IPCP in a network, it will +create a flow (using a lower layer) to an existing member of the +layer, download the bootstrapping information, and use it to configure +itself as part of this layer. + +The final primitive is the __connect__ (and __disconnect__) +primitive. This allows to create *adjacencies* between network nodes. + +An example of how to create a small two-node network is given in +[tutorial 2](/docs/tutorials/tutorial-2/) + +--- +Changelog: + +2019-07-23: Initial version diff --git a/content/en/docs/Concepts/protocols.md b/content/en/docs/Concepts/protocols.md new file mode 100644 index 0000000..16c72cb --- /dev/null +++ b/content/en/docs/Concepts/protocols.md @@ -0,0 +1,130 @@ +--- +title: "The protocols" +author: "Dimitri Staessens" +#description: protocols +date: 2019-09-06 +#type: page +draft: false +description: > + A brief introduction to the main protocols. +--- + +# Network protocol + +As Ouroboros tries to preserve privacy as much as possible, it has an +*absolutely minimal network protocol*: + +``` + 0 1 2 3 + 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | | + + Destination Address + + | | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Time-to-Live | QoS | ECN | EID | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | EID | + +-+-+-+-+-+-+-+-+ +``` + +The 5 fields in the Ouroboros network protocol are: + +* **Destination address**: This specifies the address to forward the + packet to. The width of this field is configurable based on various + preferences and the size of the envisioned network. The Ouroboros + default is 64 bits. Note that there is _no source address_, this is + agreed upon during _flow allocation_. + +* **Time-to-Live**: Similar to IPv4 and IPv6 (where this field is called + Hop Limit), this is decremented at each hop to ensures that packets + don't get forwarded forever in the network, for instance due to + (transient) loops in the forwarding path. The Ouroboros default for + the width is one octet (byte). + +* **QoS**: Ouroboros supports Quality of Service via a number of methods + (out of scope for this page), and this field is used to prioritize + scheduling of the packets when forwarding. For instance, if the + network gets congested and queues start filling up, higher priority + packets (e.g. a voice call) get scheduled more often than lower + priority packets (e.g. a file download). By default this field takes + one octet. + +* **ECN**: This field specifies Explicit Congestion Notification (ECN), + with similar intent as the ECN bits in the Type-of-Service field in + IPv4 / Traffic Class field in IPv6. The Ouroboros ECN field is by + default one octet wide, and its value is set to an increasing value + as packets are queued deeper and deeper in a congested routers' + forwarding queues. Ouroboros enforces Forward ECN (FECN). + +* **EID**: The Endpoint Identifier (EID) field specified the endpoint for + which to deliver the packet. The width of this field is configurable + (the figure shows 16 bits). The values of this field is chosen by + the endpoints, usually at _flow allocation_. It can be thought of as + similar to an ephemeral port. However, in Ouroboros there is no + hardcoded or standardized mapping of an EID to an application. + +# Transport protocol + +Packet switched networks use transport protocols on top of their +network protocol in order to deal with lost or corrupted packets. + +The Ouroboros Transport protocol (called the _Flow and Retransmission +Control Protocol_, FRCP) has only 4 fields: + +``` + 0 1 2 3 + 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Flags | Window | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Sequence Number | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Acknowledgment Number | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + +``` + +* **Flags**: There are 7 flags defined for FRCP. + + - **DATA**: Indicates that the packet is carrying data (this allows + for 0 length data). + + - **DRF** : Data Run Flag, indicates that there are no unacknowledged + packets in flight for this connection. + + - **ACK** : Indicates that this packet carries an acknowledgment. + - **FC** : Indicates that this packet updates the flow control window. + - **RDVZ**: Rendez-vous, this is used to break a zero-window deadlock + that can arise when an update to the flow control window + gets lost. RDVZ packets must be ACK'd. + - **FFGM**: First Fragment, this packet contains the first fragment of + a fragmented payload. + - **MFGM**: More Fragments, this packet is not the last fragment of a + fragmented payload. + +* **Window**: This updates the flow control window. + +* **Sequence Number**: This is a monotonically increasing sequence number + used to (re)order the packets at the receiver. + +* **Acknowledgment Number**: This is set by the receiver to indicate the + highest sequence number that was received in + order. + +# Operation + +The operation of the transport protocol is based on the [Delta-t +protocol]((https://www.osti.gov/biblio/5542785-delta-protocol-specification-working-draft)), +which is a timer-based protocol that is a bit simpler in operation +than the equivalent functionalities in TCP. In contrast with TCP/IP, +Ouroboros does congestion control purely in the network protocol, and +fragmentation and flow control purely in the transport protocol. + + + + +--- Changelog: + +2019 09 05: Initial version.
+2019 09 06: Added section on transport protocol. \ No newline at end of file diff --git a/content/en/docs/Concepts/rec_netw.jpg b/content/en/docs/Concepts/rec_netw.jpg new file mode 100644 index 0000000..bddaca5 Binary files /dev/null and b/content/en/docs/Concepts/rec_netw.jpg differ diff --git a/content/en/docs/Concepts/what.md b/content/en/docs/Concepts/what.md new file mode 100644 index 0000000..bacd4d6 --- /dev/null +++ b/content/en/docs/Concepts/what.md @@ -0,0 +1,146 @@ +--- +title: "What is a recursive network?" +author: "Dimitri Staessens" + +date: 2019-07-06 +weight: 1 +description: > + Introduction to recursive networks. +--- + +# The current networking paradigm +{{
}} + +Every computer science class that deals with networks explains the +[7-layer OSI model](https://www.bmc.com/blogs/osi-model-7-layers/). +Open Systems Interconnect (OSI) defines 7 layers, each providing an +abstraction for a certain *function* that a network application may +need. + +From top to bottom, the layers provide (roughly) the following +functions: + +The __application layer__ implements the details of the application +protocol (such as HTTP), which specifies the operations and data that +the application understands (requesting a web page). + +The __presentation layer__ provides independence of data representation, +and may also perform encryption. + +The __session layer__ sets up and manages sessions (think of a session +as a conversation or dialogue) between the applications. + +The __transport layer__ handles individual chunks of data (think of them +as words in the conversation), and can ensure that there is end-to-end +reliability (no words or phrases get lost). + +The __network layer__ forwards the packets across the network, it +provides such things as addressing and congestion control. + +The __datalink layer__ encodes data into bits and moves them between +hosts. It handles errors in the physical layer. It has two sub-layers: +Media access control layer (MAC), which says when hosts can transmit +on the medium, and logical link control (LLC) that deals with error +handling and control of transmission rates. + +Finally, the __physical layer__ is responsible for translating the +bits into a signal (e.g. laser pulses in a fibre) that is carried +between endpoints. + +This functional layering provides a logical order for the steps that +data passes through between applications. Indeed, every existing +(packet) network goes through these steps in roughly this order +(however, some may be skipped). There can be some small variations on +where the functions are implemented. For instance, TCP does congestion +control, but is a Layer 4 protocol. + +However, when looking at current networking solutions, things are not +as simple as these 7 layers seem to indicate. Just consider this +realistic scenario for a software developer working remotely. Usually +it goes something like this: You connect to the company __Virtual +Private Network__ (VPN), setup an SSH __tunnel__ over the development +server to your virtual machine and then SSH into that virtual machine. + +The use of VPNs and various tunneling technologies draw a picture +where the __functions__ of Layers 2, 3, and 4, and often layers 5 and +6 (encryption) are __repeated__ a number of times in the actual +functional path that data follows through the network stack. + +Enter __*recursive networks*__. + +# The recursive network paradigm + +The functional repetition in the network stack is discussed in +detail in the book __*"Patterns in Network Architecture: A Return to +Fundamentals"*__. From the observations in the book, a new architecture +was proposed, called the "__R__ecursive __I__nter__N__etwork +__A__rchitecture", or [__RINA__](http://www.pouzinsociety.org). + +__Ouroboros__ follows the recursive principles of RINA, but deviates +quit a bit from its internal design. There are resources on the +Internet explaining RINA, but here we will focus +on its high level design and what is relevant for Ouroboros. + +Let's look at a simple scenario of an employee contacting an internet +corporate server over a Layer 3 VPN from home. Let's assume for +simplicity that the corporate LAN is not behind a NAT firewall. All +three networks perform (among some other things): + +__Addressing__: The VPN hosts receive an IP address in the VPN, let's +say some 10.11.12.0/24 address. The host will also have a public IP +address, for instance in the 20.128.0.0/16 range . Finally that host +will have an Ethernet MAC address. Now the addresses __differ in +syntax and semantics__, but for the purpose of moving data packets, +they have the same function: __identifying a node in a network__. + +__Forwarding__: Forwarding is the process of moving packets to a +destination __with intent__: each forwarding action moves the data +packet __closer__ to its destination node with respect to some +__metric__ (distance function). + +__Network discovery__: Ethernet switches learn where the endpoints are +through MAC learning, remembering the incoming interface when it sees +a new SRC address; IP routers learn the network by exchanging +informational packets about adjacency in a process called *routing*; +and a VPN proxy server relays packets as the central hub of a network +connected as a star between the VPN clients and the local area +network (LAN) that is provides access to. + +__Congestion management__: When there is a prolonged period where a +node receives more traffic than can forward forward, for instance +because there are incoming links with higher speeds than some outgoing +link, or there is a lot of traffic between different endpoints towards +the same destination, the endpoints experience congestion. Each +network could handle this situation (but not all do: TCP does +congestion control for IP networks, but Ethernet just drops traffic +and lets the IP network deal with it. Congestion management for +Ethernet never really took off). + +__Name resolution__: In order not having to remember addresses of the +hosts (which are in a format that make it easier for a machine to deal +with), each network keeps a mapping of a name to an address. For IP +networks (which includes the VPN in our example), this is done by the +Domain Name System (DNS) service (or, alternatively, other services +such as *open root* or *namecoin*). For Ethernet, the Address +Resolution Protocol maps a higher layer name to a MAC (hardware) +address. + +{{
}} + +Recursive networks take all these functions to be part of a network +layer, and layers are mostly defined by their __scope__. The lowest +layers span a link or the reach of some wireless technology. Higher +layers span a LAN or the network of a corporation e.g. a subnetwork or +an Autonomous System (AS). An even higher layer would be a global +network, followed by a Virtual Private Network and on top a tunnel +that supports the application. Each layer being the same in terms of +functionality, but different in its choice of algorithm or +implementation. Sometimes the function is just not implemented +(there's no need for routing in a tunnel!), but logically it could be +there. + + +--- +Changelog: + +2019 07 09: Initial version. \ No newline at end of file diff --git a/content/en/docs/Contributions/_index.md b/content/en/docs/Contributions/_index.md new file mode 100644 index 0000000..2ab0e0a --- /dev/null +++ b/content/en/docs/Contributions/_index.md @@ -0,0 +1,11 @@ +--- +title: "Contribution Guidelines" +linkTitle: "Contribution Guidelines" +weight: 110 +description: > + How to contribute to Ouroboros +--- + +{{% pageinfo %}} +Under construction. +{{% /pageinfo %}} diff --git a/content/en/docs/Examples/_index.md b/content/en/docs/Examples/_index.md new file mode 100755 index 0000000..fb296e3 --- /dev/null +++ b/content/en/docs/Examples/_index.md @@ -0,0 +1,13 @@ + +--- +title: "Examples" +linkTitle: "Examples" +weight: 50 +date: 2017-01-05 +description: > + This is a collections of examples what can be done with ouroboros. +--- + +{{% pageinfo %}} +Under construction, subpages are available. +{{% /pageinfo %}} diff --git a/content/en/docs/Examples/dev-1.md b/content/en/docs/Examples/dev-1.md new file mode 100644 index 0000000..6a1af57 --- /dev/null +++ b/content/en/docs/Examples/dev-1.md @@ -0,0 +1,76 @@ +--- +title: "Writing your first Ouroboros C program" +author: "Dimitri Staessens" +date: 2019-08-31 +draft: false +description: > + A simple Hello World! example. +--- + +Here we guide you to write your first ouroboros program. It will use +the basic Ouroboros IPC Application Programming Interface. It will has +a client and a server that send a small "Hello World!" message from +the client to the server. + +We will explain how to connect two applications. The server application +uses the flow_accept() call to accept incoming connections and the +client uses the flow_alloc() call to connect to the server. The +flow_accept and flow_alloc call have the following definitions: + +```C +int flow_accept(qosspec_t * qs, const struct timespec * timeo); +int flow_alloc(const char * dst, qosspec_t * qs, const struct timespec * timeo); +``` + +On the server side, the flow_accept() call is a blocking call that will +wait for an incoming flow from a client. On the client side, the +flow_alloc() call is a blocking call that allocates a flow to *dst*. +Both calls return an non-negative integer number describing a "flow +descriptor", which is very similar to a file descriptor. On error, they +will return a negative error code. (See the [man +page](/man/man3/flow_alloc.html) for all details). If the *timeo* +parameter supplied is NULL, the calls will block indefinitely, otherwise +flow_alloc() will return -ETIMEDOUT when the time interval provided by +*timeo* expires. We are working on implementing non-blocking versions if +the provided *timeo* is 0. + +After the flow is allocated, the flow_read() and flow_write() calls +are used to read from the flow descriptor. They operate just like the +read() and write() POSIX calls. The default behaviour is that these +calls will block. To release the resource, the flow can be deallocated +using flow_dealloc. + +```C +ssize_t flow_write(int fd, const void * buf, size_t count); +ssize_t flow_read(int fd, void * buf, size_t count); int +flow_dealloc(int fd); +``` + +So a very simple application would just need a couple of lines of code +for both the server and the client: + +```C +/* server side */ +char msg[BUF_LEN]; +int fd = flow_accept(NULL, NULL); +flow_read(fd, msg, BUF_LEN); +flow_dealloc(fd); + +/* client side */ +char * msg = "Hello World!"; +int fd = flow_alloc("server", NULL, NULL); +flow_write(fd, msg, strlen(msg)); +flow_dealloc(fd); +``` + +The full code for an example is the +[oecho](/cgit/ouroboros/tree/src/tools/oecho/oecho.c) +application in the tools directory. + +To compile your C program from the command line, you have to link +-lourobos-dev. For instance, in the Ouroboros repository, you can do + +```bash +cd src/tools/oecho +gcc -louroboros-dev oecho.c -o oecho +``` \ No newline at end of file diff --git a/content/en/docs/Extra/_index.md b/content/en/docs/Extra/_index.md new file mode 100644 index 0000000..8a405b0 --- /dev/null +++ b/content/en/docs/Extra/_index.md @@ -0,0 +1,7 @@ +--- +title: "Extra" +linkTitle: "Extra" +weight: 90 +description: > + Some extra tools and software. +--- diff --git a/content/en/docs/Extra/ioq3.md b/content/en/docs/Extra/ioq3.md new file mode 100644 index 0000000..a024c7d --- /dev/null +++ b/content/en/docs/Extra/ioq3.md @@ -0,0 +1,101 @@ +--- +title: "ioq3" +author: "Dimitri Staessens" +date: 2019-10-06 +draft: false +description: > + Added support for Ouroboros to the ioq3 game engine. +--- + + +As a demo, we have added Ouroboros support to the +[ioq3](https://github.com/ioquake/ioq3) game engine. ioq3 is a fork of +ID software's [Quake III Arena GPL Source +Release](https://github.com/id-Software/Quake-III-Arena). The port is +available as a [patch](/patches/ouroboros-ioq3.patch). The servers +currently only work in dedicated mode (there is no way yet to start a +server from the client). + +To get the demo, first get the latest ioq3 sources: + +```bash +$ git clone https://github.com/ioquake/ioq3.git +$ cd ioq3 +``` + +Copy the patch via the link above, or get it via wget: + +```bash +$ wget https://ouroboros.rocks/patches/ouroboros-ioq3.patch +``` + +Apply the patch to the ioq3 code: + +```bash +$ git apply ouroboros-ioq3.patch +``` + +With Ouroboros installed, build the ioq3 project in standalone mode: + +```bash +$ STANDALONE=1 make +``` + +You may need to install some dependencies like SDL2, see the [ioq3 +documentation](http://wiki.ioquake3.org/Building_ioquake3). + +The ioq3 project only supplies the game engine. To play Quake III Arena, +you need the original game files and a valid key. Various open source +games make use of the engine. We wil detail the procedure for running +OpenArena in your ioq3 build directory. + +Go to your build directory: + +```bash +$ cd build// +``` + +To run OpenArena, you only need to the game files. First download the +zip archive (openarena-0.8.8.zip) from the [OpenArena +website](http://www.openarena.ws) (or via wget) and then extract the +baseoa folder: + +```bash +$ wget http://www.openarena.ws/request.php?4 -O openarena-0.8.8.zip +$ unzip -j openarena-0.8.8.zip 'openarena-0.8.8/baseoa/*' -d +./baseoa +``` + +Make sure you have a local Ouroboros layer running in your system (see +[this](/tutorial-1/). + +To test the game, start a server (replace with the correct +architecture extension for your machine, eg x86_64): + +```bash +$ ./ioq3ded. +set com_basegame baseoa +map aggressor +``` + +Bind the pid of the server to a name and register it in the local layer: + +```bash +$ irm bind proc name my.ioq3.server +$ irm reg name my.ioq3.server layer +``` + +To connect, start a client (in a different terminal): + +```bash +$ ./ioquake3. +set com_basegame baseoa +``` + +When the client starts, go to the console by typing ~ (tilde) and enter +the following command + +```bash +connect -O my.ioq3.server +``` + +The client should now connect to the ioq3 dedicated server over +Ouroboros. Register the name in non-local layers to connect from other +machines. Happy Fragging! diff --git a/content/en/docs/Extra/raptor.md b/content/en/docs/Extra/raptor.md new file mode 100644 index 0000000..cf0f83b --- /dev/null +++ b/content/en/docs/Extra/raptor.md @@ -0,0 +1,63 @@ +--- +title: "Raptor" +author: "Dimitri Staessens" +date: 2019-10-06 +draft: false +description: > + Proof-of-concept FPGA demonstrator for Ouroboros. +--- + +Raptor is a proof-of-concept FPGA demonstrator for running Ouroboros +directly over Ethernet PHY (OSI L1). For this, it uses the [NetFPGA +10G](http://netfpga.org/site/#/systems/3netfpga-10g/details/) platform, +which has Broadcom AEL2005 PHY 10G Ethernet devices. Raptor is +point-to-point and does not use addresses. It is available for Linux +only and support is minimal. If you are interested in trying it out, +please contact us via the ouroboros mailing list or the IRC channel. + +You can clone the [raptor repository](/cgit/raptor/): + +```bash +$ git clone http://ouroboros.rocks/git/raptor +$ git clone https://ouroboros.rocks/git/raptor +$ git clone git://ouroboros.rocks/raptor +``` + +There are two directories. The *linux* directory contains the kernel +module, the *netfpga10g* directory contains the files necessary to build +the FPGA design. + +To build and install the kernel module: + +```bash +$ make +$ sudo make install +``` + +You can now load/unload the raptor kernel module: + +```bash +$ sudo modprobe raptor +$ sudo rmmod raptor +``` + +To uninstall the module: + +```bash +$ sudo make uninstall +``` + +You will need to get some cores (such as PCIe and XAUI) from Xilinx in +order to build this project using the provided tcl script. Detailed +instructions on how to build the NetFPGA project under construction. + +Raptor is integrated in Ouroboros and the raptor IPCP will be built if +the kernel module is installed in the default location. + +Raptor was developed as part of the master thesis (in Dutch) +"Implementatie van de Recursive Internet Architecture op een FPGA +platform" by Alexander D'hoore. The kernel module is licensed under +the [GNU Public License (GPL) version +2](https://www.gnu.org/licenses/old-licenses/gpl-2.0.html). The NetFPGA +design is available under the [GNU Lesser Public License (LGPL) version +2.1](https://www.gnu.org/licenses/old-licenses/lgpl-2.1.html). diff --git a/content/en/docs/Extra/rumba.md b/content/en/docs/Extra/rumba.md new file mode 100644 index 0000000..5023f8e --- /dev/null +++ b/content/en/docs/Extra/rumba.md @@ -0,0 +1,13 @@ +--- +title: "Rumba" +author: "Dimitri Staessens" +date: 2019-10-06 +draft: false +description: > + Small orchestration framework for deploying recursive networks. +--- + +Rumba is an __experimentation framework__ for deploying recursive +network experiments in various network testbeds. It was developed as +part of the [ARCFIRE](http://ict-arcfire.eu) project, and available on +[gitlab](https://gitlab.com/arcfire/rumba) . diff --git a/content/en/docs/Faq/_index.md b/content/en/docs/Faq/_index.md new file mode 100644 index 0000000..f5599e3 --- /dev/null +++ b/content/en/docs/Faq/_index.md @@ -0,0 +1,124 @@ +--- +title: "FAQ" +date: 2019-06-22 +draft: false +description: > + Frequently Asked Questions. +weight: 85 +--- + +Got a question that is not listed here? Just pop it on our IRC channel +or mailing list and we will be happy to answer it! + +[What is Ouroboros?](#what)\ +[Is Ouroboros the same as the Recursive InterNetwork Architecture +(RINA)?](#rina)\ +[How can I use Ouroboros right now?](#deploy)\ +[What are the benefits of Ouroboros?](#benefits)\ +[How do you manage the namespaces?](#namespaces)\ + +### What is Ouroboros? + +Ouroboros is a packet-based IPC mechanism. It allows programs to +communicate by sending messages, and provides a very simple API to do +so. At its core, it's an implementation of a recursive network +architecture. It can run next to, or over, common network technologies +such as Ethernet and IP. + +[[back to top](#top)] + +### Is Ouroboros the same as the Recursive InterNetwork Architecture (RINA)? + +No. Ouroboros is a recursive network, and is born as part of our +research into RINA networks. Without the pioneering work of John Day and +others on RINA, Ouroboros would not exist. We consider the RINA model an +elegant way to think about distributed applications and networks. + +However, there are major architectural differences between Ouroboros and +RINA. The most important difference is the location of the "transport +functions" which are related to connection management, such as +fragmentation, packet ordering and automated repeat request (ARQ). RINA +places these functions in special applications called IPCPs that form +layers known as Distributed IPC Facilities (DIFs) as part of a protocol +called EFCP. This allows a RINA DIF to provide an *IPC service* to the +layer on top. + +Ouroboros has those functions in *every* application. The benefit of +this approach is that it is possible to multi-home applications in +different networks, and still have a reliable connection. It is also +more resilient since every connection is - at least in theory - +recoverable unless the application itself crashes. So, Ouroboros IPCPs +form a layer that only provides *IPC resources*. The application does +its connection management, which is implemented in the Ouroboros +library. This architectural difference impact the components and +protocols that underly the network, which are all different from RINA. + +This change has a major impact on other components and protocols. We are +preparing a research paper on Ouroboros that will contain all these +details and more. + +[[back to top](#top)] + +### How can I use Ouroboros right now? + +At this point, Ouroboros is a useable prototype. You can use it to build +small deployments for personal use. There is no global Ouroboros network +yet. + +[[back to top](#top)] + +### What are the benefits of Ouroboros? + +We get this question a lot, and there is no single simple answer to +it. Its benefits are those of a RINA network and more. In general, if +two systems provide the same service, simpler systems tend to be the +more robust and reliable ones. This is why we designed Ouroboros the +way we did. It has a bunch of small improvements over current networks +which may not look like anything game-changing by themselves, but do +add up. The reaction we usually get when demonstrating Ouroboros, is +that it makes everything really really easy. + +Some benefits are improved anonymity as we do not send source addresses +in our data transfer packets. This also prevents all kinds of swerve and +amplification attacks. The packet structures are not fixed (as the +number of layers is not fixed), so there is no fast way to decode a +packet when captured "raw" on the wire. It also makes Deep Packet +Inspection harder to do. By attaching names to data transfer components +(so there can be multiple of these to form an "address"), we can +significantly reduce routing table sizes. + +The API is very simple and universal, so we can run applications as +close to the hardware as possible to reduce latency. Currently it +requires quite some work from the application programmer to create +programs that run directly over Ethernet or over UDP or over TCP. With +the Ouroboros API, the application doesn't need to be changed. Even if +somebody comes up with a different transmission technology, the +application will never need to be modified to run over it. + +Ouroboros also makes it easy to run different instances of the same +application on the same server and load-balance them. In IP networks +this requires at least some NAT trickery (since each application is tied +to an interface:port). For instance, it takes no effort at all to run +three different webserver implementations and load-balance flows between +them for resiliency and seamless attack mitigation. + +The architecture still needs to be evaluated at scale. Ultimately, the +only way to get the numbers, are to get a large (pre-)production +deployment with real users. + +[[back to top](#top)] + +### How do you manage the namespaces? + +Ouroboros uses names that are attached to programs and processes. The +layer API always uses hashes and the network maps hashes to addresses +for location. This function is similar to a DNS lookup. The current +implementation uses a DHT for that function in the ipcp-normal (the +ipcp-udp uses a DynDNS server, the eth-llc and eth-dix use a local +database with broadcast queries). + +But this leaves the question how we assign names. Currently this is +ad-hoc, but eventually we will need an organized way for a global +namespace so that application names are unique. If we want to avoid a +central authority like ICANN, a distributed ledger would be a viable +technology to implement this, similar to, for instance, namecoin. diff --git a/content/en/docs/Overview/_index.md b/content/en/docs/Overview/_index.md new file mode 100644 index 0000000..b7493af --- /dev/null +++ b/content/en/docs/Overview/_index.md @@ -0,0 +1,11 @@ +--- +title: "Overview" +linkTitle: "Overview" +weight: 10 +description: > + A bird's eye view of Ouroboros. +--- + +{{% pageinfo %}} +Under construction. +{{% /pageinfo %}} diff --git a/content/en/docs/Reference/_index.md b/content/en/docs/Reference/_index.md new file mode 100644 index 0000000..ca25348 --- /dev/null +++ b/content/en/docs/Reference/_index.md @@ -0,0 +1,11 @@ +--- +title: "Reference" +linkTitle: "Reference" +weight: 80 +description: > + Glossary and detailed information. +--- + +{{% pageinfo %}} +Under construction. Man pages are available. +{{% /pageinfo %}} diff --git a/content/en/docs/Reference/compopt.html b/content/en/docs/Reference/compopt.html new file mode 100644 index 0000000..4c4459c --- /dev/null +++ b/content/en/docs/Reference/compopt.html @@ -0,0 +1,435 @@ +--- +title: "Compilation options" +date: 2019-06-22 +draft: false +--- + +

+ Below is a list of the compile-time configuration options for + Ouroboros. These can be set using +

+
$ cmake -D<option>=<value> ..
+

or using

+
ccmake .
+

+ Options will only show up in ccmake if they are relevant for + your system configuration. The default value for each option + is underlined. Boolean values will print as ON/OFF in + ccmake instead of True/False. +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
OptionDescriptionValues
Compilation options
CMAKE_BUILD_TYPE + Set the build type for Ouroboros. Debug builds will add some + extra logging. The debug build can further enable the + address sanitizer (ASan) thread sanitizer (TSan) and leak + sanitizer (LSan) options. + + Release, Debug, DebugASan, DebugTSan, DebugLSan +
CMAKE_INSTALL_PREFIX + Set a path prefix in order to install Ouroboros in a + sandboxed environment. Default is a system-wide install. + + <path> +
DISABLE_SWIG + Disable SWIG support. + + True, False +
Library options
DISABLE_FUSE + Disable FUSE support, removing the virtual filesystem under + <FUSE_PREFIX>. + + True, False +
FUSE_PREFIX + Set the path where the fuse system should be + mounted. Default is /tmp/ouroboros. + + <path> +
DISABLE_LIBGCRYPT + Disable support for using the libgcrypt library for + cryptographically secure random number generation and + hashing. + + True, False +
DISABLE_OPENSSL + Disable support for the libssl library for cryptographic + random number generation and hashing. + + True, False +
DISABLE_ROBUST_MUTEXES + Disable + + robust mutex + + support. Without robust mutex support, Ouroboros may lock up + if processes are killed using SIGKILL. + + True, False +
PTHREAD_COND_CLOCK + Set the + + clock type + + to use for timeouts for pthread condition variables. Default + on Linux/FreeBSD: CLOCK_MONOTONIC. Default on OS X: + CLOCK_REALTIME. + + <clock_id_t> +
Shared memory system options
SHM_PREFIX + Set a prefix for the shared memory filenames. The mandatory + leading + + slash + + is added by the build system. Default is "ouroboros". + + <size_t> +
SHM_BUFFER_SIZE + Set the maximum total number of packet blocks Ouroboros + can buffer at any point in time. Must be a power of 2. + + <size_t> +
SHM_RDRB_BLOCK_SIZE + Set the size of a packet block. Default: page size of the + system. + + <size_t> +
SHM_RDRB_MULTI-BLOCK + Allow packets that are larger than a single packet block. + + True, False +
DU_BUFF_HEADSPACE + Set the amount of space to allow for the addition of + protocol headers when a new packet buffer is passed to the + system. Default: 128 bytes. + + <size_t> +
DU_BUFF_TAILSPACE + Set the amount of space to allow for the addition of + protocol tail information (CRCs) when a new packet buffer + is passed to the system. Default: 32 bytes. + + <size_t> +
IRMd options
SYS_MAX_FLOWS + The maximum number of flows this Ouroboros system can + allocate. Default: 10240. + + <size_t> +
SOCKET_TIMEOUT + The IRMd sends commands to IPCPs over UNIX sockets. This + sets the timeout for such commands in milliseconds. Some + commands can be set independently. Default: 1000. + + <time_t> +
BOOTSTRAP_TIMEOUT + Timeout for the IRMd to wait for a response to a bootstrap + command from an IPCP in milliseconds. Default: 5000. + + <time_t> +
ENROLL_TIMEOUT + Timeout for the IRMd to wait for a response to an enroll + command from an IPCP in milliseconds. Default: 60000. + + <time_t> +
CONNECT_TIMEOUT + Timeout for the IRMd to wait for a response to a connect + command from an IPCP in milliseconds. Default: 5000. + + <time_t> +
REG_TIMEOUT + Timeout for the IRMd to wait for a response to a register + command from an IPCP in milliseconds. Default: 3000. + + <time_t> +
QUERY_TIMEOUT + Timeout for the IRMd to wait for a response to a query + command from an IPCP in milliseconds. Default: 3000. + + <time_t> +
IRMD_MIN_THREADS + The minimum number of threads in the threadpool the IRMd + keeps waiting for commands. Default: 8. + + <size_t> +
IRMD_ADD_THREADS + The number of threads the IRMd will create if the current + available threadpool is lower than + IRMD_MIN_THREADS. Default: 8. + + <size_t> +
IPCP options
DISABLE_RAPTOR + Disable support for the raptor NetFPGA implementation. + + True, False +
DISABLE_BPF + Disable support for the Berkeley Packet Filter device + interface for the Ethernet LLC layer. If no suitable + interface is found, the LLC layer will not be built. + + True, False +
DISABLE_NETMAP + Disable netmap + support for the Ethernet LLC layer. If no suitable interface + is found, the LLC layer will not be built. + + True, False +
DISABLE_RAW_SOCKETS + Disable raw sockets support for the Ethernet LLC layer. If + no suitable interface is found,the LLC layer will not be + built. + + True, False +
DISABLE_DDNS + Disable Dynamic Domain Name System support for the UDP + layer. + + True, False +
IPCP_SCHED_THR_MUL + The number of scheduler threads an IPCP runs per QoS + cube. Default is 2. + + <size_t> +
IPCP_QOS_CUBE_BE_PRIORITY + Priority for the best effort qos cube scheduler + thread. This is mapped to a system value. Scheduler + threads have at least half the system max priority value. + + 0..99 +
IPCP_QOS_CUBE_VIDEO_PRIORITY + Priority for the video qos cube scheduler thread. This is + mapped to a system value. Scheduler threads have at least + half the system max priority value. + + 0..90..99 +
IPCP_QOS_CUBE_VOICE_PRIORITY + Priority for the voice qos cube scheduler thread. This is + mapped to a system value. Scheduler threads have at least + half the system max priority value. + + 0..99 +
IPCP_FLOW_STATS + Enable statistics for the data transfer component. + + True, False +
PFT_SIZE + The forwarding table in the normal IPCP uses a + hashtable. This sets the size of this hash table. Default: 4096. + + <size_t> +
IPCP_MIN_THREADS + The minimum number of threads in the threadpool the IPCP + keeps waiting for commands. Default: 4. + + <size_t> +
IPCP_ADD_THREADS + The number of threads the IPCP will create if the current + available threadpool is lower than + IPCP_MIN_THREADS. Default:4. + + <size_t> +
diff --git a/content/en/docs/Start/_index.md b/content/en/docs/Start/_index.md new file mode 100644 index 0000000..963b9f1 --- /dev/null +++ b/content/en/docs/Start/_index.md @@ -0,0 +1,7 @@ +--- +title: "Getting Started" +linkTitle: "Getting Started" +weight: 20 +description: > + How to get up and running with the Ouroboros prototype. +--- diff --git a/content/en/docs/Start/download.md b/content/en/docs/Start/download.md new file mode 100644 index 0000000..a7f7072 --- /dev/null +++ b/content/en/docs/Start/download.md @@ -0,0 +1,29 @@ +--- +title: "Download" +date: 2019-06-22 +weight: 10 +description: > + How to get ouroboros. +draft: false +--- + +### Get Ouroboros + +**Packages:** + +For ArchLinux users, the easiest way to try Ouroboros is via the [Arch +User Repository](https://aur.archlinux.org/packages/ouroboros-git/), +which will also install all dependencies. + +**Source:** + +You can clone the [repository](/cgit/ouroboros) over http or https or +git: + +```bash +$ git clone http://ouroboros.rocks/git/ouroboros +$ git clone https://ouroboros.rocks/git/ouroboros +$ git clone git://ouroboros.rocks/ouroboros +``` + +Or download a [snapshot](/cgit/ouroboros/) tarball and extract it. \ No newline at end of file diff --git a/content/en/docs/Start/install.md b/content/en/docs/Start/install.md new file mode 100644 index 0000000..736d1a2 --- /dev/null +++ b/content/en/docs/Start/install.md @@ -0,0 +1,57 @@ +--- +title: "Install from source" +author: "Dimitri Staessens" +date: 2019-07-23 +weight: 30 +draft: false +description: > + Installation instructions. +--- + +We recommend creating a build directory: + +```bash +$ mkdir build && cd build +``` + +Run cmake providing the path to where you cloned the Ouroboros +repository. Assuming you created the build directory inside the +repository directory, do: + +```bash +$ cmake .. +``` + +Build and install Ouroboros: + +```bash +$ sudo make install +``` + +### Advanced options + +Ouroboros can be configured by providing parameters to the cmake +command: + +```bash +$ cmake -D