00_java_reseau_L_rappels.qmd

---
title: "Réseaux TCP/IP et Programmation Java"
description: |
  Introduction aux concepts fondamentaux des réseaux TCP/IP et leur implémentation en Java.
  Couvre les protocoles réseau, l'adressage IP, les sockets et la programmation réseau moderne.
categories:
  - Java
  - Lecture
  - I211
  - Réseaux
  - TCP/IP
  - Sockets
provide_notes: true
provide_slides: true
jupyter: java
echo: true
output: true
---

## Fondamentaux des réseaux

:::: {layout="[ 0.45, 0.1, 0.45 ]"}
::: {#osi-model}
Modèle OSI

| Couche | Fonction | Protocoles |
|--------|----------|------------|
| Application | Accès aux services réseaux | HTTP, FTP, SMTP |
| Présentation | Format des données | Encodage, Compression |
| Session | Gestion des sessions | Auth, Autorisation |
| Transport | Fiabilité bout en bout | TCP, UDP |
| Réseau | Routage | IP, ICMP |
| Liaison | Accès au média | Ethernet, WiFi |
| Physique | Transmission bits | Signaux électriques |
:::

::: {#separator1}
:::

::: {#tcp-ip-model}
Modèle TCP/IP

| Couche | Fonction | Protocoles |
|--------|----------|------------|
| Application | Services utilisateur | HTTP, FTP, SMTP, DNS |
| Transport | Connexion bout en bout | TCP, UDP |
| Internet | Routage et adressage | IP, ICMP, ARP |
| Accès réseau | Interface physique | Ethernet, WiFi, PPP |
:::
::::

### Adresses IPv4

:::: {.columns}
::: {.column}
- Historique
- 32 bits divisés en 4 octets (x.x.x.x)
- Plages d'adresses :
  - Privées :
    - 10.0.0.0/8
    - 172.16.0.0/12
    - 192.168.0.0/16
  - Publiques : Tout le reste
  - Spéciales :
    - 127.0.0.1 (localhost)
    - 0.0.0.0 (any)
    - 255.255.255.255 (broadcast)
- Plus d'adresses disponibles au niveau mondial
:::
::: {.column}
```{java}
//| echo: false
//| output: false
import java.net.InetAddress;
```

```{java}
//| echo: true
//| output: true
// Exemple IPv4 en Java

// How to get Hostname and IP Address
String hostname = InetAddress.getLocalHost().getHostName();
String ipAddress = InetAddress.getLocalHost().getHostAddress();

System.out.println("Hostname: " + hostname);
System.out.println("IP Address: " + ipAddress);
```

```{java}
//| echo: true
//| output: true

// Travailler avec une adresse IPv4 spécifique
InetAddress ipv4 = InetAddress.getByName("192.168.1.1");

System.out.println("Adresse loopback ? " + ipv4.isLoopbackAddress());
System.out.println("Adresse privée ? " + ipv4.isSiteLocalAddress());
```
:::
::::

### Adresse Format IPv6

- Motivations: épuisement des adresses IPv4, sécurité, qualité de service, mobilité, auto-configuration, ...
- 128 bits divisés en 8 groupes de 16 bits (xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:xxxx)
- Notation raccourcie : les zéros peuvent être omis (::1 pour localhost)

```{java}
//| echo: true
//| output: true
// Exemple IPv6 en Java
InetAddress ipv6 = InetAddress.getByName("2001:0db8:85a3:0000:0000:8a2e:0370:7334");
System.out.println("Est IPv6 ? " + (ipv6 instanceof Inet6Address));
```

### Masques de sous-réseau

- Séparation des adresses réseau et hôte
- Utilité : segmentation du réseau
- Notation CIDR : /24 équivaut à 255.255.255.0
- Calcul des adresses réseau :

```{java}
// Exemple de manipulation de sous-réseau
NetworkInterface ni = NetworkInterface.getByName("eth0");
for (InterfaceAddress ia : ni.getInterfaceAddresses()) {
    System.out.printf("Adresse: %s/%d%n",
        ia.getAddress(),
        ia.getNetworkPrefixLength());
}
```

### Résolution DNS

- Traduction des noms de domaine en adresses IP
- DNS : Domain Name System

```{java}
// Résolution DNS complète
InetAddress[] addresses = InetAddress.getAllByName("www.lis-lab.fr");
for (InetAddress addr : addresses) {
    System.out.println("Nom canonique : " + addr.getCanonicalHostName());
    System.out.println("Adresse IP : " + addr.getHostAddress());
}
```

## Ports et services

- Communication entre applications
- Numéro de port (0-65535)
- Convention de numérotation
  - Ports réservés (0 à 1023) : services bien connus
    - 80/443 : HTTP/HTTPS, 22 : SSH
  - Ports enregistrés (1024-49151) : applications enregistrées
  - Ports dynamiques (49152-65535) : applications temporaires

```{java}
//| echo: false
//| output: false
import java.net.ServerSocket;
```

```{java}
//| echo: true
//| output: true
// Vérification de port disponible
try (ServerSocket socket = new ServerSocket(0)) { // 0 = port automatique
    System.out.println("Port libre trouvé : " + socket.getLocalPort());
    System.out.println("Adresse : " + socket.getInetAddress());
}
```

### Encapsulation des données

```java
//| echo: false
//| output: true
%%plantUML
@startuml
skinparam componentStyle rectangle
skinparam backgroundColor white
skinparam defaultFontSize 14

rectangle "Encapsulation" {
  [Données HTTP] as HTTP
  [Segment TCP\nPort src/dst] as TCP
  [Paquet IP\nIP src/dst] as IP
  [Trame Ethernet\nMAC src/dst] as ETH

  HTTP -down-> TCP : encapsule
  TCP -down-> IP : encapsule
  IP -down-> ETH : encapsule

  note right of HTTP : En-têtes + Data
  note right of TCP : Port 80, 443...
  note right of IP : IPv4/IPv6
  note right of ETH : 00:1A:2B:3C:4D:5E
}
@enduml
```

## Exemple de topologie réseau

```java
//| echo: false
//| output: true
%%plantUML
@startuml Network Topology

set namespaceSeparator none

!define RECTANGLE class

' Custom styles
skinparam class {
    BackgroundColor White
    BorderColor Black
    ArrowColor Black
}

package "Réseau Local 1 (192.168.1.0/24)" {
    RECTANGLE PC1 {
        MAC: 00:1A:2B:3C:4D:5E
        IP: 192.168.1.10
    }
    RECTANGLE PC2 {
        MAC: 00:1A:2B:3C:4D:5F
        IP: 192.168.1.11
    }
    RECTANGLE SW1 {
        Switch 1
    }
    RECTANGLE GW1 {
        MAC: 00:1A:2B:3C:4D:1A
        IP LAN: 192.168.1.1
        IP WAN: 203.0.113.1
    }
    RECTANGLE DHCP1 {
        IP: 192.168.1.2
        Plage: 192.168.1.100-200
    }
}

package "Réseau Local 2 (192.168.2.0/24)" {
    RECTANGLE PC3 {
        MAC: 00:2B:3C:4D:5E:6F
        IP: 192.168.2.10
    }
    RECTANGLE PC4 {
        MAC: 00:2B:3C:4D:5E:70
        IP: 192.168.2.11
    }
    RECTANGLE SW2 {
        Switch 2
    }
    RECTANGLE GW2 {
        MAC: 00:2B:3C:4D:5E:1B
        IP LAN: 192.168.2.1
        IP WAN: 203.0.113.2
    }
    RECTANGLE DHCP2 {
        IP: 192.168.2.2
        Plage: 192.168.2.100-200
    }
}

cloud Internet {
    RECTANGLE SRV {
        IP: 198.51.100.10
        DNS: server.example.com
    }
    RECTANGLE DNS {
        IP: 198.51.100.53
        DNS Racine
    }
}

' Connections
PC1 -- SW1
PC2 -- SW1
SW1 -- GW1
SW1 -- DHCP1
PC3 -- SW2
PC4 -- SW2
SW2 -- GW2
SW2 -- DHCP2
GW1 -- Internet
GW2 -- Internet
Internet -- SRV
Internet -- DNS

@enduml
```

### Exemple de Communication

```java
//| echo: false
//| output: true
%%plantUML
@startuml
skinparam backgroundColor white
skinparam sequenceMessageAlign center
skinparam defaultFontSize 14

participant "Client\n192.168.1.10" as C
participant "Router\n203.0.113.1" as R
participant "Server\n198.51.100.10" as S

note over C, S: Établissement connexion TCP (3-way handshake)

C -> R: SYN (seq=x)
R -> S: SYN (seq=x)
S -> R: SYN-ACK (seq=y, ack=x+1)
R -> C: SYN-ACK (seq=y, ack=x+1)
C -> R: ACK (ack=y+1)
R -> S: ACK (ack=y+1)

note over C, S: HTTP Request/Response

C -> R: GET /index.html HTTP/1.1
R -> S: GET /index.html HTTP/1.1
S -> R: HTTP/1.1 200 OK
R -> C: HTTP/1.1 200 OK

@enduml
```

## Sockets TCP

- Communication orientée connexion
- Fiabilité et ordre des messages
- Exemple : HTTP, FTP, SSH

### Création d'un serveur TCP

```{java}
//| echo: false
//| output: asis
%%shell
PROVIDER="github"
REPO="ebpro/notebook-java-network-sample-tcpclientserver"
BRANCH="develop"
gitpull.sh --provider github \
  --branch ${BRANCH} ${REPO} \
  --message "Les exemples suivants sont accessibles dans le dépôt :"
```