void sinsp_filter::push_expression(boolop op)
{
sinsp_filter_expression* newexpr = new sinsp_filter_expression();
newexpr->m_boolop = op;
newexpr->m_parent = m_curexpr;
add_check((sinsp_filter_check*)newexpr);
m_curexpr = newexpr;
}
static void add_castle_checks(list_t * list, board_t * board) {
ASSERT(list!=NULL);
ASSERT(board!=NULL);
ASSERT(!board_is_check(board));
if (COLOUR_IS_WHITE(board->turn)) {
if ((board->flags & FlagsWhiteKingCastle) != 0
&& board->square[F1] == Empty
&& board->square[G1] == Empty
&& !is_attacked(board,F1,Black)) {
add_check(list,MOVE_MAKE_FLAGS(E1,G1,MoveCastle),board);
}
if ((board->flags & FlagsWhiteQueenCastle) != 0
&& board->square[D1] == Empty
&& board->square[C1] == Empty
&& board->square[B1] == Empty
&& !is_attacked(board,D1,Black)) {
add_check(list,MOVE_MAKE_FLAGS(E1,C1,MoveCastle),board);
}
} else { // black
if ((board->flags & FlagsBlackKingCastle) != 0
&& board->square[F8] == Empty
&& board->square[G8] == Empty
&& !is_attacked(board,F8,White)) {
add_check(list,MOVE_MAKE_FLAGS(E8,G8,MoveCastle),board);
}
if ((board->flags & FlagsBlackQueenCastle) != 0
&& board->square[D8] == Empty
&& board->square[C8] == Empty
&& board->square[B8] == Empty
&& !is_attacked(board,D8,White)) {
add_check(list,MOVE_MAKE_FLAGS(E8,C8,MoveCastle),board);
}
}
}
int main(void) {
int a,b,sum;
if(scanf("%d%d",&a,&b)!=2) {
puts("Invalid input!");
return 1;
}
sum = add(a,b);
if(!add_check(a,b,sum)) {
puts("Validation failed! (overflow?)");
return 2;
}
printf("%d + %d = %d\n",a,b,add(a,b));
return 0;
}
/******************************************************************************
* *
* Function: parse_list_of_checks *
* *
* Purpose: Parse list of active checks received from server *
* *
* Parameters: str - NULL terminated string received from server *
* *
* Return value: returns SUCCEED on succesfull parsing, *
* FAIL on an incoorrect format of string *
* *
* Author: Eugene Grigorjev, Alexei Vladishev (new json protocol) *
* *
* Comments: *
* String reprents as "ZBX_EOF" termination list *
* With '\n' delimeter between elements. *
* Each element represents as: *
* <key>:<refresh time>:<last log size> *
* *
******************************************************************************/
static int parse_list_of_checks(char *str)
{
const char *p;
char name[MAX_STRING_LEN], key_orig[MAX_STRING_LEN], expression[MAX_STRING_LEN], tmp[MAX_STRING_LEN],
exp_delimiter;
int delay, lastlogsize, expression_type, case_sensitive;
struct zbx_json_parse jp;
struct zbx_json_parse jp_data, jp_row;
zabbix_log(LOG_LEVEL_DEBUG, "In parse_list_of_checks()");
disable_all_metrics();
if (SUCCEED != zbx_json_open(str, &jp))
goto json_error;
if (SUCCEED != zbx_json_value_by_name(&jp, ZBX_PROTO_TAG_RESPONSE, tmp, sizeof(tmp)))
goto json_error;
if (0 != strcmp(tmp, ZBX_PROTO_VALUE_SUCCESS))
{
zabbix_log(LOG_LEVEL_ERR, "Unsucesfull response received from server");
return FAIL;
}
if (SUCCEED != zbx_json_brackets_by_name(&jp, ZBX_PROTO_TAG_DATA, &jp_data))
goto json_error;
p = NULL;
while (NULL != (p = zbx_json_next(&jp_data, p)))
{
/* {"data":[{"key":"system.cpu.num",...,...},{...},...]}
* ^------------------------------^
*/ if (SUCCEED != zbx_json_brackets_open(p, &jp_row))
goto json_error;
if (SUCCEED != zbx_json_value_by_name(&jp_row, ZBX_PROTO_TAG_KEY, name, sizeof(name)) || *name == '\0')
{
zabbix_log(LOG_LEVEL_WARNING, "Unable to retrieve value of tag \"%s\"",
ZBX_PROTO_TAG_KEY);
continue;
}
if (SUCCEED != zbx_json_value_by_name(&jp_row, ZBX_PROTO_TAG_KEY_ORIG, key_orig, sizeof(key_orig)) || *key_orig == '\0')
zbx_strlcpy(key_orig, name, sizeof(key_orig));
if (SUCCEED != zbx_json_value_by_name(&jp_row, ZBX_PROTO_TAG_DELAY, tmp, sizeof(tmp)) || *tmp == '\0')
{
zabbix_log(LOG_LEVEL_WARNING, "Unable to retrieve value of tag \"%s\"",
ZBX_PROTO_TAG_DELAY);
continue;
}
delay = atoi(tmp);
if (SUCCEED != zbx_json_value_by_name(&jp_row, ZBX_PROTO_TAG_LOGLASTSIZE, tmp, sizeof(tmp)) || *tmp == '\0')
{
zabbix_log(LOG_LEVEL_WARNING, "Unable to retrieve value of tag \"%s\"",
ZBX_PROTO_TAG_LOGLASTSIZE);
continue;
}
lastlogsize = atoi(tmp);
add_check(name, key_orig, delay, lastlogsize);
}
clean_regexps_ex(regexps, ®exps_num);
if (SUCCEED == zbx_json_brackets_by_name(&jp, ZBX_PROTO_TAG_REGEXP, &jp_data))
{
p = NULL;
while (NULL != (p = zbx_json_next(&jp_data, p)))
{
/* {"regexp":[{"name":"regexp1",...,...},{...},...]}
* ^------------------------^
*/ if (SUCCEED != zbx_json_brackets_open(p, &jp_row))
goto json_error;
if (SUCCEED != zbx_json_value_by_name(&jp_row, "name", name, sizeof(name)))
{
zabbix_log(LOG_LEVEL_WARNING, "Unable to retrieve value of tag \"%s\"",
"name");
continue;
}
if (SUCCEED != zbx_json_value_by_name(&jp_row, "expression", expression, sizeof(expression)) || *expression == '\0')
{
zabbix_log(LOG_LEVEL_WARNING, "Unable to retrieve value of tag \"%s\"",
"expression");
continue;
}
if (SUCCEED != zbx_json_value_by_name(&jp_row, "expression_type", tmp, sizeof(tmp)) || *tmp == '\0')
{
zabbix_log(LOG_LEVEL_WARNING, "Unable to retrieve value of tag \"%s\"",
"expression_type");
continue;
}
expression_type = atoi(tmp);
if (SUCCEED != zbx_json_value_by_name(&jp_row, "exp_delimiter", tmp, sizeof(tmp)))
{
zabbix_log(LOG_LEVEL_WARNING, "Unable to retrieve value of tag \"%s\"",
"exp_delimiter");
continue;
}
exp_delimiter = tmp[0];
if (SUCCEED != zbx_json_value_by_name(&jp_row, "case_sensitive", tmp, sizeof(tmp)) || *tmp == '\0')
{
zabbix_log(LOG_LEVEL_WARNING, "Unable to retrieve value of tag \"%s\"",
"case_sensitive");
continue;
}
case_sensitive = atoi(tmp);
add_regexp_ex(®exps, ®exps_alloc, ®exps_num,
name, expression, expression_type, exp_delimiter, case_sensitive);
}
}
return SUCCEED;
json_error:
zabbix_log(LOG_LEVEL_ERR, "Can't parse list of active checks. %s",
zbx_json_strerror());
return FAIL;
}
static void
help_build_index(help_file *h, int restricted)
{
long bigpos, pos = 0;
bool in_topic;
int i, lineno, ntopics;
size_t n;
char *s, *topic;
char the_topic[TOPIC_NAME_LEN + 1];
char line[LINE_SIZE + 1];
FILE *rfp;
tlist *cur;
/* Quietly ignore null values for the file */
if (!h || !h->file)
return;
if ((rfp = fopen(h->file, FOPEN_READ)) == NULL) {
do_rawlog(LT_ERR, "Can't open %s for reading: %s", h->file,
strerror(errno));
return;
}
if (restricted)
do_rawlog(LT_WIZ, "Indexing file %s (admin topics)", h->file);
else
do_rawlog(LT_WIZ, "Indexing file %s", h->file);
topics = NULL;
num_topics = 0;
top_topics = 0;
bigpos = 0L;
lineno = 0;
ntopics = 0;
in_topic = 0;
#ifdef HAVE_POSIX_FADVISE
posix_fadvise(fileno(rfp), 0, 0, POSIX_FADV_SEQUENTIAL);
#endif
while (fgets(line, LINE_SIZE, rfp) != NULL) {
++lineno;
if (ntopics == 0) {
/* Looking for the first topic, but we'll ignore blank lines */
if (!line[0]) {
/* Someone's feeding us /dev/null? */
do_rawlog(LT_ERR, "Malformed help file %s doesn't start with &",
h->file);
fclose(rfp);
return;
}
if (isspace(line[0]))
continue;
if (line[0] != '&') {
do_rawlog(LT_ERR, "Malformed help file %s doesn't start with &",
h->file);
fclose(rfp);
return;
}
}
n = strlen(line);
if (line[n - 1] != '\n') {
do_rawlog(LT_ERR, "Line %d of %s: line too long", lineno, h->file);
}
if (line[0] == '&') {
++ntopics;
if (!in_topic) {
/* Finish up last entry */
if (ntopics > 1) {
write_topic(pos);
}
in_topic = true;
}
/* parse out the topic */
/* Get the beginning of the topic string */
for (topic = &line[1];
(*topic == ' ' || *topic == '\t') && *topic != '\0'; topic++) ;
/* Get the topic */
strcpy(the_topic, "");
for (i = -1, s = topic; *s != '\n' && *s != '\0'; s++) {
if (i >= TOPIC_NAME_LEN - 1)
break;
if (*s != ' ' || the_topic[i] != ' ')
the_topic[++i] = *s;
}
if ((restricted && the_topic[0] == '&')
|| (!restricted && the_topic[0] != '&')) {
the_topic[++i] = '\0';
cur = (tlist *) malloc(sizeof(tlist));
strcpy(cur->topic, the_topic);
cur->next = top;
top = cur;
}
} else {
if (in_topic) {
pos = bigpos;
}
in_topic = false;
}
bigpos = ftell(rfp);
}
/* Handle last topic */
write_topic(pos);
if (topics)
qsort(topics, num_topics, sizeof(help_indx), topic_cmp);
h->entries = num_topics;
h->indx = topics;
add_check("help_index");
fclose(rfp);
do_rawlog(LT_WIZ, "%d topics indexed.", num_topics);
return;
}
/******************************************************************************
* *
* Function: parse_list_of_checks *
* *
* Purpose: Parse list of active checks received from server *
* *
* Parameters: str - NULL terminated string received from server *
* host - address of host *
* port - port number on host *
* *
* Return value: returns SUCCEED on successful parsing, *
* FAIL on an incorrect format of string *
* *
* Author: Eugene Grigorjev, Alexei Vladishev (new json protocol) *
* *
* Comments: *
* String represented as "ZBX_EOF" termination list *
* With '\n' delimiter between elements. *
* Each element represented as: *
* <key>:<refresh time>:<last log size>:<modification time> *
* *
******************************************************************************/
static int parse_list_of_checks(char *str, const char *host, unsigned short port)
{
const char *p;
char name[MAX_STRING_LEN], key_orig[MAX_STRING_LEN], expression[MAX_STRING_LEN],
tmp[MAX_STRING_LEN], exp_delimiter;
int delay, mtime, expression_type, case_sensitive;
zbx_uint64_t lastlogsize;
struct zbx_json_parse jp;
struct zbx_json_parse jp_data, jp_row;
zabbix_log(LOG_LEVEL_DEBUG, "In parse_list_of_checks()");
disable_all_metrics();
if (SUCCEED != zbx_json_open(str, &jp))
goto json_error;
if (SUCCEED != zbx_json_value_by_name(&jp, ZBX_PROTO_TAG_RESPONSE, tmp, sizeof(tmp)))
goto json_error;
if (0 != strcmp(tmp, ZBX_PROTO_VALUE_SUCCESS))
{
if (SUCCEED == zbx_json_value_by_name(&jp, ZBX_PROTO_TAG_INFO, tmp, sizeof(tmp)))
zabbix_log(LOG_LEVEL_WARNING, "no active checks on server [%s:%hu]: %s", host, port, tmp);
else
zabbix_log(LOG_LEVEL_WARNING, "no active checks on server");
return FAIL;
}
if (SUCCEED != zbx_json_brackets_by_name(&jp, ZBX_PROTO_TAG_DATA, &jp_data))
goto json_error;
p = NULL;
while (NULL != (p = zbx_json_next(&jp_data, p)))
{
/* {"data":[{"key":"system.cpu.num",...,...},{...},...]}
* ^------------------------------^
*/ if (SUCCEED != zbx_json_brackets_open(p, &jp_row))
goto json_error;
if (SUCCEED != zbx_json_value_by_name(&jp_row, ZBX_PROTO_TAG_KEY, name, sizeof(name)) || '\0' == *name)
{
zabbix_log(LOG_LEVEL_WARNING, "cannot retrieve value of tag \"%s\"", ZBX_PROTO_TAG_KEY);
continue;
}
if (SUCCEED != zbx_json_value_by_name(&jp_row, ZBX_PROTO_TAG_KEY_ORIG, key_orig, sizeof(key_orig))
|| '\0' == *key_orig) {
zbx_strlcpy(key_orig, name, sizeof(key_orig));
}
if (SUCCEED != zbx_json_value_by_name(&jp_row, ZBX_PROTO_TAG_DELAY, tmp, sizeof(tmp)) || '\0' == *tmp)
{
zabbix_log(LOG_LEVEL_WARNING, "cannot retrieve value of tag \"%s\"", ZBX_PROTO_TAG_DELAY);
continue;
}
delay = atoi(tmp);
if (SUCCEED != zbx_json_value_by_name(&jp_row, ZBX_PROTO_TAG_LOGLASTSIZE, tmp, sizeof(tmp)) ||
SUCCEED != is_uint64(tmp, &lastlogsize))
{
zabbix_log(LOG_LEVEL_WARNING, "cannot retrieve value of tag \"%s\"", ZBX_PROTO_TAG_LOGLASTSIZE);
continue;
}
if (SUCCEED != zbx_json_value_by_name(&jp_row, ZBX_PROTO_TAG_MTIME, tmp, sizeof(tmp)) || '\0' == *tmp)
{
zabbix_log(LOG_LEVEL_WARNING, "cannot retrieve value of tag \"%s\"", ZBX_PROTO_TAG_MTIME);
mtime = 0;
}
else
mtime = atoi(tmp);
add_check(name, key_orig, delay, lastlogsize, mtime);
}
zbx_regexp_clean_expressions(®exps);
if (SUCCEED == zbx_json_brackets_by_name(&jp, ZBX_PROTO_TAG_REGEXP, &jp_data))
{
p = NULL;
while (NULL != (p = zbx_json_next(&jp_data, p)))
{
/* {"regexp":[{"name":"regexp1",...,...},{...},...]}
* ^------------------------^
*/ if (SUCCEED != zbx_json_brackets_open(p, &jp_row))
goto json_error;
if (SUCCEED != zbx_json_value_by_name(&jp_row, "name", name, sizeof(name)))
{
zabbix_log(LOG_LEVEL_WARNING, "cannot retrieve value of tag \"%s\"", "name");
continue;
}
if (SUCCEED != zbx_json_value_by_name(&jp_row, "expression", expression, sizeof(expression)) ||
'\0' == *expression)
{
zabbix_log(LOG_LEVEL_WARNING, "cannot retrieve value of tag \"%s\"", "expression");
continue;
}
if (SUCCEED != zbx_json_value_by_name(&jp_row, "expression_type", tmp, sizeof(tmp)) ||
'\0' == *tmp)
{
zabbix_log(LOG_LEVEL_WARNING, "cannot retrieve value of tag \"%s\"", "expression_type");
continue;
}
expression_type = atoi(tmp);
if (SUCCEED != zbx_json_value_by_name(&jp_row, "exp_delimiter", tmp, sizeof(tmp)))
{
zabbix_log(LOG_LEVEL_WARNING, "cannot retrieve value of tag \"%s\"", "exp_delimiter");
continue;
}
exp_delimiter = tmp[0];
if (SUCCEED != zbx_json_value_by_name(&jp_row, "case_sensitive", tmp,
sizeof(tmp)) || '\0' == *tmp)
{
zabbix_log(LOG_LEVEL_WARNING, "cannot retrieve value of tag \"%s\"", "case_sensitive");
continue;
}
case_sensitive = atoi(tmp);
add_regexp_ex(®exps, name, expression, expression_type, exp_delimiter, case_sensitive);
}
}
return SUCCEED;
json_error:
zabbix_log(LOG_LEVEL_ERR, "cannot parse list of active checks: %s", zbx_json_strerror());
return FAIL;
}
