Merge pull request #604 from anuvratsingh/spelling_correction

Corrects minor spelling errors in documentation

README.md

@@ -214,7 +214,7 @@ _smoltcp_, being a freestanding networking stack, needs to be able to transmit a
 raw frames. For testing purposes, we will use a regular OS, and run _smoltcp_ in
 a userspace process. Only Linux is supported (right now).
 
-On \*nix OSes, transmiting and receiving raw frames normally requires superuser privileges, but
+On \*nix OSes, transmitting and receiving raw frames normally requires superuser privileges, but
 on Linux it is possible to create a _persistent tap interface_ that can be manipulated by
 a specific user:
 

fuzz/fuzz_targets/ieee802154_header.rs

@@ -5,7 +5,7 @@ use smoltcp::wire::{Ieee802154Frame, Ieee802154Repr};
 fuzz_target!(|data: &[u8]| {
     if let Ok(ref frame) = Ieee802154Frame::new_checked(data) {
         if let Ok(repr) = Ieee802154Repr::parse(frame) {
-            // The buffer len returns only the lenght required for emitting the header
+            // The buffer len returns only the length required for emitting the header
             // and does not take into account the length of the payload.
             let mut buffer = vec![0; repr.buffer_len()];
 

src/iface/fragmentation.rs

@@ -46,7 +46,7 @@ impl<'a> PacketAssembler<'a> {
     ///
     /// # Errors
     ///
-    /// - Returns [`Error::PacketAssemblerBufferTooSmall`] when the buffer is too smal for holding all the
+    /// - Returns [`Error::PacketAssemblerBufferTooSmall`] when the buffer is too small for holding all the
     /// fragments of a packet.
     pub(crate) fn start(&mut self, total_size: usize, start_time: Instant) -> Result<()> {
         match &mut self.buffer {
@@ -325,7 +325,7 @@ impl<'a, K: Eq + Ord + Clone + Copy> PacketAssemblerSet<'a, K> {
         }
     }
 
-    /// Remove all [`PacketAssembler`]s that are marked as discared.
+    /// Remove all [`PacketAssembler`]s that are marked as discarded.
     pub fn remove_discarded(&mut self) {
         loop {
             let mut key = None;

src/iface/interface.rs

@@ -33,7 +33,7 @@ pub struct Interface<'a, DeviceT: for<'d> Device<'d>> {
 
 /// The device independent part of an Ethernet network interface.
 ///
-/// Separating the device from the data required for prorcessing and dispatching makes
+/// Separating the device from the data required for processing and dispatching makes
 /// it possible to borrow them independently. For example, the tx and rx tokens borrow
 /// the `device` mutably until they're used, which makes it impossible to call other
 /// methods on the `Interface` in this time (since its `device` field is borrowed
@@ -472,7 +472,7 @@ fn icmp_reply_payload_len(len: usize, mtu: usize, header_len: usize) -> usize {
     // the minimum MTU required by IPv4. See RFC 1812 § 4.3.2.3 for
     // more details.
     //
-    // Since the entire network layer packet must fit within the minumum
+    // Since the entire network layer packet must fit within the minimum
     // MTU supported, the payload must not exceed the following:
     //
     // <min mtu> - IP Header Size * 2 - ICMPv4 DstUnreachable hdr size
@@ -950,7 +950,7 @@ where
                     // `NeighborCache` already takes care of rate limiting the neighbor discovery
                     // requests from the socket. However, without an additional rate limiting
                     // mechanism, we would spin on every socket that has yet to discover its
-                    // neighboor.
+                    // neighbor.
                     item.meta.neighbor_missing(
                         inner.now,
                         neighbor_addr.expect("non-IP response packet"),

src/lib.rs

@@ -47,7 +47,7 @@
 //! Unlike the higher layers, the wire layer APIs will not be used by a typical application.
 //! They however are the bedrock of _smoltcp_, and everything else is built on top of them.
 //!
-//! The wire layer APIs are designed by the principle "make illegal states irrepresentable".
+//! The wire layer APIs are designed by the principle "make illegal states ir-representable".
 //! If a wire layer object can be constructed, then it can also be parsed from or emitted to
 //! a lower level.
 //!

src/socket/icmp.rs

@@ -54,7 +54,7 @@ pub type IcmpSocketBuffer<'a> = PacketBuffer<'a, IpAddress>;
 /// A ICMP socket
 ///
 /// An ICMP socket is bound to a specific [IcmpEndpoint] which may
-/// be a sepecific UDP port to listen for ICMP error messages related
+/// be a specific UDP port to listen for ICMP error messages related
 /// to the port or a specific ICMP identifier value. See [bind] for
 /// more details.
 ///

src/socket/mod.rs

@@ -46,7 +46,7 @@ pub(crate) use self::waker::WakerRegistration;
 #[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone, Copy)]
 #[cfg_attr(feature = "defmt", derive(defmt::Format))]
 pub(crate) enum PollAt {
-    /// The socket needs to be polled immidiately.
+    /// The socket needs to be polled immediately.
     Now,
     /// The socket needs to be polled at given [Instant][struct.Instant].
     Time(Instant),

src/socket/raw.rs

@@ -151,7 +151,7 @@ impl<'a> RawSocket<'a> {
     /// If the buffer is filled in a way that does not match the socket's
     /// IP version or protocol, the packet will be silently dropped.
     ///
-    /// **Note:** The IP header is parsed and reserialized, and may not match
+    /// **Note:** The IP header is parsed and re-serialized, and may not match
     /// the header actually transmitted bit for bit.
     pub fn send(&mut self, size: usize) -> Result<&mut [u8]> {
         let packet_buf = self.tx_buffer.enqueue(size, ())?;
@@ -177,7 +177,7 @@ impl<'a> RawSocket<'a> {
     ///
     /// This function returns `Err(Error::Exhausted)` if the receive buffer is empty.
     ///
-    /// **Note:** The IP header is parsed and reserialized, and may not match
+    /// **Note:** The IP header is parsed and re-serialized, and may not match
     /// the header actually received bit for bit.
     pub fn recv(&mut self) -> Result<&[u8]> {
         let ((), packet_buf) = self.rx_buffer.dequeue()?;

src/socket/tcp.rs

@@ -362,11 +362,11 @@ pub struct TcpSocket<'a> {
     remote_mss: usize,
     /// The timestamp of the last packet received.
     remote_last_ts: Option<Instant>,
-    /// The sequence number of the last packet recived, used for sACK
+    /// The sequence number of the last packet received, used for sACK
     local_rx_last_seq: Option<TcpSeqNumber>,
-    /// The ACK number of the last packet recived.
+    /// The ACK number of the last packet received.
     local_rx_last_ack: Option<TcpSeqNumber>,
-    /// The number of packets recived directly after
+    /// The number of packets received directly after
     /// each other which have the same ACK number.
     local_rx_dup_acks: u8,
 
@@ -1198,7 +1198,7 @@ impl<'a> TcpSocket<'a> {
                 // number has advanced, or there was no previous sACK.
                 //
                 // While the RFC says we SHOULD keep a list of reported sACK ranges, and iterate
-                // through those, that is currently infeasable. Instead, we offer the range with
+                // through those, that is currently infeasible. Instead, we offer the range with
                 // the lowest sequence number (if one exists) to hint at what segments would
                 // most quickly advance the acknowledgement number.
                 reply_repr.sack_ranges[0] = self
@@ -1279,7 +1279,7 @@ impl<'a> TcpSocket<'a> {
             State::SynSent | State::SynReceived => (true, false),
             // In FIN-WAIT-1, LAST-ACK, or CLOSING, we've just sent a FIN.
             State::FinWait1 | State::LastAck | State::Closing => (false, true),
-            // In all other states we've already got acknowledgemetns for
+            // In all other states we've already got acknowledgements for
             // all of the control flags we sent.
             _ => (false, false),
         };
@@ -1485,7 +1485,7 @@ impl<'a> TcpSocket<'a> {
         if repr.control != TcpControl::Rst {
             if let Some(ack_number) = repr.ack_number {
                 // Sequence number corresponding to the first byte in `tx_buffer`.
-                // This normally equals `local_seq_no`, but is 1 higher if we ahve sent a SYN,
+                // This normally equals `local_seq_no`, but is 1 higher if we have sent a SYN,
                 // as the SYN occupies 1 sequence number "before" the data.
                 let tx_buffer_start_seq = self.local_seq_no + (sent_syn as usize);
 
@@ -1752,11 +1752,11 @@ impl<'a> TcpSocket<'a> {
 
             // Detect and react to duplicate ACKs by:
             // 1. Check if duplicate ACK and change self.local_rx_dup_acks accordingly
-            // 2. If exactly 3 duplicate ACKs recived, set for fast retransmit
+            // 2. If exactly 3 duplicate ACKs received, set for fast retransmit
             // 3. Update the last received ACK (self.local_rx_last_ack)
             match self.local_rx_last_ack {
                 // Duplicate ACK if payload empty and ACK doesn't move send window ->
-                // Increment duplicate ACK count and set for retransmit if we just recived
+                // Increment duplicate ACK count and set for retransmit if we just received
                 // the third duplicate ACK
                 Some(ref last_rx_ack)
                     if repr.payload.is_empty()
@@ -1788,7 +1788,7 @@ impl<'a> TcpSocket<'a> {
                         );
                     }
                 }
-                // No duplicate ACK -> Reset state and update last recived ACK
+                // No duplicate ACK -> Reset state and update last received ACK
                 _ => {
                     if self.local_rx_dup_acks > 0 {
                         self.local_rx_dup_acks = 0;
@@ -5385,7 +5385,7 @@ mod test {
         });
 
         // Send a long string of text divided into several packets
-        // because of previously recieved "window_len"
+        // because of previously received "window_len"
         s.send_slice(b"xxxxxxyyyyyywwwwwwzzzzzz").unwrap();
         // This packet is lost
         recv!(s, time 1000, Ok(TcpRepr {
@@ -5467,7 +5467,7 @@ mod test {
             _ => false,
         });
 
-        // ACK all recived segments
+        // ACK all received segments
         send!(s, time 1120, TcpRepr {
             seq_number: REMOTE_SEQ + 1,
             ack_number: Some(LOCAL_SEQ + 1 + (6 * 4)),
@@ -5487,7 +5487,7 @@ mod test {
             ..RECV_TEMPL
         }));
 
-        // Normal ACK of previously recieved segment
+        // Normal ACK of previously received segment
         send!(
             s,
             TcpRepr {
@@ -5541,7 +5541,7 @@ mod test {
 
         assert_eq!(
             s.local_rx_dup_acks, 0,
-            "duplicate ACK counter is not reset when reciving data"
+            "duplicate ACK counter is not reset when receiving data"
         );
     }
 
@@ -5550,7 +5550,7 @@ mod test {
         let mut s = socket_established();
         s.remote_mss = 6;
 
-        // Normal ACK of previously recived segment
+        // Normal ACK of previously received segment
         send!(s, time 0, TcpRepr {
             seq_number: REMOTE_SEQ + 1,
             ack_number: Some(LOCAL_SEQ + 1),
@@ -5620,10 +5620,10 @@ mod test {
 
         assert_eq!(
             s.local_rx_dup_acks, 0,
-            "duplicate ACK counter is not reset when reciving ACK which updates send window"
+            "duplicate ACK counter is not reset when receiving ACK which updates send window"
         );
 
-        // ACK all recived segments
+        // ACK all received segments
         send!(s, time 1120, TcpRepr {
             seq_number: REMOTE_SEQ + 1,
             ack_number: Some(LOCAL_SEQ + 1 + (6 * 4)),

src/storage/packet_buffer.rs

@@ -180,7 +180,7 @@ impl<'a, H> PacketBuffer<'a, H> {
     }
 
     /// Peek at a single packet from the buffer without removing it, and return a reference to
-    /// its payload as well as its header, or return `Err(Error:Exhaused)` if the buffer is empty.
+    /// its payload as well as its header, or return `Err(Error:Exhausted)` if the buffer is empty.
     ///
     /// This function otherwise behaves identically to [dequeue](#method.dequeue).
     pub fn peek(&mut self) -> Result<(&H, &[u8])> {

src/time.rs

@@ -4,7 +4,7 @@ The `time` module contains structures used to represent both
 absolute and relative time.
 
  - [Instant] is used to represent absolute time.
- - [Duration] is used to represet relative time.
+ - [Duration] is used to represent relative time.
 
 [Instant]: struct.Instant.html
 [Duration]: struct.Duration.html
@@ -177,7 +177,7 @@ pub struct Duration {
 
 impl Duration {
     pub const ZERO: Duration = Duration::from_micros(0);
-    /// Create a new `Duration` from a number of microeconds.
+    /// Create a new `Duration` from a number of microseconds.
     pub const fn from_micros(micros: u64) -> Duration {
         Duration { micros }
     }

src/wire/ieee802154.rs

@@ -479,7 +479,7 @@ impl<T: AsRef<[u8]>> Frame<T> {
         index
     }
 
-    /// Return the lenght of the key identifier field.
+    /// Return the length of the key identifier field.
     fn key_identifier_length(&self) -> Option<u8> {
         Some(match self.key_identifier_mode() {
             0 => 0,

src/wire/ipv6.rs

@@ -158,7 +158,7 @@ impl Address {
         }
     }
 
-    /// Helper function used to mask an addres given a prefix.
+    /// Helper function used to mask an address given a prefix.
     ///
     /// # Panics
     /// This function panics if `mask` is greater than 128.
@@ -245,7 +245,7 @@ impl fmt::Display for Address {
                     State::Tail
                 }
                 // Continue iterating without writing any characters until
-                // we hit anothing non-zero value.
+                // we hit a non-zero value.
                 (0, &State::Tail) => State::Tail,
                 // When the state is Head or Tail write a u16 in hexadecimal
                 // without the leading colon if the value is not 0.

src/wire/ipv6fragment.rs

@@ -166,7 +166,7 @@ pub struct Repr {
     /// The offset of the data following this header, relative to the start of the Fragmentable
     /// Part of the original packet.
     pub frag_offset: u16,
-    /// Whethere are not there are more fragments following this header
+    /// When there are more fragments following this header
     pub more_frags: bool,
     /// The identification for every packet that is fragmented.
     pub ident: u32,

src/wire/ipv6routing.rs

@@ -225,7 +225,7 @@ impl<T: AsRef<[u8]>> Header<T> {
 
 /// Getter methods for the RPL Source Routing Header routing type.
 impl<T: AsRef<[u8]>> Header<T> {
-    /// Return the number of prefix octects elided from addresses[1..n-1].
+    /// Return the number of prefix octets elided from addresses[1..n-1].
     ///
     /// # Panics
     /// This function may panic if this header is not the RPL Source Routing Header routing type.
@@ -234,7 +234,7 @@ impl<T: AsRef<[u8]>> Header<T> {
         data[field::CMPR] >> 4
     }
 
-    /// Return the number of prefix octects elided from the last address (`addresses[n]`).
+    /// Return the number of prefix octets elided from the last address (`addresses[n]`).
     ///
     /// # Panics
     /// This function may panic if this header is not the RPL Source Routing Header routing type.
@@ -243,7 +243,7 @@ impl<T: AsRef<[u8]>> Header<T> {
         data[field::CMPR] & 0xf
     }
 
-    /// Return the number of octects used for padding after `addresses[n]`.
+    /// Return the number of octets used for padding after `addresses[n]`.
     ///
     /// # Panics
     /// This function may panic if this header is not the RPL Source Routing Header routing type.
@@ -334,7 +334,7 @@ impl<T: AsRef<[u8]> + AsMut<[u8]>> Header<T> {
 
 /// Setter methods for the RPL Source Routing Header routing type.
 impl<T: AsRef<[u8]> + AsMut<[u8]>> Header<T> {
-    /// Set the number of prefix octects elided from addresses[1..n-1].
+    /// Set the number of prefix octets elided from addresses[1..n-1].
     ///
     /// # Panics
     /// This function may panic if this header is not the RPL Source Routing Header routing type.
@@ -344,7 +344,7 @@ impl<T: AsRef<[u8]> + AsMut<[u8]>> Header<T> {
         data[field::CMPR] = raw;
     }
 
-    /// Set the number of prefix octects elided from the last address (`addresses[n]`).
+    /// Set the number of prefix octets elided from the last address (`addresses[n]`).
     ///
     /// # Panics
     /// This function may panic if this header is not the RPL Source Routing Header routing type.
@@ -354,7 +354,7 @@ impl<T: AsRef<[u8]> + AsMut<[u8]>> Header<T> {
         data[field::CMPR] = raw;
     }
 
-    /// Set the number of octects used for padding after `addresses[n]`.
+    /// Set the number of octets used for padding after `addresses[n]`.
     ///
     /// # Panics
     /// This function may panic if this header is not the RPL Source Routing Header routing type.
@@ -600,7 +600,7 @@ mod test {
             Err(Error::Truncated),
             Header::new(&BYTES_SRH_ELIDED[..3]).check_len()
         );
-        // less than specfied length field
+        // less than specified length field
         assert_eq!(
             Err(Error::Truncated),
             Header::new(&BYTES_TYPE2[..23]).check_len()

src/wire/mld.rs

@@ -216,7 +216,7 @@ impl<T: AsRef<[u8]>> AddressRecord<T> {
         RecordType::from(data[field::RECORD_TYPE])
     }
 
-    /// Return the length of the auxilary data.
+    /// Return the length of the auxiliary data.
     #[inline]
     pub fn aux_data_len(&self) -> u8 {
         let data = self.buffer.as_ref();
@@ -259,7 +259,7 @@ impl<T: AsMut<[u8]> + AsRef<[u8]>> AddressRecord<T> {
         data[field::RECORD_TYPE] = rty.into();
     }
 
-    /// Return the length of the auxilary data.
+    /// Return the length of the auxiliary data.
     #[inline]
     pub fn set_aux_data_len(&mut self, len: u8) {
         let data = self.buffer.as_mut();

src/wire/ndiscoption.rs

@@ -70,7 +70,7 @@ mod field {
 
     // 8-bit identifier of the type of option.
     pub const TYPE: usize = 0;
-    // 8-bit unsigned integer. Length of the option, in units of 8 octests.
+    // 8-bit unsigned integer. Length of the option, in units of 8 octets.
     pub const LENGTH: usize = 1;
     // Minimum length of an option.
     pub const MIN_OPT_LEN: usize = 8;

src/wire/sixlowpan.rs

@@ -814,7 +814,7 @@ pub mod iphc {
                 _ => 1,
             };
 
-            // Add the lenght of the source address
+            // Add the length of the source address
             len += if self.src_addr == ipv6::Address::UNSPECIFIED {
                 0
             } else if self.src_addr.is_link_local() {
@@ -897,7 +897,7 @@ pub mod iphc {
 
             packet.set_dispatch_field();
 
-            // SETTING THE TRAFIC FLOW
+            // SETTING THE TRAFFIC FLOW
             // TODO(thvdveld): needs more work.
             packet.set_tf_field(0b11);
 
@@ -1258,7 +1258,7 @@ pub mod nhc {
             len
         }
 
-        /// Emit a high-level representaiton into a LOWPAN_NHC Extension Header packet.
+        /// Emit a high-level representation into a LOWPAN_NHC Extension Header packet.
         pub fn emit<T: AsRef<[u8]> + AsMut<[u8]>>(&self, packet: &mut ExtensionHeaderPacket<T>) {
             packet.set_dispatch_field();
             packet.set_extension_header_id(self.ext_header_id);
@@ -1394,7 +1394,7 @@ pub mod nhc {
                 let start = self.nhc_fields_start() + self.ports_size();
                 Some(NetworkEndian::read_u16(&data[start..start + 2]))
             } else {
-                // The checksum is ellided and needs to be recomputed on the 6LoWPAN termination point.
+                // The checksum is elided and needs to be recomputed on the 6LoWPAN termination point.
                 None
             }
         }
@@ -1529,7 +1529,7 @@ pub mod nhc {
                     return Err(Error::Checksum);
                 }
             } else {
-                net_trace!("Currently we do not support ellided checksums.");
+                net_trace!("Currently we do not support elided checksums.");
                 return Err(Error::Unrecognized);
             };
 
@@ -1726,7 +1726,7 @@ mod test {
 
     //match ext_packet.extension_header_id() {
     //nhc::ExtensionHeaderId::RoutingHeader => {
-    //// We are not intersted in the Next Header protocol.
+    //// We are not interested in the Next Header protocol.
     //let proto = ipv6::Protocol::Unknown(0);
     //let mut new_payload = [0; 8];
 

src/wire/tcp.rs

@@ -841,7 +841,7 @@ impl<'a> Repr<'a> {
                 TcpOption::MaxSegmentSize(value) => max_seg_size = Some(value),
                 TcpOption::WindowScale(value) => {
                     // RFC 1323: Thus, the shift count must be limited to 14 (which allows windows
-                    // of 2**30 = 1 Gbyte). If a Window Scale option is received with a shift.cnt
+                    // of 2**30 = 1 Gigabyte). If a Window Scale option is received with a shift.cnt
                     // value exceeding 14, the TCP should log the error but use 14 instead of the
                     // specified value.
                     window_scale = if value > 14 {