Merge branch 'master' into dependabot/cargo/futures-rustls-0.26.0

.github/mergify.yml

@@ -52,22 +52,24 @@ pull_request_rules:
         message: Approvals have been dismissed because the PR was updated after the `send-it` label was applied.
         changes_requested: false
 
-  # - name: Approve trivial maintainer PRs
-  #   conditions:
-  #     - base=master
-  #     - label=trivial
-  #     - author=@libp2p/rust-libp2p-maintainers
-  #   actions:
-  #     review:
+  - name: Approve trivial maintainer PRs
+    conditions:
+      - base=master
+      - label=trivial
+      - author=@libp2p/rust-libp2p-maintainers
+    actions:
+      review:
+        type: APPROVE
 
-  # - name: Approve dependabot PRs of semver-compatible updates
-  #   conditions:
-  #     - author=dependabot[bot]
-  #     - or:
-  #         - title~=bump [^\s]+ from ([1-9]+)\..+ to \1\.      # For major >= 1 versions, only approve updates with the same major version.
-  #         - title~=bump [^\s]+ from 0\.([\d]+)\..+ to 0\.\1\. # For major == 0 versions, only approve updates with the same minor version.
-  #   actions:
-  #     review:
+  - name: Approve dependabot PRs of semver-compatible updates
+    conditions:
+      - author=dependabot[bot]
+      - or:
+          - title~=bump [^\s]+ from ([1-9]+)\..+ to \1\.      # For major >= 1 versions, only approve updates with the same major version.
+          - title~=bump [^\s]+ from 0\.([\d]+)\..+ to 0\.\1\. # For major == 0 versions, only approve updates with the same minor version.
+    actions:
+      review:
+        type: APPROVE
 
 queue_rules:
   - name: default

Cargo.toml

@@ -112,7 +112,7 @@ libp2p-webrtc = { version = "0.7.1-alpha", path = "transports/webrtc" }
 libp2p-webrtc-utils = { version = "0.2.0", path = "misc/webrtc-utils" }
 libp2p-webrtc-websys = { version = "0.3.0-alpha", path = "transports/webrtc-websys" }
 libp2p-websocket = { version = "0.43.0", path = "transports/websocket" }
-libp2p-websocket-websys = { version = "0.3.1", path = "transports/websocket-websys" }
+libp2p-websocket-websys = { version = "0.3.2", path = "transports/websocket-websys" }
 libp2p-webtransport-websys = { version = "0.2.0", path = "transports/webtransport-websys" }
 libp2p-yamux = { version = "0.45.1", path = "muxers/yamux" }
 multiaddr = "0.18.1"

core/src/transport.rs

@@ -311,7 +311,7 @@ pub enum TransportEvent<TUpgr, TErr> {
 
 impl<TUpgr, TErr> TransportEvent<TUpgr, TErr> {
     /// In case this [`TransportEvent`] is an upgrade, apply the given function
-    /// to the upgrade and produce another transport event based the the function's result.
+    /// to the upgrade and produce another transport event based the function's result.
     pub fn map_upgrade<U>(self, map: impl FnOnce(TUpgr) -> U) -> TransportEvent<U, TErr> {
         match self {
             TransportEvent::Incoming {
@@ -530,7 +530,7 @@ pub enum TransportError<TErr> {
 }
 
 impl<TErr> TransportError<TErr> {
-    /// Applies a function to the the error in [`TransportError::Other`].
+    /// Applies a function to the error in [`TransportError::Other`].
     pub fn map<TNewErr>(self, map: impl FnOnce(TErr) -> TNewErr) -> TransportError<TNewErr> {
         match self {
             TransportError::MultiaddrNotSupported(addr) => {

deny.toml

@@ -37,7 +37,7 @@ ignore = [
 [licenses]
 # The lint level for crates which do not have a detectable license
 unlicensed = "deny"
-# List of explictly allowed licenses
+# List of explicitly allowed licenses
 # See https://spdx.org/licenses/ for list of possible licenses
 # [possible values: any SPDX 3.7 short identifier (+ optional exception)].
 allow = [
@@ -46,7 +46,7 @@ allow = [
     "MIT",
     "Unlicense",
 ]
-# List of explictly disallowed licenses
+# List of explicitly disallowed licenses
 # See https://spdx.org/licenses/ for list of possible licenses
 # [possible values: any SPDX 3.7 short identifier (+ optional exception)].
 deny = []

examples/stream/README.md

@@ -23,7 +23,7 @@ To run the example, follow these steps:
    cargo run --bin stream-example -- <address>
    ```
 
-3. Both terminals should now continuosly print messages. 
+3. Both terminals should now continuously print messages. 
 
 ## Conclusion
 

identity/src/secp256k1.rs

@@ -214,7 +214,7 @@ impl PublicKey {
         self.0.serialize()
     }
 
-    /// Decode a public key from a byte slice in the the format produced
+    /// Decode a public key from a byte slice in the format produced
     /// by `encode`.
     pub fn try_from_bytes(k: &[u8]) -> Result<PublicKey, DecodingError> {
         libsecp256k1::PublicKey::parse_slice(k, Some(libsecp256k1::PublicKeyFormat::Compressed))

protocols/gossipsub/src/behaviour/tests.rs

@@ -2392,7 +2392,7 @@ fn test_dont_graft_to_negative_scored_peers() {
 }
 
 ///Note that in this test also without a penalty the px would be ignored because of the
-/// acceptPXThreshold, but the spec still explicitely states the rule that px from negative
+/// acceptPXThreshold, but the spec still explicitly states the rule that px from negative
 /// peers should get ignored, therefore we test it here.
 #[test]
 fn test_ignore_px_from_negative_scored_peer() {

protocols/gossipsub/src/config.rs

@@ -262,9 +262,9 @@ impl Config {
         self.unsubscribe_backoff
     }
 
-    /// Number of heartbeat slots considered as slack for backoffs. This gurantees that we wait
+    /// Number of heartbeat slots considered as slack for backoffs. This guarantees that we wait
     /// at least backoff_slack heartbeats after a backoff is over before we try to graft. This
-    /// solves problems occuring through high latencies. In particular if
+    /// solves problems occurring through high latencies. In particular if
     /// `backoff_slack * heartbeat_interval` is longer than any latencies between processing
     /// prunes on our side and processing prunes on the receiving side this guarantees that we
     /// get not punished for too early grafting. The default is 1.
@@ -660,9 +660,9 @@ impl ConfigBuilder {
         self
     }
 
-    /// Number of heartbeat slots considered as slack for backoffs. This gurantees that we wait
+    /// Number of heartbeat slots considered as slack for backoffs. This guarantees that we wait
     /// at least backoff_slack heartbeats after a backoff is over before we try to graft. This
-    /// solves problems occuring through high latencies. In particular if
+    /// solves problems occurring through high latencies. In particular if
     /// `backoff_slack * heartbeat_interval` is longer than any latencies between processing
     /// prunes on our side and processing prunes on the receiving side this guarantees that we
     /// get not punished for too early grafting. The default is 1.

protocols/kad/src/behaviour.rs

@@ -2203,7 +2203,7 @@ where
             Some(peer) => peer,
         };
 
-        // We should order addresses from decreasing likelyhood of connectivity, so start with
+        // We should order addresses from decreasing likelihood of connectivity, so start with
         // the addresses of that peer in the k-buckets.
         let key = kbucket::Key::from(peer_id);
         let mut peer_addrs =

protocols/kad/src/kbucket.rs

@@ -344,7 +344,7 @@ enum ClosestBucketsIterState {
     /// The starting state of the iterator yields the first bucket index and
     /// then transitions to `ZoomIn`.
     Start(BucketIndex),
-    /// The iterator "zooms in" to to yield the next bucket cotaining nodes that
+    /// The iterator "zooms in" to yield the next bucket cotaining nodes that
     /// are incrementally closer to the local node but further from the `target`.
     /// These buckets are identified by a `1` in the corresponding bit position
     /// of the distance bit string. When bucket `0` is reached, the iterator

swarm/src/connection.rs

@@ -717,7 +717,7 @@ impl<UserData, Upgrade> Future for SubstreamRequested<UserData, Upgrade> {
 
 /// The options for a planned connection & handler shutdown.
 ///
-/// A shutdown is planned anew based on the the return value of
+/// A shutdown is planned anew based on the return value of
 /// [`ConnectionHandler::connection_keep_alive`] of the underlying handler
 /// after every invocation of [`ConnectionHandler::poll`].
 ///

transports/websocket-websys/CHANGELOG.md

@@ -1,3 +1,10 @@
+## 0.3.2
+
+- Change close code in drop implementation to `1000` given that in browsers only
+  the code `1000` and codes between `3000` and `4999` are allowed to be set by
+  userland code.
+  See [PR 5229](https://github.com/libp2p/rust-libp2p/pull/5229).
+
 ## 0.3.1
 
 - Add support for different WASM environments by introducing a `WebContext` that

transports/websocket-websys/Cargo.toml

@@ -3,7 +3,7 @@ name = "libp2p-websocket-websys"
 edition = "2021"
 rust-version = "1.60.0"
 description = "WebSocket for libp2p under WASM environment"
-version = "0.3.1"
+version = "0.3.2"
 authors = ["Vince Vasta <[email protected]>"]
 license = "MIT"
 repository = "https://github.com/libp2p/rust-libp2p"

transports/websocket-websys/src/lib.rs

@@ -434,13 +434,14 @@ impl AsyncWrite for Connection {
 
 impl Drop for Connection {
     fn drop(&mut self) {
-        const GO_AWAY_STATUS_CODE: u16 = 1001; // See https://www.rfc-editor.org/rfc/rfc6455.html#section-7.4.1.
+        // In browsers, userland code is not allowed to use any other status code than 1000: https://websockets.spec.whatwg.org/#dom-websocket-close
+        const REGULAR_CLOSE: u16 = 1000; // See https://www.rfc-editor.org/rfc/rfc6455.html#section-7.4.1.
 
         if let ReadyState::Connecting | ReadyState::Open = self.inner.ready_state() {
             let _ = self
                 .inner
                 .socket
-                .close_with_code_and_reason(GO_AWAY_STATUS_CODE, "connection dropped");
+                .close_with_code_and_reason(REGULAR_CLOSE, "connection dropped");
         }
 
         WebContext::new()

transports/websocket/src/framed.rs

@@ -521,7 +521,7 @@ fn parse_ws_dial_addr<T>(addr: Multiaddr) -> Result<WsAddress, Error<T>> {
     };
 
     // The original address, stripped of the `/ws` and `/wss` protocols,
-    // makes up the the address for the inner TCP-based transport.
+    // makes up the address for the inner TCP-based transport.
     let tcp_addr = match p2p {
         Some(p) => protocols.with(p),
         None => protocols,