-started using fixed width integers from the std namespace, added mis…

…sing <cstdint> includes; -set version to 1.6.2;
kamchatka-volcano · Jan 3, 2024 · 9b02b4a · 9b02b4a
1 parent e08bc5a
commit 9b02b4a
Show file tree

Hide file tree

Showing 28 changed files with 192 additions and 186 deletions.
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -1,5 +1,5 @@
 cmake_minimum_required(VERSION 3.18)
-project(fcgi_responder VERSION 1.6.1)
+project(fcgi_responder VERSION 1.6.2)
 
 include(GNUInstallDirs)
 include(external/seal_lake)

diff --git a/src/constants.h b/src/constants.h
@@ -4,11 +4,11 @@
 
 namespace fcgi {
 namespace hardcoded {
-const uint8_t protocolVersion = 1;
-const uint8_t keepConnectionMask = 1;
-const uint8_t headerSize = 8;
-const uint32_t maxDataMessageSize = std::numeric_limits<uint16_t>::max();
-const uint32_t maxRecordPaddingSize = std::numeric_limits<uint8_t>::max();
-const uint32_t maxRecordSize = headerSize + maxDataMessageSize + maxRecordPaddingSize;
+const std::uint8_t protocolVersion = 1;
+const std::uint8_t keepConnectionMask = 1;
+const std::uint8_t headerSize = 8;
+const std::uint32_t maxDataMessageSize = std::numeric_limits<std::uint16_t>::max();
+const std::uint32_t maxRecordPaddingSize = std::numeric_limits<std::uint8_t>::max();
+const std::uint32_t maxRecordSize = headerSize + maxDataMessageSize + maxRecordPaddingSize;
 } //namespace hardcoded
 } //namespace fcgi
diff --git a/src/decoder.cpp b/src/decoder.cpp
@@ -8,13 +8,13 @@ Decoder::Decoder(std::istream& input)
 {
 }
 
-Decoder& Decoder::operator>>(uint8_t& val)
+Decoder& Decoder::operator>>(std::uint8_t& val)
 {
     input_.read(reinterpret_cast<char*>(&val), 1);
     return *this;
 }
 
-Decoder& Decoder::operator>>(uint16_t& val)
+Decoder& Decoder::operator>>(std::uint16_t& val)
 {
     auto valIt = reinterpret_cast<char*>(&val);
     input_.read(valIt, 2);
@@ -24,7 +24,7 @@ Decoder& Decoder::operator>>(uint16_t& val)
     return *this;
 }
 
-Decoder& Decoder::operator>>(uint32_t& val)
+Decoder& Decoder::operator>>(std::uint32_t& val)
 {
     auto valIt = reinterpret_cast<char*>(&val);
     input_.read(valIt, 4);

diff --git a/src/decoder.h b/src/decoder.h
@@ -1,14 +1,15 @@
 #pragma once
+#include <cstdint>
 #include <istream>
 
 namespace fcgi {
 
 class Decoder {
 public:
     explicit Decoder(std::istream& input);
-    Decoder& operator>>(uint8_t& val);
-    Decoder& operator>>(uint16_t& val);
-    Decoder& operator>>(uint32_t& val);
+    Decoder& operator>>(std::uint8_t& val);
+    Decoder& operator>>(std::uint16_t& val);
+    Decoder& operator>>(std::uint32_t& val);
     Decoder& operator>>(std::string& val);
 
     void skip(std::size_t numOfBytes);

diff --git a/src/encoder.cpp b/src/encoder.cpp
@@ -8,13 +8,13 @@ Encoder::Encoder(std::ostream& stream)
 {
 }
 
-Encoder& Encoder::operator<<(uint8_t val)
+Encoder& Encoder::operator<<(std::uint8_t val)
 {
     output_.write(reinterpret_cast<const char*>(&val), 1);
     return *this;
 }
 
-Encoder& Encoder::operator<<(uint16_t val)
+Encoder& Encoder::operator<<(std::uint16_t val)
 {
     auto valIt = reinterpret_cast<char*>(&val);
 #ifndef BIG_ENDIAN_HOST
@@ -24,7 +24,7 @@ Encoder& Encoder::operator<<(uint16_t val)
     return *this;
 }
 
-Encoder& Encoder::operator<<(uint32_t val)
+Encoder& Encoder::operator<<(std::uint32_t val)
 {
     auto valIt = reinterpret_cast<char*>(&val);
 #ifndef BIG_ENDIAN_HOST

diff --git a/src/encoder.h b/src/encoder.h
@@ -1,14 +1,15 @@
 #pragma once
+#include <cstdint>
 #include <ostream>
 
 namespace fcgi {
 
 class Encoder {
 public:
     explicit Encoder(std::ostream& stream);
-    Encoder& operator<<(uint8_t val);
-    Encoder& operator<<(uint16_t val);
-    Encoder& operator<<(uint32_t val);
+    Encoder& operator<<(std::uint8_t val);
+    Encoder& operator<<(std::uint16_t val);
+    Encoder& operator<<(std::uint32_t val);
     Encoder& operator<<(const std::string& val);
 
     void addPadding(std::size_t numOfBytes);

diff --git a/src/errors.cpp b/src/errors.cpp
@@ -8,13 +8,13 @@ ProtocolError::ProtocolError(const std::string& msg)
 {
 }
 
-UnsupportedVersion::UnsupportedVersion(uint8_t protocolVersion)
+UnsupportedVersion::UnsupportedVersion(std::uint8_t protocolVersion)
     : ProtocolError{"Protocol version \"" + std::to_string(protocolVersion) + "\" isn't supported."}
     , protocolVersion_{protocolVersion}
 {
 }
 
-uint8_t UnsupportedVersion::protocolVersion() const
+std::uint8_t UnsupportedVersion::protocolVersion() const
 {
     return protocolVersion_;
 }
@@ -38,7 +38,7 @@ std::string invalidValueTypeToString(InvalidValueType type)
 
 } //namespace
 
-InvalidValue::InvalidValue(InvalidValueType type, uint32_t value)
+InvalidValue::InvalidValue(InvalidValueType type, std::uint32_t value)
     : ProtocolError{""}
     , type_{type}
     , value_{value}
@@ -59,17 +59,17 @@ InvalidValueType InvalidValue::type() const
     return type_;
 }
 
-uint32_t InvalidValue::asInt() const
+std::uint32_t InvalidValue::asInt() const
 {
-    return std::get<uint32_t>(value_);
+    return std::get<std::uint32_t>(value_);
 }
 
 std::string InvalidValue::asString() const
 {
     if (std::holds_alternative<std::string>(value_))
         return std::get<std::string>(value_);
     else
-        return std::to_string(std::get<uint32_t>(value_));
+        return std::to_string(std::get<std::uint32_t>(value_));
 }
 
 const char* InvalidValue::what() const noexcept
@@ -88,13 +88,13 @@ std::size_t RecordMessageReadError::recordSize() const
     return recordSize_;
 }
 
-InvalidRecordType::InvalidRecordType(uint8_t typeValue)
+InvalidRecordType::InvalidRecordType(std::uint8_t typeValue)
     : ProtocolError{"Record type \"" + std::to_string(typeValue) + "\" is invalid."}
     , typeValue_{typeValue}
 {
 }
 
-uint8_t InvalidRecordType::recordType() const
+std::uint8_t InvalidRecordType::recordType() const
 {
     return typeValue_;
 }

diff --git a/src/errors.h b/src/errors.h
@@ -1,4 +1,5 @@
 #pragma once
+#include <cstdint>
 #include <stdexcept>
 #include <variant>
 
@@ -11,11 +12,11 @@ class ProtocolError : public std::runtime_error {
 
 class UnsupportedVersion : public ProtocolError {
 public:
-    explicit UnsupportedVersion(uint8_t protocolVersion);
-    uint8_t protocolVersion() const;
+    explicit UnsupportedVersion(std::uint8_t protocolVersion);
+    std::uint8_t protocolVersion() const;
 
 private:
-    uint8_t protocolVersion_;
+    std::uint8_t protocolVersion_;
 };
 
 enum class InvalidValueType {
@@ -27,17 +28,17 @@ enum class InvalidValueType {
 
 class InvalidValue : public ProtocolError {
 public:
-    InvalidValue(InvalidValueType type, uint32_t value);
+    InvalidValue(InvalidValueType type, std::uint32_t value);
     InvalidValue(InvalidValueType type, const std::string& value);
     InvalidValueType type() const;
-    uint32_t asInt() const;
+    std::uint32_t asInt() const;
     std::string asString() const;
 
     const char* what() const noexcept override;
 
 private:
     InvalidValueType type_;
-    std::variant<uint32_t, std::string> value_;
+    std::variant<std::uint32_t, std::string> value_;
     std::string msg_;
 };
 
@@ -52,11 +53,11 @@ class RecordMessageReadError : public ProtocolError {
 
 class InvalidRecordType : public ProtocolError {
 public:
-    explicit InvalidRecordType(uint8_t recordType);
-    uint8_t recordType() const;
+    explicit InvalidRecordType(std::uint8_t recordType);
+    std::uint8_t recordType() const;
 
 private:
-    uint8_t typeValue_;
+    std::uint8_t typeValue_;
 };
 
 } //namespace fcgi
diff --git a/src/msgbeginrequest.cpp b/src/msgbeginrequest.cpp
@@ -30,14 +30,14 @@ ResultConnectionState MsgBeginRequest::resultConnectionState() const
 void MsgBeginRequest::toStream(std::ostream& output) const
 {
     auto encoder = Encoder(output);
-    encoder << static_cast<uint16_t>(role_) << static_cast<uint8_t>(resultConnectionState_);
+    encoder << static_cast<std::uint16_t>(role_) << static_cast<std::uint8_t>(resultConnectionState_);
     encoder.addPadding(5); //reserved bytes
 }
 
 void MsgBeginRequest::fromStream(std::istream& input, std::size_t)
 {
-    auto role = uint16_t{};
-    auto flags = uint8_t{};
+    auto role = std::uint16_t{};
+    auto flags = std::uint8_t{};
     auto decoder = Decoder(input);
     decoder >> role >> flags;
     decoder.skip(5); //reservedBytes

diff --git a/src/msgendrequest.cpp b/src/msgendrequest.cpp
@@ -5,7 +5,7 @@
 
 namespace fcgi {
 
-MsgEndRequest::MsgEndRequest(uint32_t appStatus, ProtocolStatus protocolStatus)
+MsgEndRequest::MsgEndRequest(std::uint32_t appStatus, ProtocolStatus protocolStatus)
     : appStatus_{appStatus}
     , protocolStatus_{protocolStatus}
 {
@@ -16,7 +16,7 @@ std::size_t MsgEndRequest::size()
     return 8;
 }
 
-uint32_t MsgEndRequest::appStatus() const
+std::uint32_t MsgEndRequest::appStatus() const
 {
     return appStatus_;
 }
@@ -29,13 +29,13 @@ ProtocolStatus MsgEndRequest::protocolStatus() const
 void MsgEndRequest::toStream(std::ostream& output) const
 {
     auto encoder = Encoder(output);
-    encoder << appStatus_ << static_cast<uint8_t>(protocolStatus_);
+    encoder << appStatus_ << static_cast<std::uint8_t>(protocolStatus_);
     encoder.addPadding(3); //reserved bytes
 }
 
 void MsgEndRequest::fromStream(std::istream& input, std::size_t)
 {
-    auto protocolStatus = uint8_t{};
+    auto protocolStatus = std::uint8_t{};
     auto decoder = Decoder(input);
     decoder >> appStatus_ >> protocolStatus;
     decoder.skip(3); //reserved bytes

diff --git a/src/msgendrequest.h b/src/msgendrequest.h
@@ -1,5 +1,6 @@
 #pragma once
 #include "types.h"
+#include <cstdint>
 #include <istream>
 #include <ostream>
 
@@ -11,8 +12,8 @@ class MsgEndRequest {
 
 public:
     MsgEndRequest() = default;
-    MsgEndRequest(uint32_t appStatus, ProtocolStatus protocolStatus);
-    uint32_t appStatus() const;
+    MsgEndRequest(std::uint32_t appStatus, ProtocolStatus protocolStatus);
+    std::uint32_t appStatus() const;
     ProtocolStatus protocolStatus() const;
     static std::size_t size();
 
@@ -23,7 +24,7 @@ class MsgEndRequest {
     friend bool operator==(const MsgEndRequest& lhs, const MsgEndRequest& rhs);
 
 private:
-    uint32_t appStatus_ = 0;
+    std::uint32_t appStatus_ = 0;
     ProtocolStatus protocolStatus_ = ProtocolStatus::UnknownRole;
 };
 

diff --git a/src/msgunknowntype.cpp b/src/msgunknowntype.cpp
@@ -5,7 +5,7 @@
 
 namespace fcgi {
 
-MsgUnknownType::MsgUnknownType(uint8_t unknownTypeValue)
+MsgUnknownType::MsgUnknownType(std::uint8_t unknownTypeValue)
     : unknownTypeValue_{unknownTypeValue}
 {
 }
@@ -15,7 +15,7 @@ std::size_t MsgUnknownType::size()
     return 8;
 }
 
-uint8_t MsgUnknownType::unknownTypeValue() const
+std::uint8_t MsgUnknownType::unknownTypeValue() const
 {
     return unknownTypeValue_;
 }

diff --git a/src/msgunknowntype.h b/src/msgunknowntype.h
@@ -1,5 +1,6 @@
 #pragma once
 #include "types.h"
+#include <cstdint>
 #include <istream>
 #include <ostream>
 
@@ -11,8 +12,8 @@ class MsgUnknownType {
 
 public:
     MsgUnknownType() = default;
-    explicit MsgUnknownType(uint8_t unknownTypeValue);
-    uint8_t unknownTypeValue() const;
+    explicit MsgUnknownType(std::uint8_t unknownTypeValue);
+    std::uint8_t unknownTypeValue() const;
     static std::size_t size();
 
     void toStream(std::ostream& output) const;
@@ -22,7 +23,7 @@ class MsgUnknownType {
     friend bool operator==(const MsgUnknownType& lhs, const MsgUnknownType& rhs);
 
 private:
-    uint8_t unknownTypeValue_ = 0;
+    std::uint8_t unknownTypeValue_ = 0;
 };
 
 bool operator==(const MsgUnknownType& lhs, const MsgUnknownType& rhs);

diff --git a/src/namevalue.cpp b/src/namevalue.cpp
@@ -49,7 +49,7 @@ void NameValue::setValue(const std::string& value)
 
 namespace {
 
-uint32_t readLengthFromStream(std::istream& input)
+std::uint32_t readLengthFromStream(std::istream& input)
 {
     auto ch = char{};
     input.get(ch);
@@ -68,14 +68,14 @@ uint32_t readLengthFromStream(std::istream& input)
 
         length = ((lengthB3 & 0x7f) << 24) + (lengthB2 << 16) + (lengthB1 << 8) + lengthB0;
     }
-    return static_cast<uint32_t>(length);
+    return static_cast<std::uint32_t>(length);
 }
 
-void writeLengthToStream(uint32_t length, std::ostream& output)
+void writeLengthToStream(std::uint32_t length, std::ostream& output)
 {
     auto encoder = Encoder(output);
     if (length <= 127) {
-        encoder << static_cast<uint8_t>(length);
+        encoder << static_cast<std::uint8_t>(length);
     }
     else {
         length |= 0x80000000;
@@ -87,8 +87,8 @@ void writeLengthToStream(uint32_t length, std::ostream& output)
 
 void NameValue::toStream(std::ostream& output) const
 {
-    writeLengthToStream(static_cast<uint32_t>(name_.size()), output);
-    writeLengthToStream(static_cast<uint32_t>(value_.size()), output);
+    writeLengthToStream(static_cast<std::uint32_t>(name_.size()), output);
+    writeLengthToStream(static_cast<std::uint32_t>(value_.size()), output);
     auto encoder = Encoder(output);
     encoder << name_ << value_;
 }