docs: fix spelling mistakes and whitelist correct words

Author: jacobtread

.vscode/settings.json

@@ -0,0 +1,13 @@
+{
+    "cSpell.words": [
+        "gosredirector",
+        "PKCS",
+        "Redirector",
+        "repr",
+        "reqwest",
+        "SECU",
+        "splitn",
+        "VALU",
+        "XDNS"
+    ]
+}

src/api.rs

@@ -33,11 +33,11 @@ mod headers {
     /// Header used for association tokens
     pub const ASSOCIATION: &str = "x-association";
 
-    /// Legacy header used to derive the server scheme (Exists only for backwards compatability)
+    /// Legacy header used to derive the server scheme (Exists only for backwards compatibility)
     pub const LEGACY_SCHEME: &str = "x-pocket-relay-scheme";
-    /// Legacy header used to derive the server host (Exists only for backwards compatability)
+    /// Legacy header used to derive the server host (Exists only for backwards compatibility)
     pub const LEGACY_HOST: &str = "x-pocket-relay-host";
-    /// Legacy header used to derive the server port (Exists only for backwards compatability)
+    /// Legacy header used to derive the server port (Exists only for backwards compatibility)
     pub const LEGACY_PORT: &str = "x-pocket-relay-port";
     /// Legacy header telling the server to use local http routing
     /// (Existing only for backwards compat, this is the default behavior for newer versions)
@@ -157,7 +157,7 @@ pub async fn lookup_server(
 
     url.push_str(&host);
 
-    // Ensure theres a trailing slash (URL path will be interpeted incorrectly without)
+    // Ensure theres a trailing slash (URL path will be interpreted incorrectly without)
     if !url.ends_with('/') {
         url.push('/');
     }
@@ -216,12 +216,12 @@ pub async fn lookup_server(
         ));
     }
 
-    // Debug logging association aquire
+    // Debug logging association acquire
     #[cfg(debug_assertions)]
     {
         use log::debug;
         if let Some(association) = &details.association {
-            debug!("Aquired association token: {}", association);
+            debug!("Acquired association token: {}", association);
         }
     }
 
@@ -267,7 +267,7 @@ pub async fn create_server_stream(
     let mut headers: HeaderMap<HeaderValue> = [
         (header::CONNECTION, HeaderValue::from_static("Upgrade")),
         (header::UPGRADE, HeaderValue::from_static("blaze")),
-        // Headers for legacy compatability
+        // Headers for legacy compatibility
         (
             HeaderName::from_static(headers::LEGACY_SCHEME),
             HeaderValue::from_static("http"),
@@ -348,7 +348,7 @@ pub async fn publish_telemetry_event(
     Ok(())
 }
 
-/// Errors that could occur when proxying a request
+/// Errors that could occur in the proxy process
 #[derive(Debug, Error)]
 pub enum ProxyError {
     /// Initial HTTP request failure

src/fire.rs

@@ -125,7 +125,7 @@ impl Decoder for FireCodec {
             // Use the existing frame
             current_frame
         } else {
-            // Ensure there is atleast enough bytes for the header
+            // Ensure there is at least enough bytes for the header
             if src.len() < Self::MIN_HEADER_SIZE {
                 return Ok(None);
             }

src/servers/http.rs

@@ -42,8 +42,8 @@ pub async fn start_http_server(ctx: Arc<ClientContext>) -> std::io::Result<()> {
         .map_err(|err| std::io::Error::new(ErrorKind::Other, err))
 }
 
-/// Handles an HTTP request from the HTTP server proxying it along
-/// to the Pocket Relay server
+/// Handles an HTTP request from the HTTP acting as a proxy
+/// for the Pocket Relay server
 ///
 /// ## Arguments
 /// * `request` - The HTTP request

src/servers/mod.rs

@@ -37,7 +37,7 @@ pub fn has_server_tasks() -> bool {
     !values.is_empty()
 }
 
-/// Spawns a server related task future onto tokios runtime and
+/// Spawns a server related task future onto the tokio runtime and
 /// adds the abort handle for the task to the task collection
 ///
 /// ## Arguments

src/servers/qos.rs

@@ -1,5 +1,5 @@
 //! Quality of Service server implementation, this is a pretty crude implementation
-//! but it atleast allows clients to sometimes obtain the correct address, usually
+//! but it at least allows clients to sometimes obtain the correct address, usually
 //! the server can fix it
 
 use super::{spawn_server_task, QOS_PORT};
@@ -24,7 +24,7 @@ pub async fn start_qos_server() -> std::io::Result<()> {
     // Accept messages
     loop {
         let (count, addr) = socket.recv_from(&mut buffer).await?;
-        // Create an array from the data that was recieved
+        // Create an array from the data that was received
         let buffer: Box<[u8]> = Box::from(&buffer[..count]);
 
         spawn_server_task(handle(socket.clone(), addr, buffer));
@@ -36,7 +36,7 @@ pub async fn start_qos_server() -> std::io::Result<()> {
 /// ## Arguments
 /// * `socket`      - The UDP socket used for sending the responses
 /// * `socket_addr` - The socket address of the connection (Target for the response)
-/// * `buffer`      - Buffer of bytes recieved from the socket
+/// * `buffer`      - Buffer of bytes received from the socket
 async fn handle(socket: Arc<UdpSocket>, socket_addr: SocketAddr, buffer: Box<[u8]>) {
     // Extract the IPv4 address from the socket address (Fallback to 0.0.0.0)
     let socket_ip = match socket_addr {
@@ -95,7 +95,7 @@ async fn public_address() -> Option<Ipv4Addr> {
         }
     }
 
-    // Hold the write lock to prevent others from attempting to update aswell
+    // Hold the write lock to prevent others from attempting to update as well
     let cached = &mut *PUBLIC_ADDR_CACHE.write().await;
 
     // API addresses for IP lookup

src/servers/tunnel.rs

@@ -123,8 +123,8 @@ async fn create_tunnel(ctx: Arc<ClientContext>, association: &str) -> std::io::R
     Ok(())
 }
 
-/// Represents a tunnel and its pool of conenctions that it can
-/// send data to and receieve data from
+/// Represents a tunnel and its pool of connections that it can
+/// send data to and receive data from
 struct Tunnel {
     /// Tunnel connection to the Pocket Relay server for sending [`TunnelMessage`]s
     /// through the server to reach a specific peer
@@ -149,15 +149,15 @@ enum TunnelWriteState {
     Write(Option<TunnelMessage>),
     /// Poll flushing the bytes written to [`Tunnel::io`]
     Flush,
-    /// The tunnnel has stopped and should not continue
+    /// The tunnel has stopped and should not continue
     Stop,
 }
 
 /// Holds the state for the current reading progress for a [`Tunnel`]
 enum TunnelReadState {
     /// Continue reading
     Continue,
-    /// The tunnnel has stopped and should not continue
+    /// The tunnel has stopped and should not continue
     Stop,
 }
 
@@ -274,16 +274,16 @@ struct SocketHandle(mpsc::UnboundedSender<TunnelMessage>);
 /// Size of the socket read buffer 2^16 bytes
 ///
 /// Can likely be reduced to 2^15 bytes or 2^13 bytes (or lower) since
-/// highest observed message length was 1254 bytes but testing is requried
+/// highest observed message length was 1254 bytes but testing is required
 /// before that can take place
 const READ_BUFFER_LENGTH: usize = 2usize.pow(16);
 
-/// Socket used by a [`Tunnel`] for sending and recieving messages in
+/// Socket used by a [`Tunnel`] for sending and receiving messages in
 /// order to simulate another player on the local network
 struct Socket {
     // Index of the socket
     index: u8,
-    // The underlying socket for sending and recieving
+    // The underlying socket for sending and receiving
     socket: UdpSocket,
     /// Receiver for messages coming from the the [`Tunnel`] that need to be
     /// send through the socket
@@ -305,15 +305,15 @@ enum SocketWriteState {
     Recv,
     /// Waiting for the [`Socket::socket`] to write the bytes
     Write(Bytes),
-    /// The tunnnel has stopped and should not continue
+    /// The tunnel has stopped and should not continue
     Stop,
 }
 
 /// Holds the state for the current reading progress for a [`Socket`]
 enum SocketReadState {
     /// Continue reading
     Continue,
-    /// The tunnnel has stopped and should not continue
+    /// The tunnel has stopped and should not continue
     Stop,
 }
 
@@ -392,7 +392,7 @@ impl Socket {
                     return Poll::Ready(SocketWriteState::Stop);
                 };
 
-                // Didnt write entire messsage
+                // Didn't write the entire message
                 if count != message.len() {
                     // Continue with a writing state at the remaining message
                     let message = message.slice(count..);
@@ -420,7 +420,7 @@ impl Socket {
             return Poll::Ready(SocketReadState::Stop);
         }
 
-        // Get the recieved message
+        // Get the received message
         let bytes = read_buf.filled();
         let message = Bytes::copy_from_slice(bytes);
         let message = TunnelMessage {

src/update.rs

@@ -13,7 +13,7 @@ pub struct GitHubRelease {
     pub tag_name: String,
     /// The name of the release (Usually the same as tag_name)
     pub name: String,
-    /// The datetime the release was published
+    /// The date & time the release was published
     pub published_at: String,
     /// The release assets
     pub assets: Vec<GitHubReleaseAsset>,