ri->cond = LOG_FILTER_COND_NONE;

ri->verb = LOG_FILTER_UNDEF;

// release memory if needed

log_item_free(&(ri->match));

log_item_free(&(ri->aux));

return mysql_rwlock_destroy(&(ri->rule_lock));

int elem) {

size_t rn;

assert(ruleset->count > 0);

log_builtins_filter_rule_free(&ruleset->rule[elem]);

for (rn = elem; rn < (ruleset->count - 1); rn++) {

ruleset->rule[rn] = ruleset->rule[rn + 1];

}

ruleset->count--;

log_builtins_filter_lock lt) {

if ((!filter_inited) || (ruleset == nullptr)) return -1;

switch (lt) {

case LOG_BUILTINS_LOCK_SHARED:

mysql_rwlock_rdlock(&ruleset->ruleset_lock);

break;

case LOG_BUILTINS_LOCK_EXCLUSIVE:

mysql_rwlock_wrlock(&ruleset->ruleset_lock);

break;

default:

return -2; /* purecov: inspected */

}

return 0;

log_filter_rule *ri;

while (ruleset->count > 0) {

ruleset->count--;

ri = &ruleset->rule[ruleset->count];

log_builtins_filter_rule_free(ri);

}

if (ruleset != nullptr) {

mysql_rwlock_unlock(&(ruleset->ruleset_lock));

}

if (ruleset != nullptr) {

log_filter_ruleset *rs = *ruleset;

if (rs != nullptr) {

*ruleset = nullptr;

log_builtins_filter_ruleset_drop(rs);

log_builtins_filter_ruleset_unlock(rs);

mysql_rwlock_destroy(&(rs->ruleset_lock));

my_free((void *)rs);

}

}

log_filter_rule *r;

assert(ruleset != nullptr);

assert(!log_filter_ruleset_full(ruleset));

// failsafe: simple built-in filter may not drop "System" or "Error" messages

r = log_builtins_filter_rule_init(ruleset);

log_item_set_with_key(&r->match, LOG_ITEM_LOG_PRIO, nullptr,

LOG_ITEM_FREE_NONE)

->data_integer = WARNING_LEVEL;

r->cond = LOG_FILTER_COND_LT;

r->verb = LOG_FILTER_RETURN;

ruleset->count++;

// sys_var: log_error_verbosity

r = log_builtins_filter_rule_init(ruleset);

log_item_set_with_key(&r->match, LOG_ITEM_LOG_PRIO, nullptr,

LOG_ITEM_FREE_NONE)

->data_integer = log_error_verbosity;

r->cond = LOG_FILTER_COND_GT;

r->verb = LOG_FILTER_DROP;

ruleset->count++;

// example: remove all source-line log items

// these are not desirable by default, only while debugging.

r = log_builtins_filter_rule_init(ruleset);

log_item_set(&r->match, LOG_ITEM_SRC_LINE);

r->cond = LOG_FILTER_COND_PRESENT;

r->verb = LOG_FILTER_ITEM_DEL;

// aux optional

ruleset->count++;

if (!filter_inited) return -1;

/*

if (log_filter_builtin_rules != nullptr) {

mysql_rwlock_wrlock(&log_filter_builtin_rules->ruleset_lock);

filter_inited = false;

log_builtins_filter_ruleset_free(&log_filter_builtin_rules);

} else

filter_inited = false; /* purecov: inspected */

return 0;

if (!filter_inited) {

log_filter_builtin_rules =

log_builtins_filter_ruleset_new(&rule_tag_builtin, 0);

if (log_filter_builtin_rules == nullptr) return -1;

log_builtins_filter_set_defaults(log_filter_builtin_rules);

filter_inited = true;

return 0;

} else

return -2;

log_filter_rule *r) {

switch (r->verb) {

case LOG_FILTER_RETURN:

break;

case LOG_FILTER_DROP:

log_line_item_free_all(ll);

break;

case LOG_FILTER_THROTTLE: {

ulonglong now = my_micro_time();

ulong rate =

(ulong)((r->aux.data.data_integer < 0) ? 0

: r->aux.data.data_integer);

ulong suppressed = 0;

ulong matches;

/*

mysql_rwlock_wrlock(&(r->rule_lock));

if (now >= r->throttle_window_end) {

suppressed =

(r->throttle_matches > rate) ? (r->throttle_matches - rate) : 0;

// new window

r->throttle_matches = 0;

r->throttle_window_end =

now + (r->throttle_window_size * THROTTLE_MICROSECOND_MULTIPLIER);

}

matches = ++r->throttle_matches;

mysql_rwlock_unlock(&(r->rule_lock));

/*

if (matches > rate) {

log_line_item_free_all(ll);

}

// if we actually suppressed any lines, add info declaring that

else if ((suppressed > 0) && !log_line_full(ll)) {

log_line_item_set(ll, LOG_ITEM_LOG_SUPPRESSED)->data_integer =

suppressed;

}

} break;

case LOG_FILTER_ITEM_SET:

if (r->aux.key == nullptr) return LOG_FILTER_APPLY_TARGET_NOT_IN_LOG_LINE;

// if not same field as in match, look for it

if ((ln < 0) || (0 != native_strcasecmp(r->aux.key, ll->item[ln].key)))

ln = log_line_index_by_item(ll, &r->aux);

if (ln >= 0) // found? release for over-write!

log_item_free(&ll->item[ln]);

else if (log_line_full(ll)) // otherwise, add it if there's still space

return LOG_FILTER_APPLY_OUT_OF_MEMORY;

else

ln = ll->count++;

ll->item[ln] = r->aux;

/*

ll->item[ln].alloc = LOG_ITEM_FREE_NONE;

ll->seen |= r->aux.type;

break;

case LOG_FILTER_ITEM_DEL:

// might want to delete a field other than that from the cond:

if ((r->aux.key != nullptr) &&

((ln < 0) ||

(0 != native_strcasecmp(r->aux.key, ll->item[ln].key)))) {

ln = log_line_index_by_item(ll, &r->aux);

}

if (ln < 0) return LOG_FILTER_APPLY_TARGET_NOT_IN_LOG_LINE;

{

log_item_type t = ll->item[ln].type;

log_line_item_remove(ll, ln);

/*

if (!log_item_generic_type(t) || (log_line_index_by_type(ll, t) < 0))

ll->seen &= ~t;

}

break;

default:

return LOG_FILTER_APPLY_UNKNOWN_OPERATION;

}

return LOG_FILTER_APPLY_SUCCESS;

log_filter_rule *ri) {

bool rc, lc;

log_filter_match e = LOG_FILTER_MATCH_UNCOMPARED;

/*

assert(ri != nullptr);

/*

if (li == nullptr)

return (ri->cond == LOG_FILTER_COND_ABSENT) ? LOG_FILTER_MATCH_SUCCESS

: LOG_FILTER_MATCH_UNSATISFIED;

else if (ri->cond == LOG_FILTER_COND_PRESENT)

return LOG_FILTER_MATCH_SUCCESS;

else if (ri->cond == LOG_FILTER_COND_ABSENT)

return LOG_FILTER_MATCH_UNSATISFIED;

// item class on left hand side / right hand side

rc = log_item_string_class(ri->match.item_class);

lc = log_item_string_class(li->item_class);

// if one's a string and the other isn't, fail for now

if (rc != lc)

e = LOG_FILTER_MATCH_CLASSES_DIFFER;

else {

e = LOG_FILTER_MATCH_UNSATISFIED;

double rf, lf;

// we're comparing two strings

if (rc) {

/*

rf = 0;

// some ado in case the strings aren't \0 terminated

size_t len; // length of the shorter string

len = (ri->match.data.data_string.length < li->data.data_string.length)

? ri->match.data.data_string.length

: li->data.data_string.length;

// compare for the shorter of the given lengths

lf = log_string_compare(li->data.data_string.str,

ri->match.data.data_string.str, len,

false); // case-sensitive

/*

if ((lf == 0) &&

(ri->match.data.data_string.length != li->data.data_string.length))

lf = (li->data.data_string.length > len) ? 1 : -1;

}

// we're comparing numerically

else {

// get values as floats (works for integer items as well)

log_item_get_float(&ri->match, &rf);

log_item_get_float(li, &lf);

}

// do the actual comparison

switch (ri->cond) {

case LOG_FILTER_COND_EQ: // == Equal

if (lf == rf) e = LOG_FILTER_MATCH_SUCCESS;

break;

case LOG_FILTER_COND_NE: // != Not Equal

if (lf != rf) e = LOG_FILTER_MATCH_SUCCESS;

break;

case LOG_FILTER_COND_GE: // >= Greater or Equal

if (lf >= rf) e = LOG_FILTER_MATCH_SUCCESS;

break;

case LOG_FILTER_COND_LT: // < Less Than

if (lf < rf) e = LOG_FILTER_MATCH_SUCCESS;

break;

case LOG_FILTER_COND_LE: // <= Less or Equal

if (lf <= rf) e = LOG_FILTER_MATCH_SUCCESS;

break;

case LOG_FILTER_COND_GT: // > Greater than

if (lf > rf) e = LOG_FILTER_MATCH_SUCCESS;

break;

// unknown comparison type

default:

e = LOG_FILTER_MATCH_COMPARATOR_UNKNOWN; /* purecov: inspected */

assert(false);

} // comparator switch

} // class mismatch?

return e;

size_t rn; // rule number

int ln = -1; // log-item number

log_filter_rule *r; // current rule

int processed = 0;

log_filter_match cond_result;

assert(filter_inited);

if (ruleset == nullptr) return 0; /* purecov: inspected */

mysql_rwlock_rdlock(&ruleset->ruleset_lock);

for (rn = 0; ((rn < ruleset->count) && (ll->seen != LOG_ITEM_END)); rn++) {

r = &ruleset->rule[rn];

/*

if (r->flags & LOG_FILTER_FLAG_DISABLED) continue;

/*

/*

if (r->cond == LOG_FILTER_COND_NONE) // in ELSE etc. there is no condition

{

/*

ln = -1;

goto apply_action;

}

ln = log_line_index_by_item(ll, &r->match);

/*

cond_result = log_filter_try_match((ln >= 0) ? &ll->item[ln] : nullptr, r);

if (cond_result == LOG_FILTER_MATCH_SUCCESS) {

/*

mysql_rwlock_wrlock(&(r->rule_lock));

++r->match_count;

mysql_rwlock_unlock(&(r->rule_lock));

if (r->verb == LOG_FILTER_CHAIN_AND) // AND -- test next condition

continue; // proceed with next cond

else if (r->verb == LOG_FILTER_CHAIN_OR) // OR -- one match is enough

{ // skip any other conditions in OR

while (ruleset->rule[rn].verb == LOG_FILTER_CHAIN_OR) rn++;

r = &ruleset->rule[rn];

}

/*

} else if (cond_result == LOG_FILTER_MATCH_UNSATISFIED) {

if (r->verb ==

LOG_FILTER_CHAIN_AND) { // jump to next branch (ELSEIF/ELSE/ENDIF)

while (ruleset->rule[++rn].verb == LOG_FILTER_CHAIN_AND)

; // skip over all AND conditions

}

/*

continue; // skip over last condition (the one with the actual action)

} else // misc. failures (type mismatch etc.)

continue;

apply_action:

if (log_filter_try_apply(ll, ln, r) == LOG_FILTER_APPLY_SUCCESS) {

processed++;

if (r->verb == LOG_FILTER_RETURN) goto done;

}

if (r->jump != 0) // we're at the end of a block; jump to ENDIF

rn += r->jump - 1;

}

done:

mysql_rwlock_unlock(&ruleset->ruleset_lock);

return processed;

size_t rn;

log_filter_rule *r;

int rr = -99;

if (log_builtins_filter_ruleset_lock(log_filter_builtin_rules,

LOG_BUILTINS_LOCK_EXCLUSIVE) < 0)

return -1;

/*

for (rn = 0; (rn < log_filter_builtin_rules->count); rn++) {

r = &log_filter_builtin_rules->rule[rn];

if ((r->match.type == LOG_ITEM_LOG_PRIO) && (r->verb == LOG_FILTER_DROP) &&

(r->cond == LOG_FILTER_COND_GT)) {

r->match.data.data_integer = verbosity;

r->flags &= ~LOG_FILTER_FLAG_DISABLED;

rr = 0;

goto done;

}

}

/* purecov: begin deadcode */

// if no log_error_verbosity item already exists, create one

if (log_filter_ruleset_full(

log_filter_builtin_rules)) { /* since this is a private rule-set, this

rr = -2;

goto done;

}

r = log_builtins_filter_rule_init(log_filter_builtin_rules);

log_item_set_with_key(&r->match, LOG_ITEM_LOG_PRIO, nullptr,

LOG_ITEM_FREE_NONE)

->data_integer = verbosity;

r->cond = LOG_FILTER_COND_GT;

r->verb = LOG_FILTER_DROP;

log_filter_builtin_rules->count++;

rr = 1; /* purecov: end */

done:

log_builtins_filter_ruleset_unlock(log_filter_builtin_rules);

return rr;

char symbol[80]; // error to suppress ("1234" or "MY-001234")

char *start = list; // start of token

char *end = nullptr; // end of token

size_t len; // length of token

int errcode; // error-code of token

int commas = -1; // reject two separators in a row

int rr = 0; // return value

size_t rn; // rule number

log_filter_rule *r; // rule

uint list_len = 0; // number of error-codes in input

// in update-mode, discard old suppress rules for filter rule-set

if (update) {

// lock rule-set

if (log_builtins_filter_ruleset_lock(log_filter_builtin_rules,

LOG_BUILTINS_LOCK_EXCLUSIVE) < 0)

return -1; // bail directly (without trying to unlock)

for (rn = 0; (rn < log_filter_builtin_rules->count);) {

r = &log_filter_builtin_rules->rule[rn];

if ((r->match.type == LOG_ITEM_SQL_ERRCODE) &&

(r->verb == LOG_FILTER_DROP) &&

(r->cond == LOG_FILTER_COND_EQ)) // match "drop by errcode"

log_builtins_filter_rule_remove(log_filter_builtin_rules, rn);

else

rn++;

}

}

if (list == nullptr) goto success;

while (true) {

// find start of token

while ((*start != '\0') && (isspace(*start) || (*start == ','))) {

if (*start == ',') {

/*

if (commas != 0) goto fail;

commas++;

}

start++;

}

end = start;

// find first non-token character (i.e. first character after token)

while ((*end != '\0') && !(isspace(*end) || (*end == ','))) end++;

// no token found, end loop

if ((len = (end - start)) == 0) {

if (commas < 1) // list may not end in a comma

goto success;

goto fail;

}

if (commas == 0) // element needs to be first, or follow a comma

goto fail;

else

commas = 0;

// token too long, error

if (len >= sizeof(symbol) - 1) goto fail;

strncpy(symbol, start, len);

symbol[len] = '\0';

// numeric token "1234"

if (isdigit(symbol[0])) {

char *last;

errcode = (int)strtol(symbol, &last, 10);

if (*last != '\0') errcode = -1;

}

// alphanumeric token ("MY-1234" or "ER_FOO")

else

errcode = mysql_symbol_to_errno(symbol);

if (!(((errcode >= EE_ERROR_FIRST) && (errcode <= EE_ERROR_LAST)) ||

((errcode >= ER_SERVER_RANGE_START) &&

(mysql_errno_to_builtin(errcode) >= 0))))

goto fail;

if (update) {

// make sure we have the space

if (log_filter_ruleset_full(log_filter_builtin_rules)) goto fail;

/*

if ((r = log_builtins_filter_rule_init(log_filter_builtin_rules)) ==

nullptr)

goto fail; /* purecov: inspected */

log_item_set_with_key(&r->match, LOG_ITEM_SQL_ERRCODE, nullptr,

LOG_ITEM_FREE_NONE)

->data_integer = errcode;

r->cond = LOG_FILTER_COND_EQ;

r->verb = LOG_FILTER_DROP;

log_filter_builtin_rules->count++;

}

/*

else if (++list_len >= (log_filter_builtin_rules->alloc - 2))

goto fail;

start = end;

}

fail:

rr = -(start - list + 1);

success:

if (update) log_builtins_filter_ruleset_unlock(log_filter_builtin_rules);

return rr;