2. cnp3-ebook
3. exercises/sockets
4. French
5. Zen

8 ../../exercises/sockets.rst:105
	English `DATA.indication(message)` is issued by the transport service to deliver a message to the application. In the socket API, this corresponds to the return of the ``recv`` method that is called by the application.
	French ↹ ↵ NBS … « » ‹ › ﹙-﹚ ‐ – — `DATA.indication(message)` est émis par le service de transport pour délivrer un message à l'application. Dans l'API socket, cela correspond au retour de la méthode ``recv`` qui est appelée par l'application. 208/2100 · 210 Needs editing
9 ../../exercises/sockets.rst:107
	English The `DATA` primitives are exchanged through a service access point. In the socket API, the equivalent to the service access point is the `socket`. A `socket` is a data structure which is maintained by the networking stack and is used by the application every time it needs to send or receive data through the networking stack.
	French ↹ ↵ NBS … « » ‹ › ﹙-﹚ ‐ – — Les primitives `DATA` sont échangées via un point d'accès au service. Dans l'API socket, l'équivalent du point d'accès au service est le `socket`. Une `socket` est une structure de données qui est maintenue par la pile réseau et qui est utilisée par l'application à chaque fois qu'elle doit envoyer ou recevoir des données à travers la pile réseau. 348/3260 · 326 Needs editing
10 ../../exercises/sockets.rst:110
	English Sending data to a peer using a socket
	French ↹ ↵ NBS … « » ‹ › ﹙-﹚ ‐ – — Envoi de données à un pair à l'aide d'une socket 48/370 · 37 Needs editing
12 ../../exercises/sockets.rst:114
	English The ``sendto`` system call allows to send data to a peer identified by its socket address through a given socket.
	French ↹ ↵ NBS … « » ‹ › ﹙-﹚ ‐ – — L'appel système ``sendto`` permet d'envoyer des données à un pair identifié par son adresse de socket via un socket donné. 122/1130 · 113 Needs editing
13 ../../exercises/sockets.rst:120
	English The first argument is the file descriptor of the socket that we use to perform the communication. ``buf`` is a buffer of length ``len`` containing the bytes to send to the peer. The usage of ``flags`` argument is out of the scope of this section and can be set to 0. ``dest_addr`` is the socket address of the destination to which we want to send the bytes, its length is passed using the ``addrlen`` argument.
	French ↹ ↵ NBS … « » ‹ › ﹙-﹚ ‐ – — Le premier argument est le descripteur de fichier de la socket que nous utilisons pour effectuer la communication. ``buf`` est un tampon de longueur ``len`` contenant les octets à envoyer à l'homologue. L'utilisation de l'argument ``flags`` est hors de portée de cette section et peut être mis à 0. ``dest_addr`` est l'adresse de la socket de destination à laquelle nous voulons envoyer les octets, sa longueur est passée en utilisant l'argument ``addrlen`'. 458/4100 · 410 Needs editing
14 ../../exercises/sockets.rst:122
	English In the following example, a C program is sending the bytes ``'h'``, ``'e'``, ``'l'``, ``'l'`` and ``'o'`` to a remote process located at address ``peer_addr``, using the already created socket ``sock``.
	French ↹ ↵ NBS … « » ‹ › ﹙-﹚ ‐ – — Dans l'exemple suivant, un programme C envoie les octets ``'h'``, ``'e'``, ``'l'``, ``'l'`` et ``'o'`` à un processus distant situé à l'adresse ``peer_addr``, en utilisant la socket ``sock`` déjà créée. 202/2020 · 202 Needs editing
15 ../../exercises/sockets.rst:135
	English As the ``sendto`` function is generic, this function will work correctly independently from the fact that the peer's address is defined as a path on the computer filesystem or a network address.
	French ↹ ↵ NBS … « » ‹ › ﹙-﹚ ‐ – — Comme la fonction ``sendto`` est générique, cette fonction fonctionnera correctement indépendamment du fait que l'adresse de l'homologue soit définie comme un chemin sur le système de fichiers de l'ordinateur ou une adresse réseau. 231/1940 · 194 Needs editing
16 ../../exercises/sockets.rst:139
	English Receiving data from a peer using a socket
	French ↹ ↵ NBS … « » ‹ › ﹙-﹚ ‐ – — Recevoir des données d'un pair en utilisant un socket 53/410 · 41 Needs editing
18 ../../exercises/sockets.rst:144
	English The following program binds its socket to a given socket address and then waits for receiving new bytes, using the already created socket ``sock``.
	French ↹ ↵ NBS … « » ‹ › ﹙-﹚ ‐ – — Le programme suivant lie son socket à une adresse de socket donnée et attend ensuite de recevoir de nouveaux octets, en utilisant le socket ``sock`` déjà créé. 159/1470 · 147 Needs editing
19 ../../exercises/sockets.rst:173
	English Depending on the socket address family, the operating system might implicitly assign an address to an unbound socket upon a call to ``write``, ``send`` or ``sendto``. While this is a useful behavior, describing it precisely is out of the scope of this section.
	French ↹ ↵ NBS … « » ‹ › ﹙-﹚ ‐ – — En fonction de la famille d'adresse de la socket, le système d'exploitation peut implicitement assigner une adresse à un socket non liée lors d'un appel à ``write``, ``send`` ou ``sendto``. Bien que ce comportement soit utile, sa description précise n'entre pas dans le cadre de cette section. 293/2600 · 260 Needs editing
20 ../../exercises/sockets.rst:175
	English Using this code, the program will read and print an arbitrary message received from an arbitrary peer who knows the program's socket address. If we want to know the address of the peer that sent us the message, we can use the ``recvfrom`` system call. This is what a modified version of ``bind_and_receive_from_peer`` is doing below.
	French ↹ ↵ NBS … « » ‹ › ﹙-﹚ ‐ – — En utilisant ce code, le programme lira et imprimera un message arbitraire reçu d'un homologue arbitraire qui connaît l'adresse de socket du programme. Si nous voulons connaître l'adresse de l'homologue qui nous a envoyé le message, nous pouvons utiliser l'appel système ``recvfrom``. C'est ce que fait une version modifiée de ``bind_and_receive_from_peer`` ci-dessous. 369/3330 · 333 Needs editing
21 ../../exercises/sockets.rst:213
	English This function is now using the ``recvfrom`` system call that will also provide the address of the peer who sent the message. As addresses are generic and can have different sizes, ``recvfrom`` also tells us the size of the address that it has written.
	French ↹ ↵ NBS … « » ‹ › ﹙-﹚ ‐ – — Cette fonction utilise maintenant l'appel système ``recvfrom`` qui fournira également l'adresse du pair qui a envoyé le message. Comme les adresses sont génériques et peuvent avoir différentes tailles, ``recvfrom`` nous indique également la taille de l'adresse qu'il a écrite. 276/2510 · 251 Needs editing
22 ../../exercises/sockets.rst:216
	English ``connect``: connecting a socket to a remote address
	French ↹ ↵ NBS … « » ‹ › ﹙-﹚ ‐ – — ``connect``:connecter un socket à une adresse distante 54/520 · 52 Needs editing
24 ../../exercises/sockets.rst:224
	English This system call will assign the socket ``sockfd`` to the ``addr`` remote socket address. The process can then use the ``send`` and ``write`` system calls that do not to specify the destination socket address. Furthermore, the calls to ``recv`` and ``read`` will only deliver messages sent by this remote address. This is useful when we only care about the other peer messages.
	French ↹ ↵ NBS … « » ‹ › ﹙-﹚ ‐ – — Cet appel système va assigner la socket ``sockfd`` à l'adresse de socket distante ``addr``. Le processus peut alors utiliser les appels système ``send`` et ``write`` qui ne spécifient pas l'adresse de la socket de destination. De plus, les appels à ``recv`` et ``read`` ne délivreront que les messages envoyés par cette adresse distante. Ceci est utile lorsque l'on ne s'intéresse qu'aux messages des autres pairs. 414/3770 · 377 Needs editing
25 ../../exercises/sockets.rst:227
	English The following program connects a socket to a remote address, sends a message and waits for a reply.
	French ↹ ↵ NBS … « » ‹ › ﹙-﹚ ‐ – — Le programme suivant connecte un socket à une adresse distante, envoie un message et attend une réponse. 104/990 · 99 Needs editing
26 ../../exercises/sockets.rst:259
	English Creating a new socket to communicate through a network
	French ↹ ↵ NBS … « » ‹ › ﹙-﹚ ‐ – — Création d'une nouvelle socket pour communiquer via un réseau 61/540 · 54 Needs editing
27 ../../exercises/sockets.rst:261
	English Until now, we learned how to use sockets that were already created. When writing a whole program, you will have to create you own sockets and choose the concrete technology that it will use to communicate with others. In this section, we will create new sockets and allow a program to communicate with processes located on another computer using a network. The most recent standardized technology used to communicate through a network is the :term:`IPv6` network protocol. In the IPv6 protocol, hosts are identified using *IPv6 addresses*. Modern operating systems allow IPv6 network communications between programs to be done using the socket API, just as we did in the previous sections.
	French ↹ ↵ NBS … « » ‹ › ﹙-﹚ ‐ – — Jusqu'à présent, nous avons appris à utiliser des sockets déjà créés. Lorsque vous écrirez un programme complet, vous devrez créer vos propres sockets et choisir la technologie concrète qu'il utilisera pour communiquer avec les autres. Dans cette section, nous allons créer de nouveaux sockets et permettre à un programme de communiquer avec des processus situés sur un autre ordinateur en utilisant un réseau. La technologie standardisée la plus récente utilisée pour communiquer via un réseau est le protocole réseau :term:`IPv6`. Dans le protocole IPv6, les hôtes sont identifiés à l'aide d'adresses *IPv6*. Les systèmes d'exploitation modernes permettent d'établir des communications réseau IPv6 entre programmes à l'aide de l'API socket, comme nous l'avons fait dans les sections précédentes. 797/6890 · 689 Needs editing
28 ../../exercises/sockets.rst:264
	English A program can use the ``socket`` system call to create a new socket.
	French ↹ ↵ NBS … « » ‹ › ﹙-﹚ ‐ – — Un programme peut utiliser l'appel système ``socket`` pour créer un nouveau socket. 83/680 · 68 Needs editing
29 ../../exercises/sockets.rst:270
	English The ``domain`` parameter specifies the address family that we will use to concretely perform the communication. For an IPv6 socket, the ``domain`` parameter will be set to the value ``AF_INET6``, telling the operating system that we plan to communicate using IPv6 addresses. The ``type`` parameter specifies the communication guarantees that we need. For now, we will use the type ``SOCK_DGRAM`` which allows us to send *unreliable messages*. This means that each data that we send at each call of ``sendto`` will either be completely received or not received at all. The last parameter will be set to ``0``. The following line creates a socket, telling the operating system that we want to communicate using IPv6 addresses and that we want to send unreliable messages.
	French ↹ ↵ NBS … « » ‹ › ﹙-﹚ ‐ – — Le paramètre ``domain`` spécifie la famille d'adresses que nous allons utiliser pour réaliser concrètement la communication. Pour une socket IPv6, le paramètre ``domain`` prendra la valeur ``AF_INET6``, indiquant au système d'exploitation que nous prévoyons de communiquer en utilisant des adresses IPv6. Le paramètre ``type`` spécifie les garanties de communication dont nous avons besoin. Pour l'instant, nous allons utiliser le type ``SOCK_DGRAM`` qui nous permet d'envoyer des *messages non fiables*. Cela signifie que chaque donnée que nous envoyons à chaque appel de ``sendto`` sera soit complètement reçue, soit pas du tout reçue. Le dernier paramètre sera fixé à "0". La ligne suivante crée un socket, indiquant au système d'exploitation que nous voulons communiquer en utilisant des adresses IPv6 et que nous voulons envoyer des messages non fiables. 859/7690 · 769 Needs editing
30 ../../exercises/sockets.rst:280
	English Sending a message to a remote peer using its IPv6 address
	French ↹ ↵ NBS … « » ‹ › ﹙-﹚ ‐ – — Envoi d'un message à un homologue distant en utilisant son adresse IPv6 71/570 · 57 Needs editing