From 518f5782981dce14ba1d860fcb2d001230299b25 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Juan=20Jos=C3=A9=20Guti=C3=A9rrez=20de=20Quevedo=20P=C3=A9?= =?UTF-8?q?rez?= Date: Tue, 25 Mar 2025 10:42:06 +0100 Subject: [PATCH] Refactor Spf --- src/Spf.cpp | 121 +++++++++--------- src/Spf.h | 2 +- src/test/mocks/libspf2_mock.h | 96 ++++++++++++++ .../{MockSocket.h => mocks/socket_mock.h} | 0 .../{ProxyTest.cpp => tests/proxy_test.cpp} | 4 +- src/test/tests/spf_test.cpp | 98 ++++++++++++++ 6 files changed, 261 insertions(+), 60 deletions(-) create mode 100644 src/test/mocks/libspf2_mock.h rename src/test/{MockSocket.h => mocks/socket_mock.h} (100%) rename src/test/{ProxyTest.cpp => tests/proxy_test.cpp} (98%) create mode 100644 src/test/tests/spf_test.cpp diff --git a/src/Spf.cpp b/src/Spf.cpp index 1ef0bf2..0eeec44 100644 --- a/src/Spf.cpp +++ b/src/Spf.cpp @@ -4,11 +4,11 @@ * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; version 2 of the License + * the Free Software Foundation; version 2 of the 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 + * 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 @@ -17,83 +17,90 @@ * * @author Juan José Gutiérrez de Quevedo */ + #include "Spf.h" +#include +#include +#include -SPF_server_t *Spf::spfserver=NULL; +SPF_server_t *Spf::spfserver = nullptr; /** - * constructor - * - * it will create a spfserver if this is the first created object of the class. - * if it isn't, then we just create an spfrequest + * Constructor + * + * Initializes the SPF server if this is the first created object of the class. */ -Spf::Spf():spfrequest(NULL),spfresponse(NULL) -{ - pthread_mutex_init(&mutex,NULL); - if(NULL==spfserver) - if(NULL==(spfserver=SPF_server_new(SPF_DNS_CACHE,0))) - throw Exception(_("Can't initialize SPF library"),__FILE__,__LINE__); - - if(NULL==(spfrequest=SPF_request_new(spfserver))) - throw Exception(_("Can't initialize SPF request"),__FILE__,__LINE__); +Spf::Spf() { + static std::once_flag initFlag; // To ensure thread-safe initialization + std::call_once(initFlag, []() { + spfserver = SPF_server_new(SPF_DNS_CACHE, 0); + if (!spfserver) { + throw std::runtime_error("Can't initialize SPF library"); + } + }); } /** - * destructor - * - * frees the memory of the spfrequest + * Destructor + * + * Frees the memory of the SPF server. */ -Spf::~Spf() -{ - pthread_mutex_destroy(&mutex); - if(NULL!=spfrequest) SPF_request_free(spfrequest); +Spf::~Spf() { + deinitialize(); // Clean up resources } /** - * frees all memory related to the spf class + * Frees all memory related to the SPF class. * - * this is needed because the common things are only initialized - * once (and are static), and when we close the program we need - * to deinitialize them + * This is needed because common resources are only initialized once (and are static). */ -void Spf::deinitialize() -{ - if(NULL!=spfserver) - SPF_server_free(spfserver); +void Spf::deinitialize() { + if (spfserver) { + SPF_server_free(spfserver); + spfserver = nullptr; // Optional: Avoid dangling pointer + } } /** - * make a query to the dns system for an spf record + * Makes a query to the DNS system for an SPF record. * - * highly inspired from fakehermes' source + * @param ip The IP of the remote server + * @param helo The HELO string of the remote server + * @param from The envelope from address * - * @param ip the ip of the remote server - * @param helo the hello string of the remote server - * @param from the envelope from address - * - * @returns true if it is not incorrect + * @returns true if the query is not incorrect */ -bool Spf::query(string ip,string helo,string from) -{ - bool retval=false; +bool Spf::query(const std::string& ip, const std::string& helo, const std::string& from) { + SPF_request_t* spfrequest = SPF_request_new(spfserver); // Create request here + if (!spfrequest) { + throw std::runtime_error("Can't initialize SPF request"); + } - if(SPF_request_set_ipv4_str(spfrequest,ip.c_str())) - throw Exception(_("Error configuring IP for SPF request"),__FILE__,__LINE__); - if(SPF_request_set_helo_dom(spfrequest,helo.c_str())) - throw Exception(_("Error configuring HELO for SPF request"),__FILE__,__LINE__); - if(SPF_request_set_env_from(spfrequest,from.c_str())) - throw Exception(_("Error configuring FROM for SPF request"),__FILE__,__LINE__); + // Set the values for the SPF request + if (SPF_request_set_ipv4_str(spfrequest, ip.c_str())) { + SPF_request_free(spfrequest); // Clean up on failure + throw std::runtime_error("Error configuring IP for SPF request"); + } + if (SPF_request_set_helo_dom(spfrequest, helo.c_str())) { + SPF_request_free(spfrequest); // Clean up on failure + throw std::runtime_error("Error configuring HELO for SPF request"); + } + if (SPF_request_set_env_from(spfrequest, from.c_str())) { + SPF_request_free(spfrequest); // Clean up on failure + throw std::runtime_error("Error configuring FROM for SPF request"); + } - //make the actual query - pthread_mutex_lock(&mutex); - SPF_request_query_mailfrom(spfrequest,&spfresponse); - pthread_mutex_unlock(&mutex); + // Make the actual query + SPF_response_t* spfresponse = nullptr; // Local response variable + SPF_request_query_mailfrom(spfrequest, &spfresponse); - if(NULL!=spfresponse) - { - retval=(SPF_RESULT_FAIL==SPF_response_result(spfresponse)||SPF_RESULT_SOFTFAIL==SPF_response_result(spfresponse))?false:true; - SPF_response_free(spfresponse); - } + bool retval = false; + if (spfresponse) { + retval = !(SPF_response_result(spfresponse) == SPF_RESULT_FAIL || + SPF_response_result(spfresponse) == SPF_RESULT_SOFTFAIL); + SPF_response_free(spfresponse); // Free the response + } - return retval; + SPF_request_free(spfrequest); // Free the request + return retval; } diff --git a/src/Spf.h b/src/Spf.h index 9e1a07f..ce968fd 100644 --- a/src/Spf.h +++ b/src/Spf.h @@ -38,7 +38,7 @@ class Spf Spf(); ~Spf(); static void deinitialize(); - bool query(string,string,string); + bool query(const string&, const string&, const string&); }; #endif //SPF_H diff --git a/src/test/mocks/libspf2_mock.h b/src/test/mocks/libspf2_mock.h new file mode 100644 index 0000000..09d61b9 --- /dev/null +++ b/src/test/mocks/libspf2_mock.h @@ -0,0 +1,96 @@ +#ifndef LIBSPF2_MOCK_H +#define LIBSPF2_MOCK_H +#include +#include +#include +#include + +// Control variables to adjust behavior of mocked functions +extern "C" { + static SPF_errcode_t spf_set_ipv4_result = SPF_E_SUCCESS; + static SPF_errcode_t spf_set_helo_result = SPF_E_SUCCESS; + static int spf_set_from_result; + static SPF_response_t* spf_mock_response = nullptr; + static SPF_errcode_t spf_request_query_result = SPF_E_SUCCESS; + + // New control variables for SPF_server mocking + static SPF_server_t* spf_mock_server = nullptr; + static bool spf_server_new_should_fail = false; + + SPF_server_t* SPF_server_new(SPF_server_dnstype_t dnstype,int debug) + { + if (spf_server_new_should_fail) { + return nullptr; + } + return spf_mock_server ? spf_mock_server : new SPF_server_t(); + } + + void SPF_server_free(SPF_server_t* server) { + delete server; + } + + SPF_request_t* SPF_request_new(SPF_server_t *server) { + return new SPF_request_t(); // Simply allocate and return new request + } + + void SPF_request_free(SPF_request_t* request) { + delete request; // Deallocate request + } + + SPF_errcode_t SPF_request_set_ipv4_str(SPF_request_t* request, const char* ip) { + return spf_set_ipv4_result; // Use controllable result + } + + SPF_errcode_t SPF_request_set_helo_dom(SPF_request_t* request, const char* helo) { + return spf_set_helo_result; // Use controllable result + } + + int SPF_request_set_env_from(SPF_request_t* request, const char* from) { + return spf_set_from_result; // Use controllable result + } + + SPF_errcode_t SPF_request_query_mailfrom(SPF_request_t* request, SPF_response_t** response) { + *response = spf_mock_response; + return spf_request_query_result; + } + + SPF_result_t SPF_response_result(SPF_response_t* response) { + return response->result; // Return the result + } + + void SPF_response_free(SPF_response_t* response) { + delete response; // Deallocate response + } +} + +// Functions to set return values for mocked functions +void SetSpfMockReturnIPv4Value(SPF_errcode_t value) { + spf_set_ipv4_result = value; +} + +void SetSpfMockReturnHeloValue(SPF_errcode_t value) { + spf_set_helo_result = value; +} + +void SetSpfMockReturnFromValue(int value) { + spf_set_from_result = value; +} + +void SetSpfRequestQueryResult(SPF_errcode_t value) { + spf_request_query_result = value; +} + +void SetSpfMockResponse(SPF_response_t* mockResponse) { + spf_mock_response = mockResponse; +} + +// New functions for SPF_server mocking +void SetSpfMockServer(SPF_server_t* mockServer) { + spf_mock_server = mockServer; +} + +void SetSpfServerNewShouldFail(bool shouldFail) { + spf_server_new_should_fail = shouldFail; +} + +#endif // LIBSPF2_MOCK_H diff --git a/src/test/MockSocket.h b/src/test/mocks/socket_mock.h similarity index 100% rename from src/test/MockSocket.h rename to src/test/mocks/socket_mock.h diff --git a/src/test/ProxyTest.cpp b/src/test/tests/proxy_test.cpp similarity index 98% rename from src/test/ProxyTest.cpp rename to src/test/tests/proxy_test.cpp index c8e0412..7a06603 100644 --- a/src/test/ProxyTest.cpp +++ b/src/test/tests/proxy_test.cpp @@ -1,7 +1,7 @@ // ProxyTest.cpp #include #include "Proxy.h" -#include "MockSocket.h" +#include "socket_mock.h" class ProxyTest : public ::testing::Test { protected: @@ -60,4 +60,4 @@ TEST_F(ProxyTest, HandlesEmptyLine) { int main(int argc, char** argv) { ::testing::InitGoogleMock(&argc, argv); return RUN_ALL_TESTS(); -} \ No newline at end of file +} diff --git a/src/test/tests/spf_test.cpp b/src/test/tests/spf_test.cpp new file mode 100644 index 0000000..b205875 --- /dev/null +++ b/src/test/tests/spf_test.cpp @@ -0,0 +1,98 @@ +#include +#include "Spf.h" + +#include "libspf2_mock.h" + +// Mock the SPF server responses for unit testing +class MockSPFServer { +public: + static void initialize() { + // Initialize any mock data here + } + + static void cleanup() { + // Cleanup if needed + } + + static SPF_response_t* mockResponse(SPF_result_t result) { + SPF_response_t* response = new SPF_response_t; // Replace with actual allocation + response->result = result; // Set the desired mock result + return response; + } +}; + +// Test Fixture for SPF tests +class SpfTest : public ::testing::Test { +protected: + Spf* spf; + + void SetUp() override { + // Create a new Spf instance before each test + spf = new Spf(); + } + + void TearDown() override { + // Clean up after each test + delete spf; + spf->deinitialize(); + } +}; + +// Test the construction of the Spf object +TEST_F(SpfTest, Construction) { + EXPECT_NO_THROW({ + Spf testSpf; + }); +} + +// Test SPF querying with valid parameters +TEST_F(SpfTest, QueryValidParameters) { + // Assuming the mocked SPF server is set up to return a valid response + MockSPFServer::initialize(); + + bool result = spf->query("192.0.2.1", "mail.example.com", "test@example.com"); + EXPECT_TRUE(result); + + MockSPFServer::cleanup(); +} + +// Test SPF querying with failed result +TEST_F(SpfTest, QueryFailResult) { + // Mock the response to return a fail result here + SPF_response_t* response = MockSPFServer::mockResponse(SPF_RESULT_FAIL); + + bool result = spf->query("198.51.100.1", "fail.example.com", "test@fail.com"); + EXPECT_FALSE(result); + + delete response; // Clean up mocked response +} + +// Test SPF querying with an empty HELO string +TEST_F(SpfTest, QueryEmptyHelo) { + EXPECT_THROW({ + spf->query("192.0.2.1", "", "test@example.com"); + }, std::runtime_error); +} + +// Test SPF querying with invalid IP format +TEST_F(SpfTest, QueryInvalidIPAddress) { + EXPECT_THROW({ + spf->query("invalid_ip", "mail.example.com", "test@example.com"); + }, std::runtime_error); +} + +// Test SPF request failure +TEST_F(SpfTest, QueryRequestFailure) { + // Here you might want to simulate a situation + // where the request cannot be created or fails due to some other reason. + spf->deinitialize(); // Ensure the server is cleaned up before running this. + + EXPECT_THROW({ + spf->query("192.0.2.1", "mail.example.com", "test@example.com"); + }, std::runtime_error); +} + +int main(int argc, char **argv) { + ::testing::InitGoogleTest(&argc, argv); + return RUN_ALL_TESTS(); +}