Typos in Part 1: Principles and Part 2: Protocols

book-2nd/mcq-ex/mcq-ipv6.rst

@@ -70,7 +70,7 @@ Multiple choice questions
 
    .. negative:: ``2001:db8:a:bb::cc:ddd::1``
 
-      ..comment:: This address is invalid. An IPv6 address cannot contain twice two consecutive semicolumns ``::``
+      .. comment:: This address is invalid. An IPv6 address cannot contain twice two consecutive semicolumns ``::``
 
    .. positive:: ``2001:db8:1234:1234:1234:5678::1``
 
@@ -739,7 +739,7 @@ The forwarding tables of these three routers, ignoring the routes to the local i
 
       .. code-block:: console 
 
-         00000001 00100000 10111000 00001101 010000000010011 1 10000001 11111100 
+         00000001 00100000 10111000 00001101 01000000 00100111 10000001 11111100 
          00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001
 
       .. comment:: This is the binary representation for IPv6 address ``0120:80DB:4113:81FC::1``
@@ -983,9 +983,9 @@ The routers have one address inside each network :
 
 3. Consider the network below that contains only routers. This network has been configured by a group of students and you must verify whether the configuration is correct. All the IPv6 addresses are part of the same ``/48`` prefix that we name ``p``. The following subnets are defined in this ``/48`` prefix.
 
- - ``p:12/64`` for the link between ``R1`` and ``R2``. On this subnet, ``R1`` uses address ``p:12::1`` while router ``R2`` uses address ``p:12::2``
- - ``p:13/64`` for the link between ``R1`` and ``R3``. On this subnet, ``R1`` uses address ``p:13::1`` while router ``R3`` uses address ``p:13::3``
- - ``p:24/64`` for the link between ``R2`` and ``R4``. On this subnet, ``R2`` uses address ``p:24::2`` while router ``R4`` uses address ``p:24::4``
+ - ``p:12::/64`` for the link between ``R1`` and ``R2``. On this subnet, ``R1`` uses address ``p:12::1`` while router ``R2`` uses address ``p:12::2``
+ - ``p:13::/64`` for the link between ``R1`` and ``R3``. On this subnet, ``R1`` uses address ``p:13::1`` while router ``R3`` uses address ``p:13::3``
+ - ``p:24::/64`` for the link between ``R2`` and ``R4``. On this subnet, ``R2`` uses address ``p:24::2`` while router ``R4`` uses address ``p:24::4``
  - ...
 
      .. tikz::

book-2nd/mcq-ex/mcq/static/rst-form.js

@@ -8,7 +8,7 @@ var translations = {
     },
     en: {
         score: 'You have a score of ',
-        inginious_success: 'Everything wen well',
+        inginious_success: 'Everything went well',
         request_fail: 'The request failed'
     }
 };

book-2nd/principles/reliability.rst

@@ -183,7 +183,7 @@ The datalink layer
 
 .. index:: frame
 
-Computer scientists are usually not interested in exchanging bits between two hosts. They prefer to write software that deals with larger blocks of data in order to transmit messages or complete files. Thanks to the physical layer service, it is possible to send a continuous stream of bits between two hosts. This stream of bits can include logical blocks of data, but we need to be able to extract each block of data from the bit stream despite the imperfections of the physical layer. In many networks, the basic unit of information exchanged between two directly connected hosts is often called a `frame`. A `frame` can be defined has a sequence of bits that has a particular syntax or structure. We will see examples of such frames later in this chapter. 
+Computer scientists are usually not interested in exchanging bits between two hosts. They prefer to write software that deals with larger blocks of data in order to transmit messages or complete files. Thanks to the physical layer service, it is possible to send a continuous stream of bits between two hosts. This stream of bits can include logical blocks of data, but we need to be able to extract each block of data from the bit stream despite the imperfections of the physical layer. In many networks, the basic unit of information exchanged between two directly connected hosts is often called a `frame`. A `frame` can be defined as a sequence of bits that has a particular syntax or structure. We will see examples of such frames later in this chapter. 
 
 To enable the transmission/reception of frames, the first problem to be solved is how to encode a frame as a sequence of bits, so that the receiver can easily recover the received frame despite the limitations of the physical layer.
 
@@ -782,7 +782,7 @@ Unfortunately, frame losses do not disappear because a reliable protocol uses a
 
 .. index:: cumulative acknowledgements
 
-The simplest sliding window protocol uses the `go-back-n` recovery. Intuitively, `go-back-n` operates as follows. A `go-back-n` receiver is as simple as possible. It only accepts the frames that arrive in-sequence. A `go-back-n` receiver discards any out-of-sequence frame that it receives. When `go-back-n` receives a data frame, it always returns an acknowledgement containing the sequence number of the last in-sequence frame that it has received. This acknowledgement is said to be `cumulative`. When a `go-back-n` receiver sends an acknowledgement for sequence number `x`, it implicitly acknowledges the reception of all frames whose sequence number is earlier than `x`. A key advantage of these cumulative acknowledgements is that it is easy to recover from the loss of an acknowledgement. Consider for example a `go-back-n` receiver that received frames `1`, `2` and `3`. It sent `OK1`, `OK2` and `OK3`. Unfortunately, `OK1` and `OK2` were lost. Thanks to the cumulative acknowledgements, when the receiver receives `OK3`, it knows that all three frames have been correctly received. 
+The simplest sliding window protocol uses the `go-back-n` recovery. Intuitively, `go-back-n` operates as follows. A `go-back-n` receiver is as simple as possible. It only accepts the frames that arrive in-sequence. A `go-back-n` receiver discards any out-of-sequence frame that it receives. When `go-back-n` receives a data frame, it always returns an acknowledgement containing the sequence number of the last in-sequence frame that it has received. This acknowledgement is said to be `cumulative`. When a `go-back-n` receiver sends an acknowledgement for sequence number `x`, it implicitly acknowledges the reception of all frames whose sequence number is earlier than `x`. A key advantage of these cumulative acknowledgements is that it is easy to recover from the loss of an acknowledgement. Consider for example a `go-back-n` receiver that received frames `1`, `2` and `3`. It sent `OK1`, `OK2` and `OK3`. Unfortunately, `OK1` and `OK2` were lost. Thanks to the cumulative acknowledgements, when the sender receives `OK3`, it knows that all three frames have been correctly received. 
 
 The figure below shows the FSM of a simple `go-back-n` receiver. This receiver uses two variables : `lastack` and `next`. `next` is the next expected sequence number and `lastack` the sequence number of the last data frame that has been acknowledged. The receiver only accepts the frame that are received in sequence. `maxseq` is the number of different sequence numbers (:math:`2^n`).
 

book-2nd/protocols/ipv6b.rst

@@ -58,7 +58,7 @@ Hosts ``A`` and ``B`` are attached to the same datalink layer network. They can
 
      A MAC address
 
- MAC addresses are allocated in blocks of :math:`2^{20}`. When a company registers for a block of MAC addresses, it receives an identifier. company identifier is then used to populated the `c` bits of the MAC addresses. The company can allocate all addresses in starting with this prefix and mangages the `m` bits as it wishes. 
+ MAC addresses are allocated in blocks of :math:`2^{20}`. When a company registers for a block of MAC addresses, it receives an identifier. The company identifier is then used to populate the `c` bits of the MAC addresses. The company can allocate all addresses in starting with this prefix and manages the `m` bits as it wishes. 
 
   .. figure:: pkt/macaddr-eui64.png
      :align: center