book: fix code references

Author: djc

docs/book/src/quinn/certificate-certs.rs

@@ -1,6 +1,6 @@
 use std::error::Error;
 
-use rustls::{client, pki_types::pem::PemObject};
+use rustls::pki_types::pem::PemObject;
 
 fn read_certs_from_file() -> Result<
     (

docs/book/src/quinn/certificate.md

@@ -19,13 +19,13 @@ rustls = { version = "*", features = ["dangerous_configuration", "quic"] }
 Then, allow the client to skip the certificate validation by implementing [ServerCertVerifier][ServerCertVerifier] and letting it assert verification for any server.
 
 ```rust
-{{#include certificate-insecure.rs:5:57}}
+{{#include certificate-insecure.rs:8:60}}
 ```
 
 After that, modify the [ClientConfig][ClientConfig] to use this [ServerCertVerifier][ServerCertVerifier] implementation.
 
 ```rust
-{{#include certificate-insecure.rs:59:66}}
+{{#include certificate-insecure.rs:62:71}}
 ```
 
 Finally, if you plug this [ClientConfig][ClientConfig] into the [Endpoint::set_default_client_config()][set_default_client_config] your client endpoint should verify all connections as trustworthy.
@@ -45,7 +45,7 @@ This example uses [rcgen][4] to generate a certificate.
 Let's look at an example:
 
 ```rust
-{{#include certificate-certs.rs:14:19}}
+{{#include certificate-certs.rs:20:31}}
 ```
 
 *Note that [generate_simple_self_signed][generate_simple_self_signed] returns a [Certificate][2] that can be serialized to both `.der` and `.pem` formats.*
@@ -68,7 +68,7 @@ certbot asks for the required data and writes the certificates to `fullchain.pem
 These files can then be referenced in code.
 
 ```rust
-{{#include certificate-certs.rs:5:12}}
+{{#include certificate-certs.rs:5:18}}
 ```
 
 ### Configuring Certificates
@@ -79,15 +79,15 @@ After configuring plug the configuration into the `Endpoint`.
 **Configure Server**
 
 ```rust
-{{#include certificate-certs.rs:24}}
+{{#include certificate-certs.rs:36}}
 ```
 
 This is the only thing you need to do for your server to be secured.
 
 **Configure Client**
 
 ```rust
-{{#include certificate-certs.rs:25}}
+{{#include certificate-certs.rs:37}}
 ```
 
 This is the only thing you need to do for your client to trust a server certificate signed by a conventional certificate authority.

docs/book/src/quinn/data-transfer.md

@@ -6,10 +6,10 @@ This chapter continues with the subject of sending data over this connection.
 
 ## Multiplexing
 
-Multiplexing is the act of combining data from multiple streams into a single stream. 
-This can have a significant positive effect on the performance of the application. 
-With QUIC, the programmer is in full control over the stream allocation.  
-  
+Multiplexing is the act of combining data from multiple streams into a single stream.
+This can have a significant positive effect on the performance of the application.
+With QUIC, the programmer is in full control over the stream allocation.
+
 ## Stream Types
 
 QUIC provides support for both stream and message-based communication.
@@ -28,53 +28,53 @@ New streams can be created with [Connection][Connection]'s [open_bi()][open_bi]
 
 ## Bidirectional Streams
 
-With bidirectional streams, data can be sent in both directions. 
+With bidirectional streams, data can be sent in both directions.
 For example, from the connection initiator to the peer and the other way around.
- 
+
 *open bidirectional stream*
 
 ```rust
-{{#include data-transfer.rs:7:13}}
+{{#include data-transfer.rs:4:10}}
 ```
 
 *iterate incoming bidirectional stream(s)*
 
 ```rust
-{{#include data-transfer.rs:15:23}}
+{{#include data-transfer.rs:12:20}}
 ```
 
-## Unidirectional Streams 
+## Unidirectional Streams
 
 With unidirectional streams, you can carry data only in one direction: from the initiator of the stream to its peer.
 It is possible to get reliability without ordering (so no head-of-line blocking) by opening a new stream for each packet.
 
 *open unidirectional stream*
 
 ```rust
-{{#include data-transfer.rs:25:30}}
+{{#include data-transfer.rs:22:27}}
 ```
 
 *iterating incoming unidirectional stream(s)*
 
 ```rust
-{{#include data-transfer.rs:32:38}}
+{{#include data-transfer.rs:29:35}}
 ```
 
 ## Unreliable Messaging
 
-With unreliable messaging, you can transfer data without reliability. 
+With unreliable messaging, you can transfer data without reliability.
 This could be useful if data arrival isn't essential or when high throughput is important.
 
 *send datagram*
 
 ```rust
-{{#include data-transfer.rs:40:43}}
+{{#include data-transfer.rs:37:40}}
 ```
 
 *iterating datagram stream(s)*
 
 ```rust
-{{#include data-transfer.rs:45:51}}
+{{#include data-transfer.rs:42:48}}
 ```
 
 [Endpoint]: https://docs.rs/quinn/latest/quinn/struct.Endpoint.html