diff --git a/Common++/header/DeprecationUtils.h b/Common++/header/DeprecationUtils.h index fd2ac2d6e2..afdc20cb18 100644 --- a/Common++/header/DeprecationUtils.h +++ b/Common++/header/DeprecationUtils.h @@ -3,12 +3,35 @@ /// @file #ifndef PCPP_DEPRECATED -#if defined(__GNUC__) || defined(__clang__) -#define PCPP_DEPRECATED __attribute__((deprecated)) -#elif defined(_MSC_VER) -#define PCPP_DEPRECATED __declspec(deprecated) -#else -#pragma message("WARNING: DEPRECATED feature is not implemented for this compiler") -#define PCPP_DEPRECATED + #if defined(__GNUC__) || defined(__clang__) + #define PCPP_DEPRECATED(msg) __attribute__((deprecated(msg))) + #elif defined(_MSC_VER) + #define PCPP_DEPRECATED(msg) __declspec(deprecated(msg)) + #else + #pragma message("WARNING: DEPRECATED feature is not implemented for this compiler") + #define PCPP_DEPRECATED(msg) + #endif #endif + +#if !defined(DISABLE_WARNING_PUSH) || !defined(DISABLE_WARNING_POP) + #if defined(_MSC_VER) + #define DISABLE_WARNING_PUSH __pragma(warning( push )) + #define DISABLE_WARNING_POP __pragma(warning( pop )) + #define DISABLE_WARNING(warningNumber) __pragma(warning( disable : warningNumber )) + + #define DISABLE_WARNING_DEPRECATED DISABLE_WARNING(4996) + #elif defined(__GNUC__) || defined(__clang__) + #define DO_PRAGMA(X) _Pragma(#X) + #define DISABLE_WARNING_PUSH DO_PRAGMA(GCC diagnostic push) + #define DISABLE_WARNING_POP DO_PRAGMA(GCC diagnostic pop) + #define DISABLE_WARNING(warningName) DO_PRAGMA(GCC diagnostic ignored #warningName) + + #define DISABLE_WARNING_DEPRECATED DISABLE_WARNING(-Wdeprecated-declarations) + #else + #pragma message("WARNING: Disabling of warnings is not implemented for this compiler") + #define DISABLE_WARNING_PUSH + #define DISABLE_WARNING_POP + + #define DISABLE_WARNING_DEPRECATED + #endif #endif diff --git a/Examples/Tutorials/Tutorial-PacketCraftAndEdit/main.cpp b/Examples/Tutorials/Tutorial-PacketCraftAndEdit/main.cpp index 3e6a2ce23b..71823e5748 100644 --- a/Examples/Tutorials/Tutorial-PacketCraftAndEdit/main.cpp +++ b/Examples/Tutorials/Tutorial-PacketCraftAndEdit/main.cpp @@ -70,7 +70,7 @@ int main(int argc, char* argv[]) // add URG flag tcpLayer->getTcpHeader()->urgFlag = 1; // add MSS TCP option - tcpLayer->addTcpOptionAfter(pcpp::TcpOptionBuilder(pcpp::TCPOPT_MSS, (uint16_t)1460)); + tcpLayer->insertTcpOptionAfter(pcpp::TcpOptionBuilder(pcpp::TcpOptionEnumType::Mss, (uint16_t)1460)); // let's get the HTTP layer auto* httpRequestLayer = parsedPacket.getLayerOfType(); diff --git a/Examples/Tutorials/Tutorial-PacketParsing/main.cpp b/Examples/Tutorials/Tutorial-PacketParsing/main.cpp index b1d81a8898..15999f00c4 100644 --- a/Examples/Tutorials/Tutorial-PacketParsing/main.cpp +++ b/Examples/Tutorials/Tutorial-PacketParsing/main.cpp @@ -42,13 +42,13 @@ std::string printTcpFlags(pcpp::TcpLayer* tcpLayer) return result; } -std::string printTcpOptionType(pcpp::TcpOptionType optionType) +std::string printTcpOptionType(pcpp::TcpOptionEnumType optionType) { switch (optionType) { - case pcpp::PCPP_TCPOPT_NOP: + case pcpp::TcpOptionEnumType::Nop: return "NOP"; - case pcpp::PCPP_TCPOPT_TIMESTAMP: + case pcpp::TcpOptionEnumType::Timestamp: return "Timestamp"; default: return "Other"; @@ -160,7 +160,7 @@ int main(int argc, char* argv[]) std::cout << "TCP options: "; for (pcpp::TcpOption tcpOption = tcpLayer->getFirstTcpOption(); tcpOption.isNotNull(); tcpOption = tcpLayer->getNextTcpOption(tcpOption)) { - std::cout << printTcpOptionType(tcpOption.getTcpOptionType()) << " "; + std::cout << printTcpOptionType(tcpOption.getTcpOptionEnumType()) << " "; } std::cout << std::endl; diff --git a/Packet++/header/HttpLayer.h b/Packet++/header/HttpLayer.h index b6f6d6afb6..41784e0549 100644 --- a/Packet++/header/HttpLayer.h +++ b/Packet++/header/HttpLayer.h @@ -514,7 +514,8 @@ namespace pcpp * default status code string * @deprecated Use other constructors instead. */ - PCPP_DEPRECATED explicit HttpResponseLayer(HttpVersion version, const HttpResponseStatusCode& statusCode, const std::string& statusCodeString); + PCPP_DEPRECATED("Use other constructors instead") + explicit HttpResponseLayer(HttpVersion version, const HttpResponseStatusCode& statusCode, const std::string& statusCodeString); /** * A constructor that allocates a new HTTP response header with only the first line filled. Object will be created without further fields. @@ -732,7 +733,8 @@ namespace pcpp * @return True if setting the status code was completed successfully, false otherwise * @deprecated Use the other overload instead. */ - PCPP_DEPRECATED bool setStatusCode(const HttpResponseStatusCode& newStatusCode, const std::string& statusCodeString); + PCPP_DEPRECATED("Use the other overload instead") + bool setStatusCode(const HttpResponseStatusCode& newStatusCode, const std::string& statusCodeString); /** * Set the status code diff --git a/Packet++/header/TcpLayer.h b/Packet++/header/TcpLayer.h index f17832a90b..8efad58c79 100644 --- a/Packet++/header/TcpLayer.h +++ b/Packet++/header/TcpLayer.h @@ -1,9 +1,15 @@ #pragma once +#include "DeprecationUtils.h" #include "Layer.h" #include "TLVData.h" #include +#ifndef PCPP_DEPRECATED_TCP_OPTION_TYPE +#define PCPP_DEPRECATED_TCP_OPTION_TYPE PCPP_DEPRECATED("enum TcpOptionType is deprecated; " \ + "Use enum class TcpOptionEnumType instead") +#endif + /// @file /** @@ -98,9 +104,9 @@ namespace pcpp TCPOPT_SACK_PERM = 4, /** SACK Block */ PCPP_TCPOPT_SACK = 5, - /** Echo (obsoleted by option ::PCPP_TCPOPT_TIMESTAMP) */ + /** Echo (obsoleted by option TcpOptionType::PCPP_TCPOPT_TIMESTAMP) */ TCPOPT_ECHO = 6, - /** Echo Reply (obsoleted by option ::PCPP_TCPOPT_TIMESTAMP) */ + /** Echo Reply (obsoleted by option TcpOptionType::PCPP_TCPOPT_TIMESTAMP) */ TCPOPT_ECHOREPLY = 7, /** TCP Timestamps */ PCPP_TCPOPT_TIMESTAMP = 8, @@ -138,54 +144,111 @@ namespace pcpp TCPOPT_Unknown = 255 }; + /** + * TCP options types + */ + enum class TcpOptionEnumType : uint8_t + { + /** Padding */ + Nop = 1, + /** End of options */ + Eol = 0, + /** Segment size negotiating */ + Mss = 2, + /** Window scaling */ + Window = 3, + /** SACK Permitted */ + SackPerm = 4, + /** SACK Block */ + Sack = 5, + /** Echo (obsoleted by option TcpOptionEnumType::Timestamp) */ + Echo = 6, + /** Echo Reply (obsoleted by option TcpOptionEnumType::Timestamp) */ + EchoReply = 7, + /** TCP Timestamps */ + Timestamp = 8, + /** CC (obsolete) */ + Cc = 11, + /** CC.NEW (obsolete) */ + CcNew = 12, + /** CC.ECHO(obsolete) */ + CcEcho = 13, + /** MD5 Signature Option */ + Md5 = 19, + /** Multipath TCP */ + MpTcp = 0x1e, + /** SCPS Capabilities */ + Scps = 20, + /** SCPS SNACK */ + Snack = 21, + /** SCPS Record Boundary */ + RecBound = 22, + /** SCPS Corruption Experienced */ + CorrExp = 23, + /** Quick-Start Response */ + Qs = 27, + /** User Timeout Option (also, other known unauthorized use) */ + UserTo = 28, + /** RFC3692-style Experiment 1 (also improperly used for shipping products) */ + ExpFd = 0xfd, + /** RFC3692-style Experiment 2 (also improperly used for shipping products) */ + ExpFe = 0xfe, + /** Riverbed probe option, non IANA registered option number */ + RvbdProbe = 76, + /** Riverbed transparency option, non IANA registered option number */ + RvbdTrpy = 78, + /** Unknown option */ + Unknown = 255 + }; + // TCP option lengths - /** pcpp::PCPP_TCPOPT_NOP length */ + /** pcpp::TcpOptionEnumType::Nop length */ #define PCPP_TCPOLEN_NOP 1 - /** pcpp::PCPP_TCPOPT_EOL length */ + /** pcpp::TcpOptionEnumType::Eol length */ #define PCPP_TCPOLEN_EOL 1 - /** pcpp::TCPOPT_MSS length */ + /** pcpp::TcpOptionEnumType::Mss length */ #define PCPP_TCPOLEN_MSS 4 - /** pcpp::PCPP_TCPOPT_WINDOW length */ + /** pcpp::TcpOptionEnumType::Window length */ #define PCPP_TCPOLEN_WINDOW 3 - /** pcpp::TCPOPT_SACK_PERM length */ + /** pcpp::TcpOptionEnumType::SackPerm length */ #define PCPP_TCPOLEN_SACK_PERM 2 - /** pcpp::PCPP_TCPOPT_SACK length */ + /** pcpp::TcpOptionEnumType::Sack length */ #define PCPP_TCPOLEN_SACK_MIN 2 - /** pcpp::TCPOPT_ECHO length */ + /** pcpp::TcpOptionEnumType::Echo length */ #define PCPP_TCPOLEN_ECHO 6 - /** pcpp::TCPOPT_ECHOREPLY length */ + /** pcpp::TcpOptionEnumType::EchoReply length */ #define PCPP_TCPOLEN_ECHOREPLY 6 - /** pcpp::PCPP_TCPOPT_TIMESTAMP length */ + /** pcpp::TcpOptionEnumType::Timestamp length */ #define PCPP_TCPOLEN_TIMESTAMP 10 - /** pcpp::TCPOPT_CC length */ + /** pcpp::TcpOptionEnumType::Cc length */ #define PCPP_TCPOLEN_CC 6 - /** pcpp::TCPOPT_CCNEW length */ + /** pcpp::TcpOptionEnumType::CcNew length */ #define PCPP_TCPOLEN_CCNEW 6 - /** pcpp::TCPOPT_CCECHO length */ + /** pcpp::TcpOptionEnumType::CcEcho length */ #define PCPP_TCPOLEN_CCECHO 6 - /** pcpp::TCPOPT_MD5 length */ + /** pcpp::TcpOptionEnumType::Md5 length */ #define PCPP_TCPOLEN_MD5 18 - /** pcpp::TCPOPT_MPTCP length */ + /** pcpp::TcpOptionEnumType::MpTcp length */ #define PCPP_TCPOLEN_MPTCP_MIN 8 - /** pcpp::TCPOPT_SCPS length */ + /** pcpp::TcpOptionEnumType::Scps length */ #define PCPP_TCPOLEN_SCPS 4 - /** pcpp::TCPOPT_SNACK length */ + /** pcpp::TcpOptionEnumType::Snack length */ #define PCPP_TCPOLEN_SNACK 6 - /** pcpp::TCPOPT_RECBOUND length */ + /** pcpp::TcpOptionEnumType::RecBound length */ #define PCPP_TCPOLEN_RECBOUND 2 - /** pcpp::TCPOPT_CORREXP length */ + /** pcpp::TcpOptionEnumType::CorrExp length */ #define PCPP_TCPOLEN_CORREXP 2 - /** pcpp::TCPOPT_QS length */ + /** pcpp::TcpOptionEnumType::Qs length */ #define PCPP_TCPOLEN_QS 8 - /** pcpp::TCPOPT_USER_TO length */ + /** pcpp::TcpOptionEnumType::UserTo length */ #define PCPP_TCPOLEN_USER_TO 4 - /** pcpp::TCPOPT_RVBD_PROBE length */ + /** pcpp::TcpOptionEnumType::RvbdProbe length */ #define PCPP_TCPOLEN_RVBD_PROBE_MIN 3 - /** pcpp::TCPOPT_RVBD_TRPY length */ + /** pcpp::TcpOptionEnumType::RvbdTrpy length */ #define PCPP_TCPOLEN_RVBD_TRPY_MIN 16 - /** pcpp::TCPOPT_EXP_FD and pcpp::TCPOPT_EXP_FE length */ + /** pcpp::TcpOptionEnumType::ExpFd and pcpp::TcpOptionEnumType::ExpFe length */ #define PCPP_TCPOLEN_EXP_MIN 2 @@ -208,17 +271,26 @@ namespace pcpp /** * A d'tor for this class, currently does nothing */ - ~TcpOption() { } + ~TcpOption() = default; /** - * @return TCP option type casted as pcpp::TcpOptionType enum. If the data is null a value - * of ::TCPOPT_Unknown is returned + * @deprecated This method is deprecated, please use getTcpOptionEnumType() */ + PCPP_DEPRECATED("Use getTcpOptionEnumType instead") TcpOptionType getTcpOptionType() const { return getTcpOptionType(m_Data); } + /** + * @return TCP option type casted as pcpp::TcpOptionEnumType enum. If the data is null a value + * of TcpOptionEnumType::Unknown is returned + */ + TcpOptionEnumType getTcpOptionEnumType() const + { + return getTcpOptionEnumType(m_Data); + } + /** * Check if a pointer can be assigned to the TLV record data * @param[in] recordRawData A pointer to the TLV record raw data @@ -234,8 +306,8 @@ namespace pcpp if (tlvDataLen < sizeof(TLVRawData::recordType)) return false; - const auto recordType = getTcpOptionType(data); - if (recordType == TcpOptionType::PCPP_TCPOPT_NOP || recordType == TcpOptionType::PCPP_TCPOPT_EOL) + const auto recordType = getTcpOptionEnumType(data); + if (recordType == TcpOptionEnumType::Nop || recordType == TcpOptionEnumType::Eol) return true; return TLVRecord::canAssign(recordRawData, tlvDataLen); @@ -248,8 +320,8 @@ namespace pcpp if (m_Data == nullptr) return 0; - const auto recordType = getTcpOptionType(m_Data); - if (recordType == TcpOptionType::PCPP_TCPOPT_NOP || recordType == TcpOptionType::PCPP_TCPOPT_EOL) + const auto recordType = getTcpOptionEnumType(m_Data); + if (recordType == TcpOptionEnumType::Nop || recordType == TcpOptionEnumType::Eol) return sizeof(uint8_t); return static_cast(m_Data->recordLen); @@ -260,8 +332,8 @@ namespace pcpp if (m_Data == nullptr) return 0; - const auto recordType = getTcpOptionType(m_Data); - if (recordType == TcpOptionType::PCPP_TCPOPT_NOP || recordType == TcpOptionType::PCPP_TCPOPT_EOL) + const auto recordType = getTcpOptionEnumType(m_Data); + if (recordType == TcpOptionEnumType::Nop || recordType == TcpOptionEnumType::Eol) return 0; return static_cast(m_Data->recordLen) - (2*sizeof(uint8_t)); @@ -275,6 +347,14 @@ namespace pcpp return static_cast(optionRawData->recordType); } + + static TcpOptionEnumType getTcpOptionEnumType(const TLVRawData* optionRawData) + { + if (optionRawData == nullptr) + return TcpOptionEnumType::Unknown; + + return static_cast(optionRawData->recordType); + } }; @@ -299,6 +379,24 @@ namespace pcpp EOL }; + /** + * An enum to describe NOP and EOL TCP options. Used in one of this class's c'tors + */ + enum class NopEolOptionEnumType : uint8_t + { + /** NOP TCP option */ + Nop, + /** EOL TCP option */ + Eol + }; + + /** + * @deprecated This method is deprecated, please use constructor with TcpOptionEnumType + */ + PCPP_DEPRECATED_TCP_OPTION_TYPE + TcpOptionBuilder(TcpOptionType optionType, const uint8_t* optionValue, uint8_t optionValueLen) : + TLVRecordBuilder((uint8_t)optionType, optionValue, optionValueLen) {} + /** * A c'tor for building TCP options which their value is a byte array. The TcpOption object can be later * retrieved by calling build() @@ -306,8 +404,16 @@ namespace pcpp * @param[in] optionValue A buffer containing the option value. This buffer is read-only and isn't modified in any way. * @param[in] optionValueLen Option value length in bytes */ - TcpOptionBuilder(TcpOptionType optionType, const uint8_t* optionValue, uint8_t optionValueLen) : - TLVRecordBuilder((uint8_t)optionType, optionValue, optionValueLen) {} + TcpOptionBuilder(TcpOptionEnumType optionType, const uint8_t* optionValue, uint8_t optionValueLen) : + TLVRecordBuilder(static_cast(optionType), optionValue, optionValueLen) {} + + /** + * @deprecated This method is deprecated, please use constructor with TcpOptionEnumType + */ + PCPP_DEPRECATED_TCP_OPTION_TYPE + TcpOptionBuilder(TcpOptionType optionType, uint8_t optionValue) : + TLVRecordBuilder((uint8_t)optionType, optionValue) {} + /** * A c'tor for building TCP options which have a 1-byte value. The TcpOption object can be later retrieved @@ -315,7 +421,14 @@ namespace pcpp * @param[in] optionType TCP option type * @param[in] optionValue A 1-byte option value */ - TcpOptionBuilder(TcpOptionType optionType, uint8_t optionValue) : + TcpOptionBuilder(TcpOptionEnumType optionType, uint8_t optionValue) : + TLVRecordBuilder(static_cast(optionType), optionValue) {} + + /** + * @deprecated This method is deprecated, please use constructor with TcpOptionEnumType + */ + PCPP_DEPRECATED_TCP_OPTION_TYPE + TcpOptionBuilder(TcpOptionType optionType, uint16_t optionValue) : TLVRecordBuilder((uint8_t)optionType, optionValue) {} /** @@ -324,7 +437,14 @@ namespace pcpp * @param[in] optionType TCP option type * @param[in] optionValue A 2-byte option value */ - TcpOptionBuilder(TcpOptionType optionType, uint16_t optionValue) : + TcpOptionBuilder(TcpOptionEnumType optionType, uint16_t optionValue) : + TLVRecordBuilder(static_cast(optionType), optionValue) {} + + /** + * @deprecated This method is deprecated, please use constructor with TcpOptionEnumType + */ + PCPP_DEPRECATED_TCP_OPTION_TYPE + TcpOptionBuilder(TcpOptionType optionType, uint32_t optionValue) : TLVRecordBuilder((uint8_t)optionType, optionValue) {} /** @@ -333,8 +453,14 @@ namespace pcpp * @param[in] optionType TCP option type * @param[in] optionValue A 4-byte option value */ - TcpOptionBuilder(TcpOptionType optionType, uint32_t optionValue) : - TLVRecordBuilder((uint8_t)optionType, optionValue) {} + TcpOptionBuilder(TcpOptionEnumType optionType, uint32_t optionValue) : + TLVRecordBuilder(static_cast(optionType), optionValue) {} + + /** + * @deprecated This method is deprecated, please use constructor with NopEolOptionEnumType + */ + PCPP_DEPRECATED("enum NopEolOptionTypes is deprecated; Use enum class NopEolOptionEnumType instead") + explicit TcpOptionBuilder(NopEolOptionTypes optionType); /** * A c'tor for building TCP NOP and EOL options. These option types are special in that they contain only 1 byte @@ -342,7 +468,7 @@ namespace pcpp * by calling build() * @param[in] optionType An enum value indicating which option type to build (NOP or EOL) */ - explicit TcpOptionBuilder(NopEolOptionTypes optionType); + explicit TcpOptionBuilder(NopEolOptionEnumType optionType); /** * Build the TcpOption object out of the parameters defined in the c'tor @@ -380,7 +506,7 @@ namespace pcpp */ TcpLayer(uint16_t portSrc, uint16_t portDst); - ~TcpLayer() {} + ~TcpLayer() = default; /** * A copy constructor that copy the entire header from the other TcpLayer (including TCP options) @@ -408,13 +534,19 @@ namespace pcpp */ uint16_t getDstPort() const; + /** + * @deprecated This method is deprecated, please use getTcpOption(TcpOptionEnumType option) + */ + PCPP_DEPRECATED_TCP_OPTION_TYPE + TcpOption getTcpOption(TcpOptionType option) const; + /** * Get a TCP option by type * @param[in] option TCP option type to retrieve * @return An TcpOption object that contains the first option that matches this type, or logical NULL * (TcpOption#isNull() == true) if no such option found */ - TcpOption getTcpOption(TcpOptionType option) const; + TcpOption getTcpOption(TcpOptionEnumType option) const; /** * @return The first TCP option in the packet. If the current layer contains no options the returned value will contain @@ -446,15 +578,27 @@ namespace pcpp TcpOption addTcpOption(const TcpOptionBuilder& optionBuilder); /** - * Add a new TCP option after an existing one - * @param[in] optionBuilder A TcpOptionBuilder object that contains the requested TCP option data to be added - * @param[in] prevOptionType The TCP option which the newly added option should come after. This is an optional parameter which - * gets a default value of ::TCPOPT_Unknown if omitted, which means the new option will be added as the first option in the layer - * @return A TcpOption object containing the newly added TCP option data or logical NULL - * (TcpOption#isNull() == true) if addition failed. In case of a failure a corresponding error message will be + * @deprecated This method is deprecated, please use insertTcpOptionAfter(const TcpOptionBuilder& optionBuilder, TcpOptionEnumType prevOptionType = TcpOptionEnumType::Unknown) + */ + PCPP_DEPRECATED("Use insertTcpOptionAfter instead") + TcpOption addTcpOptionAfter(const TcpOptionBuilder& optionBuilder, TcpOptionType prevOptionType = TcpOptionType::TCPOPT_Unknown); + + /** + * Insert a new TCP option after an existing one + * @param[in] optionBuilder A TcpOptionBuilder object that contains the requested TCP option data to be inserted + * @param[in] prevOptionType The TCP option which the newly inserted option should come after. This is an optional parameter which + * gets a default value of TcpOptionType::Unknown if omitted, which means the new option will be inserted as the first option in the layer + * @return A TcpOption object containing the newly inserted TCP option data or logical NULL + * (TcpOption#isNull() == true) if insertion failed. In case of a failure a corresponding error message will be * printed to log */ - TcpOption addTcpOptionAfter(const TcpOptionBuilder& optionBuilder, TcpOptionType prevOptionType = TCPOPT_Unknown); + TcpOption insertTcpOptionAfter(const TcpOptionBuilder& optionBuilder, TcpOptionEnumType prevOptionType = TcpOptionEnumType::Unknown); + + /** + * @deprecated This method is deprecated, please use removeTcpOption(TcpOptionEnumType) + */ + PCPP_DEPRECATED_TCP_OPTION_TYPE + bool removeTcpOption(TcpOptionType optionType); /** * Remove an existing TCP option from the layer. TCP option is found by type @@ -462,7 +606,7 @@ namespace pcpp * @return True if TCP option was removed or false if type wasn't found or if removal failed (in each case a proper error * will be written to log) */ - bool removeTcpOption(TcpOptionType optionType); + bool removeTcpOption(TcpOptionEnumType optionType); /** * Remove all TCP options in this layer @@ -531,3 +675,5 @@ namespace pcpp && dataLen >= hdr->dataOffset * sizeof(uint32_t); } } // namespace pcpp + +#undef PCPP_DEPRECATED_TCP_OPTION_TYPE diff --git a/Packet++/src/TcpLayer.cpp b/Packet++/src/TcpLayer.cpp index abd463463c..85bc08d871 100644 --- a/Packet++/src/TcpLayer.cpp +++ b/Packet++/src/TcpLayer.cpp @@ -18,6 +18,7 @@ #include "SmtpLayer.h" #include "PacketUtils.h" #include "Logger.h" +#include "DeprecationUtils.h" #include #include @@ -44,12 +45,26 @@ TcpOptionBuilder::TcpOptionBuilder(NopEolOptionTypes optionType) } } +TcpOptionBuilder::TcpOptionBuilder(const NopEolOptionEnumType optionType) +{ + switch (optionType) + { + case NopEolOptionEnumType::Eol: + init(static_cast(TcpOptionEnumType::Eol), nullptr, 0); + break; + case NopEolOptionEnumType::Nop: + default: + init(static_cast(TcpOptionEnumType::Nop), nullptr, 0); + break; + } +} + TcpOption TcpOptionBuilder::build() const { uint8_t recType = static_cast(m_RecType); size_t optionSize = m_RecValueLen + 2*sizeof(uint8_t); - if (recType == static_cast(PCPP_TCPOPT_EOL) || recType == static_cast(PCPP_TCPOPT_NOP)) + if (recType == static_cast(TcpOptionEnumType::Eol) || recType == static_cast(TcpOptionEnumType::Nop)) { if (m_RecValueLen != 0) { @@ -89,7 +104,7 @@ uint16_t TcpLayer::getDstPort() const return be16toh(getTcpHeader()->portDst); } -TcpOption TcpLayer::getTcpOption(TcpOptionType option) const +TcpOption TcpLayer::getTcpOption(const TcpOptionEnumType option) const { return m_OptionReader.getTLVRecord(static_cast(option), getOptionsBasePtr(), getHeaderLen() - sizeof(tcphdr)); } @@ -118,17 +133,17 @@ TcpOption TcpLayer::addTcpOption(const TcpOptionBuilder& optionBuilder) return addTcpOptionAt(optionBuilder, getHeaderLen()-m_NumOfTrailingBytes); } -TcpOption TcpLayer::addTcpOptionAfter(const TcpOptionBuilder& optionBuilder, TcpOptionType prevOptionType) +TcpOption TcpLayer::insertTcpOptionAfter(const TcpOptionBuilder& optionBuilder, const TcpOptionEnumType prevOptionType) { int offset = 0; - if (prevOptionType == TCPOPT_Unknown) + if (prevOptionType == TcpOptionEnumType::Unknown) { offset = sizeof(tcphdr); } else { - TcpOption prevOpt = getTcpOption(prevOptionType); + const TcpOption prevOpt = getTcpOption(prevOptionType); if (prevOpt.isNull()) { PCPP_LOG_ERROR("Previous option of type " << static_cast(prevOptionType) << " not found, cannot add a new TCP option"); @@ -141,9 +156,9 @@ TcpOption TcpLayer::addTcpOptionAfter(const TcpOptionBuilder& optionBuilder, Tcp return addTcpOptionAt(optionBuilder, offset); } -bool TcpLayer::removeTcpOption(TcpOptionType optionType) +bool TcpLayer::removeTcpOption(const TcpOptionEnumType optionType) { - TcpOption opt = getTcpOption(optionType); + const TcpOption opt = getTcpOption(optionType); if (opt.isNull()) { return false; @@ -176,7 +191,7 @@ bool TcpLayer::removeTcpOption(TcpOptionType optionType) bool TcpLayer::removeAllTcpOptions() { - int offset = sizeof(tcphdr); + const int offset = sizeof(tcphdr); if (!shortenLayer(offset, getHeaderLen()-offset)) return false; @@ -187,7 +202,7 @@ bool TcpLayer::removeAllTcpOptions() return true; } -TcpOption TcpLayer::addTcpOptionAt(const TcpOptionBuilder& optionBuilder, int offset) +TcpOption TcpLayer::addTcpOptionAt(const TcpOptionBuilder& optionBuilder, const int offset) { TcpOption newOption = optionBuilder.build(); if (newOption.isNull()) @@ -225,7 +240,7 @@ TcpOption TcpLayer::addTcpOptionAt(const TcpOptionBuilder& optionBuilder, int of return TcpOption(newOptPtr); } -void TcpLayer::adjustTcpOptionTrailer(size_t totalOptSize) +void TcpLayer::adjustTcpOptionTrailer(const size_t totalOptSize) { int newNumberOfTrailingBytes = 0; while ((totalOptSize + newNumberOfTrailingBytes) % 4 != 0) @@ -244,7 +259,7 @@ void TcpLayer::adjustTcpOptionTrailer(size_t totalOptSize) getTcpHeader()->dataOffset = (sizeof(tcphdr) + totalOptSize + m_NumOfTrailingBytes)/4; } -uint16_t TcpLayer::calculateChecksum(bool writeResultToPacket) +uint16_t TcpLayer::calculateChecksum(const bool writeResultToPacket) { tcphdr* tcpHdr = getTcpHeader(); uint16_t checksumRes = 0; @@ -295,7 +310,7 @@ void TcpLayer::initLayer() getTcpHeader()->dataOffset = sizeof(tcphdr)/4; } -TcpLayer::TcpLayer(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet) : Layer(data, dataLen, prevLayer, packet) +TcpLayer::TcpLayer(uint8_t* data, const size_t dataLen, Layer* prevLayer, Packet* packet) : Layer(data, dataLen, prevLayer, packet) { m_Protocol = TCP; m_NumOfTrailingBytes = 0; @@ -306,7 +321,7 @@ TcpLayer::TcpLayer() initLayer(); } -TcpLayer::TcpLayer(uint16_t portSrc, uint16_t portDst) +TcpLayer::TcpLayer(const uint16_t portSrc, const uint16_t portDst) { initLayer(); getTcpHeader()->portDst = htobe16(portDst); @@ -431,4 +446,72 @@ std::string TcpLayer::toString() const return result; } +/// ~~~~~~~~ +/// TcpLayer Deprecated Code +/// ~~~~~~~~ + +DISABLE_WARNING_PUSH +DISABLE_WARNING_DEPRECATED +TcpOption TcpLayer::addTcpOptionAfter(const TcpOptionBuilder& optionBuilder, TcpOptionType prevOptionType) +{ + int offset = 0; + + if (prevOptionType == TcpOptionType::TCPOPT_Unknown) + { + offset = sizeof(tcphdr); + } + else + { + TcpOption prevOpt = getTcpOption(prevOptionType); + if (prevOpt.isNull()) + { + PCPP_LOG_ERROR("Previous option of type " << static_cast(prevOptionType) << " not found, cannot add a new TCP option"); + return TcpOption(nullptr); + } + + offset = prevOpt.getRecordBasePtr() + prevOpt.getTotalSize() - m_Data; + } + + return addTcpOptionAt(optionBuilder, offset); +} + +TcpOption TcpLayer::getTcpOption(TcpOptionType option) const +{ + return m_OptionReader.getTLVRecord(static_cast(option), getOptionsBasePtr(), getHeaderLen() - sizeof(tcphdr)); +} + +bool TcpLayer::removeTcpOption(TcpOptionType optionType) +{ + TcpOption opt = getTcpOption(optionType); + if (opt.isNull()) + { + return false; + } + + // calculate total TCP option size + TcpOption curOpt = getFirstTcpOption(); + size_t totalOptSize = 0; + while (!curOpt.isNull()) + { + totalOptSize += curOpt.getTotalSize(); + curOpt = getNextTcpOption(curOpt); + } + totalOptSize -= opt.getTotalSize(); + + + int offset = opt.getRecordBasePtr() - m_Data; + + if (!shortenLayer(offset, opt.getTotalSize())) + { + return false; + } + + adjustTcpOptionTrailer(totalOptSize); + + m_OptionReader.changeTLVRecordCount(-1); + + return true; +} +DISABLE_WARNING_POP + } // namespace pcpp diff --git a/Tests/Fuzzers/ReadParsedPacket.h b/Tests/Fuzzers/ReadParsedPacket.h index ca7b629264..9fc0dbb326 100644 --- a/Tests/Fuzzers/ReadParsedPacket.h +++ b/Tests/Fuzzers/ReadParsedPacket.h @@ -207,7 +207,7 @@ static void readParsedPacket(pcpp::Packet parsedPacket, pcpp::Layer* layer) if (auto tcpLayer = dynamic_cast(layer)) { auto tcpLayer2 (*tcpLayer); - tcpLayer2.addTcpOptionAfter(pcpp::TcpOptionBuilder(pcpp::TcpOptionBuilder::NOP), pcpp::PCPP_TCPOPT_NOP); + tcpLayer2.insertTcpOptionAfter(pcpp::TcpOptionBuilder(pcpp::TcpOptionBuilder::NopEolOptionEnumType::Nop), pcpp::TcpOptionEnumType::Nop); } } if (parsedPacket.isPacketOfType(pcpp::SDP)) diff --git a/Tests/Packet++Test/PacketExamples/TcpPacketWithOptions2.dat b/Tests/Packet++Test/PacketExamples/TcpPacketWithOptions2.dat index f68e47f79e..6f6215842d 100644 --- a/Tests/Packet++Test/PacketExamples/TcpPacketWithOptions2.dat +++ b/Tests/Packet++Test/PacketExamples/TcpPacketWithOptions2.dat @@ -1 +1 @@ -080027191c7830469a23fbfa08004500003d4f4c40003b064798d4c7ca090a0000060050ac80b829cb98e977158680184ed2f2aa00000101080ad3f03998000300950049454e44ae426082 \ No newline at end of file +080027191c7830469a23fbfa0800450000414f4c40003b064794d4c7ca090a0000060050ac80b829cb98e977158690184ed2dea100000101080ad3f0399800030095010303020049454e44ae426082 \ No newline at end of file diff --git a/Tests/Packet++Test/PacketExamples/TcpPacketWithOptions2.pcap b/Tests/Packet++Test/PacketExamples/TcpPacketWithOptions2.pcap index bf710b8c33..2741d5e029 100644 Binary files a/Tests/Packet++Test/PacketExamples/TcpPacketWithOptions2.pcap and b/Tests/Packet++Test/PacketExamples/TcpPacketWithOptions2.pcap differ diff --git a/Tests/Packet++Test/Tests/PacketTests.cpp b/Tests/Packet++Test/Tests/PacketTests.cpp index ec9015b29c..cea40f0502 100644 --- a/Tests/Packet++Test/Tests/PacketTests.cpp +++ b/Tests/Packet++Test/Tests/PacketTests.cpp @@ -394,8 +394,8 @@ PTF_TEST_CASE(CopyLayerAndPacketTest) PTF_ASSERT_TRUE(sampleTcpPacketWithOptions.getLayerOfType()->getData() != tcpLayer.getData()); PTF_ASSERT_BUF_COMPARE(sampleTcpPacketWithOptions.getLayerOfType()->getData(), tcpLayer.getData(), sampleTcpPacketWithOptions.getLayerOfType()->getDataLen()); PTF_ASSERT_EQUAL(tcpLayer.getTcpOptionCount(), sampleTcpPacketWithOptions.getLayerOfType()->getTcpOptionCount()); - PTF_ASSERT_TRUE(sampleTcpPacketWithOptions.getLayerOfType()->getTcpOption(pcpp::PCPP_TCPOPT_TIMESTAMP).getRecordBasePtr() != tcpLayer.getTcpOption(pcpp::PCPP_TCPOPT_TIMESTAMP).getRecordBasePtr()); - PTF_ASSERT_TRUE(sampleTcpPacketWithOptions.getLayerOfType()->getTcpOption(pcpp::PCPP_TCPOPT_TIMESTAMP) == tcpLayer.getTcpOption(pcpp::PCPP_TCPOPT_TIMESTAMP)); + PTF_ASSERT_TRUE(sampleTcpPacketWithOptions.getLayerOfType()->getTcpOption(pcpp::TcpOptionEnumType::Timestamp).getRecordBasePtr() != tcpLayer.getTcpOption(pcpp::TcpOptionEnumType::Timestamp).getRecordBasePtr()); + PTF_ASSERT_TRUE(sampleTcpPacketWithOptions.getLayerOfType()->getTcpOption(pcpp::TcpOptionEnumType::Timestamp) == tcpLayer.getTcpOption(pcpp::TcpOptionEnumType::Timestamp)); //HttpLayer copy c'tor test diff --git a/Tests/Packet++Test/Tests/SllNullLoopbackTests.cpp b/Tests/Packet++Test/Tests/SllNullLoopbackTests.cpp index d06719c591..3cca58180d 100644 --- a/Tests/Packet++Test/Tests/SllNullLoopbackTests.cpp +++ b/Tests/Packet++Test/Tests/SllNullLoopbackTests.cpp @@ -58,9 +58,9 @@ PTF_TEST_CASE(SllPacketCreationTest) tcpLayer.getTcpHeader()->ackNumber = htobe32(0x7633e977); tcpLayer.getTcpHeader()->ackFlag = 1; tcpLayer.getTcpHeader()->windowSize = htobe16(4098); - PTF_ASSERT_TRUE(tcpLayer.addTcpOption(pcpp::TcpOptionBuilder(pcpp::TcpOptionBuilder::NOP)).isNotNull()); - PTF_ASSERT_TRUE(tcpLayer.addTcpOption(pcpp::TcpOptionBuilder(pcpp::TcpOptionBuilder::NOP)).isNotNull()); - pcpp::TcpOption tsOption = tcpLayer.addTcpOption(pcpp::TcpOptionBuilder(pcpp::PCPP_TCPOPT_TIMESTAMP, nullptr, PCPP_TCPOLEN_TIMESTAMP-2)); + PTF_ASSERT_TRUE(tcpLayer.addTcpOption(pcpp::TcpOptionBuilder(pcpp::TcpOptionBuilder::NopEolOptionEnumType::Nop)).isNotNull()); + PTF_ASSERT_TRUE(tcpLayer.addTcpOption(pcpp::TcpOptionBuilder(pcpp::TcpOptionBuilder::NopEolOptionEnumType::Nop)).isNotNull()); + pcpp::TcpOption tsOption = tcpLayer.addTcpOption(pcpp::TcpOptionBuilder(pcpp::TcpOptionEnumType::Timestamp, nullptr, PCPP_TCPOLEN_TIMESTAMP-2)); PTF_ASSERT_TRUE(tsOption.isNotNull()); tsOption.setValue(htobe32(0x0402383b)); tsOption.setValue(htobe32(0x03ff37f5), 4); diff --git a/Tests/Packet++Test/Tests/TcpTests.cpp b/Tests/Packet++Test/Tests/TcpTests.cpp index da21233b14..f50e28cd12 100644 --- a/Tests/Packet++Test/Tests/TcpTests.cpp +++ b/Tests/Packet++Test/Tests/TcpTests.cpp @@ -8,6 +8,12 @@ #include "PayloadLayer.h" #include "SystemUtils.h" #include "PacketUtils.h" +#include "DeprecationUtils.h" + +// TODO: remove these macros, when deprecated code is gone +DISABLE_WARNING_PUSH +DISABLE_WARNING_DEPRECATED + PTF_TEST_CASE(TcpPacketNoOptionsParsing) { @@ -44,8 +50,14 @@ PTF_TEST_CASE(TcpPacketNoOptionsParsing) // TCP options PTF_ASSERT_EQUAL(tcpLayer->getTcpOptionCount(), 0); + + //TODO: remove deprecated PTF_ASSERT_TRUE(tcpLayer->getTcpOption(pcpp::PCPP_TCPOPT_NOP).isNull()); PTF_ASSERT_TRUE(tcpLayer->getTcpOption(pcpp::PCPP_TCPOPT_TIMESTAMP).isNull()); + //end deprecated + + PTF_ASSERT_TRUE(tcpLayer->getTcpOption(pcpp::TcpOptionEnumType::Nop).isNull()); + PTF_ASSERT_TRUE(tcpLayer->getTcpOption(pcpp::TcpOptionEnumType::Timestamp).isNull()); pcpp::Layer* afterTcpLayer = tcpLayer->getNextLayer(); PTF_ASSERT_NOT_NULL(afterTcpLayer); @@ -77,18 +89,28 @@ PTF_TEST_CASE(TcpPacketWithOptionsParsing) // TCP options PTF_ASSERT_EQUAL(tcpLayer->getTcpOptionCount(), 3); + + //TODO: remove deprecated + PTF_ASSERT_TRUE(!tcpLayer->getTcpOption(pcpp::PCPP_TCPOPT_NOP).isNull()); pcpp::TcpOption timestampOptionData = tcpLayer->getTcpOption(pcpp::PCPP_TCPOPT_TIMESTAMP); PTF_ASSERT_TRUE(!timestampOptionData.isNull()); - PTF_ASSERT_TRUE(!tcpLayer->getTcpOption(pcpp::PCPP_TCPOPT_NOP).isNull()); PTF_ASSERT_EQUAL(timestampOptionData.getTotalSize(), 10); uint32_t tsValue = timestampOptionData.getValueAs(); uint32_t tsEchoReply = timestampOptionData.getValueAs(4); PTF_ASSERT_EQUAL(tsValue, htobe32(195102)); PTF_ASSERT_EQUAL(tsEchoReply, htobe32(3555729271UL)); + //end deprecated + + PTF_ASSERT_TRUE(!tcpLayer->getTcpOption(pcpp::TcpOptionEnumType::Nop).isNull()); + pcpp::TcpOption timestampOptionData2 = tcpLayer->getTcpOption(pcpp::TcpOptionEnumType::Timestamp); + PTF_ASSERT_TRUE(!timestampOptionData2.isNull()); + PTF_ASSERT_EQUAL(timestampOptionData2.getTotalSize(), 10); + uint32_t tsValue2 = timestampOptionData2.getValueAs(); + uint32_t tsEchoReply2 = timestampOptionData2.getValueAs(4); + PTF_ASSERT_EQUAL(tsValue2, htobe32(195102)); + PTF_ASSERT_EQUAL(tsEchoReply2, htobe32(3555729271UL)); } // TcpPacketWithOptionsParsing - - PTF_TEST_CASE(TcpPacketWithOptionsParsing2) { timeval time; @@ -102,6 +124,8 @@ PTF_TEST_CASE(TcpPacketWithOptionsParsing2) PTF_ASSERT_NOT_NULL(tcpLayer); PTF_ASSERT_EQUAL(tcpLayer->getTcpOptionCount(), 5); + + //TODO: remove deprecated pcpp::TcpOption mssOption = tcpLayer->getTcpOption(pcpp::TCPOPT_MSS); pcpp::TcpOption sackPermOption = tcpLayer->getTcpOption(pcpp::TCPOPT_SACK_PERM); pcpp::TcpOption windowScaleOption = tcpLayer->getTcpOption(pcpp::PCPP_TCPOPT_WINDOW); @@ -122,7 +146,30 @@ PTF_TEST_CASE(TcpPacketWithOptionsParsing2) PTF_ASSERT_EQUAL(sackPermOption.getValueAs(), 0); PTF_ASSERT_EQUAL(mssOption.getValueAs(), 0); PTF_ASSERT_EQUAL(mssOption.getValueAs(1), 0); - + //end deprecated + + pcpp::TcpOption mssOption2 = tcpLayer->getTcpOption(pcpp::TcpOptionEnumType::Mss); + pcpp::TcpOption sackPermOption2 = tcpLayer->getTcpOption(pcpp::TcpOptionEnumType::SackPerm); + pcpp::TcpOption windowScaleOption2 = tcpLayer->getTcpOption(pcpp::TcpOptionEnumType::Window); + PTF_ASSERT_TRUE(mssOption2.isNotNull()); + PTF_ASSERT_TRUE(sackPermOption2.isNotNull()); + PTF_ASSERT_TRUE(windowScaleOption2.isNotNull()); + + PTF_ASSERT_EQUAL(mssOption2.getTcpOptionEnumType(), pcpp::TcpOptionEnumType::Mss, enumclass); + PTF_ASSERT_EQUAL(sackPermOption2.getTcpOptionEnumType(), pcpp::TcpOptionEnumType::SackPerm, enumclass); + PTF_ASSERT_EQUAL(windowScaleOption2.getTcpOptionEnumType(), pcpp::TcpOptionEnumType::Window, enumclass); + + PTF_ASSERT_EQUAL(mssOption2.getTotalSize(), 4); + PTF_ASSERT_EQUAL(sackPermOption2.getTotalSize(), 2); + PTF_ASSERT_EQUAL(windowScaleOption2.getTotalSize(), 3); + + PTF_ASSERT_EQUAL(mssOption2.getValueAs(), htobe16(1460)); + PTF_ASSERT_EQUAL(windowScaleOption2.getValueAs(), 4); + PTF_ASSERT_EQUAL(sackPermOption2.getValueAs(), 0); + PTF_ASSERT_EQUAL(mssOption2.getValueAs(), 0); + PTF_ASSERT_EQUAL(mssOption2.getValueAs(1), 0); + + //TODO: remove deprecated pcpp::TcpOption curOpt = tcpLayer->getFirstTcpOption(); PTF_ASSERT_TRUE(curOpt.isNotNull() && curOpt.getTcpOptionType() == pcpp::TCPOPT_MSS); curOpt = tcpLayer->getNextTcpOption(curOpt); @@ -133,6 +180,18 @@ PTF_TEST_CASE(TcpPacketWithOptionsParsing2) PTF_ASSERT_TRUE(curOpt.isNotNull() && curOpt.getTcpOptionType() == pcpp::PCPP_TCPOPT_NOP); curOpt = tcpLayer->getNextTcpOption(curOpt); PTF_ASSERT_TRUE(curOpt.isNotNull() && curOpt.getTcpOptionType() == pcpp::PCPP_TCPOPT_WINDOW); + //end deprecated + + curOpt = tcpLayer->getFirstTcpOption(); + PTF_ASSERT_TRUE(curOpt.isNotNull() && curOpt.getTcpOptionEnumType() == pcpp::TcpOptionEnumType::Mss); + curOpt = tcpLayer->getNextTcpOption(curOpt); + PTF_ASSERT_TRUE(curOpt.isNotNull() && curOpt.getTcpOptionEnumType() == pcpp::TcpOptionEnumType::SackPerm); + curOpt = tcpLayer->getNextTcpOption(curOpt); + PTF_ASSERT_TRUE(curOpt.isNotNull() && curOpt.getTcpOptionEnumType() == pcpp::TcpOptionEnumType::Timestamp); + curOpt = tcpLayer->getNextTcpOption(curOpt); + PTF_ASSERT_TRUE(curOpt.isNotNull() && curOpt.getTcpOptionEnumType() == pcpp::TcpOptionEnumType::Nop); + curOpt = tcpLayer->getNextTcpOption(curOpt); + PTF_ASSERT_TRUE(curOpt.isNotNull() && curOpt.getTcpOptionEnumType() == pcpp::TcpOptionEnumType::Window); curOpt = tcpLayer->getNextTcpOption(curOpt); PTF_ASSERT_TRUE(curOpt.isNull()); } // TcpPacketWithOptionsParsing2 @@ -152,8 +211,6 @@ PTF_TEST_CASE(TcpMalformedPacketParsing) PTF_ASSERT_NULL(badTcpPacket.getLayerOfType()); } // TcpMalformedPacketParsing - - PTF_TEST_CASE(TcpPacketCreation) { pcpp::MacAddress srcMac("30:46:9a:23:fb:fa"); @@ -177,7 +234,11 @@ PTF_TEST_CASE(TcpPacketCreation) PTF_ASSERT_EQUAL(tcpLayer.getHeaderLen(), 24); PTF_ASSERT_TRUE(tcpLayer.addTcpOption(pcpp::TcpOptionBuilder(pcpp::PCPP_TCPOPT_TIMESTAMP, nullptr, PCPP_TCPOLEN_TIMESTAMP-2)).isNotNull()); PTF_ASSERT_EQUAL(tcpLayer.getHeaderLen(), 32); - PTF_ASSERT_EQUAL(tcpLayer.getTcpOptionCount(), 3); + + PTF_ASSERT_TRUE(tcpLayer.addTcpOption(pcpp::TcpOptionBuilder(pcpp::TcpOptionBuilder::NopEolOptionEnumType::Nop)).isNotNull()); + PTF_ASSERT_TRUE(tcpLayer.addTcpOption(pcpp::TcpOptionBuilder(pcpp::TcpOptionEnumType::Window, nullptr, PCPP_TCPOLEN_WINDOW-2)).isNotNull()); + PTF_ASSERT_EQUAL(tcpLayer.getHeaderLen(), 36); + PTF_ASSERT_EQUAL(tcpLayer.getTcpOptionCount(), 5); uint8_t payloadData[9] = { 0x00, 0x49, 0x45, 0x4e, 0x44, 0xae, 0x42, 0x60, 0x82 }; pcpp::PayloadLayer payloadLayer(payloadData, 9); @@ -195,7 +256,12 @@ PTF_TEST_CASE(TcpPacketCreation) tsOption.setValue(tsValue); tsOption.setValue(tsEchoReply, 4); - PTF_ASSERT_EQUAL(tcpLayer.getTcpOptionCount(), 3); + uint8_t windowScaleFactor = 2; + pcpp::TcpOption windowOption = tcpLayer.getTcpOption(pcpp::TcpOptionEnumType::Window); + PTF_ASSERT_TRUE(windowOption.isNotNull()); + windowOption.setValue(windowScaleFactor); + + PTF_ASSERT_EQUAL(tcpLayer.getTcpOptionCount(), 5); tcpPacket.computeCalculateFields(); @@ -262,15 +328,15 @@ PTF_TEST_CASE(TcpPacketCreation2) pcpp::TcpOption qsOption = tcpLayer.addTcpOptionAfter(pcpp::TcpOptionBuilder(pcpp::TCPOPT_QS, nullptr, PCPP_TCPOLEN_QS), pcpp::TCPOPT_MSS); PTF_ASSERT_TRUE(qsOption.isNotNull()); PTF_ASSERT_TRUE(qsOption.setValue(htobe32(9999))); - PTF_ASSERT_TRUE(tcpLayer.addTcpOption(pcpp::TcpOptionBuilder(pcpp::TCPOPT_SNACK, (uint32_t)htobe32(1000))).isNotNull()); - PTF_ASSERT_TRUE(tcpLayer.addTcpOptionAfter(pcpp::TcpOptionBuilder(pcpp::TcpOptionBuilder::NOP), pcpp::PCPP_TCPOPT_TIMESTAMP).isNotNull()); + PTF_ASSERT_TRUE(tcpLayer.addTcpOption(pcpp::TcpOptionBuilder(pcpp::TcpOptionEnumType::Snack, static_cast(htobe32(1000)))).isNotNull()); + PTF_ASSERT_TRUE(tcpLayer.insertTcpOptionAfter(pcpp::TcpOptionBuilder(pcpp::TcpOptionBuilder::NopEolOptionEnumType::Nop), pcpp::TcpOptionEnumType::Timestamp).isNotNull()); PTF_ASSERT_EQUAL(tcpLayer.getTcpOptionCount(), 8); - PTF_ASSERT_TRUE(tcpLayer.removeTcpOption(pcpp::TCPOPT_QS)); + PTF_ASSERT_TRUE(tcpLayer.removeTcpOption(pcpp::TcpOptionEnumType::Qs)); PTF_ASSERT_EQUAL(tcpLayer.getTcpOptionCount(), 7); PTF_ASSERT_TRUE(tcpLayer.removeTcpOption(pcpp::TCPOPT_SNACK)); - PTF_ASSERT_TRUE(tcpLayer.removeTcpOption(pcpp::PCPP_TCPOPT_NOP)); + PTF_ASSERT_TRUE(tcpLayer.removeTcpOption(pcpp::TcpOptionEnumType::Nop)); PTF_ASSERT_EQUAL(tcpLayer.getTcpOptionCount(), 5); PTF_ASSERT_BUF_COMPARE(tcpPacket.getRawPacket()->getRawData(), buffer1, bufferLength1); @@ -331,3 +397,4 @@ PTF_TEST_CASE(TcpChecksumMultiBuffer) c = pcpp::computeChecksum(vec, 4); PTF_ASSERT_EQUAL(c, 0); } // TcpChecksumInvalidRead +DISABLE_WARNING_POP diff --git a/Tests/PcppTestFramework/PcppTestFramework.h b/Tests/PcppTestFramework/PcppTestFramework.h index 1041f09d35..8f63774710 100644 --- a/Tests/PcppTestFramework/PcppTestFramework.h +++ b/Tests/PcppTestFramework/PcppTestFramework.h @@ -15,6 +15,13 @@ #define ptr_PTF_PRINT_TYPE_EXPECTED(exp, val) exp << "[ptr: " << val << "]" #define enumclass_PTF_PRINT_TYPE_ACTUAL(exp, val) "enum[" << +static_cast::type>(val) << "]" #define enumclass_PTF_PRINT_TYPE_EXPECTED(exp, val) exp << "[" << +static_cast::type>(val) << "]" +#define BUFFER_PRINT(buffer, size) \ + for(size_t currentByteId = 0; currentByteId < static_cast(size); ++currentByteId) { \ + std::cout << std::setfill('0') << std::setw(2) << std::right << std::hex << static_cast(*(buffer + currentByteId)) << " "; \ + } \ + std::cout << std::setfill(' ') << std::setw(0) << std::left << std::dec; \ + std::cout << std::endl + #define PTF_PRINT_ASSERTION(severity, op) \ std::cout << std::left << std::setw(35) << __FUNCTION__ << ": " \ @@ -126,10 +133,10 @@ #define PTF_ASSERT_BUF_COMPARE(buf1, buf2, size) \ if (memcmp(buf1, buf2, size) != 0) { \ PTF_PRINT_ASSERTION("FAILED", "BUFFER COMPARE") \ - << " [ " << #buf1 << " ]" << std::endl \ - << " <>" << std::endl \ - << " [ " << #buf2 << " ]" \ - << std::endl; \ + << " Actual " << std::endl; \ + BUFFER_PRINT(buf1, size) \ + << " Expected " << std::endl; \ + BUFFER_PRINT(buf2, size); \ ptfResult = PTF_RESULT_FAILED; \ return; \ }