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

16 ../../exercises/sockets.rst:137
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Receiving data from a peer using a socket 41/10000 · 41
17 ../../exercises/sockets.rst:139
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Operating systems allow assigning an address to a socket using the ``bind`` system call. This is useful when you want to receive messages from another program to which you announced your socket address. Once the address is assigned to the socket, the program can receive data from others using system calls such as ``recv`` and ``read``. Note that we can use the ``read`` system call as the operating system provides a socket as a file descriptor. 447/10000 · 447
18 ../../exercises/sockets.rst:142
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — The following program binds its socket to a given socket address and then waits for receiving new bytes, using the already created socket ``sock``. 147/10000 · 147
19 ../../exercises/sockets.rst:171
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — 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. 260/10000 · 260
20 ../../exercises/sockets.rst:175
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — While the provided examples show the usage of a `char` array as the data buffer, implementers should **never** assume that it contains a string. C programs rely on the `char` type to refer to a 8-bit long value, and arbitrary binary values can be exchanged over the network (i.e., the ``\0`` value does not delimit the end of the data). 336/10000 · 336
21 ../../exercises/sockets.rst:177
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — 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. 333/10000 · 333
22 ../../exercises/sockets.rst:215
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — 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. 251/10000 · 251
23 ../../exercises/sockets.rst:218
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — ``connect``: connecting a socket to a remote address 52/10000 · 52
24 ../../exercises/sockets.rst:220
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Operating systems enable linking a socket to a remote address so that every information sent through the socket will only be sent to this remote address, and the socket will only receive messages sent by this remote address. This can be done using the ``connect`` system call shown below. 288/10000 · 288
25 ../../exercises/sockets.rst:226
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — 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. 377/10000 · 377
26 ../../exercises/sockets.rst:229
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — The following program connects a socket to a remote address, sends a message and waits for a reply. 99/10000 · 99
27 ../../exercises/sockets.rst:261
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Creating a new socket to communicate through a network 54/10000 · 54
28 ../../exercises/sockets.rst:263
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — 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. 689/10000 · 689
29 ../../exercises/sockets.rst:266
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — A program can use the ``socket`` system call to create a new socket. 68/10000 · 68
30 ../../exercises/sockets.rst:272
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — 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. 769/10000 · 769
31 ../../exercises/sockets.rst:282
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Sending a message to a remote peer using its IPv6 address 57/10000 · 57
32 ../../exercises/sockets.rst:286
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Now that we created an IPv6 socket, we can use it to reach another program if we know its IPv6 address. IPv6 addresses have a human-readable format that can be represented as a string of characters. The details of IPv6 addresses are out of scope of this section but here are some examples : 290/10000 · 290
33 ../../exercises/sockets.rst:285
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — The ``::1`` IPv6 address identifies the computer on which the current program is running. 89/10000 · 89
34 ../../exercises/sockets.rst:286
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — The ``2001:6a8:308f:9:0:82ff:fe68:e520`` IPv6 address identifies the computer serving the ``https://beta.computer-networking.info`` website. 140/10000 · 140
35 ../../exercises/sockets.rst:290
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — An IPv6 address often identifies a computer and not a program running on the computer. In order to identify a specific program running on a specific computer, we use a *port number* in addition to the IPv6 address. A program using an IPv6 socket is this identified using : 272/10000 · 272