PostgresLayer.h

Go to the documentation of this file.

#pragma once
 
#include "Layer.h"
#include "PointerVector.h"
#include <memory>
#include <ostream>
#include <unordered_map>
 
 
namespace pcpp
{
 
    enum class PostgresMessageOrigin
    {
        Frontend,
        Backend
    };
 
    class PostgresMessageType
    {
    public:
        enum Value : uint8_t
        {
            // Frontend (client) message types
 
            Frontend_StartupMessage,
            Frontend_SSLRequest,
            Frontend_CancelRequest,
            Frontend_GSSENCRequest,
            Frontend_Query,
            Frontend_Parse,
            Frontend_Bind,
            Frontend_Execute,
            Frontend_Close,
            Frontend_Describe,
            Frontend_FunctionCall,
            Frontend_Flush,
            Frontend_Sync,
            Frontend_CopyData,
            Frontend_CopyDone,
            Frontend_CopyFail,
            Frontend_Terminate,
            Frontend_Unknown,
 
            // Backend (server) message types
 
            Backend_AuthenticationOk,
            Backend_AuthenticationKerberosV4,
            Backend_AuthenticationKerberosV5,
            Backend_AuthenticationCleartextPassword,
            Backend_AuthenticationMD5Password,
            Backend_AuthenticationGSS,
            Backend_AuthenticationGSSContinue,
            Backend_AuthenticationSSPI,
            Backend_AuthenticationSASL,
            Backend_AuthenticationSASLContinue,
            Backend_AuthenticationSASLFinal,
            Backend_BackendKeyData,
            Backend_BindComplete,
            Backend_CloseComplete,
            Backend_CommandComplete,
            Backend_CopyData,
            Backend_CopyDone,
            Backend_CopyInResponse,
            Backend_CopyOutResponse,
            Backend_CopyBothResponse,
            Backend_DataRow,
            Backend_EmptyQueryResponse,
            Backend_ErrorResponse,
            Backend_FunctionCallResponse,
            Backend_NegotiateProtocolVersion,
            Backend_NoData,
            Backend_NoticeResponse,
            Backend_NotificationResponse,
            Backend_ParameterDescription,
            Backend_ParameterStatus,
            Backend_ParseComplete,
            Backend_PortalSuspended,
            Backend_ReadyForQuery,
            Backend_RowDescription,
            Backend_Unknown,
        };
 
        constexpr PostgresMessageType() : m_Value(Frontend_Unknown)
        {}
 
        // cppcheck-suppress noExplicitConstructor
        constexpr PostgresMessageType(Value value) : m_Value(value)
        {}
 
        char toChar() const;
 
        std::string toString() const;
 
        friend std::ostream& operator<<(std::ostream& os, const PostgresMessageType& messageType)
        {
            os << messageType.toString();
            return os;
        }
 
        explicit operator std::string() const
        {
            return toString();
        }
 
        PostgresMessageOrigin getOrigin() const;
 
        // Allow switch and comparisons
        constexpr operator Value() const
        {
            return m_Value;
        }
 
        // Prevent usage: if(PostgresMessageType)
        explicit operator bool() const = delete;
 
    private:
        Value m_Value;
    };
 
    class PostgresMessage
    {
    public:
        virtual ~PostgresMessage() = default;
 
        static std::unique_ptr<PostgresMessage> parsePostgresBackendMessage(const uint8_t* data, size_t dataLen);
 
        static std::unique_ptr<PostgresMessage> parsePostgresFrontendMessage(const uint8_t* data, size_t dataLen);
 
        PostgresMessageType getMessageType() const
        {
            return m_MessageType;
        }
 
        PostgresMessageOrigin getMessageOrigin() const
        {
            return m_MessageType.getOrigin();
        }
 
        uint32_t getMessageLength() const;
 
        size_t getTotalMessageLength() const
        {
            return m_DataLen;
        }
 
        std::vector<uint8_t> getRawPayload() const;
 
    protected:
        PostgresMessage(const uint8_t* data, size_t dataLen, const PostgresMessageType& messageType)
            : m_Data(data), m_DataLen(dataLen), m_MessageType(messageType)
        {}
 
        const uint8_t* m_Data;
        size_t m_DataLen;
        PostgresMessageType m_MessageType;
    };
 
    class PostgresStartupMessage : public PostgresMessage
    {
    public:
        using ParameterMap = std::unordered_map<std::string, std::string>;
 
        PostgresStartupMessage(const uint8_t* data, size_t dataLen)
            : PostgresMessage(data, dataLen, PostgresMessageType::Frontend_StartupMessage)
        {}
 
        uint32_t getProtocolVersion() const;
 
        uint16_t getProtocolMajorVersion() const;
 
        uint16_t getProtocolMinorVersion() const;
 
        const ParameterMap& getParameters() const;
 
        std::string getParameter(const std::string& name) const;
 
    private:
        static constexpr size_t ProtocolVersionOffset = 4;
        static constexpr size_t MinStartupMessageLength = 8;
 
        mutable ParameterMap m_Parameters;
        mutable bool m_ParametersParsed = false;
 
        std::string readString(size_t offset) const;
    };
 
    class PostgresParameterStatus : public PostgresMessage
    {
    public:
        PostgresParameterStatus(const uint8_t* data, size_t dataLen)
            : PostgresMessage(data, dataLen, PostgresMessageType::Backend_ParameterStatus)
        {}
 
        std::string getParameterName() const;
 
        std::string getParameterValue() const;
    };
 
    class PostgresQueryMessage : public PostgresMessage
    {
    public:
        PostgresQueryMessage(const uint8_t* data, size_t dataLen)
            : PostgresMessage(data, dataLen, PostgresMessageType::Frontend_Query)
        {}
 
        std::string getQuery() const;
    };
 
    class PostgresRowDescriptionMessage : public PostgresMessage
    {
    public:
        enum class PostgresColumnFormat
        {
            Text = 0,
            Binary = 1,
            Unknown = 2
        };
 
        struct PostgresColumnInfo
        {
            std::string name;
            uint32_t tableOID;
            uint16_t columnIndex;
            uint32_t typeOID;
            int16_t typeSize;
            int32_t typeModifier;
            PostgresColumnFormat format;
        };
 
        PostgresRowDescriptionMessage(const uint8_t* data, size_t dataLen)
            : PostgresMessage(data, dataLen, PostgresMessageType::Backend_RowDescription)
        {}
 
        std::vector<PostgresColumnInfo> getColumnInfos() const;
    };
 
    class PostgresDataRowMessage : public PostgresMessage
    {
    public:
        class ColumnData
        {
        public:
            ColumnData(const uint8_t* data, size_t dataLen) : m_Data(data), m_DataLen(dataLen)
            {}
 
            std::vector<uint8_t> getData() const
            {
                if (!m_Data)
                {
                    return {};
                }
                return { m_Data, m_Data + m_DataLen };
            }
 
            std::string toHexString() const;
 
            std::string toString() const;
 
            bool isNull() const
            {
                return m_Data == nullptr;
            }
 
        private:
            const uint8_t* m_Data;
            size_t m_DataLen;
        };
 
        PostgresDataRowMessage(const uint8_t* data, size_t dataLen)
            : PostgresMessage(data, dataLen, PostgresMessageType::Backend_DataRow)
        {}
 
        std::vector<ColumnData> getDataRow() const;
    };
 
    class PostgresErrorResponseMessage : public PostgresMessage
    {
    public:
        enum class ErrorField : uint8_t
        {
            Severity = 'S',
            SeverityNonLocalized = 'V',
            SQLState = 'C',
            Message = 'M',
            Detail = 'D',
            Hint = 'H',
            Position = 'P',
            InternalPosition = 'p',
            InternalQuery = 'q',
            Where = 'W',
            Schema = 's',
            Table = 't',
            Column = 'c',
            DataType = 'd',
            Constraint = 'n',
            File = 'F',
            Line = 'L',
            Routine = 'R',
            Terminator = '\0'
        };
 
        using FieldMap = std::unordered_map<ErrorField, std::string>;
 
        PostgresErrorResponseMessage(const uint8_t* data, size_t dataLen)
            : PostgresMessage(data, dataLen, PostgresMessageType::Backend_ErrorResponse)
        {}
 
        const FieldMap& getFields() const;
 
    private:
        mutable FieldMap m_Fields;
        mutable bool m_FieldsParsed = false;
    };
 
    class PostgresLayer : public Layer
    {
    public:
        ~PostgresLayer() override = default;
 
        static bool isPostgresPort(uint16_t port)
        {
            return port == 5432;
        }
 
        static PostgresLayer* parsePostgresBackendMessages(uint8_t* data, size_t dataLen, Layer* prevLayer,
                                                           Packet* packet);
 
        static PostgresLayer* parsePostgresFrontendMessages(uint8_t* data, size_t dataLen, Layer* prevLayer,
                                                            Packet* packet);
 
        PostgresMessageOrigin getPostgresOrigin() const
        {
            return m_MessageOrigin;
        }
 
        const PointerVector<PostgresMessage>& getPostgresMessages() const;
 
        const PostgresMessage* getPostgresMessage(const PostgresMessageType& messageType) const;
 
        template <class TMessage, std::enable_if_t<std::is_base_of<PostgresMessage, TMessage>::value, bool> = nullptr>
        const TMessage* getPostgresMessage() const
        {
            const auto& messages = getPostgresMessages();
            for (const auto& msg : messages)
            {
                auto result = dynamic_cast<const TMessage*>(msg);
                if (result != nullptr)
                {
                    return result;
                }
            }
            return nullptr;
        }
 
        // Overridden methods
 
        size_t getHeaderLen() const override
        {
            return m_DataLen;
        }
 
        void parseNextLayer() override
        {}
 
        void computeCalculateFields() override
        {}
 
        OsiModelLayer getOsiModelLayer() const override
        {
            return OsiModelApplicationLayer;
        }
 
        std::string toString() const override;
 
    private:
        PostgresMessageOrigin m_MessageOrigin;
        mutable PointerVector<PostgresMessage> m_Messages;
        mutable bool m_MessagesInitialized = false;
 
        PostgresLayer(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet,
                      PostgresMessageOrigin messageOrigin)
            : Layer(data, dataLen, prevLayer, packet, Postgres), m_MessageOrigin(messageOrigin)
        {}
    };
}  // namespace pcpp