Exhaustive enum switch

cmake/preproject.cmake

@@ -71,6 +71,7 @@ function(add_warning_checks name)
             -Wno-unused-parameter
             -Wno-unused-function
             -Wshadow
+            -Wswitch-enum
   )
 endfunction()
 

include/ccf/crypto/curve.h

@@ -43,13 +43,19 @@ namespace ccf::crypto
   {
     switch (ec)
     {
+      case CurveID::NONE:
+      case CurveID::CURVE25519:
+      case CurveID::X25519:
+      {
+        throw std::logic_error(fmt::format("Invalid ECDSA curve: {}", ec));
+      }
       case CurveID::SECP384R1:
         return MDType::SHA384;
       case CurveID::SECP256R1:
         return MDType::SHA256;
       default:
       {
-        throw std::logic_error(fmt::format("Unhandled CurveID: {}", ec));
+        throw std::logic_error(fmt::format("Unhandled CurveId: {}", ec));
       }
     }
   }

include/ccf/crypto/jwk.h

@@ -69,6 +69,11 @@ namespace ccf::crypto
   {
     switch (curve_id)
     {
+      case CurveID::NONE:
+      case CurveID::CURVE25519:
+      case CurveID::X25519:
+        throw std::logic_error(
+          fmt::format("Invalid JWK EC CurveId {}", curve_id));
       case CurveID::SECP384R1:
         return JsonWebKeyECCurve::P384;
       case CurveID::SECP256R1:
@@ -82,6 +87,9 @@ namespace ccf::crypto
   {
     switch (jwk_curve)
     {
+      case JsonWebKeyECCurve::P521:
+        throw std::logic_error(
+          fmt::format("Unsupported JWK curve {}", jwk_curve));
       case JsonWebKeyECCurve::P384:
         return CurveID::SECP384R1;
       case JsonWebKeyECCurve::P256:
@@ -105,6 +113,10 @@ namespace ccf::crypto
   {
     switch (curve_id)
     {
+      case CurveID::NONE:
+      case CurveID::SECP384R1:
+      case CurveID::SECP256R1:
+        throw std::logic_error(fmt::format("Invalid EdDSA curve {}", curve_id));
       case CurveID::CURVE25519:
         return JsonWebKeyEdDSACurve::ED25519;
       case CurveID::X25519:

include/ccf/endpoint.h

@@ -508,30 +508,27 @@ struct formatter<ccf::endpoints::ForwardingRequired>
   auto format(
     const ccf::endpoints::ForwardingRequired& v, FormatContext& ctx) const
   {
-    char const* s = nullptr;
     switch (v)
     {
       case ccf::endpoints::ForwardingRequired::Sometimes:
       {
-        s = "sometimes";
-        break;
+        return format_to(ctx.out(), "sometimes");
       }
       case ccf::endpoints::ForwardingRequired::Always:
       {
-        s = "always";
-        break;
+        return format_to(ctx.out(), "always");
       }
       case ccf::endpoints::ForwardingRequired::Never:
       {
-        s = "never";
-        break;
+        return format_to(ctx.out(), "never");
       }
       default:
       {
-        throw std::logic_error("Unhandled value for ForwardingRequired");
+        throw std::logic_error(fmt::format(
+          "Unhandled value for ForwardingRequired: {}",
+          static_cast<uint8_t>(v)));
       }
     }
-    return format_to(ctx.out(), "{}", s);
   }
 };
 FMT_END_NAMESPACE

include/ccf/pal/attestation_sev_snp.h

@@ -278,8 +278,8 @@ pRb21iI1NlNCfOGUPIhVpWECAwEAAQ==
             .fmc = tcb.fmc};
         }
         default:
-          throw std::logic_error(
-            "Unsupported SEV-SNP product for TCB version policy");
+          throw std::logic_error(fmt::format(
+            "Unsupported SEV-SNP product for TCB version policy: {}", product));
       }
     }
 

include/ccf/service/tables/proposals.h

@@ -72,13 +72,18 @@ struct formatter<ccf::ProposalState>
       {
         return format_to(ctx.out(), "rejected");
       }
+      case (ccf::ProposalState::FAILED):
+      {
+        return format_to(ctx.out(), "failed");
+      }
       case (ccf::ProposalState::DROPPED):
       {
         return format_to(ctx.out(), "dropped");
       }
       default:
       {
-        return format_to(ctx.out(), "UNKNOWN");
+        throw std::logic_error(fmt::format(
+          "Unknown proposal state {}", static_cast<uint8_t>(state)));
       }
     }
   }

samples/apps/programmability/programmability.cpp

@@ -268,7 +268,8 @@ namespace programmabilityapp
             "Failed to check if action is original");
           return true;
         }
-        default:
+        case ccf::ApiResult::Uninitialised:
+        case ccf::ApiResult::NotFound:
         {
           return true;
         }

src/consensus/aft/raft.h

@@ -799,9 +799,11 @@ namespace aft
             break;
           }
 
+          case raft_append_entries_signed_response:
           default:
           {
-            RAFT_FAIL_FMT("Unhandled AFT message type: {}", type);
+            RAFT_FAIL_FMT("Received unhandled AFT message type: {}", type);
+            return;
           }
         }
       }
@@ -1444,7 +1446,11 @@ namespace aft
             break;
           }
 
-          default:
+          case ccf::kv::ApplyResult::PASS_BACKUP_SIGNATURE:
+          case ccf::kv::ApplyResult::PASS_BACKUP_SIGNATURE_SEND_ACK:
+          case ccf::kv::ApplyResult::PASS_NONCES:
+          case ccf::kv::ApplyResult::PASS_NEW_VIEW:
+          case ccf::kv::ApplyResult::PASS_APPLY:
           {
             throw std::logic_error("Unknown ApplyResult value");
           }
@@ -2427,7 +2433,9 @@ namespace aft
           case ccf::kv::LeadershipState::Candidate:
             become_leader();
             break;
-          default:
+          case ccf::kv::LeadershipState::None:
+          case ccf::kv::LeadershipState::Leader:
+          case ccf::kv::LeadershipState::Follower:
             throw std::logic_error(
               "add_vote_for_me() called while not a pre-vote candidate or "
               "candidate");

src/crypto/openssl/hash.h

@@ -33,7 +33,6 @@ namespace ccf::crypto
         default:
           throw std::runtime_error("Unsupported hash algorithm");
       }
-      return nullptr;
     }
 
     std::vector<uint8_t> hkdf(

src/ds/actors.h

@@ -37,7 +37,7 @@ namespace ccf
       {
         return "node";
       }
-      default:
+      case ActorsType::unknown:
       {
         return "";
       }

src/enclave/tls_session.h

@@ -279,8 +279,11 @@ namespace ccf
           break;
         }
 
-        default:
+        case closed:
+        case authfail:
+        case error:
         {
+          break;
         }
       }
     }
@@ -435,15 +438,23 @@ namespace ccf
         case error:
           return;
 
-        default:
+        case handshake:
+        case ready:
+        case closing:
         {
+          break;
         }
       }
 
       status = status_;
 
       switch (status)
       {
+        case handshake:
+        case ready:
+        {
+          break;
+        }
         case closing:
         case closed:
         {
@@ -471,8 +482,8 @@ namespace ccf
         }
 
         default:
-        {
-        }
+          throw std::logic_error(
+            fmt::format("TLS {} unknown status: {}", session_id, status));
       }
     }
 

src/host/tcp.h

@@ -276,6 +276,20 @@ namespace asynchost
     {
       switch (status)
       {
+        case FRESH:
+        case BINDING:
+        case LISTENING_RESOLVING:
+        case LISTENING:
+        case CONNECTING_RESOLVING:
+        case CONNECTING:
+        case CONNECTED:
+        case LISTENING_FAILED:
+        case RECONNECTING:
+        {
+          LOG_DEBUG_FMT(
+            "Unexpected status during reconnect, ignoring: {}", status);
+          break;
+        }
         case BINDING_FAILED:
         {
           // Try again, from the start.
@@ -309,8 +323,8 @@ namespace asynchost
 
         default:
         {
-          LOG_DEBUG_FMT(
-            "Unexpected status during reconnect, ignoring: {}", status);
+          throw std::logic_error(
+            fmt::format("Unexpected status during reconnect: {}", status));
         }
       }
 
@@ -364,6 +378,10 @@ namespace asynchost
           break;
         }
 
+        case FRESH:
+        case LISTENING_RESOLVING:
+        case LISTENING:
+        case LISTENING_FAILED:
         default:
         {
           free_write(req);
@@ -649,6 +667,17 @@ namespace asynchost
             break;
           }
 
+          case FRESH:
+          case LISTENING:
+          case BINDING:
+          case BINDING_FAILED:
+          case CONNECTING:
+          case CONNECTED:
+          case DISCONNECTED:
+          case RESOLVING_FAILED:
+          case LISTENING_FAILED:
+          case CONNECTING_FAILED:
+          case RECONNECTING:
           default:
           {
             throw std::logic_error(

src/host/udp.h

@@ -199,7 +199,7 @@ namespace asynchost
           return send_write(req, len, &addr);
         }
 
-        // This shouldn't happen, but the only state is FRESH
+        case FRESH:
         default:
         {
           free_write(req);

src/http/curl.h

@@ -418,7 +418,7 @@ namespace ccf::curl
           fmt::format("Unsupported HTTP method: {}", method.c_str()));
       }
 
-      switch (http_method.value())
+      switch (static_cast<int>(http_method.value()))
       {
         case HTTP_GET:
           CHECK_CURL_EASY_SETOPT(curl_handle, CURLOPT_HTTPGET, 1L);

src/js/permissions_checks.h

@@ -79,7 +79,7 @@ namespace ccf::js
               {
                 return KVAccessPermissions::WRITE_ONLY;
               }
-              default:
+              case (TxAccess::GOV_RO):
               {
                 return KVAccessPermissions::ILLEGAL;
               }

src/kv/generic_serialise_wrapper.h

@@ -4,6 +4,7 @@
 
 #include "ccf/kv/serialisers/serialised_entry.h"
 #include "ds/ccf_assert.h"
+#include "ds/serialized.h"
 #include "kv_types.h"
 #include "node/rpc/claims.h"
 #include "serialised_entry_format.h"
@@ -52,8 +53,10 @@ namespace ccf::kv
           current_writer = &public_writer;
           current_domain = SecurityDomain::PUBLIC;
           break;
-        default:
-          break;
+        case SecurityDomain::SECURITY_DOMAIN_MAX:
+        {
+          throw std::logic_error("Invalid security domain");
+        }
       }
     }
 

src/node/channels.h

@@ -899,11 +899,19 @@ namespace ccf
             return false;
           }
 
+          case (NodeMsgType::channel_msg):
+          {
+            CHANNEL_SEND_FAIL(
+              "Cannot send channel message on unestablished channel");
+            return false;
+          }
+
           default:
           {
             CHANNEL_SEND_FAIL(
-              "Unhandled message type {} on unestablished channel - ignoring",
-              type);
+              "Cannot send message of unexpected type {} on unestablished "
+              "channel",
+              static_cast<size_t>(type));
             return false;
           }
         }

src/node/hooks.h

@@ -8,6 +8,8 @@
 #include "service/tables/config.h"
 #include "service/tables/signatures.h"
 
+#include <stdexcept>
+
 namespace ccf
 {
   struct NodeAddr
@@ -56,6 +58,10 @@ namespace ccf
           }
           default:
           {
+            throw std::logic_error(fmt::format(
+              "Unknown node status {} for node {} in configuration change hook",
+              static_cast<uint8_t>(ni.status),
+              node_id));
           }
         }
       }