MySqlLayer.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 MySqlMessageOrigin
    {
        Client,
        Server
    };
 
    class MySqlMessageType
    {
    public:
        enum Value : uint8_t
        {
            Client_HandshakeResponse,
            Client_Sleep,
            Client_Quit,
            Client_InitDb,
            Client_Query,
            Client_FieldList,
            Client_CreateDb,
            Client_DropDb,
            Client_Refresh,
            Client_Shutdown,
            Client_Statistics,
            Client_ProcessInfo,
            Client_Connect,
            Client_ProcessKill,
            Client_Debug,
            Client_Ping,
            Client_Time,
            Client_DelayedInsert,
            Client_ChangeUser,
            Client_BinlogDump,
            Client_TableDump,
            Client_ConnectOut,
            Client_RegisterSlave,
            Client_StmtPrepare,
            Client_StmtExecute,
            Client_StmtFetch,
            Client_StmtClose,
            Client_StmtReset,
            Client_SetOption,
            Client_StmtSendLongData,
            Client_Daemon,
            Client_BinlogDumpGtid,
            Client_ResetConnection,
            Client_Clone,
 
            Server_Handshake,
            Server_Ok,
            Server_AuthSwitchRequest,
            Server_EOF,
            Server_Error,
            Server_Data,
 
            Unknown
        };
 
        constexpr MySqlMessageType() : m_Value(Unknown)
        {}
 
        // cppcheck-suppress noExplicitConstructor
        constexpr MySqlMessageType(Value value) : m_Value(value)
        {}
 
        std::string toString() const;
 
        friend std::ostream& operator<<(std::ostream& os, const MySqlMessageType& messageType)
        {
            os << messageType.toString();
            return os;
        }
 
        explicit operator std::string() const
        {
            return toString();
        }
 
        MySqlMessageOrigin getOrigin() const;
 
        // Allow switch and comparisons
        constexpr operator Value() const
        {
            return m_Value;
        }
 
        // Prevent usage: if(MySqlMessageType)
        explicit operator bool() const = delete;
 
    private:
        Value m_Value;
    };
 
    class MySqlMessage
    {
    public:
        virtual ~MySqlMessage() = default;
 
        static std::unique_ptr<MySqlMessage> parseMySqlMessage(const uint8_t* data, size_t dataLen,
                                                               MySqlMessageOrigin origin);
 
        MySqlMessageType getMessageType() const
        {
            return m_MessageType;
        }
 
        MySqlMessageOrigin getMessageOrigin() const
        {
            return m_MessageOrigin;
        }
 
        virtual uint32_t getMessageLength() const;
 
        uint8_t getPacketNumber() const;
 
        size_t getTotalMessageLength() const
        {
            return m_DataLen;
        }
 
        virtual std::vector<uint8_t> getRawPayload() const;
 
    protected:
        MySqlMessage(const uint8_t* data, size_t dataLen, const MySqlMessageType& messageType,
                     MySqlMessageOrigin origin)
            : m_Data(data), m_DataLen(dataLen), m_MessageType(messageType), m_MessageOrigin(origin)
        {}
 
        static constexpr int basicMessageLength = 4;
        static constexpr int commandLength = 1;
        static constexpr int packetNumberIndex = 3;
        static constexpr int commandIndex = packetNumberIndex + 1;
 
        const uint8_t* m_Data;
        size_t m_DataLen;
        MySqlMessageType m_MessageType;
        MySqlMessageOrigin m_MessageOrigin;
    };
 
    class MySqlCommandMessage : public MySqlMessage
    {
        friend class MySqlMessage;
 
    public:
        uint32_t getMessageLength() const override;
        std::vector<uint8_t> getRawPayload() const override;
 
    protected:
        MySqlCommandMessage(const uint8_t* data, size_t dataLen, const MySqlMessageType& messageType,
                            MySqlMessageOrigin origin)
            : MySqlMessage(data, dataLen, messageType, origin)
        {}
    };
 
    class MySqlQueryMessage : public MySqlCommandMessage
    {
        friend class MySqlMessage;
 
    public:
        std::string getQuery() const;
 
    protected:
        MySqlQueryMessage(const uint8_t* data, size_t dataLen)
            : MySqlCommandMessage(data, dataLen, MySqlMessageType::Client_Query, MySqlMessageOrigin::Client)
        {}
 
    private:
        static constexpr int statementIndex = commandIndex + 3;
    };
 
    class MySqlErrorMessage : public MySqlCommandMessage
    {
        friend class MySqlMessage;
 
    public:
        uint16_t getErrorCode() const;
 
        std::string getSqlState() const;
 
        std::string getErrorMessage() const;
 
    protected:
        MySqlErrorMessage(const uint8_t* data, size_t dataLen)
            : MySqlCommandMessage(data, dataLen, MySqlMessageType::Server_Error, MySqlMessageOrigin::Server)
        {}
 
    private:
        static constexpr int errorCodeIndex = commandIndex + 1;
        static constexpr int sqlStateIndex = errorCodeIndex + sizeof(uint16_t) + 1;
        static constexpr int sqlStateSize = 5;
        static constexpr int errorMessageIndex = sqlStateIndex + sqlStateSize;
    };
 
    class MySqlLayer : public Layer
    {
    public:
        ~MySqlLayer() override = default;
 
        static bool isMySqlPort(uint16_t port)
        {
            return port == 3306;
        }
 
        static MySqlLayer* parseMySqlClientMessage(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet);
 
        static MySqlLayer* parseMySqlServerMessage(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet);
 
        MySqlMessageOrigin getMySqlOrigin() const
        {
            return m_MessageOrigin;
        }
 
        const PointerVector<MySqlMessage>& getMySqlMessages() const;
 
        const MySqlMessage* getMySqlMessage(const MySqlMessageType& messageType) const;
 
        template <class TMessage, std::enable_if_t<std::is_base_of<MySqlMessage, TMessage>::value, bool> = nullptr>
        const TMessage* getMySqlMessage() const
        {
            const auto& messages = getMySqlMessages();
            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:
        MySqlMessageOrigin m_MessageOrigin;
        mutable PointerVector<MySqlMessage> m_Messages;
        mutable bool m_MessagesInitialized = false;
 
        MySqlLayer(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet, MySqlMessageOrigin origin)
            : Layer(data, dataLen, prevLayer, packet, MySQL), m_MessageOrigin(origin)
        {}
    };
 
}  // namespace pcpp