{
delete request;
delete status;
- delete header[0];
- delete header[1];
- delete trailer[0];
- delete trailer[1];
+ delete header[SRC_CLIENT];
+ delete header[SRC_SERVER];
+ delete trailer[SRC_CLIENT];
+ delete trailer[SRC_SERVER];
delete latest_body;
}
// 3. garbage collects unneeded transactions
// 4. returns the current transaction
- // Request section: put the old transaction in the pipeline and replace it with a new
- // transaction. If the pipeline overflows or underflows we stop using it and just delete the
- // old transaction.
+ // Request section: replace the old request transaction with a new transaction.
if (session_data->section_type[source_id] == SEC_REQUEST)
{
- // When pipelining is not occurring the response should already have taken this transaction
- // and left nullptr.
+ // If the HTTP request and response messages are alternating (usual situation) the old
+ // request transaction will have been moved to the server side when the last response
+ // message was received. This will be nullptr and we don't need to deal with the old
+ // request transaction here.
if (session_data->transaction[SRC_CLIENT] != nullptr)
{
- if ((session_data->pipeline_overflow) || (session_data->pipeline_underflow))
+ // The old request transaction is still here. Typically that is because the
+ // the current request has arrived before the previous response (pipelining). We need
+ // to add this transaction to our pipeline where it will wait for the matching
+ // response. But there are some special cases to check first.
+ if (session_data->transaction[SRC_CLIENT]->response_seen)
{
- delete session_data->transaction[SRC_CLIENT];
+ // The response started before the request finished. When the response took the
+ // old request transaction it did not leave the usual nullptr because we still
+ // needed it. Instead the two sides have been sharing the transaction. This is a
+ // soft delete that eliminates our interest in this transaction without disturbing
+ // the possibly ongoing response processing.
+ delete_transaction(session_data->transaction[SRC_CLIENT]);
+ }
+ else if ((session_data->pipeline_overflow) || (session_data->pipeline_underflow))
+ {
+ // Pipelining previously broke down and both sides are processed separately from
+ // now on. We just throw things away when we are done with them.
+ delete_transaction(session_data->transaction[SRC_CLIENT]);
}
else if (!session_data->add_to_pipeline(session_data->transaction[SRC_CLIENT]))
{
// The pipeline is full and just overflowed.
- session_data->infractions[source_id] += INF_PARTIAL_START;
+ session_data->infractions[source_id] += INF_PIPELINE_OVERFLOW;
session_data->events[source_id].create_event(EVENT_PIPELINE_MAX);
- delete session_data->transaction[SRC_CLIENT];
+ delete_transaction(session_data->transaction[SRC_CLIENT]);
}
}
session_data->transaction[SRC_CLIENT] = new NHttpTransaction;
}
+ // This transaction has more than one response. This is a new response which is replacing the
+ // interim response. The two responses cannot coexist so we must clean up the interim response.
+ else if ((session_data->section_type[source_id] == SEC_STATUS) &&
+ (session_data->transaction[SRC_SERVER] != nullptr) &&
+ session_data->transaction[SRC_SERVER]->second_response_expected)
+ {
+ assert(session_data->transaction[SRC_SERVER] != nullptr);
+ session_data->transaction[SRC_SERVER]->second_response_expected = false;
+ delete session_data->transaction[SRC_SERVER]->status;
+ session_data->transaction[SRC_SERVER]->status = nullptr;
+ delete session_data->transaction[SRC_SERVER]->header[SRC_SERVER];
+ session_data->transaction[SRC_SERVER]->header[SRC_SERVER] = nullptr;
+ delete session_data->transaction[SRC_SERVER]->trailer[SRC_SERVER];
+ session_data->transaction[SRC_SERVER]->trailer[SRC_SERVER] = nullptr;
+ }
// Status section: delete the current transaction and get a new one from the pipeline. If the
- // pipeline is empty check for a request-side transaction that just finished and take it. If
- // there is no transaction available then declare an underflow and create a new transaction
- // specifically for the response side.
+ // pipeline is empty check for a request transaction and take it. If there is no transaction
+ // available then declare an underflow and create a new transaction specifically for the
+ // response side.
else if (session_data->section_type[source_id] == SEC_STATUS)
{
- delete session_data->transaction[SRC_SERVER];
+ delete_transaction(session_data->transaction[SRC_SERVER]);
if (session_data->pipeline_underflow)
{
+ // A previous underflow separated the two sides forever
session_data->transaction[SRC_SERVER] = new NHttpTransaction;
}
else if ((session_data->transaction[SRC_SERVER] = session_data->take_from_pipeline()) ==
nullptr)
{
- if ((session_data->transaction[SRC_CLIENT] != nullptr) &&
- (session_data->type_expected[SRC_CLIENT] == SEC_REQUEST))
+ if ((session_data->transaction[SRC_CLIENT] == nullptr) ||
+ (session_data->transaction[SRC_CLIENT]->response_seen))
{
+ // Either there is no request at all or there is a request but a previous response
+ // already took it. Either way we have more responses than requests.
+ session_data->pipeline_underflow = true;
+ session_data->transaction[SRC_SERVER] = new NHttpTransaction;
+ }
+
+ else if (session_data->type_expected[SRC_CLIENT] == SEC_REQUEST)
+ {
+ // This is the normal case where the requests and responses are alternating (no
+ // pipelining). Processing of the response is complete so the request just takes
+ // it.
session_data->transaction[SRC_SERVER] = session_data->transaction[SRC_CLIENT];
session_data->transaction[SRC_CLIENT] = nullptr;
}
else
{
- session_data->pipeline_underflow = true;
- session_data->transaction[SRC_SERVER] = new NHttpTransaction;
+ // Response message is starting before the request message has finished. Request
+ // side is not finished with this transaction so two sides share it
+ session_data->transaction[SRC_CLIENT]->shared_ownership = true;
+ session_data->transaction[SRC_SERVER] = session_data->transaction[SRC_CLIENT];
}
}
+ session_data->transaction[SRC_SERVER]->response_seen = true;
}
- assert((source_id == SRC_SERVER) || (session_data->transaction[source_id] != nullptr));
+ assert(session_data->transaction[source_id] != nullptr);
return session_data->transaction[source_id];
}
+void NHttpTransaction::delete_transaction(NHttpTransaction* transaction)
+{
+ if (transaction != nullptr)
+ {
+ if (!transaction->shared_ownership)
+ delete transaction;
+ else
+ transaction->shared_ownership = false;
+ }
+}
+
+void NHttpTransaction::set_body(NHttpMsgBody* latest_body_)
+{
+ delete latest_body;
+ latest_body = latest_body_;
+}
+
--- /dev/null
+//--------------------------------------------------------------------------
+// Copyright (C) 2016 Cisco and/or its affiliates. All rights reserved.
+//
+// This program is free software; you can redistribute it and/or modify it
+// under the terms of the GNU General Public License Version 2 as published
+// by the Free Software Foundation. You may not use, modify or distribute
+// this program under any other version of the GNU General Public License.
+//
+// This program is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this program; if not, write to the Free Software Foundation, Inc.,
+// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+//--------------------------------------------------------------------------
+
+// nhttp_transaction_test.cc author Tom Peters <thopeter@cisco.com>
+// unit test main
+
+#include "service_inspectors/nhttp_inspect/nhttp_transaction.h"
+#include "service_inspectors/nhttp_inspect/nhttp_module.h"
+#include "service_inspectors/nhttp_inspect/nhttp_flow_data.h"
+#include "service_inspectors/nhttp_inspect/nhttp_enum.h"
+
+#include <CppUTest/CommandLineTestRunner.h>
+#include <CppUTest/TestHarness.h>
+#include <CppUTestExt/MockSupport.h>
+
+using namespace NHttpEnums;
+
+// Stubs whose sole purpose is to make the test code link
+unsigned FlowData::flow_id = 0;
+FlowData::FlowData(unsigned, Inspector*) {}
+FlowData::~FlowData() {}
+int SnortEventqAdd(unsigned int, unsigned int, RuleType) { return 0; }
+THREAD_LOCAL PegCount NHttpModule::peg_counts[1];
+
+class NHttpUnitTestSetup
+{
+public:
+ static SectionType* get_section_type(NHttpFlowData* flow_data)
+ { assert(flow_data!=nullptr); return flow_data->section_type; }
+ static SectionType* get_type_expected(NHttpFlowData* flow_data)
+ { assert(flow_data!=nullptr); return flow_data->type_expected; }
+};
+
+TEST_GROUP(nhttp_transaction_test)
+{
+ NHttpFlowData* const flow_data = new NHttpFlowData;
+ SectionType* const section_type = NHttpUnitTestSetup::get_section_type(flow_data);
+ SectionType* const type_expected = NHttpUnitTestSetup::get_type_expected(flow_data);
+
+ void teardown()
+ {
+ delete flow_data;
+ }
+};
+
+TEST(nhttp_transaction_test, simple_transaction)
+{
+ // This test is a request message with a chunked body and trailers followed by a similar
+ // response message. No overlap in time.
+ // Request
+ type_expected[SRC_CLIENT] = SEC_REQUEST;
+ section_type[SRC_CLIENT] = SEC_REQUEST;
+ NHttpTransaction* trans = NHttpTransaction::attach_my_transaction(flow_data, SRC_CLIENT);
+ CHECK(trans != nullptr);
+ type_expected[SRC_CLIENT] = SEC_HEADER;
+ section_type[SRC_CLIENT] = SEC_HEADER;
+ CHECK(trans == NHttpTransaction::attach_my_transaction(flow_data, SRC_CLIENT));
+ type_expected[SRC_CLIENT] = SEC_BODY_CHUNK;
+ section_type[SRC_CLIENT] = SEC_BODY_CHUNK;
+ for (unsigned k=0; k<100; k++)
+ {
+ CHECK(trans == NHttpTransaction::attach_my_transaction(flow_data, SRC_CLIENT));
+ }
+ type_expected[SRC_CLIENT] = SEC_TRAILER;
+ section_type[SRC_CLIENT] = SEC_TRAILER;
+ CHECK(trans == NHttpTransaction::attach_my_transaction(flow_data, SRC_CLIENT));
+ type_expected[SRC_CLIENT] = SEC_REQUEST;
+
+ // Response
+ section_type[SRC_SERVER] = SEC_STATUS;
+ CHECK(trans == NHttpTransaction::attach_my_transaction(flow_data, SRC_SERVER));
+ section_type[SRC_SERVER] = SEC_HEADER;
+ CHECK(trans == NHttpTransaction::attach_my_transaction(flow_data, SRC_SERVER));
+ section_type[SRC_SERVER] = SEC_BODY_CHUNK;
+ for (unsigned k=0; k<100; k++)
+ {
+ CHECK(trans == NHttpTransaction::attach_my_transaction(flow_data, SRC_SERVER));
+ }
+ section_type[SRC_SERVER] = SEC_TRAILER;
+ CHECK(trans == NHttpTransaction::attach_my_transaction(flow_data, SRC_SERVER));
+}
+
+TEST(nhttp_transaction_test, orphan_response)
+{
+ // Response message without a request
+ type_expected[SRC_CLIENT] = SEC_REQUEST;
+ section_type[SRC_SERVER] = SEC_STATUS;
+ NHttpTransaction* trans = NHttpTransaction::attach_my_transaction(flow_data, SRC_SERVER);
+ CHECK(trans != nullptr);
+ section_type[SRC_SERVER] = SEC_HEADER;
+ CHECK(trans == NHttpTransaction::attach_my_transaction(flow_data, SRC_SERVER));
+ section_type[SRC_SERVER] = SEC_BODY_CHUNK;
+ for (unsigned k=0; k<10; k++)
+ {
+ CHECK(trans == NHttpTransaction::attach_my_transaction(flow_data, SRC_SERVER));
+ }
+ section_type[SRC_SERVER] = SEC_TRAILER;
+ CHECK(trans == NHttpTransaction::attach_my_transaction(flow_data, SRC_SERVER));
+}
+
+TEST(nhttp_transaction_test, simple_pipeline)
+{
+ // Pipeline with four requests followed by four responses
+ NHttpTransaction* trans[4];
+ for (unsigned k=0; k < 4; k++)
+ {
+ type_expected[SRC_CLIENT] = SEC_REQUEST;
+ section_type[SRC_CLIENT] = SEC_REQUEST;
+ trans[k] = NHttpTransaction::attach_my_transaction(flow_data, SRC_CLIENT);
+ CHECK(trans[k] != nullptr);
+ type_expected[SRC_CLIENT] = SEC_HEADER;
+ section_type[SRC_CLIENT] = SEC_HEADER;
+ CHECK(trans[k] == NHttpTransaction::attach_my_transaction(flow_data, SRC_CLIENT));
+ for (unsigned j=0; j < k; j++)
+ {
+ CHECK(trans[k] != trans[j]);
+ }
+ }
+ type_expected[SRC_CLIENT] = SEC_REQUEST;
+
+ for (unsigned k=0; k < 4; k++)
+ {
+ section_type[SRC_SERVER] = SEC_STATUS;
+ CHECK(trans[k] == NHttpTransaction::attach_my_transaction(flow_data, SRC_SERVER));
+ section_type[SRC_SERVER] = SEC_HEADER;
+ CHECK(trans[k] == NHttpTransaction::attach_my_transaction(flow_data, SRC_SERVER));
+ section_type[SRC_SERVER] = SEC_BODY_CL;
+ CHECK(trans[k] == NHttpTransaction::attach_my_transaction(flow_data, SRC_SERVER));
+ }
+}
+
+TEST(nhttp_transaction_test, concurrent_request_response)
+{
+ // Response starts before request completes, request completes first
+ type_expected[SRC_CLIENT] = SEC_REQUEST;
+ section_type[SRC_CLIENT] = SEC_REQUEST;
+ NHttpTransaction* trans = NHttpTransaction::attach_my_transaction(flow_data, SRC_CLIENT);
+ CHECK(trans != nullptr);
+ type_expected[SRC_CLIENT] = SEC_HEADER;
+ section_type[SRC_CLIENT] = SEC_HEADER;
+ CHECK(trans == NHttpTransaction::attach_my_transaction(flow_data, SRC_CLIENT));
+ type_expected[SRC_CLIENT] = SEC_BODY_CHUNK;
+
+ section_type[SRC_SERVER] = SEC_STATUS;
+ CHECK(trans == NHttpTransaction::attach_my_transaction(flow_data, SRC_SERVER));
+ section_type[SRC_SERVER] = SEC_HEADER;
+ CHECK(trans == NHttpTransaction::attach_my_transaction(flow_data, SRC_SERVER));
+
+ section_type[SRC_CLIENT] = SEC_BODY_CHUNK;
+ for (unsigned k=0; k<4; k++)
+ {
+ CHECK(trans == NHttpTransaction::attach_my_transaction(flow_data, SRC_CLIENT));
+ }
+ type_expected[SRC_CLIENT] = SEC_TRAILER;
+ section_type[SRC_CLIENT] = SEC_TRAILER;
+ CHECK(trans == NHttpTransaction::attach_my_transaction(flow_data, SRC_CLIENT));
+ type_expected[SRC_CLIENT] = SEC_REQUEST;
+
+ section_type[SRC_SERVER] = SEC_BODY_CHUNK;
+ for (unsigned k=0; k<6; k++)
+ {
+ CHECK(trans == NHttpTransaction::attach_my_transaction(flow_data, SRC_SERVER));
+ }
+ section_type[SRC_SERVER] = SEC_TRAILER;
+ CHECK(trans == NHttpTransaction::attach_my_transaction(flow_data, SRC_SERVER));
+}
+
+TEST(nhttp_transaction_test, pipeline_underflow)
+{
+ // Underflow scenario with request, two responses, request, response
+ type_expected[SRC_CLIENT] = SEC_REQUEST;
+ section_type[SRC_CLIENT] = SEC_REQUEST;
+ NHttpTransaction* trans = NHttpTransaction::attach_my_transaction(flow_data, SRC_CLIENT);
+ CHECK(trans != nullptr);
+ type_expected[SRC_CLIENT] = SEC_HEADER;
+ section_type[SRC_CLIENT] = SEC_HEADER;
+ CHECK(trans == NHttpTransaction::attach_my_transaction(flow_data, SRC_CLIENT));
+ type_expected[SRC_CLIENT] = SEC_REQUEST;
+
+ section_type[SRC_SERVER] = SEC_STATUS;
+ CHECK(trans == NHttpTransaction::attach_my_transaction(flow_data, SRC_SERVER));
+ section_type[SRC_SERVER] = SEC_HEADER;
+ CHECK(trans == NHttpTransaction::attach_my_transaction(flow_data, SRC_SERVER));
+
+ section_type[SRC_SERVER] = SEC_STATUS;
+ trans = NHttpTransaction::attach_my_transaction(flow_data, SRC_SERVER);
+ CHECK(trans != nullptr);
+ section_type[SRC_SERVER] = SEC_HEADER;
+ CHECK(trans == NHttpTransaction::attach_my_transaction(flow_data, SRC_SERVER));
+
+ section_type[SRC_CLIENT] = SEC_REQUEST;
+ NHttpTransaction* trans2 = NHttpTransaction::attach_my_transaction(flow_data, SRC_CLIENT);
+ CHECK((trans2 != nullptr) && (trans2 != trans));
+ type_expected[SRC_CLIENT] = SEC_HEADER;
+ section_type[SRC_CLIENT] = SEC_HEADER;
+ CHECK(trans2 == NHttpTransaction::attach_my_transaction(flow_data, SRC_CLIENT));
+ type_expected[SRC_CLIENT] = SEC_REQUEST;
+
+ section_type[SRC_SERVER] = SEC_STATUS;
+ trans = NHttpTransaction::attach_my_transaction(flow_data, SRC_SERVER);
+ CHECK((trans != nullptr) && (trans != trans2));
+ section_type[SRC_SERVER] = SEC_HEADER;
+ CHECK(trans == NHttpTransaction::attach_my_transaction(flow_data, SRC_SERVER));
+}
+
+TEST(nhttp_transaction_test, concurrent_request_response_underflow)
+{
+ // Response starts before request completes, response completes first, second response
+ type_expected[SRC_CLIENT] = SEC_REQUEST;
+ section_type[SRC_CLIENT] = SEC_REQUEST;
+ NHttpTransaction* trans = NHttpTransaction::attach_my_transaction(flow_data, SRC_CLIENT);
+ CHECK(trans != nullptr);
+ type_expected[SRC_CLIENT] = SEC_HEADER;
+ section_type[SRC_CLIENT] = SEC_HEADER;
+ CHECK(trans == NHttpTransaction::attach_my_transaction(flow_data, SRC_CLIENT));
+ type_expected[SRC_CLIENT] = SEC_BODY_CHUNK;
+
+ section_type[SRC_SERVER] = SEC_STATUS;
+ CHECK(trans == NHttpTransaction::attach_my_transaction(flow_data, SRC_SERVER));
+ section_type[SRC_SERVER] = SEC_HEADER;
+ CHECK(trans == NHttpTransaction::attach_my_transaction(flow_data, SRC_SERVER));
+ section_type[SRC_SERVER] = SEC_BODY_CHUNK;
+ for (unsigned k=0; k<6; k++)
+ {
+ CHECK(trans == NHttpTransaction::attach_my_transaction(flow_data, SRC_SERVER));
+ }
+ section_type[SRC_SERVER] = SEC_TRAILER;
+ CHECK(trans == NHttpTransaction::attach_my_transaction(flow_data, SRC_SERVER));
+
+ section_type[SRC_CLIENT] = SEC_BODY_CHUNK;
+ for (unsigned k=0; k<4; k++)
+ {
+ CHECK(trans == NHttpTransaction::attach_my_transaction(flow_data, SRC_CLIENT));
+ }
+ type_expected[SRC_CLIENT] = SEC_TRAILER;
+ section_type[SRC_CLIENT] = SEC_TRAILER;
+ CHECK(trans == NHttpTransaction::attach_my_transaction(flow_data, SRC_CLIENT));
+ type_expected[SRC_CLIENT] = SEC_REQUEST;
+
+ section_type[SRC_SERVER] = SEC_STATUS;
+ NHttpTransaction* trans2 = NHttpTransaction::attach_my_transaction(flow_data, SRC_SERVER);
+ CHECK((trans2 != nullptr) && (trans2 != trans));
+ section_type[SRC_SERVER] = SEC_HEADER;
+ CHECK(trans2 == NHttpTransaction::attach_my_transaction(flow_data, SRC_SERVER));
+ section_type[SRC_SERVER] = SEC_BODY_CHUNK;
+ for (unsigned k=0; k<6; k++)
+ {
+ CHECK(trans2 == NHttpTransaction::attach_my_transaction(flow_data, SRC_SERVER));
+ }
+ section_type[SRC_SERVER] = SEC_TRAILER;
+ CHECK(trans2 == NHttpTransaction::attach_my_transaction(flow_data, SRC_SERVER));
+}
+
+TEST(nhttp_transaction_test, basic_continue)
+{
+ // Request with interim response and final response
+ // Request headers
+ type_expected[SRC_CLIENT] = SEC_REQUEST;
+ section_type[SRC_CLIENT] = SEC_REQUEST;
+ NHttpTransaction* trans = NHttpTransaction::attach_my_transaction(flow_data, SRC_CLIENT);
+ CHECK(trans != nullptr);
+ type_expected[SRC_CLIENT] = SEC_HEADER;
+ section_type[SRC_CLIENT] = SEC_HEADER;
+ CHECK(trans == NHttpTransaction::attach_my_transaction(flow_data, SRC_CLIENT));
+ type_expected[SRC_CLIENT] = SEC_BODY_CHUNK;
+
+ // Interim response
+ section_type[SRC_SERVER] = SEC_STATUS;
+ CHECK(trans == NHttpTransaction::attach_my_transaction(flow_data, SRC_SERVER));
+ trans->second_response_coming();
+ section_type[SRC_SERVER] = SEC_HEADER;
+ CHECK(trans == NHttpTransaction::attach_my_transaction(flow_data, SRC_SERVER));
+
+ // Request body
+ section_type[SRC_CLIENT] = SEC_BODY_CHUNK;
+ for (unsigned k=0; k<4; k++)
+ {
+ CHECK(trans == NHttpTransaction::attach_my_transaction(flow_data, SRC_CLIENT));
+ }
+ type_expected[SRC_CLIENT] = SEC_TRAILER;
+ section_type[SRC_CLIENT] = SEC_TRAILER;
+ CHECK(trans == NHttpTransaction::attach_my_transaction(flow_data, SRC_CLIENT));
+ type_expected[SRC_CLIENT] = SEC_REQUEST;
+
+ // Second response
+ section_type[SRC_SERVER] = SEC_STATUS;
+ CHECK(trans == NHttpTransaction::attach_my_transaction(flow_data, SRC_SERVER));
+ section_type[SRC_SERVER] = SEC_HEADER;
+ CHECK(trans == NHttpTransaction::attach_my_transaction(flow_data, SRC_SERVER));
+ section_type[SRC_SERVER] = SEC_BODY_CHUNK;
+ for (unsigned k=0; k<6; k++)
+ {
+ CHECK(trans == NHttpTransaction::attach_my_transaction(flow_data, SRC_SERVER));
+ }
+ section_type[SRC_SERVER] = SEC_TRAILER;
+ CHECK(trans == NHttpTransaction::attach_my_transaction(flow_data, SRC_SERVER));
+}
+
+TEST(nhttp_transaction_test, multiple_continue)
+{
+ // Request with interim response and final response
+ // Request headers
+ type_expected[SRC_CLIENT] = SEC_REQUEST;
+ section_type[SRC_CLIENT] = SEC_REQUEST;
+ NHttpTransaction* trans = NHttpTransaction::attach_my_transaction(flow_data, SRC_CLIENT);
+ CHECK(trans != nullptr);
+ type_expected[SRC_CLIENT] = SEC_HEADER;
+ section_type[SRC_CLIENT] = SEC_HEADER;
+ CHECK(trans == NHttpTransaction::attach_my_transaction(flow_data, SRC_CLIENT));
+ type_expected[SRC_CLIENT] = SEC_BODY_CHUNK;
+
+ // Interim responses
+ for (unsigned k=0; k < 10; k++)
+ {
+ section_type[SRC_SERVER] = SEC_STATUS;
+ CHECK(trans == NHttpTransaction::attach_my_transaction(flow_data, SRC_SERVER));
+ trans->second_response_coming();
+ section_type[SRC_SERVER] = SEC_HEADER;
+ CHECK(trans == NHttpTransaction::attach_my_transaction(flow_data, SRC_SERVER));
+ }
+
+ // Request body
+ section_type[SRC_CLIENT] = SEC_BODY_CHUNK;
+ for (unsigned k=0; k<4; k++)
+ {
+ CHECK(trans == NHttpTransaction::attach_my_transaction(flow_data, SRC_CLIENT));
+ }
+ type_expected[SRC_CLIENT] = SEC_TRAILER;
+ section_type[SRC_CLIENT] = SEC_TRAILER;
+ CHECK(trans == NHttpTransaction::attach_my_transaction(flow_data, SRC_CLIENT));
+ type_expected[SRC_CLIENT] = SEC_REQUEST;
+
+ // Final response
+ section_type[SRC_SERVER] = SEC_STATUS;
+ CHECK(trans == NHttpTransaction::attach_my_transaction(flow_data, SRC_SERVER));
+ section_type[SRC_SERVER] = SEC_HEADER;
+ CHECK(trans == NHttpTransaction::attach_my_transaction(flow_data, SRC_SERVER));
+ section_type[SRC_SERVER] = SEC_BODY_CHUNK;
+ for (unsigned k=0; k<6; k++)
+ {
+ CHECK(trans == NHttpTransaction::attach_my_transaction(flow_data, SRC_SERVER));
+ }
+ section_type[SRC_SERVER] = SEC_TRAILER;
+ CHECK(trans == NHttpTransaction::attach_my_transaction(flow_data, SRC_SERVER));
+}
+
+TEST(nhttp_transaction_test, multiple_orphan_continue)
+{
+ type_expected[SRC_CLIENT] = SEC_REQUEST;
+ // Repeated interim and final response messages without a request
+ for (unsigned k=0; k < 10; k++)
+ {
+ // Interim response
+ section_type[SRC_SERVER] = SEC_STATUS;
+ NHttpTransaction* trans = NHttpTransaction::attach_my_transaction(flow_data, SRC_SERVER);
+ CHECK(trans != nullptr);
+ trans->second_response_coming();
+ section_type[SRC_SERVER] = SEC_HEADER;
+ CHECK(trans == NHttpTransaction::attach_my_transaction(flow_data, SRC_SERVER));
+ section_type[SRC_SERVER] = SEC_BODY_CHUNK;
+ CHECK(trans == NHttpTransaction::attach_my_transaction(flow_data, SRC_SERVER));
+ section_type[SRC_SERVER] = SEC_TRAILER;
+ CHECK(trans == NHttpTransaction::attach_my_transaction(flow_data, SRC_SERVER));
+
+ // Final response
+ section_type[SRC_SERVER] = SEC_STATUS;
+ CHECK(trans == NHttpTransaction::attach_my_transaction(flow_data, SRC_SERVER));
+ section_type[SRC_SERVER] = SEC_HEADER;
+ CHECK(trans == NHttpTransaction::attach_my_transaction(flow_data, SRC_SERVER));
+ section_type[SRC_SERVER] = SEC_BODY_CHUNK;
+ CHECK(trans == NHttpTransaction::attach_my_transaction(flow_data, SRC_SERVER));
+ section_type[SRC_SERVER] = SEC_TRAILER;
+ CHECK(trans == NHttpTransaction::attach_my_transaction(flow_data, SRC_SERVER));
+ }
+}
+
+TEST(nhttp_transaction_test, pipeline_continue_pipeline)
+{
+ // 3.5 requests in pipeline, 3 responses + continue response, body + 3 requests in pipeline,
+ // final response + 3 responses
+ NHttpTransaction* trans[7];
+ // Four requests in pipeline, the final one will be continued later
+ for (unsigned k=0; k < 4; k++)
+ {
+ type_expected[SRC_CLIENT] = SEC_REQUEST;
+ section_type[SRC_CLIENT] = SEC_REQUEST;
+ trans[k] = NHttpTransaction::attach_my_transaction(flow_data, SRC_CLIENT);
+ CHECK(trans[k] != nullptr);
+ type_expected[SRC_CLIENT] = SEC_HEADER;
+ section_type[SRC_CLIENT] = SEC_HEADER;
+ CHECK(trans[k] == NHttpTransaction::attach_my_transaction(flow_data, SRC_CLIENT));
+ for (unsigned j=0; j < k; j++)
+ {
+ CHECK(trans[k] != trans[j]);
+ }
+ }
+ type_expected[SRC_CLIENT] = SEC_BODY_CL;
+
+ // Three responses to the pipeline
+ for (unsigned k=0; k < 3; k++)
+ {
+ section_type[SRC_SERVER] = SEC_STATUS;
+ CHECK(trans[k] == NHttpTransaction::attach_my_transaction(flow_data, SRC_SERVER));
+ section_type[SRC_SERVER] = SEC_HEADER;
+ CHECK(trans[k] == NHttpTransaction::attach_my_transaction(flow_data, SRC_SERVER));
+ section_type[SRC_SERVER] = SEC_BODY_CL;
+ CHECK(trans[k] == NHttpTransaction::attach_my_transaction(flow_data, SRC_SERVER));
+ }
+
+ // Interim response to fourth request
+ section_type[SRC_SERVER] = SEC_STATUS;
+ CHECK(trans[3] == NHttpTransaction::attach_my_transaction(flow_data, SRC_SERVER));
+ trans[3]->second_response_coming();
+ section_type[SRC_SERVER] = SEC_HEADER;
+ CHECK(trans[3] == NHttpTransaction::attach_my_transaction(flow_data, SRC_SERVER));
+
+ // Finish the fourth request
+ section_type[SRC_CLIENT] = SEC_BODY_CL;
+ CHECK(trans[3] == NHttpTransaction::attach_my_transaction(flow_data, SRC_CLIENT));
+
+ // Requests 5-7 in pipeline
+ for (unsigned k=4; k < 7; k++)
+ {
+ type_expected[SRC_CLIENT] = SEC_REQUEST;
+ section_type[SRC_CLIENT] = SEC_REQUEST;
+ trans[k] = NHttpTransaction::attach_my_transaction(flow_data, SRC_CLIENT);
+ CHECK(trans[k] != nullptr);
+ type_expected[SRC_CLIENT] = SEC_HEADER;
+ section_type[SRC_CLIENT] = SEC_HEADER;
+ CHECK(trans[k] == NHttpTransaction::attach_my_transaction(flow_data, SRC_CLIENT));
+ for (unsigned j=5; j < k; j++)
+ {
+ CHECK(trans[k] != trans[j]);
+ }
+ }
+ type_expected[SRC_CLIENT] = SEC_REQUEST;
+
+ // Final response to 4 and responses to 5-7
+ for (unsigned k=3; k < 7; k++)
+ {
+ section_type[SRC_SERVER] = SEC_STATUS;
+ CHECK(trans[k] == NHttpTransaction::attach_my_transaction(flow_data, SRC_SERVER));
+ section_type[SRC_SERVER] = SEC_HEADER;
+ CHECK(trans[k] == NHttpTransaction::attach_my_transaction(flow_data, SRC_SERVER));
+ section_type[SRC_SERVER] = SEC_BODY_CL;
+ CHECK(trans[k] == NHttpTransaction::attach_my_transaction(flow_data, SRC_SERVER));
+ }
+}
+
+int main(int argc, char** argv)
+{
+ return CommandLineTestRunner::RunAllTests(argc, argv);
+}
+
projects / thirdparty / snort3.git / commitdiff
