Return MissingBlockContext on encryption mismatch

upstairs/src/deferred.rs

@@ -7,7 +7,7 @@ use crate::{
     BlockRes, ClientId, ImpactedBlocks, Message, RawWrite, Validation,
 };
 use bytes::BytesMut;
-use crucible_common::{integrity_hash, RegionDefinition};
+use crucible_common::{integrity_hash, CrucibleError, RegionDefinition};
 use crucible_protocol::ReadBlockContext;
 use futures::{
     future::{ready, Either, Ready},
@@ -234,42 +234,48 @@ impl DeferredRead {
             let block_size = data.len() / rs.len();
             for (i, r) in rs.iter_mut().enumerate() {
                 let v = if let Some(ctx) = &self.cfg.encryption_context {
-                    let r = match r {
-                        ReadBlockContext::Empty => None,
+                    match r {
+                        ReadBlockContext::Empty => Ok(None),
+                        ReadBlockContext::Encrypted { ctx } => Ok(Some(*ctx)),
                         ReadBlockContext::Unencrypted { .. } => {
                             error!(
                                 self.log,
                                 "expected encrypted but got unencrypted \
                                  block context"
                             );
-                            None
+                            Err(CrucibleError::MissingBlockContext)
                         }
-                        ReadBlockContext::Encrypted { ctx } => Some(*ctx),
-                    };
-                    validate_encrypted_read_response(
-                        r,
-                        &mut data[i * block_size..][..block_size],
-                        ctx,
-                        &self.log,
-                    )
+                    }
+                    .and_then(|r| {
+                        validate_encrypted_read_response(
+                            r,
+                            &mut data[i * block_size..][..block_size],
+                            ctx,
+                            &self.log,
+                        )
+                    })
                 } else {
-                    let r = match r {
-                        ReadBlockContext::Empty => None,
+                    match r {
+                        ReadBlockContext::Empty => Ok(None),
+                        ReadBlockContext::Unencrypted { hash } => {
+                            Ok(Some(*hash))
+                        }
                         ReadBlockContext::Encrypted { .. } => {
                             error!(
                                 self.log,
                                 "expected unencrypted but got encrypted \
                                  block context"
                             );
-                            None
+                            Err(CrucibleError::MissingBlockContext)
                         }
-                        ReadBlockContext::Unencrypted { hash } => Some(*hash),
-                    };
-                    validate_unencrypted_read_response(
-                        r,
-                        &mut data[i * block_size..][..block_size],
-                        &self.log,
-                    )
+                    }
+                    .and_then(|r| {
+                        validate_unencrypted_read_response(
+                            r,
+                            &mut data[i * block_size..][..block_size],
+                            &self.log,
+                        )
+                    })
                 };
                 match v {
                     Ok(hash) => hashes.push(hash),