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

41 ../../exercises/sockets.rst:328
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Endianness: exchanging integers between different computers 59/10000 · 59
42 ../../exercises/sockets.rst:330
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Besides character strings, some applications also need to exchange 16 bits and 32 bits fields such as integers. A naive solution would have been to send the 16- or 32-bits field as it is encoded in the host's memory. Unfortunately, there are different methods to store 16- or 32-bits fields in memory. Some CPUs store the most significant byte of a 16-bits field in the first address of the field while others store the least significant byte at this location. When networked applications running on different CPUs exchange 16 bits fields, there are two possibilities to transfer them over the transport service : 613/10000 · 613
43 ../../exercises/sockets.rst:332
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — send the most significant byte followed by the least significant byte 69/10000 · 69
44 ../../exercises/sockets.rst:333
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — send the least significant byte followed by the most significant byte 69/10000 · 69
45 ../../exercises/sockets.rst:335
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — The first possibility was named `big-endian` in a note written by Cohen [Cohen1980]_ while the second was named `little-endian`. Vendors of CPUs that used `big-endian` in memory insisted on using `big-endian` encoding in networked applications while vendors of CPUs that used `little-endian` recommended the opposite. Several studies were written on the relative merits of each type of encoding, but the discussion became almost a religious issue [Cohen1980]_. Eventually, the Internet chose the `big-endian` encoding, i.e. multi-byte fields are always transmitted by sending the most significant byte first, :rfc:`791` refers to this encoding as the :term:`network-byte order`. Most libraries [#fhtonl]_ used to write networked applications contain functions to convert multi-byte fields from memory to the network byte order and the reverse. 844/10000 · 844
46 ../../exercises/sockets.rst:337
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Besides 16 and 32 bit words, some applications need to exchange data structures containing bit fields of various lengths. For example, a message may be composed of a 16 bits field followed by eight, one bit flags, a 24 bits field and two 8 bits bytes. Internet protocol specifications will define such a message by using a representation such as the one below. In this representation, each line corresponds to 32 bits and the vertical lines are used to delineate fields. The numbers above the lines indicate the bit positions in the 32-bits word, with the high order bit at position `0`. 587/10000 · 587
47 ../../exercises/sockets.rst:343
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Message format 14/10000 · 14
48 ../../exercises/sockets.rst:345
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — The message mentioned above will be transmitted starting from the upper 32-bits word in network byte order. The first field is encoded in 16 bits. It is followed by eight one bit flags (`A-H`), a 24 bits field whose high order byte is shown in the first line and the two low order bytes appear in the second line followed by two one byte fields. This ASCII representation is frequently used when defining binary protocols. We will use it for all the binary protocols that are discussed in this book. 499/10000 · 499
49 ../../exercises/sockets.rst:348
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Exercises 9/10000 · 9
50 ../../exercises/sockets.rst:350
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Here are some exercises that will help you to learn how to use sockets. 71/10000 · 71
51 ../../exercises/sockets.rst:367
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — During this course, you will be asked to implement a transport protocol running on Linux devices. To prepare yourself, try to implement the protocol described in the above tasks on your Linux personal machine. If you did these exercises correctly, most of your answers can be used as it (do not forget to include the required header files). In addition to the previously produced code, you will need 399/10000 · 399
52 ../../exercises/sockets.rst:369
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — to wrap the ``create_and_send_message`` in a ``client`` executable that can parse user arguments (the ``getopt(3)`` function might help) and appropriately call the wrapped function; 181/10000 · 181
53 ../../exercises/sockets.rst:370
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — to wrap the ``recv_and_handle_message`` server function in a ``server`` executable, similarly to what you have done with the ``client`` executable. 147/10000 · 147
54 ../../exercises/sockets.rst:372
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — As an example, here is what you could have to invoke your programs. 67/10000 · 67
55 ../../exercises/sockets.rst:385
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — If you want to observe the packets exchanged over the network, use a packet dissector such as `wireshark`_ or `tcpdump`_, listen the loopback interface (``lo``) and filter UDP packets using port 10000 (``udp.port==10000`` in `wireshark`_, ``udp port 10000`` with `tcpdump`_). 275/10000 · 275
56 ../../exercises/sockets.rst:389
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Footnotes 9/10000 · 9
57 ../../exercises/sockets.rst:390
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — For example, the ``htonl(3)`` (resp. ``ntohl(3)``) function the standard C library converts a 32-bits unsigned integer from the byte order used by the CPU to the network byte order (resp. from the network byte order to the CPU byte order). Similar functions exist in other programming languages. 295/10000 · 295
The translation has come to an end.