void
NavAI::Navigator()
{
accumulator.Clear();
magnitude = 0;
brakes = 0;
hold = false;
if (navpt) {
if (navpt->Status() == Instruction::COMPLETE && navpt->HoldTime() > 0) {
ship->SetDirectorInfo(Game::GetText("ai.auto-hold"));
hold = true;
}
else {
ship->SetDirectorInfo(Game::GetText("ai.auto-nav"));
}
}
else {
ship->SetDirectorInfo(Game::GetText("ai.auto-stop"));
}
Accumulate(AvoidTerrain());
Accumulate(AvoidCollision());
if (!hold)
accumulator = SeekTarget();
HelmControl();
ThrottleControl();
}
void ReportEnvironmental::EndTimestep( float currentTime, float dt )
{
Accumulate( _num_enviro_infections_label, enviro_infections_counter );
Accumulate( _num_contact_infections_label, contact_infections_counter );
enviro_infections_counter = 0;
contact_infections_counter = 0;
Report::EndTimestep( currentTime, dt );
}
void VectorSpeciesReport::EndTimestep( float currentTime, float dt )
{
Accumulate("Adult Vectors", adult_vectors);
Accumulate("Infectious Vectors", infectious_vectors);
Accumulate("Daily EIR", daily_eir);
Accumulate("Daily HBR", daily_hbr);
clearChannelsBins();
}
TVector<TFeatureEffect> CalcRegularFeatureEffect(const TVector<std::pair<double, TFeature>>& internalEffect,
int catFeaturesCount, int floatFeaturesCount) {
TVector<double> catFeatureEffect(catFeaturesCount);
TVector<double> floatFeatureEffect(floatFeaturesCount);
for (const auto& effectWithSplit : internalEffect) {
TFeature feature = effectWithSplit.second;
switch (feature.Type) {
case ESplitType::FloatFeature:
floatFeatureEffect[feature.FeatureIdx] += effectWithSplit.first;
break;
case ESplitType::OneHotFeature:
catFeatureEffect[feature.FeatureIdx] += effectWithSplit.first;
break;
case ESplitType::OnlineCtr:
auto& proj = feature.Ctr.Base.Projection;
int featuresInSplit = proj.BinFeatures.ysize() + proj.CatFeatures.ysize() + proj.OneHotFeatures.ysize();
double addEffect = effectWithSplit.first / featuresInSplit;
for (const auto& binFeature : proj.BinFeatures) {
floatFeatureEffect[binFeature.FloatFeature] += addEffect;
}
for (auto catIndex : proj.CatFeatures) {
catFeatureEffect[catIndex] += addEffect;
}
for (auto oneHotFeature : proj.OneHotFeatures) {
catFeatureEffect[oneHotFeature.CatFeatureIdx] += addEffect;
}
break;
}
}
double totalCat = Accumulate(catFeatureEffect.begin(), catFeatureEffect.end(), 0.0);
double totalFloat = Accumulate(floatFeatureEffect.begin(), floatFeatureEffect.end(), 0.0);
double total = totalCat + totalFloat;
TVector<TFeatureEffect> regularFeatureEffect;
for (int i = 0; i < catFeatureEffect.ysize(); ++i) {
if (catFeatureEffect[i] > 0) {
regularFeatureEffect.push_back(TFeatureEffect(catFeatureEffect[i] / total * 100, EFeatureType::Categorical, i));
}
}
for (int i = 0; i < floatFeatureEffect.ysize(); ++i) {
if (floatFeatureEffect[i] > 0) {
regularFeatureEffect.push_back(TFeatureEffect(floatFeatureEffect[i] / total * 100, EFeatureType::Float, i));
}
}
Sort(regularFeatureEffect.rbegin(), regularFeatureEffect.rend(), [](const TFeatureEffect& left, const TFeatureEffect& right) {
return left.Score < right.Score;
});
return regularFeatureEffect;
}
void
ReportEnvironmental::LogNodeData( INodeContext * pNC )
{
Report::LogNodeData( pNC );
auto contagionPop = pNC->GetContagionByRoute();
NonNegativeFloat contactContagionPop = contagionPop["contact"];
NonNegativeFloat enviroContagionPop = contagionPop["environmental"];
LOG_DEBUG_F( "Recording %f as 'Contact Contagion Population'.\n", float(contactContagionPop) );
LOG_DEBUG_F( "Recording %f as 'Environmental Contagion Population'.\n", float(enviroContagionPop) );
Accumulate( "Contact Contagion Population", contactContagionPop );
Accumulate( "Environmental Contagion Population", enviroContagionPop );
}
// Attempt to increment the appropriate bin in the provided Telemetry probe ID. If
// there was a hash failure, we do nothing.
void
AccumulateTelemetryForRootCA(mozilla::Telemetry::HistogramID probe,
const CERTCertificate* cert)
{
int32_t binId = RootCABinNumber(&cert->derCert);
if (binId != ROOT_CERTIFICATE_HASH_FAILURE) {
Accumulate(probe, binId);
}
}
void GetDiffAndPSNR(const uint8_t rgba1[], const uint8_t rgba2[],
uint32_t width, uint32_t height, int premultiply,
int* const max_diff, double* const psnr) {
const uint32_t stride = width * kNumChannels;
const int kAlphaChannel = kNumChannels - 1;
double f_max_diff = 0.;
double sse = 0.;
uint32_t x, y;
for (y = 0; y < height; ++y) {
for (x = 0; x < stride; x += kNumChannels) {
int k;
const size_t offset = y * stride + x;
const int alpha1 = rgba1[offset + kAlphaChannel];
const int alpha2 = rgba2[offset + kAlphaChannel];
Accumulate(alpha1, alpha2, &f_max_diff, &sse);
if (!premultiply) {
for (k = 0; k < kAlphaChannel; ++k) {
Accumulate(rgba1[offset + k], rgba2[offset + k], &f_max_diff, &sse);
}
} else {
// premultiply R/G/B channels with alpha value
for (k = 0; k < kAlphaChannel; ++k) {
Accumulate(rgba1[offset + k] * alpha1 / 255.,
rgba2[offset + k] * alpha2 / 255.,
&f_max_diff, &sse);
}
}
}
}
*max_diff = (int)f_max_diff;
if (*max_diff == 0) {
*psnr = 99.; // PSNR when images are identical.
} else {
sse /= stride * height;
*psnr = 4.3429448 * log(255. * 255. / sse);
}
}
int
ReaderHelper::GetRSSvalue(const std::array<int, 4>& widths, int maxWidth, bool noNarrow)
{
int elements = static_cast<int>(widths.size());
int n = Accumulate(widths, 0);
int val = 0;
int narrowMask = 0;
for (int bar = 0; bar < elements - 1; bar++) {
int elmWidth;
for (elmWidth = 1, narrowMask |= 1 << bar;
elmWidth < widths[bar];
elmWidth++, narrowMask &= ~(1 << bar)) {
int subVal = combins(n - elmWidth - 1, elements - bar - 2);
if (noNarrow && (narrowMask == 0) &&
(n - elmWidth - (elements - bar - 1) >= elements - bar - 1)) {
subVal -= combins(n - elmWidth - (elements - bar),
elements - bar - 2);
}
if (elements - bar - 1 > 1) {
int lessVal = 0;
for (int mxwElement = n - elmWidth - (elements - bar - 2);
mxwElement > maxWidth; mxwElement--) {
lessVal += combins(n - elmWidth - mxwElement - 1,
elements - bar - 3);
}
subVal -= lessVal * (elements - 1 - bar);
}
else if (n - elmWidth > maxWidth) {
subVal--;
}
val += subVal;
}
n -= elmWidth;
}
return val;
}
static int FindSubexprs(SEXP expr, SEXP exprlist, SEXP tag)
{
SEXP e;
int k;
switch(TYPEOF(expr)) {
case SYMSXP:
case LGLSXP:
case INTSXP:
case REALSXP:
case CPLXSXP:
return 0;
break;
case LISTSXP:
if (inherits(expr, "expression"))
return FindSubexprs(CAR(expr), exprlist, tag);
else { InvalidExpression("FindSubexprs"); return -1/*-Wall*/; }
break;
case LANGSXP:
if (CAR(expr) == install("(")) {
return FindSubexprs(CADR(expr), exprlist, tag);
}
else {
e = CDR(expr);
while(e != R_NilValue) {
if ((k = FindSubexprs(CAR(e), exprlist, tag)) != 0)
SETCAR(e, MakeVariable(k, tag));
e = CDR(e);
}
return Accumulate(expr, exprlist);
}
break;
default:
InvalidExpression("FindSubexprs");
return -1/*-Wall*/;
}
}
/*@
MPI_Accumulate - Accumulate data into the target process using remote
memory access
Input Parameters:
+ origin_addr - initial address of buffer (choice)
. origin_count - number of entries in buffer (nonnegative integer)
. origin_datatype - datatype of each buffer entry (handle)
. target_rank - rank of target (nonnegative integer)
. target_disp - displacement from start of window to beginning of target
buffer (nonnegative integer)
. target_count - number of entries in target buffer (nonnegative integer)
. target_datatype - datatype of each entry in target buffer (handle)
. op - predefined reduce operation (handle)
- win - window object (handle)
Notes:
The basic components of both the origin and target datatype must be the same
predefined datatype (e.g., all 'MPI_INT' or all 'MPI_DOUBLE_PRECISION').
.N Fortran
.N Errors
.N MPI_SUCCESS
.N MPI_ERR_ARG
.N MPI_ERR_COUNT
.N MPI_ERR_RANK
.N MPI_ERR_TYPE
.N MPI_ERR_WIN
@*/
int MPI_Accumulate(void *origin_addr, int origin_count, MPI_Datatype
origin_datatype, int target_rank, MPI_Aint
target_disp, int target_count, MPI_Datatype
target_datatype, MPI_Op op, MPI_Win win)
{
static const char FCNAME[] = "MPI_Accumulate";
int mpi_errno = MPI_SUCCESS;
MPID_Win *win_ptr = NULL;
MPID_MPI_STATE_DECL(MPID_STATE_MPI_ACCUMULATE);
MPIR_ERRTEST_INITIALIZED_ORDIE();
MPIU_THREAD_CS_ENTER(ALLFUNC,);
MPID_MPI_RMA_FUNC_ENTER(MPID_STATE_MPI_ACCUMULATE);
/* Validate parameters, especially handles needing to be converted */
# ifdef HAVE_ERROR_CHECKING
{
MPID_BEGIN_ERROR_CHECKS;
{
MPIR_ERRTEST_WIN(win, mpi_errno);
if (mpi_errno != MPI_SUCCESS) goto fn_fail;
}
MPID_END_ERROR_CHECKS;
}
# endif
/* Convert MPI object handles to object pointers */
MPID_Win_get_ptr( win, win_ptr );
/* Validate parameters and objects (post conversion) */
# ifdef HAVE_ERROR_CHECKING
{
MPID_BEGIN_ERROR_CHECKS;
{
MPID_Comm * comm_ptr;
/* Validate win_ptr */
MPID_Win_valid_ptr( win_ptr, mpi_errno );
if (mpi_errno) goto fn_fail;
MPIR_ERRTEST_COUNT(origin_count, mpi_errno);
MPIR_ERRTEST_DATATYPE(origin_datatype, "origin_datatype",
mpi_errno);
MPIR_ERRTEST_COUNT(target_count, mpi_errno);
MPIR_ERRTEST_DATATYPE(target_datatype, "target_datatype",
mpi_errno);
MPIR_ERRTEST_DISP(target_disp, mpi_errno);
if (HANDLE_GET_KIND(origin_datatype) != HANDLE_KIND_BUILTIN)
{
MPID_Datatype *datatype_ptr = NULL;
MPID_Datatype_get_ptr(origin_datatype, datatype_ptr);
MPID_Datatype_valid_ptr(datatype_ptr, mpi_errno);
MPID_Datatype_committed_ptr(datatype_ptr, mpi_errno);
}
if (HANDLE_GET_KIND(target_datatype) != HANDLE_KIND_BUILTIN)
{
MPID_Datatype *datatype_ptr = NULL;
MPID_Datatype_get_ptr(target_datatype, datatype_ptr);
MPID_Datatype_valid_ptr(datatype_ptr, mpi_errno);
MPID_Datatype_committed_ptr(datatype_ptr, mpi_errno);
}
comm_ptr = win_ptr->comm_ptr;
MPIR_ERRTEST_SEND_RANK(comm_ptr, target_rank, mpi_errno);
if (mpi_errno != MPI_SUCCESS) goto fn_fail;
}
MPID_END_ERROR_CHECKS;
}
# endif /* HAVE_ERROR_CHECKING */
/* ... body of routine ... */
if (target_rank == MPI_PROC_NULL) goto fn_exit;
mpi_errno = MPIU_RMA_CALL(win_ptr,Accumulate(origin_addr, origin_count,
origin_datatype,
target_rank, target_disp, target_count,
target_datatype, op, win_ptr));
if (mpi_errno != MPI_SUCCESS) goto fn_fail;
/* ... end of body of routine ... */
fn_exit:
MPID_MPI_RMA_FUNC_EXIT(MPID_STATE_MPI_ACCUMULATE);
MPIU_THREAD_CS_EXIT(ALLFUNC,);
return mpi_errno;
fn_fail:
/* --BEGIN ERROR HANDLING-- */
# ifdef HAVE_ERROR_CHECKING
{
mpi_errno = MPIR_Err_create_code(
mpi_errno, MPIR_ERR_RECOVERABLE, FCNAME, __LINE__, MPI_ERR_OTHER, "**mpi_accumulate",
"**mpi_accumulate %p %d %D %d %d %d %D %O %W", origin_addr, origin_count, origin_datatype,
target_rank, target_disp, target_count, target_datatype, op, win);
}
# endif
mpi_errno = MPIR_Err_return_win( win_ptr, FCNAME, mpi_errno );
goto fn_exit;
/* --END ERROR HANDLING-- */
}
//------------------------------------------------------------------------------
Solver::SolverState BatchEstimator::AdvanceState()
{
switch (currentState)
{
case INITIALIZING:
#ifdef DEBUG_STATE_MACHINE
MessageInterface::ShowMessage("Entered Estimator state machine: "
"INITIALIZING\n");
#endif
// ReportProgress();
CompleteInitialization();
break;
case PROPAGATING:
#ifdef DEBUG_STATE_MACHINE
MessageInterface::ShowMessage("Entered Estimator state machine: "
"PROPAGATING\n");
#endif
// ReportProgress();
FindTimeStep();
break;
case CALCULATING:
#ifdef DEBUG_STATE_MACHINE
MessageInterface::ShowMessage("Entered Estimator state machine: "
"CALCULATING\n");
#endif
// ReportProgress();
CalculateData();
break;
case LOCATING:
#ifdef DEBUG_STATE_MACHINE
MessageInterface::ShowMessage("Entered Estimator state machine: "
"LOCATING\n");
#endif
// ReportProgress();
ProcessEvent();
break;
case ACCUMULATING:
#ifdef DEBUG_STATE_MACHINE
MessageInterface::ShowMessage("Entered Estimator state machine: "
"ACCUMULATING\n");
#endif
// ReportProgress();
Accumulate();
break;
case ESTIMATING:
#ifdef DEBUG_STATE_MACHINE
MessageInterface::ShowMessage("Entered Estimator state machine: "
"ESTIMATING\n");
#endif
// ReportProgress();
Estimate();
break;
case CHECKINGRUN:
#ifdef DEBUG_STATE_MACHINE
MessageInterface::ShowMessage("Entered Estimator state machine: "
"CHECKINGRUN\n");
#endif
// ReportProgress();
CheckCompletion();
break;
case FINISHED:
#ifdef DEBUG_STATE_MACHINE
MessageInterface::ShowMessage("Entered Estimator state machine: "
"FINISHED\n");
#endif
RunComplete();
// ReportProgress();
break;
default:
#ifdef DEBUG_STATE_MACHINE
MessageInterface::ShowMessage("Entered Estimator state machine: "
"Bad state for an estimator.\n");
#endif
/* throw EstimatorException("Solver state not supported for the simulator")*/;
}
return currentState;
}
int Accumulate(T v, Ts... vs)
{
return v + Accumulate(vs...);
}
int main()
{
int acc = Accumulate(1, 2, 3, 4, -5);
int count = CountElements<1, 2, 3, 4, 5>();
return ((acc == 5) && (count == 5)) ? 0 : 1;
}
double TrackList::GetEndTime() const
{
return Accumulate(*this, &Track::GetEndTime, -DBL_MAX, std::max);
}
double TrackList::GetStartTime() const
{
return Accumulate(*this, &Track::GetStartTime, DBL_MAX, std::min);
}
double TrackList::GetMinOffset() const
{
return Accumulate(*this, &Track::GetOffset, DBL_MAX, std::min);
}
template <class T> T AbstractGroup<T>::CascadeScalarMultiply(const Element &x, const Integer &e1, const Element &y, const Integer &e2) const
{
const unsigned expLen = STDMAX(e1.BitCount(), e2.BitCount());
if (expLen==0)
return this->Identity();
const unsigned w = (expLen <= 46 ? 1 : (expLen <= 260 ? 2 : 3));
const unsigned tableSize = 1<<w;
std::vector<Element> powerTable(tableSize << w);
powerTable[1] = x;
powerTable[tableSize] = y;
if (w==1)
powerTable[3] = this->Add(x,y);
else
{
powerTable[2] = this->Double(x);
powerTable[2*tableSize] = this->Double(y);
unsigned i, j;
for (i=3; i<tableSize; i+=2)
powerTable[i] = Add(powerTable[i-2], powerTable[2]);
for (i=1; i<tableSize; i+=2)
for (j=i+tableSize; j<(tableSize<<w); j+=tableSize)
powerTable[j] = Add(powerTable[j-tableSize], y);
for (i=3*tableSize; i<(tableSize<<w); i+=2*tableSize)
powerTable[i] = Add(powerTable[i-2*tableSize], powerTable[2*tableSize]);
for (i=tableSize; i<(tableSize<<w); i+=2*tableSize)
for (j=i+2; j<i+tableSize; j+=2)
powerTable[j] = Add(powerTable[j-1], x);
}
Element result;
unsigned power1 = 0, power2 = 0, prevPosition = expLen-1;
bool firstTime = true;
for (int i = expLen-1; i>=0; i--)
{
power1 = 2*power1 + e1.GetBit(i);
power2 = 2*power2 + e2.GetBit(i);
if (i==0 || 2*power1 >= tableSize || 2*power2 >= tableSize)
{
unsigned squaresBefore = prevPosition-i;
unsigned squaresAfter = 0;
prevPosition = i;
while ((power1 || power2) && power1%2 == 0 && power2%2==0)
{
power1 /= 2;
power2 /= 2;
squaresBefore--;
squaresAfter++;
}
if (firstTime)
{
result = powerTable[(power2<<w) + power1];
firstTime = false;
}
else
{
while (squaresBefore--)
result = this->Double(result);
if (power1 || power2)
Accumulate(result, powerTable[(power2<<w) + power1]);
}
while (squaresAfter--)
result = this->Double(result);
power1 = power2 = 0;
}
}
return result;
}
double TrackList::GetEndTime() const
{
return Accumulate(*this, &Track::GetEndTime, doubleMax);
}
void OS_ReadMSG_analysisd(int m_queue)
#endif
{
int i;
char msg[OS_MAXSTR +1];
Eventinfo *lf;
RuleInfo *stats_rule = NULL;
/* Null to global currently pointers */
currently_rule = NULL;
/* Initiating the logs */
OS_InitLog();
/* Initiating the integrity database */
SyscheckInit();
/* Initializing Rootcheck */
RootcheckInit();
/* Initializing host info */
HostinfoInit();
/* Creating the event list */
OS_CreateEventList(Config.memorysize);
/* Initiating the FTS list */
if(!FTS_Init())
{
ErrorExit(FTS_LIST_ERROR, ARGV0);
}
/* Initialize the Accumulator */
if(!Accumulate_Init()) {
merror("accumulator: ERROR: Initialization failed");
exit(1);
}
/* Starting the active response queues */
if(Config.ar)
{
/* Waiting the ARQ to settle .. */
sleep(3);
#ifndef LOCAL
if(Config.ar & REMOTE_AR)
{
if((arq = StartMQ(ARQUEUE, WRITE)) < 0)
{
merror(ARQ_ERROR, ARGV0);
/* If LOCAL_AR is set, keep it there */
if(Config.ar & LOCAL_AR)
{
Config.ar = 0;
Config.ar|=LOCAL_AR;
}
else
{
Config.ar = 0;
}
}
else
{
verbose(CONN_TO, ARGV0, ARQUEUE, "active-response");
}
}
#else
/* Only for LOCAL_ONLY installs */
if(Config.ar & REMOTE_AR)
{
if(Config.ar & LOCAL_AR)
{
Config.ar = 0;
Config.ar|=LOCAL_AR;
}
else
{
Config.ar = 0;
}
}
#endif
if(Config.ar & LOCAL_AR)
{
if((execdq = StartMQ(EXECQUEUE, WRITE)) < 0)
{
merror(ARQ_ERROR, ARGV0);
/* If REMOTE_AR is set, keep it there */
if(Config.ar & REMOTE_AR)
{
Config.ar = 0;
Config.ar|=REMOTE_AR;
}
else
{
Config.ar = 0;
}
}
else
{
verbose(CONN_TO, ARGV0, EXECQUEUE, "exec");
}
}
}
debug1("%s: DEBUG: Active response Init completed.", ARGV0);
/* Getting currently time before starting */
c_time = time(NULL);
/* Starting the hourly/weekly stats */
if(Start_Hour() < 0)
Config.stats = 0;
else
{
/* Initializing stats rules */
stats_rule = zerorulemember(
STATS_MODULE,
Config.stats,
0,0,0,0,0,0);
if(!stats_rule)
{
ErrorExit(MEM_ERROR, ARGV0);
}
stats_rule->group = "stats,";
stats_rule->comment = "Excessive number of events (above normal).";
}
/* Doing some cleanup */
memset(msg, '\0', OS_MAXSTR +1);
/* Initializing the logs */
{
lf = (Eventinfo *)calloc(1,sizeof(Eventinfo));
if(!lf)
ErrorExit(MEM_ERROR, ARGV0);
lf->year = prev_year;
strncpy(lf->mon, prev_month, 3);
lf->day = today;
if(OS_GetLogLocation(lf) < 0)
{
ErrorExit("%s: Error allocating log files", ARGV0);
}
Free_Eventinfo(lf);
}
debug1("%s: DEBUG: Startup completed. Waiting for new messages..",ARGV0);
if(Config.custom_alert_output)
debug1("%s: INFO: Custom output found.!",ARGV0);
/* Daemon loop */
while(1)
{
lf = (Eventinfo *)calloc(1,sizeof(Eventinfo));
/* This shouldn't happen .. */
if(lf == NULL)
{
ErrorExit(MEM_ERROR,ARGV0);
}
DEBUG_MSG("%s: DEBUG: Waiting for msgs - %d ", ARGV0, (int)time(0));
/* Receive message from queue */
if((i = OS_RecvUnix(m_queue, OS_MAXSTR, msg)))
{
RuleNode *rulenode_pt;
/* Getting the time we received the event */
c_time = time(NULL);
/* Default values for the log info */
Zero_Eventinfo(lf);
/* Checking for a valid message. */
if(i < 4)
{
merror(IMSG_ERROR, ARGV0, msg);
Free_Eventinfo(lf);
continue;
}
/* Message before extracting header */
DEBUG_MSG("%s: DEBUG: Received msg: %s ", ARGV0, msg);
/* Clean the msg appropriately */
if(OS_CleanMSG(msg, lf) < 0)
{
merror(IMSG_ERROR,ARGV0, msg);
Free_Eventinfo(lf);
continue;
}
/* Msg cleaned */
DEBUG_MSG("%s: DEBUG: Msg cleanup: %s ", ARGV0, lf->log);
/* Currently rule must be null in here */
currently_rule = NULL;
/** Checking the date/hour changes **/
/* Update the hour */
if(thishour != __crt_hour)
{
/* Search all the rules and print the number
* of alerts that each one fired.
*/
DumpLogstats();
thishour = __crt_hour;
/* Check if the date has changed */
if(today != lf->day)
{
if(Config.stats)
{
/* Update the hourly stats (done daily) */
Update_Hour();
}
if(OS_GetLogLocation(lf) < 0)
{
ErrorExit("%s: Error allocating log files", ARGV0);
}
today = lf->day;
strncpy(prev_month, lf->mon, 3);
prev_year = lf->year;
}
}
/* Incrementing number of events received */
hourly_events++;
/*** Running decoders ***/
/* Integrity check from syscheck */
if(msg[0] == SYSCHECK_MQ)
{
hourly_syscheck++;
if(!DecodeSyscheck(lf))
{
/* We don't process syscheck events further */
goto CLMEM;
}
/* Getting log size */
lf->size = strlen(lf->log);
}
/* Rootcheck decoding */
else if(msg[0] == ROOTCHECK_MQ)
{
if(!DecodeRootcheck(lf))
{
/* We don't process rootcheck events further */
goto CLMEM;
}
lf->size = strlen(lf->log);
}
/* Host information special decoder */
else if(msg[0] == HOSTINFO_MQ)
{
if(!DecodeHostinfo(lf))
{
/* We don't process hostinfo events further */
goto CLMEM;
}
lf->size = strlen(lf->log);
}
/* Run the general Decoders */
else
{
/* Getting log size */
lf->size = strlen(lf->log);
DecodeEvent(lf);
}
/* Run accumulator */
if( lf->decoder_info->accumulate == 1 ) {
lf = Accumulate(lf);
}
/* Firewall event */
if(lf->decoder_info->type == FIREWALL)
{
/* If we could not get any information from
* the log, just ignore it
*/
hourly_firewall++;
if(Config.logfw)
{
if(!FW_Log(lf))
{
goto CLMEM;
}
}
}
/* We only check if the last message is
* duplicated on syslog.
*/
else if(lf->decoder_info->type == SYSLOG)
{
/* Checking if the message is duplicated */
if(LastMsg_Stats(lf->full_log) == 1)
goto CLMEM;
else
LastMsg_Change(lf->full_log);
}
/* Stats checking */
if(Config.stats)
{
if(Check_Hour() == 1)
{
void *saved_rule = lf->generated_rule;
char *saved_log;
/* Saving previous log */
saved_log = lf->full_log;
lf->generated_rule = stats_rule;
lf->full_log = __stats_comment;
/* alert for statistical analysis */
if(stats_rule->alert_opts & DO_LOGALERT)
{
__crt_ftell = ftell(_aflog);
if(Config.custom_alert_output)
{
OS_CustomLog(lf,Config.custom_alert_output_format);
}
else
{
OS_Log(lf);
}
}
/* Set lf to the old values */
lf->generated_rule = saved_rule;
lf->full_log = saved_log;
}
}
/* Checking the rules */
DEBUG_MSG("%s: DEBUG: Checking the rules - %d ",
ARGV0, lf->decoder_info->type);
/* Looping all the rules */
rulenode_pt = OS_GetFirstRule();
if(!rulenode_pt)
{
ErrorExit("%s: Rules in an inconsistent state. Exiting.",
ARGV0);
}
do
{
if(lf->decoder_info->type == OSSEC_ALERT)
{
if(!lf->generated_rule)
{
goto CLMEM;
}
/* We go ahead in here and process the alert. */
currently_rule = lf->generated_rule;
}
/* The categories must match */
else if(rulenode_pt->ruleinfo->category !=
lf->decoder_info->type)
{
continue;
}
/* Checking each rule. */
else if((currently_rule = OS_CheckIfRuleMatch(lf, rulenode_pt))
== NULL)
{
continue;
}
/* Ignore level 0 */
if(currently_rule->level == 0)
{
break;
}
/* Checking ignore time */
if(currently_rule->ignore_time)
{
if(currently_rule->time_ignored == 0)
{
currently_rule->time_ignored = lf->time;
}
/* If the currently time - the time the rule was ignored
* is less than the time it should be ignored,
* leave (do not alert again).
*/
else if((lf->time - currently_rule->time_ignored)
< currently_rule->ignore_time)
{
break;
}
else
{
currently_rule->time_ignored = lf->time;
}
}
/* Pointer to the rule that generated it */
lf->generated_rule = currently_rule;
/* Checking if we should ignore it */
if(currently_rule->ckignore && IGnore(lf))
{
/* Ignoring rule */
lf->generated_rule = NULL;
break;
}
/* Checking if we need to add to ignore list */
if(currently_rule->ignore)
{
AddtoIGnore(lf);
}
/* Log the alert if configured to ... */
if(currently_rule->alert_opts & DO_LOGALERT)
{
__crt_ftell = ftell(_aflog);
if(Config.custom_alert_output)
{
OS_CustomLog(lf,Config.custom_alert_output_format);
}
else
{
OS_Log(lf);
}
}
/* Log to prelude */
#ifdef PRELUDE
if(Config.prelude)
{
if(Config.prelude_log_level <= currently_rule->level)
{
OS_PreludeLog(lf);
}
}
#endif
/* Log to zeromq */
#ifdef ZEROMQ_OUTPUT
if(Config.zeromq_output)
{
zeromq_output_event(lf);
}
#endif
/* Log to Picviz */
if (Config.picviz)
{
OS_PicvizLog(lf);
}
/* Execute an active response */
if(currently_rule->ar)
{
int do_ar;
active_response **rule_ar;
rule_ar = currently_rule->ar;
while(*rule_ar)
{
do_ar = 1;
if((*rule_ar)->ar_cmd->expect & USERNAME)
{
if(!lf->dstuser ||
!OS_PRegex(lf->dstuser,"^[a-zA-Z._0-9@?-]*$"))
{
if(lf->dstuser)
merror(CRAFTED_USER, ARGV0, lf->dstuser);
do_ar = 0;
}
}
if((*rule_ar)->ar_cmd->expect & SRCIP)
{
if(!lf->srcip ||
!OS_PRegex(lf->srcip, "^[a-zA-Z.:_0-9-]*$"))
{
if(lf->srcip)
merror(CRAFTED_IP, ARGV0, lf->srcip);
do_ar = 0;
}
}
if((*rule_ar)->ar_cmd->expect & FILENAME)
{
if(!lf->filename)
{
do_ar = 0;
}
}
if(do_ar)
{
OS_Exec(&execdq, &arq, lf, *rule_ar);
}
rule_ar++;
}
}
/* Copy the structure to the state memory of if_matched_sid */
if(currently_rule->sid_prev_matched)
{
if(!OSList_AddData(currently_rule->sid_prev_matched, lf))
{
merror("%s: Unable to add data to sig list.", ARGV0);
}
else
{
lf->sid_node_to_delete =
currently_rule->sid_prev_matched->last_node;
}
}
/* Group list */
else if(currently_rule->group_prev_matched)
{
i = 0;
while(i < currently_rule->group_prev_matched_sz)
{
if(!OSList_AddData(
currently_rule->group_prev_matched[i],
lf))
{
merror("%s: Unable to add data to grp list.",ARGV0);
}
i++;
}
}
OS_AddEvent(lf);
break;
}while((rulenode_pt = rulenode_pt->next) != NULL);
/* If configured to log all, do it */
if(Config.logall)
OS_Store(lf);
/* Cleaning the memory */
CLMEM:
/* Only clear the memory if the eventinfo was not
* added to the stateful memory
* -- message is free inside clean event --
*/
if(lf->generated_rule == NULL)
Free_Eventinfo(lf);
}
else
{
free(lf);
}
}
return;
}
double TrackList::GetMinOffset() const
{
return Accumulate(*this, &Track::GetOffset, doubleMin);
}
double TrackList::GetStartTime() const
{
return Accumulate(*this, &Track::GetStartTime, doubleMin);
}
FINL
CAccumulator<T_TYPE, T_SIZE>& operator<< (const T_TYPE& datum ) {
Accumulate ( datum );
return (*this);
}
void OS_ReadMSG(char *ut_str)
{
char msg[OS_MAXSTR + 1];
int exit_code = 0;
char *ut_alertlevel = NULL;
char *ut_rulelevel = NULL;
char *ut_decoder_name = NULL;
if (ut_str) {
/* XXX Break apart string */
ut_rulelevel = ut_str;
ut_alertlevel = strchr(ut_rulelevel, ':');
if (!ut_alertlevel) {
ErrorExit("%s: -U requires the matching format to be "
"\"<rule_id>:<alert_level>:<decoder_name>\"", ARGV0);
} else {
*ut_alertlevel = '\0';
ut_alertlevel++;
}
ut_decoder_name = strchr(ut_alertlevel, ':');
if (!ut_decoder_name) {
ErrorExit("%s: -U requires the matching format to be "
"\"<rule_id>:<alert_level>:<decoder_name>\"", ARGV0);
} else {
*ut_decoder_name = '\0';
ut_decoder_name++;
}
}
RuleInfoDetail *last_info_detail;
Eventinfo *lf;
/* Null global pointer to current rule */
currently_rule = NULL;
/* Create the event list */
OS_CreateEventList(Config.memorysize);
/* Initiate the FTS list */
if (!FTS_Init()) {
ErrorExit(FTS_LIST_ERROR, ARGV0);
}
/* Initialize the Accumulator */
if (!Accumulate_Init()) {
merror("accumulator: ERROR: Initialization failed");
exit(1);
}
__crt_ftell = 1;
/* Get current time before starting */
c_time = time(NULL);
/* Do some cleanup */
memset(msg, '\0', OS_MAXSTR + 1);
if (!alert_only) {
print_out("%s: Type one log per line.\n", ARGV0);
}
/* Daemon loop */
while (1) {
lf = (Eventinfo *)calloc(1, sizeof(Eventinfo));
os_calloc(Config.decoder_order_size, sizeof(char*), lf->fields);
/* This shouldn't happen */
if (lf == NULL) {
ErrorExit(MEM_ERROR, ARGV0, errno, strerror(errno));
}
/* Fix the msg */
snprintf(msg, 15, "1:stdin:");
/* Receive message from queue */
if (fgets(msg + 8, OS_MAXSTR - 8, stdin)) {
RuleNode *rulenode_pt;
/* Get the time we received the event */
c_time = time(NULL);
/* Remov newline */
if (msg[strlen(msg) - 1] == '\n') {
msg[strlen(msg) - 1] = '\0';
}
/* Make sure we ignore blank lines */
if (strlen(msg) < 10) {
continue;
}
if (!alert_only) {
print_out("\n");
}
/* Default values for the log info */
Zero_Eventinfo(lf);
/* Clean the msg appropriately */
if (OS_CleanMSG(msg, lf) < 0) {
merror(IMSG_ERROR, ARGV0, msg);
Free_Eventinfo(lf);
continue;
}
/* Current rule must be null in here */
currently_rule = NULL;
/*** Run decoders ***/
/* Get log size */
lf->size = strlen(lf->log);
/* Decode event */
DecodeEvent(lf);
/* Run accumulator */
if ( lf->decoder_info->accumulate == 1 ) {
print_out("\n**ACCUMULATOR: LEVEL UP!!**\n");
lf = Accumulate(lf);
}
/* Loop over all the rules */
rulenode_pt = OS_GetFirstRule();
if (!rulenode_pt) {
ErrorExit("%s: Rules in an inconsistent state. Exiting.",
ARGV0);
}
#ifdef TESTRULE
if (full_output && !alert_only) {
print_out("\n**Rule debugging:");
}
#endif
do {
if (lf->decoder_info->type == OSSEC_ALERT) {
if (!lf->generated_rule) {
break;
}
/* Process the alert */
currently_rule = lf->generated_rule;
}
/* The categories must match */
else if (rulenode_pt->ruleinfo->category !=
lf->decoder_info->type) {
continue;
}
/* Check each rule */
else if ((currently_rule = OS_CheckIfRuleMatch(lf, rulenode_pt))
== NULL) {
continue;
}
#ifdef TESTRULE
if (!alert_only) {
const char *(ruleinfodetail_text[]) = {"Text", "Link", "CVE", "OSVDB", "BUGTRACKID"};
print_out("\n**Phase 3: Completed filtering (rules).");
print_out(" Rule id: '%d'", currently_rule->sigid);
print_out(" Level: '%d'", currently_rule->level);
print_out(" Description: '%s'", currently_rule->comment);
for (last_info_detail = currently_rule->info_details; last_info_detail != NULL; last_info_detail = last_info_detail->next) {
print_out(" Info - %s: '%s'", ruleinfodetail_text[last_info_detail->type], last_info_detail->data);
}
}
#endif
/* Ignore level 0 */
if (currently_rule->level == 0) {
break;
}
/* Check ignore time */
if (currently_rule->ignore_time) {
if (currently_rule->time_ignored == 0) {
currently_rule->time_ignored = lf->time;
}
/* If the current time - the time the rule was ignored
* is less than the time it should be ignored,
* do not alert again
*/
else if ((lf->time - currently_rule->time_ignored)
< currently_rule->ignore_time) {
break;
} else {
currently_rule->time_ignored = 0;
}
}
/* Pointer to the rule that generated it */
lf->generated_rule = currently_rule;
/* Check if we should ignore it */
if (currently_rule->ckignore && IGnore(lf)) {
lf->generated_rule = NULL;
break;
}
/* Check if we need to add to ignore list */
if (currently_rule->ignore) {
AddtoIGnore(lf);
}
/* Log the alert if configured to */
if (currently_rule->alert_opts & DO_LOGALERT) {
if (alert_only) {
OS_LogOutput(lf);
__crt_ftell++;
} else {
print_out("**Alert to be generated.\n\n");
}
}
/* Copy the structure to the state memory of if_matched_sid */
if (currently_rule->sid_prev_matched) {
if (!OSList_AddData(currently_rule->sid_prev_matched, lf)) {
merror("%s: Unable to add data to sig list.", ARGV0);
} else {
lf->sid_node_to_delete =
currently_rule->sid_prev_matched->last_node;
}
}
/* Group list */
else if (currently_rule->group_prev_matched) {
unsigned int i = 0;
while (i < currently_rule->group_prev_matched_sz) {
if (!OSList_AddData(
currently_rule->group_prev_matched[i],
lf)) {
merror("%s: Unable to add data to grp list.", ARGV0);
}
i++;
}
}
OS_AddEvent(lf);
break;
} while ((rulenode_pt = rulenode_pt->next) != NULL);
if (ut_str) {
/* Set up exit code if we are doing unit testing */
char holder[1024];
holder[1] = '\0';
exit_code = 3;
print_out("lf->decoder_info->name: '%s'", lf->decoder_info->name);
print_out("ut_decoder_name : '%s'", ut_decoder_name);
if (lf->decoder_info->name != NULL && strcasecmp(ut_decoder_name, lf->decoder_info->name) == 0) {
exit_code--;
if (!currently_rule) {
merror("%s: currently_rule not set!", ARGV0);
exit(-1);
}
snprintf(holder, 1023, "%d", currently_rule->sigid);
if (strcasecmp(ut_rulelevel, holder) == 0) {
exit_code--;
snprintf(holder, 1023, "%d", currently_rule->level);
if (strcasecmp(ut_alertlevel, holder) == 0) {
exit_code--;
printf("%d\n", exit_code);
}
}
} else if (lf->decoder_info->name != NULL) {
print_out("decoder matched : '%s'", lf->decoder_info->name);
print_out("decoder expected: '%s'", ut_decoder_name);
} else {
print_out("decoder matched : 'NULL'");
}
}
/* Only clear the memory if the eventinfo was not
* added to the stateful memory
* -- message is free inside clean event --
*/
if (lf->generated_rule == NULL) {
Free_Eventinfo(lf);
}
} else {
exit(exit_code);
}
}
exit(exit_code);
}
