180 lines
5 KiB
Markdown
180 lines
5 KiB
Markdown
# Donar
|
|
|
|
## Quickstart
|
|
|
|
### Installation
|
|
|
|
The following steps are provided for [Fedora 29 Workstation](https://getfedora.org/fr/workstation/download/).
|
|
We assume you have two containers or two virtual machines or two physical machines.
|
|
|
|
To setup each machine, you should do:
|
|
|
|
```
|
|
sudo dnf install --refresh -y cmake gcc gcc-c++ ninja-build glib2-devel glib2 tor valgrind git net-tools nmap-ncat
|
|
git clone https://gitlab.inria.fr/qdufour/donar.git
|
|
cd donar
|
|
mkdir out && cd out && cmake -GNinja .. && ninja && sudo ninja install
|
|
```
|
|
|
|
### Commands
|
|
|
|
Now your machine is ready and you will be able to use the following commads:
|
|
|
|
* `donar` is our main binary. It can be run as a client or a server.
|
|
* `udpecho` is a simple udp server that send back the data sent to him.
|
|
* `torecho` is a simple tcp server that send back the data sent to him + configure the tor daemon to generate a hidden service URL and be accessible on the Tor network.
|
|
* `measlat` can be used in conjunction with `udpecho` or `torecho` to measure a Rount Time Trip (RTT)
|
|
|
|
Try to run the previous commands in your terminal without any option, you will see their help.
|
|
|
|
At any moment, you can use the following commands that are not part of the project to understand what you are doing:
|
|
|
|
```bash
|
|
netstat -ulpn # Show programs that listen on an UDP port
|
|
netstat -tlpn # Show prograns that listen on a TCP port
|
|
nc 127.0.0.1 8000 # Connect via TCP on server 127.0.0.1 listening on port 8000
|
|
nc -u 127.0.0.1 8000 # Connect via UDP on server 127.0.0.1 listening on port 8000
|
|
```
|
|
|
|
### Introduction to the debug tools `udpecho` and `measlat`
|
|
|
|
Now let's start simple, we will launch our udp echo server and access it locally:
|
|
|
|
```bash
|
|
udpecho -p 8000 &
|
|
nc 127.0.0.1 8000
|
|
```
|
|
|
|
If you write some data on your terminal and press enter, you will see that your data has been repeated. Well done!
|
|
|
|
Now, instead of using `nc`, we will use `measlat` to use this echo server to measure latencies (make sure that `udpecho` is still running):
|
|
|
|
```bash
|
|
measlat -h 127.0.0.1 -p 8000 -t udp
|
|
```
|
|
|
|
`measlat` will send one packet to our udpecho server and wait to receive it back, measure the time it took, display it and exit.
|
|
|
|
You can use `measlat` more extensively by defining the number of measures to do, an interval and the size of the packet:
|
|
|
|
```bash
|
|
measlat -h 127.0.0.1 -p 8000 -t udp -c 10 -i 100 -s 150
|
|
```
|
|
|
|
### Introduction to `donar`
|
|
|
|
Now, let's introduce our main project.
|
|
First, kill all the remaining processes `killall udpecho measlat nc`.
|
|
|
|
*On both machine*
|
|
Move to the donar repository root where you will see the `torrc_simple` file.
|
|
We will need to start by launching tor in a terminal:
|
|
|
|
```bash
|
|
tor -f ./torrc_simple
|
|
```
|
|
|
|
*On machine A*
|
|
Launch Donar server in a second terminal:
|
|
|
|
```bash
|
|
donar -s -a naive -e 3000 -r 3001
|
|
```
|
|
|
|
In a third terminal, launch your echo service:
|
|
|
|
```bash
|
|
udpecho -p 3000
|
|
```
|
|
|
|
Display the content of the file `onion_services.pub` that has been created in your working directory.
|
|
|
|
*On machine B*
|
|
Copy the content of the file `onion_services.pub` that is on *machine A* to *machine B* in a file named `machine_a.pub`.
|
|
Now, run Donar client in a second terminal:
|
|
|
|
```bash
|
|
donar -c -a naive -o machine_a.pub -r 3000 -e 3001
|
|
```
|
|
|
|
In a third terminal, launch your echo service:
|
|
|
|
```bash
|
|
udpecho -p 3001
|
|
```
|
|
|
|
*On machine A*
|
|
You can access to the echo service from *machine B* by running:
|
|
|
|
```bash
|
|
nc 127.13.3.7 3001
|
|
# or
|
|
measlat -h 127.13.3.7 -p 3001 -t udp
|
|
```
|
|
|
|
*On machine B*
|
|
You can access to the echo service from *machine A* by running:
|
|
|
|
```bash
|
|
nc 127.13.3.7 3000
|
|
# or
|
|
measlat -h 127.13.3.7 -p 3000 -t udp
|
|
```
|
|
|
|
If it works, that's all! You are now mastering Donar!
|
|
|
|
## Linphone configuration
|
|
|
|
Choose a SIP UDP, Audio RTP/UDP and Video RTP/UDP that is different between your clients.
|
|
Go to manage account.
|
|
Add a new SIP proxy.
|
|
|
|
```
|
|
Username: <username>@127.13.3.7:<SIP_PORT>
|
|
Proxy: 127.13.3.7:<SIP_PORT>
|
|
Leave the rest empty.
|
|
Uncheck all the checkboxes.
|
|
```
|
|
|
|
## Docker build
|
|
|
|
```
|
|
sudo docker build -t registry.gitlab.inria.fr/qdufour/donar .
|
|
sudo docker push registry.gitlab.inria.fr/qdufour/donar
|
|
```
|
|
|
|
```
|
|
mkdir -p ./{xp1-shared,xp1-res}
|
|
sudo chown -R 1000 ./{xp1-shared,xp1-res}
|
|
|
|
sudo docker run -t -i \
|
|
--privileged \
|
|
-v `pwd`/xp1-shared:/home/donar/shared \
|
|
registry.gitlab.inria.fr/qdufour/donar \
|
|
xp1-server
|
|
|
|
sudo docker run -t -i \
|
|
--privileged \
|
|
-v `pwd`/xp1-res:/home/donar/res \
|
|
-v `pwd`/xp1-shared:/home/donar/shared \
|
|
registry.gitlab.inria.fr/qdufour/donar \
|
|
xp1-client 1000 100 100
|
|
|
|
```
|
|
|
|
## Run an XP instance
|
|
|
|
```
|
|
sudo ./scripts/xp1 1000 100 100
|
|
```
|
|
|
|
## Run instances in parallel
|
|
|
|
We generate the name of the algorithm to run on the right side of the parallel command.
|
|
The idea is to generate a sequence like the following: `orig naive rr rrh orig naive rr rrh orig...`.
|
|
|
|
```
|
|
parallel -j 12 bash -c './xp-instance-runner $1 6000 100 100' -- `xp0=orig xp1=naive xp2=rr xp3=rrh; for i in {0..99}; do q='xp'$((i % 4)); echo ${!q}; done`
|
|
parallel.moreutils -j 16 bash -c './xp-instance-runner $0 6000 100 100' -- `xp0=orig xp1=naive xp2=rr xp3=rrh; for i in {0..219}; do q='xp'$((i % 4)); echo ${!q}; done`
|
|
```
|
|
|