#include <filterparserthread.h>

Inheritance diagram for FilterParserThread:

Collaboration diagram for FilterParserThread:

Signals
void	IPFilterParsed (int ruleCount)

void	IPFilterError ()

Public Member Functions
	FilterParserThread (QObject *parent=nullptr)

	~FilterParserThread ()

void	processFilterFile (const QString &filePath)

lt::ip_filter	IPfilter ()

Protected Member Functions
void	run () override

Private Member Functions
int	findAndNullDelimiter (char *const data, char delimiter, int start, int end, bool reverse=false)

int	trim (char *const data, int start, int end)

int	parseDATFilterFile ()

int	parseP2PFilterFile ()

int	getlineInStream (QDataStream &stream, std::string &name, char delim)

int	parseP2BFilterFile ()

Private Attributes
bool	m_abort

QString	m_filePath

lt::ip_filter	m_filter

Detailed Description

Definition at line 37 of file filterparserthread.h.

Constructor & Destructor Documentation

◆ FilterParserThread()

FilterParserThread::FilterParserThread ( QObject * parent = nullptr )

Definition at line 111 of file filterparserthread.cpp.

     : QThread(parent)
     , m_abort(false)
 {
 }

◆ ~FilterParserThread()

FilterParserThread::~FilterParserThread ( )

Definition at line 117 of file filterparserthread.cpp.

 {
     m_abort = true;
     wait();
 }

References m_abort.

Member Function Documentation

◆ findAndNullDelimiter()

int FilterParserThread::findAndNullDelimiter	(	char *const	data,
		char	delimiter,
		int	start,
		int	end,
		bool	reverse = `false`
	)

private

Definition at line 650 of file filterparserthread.cpp.

 {
     if (!reverse)
     {
         for (int i = start; i <= end; ++i)
         {
             if (data[i] == delimiter)
             {
                 data[i] = '\0';
                 return i;
             }
         }
     }
     else
     {
         for (int i = end; i >= start; --i)
         {
             if (data[i] == delimiter)
             {
                 data[i] = '\0';
                 return i;
             }
         }
     }
  
     return -1;
 }

Referenced by parseDATFilterFile(), and parseP2PFilterFile().

Here is the caller graph for this function:

◆ getlineInStream()

int FilterParserThread::getlineInStream	(	QDataStream &	stream,
		std::string &	name,
		char	delim
	)

private

Definition at line 441 of file filterparserthread.cpp.

 {
     char c;
     int totalRead = 0;
     int read;
     do
     {
         read = stream.readRawData(&c, 1);
         totalRead += read;
         if (read > 0)
         {
             if (c != delim)
             {
                 name += c;
             }
             else
             {
                 // Delim found
                 return totalRead;
             }
         }
     }
     while (read > 0);
  
     return totalRead;
 }

Referenced by parseP2BFilterFile().

Here is the caller graph for this function:

◆ IPfilter()

lt::ip_filter FilterParserThread::IPfilter ( )

Definition at line 611 of file filterparserthread.cpp.

 {
     return m_filter;
 }

References m_filter.

◆ IPFilterError

void FilterParserThread::IPFilterError ( )

signal

Referenced by BitTorrent::Session::enableIPFilter(), and run().

Here is the caller graph for this function:

◆ IPFilterParsed

void FilterParserThread::IPFilterParsed ( int ruleCount )

signal

Referenced by BitTorrent::Session::enableIPFilter(), and run().

Here is the caller graph for this function:

◆ parseDATFilterFile()

int FilterParserThread::parseDATFilterFile ( )

private

Definition at line 124 of file filterparserthread.cpp.

 {
     int ruleCount = 0;
     QFile file(m_filePath);
     if (!file.exists()) return ruleCount;
  
     if (!file.open(QIODevice::ReadOnly | QIODevice::Text))
     {
         LogMsg(tr("I/O Error: Could not open IP filter file in read mode."), Log::CRITICAL);
         return ruleCount;
     }
  
     std::vector<char> buffer(BUFFER_SIZE, 0); // seems a bit faster than QVector
     qint64 bytesRead = 0;
     int offset = 0;
     int start = 0;
     int endOfLine = -1;
     int nbLine = 0;
     int parseErrorCount = 0;
     const auto addLog = [&parseErrorCount](const QString &msg)
     {
         if (parseErrorCount <= MAX_LOGGED_ERRORS)
             LogMsg(msg, Log::CRITICAL);
     };
  
     while (true)
     {
         bytesRead = file.read(buffer.data() + offset, BUFFER_SIZE - offset - 1);
         if (bytesRead < 0)
             break;
         const int dataSize = bytesRead + offset;
         if ((bytesRead == 0) && (dataSize == 0))
             break;
  
         for (start = 0; start < dataSize; ++start)
         {
             endOfLine = -1;
             // The file might have ended without the last line having a newline
             if (!((bytesRead == 0) && (dataSize > 0)))
             {
                 for (int i = start; i < dataSize; ++i)
                 {
                     if (buffer[i] == '\n')
                     {
                         endOfLine = i;
                         // We need to NULL the newline in case the line has only an IP range.
                         // In that case the parser won't work for the end IP, because it ends
                         // with the newline and not with a number.
                         buffer[i] = '\0';
                         break;
                     }
                 }
             }
             else
             {
                 endOfLine = dataSize;
                 buffer[dataSize] = '\0';
             }
  
             if (endOfLine == -1)
             {
                 // read the next chunk from file
                 // but first move(copy) the leftover data to the front of the buffer
                 offset = dataSize - start;
                 memmove(buffer.data(), buffer.data() + start, offset);
                 break;
             }
  
             ++nbLine;
  
             if ((buffer[start] == '#')
                 || ((buffer[start] == '/') && ((start + 1 < dataSize) && (buffer[start + 1] == '/'))))
                 {
                 start = endOfLine;
                 continue;
             }
  
             // Each line should follow this format:
             // 001.009.096.105 - 001.009.096.105 , 000 , Some organization
             // The 3rd entry is access level and if above 127 the IP range isn't blocked.
             const int firstComma = findAndNullDelimiter(buffer.data(), ',', start, endOfLine);
             if (firstComma != -1)
                 findAndNullDelimiter(buffer.data(), ',', firstComma + 1, endOfLine);
  
             // Check if there is an access value (apparently not mandatory)
             if (firstComma != -1)
             {
                 // There is possibly one
                 const long int nbAccess = strtol(buffer.data() + firstComma + 1, nullptr, 10);
                 // Ignoring this rule because access value is too high
                 if (nbAccess > 127L)
                 {
                     start = endOfLine;
                     continue;
                 }
             }
  
             // IP Range should be split by a dash
             const int endOfIPRange = ((firstComma == -1) ? (endOfLine - 1) : (firstComma - 1));
             const int delimIP = findAndNullDelimiter(buffer.data(), '-', start, endOfIPRange);
             if (delimIP == -1)
             {
                 ++parseErrorCount;
                 addLog(tr("IP filter line %1 is malformed.").arg(nbLine));
                 start = endOfLine;
                 continue;
             }
  
             lt::address startAddr;
             int newStart = trim(buffer.data(), start, delimIP - 1);
             if (!parseIPAddress(buffer.data() + newStart, startAddr))
             {
                 ++parseErrorCount;
                 addLog(tr("IP filter line %1 is malformed. Start IP of the range is malformed.").arg(nbLine));
                 start = endOfLine;
                 continue;
             }
  
             lt::address endAddr;
             newStart = trim(buffer.data(), delimIP + 1, endOfIPRange);
             if (!parseIPAddress(buffer.data() + newStart, endAddr))
             {
                 ++parseErrorCount;
                 addLog(tr("IP filter line %1 is malformed. End IP of the range is malformed.").arg(nbLine));
                 start = endOfLine;
                 continue;
             }
  
             if ((startAddr.is_v4() != endAddr.is_v4())
                 || (startAddr.is_v6() != endAddr.is_v6()))
                 {
                 ++parseErrorCount;
                 addLog(tr("IP filter line %1 is malformed. One IP is IPv4 and the other is IPv6!").arg(nbLine));
                 start = endOfLine;
                 continue;
             }
  
             start = endOfLine;
  
             // Now Add to the filter
             try
             {
                 m_filter.add_rule(startAddr, endAddr, lt::ip_filter::blocked);
                 ++ruleCount;
             }
             catch (const std::exception &e)
             {
                 ++parseErrorCount;
                 addLog(tr("IP filter exception thrown for line %1. Exception is: %2")
                        .arg(nbLine).arg(QString::fromLocal8Bit(e.what())));
             }
         }
  
         if (start >= dataSize)
             offset = 0;
     }
  
     if (parseErrorCount > MAX_LOGGED_ERRORS)
         LogMsg(tr("%1 extra IP filter parsing errors occurred.", "513 extra IP filter parsing errors occurred.")
                .arg(parseErrorCount - MAX_LOGGED_ERRORS), Log::CRITICAL);
     return ruleCount;
 }

References anonymous_namespace{filterparserthread.cpp}::BUFFER_SIZE, Log::CRITICAL, nova3.nova2dl::e, file(), findAndNullDelimiter(), LogMsg(), m_filePath, m_filter, anonymous_namespace{filterparserthread.cpp}::MAX_LOGGED_ERRORS, anonymous_namespace{filterparserthread.cpp}::parseIPAddress(), and trim().

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ parseP2BFilterFile()

int FilterParserThread::parseP2BFilterFile ( )

private

Definition at line 469 of file filterparserthread.cpp.

 {
     int ruleCount = 0;
     QFile file(m_filePath);
     if (!file.exists()) return ruleCount;
  
     if (!file.open(QIODevice::ReadOnly))
     {
         LogMsg(tr("I/O Error: Could not open IP filter file in read mode."), Log::CRITICAL);
         return ruleCount;
     }
  
     QDataStream stream(&file);
     // Read header
     char buf[7];
     unsigned char version;
     if (!stream.readRawData(buf, sizeof(buf))
         || memcmp(buf, "\xFF\xFF\xFF\xFFP2B", 7)
         || !stream.readRawData(reinterpret_cast<char*>(&version), sizeof(version)))
         {
         LogMsg(tr("Parsing Error: The filter file is not a valid PeerGuardian P2B file."), Log::CRITICAL);
         return ruleCount;
     }
  
     if ((version == 1) || (version == 2))
     {
         qDebug ("p2b version 1 or 2");
         unsigned int start, end;
  
         std::string name;
         while (getlineInStream(stream, name, '\0') && !m_abort)
         {
             if (!stream.readRawData(reinterpret_cast<char*>(&start), sizeof(start))
                 || !stream.readRawData(reinterpret_cast<char*>(&end), sizeof(end)))
                 {
                 LogMsg(tr("Parsing Error: The filter file is not a valid PeerGuardian P2B file."), Log::CRITICAL);
                 return ruleCount;
             }
  
             // Network byte order to Host byte order
             // asio address_v4 constructor expects it
             // that way
             const lt::address_v4 first(ntohl(start));
             const lt::address_v4 last(ntohl(end));
             // Apply to bittorrent session
             try
             {
                 m_filter.add_rule(first, last, lt::ip_filter::blocked);
                 ++ruleCount;
             }
             catch (const std::exception &) {}
         }
     }
     else if (version == 3)
     {
         qDebug ("p2b version 3");
         unsigned int namecount;
         if (!stream.readRawData(reinterpret_cast<char*>(&namecount), sizeof(namecount)))
         {
             LogMsg(tr("Parsing Error: The filter file is not a valid PeerGuardian P2B file."), Log::CRITICAL);
             return ruleCount;
         }
  
         namecount = ntohl(namecount);
         // Reading names although, we don't really care about them
         for (unsigned int i = 0; i < namecount; ++i)
         {
             std::string name;
             if (!getlineInStream(stream, name, '\0'))
             {
                 LogMsg(tr("Parsing Error: The filter file is not a valid PeerGuardian P2B file."), Log::CRITICAL);
                 return ruleCount;
             }
  
             if (m_abort) return ruleCount;
         }
  
         // Reading the ranges
         unsigned int rangecount;
         if (!stream.readRawData(reinterpret_cast<char*>(&rangecount), sizeof(rangecount)))
         {
             LogMsg(tr("Parsing Error: The filter file is not a valid PeerGuardian P2B file."), Log::CRITICAL);
             return ruleCount;
         }
  
         rangecount = ntohl(rangecount);
         unsigned int name, start, end;
         for (unsigned int i = 0; i < rangecount; ++i)
         {
             if (!stream.readRawData(reinterpret_cast<char*>(&name), sizeof(name))
                 || !stream.readRawData(reinterpret_cast<char*>(&start), sizeof(start))
                 || !stream.readRawData(reinterpret_cast<char*>(&end), sizeof(end)))
                 {
                 LogMsg(tr("Parsing Error: The filter file is not a valid PeerGuardian P2B file."), Log::CRITICAL);
                 return ruleCount;
             }
  
             // Network byte order to Host byte order
             // asio address_v4 constructor expects it
             // that way
             const lt::address_v4 first(ntohl(start));
             const lt::address_v4 last(ntohl(end));
             // Apply to bittorrent session
             try
             {
                 m_filter.add_rule(first, last, lt::ip_filter::blocked);
                 ++ruleCount;
             }
             catch (const std::exception &) {}
  
             if (m_abort) return ruleCount;
         }
     }
     else
     {
         LogMsg(tr("Parsing Error: The filter file is not a valid PeerGuardian P2B file."), Log::CRITICAL);
     }
  
     return ruleCount;
 }

References Log::CRITICAL, file(), getlineInStream(), LogMsg(), m_abort, m_filePath, and m_filter.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ parseP2PFilterFile()

int FilterParserThread::parseP2PFilterFile ( )

private

Definition at line 288 of file filterparserthread.cpp.

 {
     int ruleCount = 0;
     QFile file(m_filePath);
     if (!file.exists()) return ruleCount;
  
     if (!file.open(QIODevice::ReadOnly | QIODevice::Text))
     {
         LogMsg(tr("I/O Error: Could not open IP filter file in read mode."), Log::CRITICAL);
         return ruleCount;
     }
  
     std::vector<char> buffer(BUFFER_SIZE, 0); // seems a bit faster than QVector
     qint64 bytesRead = 0;
     int offset = 0;
     int start = 0;
     int endOfLine = -1;
     int nbLine = 0;
     int parseErrorCount = 0;
     const auto addLog = [&parseErrorCount](const QString &msg)
     {
         if (parseErrorCount <= MAX_LOGGED_ERRORS)
             LogMsg(msg, Log::CRITICAL);
     };
  
     while (true)
     {
         bytesRead = file.read(buffer.data() + offset, BUFFER_SIZE - offset - 1);
         if (bytesRead < 0)
             break;
         const int dataSize = bytesRead + offset;
         if ((bytesRead == 0) && (dataSize == 0))
             break;
  
         for (start = 0; start < dataSize; ++start)
         {
             endOfLine = -1;
             // The file might have ended without the last line having a newline
             if (!((bytesRead == 0) && (dataSize > 0)))
             {
                 for (int i = start; i < dataSize; ++i)
                 {
                     if (buffer[i] == '\n')
                     {
                         endOfLine = i;
                         // We need to NULL the newline in case the line has only an IP range.
                         // In that case the parser won't work for the end IP, because it ends
                         // with the newline and not with a number.
                         buffer[i] = '\0';
                         break;
                     }
                 }
             }
             else
             {
                 endOfLine = dataSize;
                 buffer[dataSize] = '\0';
             }
  
             if (endOfLine == -1)
             {
                 // read the next chunk from file
                 // but first move(copy) the leftover data to the front of the buffer
                 offset = dataSize - start;
                 memmove(buffer.data(), buffer.data() + start, offset);
                 break;
             }
  
             ++nbLine;
  
             if ((buffer[start] == '#')
                 || ((buffer[start] == '/') && ((start + 1 < dataSize) && (buffer[start + 1] == '/'))))
                 {
                 start = endOfLine;
                 continue;
             }
  
             // Each line should follow this format:
             // Some organization:1.0.0.0-1.255.255.255
             // The "Some organization" part might contain a ':' char itself so we find the last occurrence
             const int partsDelimiter = findAndNullDelimiter(buffer.data(), ':', start, endOfLine, true);
             if (partsDelimiter == -1)
             {
                 ++parseErrorCount;
                 addLog(tr("IP filter line %1 is malformed.").arg(nbLine));
                 start = endOfLine;
                 continue;
             }
  
             // IP Range should be split by a dash
             const int delimIP = findAndNullDelimiter(buffer.data(), '-', partsDelimiter + 1, endOfLine);
             if (delimIP == -1)
             {
                 ++parseErrorCount;
                 addLog(tr("IP filter line %1 is malformed.").arg(nbLine));
                 start = endOfLine;
                 continue;
             }
  
             lt::address startAddr;
             int newStart = trim(buffer.data(), partsDelimiter + 1, delimIP - 1);
             if (!parseIPAddress(buffer.data() + newStart, startAddr))
             {
                 ++parseErrorCount;
                 addLog(tr("IP filter line %1 is malformed. Start IP of the range is malformed.").arg(nbLine));
                 start = endOfLine;
                 continue;
             }
  
             lt::address endAddr;
             newStart = trim(buffer.data(), delimIP + 1, endOfLine);
             if (!parseIPAddress(buffer.data() + newStart, endAddr))
             {
                 ++parseErrorCount;
                 addLog(tr("IP filter line %1 is malformed. End IP of the range is malformed.").arg(nbLine));
                 start = endOfLine;
                 continue;
             }
  
             if ((startAddr.is_v4() != endAddr.is_v4())
                 || (startAddr.is_v6() != endAddr.is_v6()))
                 {
                 ++parseErrorCount;
                 addLog(tr("IP filter line %1 is malformed. One IP is IPv4 and the other is IPv6!").arg(nbLine));
                 start = endOfLine;
                 continue;
             }
  
             start = endOfLine;
  
             try
             {
                 m_filter.add_rule(startAddr, endAddr, lt::ip_filter::blocked);
                 ++ruleCount;
             }
             catch (const std::exception &e)
             {
                 ++parseErrorCount;
                 addLog(tr("IP filter exception thrown for line %1. Exception is: %2")
                        .arg(nbLine).arg(QString::fromLocal8Bit(e.what())));
             }
         }
  
         if (start >= dataSize)
             offset = 0;
     }
  
     if (parseErrorCount > MAX_LOGGED_ERRORS)
         LogMsg(tr("%1 extra IP filter parsing errors occurred.", "513 extra IP filter parsing errors occurred.")
                .arg(parseErrorCount - MAX_LOGGED_ERRORS), Log::CRITICAL);
     return ruleCount;
 }

References anonymous_namespace{filterparserthread.cpp}::BUFFER_SIZE, Log::CRITICAL, nova3.nova2dl::e, file(), findAndNullDelimiter(), LogMsg(), m_filePath, m_filter, anonymous_namespace{filterparserthread.cpp}::MAX_LOGGED_ERRORS, anonymous_namespace{filterparserthread.cpp}::parseIPAddress(), and trim().

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ processFilterFile()

void FilterParserThread::processFilterFile ( const QString & filePath )

Definition at line 595 of file filterparserthread.cpp.

 {
     if (isRunning())
     {
         // Already parsing a filter, m_abort first
         m_abort = true;
         wait();
     }
  
     m_abort = false;
     m_filePath = filePath;
     m_filter = lt::ip_filter();
     // Run it
     start();
 }

References m_abort, m_filePath, and m_filter.

◆ run()

void FilterParserThread::run ( )

overrideprotected

Definition at line 616 of file filterparserthread.cpp.

 {
     qDebug("Processing filter file");
     int ruleCount = 0;
     if (m_filePath.endsWith(".p2p", Qt::CaseInsensitive))
     {
         // PeerGuardian p2p file
         ruleCount = parseP2PFilterFile();
     }
     else if (m_filePath.endsWith(".p2b", Qt::CaseInsensitive))
     {
         // PeerGuardian p2b file
         ruleCount = parseP2BFilterFile();
     }
     else if (m_filePath.endsWith(".dat", Qt::CaseInsensitive))
     {
         // eMule DAT format
         ruleCount = parseDATFilterFile();
     }
  
     if (m_abort) return;
  
     try
     {
         emit IPFilterParsed(ruleCount);
     }
     catch (const std::exception &)
     {
         emit IPFilterError();
     }
  
     qDebug("IP Filter thread: finished parsing, filter applied");
 }

References IPFilterError(), IPFilterParsed(), m_abort, m_filePath, parseDATFilterFile(), parseP2BFilterFile(), and parseP2PFilterFile().

Here is the call graph for this function:

◆ trim()

int FilterParserThread::trim	(	char *const	data,
		int	start,
		int	end
	)

private

Definition at line 678 of file filterparserthread.cpp.

 {
     if (start >= end) return start;
     int newStart = start;
  
     for (int i = start; i <= end; ++i)
     {
         if (isspace(data[i]) != 0)
         {
             data[i] = '\0';
         }
         else
         {
             newStart = i;
             break;
         }
     }
  
     for (int i = end; i >= start; --i)
     {
         if (isspace(data[i]) != 0)
             data[i] = '\0';
         else
             break;
     }
  
     return newStart;
 }

Referenced by parseDATFilterFile(), and parseP2PFilterFile().

Here is the caller graph for this function:

Member Data Documentation

◆ m_abort

bool FilterParserThread::m_abort

private

Definition at line 62 of file filterparserthread.h.

Referenced by parseP2BFilterFile(), processFilterFile(), run(), and ~FilterParserThread().

◆ m_filePath

QString FilterParserThread::m_filePath

private

Definition at line 63 of file filterparserthread.h.

Referenced by parseDATFilterFile(), parseP2BFilterFile(), parseP2PFilterFile(), processFilterFile(), and run().

◆ m_filter

lt::ip_filter FilterParserThread::m_filter

private

Definition at line 64 of file filterparserthread.h.

Referenced by IPfilter(), parseDATFilterFile(), parseP2BFilterFile(), parseP2PFilterFile(), and processFilterFile().

The documentation for this class was generated from the following files:

src/base/bittorrent/filterparserthread.h
src/base/bittorrent/filterparserthread.cpp

Signals

Public Member Functions

Protected Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ FilterParserThread()

◆ ~FilterParserThread()

Member Function Documentation

◆ findAndNullDelimiter()

◆ getlineInStream()

◆ IPfilter()

◆ IPFilterError

◆ IPFilterParsed

◆ parseDATFilterFile()

◆ parseP2BFilterFile()

◆ parseP2PFilterFile()

◆ processFilterFile()

◆ run()

◆ trim()

Member Data Documentation

◆ m_abort

◆ m_filePath

◆ m_filter