Fix all typos

src/net/error.rs

@@ -59,7 +59,7 @@ impl<T> From<tokio::sync::mpsc::error::SendError<T>> for Error {
 	}
 }
 
-/// Ths trait adds a `.log_err()` method on `Result<(), E>` types,
+/// The trait adds a `.log_err()` method on `Result<(), E>` types,
 /// which dismisses the error by logging it to stderr.
 pub trait LogError {
 	fn log_err(self, msg: &'static str);

src/net/message.rs

@@ -18,7 +18,7 @@ use crate::util::*;
 /// in the send queue of the client, and their responses in the send queue of the
 /// server. Lower values mean higher priority.
 ///
-/// This mechanism is usefull for messages bigger than the maximum chunk size
+/// This mechanism is useful for messages bigger than the maximum chunk size
 /// (set at `0x4000` bytes), such as large file transfers.
 /// In such case, all of the messages in the send queue with the highest priority
 /// will take turns to send individual chunks, in a round-robin fashion.
@@ -102,7 +102,7 @@ pub trait Message: Serialize + for<'de> Deserialize<'de> + Send + Sync + 'static
 
 /// The Req<M> is a helper object used to create requests and attach them
 /// a stream of data. If the stream is a fixed Bytes and not a ByteStream,
-/// Req<M> is cheaply clonable to allow the request to be sent to different
+/// Req<M> is cheaply cloneable to allow the request to be sent to different
 /// peers (Clone will panic if the stream is a ByteStream).
 pub struct Req<M: Message> {
 	pub(crate) msg: Arc<M>,

src/net/netapp.rs

@@ -41,7 +41,7 @@ pub(crate) type VersionTag = [u8; 16];
 pub(crate) const NETAPP_VERSION_TAG: u64 = 0x6772676e65740010; // grgnet 0x0010 (1.0)
 
 /// HelloMessage is sent by the client on a Netapp connection to indicate
-/// that they are also a server and ready to recieve incoming connections
+/// that they are also a server and ready to receive incoming connections
 /// at the specified address and port. If the client doesn't know their
 /// public address, they don't need to specify it and we look at the
 /// remote address of the socket is used instead.
@@ -290,7 +290,7 @@ impl NetApp {
 	/// Attempt to connect to a peer, given by its ip:port and its public key.
 	/// The public key will be checked during the secret handshake process.
 	/// This function returns once the connection has been established and a
-	/// successfull handshake was made. At this point we can send messages to
+	/// successful handshake was made. At this point we can send messages to
 	/// the other node with `Netapp::request`
 	pub async fn try_connect(self: Arc<Self>, ip: SocketAddr, id: NodeID) -> Result<(), Error> {
 		// Don't connect to ourself, we don't care

src/net/peering.rs

@@ -138,7 +138,7 @@ pub enum PeerConnState {
 	/// A connection tentative is in progress (the nth, where n is the value stored)
 	Trying(usize),
 
-	/// We abandonned trying to connect to this peer (too many failed attempts)
+	/// We abandoned trying to connect to this peer (too many failed attempts)
 	Abandonned,
 }
 

src/net/send.rs

@@ -28,7 +28,7 @@ use crate::stream::*;
 //   - if error:
 //       - u8: error kind, encoded using error::io_errorkind_to_u8
 //       - rest: error message
-//   - absent for cancel messag
+//   - absent for cancel message
 
 pub(crate) type RequestID = u32;
 pub(crate) type ChunkLength = u16;
@@ -217,7 +217,7 @@ impl<'a> futures::Future for SendQueuePollNextReady<'a> {
 
 enum DataFrame {
 	/// a fixed size buffer containing some data + a boolean indicating whether
-	/// there may be more data comming from this stream. Can be used for some
+	/// there may be more data coming from this stream. Can be used for some
 	/// optimization. It's an error to set it to false if there is more data, but it is correct
 	/// (albeit sub-optimal) to set it to true if there is nothing coming after
 	Data(Bytes, bool),
@@ -310,7 +310,7 @@ pub(crate) trait SendLoop: Sync {
 			// recv_fut is cancellation-safe according to tokio doc,
 			// send_fut is cancellation-safe as implemented above?
 			tokio::select! {
-				biased;	// always read incomming channel first if it has data
+				biased;	// always read incoming channel first if it has data
 				sth = recv_fut => {
 					match sth {
 						Some(SendItem::Stream(id, prio, order_tag, data)) => {

src/net/stream.rs

@@ -16,7 +16,7 @@ use crate::bytes_buf::BytesBuf;
 ///
 /// Items sent in the ByteStream may be errors of type `std::io::Error`.
 /// An error indicates the end of the ByteStream: a reader should no longer read
-/// after recieving an error, and a writer should stop writing after sending an error.
+/// after receiving an error, and a writer should stop writing after sending an error.
 pub type ByteStream = Pin<Box<dyn Stream<Item = Packet> + Send + Sync>>;
 
 /// A packet sent in a ByteStream, which may contain either

src/net/test.rs

@@ -66,7 +66,7 @@ async fn run_test_inner(port_base: u16) {
 	println!("A pl2: {:?}", pl2);
 	assert_eq!(pl2.len(), 2);
 
-	// Connect third ndoe and check it peers with everyone
+	// Connect third node and check it peers with everyone
 	let (thread3, _netapp3, peering3) =
 		run_netapp(netid, pk3, sk3, addr3, vec![(pk2, addr2)], stop_rx.clone());
 	tokio::time::sleep(Duration::from_secs(3)).await;

src/net/util.rs

@@ -25,7 +25,7 @@ where
 /// This async function returns only when a true signal was received
 /// from a watcher that tells us when to exit.
 ///
-/// Usefull in a select statement to interrupt another
+/// Useful in a select statement to interrupt another
 /// future:
 /// ```ignore
 /// select!(