static void add_message_alert(DB_ESCALATION *escalation, DB_EVENT *event, DB_ACTION *action,
zbx_uint64_t userid, zbx_uint64_t mediatypeid, char *subject, char *message)
{
DB_RESULT result;
DB_ROW row;
zbx_uint64_t alertid;
int now, severity, medias = 0;
char *sendto_esc, *subject_esc, *message_esc, *error_esc;
char error[MAX_STRING_LEN];
zabbix_log(LOG_LEVEL_DEBUG, "In add_message_alert()");
/* zabbix_log(LOG_LEVEL_DEBUG,"MESSAGE\n\tuserid : " ZBX_FS_UI64 "\n\tsubject: %s\n\tmessage: %s", userid, subject, message);*/
now = time(NULL);
subject_esc = DBdyn_escape_string_len(subject, ALERT_SUBJECT_LEN);
message_esc = DBdyn_escape_string(message);
if (0 == mediatypeid)
{
result = DBselect("select mediatypeid,sendto,severity,period from media"
" where active=%d and userid=" ZBX_FS_UI64,
MEDIA_STATUS_ACTIVE,
userid);
}
else
{
result = DBselect("select mediatypeid,sendto,severity,period from media"
" where active=%d and userid=" ZBX_FS_UI64 " and mediatypeid=" ZBX_FS_UI64,
MEDIA_STATUS_ACTIVE,
userid,
mediatypeid);
}
while (NULL != (row = DBfetch(result))) {
medias = 1;
ZBX_STR2UINT64(mediatypeid, row[0]);
severity = atoi(row[2]);
zabbix_log( LOG_LEVEL_DEBUG, "Trigger severity [%d] Media severity [%d] Period [%s]",
event->trigger_priority,
severity,
row[3]);
if (((1 << event->trigger_priority) & severity) == 0) {
zabbix_log( LOG_LEVEL_DEBUG, "Won't send message (severity)");
continue;
}
if (check_time_period(row[3], (time_t)NULL) == 0) {
zabbix_log( LOG_LEVEL_DEBUG, "Won't send message (period)");
continue;
}
alertid = DBget_maxid("alerts", "alertid");
sendto_esc = DBdyn_escape_string_len(row[1], ALERT_SENDTO_LEN);
DBexecute("insert into alerts (alertid,actionid,eventid,userid,clock"
",mediatypeid,sendto,subject,message,status,alerttype,esc_step)"
" values (" ZBX_FS_UI64 "," ZBX_FS_UI64 "," ZBX_FS_UI64 "," ZBX_FS_UI64 ",%d"
"," ZBX_FS_UI64 ",'%s','%s','%s',%d,%d,%d)",
alertid,
action->actionid,
event->eventid,
userid,
now,
mediatypeid,
sendto_esc,
subject_esc,
message_esc,
ALERT_STATUS_NOT_SENT,
ALERT_TYPE_MESSAGE,
escalation->esc_step);
zbx_free(sendto_esc);
}
DBfree_result(result);
if (0 == medias) {
zbx_snprintf(error, sizeof(error), "No media defined for user \"%s\"",
zbx_user_string(userid));
alertid = DBget_maxid("alerts", "alertid");
error_esc = DBdyn_escape_string(error);
DBexecute("insert into alerts (alertid,actionid,eventid,userid,retries,clock"
",subject,message,status,alerttype,error,esc_step)"
" values (" ZBX_FS_UI64 "," ZBX_FS_UI64 "," ZBX_FS_UI64 "," ZBX_FS_UI64 ",%d,%d"
",'%s','%s',%d,%d,'%s',%d)",
alertid,
action->actionid,
event->eventid,
userid,
ALERT_MAX_RETRIES,
now,
subject_esc,
message_esc,
ALERT_STATUS_FAILED,
ALERT_TYPE_MESSAGE,
error_esc,
escalation->esc_step);
zbx_free(error_esc);
}
zbx_free(subject_esc);
zbx_free(message_esc);
}
static void add_message_alert(DB_ESCALATION *escalation, DB_EVENT *event, DB_ACTION *action,
zbx_uint64_t userid, zbx_uint64_t mediatypeid, const char *subject, const char *message)
{
const char *__function_name = "add_message_alert";
DB_RESULT result;
DB_ROW row;
zbx_uint64_t alertid;
int now, severity, medias = 0;
char *subject_dyn, *message_dyn, *sendto_esc, *subject_esc, *message_esc, *error_esc;
char error[MAX_STRING_LEN];
zabbix_log(LOG_LEVEL_DEBUG, "In %s()", __function_name);
subject_dyn = zbx_strdup(NULL, subject);
message_dyn = zbx_strdup(NULL, message);
substitute_simple_macros(event, &userid, NULL, NULL, NULL, NULL, &subject_dyn, MACRO_TYPE_MESSAGE, NULL, 0);
substitute_simple_macros(event, &userid, NULL, NULL, NULL, NULL, &message_dyn, MACRO_TYPE_MESSAGE, NULL, 0);
now = time(NULL);
subject_esc = DBdyn_escape_string_len(subject_dyn, ALERT_SUBJECT_LEN);
message_esc = DBdyn_escape_string_len(message_dyn, ALERT_MESSAGE_LEN);
zbx_free(subject_dyn);
zbx_free(message_dyn);
if (0 == mediatypeid)
{
result = DBselect(
"select m.mediatypeid,m.sendto,m.severity,m.period,mt.status"
" from media m,media_type mt"
" where m.mediatypeid=mt.mediatypeid"
" and m.active=%d"
" and m.userid=" ZBX_FS_UI64,
MEDIA_STATUS_ACTIVE, userid);
}
else
{
result = DBselect(
"select m.mediatypeid,m.sendto,m.severity,m.period,mt.status"
" from media m,media_type mt"
" where m.mediatypeid=mt.mediatypeid"
" and m.active=%d"
" and m.userid=" ZBX_FS_UI64
" and m.mediatypeid=" ZBX_FS_UI64,
MEDIA_STATUS_ACTIVE, userid, mediatypeid);
}
while (NULL != (row = DBfetch(result)))
{
medias = 1;
ZBX_STR2UINT64(mediatypeid, row[0]);
severity = atoi(row[2]);
zabbix_log(LOG_LEVEL_DEBUG, "Trigger severity [%d] Media severity [%d] Period [%s]",
(int)event->trigger.priority, severity, row[3]);
if (((1 << event->trigger.priority) & severity) == 0)
{
zabbix_log(LOG_LEVEL_DEBUG, "Won't send message (severity)");
continue;
}
if (FAIL == check_time_period(row[3], (time_t)NULL))
{
zabbix_log(LOG_LEVEL_DEBUG, "Won't send message (period)");
continue;
}
alertid = DBget_maxid("alerts");
sendto_esc = DBdyn_escape_string_len(row[1], ALERT_SENDTO_LEN);
if (MEDIA_TYPE_STATUS_ACTIVE == atoi(row[4]))
{
DBexecute("insert into alerts (alertid,actionid,eventid,userid,clock"
",mediatypeid,sendto,subject,message,status,alerttype,esc_step)"
" values (" ZBX_FS_UI64 "," ZBX_FS_UI64 "," ZBX_FS_UI64 "," ZBX_FS_UI64 ",%d"
"," ZBX_FS_UI64 ",'%s','%s','%s',%d,%d,%d)",
alertid,
action->actionid,
event->eventid,
userid,
now,
mediatypeid,
sendto_esc,
subject_esc,
message_esc,
ALERT_STATUS_NOT_SENT,
ALERT_TYPE_MESSAGE,
escalation->esc_step);
}
else
{
error_esc = DBdyn_escape_string("Media type disabled");
DBexecute("insert into alerts (alertid,actionid,eventid,userid,clock"
",mediatypeid,sendto,subject,message,status,alerttype,esc_step,error)"
" values (" ZBX_FS_UI64 "," ZBX_FS_UI64 "," ZBX_FS_UI64 "," ZBX_FS_UI64 ",%d"
"," ZBX_FS_UI64 ",'%s','%s','%s',%d,%d,%d,'%s')",
alertid,
action->actionid,
event->eventid,
userid,
now,
mediatypeid,
sendto_esc,
subject_esc,
message_esc,
ALERT_STATUS_FAILED,
ALERT_TYPE_MESSAGE,
escalation->esc_step,
error_esc);
zbx_free(error_esc);
}
zbx_free(sendto_esc);
}
DBfree_result(result);
if (0 == medias)
{
zbx_snprintf(error, sizeof(error), "No media defined for user \"%s\"",
zbx_user_string(userid));
alertid = DBget_maxid("alerts");
error_esc = DBdyn_escape_string(error);
DBexecute("insert into alerts (alertid,actionid,eventid,userid,retries,clock"
",subject,message,status,alerttype,error,esc_step)"
" values (" ZBX_FS_UI64 "," ZBX_FS_UI64 "," ZBX_FS_UI64 "," ZBX_FS_UI64 ",%d,%d"
",'%s','%s',%d,%d,'%s',%d)",
alertid,
action->actionid,
event->eventid,
userid,
ALERT_MAX_RETRIES,
now,
subject_esc,
message_esc,
ALERT_STATUS_FAILED,
ALERT_TYPE_MESSAGE,
error_esc,
escalation->esc_step);
zbx_free(error_esc);
}
zbx_free(subject_esc);
zbx_free(message_esc);
zabbix_log(LOG_LEVEL_DEBUG, "End of %s()", __function_name);
}
/******************************************************************************
* *
* Function: check_trigger_condition *
* *
* Purpose: check if event matches single condition *
* *
* Parameters: event - trigger event to check *
* (event->source == EVENT_SOURCE_TRIGGERS) *
* condition - condition for matching *
* *
* Return value: SUCCEED - matches, FAIL - otherwise *
* *
* Author: Alexei Vladishev *
* *
* Comments: *
* *
******************************************************************************/
static int check_trigger_condition(DB_EVENT *event, DB_CONDITION *condition)
{
const char *__function_name = "check_trigger_condition";
DB_RESULT result;
DB_ROW row;
zbx_uint64_t condition_value;
int nodeid;
char *tmp_str = NULL;
int ret = FAIL;
zabbix_log(LOG_LEVEL_DEBUG, "In %s()", __function_name);
if (condition->conditiontype == CONDITION_TYPE_HOST_GROUP)
{
ZBX_STR2UINT64(condition_value, condition->value);
result = DBselect(
"select distinct hg.groupid"
" from hosts_groups hg,hosts h,items i,functions f,triggers t"
" where hg.hostid=h.hostid"
" and h.hostid=i.hostid"
" and i.itemid=f.itemid"
" and f.triggerid=t.triggerid"
" and t.triggerid=" ZBX_FS_UI64
" and hg.groupid=" ZBX_FS_UI64,
event->objectid,
condition_value);
switch (condition->operator)
{
case CONDITION_OPERATOR_EQUAL:
if (NULL != DBfetch(result))
ret = SUCCEED;
break;
case CONDITION_OPERATOR_NOT_EQUAL:
if (NULL == DBfetch(result))
ret = SUCCEED;
break;
default:
zabbix_log(LOG_LEVEL_ERR, "Unsupported operator [%d] for condition id [" ZBX_FS_UI64 "]",
condition->operator,
condition->conditionid);
}
DBfree_result(result);
}
else if (condition->conditiontype == CONDITION_TYPE_HOST_TEMPLATE)
{
zbx_uint64_t hostid, triggerid;
ZBX_STR2UINT64(condition_value, condition->value);
switch (condition->operator)
{
case CONDITION_OPERATOR_EQUAL:
case CONDITION_OPERATOR_NOT_EQUAL:
triggerid = event->objectid;
do
{
result = DBselect(
"select distinct i.hostid,t.templateid"
" from items i,functions f,triggers t"
" where i.itemid=f.itemid"
" and f.triggerid=t.templateid"
" and t.triggerid=" ZBX_FS_UI64,
triggerid);
if (NULL != (row = DBfetch(result)))
{
ZBX_STR2UINT64(hostid, row[0]);
ZBX_STR2UINT64(triggerid, row[1]);
if (hostid == condition_value)
{
ret = SUCCEED;
break;
}
}
else
triggerid = 0;
DBfree_result(result);
} while (SUCCEED != ret && 0 != triggerid);
if (CONDITION_OPERATOR_NOT_EQUAL == condition->operator)
ret = (SUCCEED == ret) ? FAIL : SUCCEED;
break;
default:
zabbix_log(LOG_LEVEL_ERR, "Unsupported operator [%d] for condition id [" ZBX_FS_UI64 "]",
condition->operator,
condition->conditionid);
}
}
else if (condition->conditiontype == CONDITION_TYPE_HOST)
{
ZBX_STR2UINT64(condition_value, condition->value);
switch (condition->operator)
{
case CONDITION_OPERATOR_EQUAL:
case CONDITION_OPERATOR_NOT_EQUAL:
result = DBselect(
"select distinct i.hostid"
" from items i,functions f,triggers t"
" where i.itemid=f.itemid"
" and f.triggerid=t.triggerid"
" and t.triggerid=" ZBX_FS_UI64
" and i.hostid=" ZBX_FS_UI64,
event->objectid,
condition_value);
if (NULL != DBfetch(result))
ret = SUCCEED;
DBfree_result(result);
if (CONDITION_OPERATOR_NOT_EQUAL == condition->operator)
ret = (SUCCEED == ret) ? FAIL : SUCCEED;
break;
default:
zabbix_log(LOG_LEVEL_ERR, "Unsupported operator [%d] for condition id [" ZBX_FS_UI64 "]",
condition->operator, condition->conditionid);
}
}
else if (condition->conditiontype == CONDITION_TYPE_TRIGGER)
{
zbx_uint64_t triggerid;
ZBX_STR2UINT64(condition_value, condition->value);
switch (condition->operator)
{
case CONDITION_OPERATOR_EQUAL:
case CONDITION_OPERATOR_NOT_EQUAL:
if (event->objectid == condition_value)
ret = SUCCEED;
/* Processing of templated triggers */
else
{
for (triggerid = event->objectid; 0 != triggerid && FAIL == ret;)
{
result = DBselect(
"select templateid"
" from triggers"
" where triggerid=" ZBX_FS_UI64,
triggerid);
if (NULL == (row = DBfetch(result)))
triggerid = 0;
else
{
ZBX_STR2UINT64(triggerid, row[0]);
if (triggerid == condition_value)
ret = SUCCEED;
}
DBfree_result(result);
}
}
if (CONDITION_OPERATOR_NOT_EQUAL == condition->operator)
ret = (SUCCEED == ret) ? FAIL : SUCCEED;
break;
default:
zabbix_log(LOG_LEVEL_ERR, "Unsupported operator [%d] for condition id [" ZBX_FS_UI64 "]",
condition->operator, condition->conditionid);
}
}
else if (condition->conditiontype == CONDITION_TYPE_TRIGGER_NAME)
{
tmp_str = zbx_strdup(tmp_str, event->trigger.description);
substitute_simple_macros(event, NULL, NULL, NULL, NULL, &tmp_str, MACRO_TYPE_TRIGGER_DESCRIPTION, NULL, 0);
switch (condition->operator)
{
case CONDITION_OPERATOR_LIKE:
if (NULL != strstr(tmp_str, condition->value))
ret = SUCCEED;
break;
case CONDITION_OPERATOR_NOT_LIKE:
if (NULL == strstr(tmp_str, condition->value))
ret = SUCCEED;
break;
default:
zabbix_log(LOG_LEVEL_ERR, "Unsupported operator [%d] for condition id [" ZBX_FS_UI64 "]",
condition->operator,
condition->conditionid);
}
zbx_free(tmp_str);
}
else if (condition->conditiontype == CONDITION_TYPE_TRIGGER_SEVERITY)
{
condition_value = atoi(condition->value);
switch (condition->operator)
{
case CONDITION_OPERATOR_EQUAL:
if (event->trigger.priority == condition_value)
ret = SUCCEED;
break;
case CONDITION_OPERATOR_NOT_EQUAL:
if (event->trigger.priority != condition_value)
ret = SUCCEED;
break;
case CONDITION_OPERATOR_MORE_EQUAL:
if (event->trigger.priority >= condition_value)
ret = SUCCEED;
break;
case CONDITION_OPERATOR_LESS_EQUAL:
if (event->trigger.priority <= condition_value)
ret = SUCCEED;
break;
default:
zabbix_log(LOG_LEVEL_ERR, "Unsupported operator [%d] for condition id [" ZBX_FS_UI64 "]",
condition->operator,
condition->conditionid);
}
}
else if (condition->conditiontype == CONDITION_TYPE_TRIGGER_VALUE)
{
condition_value = atoi(condition->value);
switch (condition->operator)
{
case CONDITION_OPERATOR_EQUAL:
if (event->value == condition_value)
ret = SUCCEED;
break;
default:
zabbix_log(LOG_LEVEL_ERR, "Unsupported operator [%d] for condition id [" ZBX_FS_UI64 "]",
condition->operator,
condition->conditionid);
}
}
else if (condition->conditiontype == CONDITION_TYPE_TIME_PERIOD)
{
switch (condition->operator)
{
case CONDITION_OPERATOR_IN:
if (SUCCEED == check_time_period(condition->value, (time_t)NULL))
ret = SUCCEED;
break;
case CONDITION_OPERATOR_NOT_IN:
if (FAIL == check_time_period(condition->value, (time_t)NULL))
ret = SUCCEED;
break;
default:
zabbix_log(LOG_LEVEL_ERR, "Unsupported operator [%d] for condition id [" ZBX_FS_UI64 "]",
condition->operator,
condition->conditionid);
}
}
else if (condition->conditiontype == CONDITION_TYPE_MAINTENANCE)
{
switch (condition->operator) {
case CONDITION_OPERATOR_IN:
result = DBselect(
"select count(*)"
" from hosts h,items i,functions f,triggers t"
" where h.hostid=i.hostid"
" and h.maintenance_status=%d"
" and i.itemid=f.itemid"
" and f.triggerid=t.triggerid"
" and t.triggerid=" ZBX_FS_UI64,
HOST_MAINTENANCE_STATUS_ON,
event->objectid);
if (NULL != (row = DBfetch(result)) && FAIL == DBis_null(row[0]) && 0 != atoi(row[0]))
ret = SUCCEED;
DBfree_result(result);
break;
case CONDITION_OPERATOR_NOT_IN:
result = DBselect(
"select count(*)"
" from hosts h,items i,functions f,triggers t"
" where h.hostid=i.hostid"
" and h.maintenance_status=%d"
" and i.itemid=f.itemid"
" and f.triggerid=t.triggerid"
" and t.triggerid=" ZBX_FS_UI64,
HOST_MAINTENANCE_STATUS_OFF,
event->objectid);
if (NULL != (row = DBfetch(result)) && FAIL == DBis_null(row[0]) && 0 != atoi(row[0]))
ret = SUCCEED;
DBfree_result(result);
break;
default:
zabbix_log(LOG_LEVEL_ERR, "Unsupported operator [%d] for condition id [" ZBX_FS_UI64 "]",
condition->operator,
condition->conditionid);
}
}
else if (condition->conditiontype == CONDITION_TYPE_NODE)
{
nodeid = get_nodeid_by_id(event->objectid);
condition_value = atoi(condition->value);
switch (condition->operator) {
case CONDITION_OPERATOR_EQUAL:
if (nodeid == condition_value)
ret = SUCCEED;
break;
case CONDITION_OPERATOR_NOT_EQUAL:
if (nodeid != condition_value)
ret = SUCCEED;
break;
default:
zabbix_log(LOG_LEVEL_ERR, "Unsupported operator [%d] for condition id [" ZBX_FS_UI64 "]",
condition->operator,
condition->conditionid);
}
}
else if (condition->conditiontype == CONDITION_TYPE_EVENT_ACKNOWLEDGED)
{
result = DBselect(
"select acknowledged"
" from events"
" where acknowledged=%d"
" and eventid=" ZBX_FS_UI64,
atoi(condition->value),
event->eventid);
switch (condition->operator)
{
case CONDITION_OPERATOR_EQUAL:
if (NULL != (row = DBfetch(result)))
ret = SUCCEED;
break;
default:
zabbix_log(LOG_LEVEL_ERR, "Unsupported operator [%d] for condition id [" ZBX_FS_UI64 "]",
condition->operator,
condition->conditionid);
}
DBfree_result(result);
}
else if (condition->conditiontype == CONDITION_TYPE_APPLICATION)
{
result = DBselect(
"select distinct a.name"
" from applications a,items_applications i,functions f,triggers t"
" where a.applicationid=i.applicationid"
" and i.itemid=f.itemid"
" and f.triggerid=t.triggerid"
" and t.triggerid=" ZBX_FS_UI64,
event->objectid);
switch (condition->operator) {
case CONDITION_OPERATOR_EQUAL:
while (NULL != (row = DBfetch(result)))
{
if (0 == strcmp(row[0], condition->value))
{
ret = SUCCEED;
break;
}
}
break;
case CONDITION_OPERATOR_LIKE:
while (NULL != (row = DBfetch(result)))
{
if (NULL != strstr(row[0], condition->value))
{
ret = SUCCEED;
break;
}
}
break;
case CONDITION_OPERATOR_NOT_LIKE:
ret = SUCCEED;
while (NULL != (row = DBfetch(result)))
{
if (NULL != strstr(row[0], condition->value))
{
ret = FAIL;
break;
}
}
break;
default:
zabbix_log(LOG_LEVEL_ERR, "Unsupported operator [%d] for condition id [" ZBX_FS_UI64 "]",
condition->operator,
condition->conditionid);
}
DBfree_result(result);
}
else
{
zabbix_log(LOG_LEVEL_ERR, "Unsupported condition type [%d] for condition id [" ZBX_FS_UI64 "]",
condition->conditiontype,
condition->conditionid);
}
zabbix_log(LOG_LEVEL_DEBUG, "End of %s():%s", __function_name, zbx_result_string(ret));
return ret;
}