mirror of
https://github.com/rsyslog/loganalyzer.git
synced 2025-09-26 11:19:26 +02:00
1231 lines
35 KiB
PHP
1231 lines
35 KiB
PHP
<?php
|
|
/*
|
|
*********************************************************************
|
|
* -> www.phplogcon.org <-
|
|
* -----------------------------------------------------------------
|
|
* LogStreamPDO provides access to the data through PDO Interface
|
|
*
|
|
* \version 2.0.0 Init Version
|
|
*
|
|
* All directives are explained within this file
|
|
*
|
|
* Copyright (C) 2008 Adiscon GmbH.
|
|
*
|
|
* This file is part of phpLogCon.
|
|
*
|
|
* PhpLogCon 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, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* PhpLogCon 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 phpLogCon. If not, see <http://www.gnu.org/licenses/>.
|
|
*
|
|
* A copy of the GPL can be found in the file "COPYING" in this
|
|
* distribution.
|
|
*********************************************************************
|
|
*/
|
|
|
|
// --- Avoid directly accessing this file!
|
|
if ( !defined('IN_PHPLOGCON') )
|
|
{
|
|
die('Hacking attempt');
|
|
exit;
|
|
}
|
|
// ---
|
|
|
|
// --- Required Includes!
|
|
require_once($gl_root_path . 'include/constants_errors.php');
|
|
// ---
|
|
|
|
class LogStreamPDO extends LogStream {
|
|
private $_dbhandle = null;
|
|
|
|
// Helper to store the database records
|
|
private $bufferedRecords = null;
|
|
private $_currentRecordStart = 0;
|
|
private $_currentRecordNum = 0;
|
|
private $_totalRecordCount = -1;
|
|
private $_previousPageUID = -1;
|
|
private $_lastPageUID = -1;
|
|
private $_firstPageUID = -1;
|
|
private $_currentPageNumber = -1;
|
|
|
|
private $_SQLwhereClause = "";
|
|
private $_myDBQuery = null;
|
|
|
|
// Constructor
|
|
public function LogStreamPDO($streamConfigObj) {
|
|
$this->_logStreamConfigObj = $streamConfigObj;
|
|
|
|
// Verify if Extension is enabled
|
|
if ( extension_loaded('pdo') == 0 )
|
|
DieWithFriendlyErrorMsg("Error, PDO Extensions are not enabled or installed! This Source can not operate.");
|
|
|
|
/*
|
|
if ( $this->_logStreamConfigObj->DBType == DB_MYSQL )
|
|
{
|
|
// Probe if a function exists!
|
|
if ( !function_exists("mysql_connect") )
|
|
DieWithFriendlyErrorMsg("Error, MYSQL Extensions are not enabled! Function 'mysql_connect' does not exist.");
|
|
}
|
|
*/
|
|
}
|
|
|
|
/**
|
|
* Open and verifies the database conncetion
|
|
*
|
|
* @param arrProperties array in: Properties wish list.
|
|
* @return integer Error stat
|
|
*/
|
|
public function Open($arrProperties)
|
|
{
|
|
global $dbmapping;
|
|
|
|
// Initialise Basic stuff within the Classs
|
|
$this->RunBasicInits();
|
|
|
|
// Verify database driver and connection (This also opens the database!)
|
|
$res = $this->Verify();
|
|
if ( $res != SUCCESS )
|
|
return $res;
|
|
|
|
// Copy the Property Array
|
|
$this->_arrProperties = $arrProperties;
|
|
|
|
// Check if DB Mapping exists
|
|
if ( !isset($dbmapping[ $this->_logStreamConfigObj->DBTableType ]) )
|
|
return ERROR_DB_INVALIDDBMAPPING;
|
|
|
|
// Create SQL Where Clause first!
|
|
$res = $this->CreateSQLWhereClause();
|
|
if ( $res != SUCCESS )
|
|
return $res;
|
|
|
|
// Only obtain rowcount if enabled and not done before
|
|
if ( $this->_logStreamConfigObj->DBEnableRowCounting && $this->_totalRecordCount == -1 )
|
|
$this->_totalRecordCount = $this->GetRowCountFromTable();
|
|
|
|
// Success, this means we init the Pagenumber to ONE!
|
|
//$this->_currentPageNumber = 1;
|
|
|
|
// reached this point means success!
|
|
return SUCCESS;
|
|
}
|
|
|
|
/**
|
|
* Close the database connection.
|
|
*
|
|
* @return integer Error state
|
|
*/
|
|
public function Close()
|
|
{
|
|
// trigger closing database query!
|
|
$this->DestroyMainSQLQuery();
|
|
|
|
// TODO CLOSE DB CONN?!
|
|
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Verify if the database connection exists!
|
|
*
|
|
* @return integer Error state
|
|
*/
|
|
public function Verify() {
|
|
// Create DSN String
|
|
$myDBDriver = $this->_logStreamConfigObj->GetPDODatabaseType();
|
|
$myDsn = $this->_logStreamConfigObj->CreateConnectDSN();
|
|
if ( strlen($myDsn) > 0 )
|
|
{
|
|
// Check if configured driver is actually loaded!
|
|
//print_r(PDO::getAvailableDrivers());
|
|
if ( !in_array($myDBDriver, PDO::getAvailableDrivers()) )
|
|
{
|
|
global $extraErrorDescription;
|
|
$extraErrorDescription = "PDO Database Driver not loaded: " . $myDBDriver . "<br>Please check your php configuration extensions";
|
|
// $this->PrintDebugError($extraErrorDescription);
|
|
|
|
// return error code
|
|
return ERROR_DB_INVALIDDBDRIVER;
|
|
}
|
|
|
|
try
|
|
{
|
|
// Try to connect to the database
|
|
$this->_dbhandle = new PDO( $myDsn, $this->_logStreamConfigObj->DBUser, $this->_logStreamConfigObj->DBPassword /*, array(PDO::ATTR_TIMEOUT =>25)*/);
|
|
//$this->_dbhandle->setAttribute(PDO::ATTR_TIMEOUT, 25);
|
|
}
|
|
catch (PDOException $e)
|
|
{
|
|
global $extraErrorDescription;
|
|
$extraErrorDescription = "PDO Database Connection failed: " . $e->getMessage() . "<br>DSN: " . $myDsn;
|
|
// $this->PrintDebugError($extraErrorDescription);
|
|
|
|
// return error code
|
|
return ERROR_DB_CONNECTFAILED;
|
|
}
|
|
|
|
try
|
|
{
|
|
// This is one way to check if the table exists! But I don't really like it tbh -.-
|
|
$tmpStmnt = $this->_dbhandle->prepare("SELECT ID FROM " . $this->_logStreamConfigObj->DBTableName . " WHERE ID=1");
|
|
$tmpStmnt->execute();
|
|
$colcount = $tmpStmnt->columnCount();
|
|
if ( $colcount <= 0 )
|
|
return ERROR_DB_TABLENOTFOUND;
|
|
}
|
|
catch (PDOException $e)
|
|
{
|
|
global $extraErrorDescription;
|
|
$extraErrorDescription = "Could not find table: " . $e->getMessage();
|
|
|
|
// return error code
|
|
return ERROR_DB_TABLENOTFOUND;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Invalid DB Driver!
|
|
return ERROR_DB_INVALIDDBDRIVER;
|
|
}
|
|
|
|
// reached this point means success ;)!
|
|
return SUCCESS;
|
|
}
|
|
|
|
/**
|
|
* Read the data from a specific uID which means in this
|
|
* case beginning with from the Database ID
|
|
*
|
|
* @param uID integer in/out: unique id of the data row
|
|
* @param arrProperitesOut array out: array filled with properties
|
|
* @return integer Error state
|
|
* @see ReadNext()
|
|
*/
|
|
public function Read($uID, &$arrProperitesOut)
|
|
{
|
|
// Seek the first uID!
|
|
if ( $this->Sseek($uID, EnumSeek::UID, 0) == SUCCESS)
|
|
{
|
|
// Read the next record!
|
|
$ret = $this->ReadNext($uID, $arrProperitesOut);
|
|
}
|
|
else
|
|
$ret = ERROR_NOMORERECORDS;
|
|
|
|
// return result!
|
|
return $ret;
|
|
}
|
|
|
|
/**
|
|
* Read the next line from the file depending on the current
|
|
* read direction.
|
|
*
|
|
* Hint: If the current stream becomes unavailable an error
|
|
* stated is retuned. A typical case is if a log rotation
|
|
* changed the original data source.
|
|
*
|
|
* @param uID integer out: uID is the offset of data row
|
|
* @param arrProperitesOut array out: properties
|
|
* @return integer Error state
|
|
* @see ReadNext
|
|
*/
|
|
public function ReadNext(&$uID, &$arrProperitesOut, $bParseMessage = true)
|
|
{
|
|
// Helpers needed for DB Mapping
|
|
global $content, $gl_starttime;
|
|
global $dbmapping, $fields;
|
|
$szTableType = $this->_logStreamConfigObj->DBTableType;
|
|
|
|
// define $ret
|
|
$ret = SUCCESS;
|
|
|
|
do
|
|
{
|
|
// No buffer? then read from DB!
|
|
if ( $this->bufferedRecords == null )
|
|
$ret = $this->ReadNextRecordsFromDB($uID);
|
|
else
|
|
{
|
|
if ( !isset($this->bufferedRecords[$this->_currentRecordNum] ) )
|
|
{
|
|
// We need to load new records, so clear the old ones first!
|
|
$this->ResetBufferedRecords();
|
|
|
|
// Set new Record start, will be used in the SQL Statement!
|
|
$this->_currentRecordStart = $this->_currentRecordNum; // + 1;
|
|
|
|
// Now read new ones
|
|
$ret = $this->ReadNextRecordsFromDB($uID);
|
|
|
|
// Check if we found more records
|
|
if ( !isset($this->bufferedRecords[$this->_currentRecordNum] ) )
|
|
$ret = ERROR_NOMORERECORDS;
|
|
}
|
|
}
|
|
|
|
if ( $ret == SUCCESS )
|
|
{
|
|
// Init and set variables
|
|
foreach ( $this->_arrProperties as $property )
|
|
{
|
|
// Check if mapping exists
|
|
if ( isset($dbmapping[$szTableType][$property]) )
|
|
{
|
|
// Copy property if available!
|
|
$dbfieldname = $dbmapping[$szTableType][$property];
|
|
if ( isset($this->bufferedRecords[$this->_currentRecordNum][$dbfieldname]) )
|
|
{
|
|
if ( isset($fields[$property]['FieldType']) && $fields[$property]['FieldType'] == FILTER_TYPE_DATE ) // Handle as date!
|
|
$arrProperitesOut[$property] = GetEventTime( $this->bufferedRecords[$this->_currentRecordNum][$dbfieldname] );
|
|
else
|
|
$arrProperitesOut[$property] = $this->bufferedRecords[$this->_currentRecordNum][$dbfieldname];
|
|
}
|
|
else
|
|
$arrProperitesOut[$property] = '';
|
|
}
|
|
else
|
|
$arrProperitesOut[$property] = '';
|
|
}
|
|
|
|
// Run optional Message Parsers now
|
|
if ( isset($arrProperitesOut[SYSLOG_MESSAGE]) )
|
|
{
|
|
$retParser = $this->_logStreamConfigObj->ProcessMsgParsers($arrProperitesOut[SYSLOG_MESSAGE], $arrProperitesOut);
|
|
|
|
// Check if we have to skip the message!
|
|
if ( $retParser == ERROR_MSG_SKIPMESSAGE )
|
|
$ret = $retParser;
|
|
}
|
|
|
|
// Set uID to the PropertiesOut! //DEBUG -> $this->_currentRecordNum;
|
|
$uID = $arrProperitesOut[SYSLOG_UID] = $this->bufferedRecords[$this->_currentRecordNum][$dbmapping[$szTableType][SYSLOG_UID]];
|
|
|
|
// Increment $_currentRecordNum
|
|
$this->_currentRecordNum++;
|
|
}
|
|
|
|
// Check how long we are running. If only two seconds of execution time are left, we abort further reading!
|
|
$scriptruntime = intval(microtime_float() - $gl_starttime);
|
|
if ( $scriptruntime > ($content['MaxExecutionTime']-2) )
|
|
{
|
|
// This may display a warning message, so the user knows we stopped reading records because of the script timeout.
|
|
$content['logstream_warning'] = "false";
|
|
$content['logstream_warning_details'] = $content['LN_WARNING_LOGSTREAMDISK_TIMEOUT'];
|
|
$content['logstream_warning_code'] = ERROR_FILE_NOMORETIME;
|
|
|
|
// Return error code
|
|
return ERROR_FILE_NOMORETIME;
|
|
}
|
|
|
|
// This additional filter check will take care on dynamic fields from the message parser!
|
|
} while ( $this->ApplyFilters($ret, $arrProperitesOut) != SUCCESS && $ret == SUCCESS );
|
|
|
|
// reached here means return result!
|
|
return $ret;
|
|
}
|
|
|
|
/**
|
|
* Implementation of Seek
|
|
*/
|
|
public function Sseek(&$uID, $mode, $numrecs)
|
|
{
|
|
// predefine return value
|
|
$ret = SUCCESS;
|
|
|
|
switch ($mode)
|
|
{
|
|
case EnumSeek::UID:
|
|
// if ( $uID == UID_UNKNOWN ) // set uID to first ID!
|
|
{
|
|
// No buffer? then read from DB!
|
|
if ( $this->bufferedRecords == null )
|
|
$ret = $this->ReadNextRecordsFromDB($uID);
|
|
|
|
if ( $ret == SUCCESS )
|
|
{
|
|
$this->_currentRecordNum = 0;
|
|
$uID = $this->bufferedRecords[ $this->_currentRecordNum ];
|
|
}
|
|
}
|
|
/* else
|
|
{
|
|
// Obtain fieldname for uID
|
|
global $dbmapping;
|
|
$uidfieldname = $dbmapping[$this->_logStreamConfigObj->DBTableType][SYSLOG_UID];
|
|
|
|
// Clear if necessary!
|
|
if ( $this->bufferedRecords == null )
|
|
$this->ResetBufferedRecords();
|
|
|
|
// Loop through all records for now, maybe optimized later!
|
|
$bFound = false;
|
|
$tmpuID = $uID;
|
|
$ret = ERROR_NOMORERECORDS; // Set Default error code!
|
|
|
|
// Set totalpages number if available
|
|
if ( $this->_totalRecordCount != -1 )
|
|
$totalpages = intval($this->_totalRecordCount / $this->_logStreamConfigObj->_pageCount);
|
|
else
|
|
$totalpages = 1;
|
|
|
|
while( $bFound == false && $this->ReadNextIDsFromDB() == SUCCESS )
|
|
{
|
|
foreach ( $this->bufferedRecords as $myRecord )
|
|
{
|
|
if ( $myRecord[$uidfieldname] == $uID )
|
|
{
|
|
$bFound = true;
|
|
$ret = SUCCESS;
|
|
break; // Break foreach loop!
|
|
}
|
|
else
|
|
{
|
|
$tmpuID = $myRecord[$uidfieldname];
|
|
// Only Increment $_currentRecordNum
|
|
$this->_currentRecordNum++;
|
|
}
|
|
|
|
// Increment our Pagenumber if needed!
|
|
if ( $this->_currentRecordNum % $this->_logStreamConfigObj->_pageCount == 0 )
|
|
$this->_currentPageNumber++;
|
|
}
|
|
|
|
if ( $this->_currentPageNumber > 1 && $this->_readDirection == EnumReadDirection::Forward)
|
|
$this->_currentPageNumber = $totalpages - $this->_currentPageNumber + 1;
|
|
|
|
//--- Extra check to set the correct $_previousPageUID!
|
|
if ( $this->_currentRecordNum > $this->_logStreamConfigObj->_pageCount && isset($this->bufferedRecords[$this->_currentRecordNum - 50][$uidfieldname]) )
|
|
{
|
|
$this->_previousPageUID = $this->bufferedRecords[$this->_currentRecordNum - $this->_logStreamConfigObj->_pageCount - 1][$uidfieldname];
|
|
}
|
|
// TODO! Handle the case where previous ID is not set in the bufferedrecords!
|
|
//---
|
|
|
|
// We need to load new records, so clear the old ones first!
|
|
$this->ResetBufferedRecords();
|
|
|
|
// Set new Record start, will be used in the SQL Statement!
|
|
$this->_currentRecordStart = $this->_currentRecordNum;
|
|
}
|
|
|
|
// Delete buffered records, then they will be read automatically in ReadNext()
|
|
$this->ResetBufferedRecords();
|
|
}
|
|
*/
|
|
break;
|
|
}
|
|
|
|
// Return result!
|
|
return $ret;
|
|
}
|
|
|
|
/**
|
|
* GetMessageCount will return the count of Message.
|
|
* If this count is not available, the function will
|
|
* return the default -1
|
|
*/
|
|
public function GetMessageCount()
|
|
{
|
|
return $this->_totalRecordCount;
|
|
}
|
|
|
|
/**
|
|
* This function returns the first UID for previous PAGE, if availbale!
|
|
* Otherwise will return -1!
|
|
*/
|
|
public function GetPreviousPageUID()
|
|
{
|
|
return $this->_previousPageUID;
|
|
}
|
|
|
|
/**
|
|
* This function returns the FIRST UID for the FIRST PAGE!
|
|
* Will be done by a seperated SQL Statement.
|
|
*/
|
|
public function GetFirstPageUID()
|
|
{
|
|
global $querycount, $dbmapping;
|
|
$szTableType = $this->_logStreamConfigObj->DBTableType;
|
|
|
|
$szSql = "SELECT MAX(" . $dbmapping[$szTableType][SYSLOG_UID] . ") FROM " . $this->_logStreamConfigObj->DBTableName . $this->_SQLwhereClause;
|
|
$myQuery = $this->_dbhandle->query($szSql);
|
|
if ( $myQuery )
|
|
{
|
|
$myRow = $myQuery->fetchColumn();
|
|
$this->_firstPageUID = $myRow; // $myRow[0];
|
|
|
|
// Free query now
|
|
$myQuery->closeCursor();
|
|
|
|
// Increment for the Footer Stats
|
|
$querycount++;
|
|
|
|
}
|
|
//echo $szSql . "<br>" . $this->_firstPageUID;
|
|
//exit;
|
|
|
|
// finally return result!
|
|
return $this->_firstPageUID;
|
|
}
|
|
|
|
/**
|
|
* This function returns the first UID for the last PAGE!
|
|
* Will be done by a seperated SQL Statement.
|
|
*/
|
|
public function GetLastPageUID()
|
|
{
|
|
global $querycount, $dbmapping;
|
|
$szTableType = $this->_logStreamConfigObj->DBTableType;
|
|
|
|
$szSql = "SELECT MIN(" . $dbmapping[$szTableType][SYSLOG_UID] . ") FROM " . $this->_logStreamConfigObj->DBTableName . $this->_SQLwhereClause;
|
|
$myQuery = $this->_dbhandle->query($szSql);
|
|
if ( $myQuery )
|
|
{
|
|
$myRow = $myQuery->fetchColumn();
|
|
$this->_lastPageUID = $myRow; // $myRow[0];
|
|
|
|
// Free query now
|
|
$myQuery->closeCursor();
|
|
|
|
// Increment for the Footer Stats
|
|
$querycount++;
|
|
|
|
}
|
|
//echo $szSql . "<br>" . $this->_lastPageUID;
|
|
//exit;
|
|
|
|
// finally return result!
|
|
return $this->_lastPageUID;
|
|
}
|
|
|
|
/**
|
|
* This function returns the current Page number, if availbale!
|
|
* Otherwise will return 0! We also assume that this function is
|
|
* only called once DB is open!
|
|
*/
|
|
public function GetCurrentPageNumber()
|
|
{
|
|
return $this->_currentPageNumber;
|
|
}
|
|
|
|
/*
|
|
* Implementation of IsPropertySortable
|
|
*
|
|
* For now, sorting is only possible for the UID Property!
|
|
*/
|
|
public function IsPropertySortable($myProperty)
|
|
{
|
|
global $fields;
|
|
|
|
// TODO: HARDCODED | FOR NOW only FALSE!
|
|
return false;
|
|
|
|
if ( isset($fields[$myProperty]) && $myProperty == SYSLOG_UID )
|
|
return true;
|
|
else
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Implementation of GetLogStreamStats
|
|
*
|
|
* Returns an Array og logstream statsdata
|
|
* Count of Data Items
|
|
* Total Filesize
|
|
*/
|
|
public function GetLogStreamStats()
|
|
{
|
|
global $querycount, $dbmapping;
|
|
$szTableType = $this->_logStreamConfigObj->DBTableType;
|
|
|
|
// Perform if Connection is true!
|
|
if ( $this->_dbhandle != null )
|
|
{
|
|
$tableName = $this->_logStreamConfigObj->DBTableName;
|
|
|
|
// SHOW TABLE STATUS FROM
|
|
$stats = NULL;
|
|
$szSql = "SELECT count(" . $dbmapping[$szTableType][SYSLOG_UID] . ") as Counter FROM " . $this->_logStreamConfigObj->DBTableName;
|
|
$myQuery = $this->_dbhandle->query($szSql);
|
|
if ( $myQuery )
|
|
{
|
|
// Set tablename!
|
|
$tableName = $this->_logStreamConfigObj->DBTableName;
|
|
$myStats[] = array( 'StatsDisplayName' => 'TableName', 'StatsValue' => $tableName );
|
|
|
|
// obtain first and only row
|
|
$myRow = $myQuery->fetchColumn();
|
|
$myStats[] = array( 'StatsDisplayName' => 'Rows', 'StatsValue' => $myRow );
|
|
$stats[]['STATSDATA'] = $myStats;
|
|
|
|
// Free query now
|
|
$myQuery->closeCursor();
|
|
|
|
// Increment for the Footer Stats
|
|
$querycount++;
|
|
}
|
|
|
|
// return results!
|
|
return $stats;
|
|
}
|
|
else
|
|
return null;
|
|
}
|
|
|
|
|
|
/**
|
|
* Implementation of GetLogStreamTotalRowCount
|
|
*
|
|
* Returns the total amount of rows in the main datatable
|
|
*/
|
|
public function GetLogStreamTotalRowCount()
|
|
{
|
|
global $querycount, $dbmapping;
|
|
$szTableType = $this->_logStreamConfigObj->DBTableType;
|
|
|
|
// Set default rowcount
|
|
$rowcount = null;
|
|
|
|
// Perform if Connection is true!
|
|
if ( $this->_dbhandle != null )
|
|
{
|
|
// Get Total Rowcount
|
|
$szSql = "SELECT count(" . $dbmapping[$szTableType][SYSLOG_UID] . ") as Counter FROM " . $this->_logStreamConfigObj->DBTableName;
|
|
$myQuery = $this->_dbhandle->query($szSql);
|
|
if ( $myQuery )
|
|
{
|
|
// Obtain RowCount!
|
|
$myRow = $myQuery->fetchColumn();
|
|
$rowcount = $myRow;
|
|
|
|
// Free query now
|
|
$myQuery->closeCursor();
|
|
|
|
// Increment for the Footer Stats
|
|
$querycount++;
|
|
}
|
|
}
|
|
|
|
//return result
|
|
return $rowcount;
|
|
}
|
|
|
|
|
|
/**
|
|
* Implementation of the CleanupLogdataByDate function! Returns affected rows!
|
|
*/
|
|
public function CleanupLogdataByDate( $nDateTimeStamp )
|
|
{
|
|
global $querycount, $dbmapping;
|
|
$szTableType = $this->_logStreamConfigObj->DBTableType;
|
|
|
|
// Set default rowcount
|
|
$rowcount = null;
|
|
|
|
// Perform if Connection is true!
|
|
if ( $this->_dbhandle != null )
|
|
{
|
|
// Create WHERE attachment
|
|
if ( $nDateTimeStamp > 0 )
|
|
$szWhere = " WHERE " . $dbmapping[$szTableType][SYSLOG_DATE] . " < '" . date('Y-m-d H:i:s', $nDateTimeStamp) . "'";
|
|
else
|
|
$szWhere = "";
|
|
|
|
// DELETE DATA NOW!
|
|
$szSql = "DELETE FROM " . $this->_logStreamConfigObj->DBTableName . $szWhere;
|
|
$myQuery = $this->_dbhandle->query($szSql);
|
|
if ( $myQuery )
|
|
{
|
|
// Get affected rows and return!
|
|
$rowcount = $myQuery->rowCount();
|
|
|
|
// Free query now
|
|
$myQuery->closeCursor();
|
|
}
|
|
}
|
|
|
|
//return affected rows
|
|
return $rowcount;
|
|
}
|
|
|
|
|
|
/**
|
|
* Implementation of GetCountSortedByField
|
|
*
|
|
* In the PDO DB Logstream, the database will do most of the work
|
|
*
|
|
* @return integer Error stat
|
|
*/
|
|
public function GetCountSortedByField($szFieldId, $nFieldType, $nRecordLimit)
|
|
{
|
|
global $content, $dbmapping;
|
|
|
|
// Copy helper variables, this is just for better readability
|
|
$szTableType = $this->_logStreamConfigObj->DBTableType;
|
|
|
|
if ( isset($dbmapping[$szTableType][$szFieldId]) )
|
|
{
|
|
// Set DB Field name first!
|
|
$myDBFieldName = $dbmapping[$szTableType][$szFieldId];
|
|
$myDBQueryFieldName = $myDBFieldName;
|
|
$mySelectFieldName = $myDBFieldName;
|
|
|
|
// Special handling for date fields
|
|
if ( $nFieldType == FILTER_TYPE_DATE )
|
|
{
|
|
if ( $this->_logStreamConfigObj->DBType == DB_MYSQL ||
|
|
$this->_logStreamConfigObj->DBType == DB_PGSQL )
|
|
{
|
|
// Helper variable for the select statement
|
|
$mySelectFieldName = $mySelectFieldName . "grouped";
|
|
$myDBQueryFieldName = "DATE( " . $myDBFieldName . ") AS " . $mySelectFieldName ;
|
|
}
|
|
else if($this->_logStreamConfigObj->DBType == DB_MSSQL )
|
|
{
|
|
// TODO FIND A WAY FOR MSSQL!
|
|
}
|
|
}
|
|
|
|
// Create SQL String now!
|
|
$szSql = "SELECT " .
|
|
$myDBQueryFieldName . ", " .
|
|
"count(" . $myDBFieldName . ") as totalcount " .
|
|
" FROM " . $this->_logStreamConfigObj->DBTableName .
|
|
" GROUP BY " . $mySelectFieldName .
|
|
" ORDER BY totalcount DESC";
|
|
// Append LIMIT in this case!
|
|
if ( $this->_logStreamConfigObj->DBType == DB_MYSQL ||
|
|
$this->_logStreamConfigObj->DBType == DB_PGSQL )
|
|
$szSql .= " LIMIT " . $nRecordLimit;
|
|
|
|
// Perform Database Query
|
|
$this->_myDBQuery = $this->_dbhandle->query($szSql);
|
|
if ( !$this->_myDBQuery )
|
|
return ERROR_DB_QUERYFAILED;
|
|
|
|
if ( $this->_myDBQuery->rowCount() == 0 )
|
|
return ERROR_NOMORERECORDS;
|
|
|
|
// Initialize Array variable
|
|
$aResult = array();
|
|
|
|
// read data records
|
|
$iCount = 0;
|
|
while ( ($myRow = $this->_myDBQuery->fetch(PDO::FETCH_ASSOC)) && $iCount < $nRecordLimit)
|
|
{
|
|
if ( isset($myRow[$mySelectFieldName]) )
|
|
{
|
|
$aResult[ $myRow[$mySelectFieldName] ] = $myRow['totalcount'];
|
|
$iCount++;
|
|
}
|
|
}
|
|
|
|
// return finished array
|
|
if ( count($aResult) > 0 )
|
|
return $aResult;
|
|
else
|
|
return ERROR_NOMORERECORDS;
|
|
}
|
|
else
|
|
{
|
|
// return error code, field mapping not found
|
|
return ERROR_DB_DBFIELDNOTFOUND;
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* ============= Beginn of private functions =============
|
|
*/
|
|
|
|
/*
|
|
* This function expects the filters to already being set earlier.
|
|
* Otherwise no usual WHERE Clause can be created!
|
|
*/
|
|
private function CreateSQLWhereClause()
|
|
{
|
|
if ( $this->_filters != null )
|
|
{
|
|
global $dbmapping;
|
|
$szTableType = $this->_logStreamConfigObj->DBTableType;
|
|
|
|
// Reset WhereClause
|
|
$this->_SQLwhereClause = "";
|
|
|
|
// Loop through all available properties
|
|
foreach( $this->_arrProperties as $propertyname )
|
|
{
|
|
// If the property exists in the filter array, we have something to filter for ^^!
|
|
if ( array_key_exists($propertyname, $this->_filters) )
|
|
{
|
|
// Process all filters
|
|
foreach( $this->_filters[$propertyname] as $myfilter )
|
|
{
|
|
// Only perform if database mapping is available for this filter!
|
|
if ( isset($dbmapping[$szTableType][$propertyname]) )
|
|
{
|
|
switch( $myfilter[FILTER_TYPE] )
|
|
{
|
|
case FILTER_TYPE_STRING:
|
|
// --- Either make a LIKE or a equal query!
|
|
if ( $myfilter[FILTER_MODE] & FILTER_MODE_SEARCHFULL )
|
|
{
|
|
// Set addnot to nothing
|
|
$addnod = "";
|
|
|
|
// --- Check if user wants to include or exclude!
|
|
if ( $myfilter[FILTER_MODE] & FILTER_MODE_INCLUDE)
|
|
{
|
|
$szSearchBegin = " = '";
|
|
$szSearchEnd = "' ";
|
|
}
|
|
else
|
|
{
|
|
$szSearchBegin = " <> '";
|
|
$szSearchEnd = "' ";
|
|
}
|
|
// ---
|
|
}
|
|
else
|
|
{
|
|
// --- Check if user wants to include or exclude!
|
|
if ( $myfilter[FILTER_MODE] & FILTER_MODE_INCLUDE)
|
|
$addnod = "";
|
|
else
|
|
$addnod = " NOT";
|
|
// ---
|
|
|
|
$szSearchBegin = " LIKE '%";
|
|
$szSearchEnd = "%' ";
|
|
}
|
|
// ---
|
|
|
|
// --- If Syslog message, we have AND handling, otherwise OR!
|
|
if ( $propertyname == SYSLOG_MESSAGE )
|
|
$addor = " AND ";
|
|
else
|
|
{
|
|
// If we exclude filters, we need to combine with AND
|
|
if ( $myfilter[FILTER_MODE] & FILTER_MODE_INCLUDE)
|
|
$addor = " OR ";
|
|
else
|
|
$addor = " AND ";
|
|
}
|
|
// ---
|
|
|
|
// Not create LIKE Filters
|
|
if ( isset($tmpfilters[$propertyname]) )
|
|
$tmpfilters[$propertyname][FILTER_VALUE] .= $addor . $dbmapping[$szTableType][$propertyname] . $addnod . $szSearchBegin . DB_RemoveBadChars($myfilter[FILTER_VALUE], $this->_logStreamConfigObj->DBType) . $szSearchEnd;
|
|
else
|
|
{
|
|
$tmpfilters[$propertyname][FILTER_TYPE] = FILTER_TYPE_STRING;
|
|
$tmpfilters[$propertyname][FILTER_VALUE] = $dbmapping[$szTableType][$propertyname] . $addnod . $szSearchBegin . DB_RemoveBadChars($myfilter[FILTER_VALUE], $this->_logStreamConfigObj->DBType) . $szSearchEnd;
|
|
}
|
|
break;
|
|
case FILTER_TYPE_NUMBER:
|
|
// --- Check if user wants to include or exclude!
|
|
if ( $myfilter[FILTER_MODE] & FILTER_MODE_EXCLUDE )
|
|
{
|
|
// Add to filterset
|
|
$szArrayKey = $propertyname . "-NOT";
|
|
if ( isset($tmpfilters[$szArrayKey]) )
|
|
$tmpfilters[$szArrayKey][FILTER_VALUE] .= ", " . $myfilter[FILTER_VALUE];
|
|
else
|
|
{
|
|
$tmpfilters[$szArrayKey][FILTER_TYPE] = FILTER_TYPE_NUMBER;
|
|
$tmpfilters[$szArrayKey][FILTER_VALUE] = $dbmapping[$szTableType][$propertyname] . " NOT IN (" . DB_RemoveBadChars($myfilter[FILTER_VALUE], $this->_logStreamConfigObj->DBType);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Add to filterset
|
|
if ( isset($tmpfilters[$propertyname]) )
|
|
$tmpfilters[$propertyname][FILTER_VALUE] .= ", " . $myfilter[FILTER_VALUE];
|
|
else
|
|
{
|
|
$tmpfilters[$propertyname][FILTER_TYPE] = FILTER_TYPE_NUMBER;
|
|
$tmpfilters[$propertyname][FILTER_VALUE] = $dbmapping[$szTableType][$propertyname] . " IN (" . DB_RemoveBadChars($myfilter[FILTER_VALUE], $this->_logStreamConfigObj->DBType);
|
|
}
|
|
}
|
|
// ---
|
|
break;
|
|
case FILTER_TYPE_DATE:
|
|
if ( isset($tmpfilters[$propertyname]) )
|
|
$tmpfilters[$propertyname][FILTER_VALUE] .= " AND ";
|
|
else
|
|
{
|
|
$tmpfilters[$propertyname][FILTER_VALUE] = "";
|
|
$tmpfilters[$propertyname][FILTER_TYPE] = FILTER_TYPE_DATE;
|
|
}
|
|
|
|
if ( $myfilter[FILTER_DATEMODE] == DATEMODE_LASTX )
|
|
{
|
|
// Get current timestamp
|
|
$nNowTimeStamp = time();
|
|
|
|
if ( $myfilter[FILTER_VALUE] == DATE_LASTX_HOUR )
|
|
$nNowTimeStamp -= 60 * 60; // One Hour!
|
|
else if ( $myfilter[FILTER_VALUE] == DATE_LASTX_12HOURS )
|
|
$nNowTimeStamp -= 60 * 60 * 12; // 12 Hours!
|
|
else if ( $myfilter[FILTER_VALUE] == DATE_LASTX_24HOURS )
|
|
$nNowTimeStamp -= 60 * 60 * 24; // 24 Hours!
|
|
else if ( $myfilter[FILTER_VALUE] == DATE_LASTX_7DAYS )
|
|
$nNowTimeStamp -= 60 * 60 * 24 * 7; // 7 days
|
|
else if ( $myfilter[FILTER_VALUE] == DATE_LASTX_31DAYS )
|
|
$nNowTimeStamp -= 60 * 60 * 24 * 31; // 31 days
|
|
else
|
|
{
|
|
// Set filter to unknown and Abort in this case!
|
|
$tmpfilters[$propertyname][FILTER_TYPE] = FILTER_TYPE_UNKNOWN;
|
|
break;
|
|
}
|
|
|
|
// Append filter
|
|
$tmpfilters[$propertyname][FILTER_VALUE] .= $dbmapping[$szTableType][$propertyname] . " > '" . date("Y-m-d H:i:s", $nNowTimeStamp) . "'";
|
|
}
|
|
else if ( $myfilter[FILTER_DATEMODE] == DATEMODE_RANGE_FROM )
|
|
{
|
|
// Obtain Event struct for the time!
|
|
$myeventtime = GetEventTime($myfilter[FILTER_VALUE]);
|
|
$tmpfilters[$propertyname][FILTER_VALUE] .= $dbmapping[$szTableType][$propertyname] . " > '" . date("Y-m-d H:i:s", $myeventtime[EVTIME_TIMESTAMP]) . "'";
|
|
}
|
|
else if ( $myfilter[FILTER_DATEMODE] == DATEMODE_RANGE_TO )
|
|
{
|
|
// Obtain Event struct for the time!
|
|
$myeventtime = GetEventTime($myfilter[FILTER_VALUE]);
|
|
$tmpfilters[$propertyname][FILTER_VALUE] .= $dbmapping[$szTableType][$propertyname] . " < '" . date("Y-m-d H:i:s", $myeventtime[EVTIME_TIMESTAMP]) . "'";
|
|
}
|
|
|
|
break;
|
|
default:
|
|
// Nothing to do!
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Check how to treat not found db mappings / filters
|
|
if ( GetConfigSetting("TreatNotFoundFiltersAsTrue", 0, CFGLEVEL_USER) == 0 )
|
|
return ERROR_DB_DBFIELDNOTFOUND;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Check and combine all filters now!
|
|
if ( isset($tmpfilters) )
|
|
{
|
|
// Append filters
|
|
foreach( $tmpfilters as $tmpfilter )
|
|
{
|
|
// Init WHERE or Append AND
|
|
if ( strlen($this->_SQLwhereClause) > 0 )
|
|
$this->_SQLwhereClause .= " AND ";
|
|
else
|
|
$this->_SQLwhereClause = " WHERE ";
|
|
|
|
switch( $tmpfilter[FILTER_TYPE] )
|
|
{
|
|
case FILTER_TYPE_STRING:
|
|
$this->_SQLwhereClause .= "( " . $tmpfilter[FILTER_VALUE] . ") ";
|
|
break;
|
|
case FILTER_TYPE_NUMBER:
|
|
$this->_SQLwhereClause .= $tmpfilter[FILTER_VALUE] . ") ";
|
|
break;
|
|
case FILTER_TYPE_DATE:
|
|
$this->_SQLwhereClause .= $tmpfilter[FILTER_VALUE];
|
|
break;
|
|
default:
|
|
// Should not happen, wrong filters!
|
|
// We add a dummy into the where clause, just as a place holder
|
|
$this->_SQLwhereClause .= " 1=1 ";
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
//echo $this->_SQLwhereClause;
|
|
//$dbmapping[$szTableType][SYSLOG_UID]
|
|
}
|
|
else // No filters means nothing to do!
|
|
return SUCCESS;
|
|
}
|
|
|
|
/*
|
|
* Create the SQL QUery!
|
|
*/
|
|
private function CreateMainSQLQuery($uID)
|
|
{
|
|
global $querycount;
|
|
|
|
// create query if necessary!
|
|
// if ( $this->_myDBQuery == null )
|
|
{
|
|
// Get SQL Statement
|
|
$szSql = $this->CreateSQLStatement($uID);
|
|
|
|
// --- Append LIMIT if supported by the driver! Why the hell do we still have no unified solution for this crap in the sql language?!
|
|
if ( $this->_logStreamConfigObj->DBType == DB_MYSQL )
|
|
$szSql .= " LIMIT " . $this->_logStreamConfigObj->RecordsPerQuery;
|
|
// $szSql .= " LIMIT " . $this->_currentRecordStart . ", " . $this->_logStreamConfigObj->RecordsPerQuery;
|
|
else if ( $this->_logStreamConfigObj->DBType == DB_PGSQL )
|
|
$szSql .= " LIMIT " . $this->_logStreamConfigObj->RecordsPerQuery;
|
|
// $szSql .= " LIMIT " . $this->_logStreamConfigObj->RecordsPerQuery . " OFFSET " . $this->_currentRecordStart;
|
|
// echo $szSql . "<br>";
|
|
// ---
|
|
|
|
// Perform Database Query
|
|
$this->_myDBQuery = $this->_dbhandle->query($szSql);
|
|
if ( !$this->_myDBQuery )
|
|
{
|
|
$this->PrintDebugError( "Invalid SQL: ".$szSql . "<br><br>Errorcode: " . $this->_dbhandle->errorCode() );
|
|
return ERROR_DB_QUERYFAILED;
|
|
}
|
|
else
|
|
{
|
|
// Skip one entry in this case
|
|
if ( $this->_currentRecordStart > 0 )
|
|
{
|
|
// Throw away
|
|
$myRow = $this->_myDBQuery->fetch(PDO::FETCH_ASSOC);
|
|
}
|
|
|
|
}
|
|
|
|
// Increment for the Footer Stats
|
|
$querycount++;
|
|
}
|
|
|
|
// return success state if reached this point!
|
|
return SUCCESS;
|
|
}
|
|
|
|
/*
|
|
* Destroy the SQL QUery!
|
|
*/
|
|
private function DestroyMainSQLQuery()
|
|
{
|
|
// create query if necessary!
|
|
if ( $this->_myDBQuery != null )
|
|
{
|
|
// Free Query ressources
|
|
$this->_myDBQuery->closeCursor();
|
|
$this->_myDBQuery = null;
|
|
}
|
|
|
|
// return success state if reached this point!
|
|
return SUCCESS;
|
|
}
|
|
|
|
/*
|
|
* This helper function will read the next records into the buffer.
|
|
*/
|
|
private function ReadNextRecordsFromDB($uID)
|
|
{
|
|
// Clear SQL Query first!
|
|
$this->DestroyMainSQLQuery();
|
|
|
|
// Create query if necessary
|
|
// if ( $this->_myDBQuery == null )
|
|
{
|
|
// return error if there was one!
|
|
if ( ($res = $this->CreateMainSQLQuery($uID)) != SUCCESS )
|
|
return $res;
|
|
|
|
// return specially with NO RECORDS when 0 records are returned! Otherwise it will be -1
|
|
if ( $this->_myDBQuery->rowCount() == 0 )
|
|
return ERROR_NOMORERECORDS;
|
|
}
|
|
|
|
// Copy rows into the buffer!
|
|
$iBegin = $this->_currentRecordNum;
|
|
|
|
$iCount = 0;
|
|
while( $this->_logStreamConfigObj->RecordsPerQuery > $iCount)
|
|
{
|
|
//Obtain next record
|
|
$myRow = $this->_myDBQuery->fetch(PDO::FETCH_ASSOC);
|
|
|
|
// Check if result was successfull!
|
|
if ( $myRow === FALSE || !$myRow )
|
|
break;
|
|
|
|
$this->bufferedRecords[$iBegin] = $myRow;
|
|
$iBegin++;
|
|
|
|
// Increment counter
|
|
$iCount++;
|
|
}
|
|
|
|
// --- Check if results were found
|
|
if ( $iBegin == $this->_currentRecordNum )
|
|
return ERROR_NOMORERECORDS;
|
|
// ---
|
|
|
|
// return success state if reached this point!
|
|
return SUCCESS;
|
|
}
|
|
|
|
/*
|
|
* Creates the SQL Statement we are going to use!
|
|
*/
|
|
private function CreateSQLStatement($uID, $includeFields = true)
|
|
{
|
|
global $dbmapping;
|
|
|
|
// Copy helper variables, this is just for better readability
|
|
$szTableType = $this->_logStreamConfigObj->DBTableType;
|
|
$szSortColumn = $this->_logStreamConfigObj->SortColumn;
|
|
|
|
// Create Basic SQL String
|
|
// if ( $this->_logStreamConfigObj->DBEnableRowCounting ) // with SQL_CALC_FOUND_ROWS
|
|
// $sqlString = "SELECT SQL_CALC_FOUND_ROWS " . $dbmapping[$szTableType][SYSLOG_UID];
|
|
// else // without row calc
|
|
$sqlString = "SELECT " . $dbmapping[$szTableType][SYSLOG_UID];
|
|
|
|
// Append fields if needed
|
|
if ( $includeFields && $this->_arrProperties != null )
|
|
{
|
|
// Loop through all requested fields
|
|
foreach ( $this->_arrProperties as $myproperty )
|
|
{
|
|
// SYSLOG_UID already added!
|
|
if ( $myproperty != SYSLOG_UID && isset($dbmapping[$szTableType][$myproperty]) )
|
|
{
|
|
// Append field!
|
|
$sqlString .= ", " . $dbmapping[$szTableType][$myproperty];
|
|
}
|
|
}
|
|
}
|
|
|
|
// Append FROM 'table'!
|
|
$sqlString .= " FROM " . $this->_logStreamConfigObj->DBTableName;
|
|
|
|
// Append precreated where clause
|
|
$sqlString .= $this->_SQLwhereClause;
|
|
|
|
// Append UID QUERY!
|
|
if ( $uID != -1 )
|
|
{
|
|
if ( $this->_readDirection == EnumReadDirection::Forward )
|
|
$myOperator = ">=";
|
|
else
|
|
$myOperator = "<=";
|
|
|
|
if ( strlen($this->_SQLwhereClause) > 0 )
|
|
$sqlString .= " AND " . $dbmapping[$szTableType][SYSLOG_UID] . " $myOperator $uID";
|
|
else
|
|
$sqlString .= " WHERE " . $dbmapping[$szTableType][SYSLOG_UID] . " $myOperator $uID";
|
|
}
|
|
|
|
// Append ORDER clause
|
|
if ( $this->_readDirection == EnumReadDirection::Forward )
|
|
$sqlString .= " ORDER BY " . $dbmapping[$szTableType][$szSortColumn];
|
|
else if ( $this->_readDirection == EnumReadDirection::Backward )
|
|
$sqlString .= " ORDER BY " . $dbmapping[$szTableType][$szSortColumn] . " DESC";
|
|
|
|
//echo $sqlString;
|
|
//exit;
|
|
|
|
// return SQL result string:
|
|
return $sqlString;
|
|
}
|
|
|
|
/*
|
|
* Reset record buffer in this function!
|
|
*/
|
|
private function ResetBufferedRecords()
|
|
{
|
|
if ( isset($this->bufferedRecords) )
|
|
{
|
|
// Loop through all subrecords first!
|
|
foreach ($this->bufferedRecords as $mykey => $myrecord)
|
|
unset( $this->bufferedRecords[$mykey] );
|
|
|
|
// Set buffered records to NULL!
|
|
$this->bufferedRecords = null;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Helper function to display SQL Errors for now!
|
|
*/
|
|
private function PrintDebugError($szErrorMsg)
|
|
{
|
|
if ( GetConfigSetting("MiscShowDebugMsg", 0, CFGLEVEL_USER) == 1 )
|
|
{
|
|
$errdesc = $this->_dbhandle == null ? "" : implode( ";", $this->_dbhandle->errorInfo() );
|
|
$errno = $this->_dbhandle == null ? "" : $this->_dbhandle->errorCode();
|
|
|
|
$errormsg ="<table width=\"600\" align=\"center\" class=\"with_border\"><tr><td>";
|
|
$errormsg.="<center><H3><font color='red'>Error: " . $szErrorMsg . "</font></H3><br></center>";
|
|
$errormsg.="<B>Errordetails:</B><br>";
|
|
$errormsg.="Detail Error: $errdesc <br>";
|
|
$errormsg.="Error Code: $errno <br>";
|
|
$errormsg.="Date: ".date("d.m.Y @ H:i"). "<br>";
|
|
$errormsg.="</td></tr></table>";
|
|
|
|
//Output!
|
|
print( $errormsg );
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Returns the number of possible records by using a select count statement!
|
|
*/
|
|
private function GetRowCountFromTable()
|
|
{
|
|
/*
|
|
if ( $myquery = mysql_query("Select FOUND_ROWS();", $this->_dbhandle) )
|
|
{
|
|
// Get first and only row!
|
|
$myRow = mysql_fetch_array($myquery);
|
|
|
|
// copy row count
|
|
$numRows = $myRow[0];
|
|
}
|
|
else
|
|
$numRows = -1;
|
|
*/
|
|
|
|
/* OLD slow code! */
|
|
global $dbmapping,$querycount;
|
|
$szTableType = $this->_logStreamConfigObj->DBTableType;
|
|
|
|
// Create Statement and perform query!
|
|
$szSql = "SELECT count(" . $dbmapping[$szTableType][SYSLOG_UID] . ") FROM " . $this->_logStreamConfigObj->DBTableName . $this->_SQLwhereClause;
|
|
$myQuery = $this->_dbhandle->query($szSql);
|
|
if ($myQuery)
|
|
{
|
|
// obtain first and only row
|
|
$myRow = $myQuery->fetchColumn();
|
|
$numRows = $myRow; // $myRow[0];
|
|
|
|
// Increment for the Footer Stats
|
|
$querycount++;
|
|
|
|
// Free query now
|
|
$myQuery->closeCursor();
|
|
}
|
|
else
|
|
{
|
|
$this->PrintDebugError("RowCount query failed: " . $szSql);
|
|
$numRows = -1;
|
|
}
|
|
|
|
// return result!
|
|
return $numRows;
|
|
}
|
|
|
|
|
|
}
|
|
|
|
?>
|