# Rapport projet réseau
## L'application
#### Description
L'application que nous avons imaginé est une application d'espionnage. Son fonctionnement est le suivant, on place un tracker bluetooth sur une cible, ensuite, on positionne une caméra à un endroit, par exemple devant une porte. Quand la cible va passer devant la porte où se trouve la caméra, celle-ci va prendre une photo et l'envoyer au serveur. L'espion pourra récupérer la photo prise en faisant une requête au serveur.
#### Appareils
L'application est composé des 4 éléments suivants :
- `Tracker` : un raspberry alimenté par une batterie portable dont le bluetooth est activé en permannence.
- `Caméra` : un raspberry équipé d'une caméra qui scan en permanance les appareils bluetooth à proximité. La caméra est connecté au server via un cable ethernet.
- `Serveur` : un raspberry faisaint office de hotspot wifi.
- `Client` : un raspberry connecté en wifi au serveur.
#### Fonctionement
Lorsque le `Tracker` passe à proximité de la `Caméra`, celle-ci le détecte via l'intensité du signal bluetooth entre le `Tracker` et la `Caméra`. Lorsque le `Tracker` est à moins de 5 mètres de la `Caméra`, celle-ci prends une photo. La `Caméra` envoie ensuite au `Serveur` la photo via la connexion ethernet. Le `Serveur` stocke les photos dans sa mémoire. Le `Client` peut alors se connecter en Wifi au `Serveur`. Une fois connecté, le `Client` peut faire une requête afin de récupérer toutes les nouvelles photos qui ont été prises depuis ça dernière requête.
## Architecture du réseau
Afin de créer notre application, la première étape est de configurer nos différents raspberry afin de créer un réseau.
### Le serveur
Le serveur a deux fonctionnalités :
- Hotspot WiFi
- Serveur DHCP
Ici, ce qui est compliqué, c'est qu'il faut faire communiquer l'interface WiFi et ethernet ensemble afin que le serveur puisse servir de pont entre le client et la caméra.
Il est donc nécessaire que le serveur attribue des adresses IP sur le même sous réseau aux appareils connectés via l'interface WiFi et à l'appareil connecté à l'interface ethernet.
*Setup :*
```
Server
┌──────┐ wifi
│ wlan0│ <~.~.~.~.> Client
ethernet |(br0) │ ╲
Camera <────────> |eth0 │ 192.168.100._
╲ └──────┘ (dhcp from
192.168.100.10 192.168.100.1 Server)
```
### Point d'accès WiFi
Pour créer un point d'accès WiFi, on va utiliser le daemon `hostapd`.
#### 1) Configuration de `systemd-networkd`
Pour des raisons pratiques, la première étape consite à utiliser `systemd-networkd` au lieu de `dhcp` qui est le daemon s'occupant du réseau par défault dans raspberryOS.
Désinstallation de `dhcp`:
```
pi@server:~ $ sudo -Es
root@server:~ # systemctl daemon-reload
root@server:~ # systemctl disable --now ifupdown dhcpcd dhcpcd5 isc-dhcp-client isc-dhcp-common rsyslog
root@server:~ # apt --autoremove purge ifupdown dhcpcd dhcpcd5 isc-dhcp-client isc-dhcp-common rsyslog
root@server:~ # rm -r /etc/network /etc/dhcp
```
Installation et activation de `systemd-resolved` et `systemd-networkd`:
```
root@server:~ # systemctl disable --now avahi-daemon libnss-mdns
root@server:~ # apt --autoremove purge avahi-daemon
root@server:~ # apt install libnss-resolve
root@server:~ # ln -sf /run/systemd/resolve/stub-resolv.conf /etc/resolv.conf
root@server:~ # apt-mark hold avahi-daemon dhcpcd dhcpcd5 ifupdown isc-dhcp-client isc-dhcp-common libnss-mdns openresolv server-net-mods rsyslog
root@server:~ # systemctl enable systemd-networkd.service systemd-resolved.service
root@server:~ # exit
```
#### 2) Installation et configuration de `hostapd`
Afin de créer un point d'accés WiFi grâce au rapsberry pi, on va utiliser `hostapd`.
```
root@server:~ # apt install hostapd
root@server:~ # nano /etc/hostapd/hostapd.conf
```
Fichier *hostapd.conf*:
```
driver=nl80211
ssid=PepitoNetwork
country_code=FR
hw_mode=g
channel=1
auth_algs=1
```
Création du service pour le point d'accès avec `hostapd`:
```
root@server:~ # systemctl edit --force --full accesspoint@.service
```
Configuration du service:
```
[Unit]
Description=accesspoint with hostapd (interface-specific version)
Wants=wpa_supplicant@%i.service
[Service]
ExecStartPre=/sbin/iw dev %i interface add ap@%i type __ap
ExecStart=/usr/sbin/hostapd -i ap@%i /etc/hostapd/hostapd.conf
ExecStopPost=-/sbin/iw dev ap@%i del
[Install]
WantedBy=sys-subsystem-net-devices-%i.device
```
Activation du service:
```
root@server:~ # systemctl enable accesspoint@wlan0.service
root@server:~ # rfkill unblock wlan
```
#### 3) Configuration de `wpa_supplicant` pour la connexion du client
```
root@server:~ # nano /etc/wpa_supplicant/wpa_supplicant-wlan0.conf
```
Fichier *wpa_supplicant-wlan0.conf*:
```
country=FR
ctrl_interface=DIR=/var/run/wpa_supplicant GROUP=netdev
update_config=1
network={
ssid="PepitoNetwork"
key_mgmt=NONE
}
```
```
root@server:~ # chmod 600 /etc/wpa_supplicant/wpa_supplicant-wlan0.conf
```
Configuration de `wpa_supplicant`:
```
root@server:~ # systemctl disable wpa_supplicant.service
root@server:~ # systemctl edit wpa_supplicant@wlan0.service
```
```
[Unit]
BindsTo=accesspoint@%i.service
After=accesspoint@%i.service
```
#### 4) Configuration de l'interface
```
root@server:~ # nano /etc/systemd/network/08-wifi.network
```
Fichier *08-wifi.network*:
```
[Match]
Name=wlan0
[Network]
LLMNR=no
MulticastDNS=yes
DHCP=yes
Address = 192.168.100.1
```
À ce stade, la configuration du point d'accès WiFi est terminée. Il est donc possible de se connecter au serveur via le réseau WiFi ouvert nommé *PepitoNetwork*.
Il faut maintenant créer un bridge afin que les appareils connectés au point d'accès wifi puissent communiquer avec celui connecté au port ethernet du serveur.
### Bridge
Afin de lier les interfaces `wlan0` et `eth0`, on va créer un bridge `br0`. Ensuite, il suffira d'indiquer au serveur dhcp d'écouter l'interface `br0`. Les appareils connectés en serveur via wifi et ethernet se verront donc attribuer des adresses IP sur le même sous réseau.
#### 1) Configuration de `hostapd` pour un bridge
Ajoute la ligne `bridge=br0` au fichier *hostapd.conf*:
```
root@server:~ # echo 'bridge=br0' >> /etc/hostapd/hostapd.conf
```
#### 2) Configuration de `wpa_supplicant` pour un bridge
```
root@server:~ # systemctl edit wpa_supplicant@wlan0.service
```
```
[Unit]
BindsTo=accesspoint@%i.service
After=accesspoint@%i.service
[Service]
ExecStartPost=/lib/systemd/systemd-networkd-wait-online --interface=%i --timeout=60 --quiet
ExecStartPost=/bin/ip link set ap@%i up
ExecStopPost=-/bin/ip link set ap@%i up
```
#### 3) Configuration des interfaces
```
root@server:~ # nano /etc/systemd/network/02-br0.netdev
```
Fichier *network/02-br0.netdev*:
```
[NetDev]
Name=br0
Kind=bridge
```
```
root@server:~ # nano /etc/systemd/04-eth0.network
```
Fichier *04-eth0.network*:
```
[Match]
Name=eth0
[Network]
Bridge=br0
```
```
root@server:~ # nano /etc/systemd/network/16-br0_up.network
```
Fichier *16-br0_up.network*:
```
[Match]
Name=br0
[Network]
IPMasquerade=yes
Address=192.168.100.1/24
DHCPServer=yes
```
Voilà le bridge `br0` créé et configuré. Il est maintenant possible d'établir une connexion entre un appareil connecté en WiFi et l'appareil connecté au port ethernet.
## Communication Serveur - Client
L'architecture du réseau étant établi, il faut maintenant coder l'application. Dans cette section, nous allons détailler le fonctionnement et le code de l'application qui permet au client de télécharger les vidéos enregistrées par la caméra qui sont stockées.sur le serveur le serveur.
#### 1) Initialisation de la connexion
La première chose à faire est de créer un `socket` côte client et un autre côté serveur. C'est via ces 2 sockets que seront envoyées les données entre le client et le serveur une fois la connexion établie.
`serveur.py`
```python
def setupServer():
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
print("Socket created.")
try:
s.bind((host, port))
except socket.error as msg:
print(msg)
print("Socket bind comlete.")
return s
```
`client.py`
```python
def setupClient():
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
print("Socket created.")
return s
```
Ensuite, on peut établir une connexion entre le client et le serveur en utilisant le socket que l'on vient juste de créer.
`server.py`
```python
def setupConnection(s):
s.listen(1) # Allows one connection at a time.
conn, address = s.accept()
print("Connected to: " + address[0] + ":" + str(address[1]))
return conn
```
`client.py`
```python
def setupConnection(s):
s.connect((host, port))
print("Client connect")
return s
```
#### 2) Modèle de communication
La connexion entre le serveur et le client est établie, il font donc maintenant réfléchir à la manière dont ils vont communiquer ensemble. Voici un schéma détaillant la manière dont le client et le serveur communiquent.
<img src="https://i.imgur.com/pKEVMJM.png" alt="drawing" width="400"/>
Quand le client veut télécharger les vidéos présentes sur le serveur, il envoie une requête `GET`, le serveur lui envoie la réponse `ACK_GET` pour indiquer qu'il a bien reçu la demande.
Le client envoie ensuite `READY` pour indiquer qu'il est prêt à recevoir des données. Le serveur lui envoie alors la requête`STORE filename size` pour indiquer au client qu'il va envoyer le fichier `filename` et que celui-ci fait une taille `size` en bit.
Après avoir reçu `ACK_STORE` du client, le serveur commence à envoyer les données. Une fois que le client à reçu l'entièreté du fichier, il lui envoie `READY` pour lui indiquer qu'il est prêt à recevoir un autre fichier.
S'il y a encore des fichiers à envoyer, on recommence à partir de `STORE filename size` sinon le serveur envoie `OVER` au client pour indiquer que tous les fichiers ont été téléchargés.
#### 3) Fonctionnement
##### Les requêtes
Pour envoyer une requête au serveur, il suffit de la tapper dans le terminal du client.
```python
def userCommand(s):
command = input("Enter your command: ")
s.send(str.encode(command))
reply(s)
```
Les requêtes sont reçu puit décodées par le serveur ou le client.
```python
def receiveMessage(conn):
# Receive the data
data = conn.recv(1024) # receive the data
data = data.decode('utf-8')
# Split the data such that you separate the command
# from the rest of the data.
dataMessage = data.split(' ')
command = dataMessage[0]
return command
```
Un fois décoder, la requête est traitée.
`server.py`
```python
command = receiveMessage(conn)
if command == 'GET':
conn.send(str.encode("ACK_GET"))
print("Send command received")
for filename in listdir(filespath):
reply = receiveMessage(conn)
if reply == 'READY':
sendVideo(conn, filename)
reply = receiveMessage(conn)
if reply == 'READY':
conn.send(str.encode("OVER"))
print("All files have been sent")
elif command == 'EXIT':
print("Our client has left us :(")
conn.send(str.encode("ACK_EXIT"))
conn = setupConnection(s)
elif command == 'KILL':
print("Our client has left us :(")
conn.send(str.encode("ACK_KILL"))
break
else:
conn.send(str.encode("UKNOWN"))
```
`client.py`
```python
def reply(s):
command = receiveMessage(s)
if command == 'ACK_GET':
print("Files are being downloaded...")
waitingForFile(s)
elif command == 'ACK_EXIT':
print("Bye")
s.close()
exit()
elif command == 'ACK_KILL':
print("Serveur is shutting down")
s.close()
exit()
elif command == 'UKNOWN':
print("Uknown command, try again")
```
Les requête que l'on peut envoyer au serveur sont les suivantes :
- `GET` pour télécharger toutes les vidéos stockées sur le serveur.
- `EXIT` pour déconnecter le client du serveur.
- `KILL` pour fermer le serveur.
`GET` son fonctionnement est détaillé dans la partie suivante.
`EXIT` déconnecte le client en fermant la connexion puis en ouvrant une autre, cela permet au client de se reconnecter plus tard sans avoir besoin de relancer le serveur.
`KILL` se contente de sortir de la boucle du programme ce qui a pour effet de fermer la connexion puis le socket.
Pour chaque requête envoyée par le client, un acknowledgement est envoyé par le serveur une fois la requête reçue.
Notre projet se concentre autour de la command 'GET', pour pouvoir envoyer une vidéo, il faut d'abord avoir une vidéo.
##### La prise de vidéos
Pour enregistrer une vidéo, la caméra utilise la bibliothèque `picamera` qui permet d'enregistrer des vidéos à partir de la caméra brancher sur le raspberry via la camera serial interface (CSI)
```python
def record_video():
print("Start recording for", video_duration, "seconds")
with picamera.PiCamera() as camera:
camera.resolution = (1280,720)
camera.start_recording("recording.h264")
sleep(video_duration)
camera.stop_recording()
print("Stop recording")
```
Maintenant, que nous avons la vidéo, nous voulons changer son format et la renommer. La fonction `convert_video` change le nom de la vidéo pour lui donner la date précise à laquelle elle a été prise, la convertie en format mp4
```python
def convert_video():
print("Converting the video")
filename = datetime.now().strftime("%Y.%m.%d-%H:%M:%S") + ".mp4"
completeFilePath = filespath + filename
call(["MP4Box -add recording.h264 "+completeFilePath], shell=True)
call(["rm recording.h264"], shell=True)
print("Video converted")
return filename
```
L'espion sait maintenant à quelle heure a été prise la vidéo, mais il ne possède pas encore la vidéo.
##### L'envoie de vidéos
Envoyer une vidéo est quelque chose d'assez simple, il suffit d'envoyer la vidéo par paquet de bit et puis c'est fini. Envoyer plusieurs vidéos à la suite en revanche ça devient plus compliqué.
Le problème, quand on envoie plusieurs fichiers, est de pouvoir les délémité. En effet, envoyer plusieurs fichiers à la suite revient à envoyer un flux de bit, comment faire pour délimiter ce flux en plusieurs parties qui représente des fichiers distinct.
À ce problème, il y a deux solutions :
- Faire en sorte que le client ouvre une nouvelle connexion pour chaque fichier.
- Faire en sorte que le serveur envoie la taille du fichier avant d'envoyer le fichier lui-même. Demandez au client d'écrire les données dans un fichier jusqu'à ce que le nombre de bit reçu soit égale à la taille du fichier. Ensuite recommencer sur un autre fichier.
La première solution fonctionne, mais elle est loin d'être optimisé, nous avons donc choisi la deuxième qui est meilleur en tout point.
```python
def sendVideo(c, filename):
print("Sending :", filename)
filepath = path.join(filespath, filename)
with open(filepath, 'rb') as video:
t = time()
size = len(video.read())
c.send(str.encode("STORE " + filename + " " + str(size)))
reply = receiveMessage(c)
if reply == 'ACK_STORE':
video.seek(0)
chunk = video.read(1024)
while chunk:
c.send(chunk)
chunk = video.read(1024)
print("-- %s seconds--" % ((time() - t)))
```
Ce que l'on fait en pratique, c'est envoyé via la requête `STORE` le nom et la taille en bit de la vidéo que l'on s'apprête à envoyer. Ensuite une fois avoir reçu l'acknowledgement pour `STORE` on commence à envoyer la vidéo.
Maintenant, que la vidéo est envoyée, il faut la réceptionner de l'autre côté.
##### La réception de vidéos
Recevoir une vidéo n'est pas très compliqué non plus, il suffit de récupérer les paquets de bits envoyés par la fonction sendVideo. Mais encore une fois recevoir plusieurs vidéos devient plus compliqué.
Les problématiques et les solutions sont les mêmes que pour l'envoi de vidéo. Pour éviter que la fonction ne sauvegarde toutes les vidéos dans un seul fichier, on délimite le flux de données qui arrive, chacune des parties représentent une vidéo.
```python
def storeFile(s, filename, size):
bufferSize = 0
print(filename, ":")
bar = tqdm.tqdm(total=size-1, unit='B', unit_scale=True)
with open(filePath+filename, "wb") as video:
while bufferSize < size:
buffer = s.recv(1024)
bufferSize += len(buffer)
bar.update(len(buffer))
video.write(buffer)
bar.close()
waitingForFile(s)
```
StoreFile reçoit une vidéo, le nom de la vidéo, et la taille du flux correspondant à la vidéo pour être sur de ne pas enrengistrer plus que la vidéo, et enrengistre la vidéo.
Pour gérer tout ces flux de vidéos, on fait appel à une autre fonction, waitingForFile
```python
def waitingForFile(s):
s.send(str.encode('READY'))
data = s.recv(1024)
data = data.decode('utf-8')
dataMessage = data.split(' ')
command = dataMessage[0]
if command == 'STORE':
s.send(str.encode('ACK_STORE'))
storeFile(s, dataMessage[1], int(dataMessage[2]))
elif command == 'OVER':
print("All files have been downloaded")
```
Celle-ci permet de gérer les flux pour que d'un côté le serveur ou la caméra n'envoient pas tout en même temps, et d'un autre côté, que le client ou le serveur ne reçoivent que ce qu'il doit reçevoir uniquement quand il sont prêt.
```python
while True:
print("Scanning...")
nearby_devices = bluetooth.discover_devices(duration=4)
for addr in nearby_devices:
if addr == ADDR:
```
Google Drive
Gist
Clipboard
Sign in with Wallet
