Use unique_ptr and C++ casting in Examples (seladb#1643)

lumiZGorlic · web-flow · commit feba0b7124a4 · 2024-11-19T23:18:06.000-08:00
diff --git a/Examples/ArpSpoofing/main.cpp b/Examples/ArpSpoofing/main.cpp
@@ -65,7 +65,7 @@ pcpp::MacAddress getMacAddress(const pcpp::IPv4Address& ipAddr, pcpp::PcapLiveDe
 
 	pcpp::MacAddress macSrc = pDevice->getMacAddress();
 	pcpp::MacAddress macDst(0xff, 0xff, 0xff, 0xff, 0xff, 0xff);
-	pcpp::EthLayer ethLayer(macSrc, macDst, (uint16_t)PCPP_ETHERTYPE_ARP);
+	pcpp::EthLayer ethLayer(macSrc, macDst, static_cast<uint16_t>(PCPP_ETHERTYPE_ARP));
 	pcpp::ArpLayer arpLayer(pcpp::ARP_REQUEST, pDevice->getMacAddress(), pDevice->getMacAddress(),
 	                        pDevice->getIPv4Address(), ipAddr);
 
@@ -136,15 +136,15 @@ void doArpSpoofing(pcpp::PcapLiveDevice* pDevice, const pcpp::IPv4Address& gatew
 
 	// Create ARP reply for the gateway
 	pcpp::Packet gwArpReply(500);
-	pcpp::EthLayer gwEthLayer(deviceMacAddress, gatewayMacAddr, (uint16_t)PCPP_ETHERTYPE_ARP);
+	pcpp::EthLayer gwEthLayer(deviceMacAddress, gatewayMacAddr, static_cast<uint16_t>(PCPP_ETHERTYPE_ARP));
 	pcpp::ArpLayer gwArpLayer(pcpp::ARP_REPLY, pDevice->getMacAddress(), gatewayMacAddr, victimAddr, gatewayAddr);
 	gwArpReply.addLayer(&gwEthLayer);
 	gwArpReply.addLayer(&gwArpLayer);
 	gwArpReply.computeCalculateFields();
 
 	// Create ARP reply for the victim
 	pcpp::Packet victimArpReply(500);
-	pcpp::EthLayer victimEthLayer(deviceMacAddress, victimMacAddr, (uint16_t)PCPP_ETHERTYPE_ARP);
+	pcpp::EthLayer victimEthLayer(deviceMacAddress, victimMacAddr, static_cast<uint16_t>(PCPP_ETHERTYPE_ARP));
 	pcpp::ArpLayer victimArpLayer(pcpp::ARP_REPLY, pDevice->getMacAddress(), victimMacAddr, gatewayAddr, victimAddr);
 	victimArpReply.addLayer(&victimEthLayer);
 	victimArpReply.addLayer(&victimArpLayer);
diff --git a/Examples/Arping/main.cpp b/Examples/Arping/main.cpp
@@ -101,7 +101,7 @@ void listInterfaces()
  */
 void onApplicationInterrupted(void* cookie)
 {
-	auto shouldStop = (bool*)cookie;
+	auto shouldStop = static_cast<bool*>(cookie);
 	*shouldStop = true;
 }
 
diff --git a/Examples/HttpAnalyzer/HttpStatsCollector.h b/Examples/HttpAnalyzer/HttpStatsCollector.h
@@ -347,9 +347,9 @@ class HttpStatsCollector
 		if (m_FlowTable.size() != 0)
 		{
 			m_GeneralStats.averageAmountOfDataPerFlow =
-			    (double)m_GeneralStats.amountOfHttpTraffic / (double)m_FlowTable.size();
+			    static_cast<double>(m_GeneralStats.amountOfHttpTraffic) / static_cast<double>(m_FlowTable.size());
 			m_GeneralStats.averageNumOfPacketsPerFlow =
-			    (double)m_GeneralStats.numOfHttpPackets / (double)m_FlowTable.size();
+			    static_cast<double>(m_GeneralStats.numOfHttpPackets) / static_cast<double>(m_FlowTable.size());
 		}
 
 		return hashVal;
@@ -419,7 +419,8 @@ class HttpStatsCollector
 				// calc average transactions per flow
 				if (m_FlowTable.size() != 0)
 					m_GeneralStats.averageNumOfHttpTransactionsPerFlow =
-					    (double)m_GeneralStats.numOfHttpTransactions / (double)m_FlowTable.size();
+					    static_cast<double>(m_GeneralStats.numOfHttpTransactions) /
+					    static_cast<double>(m_FlowTable.size());
 			}
 
 			// set last seen sequence number
@@ -435,8 +436,8 @@ class HttpStatsCollector
 		m_RequestStats.numOfMessages++;
 		m_RequestStats.totalMessageHeaderSize += req->getHeaderLen();
 		if (m_RequestStats.numOfMessages != 0)
-			m_RequestStats.averageMessageHeaderSize =
-			    (double)m_RequestStats.totalMessageHeaderSize / (double)m_RequestStats.numOfMessages;
+			m_RequestStats.averageMessageHeaderSize = static_cast<double>(m_RequestStats.totalMessageHeaderSize) /
+			                                          static_cast<double>(m_RequestStats.numOfMessages);
 
 		// extract hostname and add to hostname count map
 		pcpp::HeaderField* hostField = req->getFieldByName(PCPP_HTTP_HOST_FIELD);
@@ -454,8 +455,8 @@ class HttpStatsCollector
 		m_ResponseStats.numOfMessages++;
 		m_ResponseStats.totalMessageHeaderSize += res->getHeaderLen();
 		if (m_ResponseStats.numOfMessages != 0)
-			m_ResponseStats.averageMessageHeaderSize =
-			    (double)m_ResponseStats.totalMessageHeaderSize / (double)m_ResponseStats.numOfMessages;
+			m_ResponseStats.averageMessageHeaderSize = static_cast<double>(m_ResponseStats.totalMessageHeaderSize) /
+			                                           static_cast<double>(m_ResponseStats.numOfMessages);
 
 		// extract content-length (if exists)
 		pcpp::HeaderField* contentLengthField = res->getFieldByName(PCPP_HTTP_CONTENT_LENGTH_FIELD);
@@ -464,8 +465,9 @@ class HttpStatsCollector
 			m_ResponseStats.numOfMessagesWithContentLength++;
 			m_ResponseStats.totalContentLengthSize += atoi(contentLengthField->getFieldValue().c_str());
 			if (m_ResponseStats.numOfMessagesWithContentLength != 0)
-				m_ResponseStats.averageContentLengthSize = (double)m_ResponseStats.totalContentLengthSize /
-				                                           (double)m_ResponseStats.numOfMessagesWithContentLength;
+				m_ResponseStats.averageContentLengthSize =
+				    static_cast<double>(m_ResponseStats.totalContentLengthSize) /
+				    static_cast<double>(m_ResponseStats.numOfMessagesWithContentLength);
 		}
 
 		// extract content-type and add to content-type map
@@ -497,7 +499,7 @@ class HttpStatsCollector
 
 		gettimeofday(&tv, nullptr);
 
-		return (((double)tv.tv_sec) + (double)(tv.tv_usec / 1000000.0));
+		return ((static_cast<double>(tv.tv_sec)) + static_cast<double>(tv.tv_usec / 1000000.0));
 	}
 
 	HttpGeneralStats m_GeneralStats;
diff --git a/Examples/HttpAnalyzer/main.cpp b/Examples/HttpAnalyzer/main.cpp
@@ -17,6 +17,7 @@
  * For more details about modes of operation and parameters run HttpAnalyzer -h
  */
 
+#include <memory>
 #include <iomanip>
 #include <algorithm>
 #include "PcapLiveDeviceList.h"
@@ -150,7 +151,7 @@ void httpPacketArrive(pcpp::RawPacket* packet, pcpp::PcapLiveDevice* dev, void*
 	// parse the packet
 	pcpp::Packet parsedPacket(packet);
 
-	HttpPacketArrivedData* data = (HttpPacketArrivedData*)cookie;
+	HttpPacketArrivedData* data = static_cast<HttpPacketArrivedData*>(cookie);
 
 	// give the packet to the collector
 	data->statsCollector->collectStats(&parsedPacket);
@@ -392,7 +393,7 @@ void printCurrentRates(HttpStatsCollector& collector)
  */
 void onApplicationInterrupted(void* cookie)
 {
-	bool* shouldStop = (bool*)cookie;
+	bool* shouldStop = static_cast<bool*>(cookie);
 	*shouldStop = true;
 }
 
@@ -402,7 +403,7 @@ void onApplicationInterrupted(void* cookie)
 void analyzeHttpFromPcapFile(const std::string& pcapFileName, uint16_t dstPort)
 {
 	// open input file (pcap or pcapng file)
-	pcpp::IFileReaderDevice* reader = pcpp::IFileReaderDevice::getReader(pcapFileName);
+	std::unique_ptr<pcpp::IFileReaderDevice> reader(pcpp::IFileReaderDevice::getReader(pcapFileName));
 
 	if (!reader->open())
 		EXIT_WITH_ERROR("Could not open input pcap file");
@@ -427,9 +428,6 @@ void analyzeHttpFromPcapFile(const std::string& pcapFileName, uint16_t dstPort)
 
 	// close input file
 	reader->close();
-
-	// free reader memory
-	delete reader;
 }
 
 /**
@@ -447,10 +445,10 @@ void analyzeHttpFromLiveTraffic(pcpp::PcapLiveDevice* dev, bool printRatesPeriod
 		EXIT_WITH_ERROR("Could not set up filter on device");
 
 	// if needed to save the captured packets to file - open a writer device
-	pcpp::PcapFileWriterDevice* pcapWriter = nullptr;
+	std::unique_ptr<pcpp::PcapFileWriterDevice> pcapWriter;
 	if (savePacketsToFileName != "")
 	{
-		pcapWriter = new pcpp::PcapFileWriterDevice(savePacketsToFileName);
+		pcapWriter.reset(new pcpp::PcapFileWriterDevice(savePacketsToFileName));
 		if (!pcapWriter->open())
 		{
 			EXIT_WITH_ERROR("Could not open pcap file for writing");
@@ -461,7 +459,7 @@ void analyzeHttpFromLiveTraffic(pcpp::PcapLiveDevice* dev, bool printRatesPeriod
 	HttpPacketArrivedData data;
 	HttpStatsCollector collector(dstPort);
 	data.statsCollector = &collector;
-	data.pcapWriter = pcapWriter;
+	data.pcapWriter = pcapWriter.get();
 	dev->startCapture(httpPacketArrive, &data);
 
 	// register the on app close event to print summary stats on app termination
@@ -495,7 +493,6 @@ void analyzeHttpFromLiveTraffic(pcpp::PcapLiveDevice* dev, bool printRatesPeriod
 	if (pcapWriter != nullptr)
 	{
 		pcapWriter->close();
-		delete pcapWriter;
 	}
 }
 
diff --git a/Examples/PcapSplitter/main.cpp b/Examples/PcapSplitter/main.cpp
@@ -45,6 +45,7 @@
  */
 
 #include <iostream>
+#include <memory>
 #include <string>
 #include <unordered_map>
 #include <RawPacket.h>
@@ -294,66 +295,67 @@ int main(int argc, char* argv[])
 		EXIT_WITH_ERROR("Split method was not given");
 	}
 
-	Splitter* splitter = nullptr;
+	std::unique_ptr<Splitter> splitter;
 
 	// decide of the splitter to use, according to the user's choice
 	if (method == SPLIT_BY_FILE_SIZE)
 	{
 		uint64_t paramAsUint64 = (paramWasSet ? strtoull(param, nullptr, 10) : 0);
-		splitter = new FileSizeSplitter(paramAsUint64);
+		splitter.reset(new FileSizeSplitter(paramAsUint64));
 	}
 	else if (method == SPLIT_BY_PACKET_COUNT)
 	{
 		int paramAsInt = (paramWasSet ? atoi(param) : 0);
-		splitter = new PacketCountSplitter(paramAsInt);
+		splitter.reset(new PacketCountSplitter(paramAsInt));
 	}
 	else if (method == SPLIT_BY_IP_CLIENT)
 	{
 		int paramAsInt = (paramWasSet ? atoi(param) : SplitterWithMaxFiles::UNLIMITED_FILES_MAGIC_NUMBER);
-		splitter = new ClientIPSplitter(paramAsInt);
+		splitter.reset(new ClientIPSplitter(paramAsInt));
 	}
 	else if (method == SPLIT_BY_IP_SERVER)
 	{
 		int paramAsInt = (paramWasSet ? atoi(param) : SplitterWithMaxFiles::UNLIMITED_FILES_MAGIC_NUMBER);
-		splitter = new ServerIPSplitter(paramAsInt);
+		splitter.reset(new ServerIPSplitter(paramAsInt));
 	}
 	else if (method == SPLIT_BY_SERVER_PORT)
 	{
 		int paramAsInt = (paramWasSet ? atoi(param) : SplitterWithMaxFiles::UNLIMITED_FILES_MAGIC_NUMBER);
-		splitter = new ServerPortSplitter(paramAsInt);
+		splitter.reset(new ServerPortSplitter(paramAsInt));
 	}
 	else if (method == SPLIT_BY_CLIENT_PORT)
 	{
 		int paramAsInt = (paramWasSet ? atoi(param) : SplitterWithMaxFiles::UNLIMITED_FILES_MAGIC_NUMBER);
-		splitter = new ClientPortSplitter(paramAsInt);
+		splitter.reset(new ClientPortSplitter(paramAsInt));
 	}
 	else if (method == SPLIT_BY_2_TUPLE)
 	{
 		int paramAsInt = (paramWasSet ? atoi(param) : SplitterWithMaxFiles::UNLIMITED_FILES_MAGIC_NUMBER);
-		splitter = new TwoTupleSplitter(paramAsInt);
+		splitter.reset(new TwoTupleSplitter(paramAsInt));
 	}
 	else if (method == SPLIT_BY_5_TUPLE)
 	{
 		int paramAsInt = (paramWasSet ? atoi(param) : SplitterWithMaxFiles::UNLIMITED_FILES_MAGIC_NUMBER);
-		splitter = new FiveTupleSplitter(paramAsInt);
+		splitter.reset(new FiveTupleSplitter(paramAsInt));
 	}
 	else if (method == SPLIT_BY_BPF_FILTER)
 	{
-		splitter = new BpfCriteriaSplitter(std::string(param));
+		splitter.reset(new BpfCriteriaSplitter(std::string(param)));
 	}
 	else if (method == SPLIT_BY_ROUND_ROBIN)
 	{
 		int paramAsInt = (paramWasSet ? atoi(param) : 0);
-		splitter = new RoundRobinSplitter(paramAsInt);
+		splitter.reset(new RoundRobinSplitter(paramAsInt));
 	}
 	else
+	{
 		EXIT_WITH_ERROR("Unknown method '" << method << "'");
+	}
 
 	// verify splitter param is legal, otherwise return an error
 	std::string errorStr;
 	if (!splitter->isSplitterParamLegal(errorStr))
 	{
-		delete splitter;
 		EXIT_WITH_ERROR(errorStr);
 	}
 
@@ -362,8 +364,8 @@ int main(int argc, char* argv[])
 	    outputPcapDir + std::string(1, SEPARATOR) + getFileNameWithoutExtension(inputPcapFileName) + "-";
 
 	// open a pcap file for reading
-	pcpp::IFileReaderDevice* reader = pcpp::IFileReaderDevice::getReader(inputPcapFileName);
-	bool isReaderPcapng = (dynamic_cast<pcpp::PcapNgFileReaderDevice*>(reader) != nullptr);
+	std::unique_ptr<pcpp::IFileReaderDevice> reader(pcpp::IFileReaderDevice::getReader(inputPcapFileName));
+	bool isReaderPcapng = (dynamic_cast<pcpp::PcapNgFileReaderDevice*>(reader.get()) != nullptr);
 
 	if (reader == nullptr || !reader->open())
 	{
@@ -387,7 +389,7 @@ int main(int argc, char* argv[])
 	pcpp::RawPacket rawPacket;
 
 	// prepare a map of file number to IFileWriterDevice
-	std::unordered_map<int, pcpp::IFileWriterDevice*> outputFiles;
+	std::unordered_map<int, std::unique_ptr<pcpp::IFileWriterDevice>> outputFiles;
 
 	// read all packets from input file, for each packet do:
 	while (reader->getNextPacket(rawPacket))
@@ -411,12 +413,12 @@ int main(int argc, char* argv[])
 			if (isReaderPcapng)
 			{
 				// if reader is pcapng, create a pcapng writer
-				outputFiles[fileNum] = new pcpp::PcapNgFileWriterDevice(fileName);
+				outputFiles[fileNum].reset(new pcpp::PcapNgFileWriterDevice(fileName));
 			}
 			else
 			{
 				// if reader is pcap, create a pcap writer
-				outputFiles[fileNum] = new pcpp::PcapFileWriterDevice(fileName, rawPacket.getLinkLayerType());
+				outputFiles[fileNum].reset(new pcpp::PcapFileWriterDevice(fileName, rawPacket.getLinkLayerType()));
 			}
 
 			// open the writer
@@ -438,12 +440,12 @@ int main(int argc, char* argv[])
 			if (isReaderPcapng)
 			{
 				// if reader is pcapng, create a pcapng writer
-				outputFiles[fileNum] = new pcpp::PcapNgFileWriterDevice(fileName);
+				outputFiles[fileNum].reset(new pcpp::PcapNgFileWriterDevice(fileName));
 			}
 			else
 			{
 				// if reader is pcap, create a pcap writer
-				outputFiles[fileNum] = new pcpp::PcapFileWriterDevice(fileName, rawPacket.getLinkLayerType());
+				outputFiles[fileNum].reset(new pcpp::PcapFileWriterDevice(fileName, rawPacket.getLinkLayerType()));
 			}
 
 			// open the writer in __append__ mode
@@ -464,8 +466,7 @@ int main(int argc, char* argv[])
 				outputFiles[fileId]->close();
 
 				// free the writer memory and put null in the map record
-				delete outputFiles[fileId];
-				outputFiles[fileId] = nullptr;
+				outputFiles[fileId].reset();
 			}
 		}
 
@@ -478,17 +479,12 @@ int main(int argc, char* argv[])
 	// close the reader file
 	reader->close();
 
-	// free reader memory
-	delete reader;
-	delete splitter;
-
 	// close the writer files which are still open
 	for (const auto& it : outputFiles)
 	{
 		if (it.second != nullptr)
 		{
 			it.second->close();
-			delete it.second;
 		}
 	}
 
diff --git a/Examples/SSLAnalyzer/SSLStatsCollector.h b/Examples/SSLAnalyzer/SSLStatsCollector.h
@@ -302,9 +302,9 @@ class SSLStatsCollector
 		if (m_FlowTable.size() != 0)
 		{
 			m_GeneralStats.averageAmountOfDataPerFlow =
-			    (double)m_GeneralStats.amountOfSSLTraffic / (double)m_FlowTable.size();
+			    static_cast<double>(m_GeneralStats.amountOfSSLTraffic) / static_cast<double>(m_FlowTable.size());
 			m_GeneralStats.averageNumOfPacketsPerFlow =
-			    (double)m_GeneralStats.numOfSSLPackets / (double)m_FlowTable.size();
+			    static_cast<double>(m_GeneralStats.numOfSSLPackets) / static_cast<double>(m_FlowTable.size());
 		}
 
 		return hashVal;
@@ -406,7 +406,7 @@ class SSLStatsCollector
 
 		gettimeofday(&tv, nullptr);
 
-		return (((double)tv.tv_sec) + (double)(tv.tv_usec / 1000000.0));
+		return ((static_cast<double>(tv.tv_sec)) + static_cast<double>(tv.tv_usec / 1000000.0));
 	}
 
 	SSLGeneralStats m_GeneralStats;
diff --git a/Examples/SSLAnalyzer/main.cpp b/Examples/SSLAnalyzer/main.cpp

Original file line number	Diff line number	Diff line change
`@@ -101,7 +101,7 @@ void listInterfaces()`
`101`	`101`	`*/`
`102`	`102`	`void onApplicationInterrupted(void* cookie)`
`103`	`103`	`{`
`104`		`- auto shouldStop = (bool*)cookie;`
	`104`	`+ auto shouldStop = static_cast<bool*>(cookie);`
`105`	`105`	`*shouldStop = true;`
`106`	`106`	`}`
`107`	`107`
Original file line number	Diff line number	Diff line change
`@@ -45,6 +45,7 @@`
`45`	`45`	`*/`
`46`	`46`
`47`	`47`	`#include <iostream>`
	`48`	`+#include <memory>`
`48`	`49`	`#include <string>`
`49`	`50`	`#include <unordered_map>`
`50`	`51`	`#include <RawPacket.h>`
`@@ -294,66 +295,67 @@ int main(int argc, char* argv[])`
`294`	`295`	`EXIT_WITH_ERROR("Split method was not given");`
`295`	`296`	`}`
`296`	`297`
`297`		`- Splitter* splitter = nullptr;`
	`298`	`+ std::unique_ptr<Splitter> splitter;`
`298`	`299`
`299`	`300`	`// decide of the splitter to use, according to the user's choice`
`300`	`301`	`if (method == SPLIT_BY_FILE_SIZE)`
`301`	`302`	`{`
`302`	`303`	`uint64_t paramAsUint64 = (paramWasSet ? strtoull(param, nullptr, 10) : 0);`
`303`		`- splitter = new FileSizeSplitter(paramAsUint64);`
	`304`	`+ splitter.reset(new FileSizeSplitter(paramAsUint64));`
`304`	`305`	`}`
`305`	`306`	`else if (method == SPLIT_BY_PACKET_COUNT)`
`306`	`307`	`{`
`307`	`308`	`int paramAsInt = (paramWasSet ? atoi(param) : 0);`
`308`		`- splitter = new PacketCountSplitter(paramAsInt);`
	`309`	`+ splitter.reset(new PacketCountSplitter(paramAsInt));`
`309`	`310`	`}`
`310`	`311`	`else if (method == SPLIT_BY_IP_CLIENT)`
`311`	`312`	`{`
`312`	`313`	`int paramAsInt = (paramWasSet ? atoi(param) : SplitterWithMaxFiles::UNLIMITED_FILES_MAGIC_NUMBER);`
`313`		`- splitter = new ClientIPSplitter(paramAsInt);`
	`314`	`+ splitter.reset(new ClientIPSplitter(paramAsInt));`
`314`	`315`	`}`
`315`	`316`	`else if (method == SPLIT_BY_IP_SERVER)`
`316`	`317`	`{`
`317`	`318`	`int paramAsInt = (paramWasSet ? atoi(param) : SplitterWithMaxFiles::UNLIMITED_FILES_MAGIC_NUMBER);`
`318`		`- splitter = new ServerIPSplitter(paramAsInt);`
	`319`	`+ splitter.reset(new ServerIPSplitter(paramAsInt));`
`319`	`320`	`}`
`320`	`321`	`else if (method == SPLIT_BY_SERVER_PORT)`
`321`	`322`	`{`
`322`	`323`	`int paramAsInt = (paramWasSet ? atoi(param) : SplitterWithMaxFiles::UNLIMITED_FILES_MAGIC_NUMBER);`
`323`		`- splitter = new ServerPortSplitter(paramAsInt);`
	`324`	`+ splitter.reset(new ServerPortSplitter(paramAsInt));`
`324`	`325`	`}`
`325`	`326`	`else if (method == SPLIT_BY_CLIENT_PORT)`
`326`	`327`	`{`
`327`	`328`	`int paramAsInt = (paramWasSet ? atoi(param) : SplitterWithMaxFiles::UNLIMITED_FILES_MAGIC_NUMBER);`
`328`		`- splitter = new ClientPortSplitter(paramAsInt);`
	`329`	`+ splitter.reset(new ClientPortSplitter(paramAsInt));`
`329`	`330`	`}`
`330`	`331`	`else if (method == SPLIT_BY_2_TUPLE)`
`331`	`332`	`{`
`332`	`333`	`int paramAsInt = (paramWasSet ? atoi(param) : SplitterWithMaxFiles::UNLIMITED_FILES_MAGIC_NUMBER);`
`333`		`- splitter = new TwoTupleSplitter(paramAsInt);`
	`334`	`+ splitter.reset(new TwoTupleSplitter(paramAsInt));`
`334`	`335`	`}`
`335`	`336`	`else if (method == SPLIT_BY_5_TUPLE)`
`336`	`337`	`{`
`337`	`338`	`int paramAsInt = (paramWasSet ? atoi(param) : SplitterWithMaxFiles::UNLIMITED_FILES_MAGIC_NUMBER);`
`338`		`- splitter = new FiveTupleSplitter(paramAsInt);`
	`339`	`+ splitter.reset(new FiveTupleSplitter(paramAsInt));`
`339`	`340`	`}`
`340`	`341`	`else if (method == SPLIT_BY_BPF_FILTER)`
`341`	`342`	`{`
`342`		`- splitter = new BpfCriteriaSplitter(std::string(param));`
	`343`	`+ splitter.reset(new BpfCriteriaSplitter(std::string(param)));`
`343`	`344`	`}`
`344`	`345`	`else if (method == SPLIT_BY_ROUND_ROBIN)`
`345`	`346`	`{`
`346`	`347`	`int paramAsInt = (paramWasSet ? atoi(param) : 0);`
`347`		`- splitter = new RoundRobinSplitter(paramAsInt);`
	`348`	`+ splitter.reset(new RoundRobinSplitter(paramAsInt));`
`348`	`349`	`}`
`349`	`350`	`else`
	`351`	`+ {`
`350`	`352`	`EXIT_WITH_ERROR("Unknown method '" << method << "'");`
	`353`	`+ }`
`351`	`354`
`352`	`355`	`// verify splitter param is legal, otherwise return an error`
`353`	`356`	`std::string errorStr;`
`354`	`357`	`if (!splitter->isSplitterParamLegal(errorStr))`
`355`	`358`	`{`
`356`		`- delete splitter;`
`357`	`359`	`EXIT_WITH_ERROR(errorStr);`
`358`	`360`	`}`
`359`	`361`
`@@ -362,8 +364,8 @@ int main(int argc, char* argv[])`
`362`	`364`	`outputPcapDir + std::string(1, SEPARATOR) + getFileNameWithoutExtension(inputPcapFileName) + "-";`
`363`	`365`
`364`	`366`	`// open a pcap file for reading`
`365`		`- pcpp::IFileReaderDevice* reader = pcpp::IFileReaderDevice::getReader(inputPcapFileName);`
`366`		`- bool isReaderPcapng = (dynamic_cast<pcpp::PcapNgFileReaderDevice*>(reader) != nullptr);`
	`367`	`+ std::unique_ptr<pcpp::IFileReaderDevice> reader(pcpp::IFileReaderDevice::getReader(inputPcapFileName));`
	`368`	`+ bool isReaderPcapng = (dynamic_cast<pcpp::PcapNgFileReaderDevice*>(reader.get()) != nullptr);`
`367`	`369`
`368`	`370`	`if (reader == nullptr \|\| !reader->open())`
`369`	`371`	`{`
`@@ -387,7 +389,7 @@ int main(int argc, char* argv[])`
`387`	`389`	`pcpp::RawPacket rawPacket;`
`388`	`390`
`389`	`391`	`// prepare a map of file number to IFileWriterDevice`
`390`		`- std::unordered_map<int, pcpp::IFileWriterDevice*> outputFiles;`
	`392`	`+ std::unordered_map<int, std::unique_ptr<pcpp::IFileWriterDevice>> outputFiles;`
`391`	`393`
`392`	`394`	`// read all packets from input file, for each packet do:`
`393`	`395`	`while (reader->getNextPacket(rawPacket))`
`@@ -411,12 +413,12 @@ int main(int argc, char* argv[])`
`411`	`413`	`if (isReaderPcapng)`
`412`	`414`	`{`
`413`	`415`	`// if reader is pcapng, create a pcapng writer`
`414`		`- outputFiles[fileNum] = new pcpp::PcapNgFileWriterDevice(fileName);`
	`416`	`+ outputFiles[fileNum].reset(new pcpp::PcapNgFileWriterDevice(fileName));`
`415`	`417`	`}`
`416`	`418`	`else`
`417`	`419`	`{`
`418`	`420`	`// if reader is pcap, create a pcap writer`
`419`		`- outputFiles[fileNum] = new pcpp::PcapFileWriterDevice(fileName, rawPacket.getLinkLayerType());`
	`421`	`+ outputFiles[fileNum].reset(new pcpp::PcapFileWriterDevice(fileName, rawPacket.getLinkLayerType()));`
`420`	`422`	`}`
`421`	`423`
`422`	`424`	`// open the writer`
`@@ -438,12 +440,12 @@ int main(int argc, char* argv[])`
`438`	`440`	`if (isReaderPcapng)`
`439`	`441`	`{`
`440`	`442`	`// if reader is pcapng, create a pcapng writer`
`441`		`- outputFiles[fileNum] = new pcpp::PcapNgFileWriterDevice(fileName);`
	`443`	`+ outputFiles[fileNum].reset(new pcpp::PcapNgFileWriterDevice(fileName));`
`442`	`444`	`}`
`443`	`445`	`else`
`444`	`446`	`{`
`445`	`447`	`// if reader is pcap, create a pcap writer`
`446`		`- outputFiles[fileNum] = new pcpp::PcapFileWriterDevice(fileName, rawPacket.getLinkLayerType());`
	`448`	`+ outputFiles[fileNum].reset(new pcpp::PcapFileWriterDevice(fileName, rawPacket.getLinkLayerType()));`
`447`	`449`	`}`
`448`	`450`
`449`	`451`	`// open the writer in __append__ mode`
`@@ -464,8 +466,7 @@ int main(int argc, char* argv[])`
`464`	`466`	`outputFiles[fileId]->close();`
`465`	`467`
`466`	`468`	`// free the writer memory and put null in the map record`
`467`		`- delete outputFiles[fileId];`
`468`		`- outputFiles[fileId] = nullptr;`
	`469`	`+ outputFiles[fileId].reset();`
`469`	`470`	`}`
`470`	`471`	`}`
`471`	`472`
`@@ -478,17 +479,12 @@ int main(int argc, char* argv[])`
`478`	`479`	`// close the reader file`
`479`	`480`	`reader->close();`
`480`	`481`
`481`		`- // free reader memory`
`482`		`- delete reader;`
`483`		`- delete splitter;`
`484`		`-`
`485`	`482`	`// close the writer files which are still open`
`486`	`483`	`for (const auto& it : outputFiles)`
`487`	`484`	`{`
`488`	`485`	`if (it.second != nullptr)`
`489`	`486`	`{`
`490`	`487`	`it.second->close();`
`491`		`- delete it.second;`
`492`	`488`	`}`
`493`	`489`	`}`
`494`	`490`
Original file line number	Diff line number	Diff line change
`@@ -302,9 +302,9 @@ class SSLStatsCollector`
`302`	`302`	`if (m_FlowTable.size() != 0)`
`303`	`303`	`{`
`304`	`304`	`m_GeneralStats.averageAmountOfDataPerFlow =`
`305`		`- (double)m_GeneralStats.amountOfSSLTraffic / (double)m_FlowTable.size();`
	`305`	`+ static_cast<double>(m_GeneralStats.amountOfSSLTraffic) / static_cast<double>(m_FlowTable.size());`
`306`	`306`	`m_GeneralStats.averageNumOfPacketsPerFlow =`
`307`		`- (double)m_GeneralStats.numOfSSLPackets / (double)m_FlowTable.size();`
	`307`	`+ static_cast<double>(m_GeneralStats.numOfSSLPackets) / static_cast<double>(m_FlowTable.size());`
`308`	`308`	`}`
`309`	`309`
`310`	`310`	`return hashVal;`
`@@ -406,7 +406,7 @@ class SSLStatsCollector`
`406`	`406`
`407`	`407`	`gettimeofday(&tv, nullptr);`
`408`	`408`
`409`		`- return (((double)tv.tv_sec) + (double)(tv.tv_usec / 1000000.0));`
	`409`	`+ return ((static_cast<double>(tv.tv_sec)) + static_cast<double>(tv.tv_usec / 1000000.0));`
`410`	`410`	`}`
`411`	`411`
`412`	`412`	`SSLGeneralStats m_GeneralStats;`