492 lines
9.8 KiB
C++
492 lines
9.8 KiB
C++
/*
|
|
* Copyright (c) 2016 MariaDB Corporation Ab
|
|
*
|
|
* Use of this software is governed by the Business Source License included
|
|
* in the LICENSE.TXT file and at www.mariadb.com/bsl11.
|
|
*
|
|
* Change Date: 2023-11-12
|
|
*
|
|
* On the date above, in accordance with the Business Source License, use
|
|
* of this software will be governed by version 2 or later of the General
|
|
* Public License.
|
|
*/
|
|
|
|
#include "internal/event.hh"
|
|
#include <algorithm>
|
|
#include <string.h>
|
|
#include <maxbase/assert.h>
|
|
#include <maxbase/atomic.h>
|
|
|
|
using namespace std;
|
|
|
|
namespace
|
|
{
|
|
|
|
using namespace maxscale;
|
|
|
|
const char CN_UNKNOWN[] = "Unknown";
|
|
|
|
const char CN_FACILITY[] = "facility";
|
|
const char CN_LEVEL[] = "level";
|
|
|
|
const char CN_AUTHENTICATION_FAILURE[] = "authentication_failure";
|
|
|
|
const char EVENT_PREFIX[] = "event.";
|
|
|
|
|
|
struct NAME_AND_VALUE
|
|
{
|
|
const char* zName;
|
|
int32_t value;
|
|
};
|
|
|
|
int name_and_value_compare(const void* pLeft, const void* pRight)
|
|
{
|
|
const NAME_AND_VALUE* pL = static_cast<const NAME_AND_VALUE*>(pLeft);
|
|
const NAME_AND_VALUE* pR = static_cast<const NAME_AND_VALUE*>(pRight);
|
|
|
|
return strcmp(pL->zName, pR->zName);
|
|
}
|
|
|
|
|
|
// Keep these in alphabetical order.
|
|
const NAME_AND_VALUE levels[] =
|
|
{
|
|
{
|
|
"LOG_ALERT",
|
|
LOG_ALERT,
|
|
},
|
|
{
|
|
"LOG_CRIT",
|
|
LOG_CRIT,
|
|
},
|
|
{
|
|
"LOG_DEBUG",
|
|
LOG_DEBUG,
|
|
},
|
|
{
|
|
"LOG_EMER",
|
|
LOG_EMERG,
|
|
},
|
|
{
|
|
"LOG_ERR",
|
|
LOG_ERR,
|
|
},
|
|
{
|
|
"LOG_INFO",
|
|
LOG_INFO,
|
|
},
|
|
{
|
|
"LOG_NOTICE",
|
|
LOG_NOTICE,
|
|
},
|
|
{
|
|
"LOG_WARNING",
|
|
LOG_WARNING,
|
|
},
|
|
};
|
|
|
|
const int N_LEVELS = sizeof(levels) / sizeof(levels[0]);
|
|
|
|
|
|
// Keep these in alphabetical order.
|
|
const NAME_AND_VALUE facilities[] =
|
|
{
|
|
{
|
|
"LOG_AUTH",
|
|
LOG_AUTH
|
|
},
|
|
{
|
|
"LOG_AUTHPRIV",
|
|
LOG_AUTHPRIV
|
|
},
|
|
{
|
|
"LOG_CRON",
|
|
LOG_CRON
|
|
},
|
|
{
|
|
"LOG_DAEMON",
|
|
LOG_DAEMON
|
|
},
|
|
{
|
|
"LOG_FTP",
|
|
LOG_FTP
|
|
},
|
|
{
|
|
"LOG_KERN",
|
|
LOG_KERN
|
|
},
|
|
{
|
|
"LOG_LOCAL0",
|
|
LOG_LOCAL0
|
|
},
|
|
{
|
|
"LOG_LOCAL1",
|
|
LOG_LOCAL1
|
|
},
|
|
{
|
|
"LOG_LOCAL2",
|
|
LOG_LOCAL2
|
|
},
|
|
{
|
|
"LOG_LOCAL3",
|
|
LOG_LOCAL3
|
|
},
|
|
{
|
|
"LOG_LOCAL4",
|
|
LOG_LOCAL4
|
|
},
|
|
{
|
|
"LOG_LOCAL5",
|
|
LOG_LOCAL5
|
|
},
|
|
{
|
|
"LOG_LOCAL6",
|
|
LOG_LOCAL6
|
|
},
|
|
{
|
|
"LOG_LOCAL7",
|
|
LOG_LOCAL0
|
|
},
|
|
{
|
|
"LOG_LPR",
|
|
LOG_LPR
|
|
},
|
|
{
|
|
"LOG_MAIL",
|
|
LOG_MAIL
|
|
},
|
|
{
|
|
"LOG_NEWS",
|
|
LOG_NEWS
|
|
},
|
|
{
|
|
"LOG_SYSLOG",
|
|
LOG_SYSLOG
|
|
},
|
|
{
|
|
"LOG_USER",
|
|
LOG_USER
|
|
},
|
|
{
|
|
"LOG_UUCP",
|
|
LOG_UUCP
|
|
},
|
|
};
|
|
|
|
const int N_FACILITIES = sizeof(facilities) / sizeof(facilities[0]);
|
|
|
|
|
|
struct EVENT
|
|
{
|
|
const char* zName;
|
|
event::id_t id;
|
|
int32_t facility;
|
|
int32_t level;
|
|
};
|
|
|
|
// Keep these in alphabetical order.
|
|
EVENT events[] =
|
|
{
|
|
{
|
|
CN_AUTHENTICATION_FAILURE,
|
|
event::AUTHENTICATION_FAILURE,
|
|
event::DEFAULT_FACILITY,
|
|
event::DEFAULT_LEVEL
|
|
}
|
|
};
|
|
|
|
const int N_EVENTS = sizeof(events) / sizeof(events[0]);
|
|
|
|
int event_compare(const void* pLeft, const void* pRight)
|
|
{
|
|
const EVENT* pL = static_cast<const EVENT*>(pLeft);
|
|
const EVENT* pR = static_cast<const EVENT*>(pRight);
|
|
|
|
return strcmp(pL->zName, pR->zName);
|
|
}
|
|
|
|
|
|
struct
|
|
{
|
|
EVENT* events;
|
|
const NAME_AND_VALUE* levels;
|
|
const NAME_AND_VALUE* facilities;
|
|
} this_unit =
|
|
{
|
|
events,
|
|
levels,
|
|
facilities
|
|
};
|
|
|
|
event::result_t configure_facility(event::id_t id, const char* zValue)
|
|
{
|
|
event::result_t rv = event::INVALID;
|
|
|
|
int32_t facility;
|
|
if (log_facility_from_string(&facility, zValue))
|
|
{
|
|
event::set_log_facility(id, facility);
|
|
rv = event::ACCEPTED;
|
|
}
|
|
else
|
|
{
|
|
MXS_ERROR("%s is not a valid facility.", zValue);
|
|
}
|
|
|
|
return rv;
|
|
}
|
|
|
|
event::result_t configure_level(event::id_t id, const char* zValue)
|
|
{
|
|
event::result_t rv = event::INVALID;
|
|
|
|
int32_t level;
|
|
if (log_level_from_string(&level, zValue))
|
|
{
|
|
event::set_log_level(id, level);
|
|
rv = event::ACCEPTED;
|
|
}
|
|
else
|
|
{
|
|
MXS_ERROR("%s is not a valid level.", zValue);
|
|
}
|
|
|
|
return rv;
|
|
}
|
|
}
|
|
|
|
namespace maxscale
|
|
{
|
|
|
|
const char* log_level_to_string(int32_t level)
|
|
{
|
|
auto begin = this_unit.levels;
|
|
auto end = begin + N_LEVELS;
|
|
|
|
auto i = find_if(begin,
|
|
end,
|
|
[level](const NAME_AND_VALUE& item) -> bool {
|
|
return item.value == level;
|
|
});
|
|
|
|
return i == end ? CN_UNKNOWN : i->zName;
|
|
}
|
|
|
|
bool log_level_from_string(int32_t* pLevel, const char* zValue)
|
|
{
|
|
NAME_AND_VALUE key = {zValue};
|
|
void* pResult = bsearch(&key,
|
|
this_unit.levels,
|
|
N_LEVELS,
|
|
sizeof(NAME_AND_VALUE),
|
|
name_and_value_compare);
|
|
|
|
if (pResult)
|
|
{
|
|
const NAME_AND_VALUE* pItem = static_cast<const NAME_AND_VALUE*>(pResult);
|
|
|
|
*pLevel = pItem->value;
|
|
}
|
|
|
|
return pResult != nullptr;
|
|
}
|
|
|
|
const char* log_facility_to_string(int32_t facility)
|
|
{
|
|
auto begin = this_unit.facilities;
|
|
auto end = begin + N_FACILITIES;
|
|
|
|
auto i = find_if(begin,
|
|
end,
|
|
[facility](const NAME_AND_VALUE& item) -> bool {
|
|
return item.value == facility;
|
|
});
|
|
|
|
return i == end ? CN_UNKNOWN : i->zName;
|
|
}
|
|
|
|
bool log_facility_from_string(int32_t* pFacility, const char* zValue)
|
|
{
|
|
NAME_AND_VALUE key = {zValue};
|
|
void* pResult = bsearch(&key,
|
|
this_unit.facilities,
|
|
N_FACILITIES,
|
|
sizeof(NAME_AND_VALUE),
|
|
name_and_value_compare);
|
|
|
|
if (pResult)
|
|
{
|
|
const NAME_AND_VALUE* pItem = static_cast<const NAME_AND_VALUE*>(pResult);
|
|
|
|
*pFacility = pItem->value;
|
|
}
|
|
|
|
return pResult != nullptr;
|
|
}
|
|
|
|
|
|
namespace event
|
|
{
|
|
|
|
const char* to_string(id_t id)
|
|
{
|
|
auto begin = this_unit.events;
|
|
auto end = begin + N_EVENTS;
|
|
|
|
auto i = find_if(begin,
|
|
end,
|
|
[id](const EVENT& item) -> bool {
|
|
return item.id == id;
|
|
});
|
|
|
|
return i == end ? CN_UNKNOWN : i->zName;
|
|
}
|
|
|
|
bool from_string(id_t* pId, const char* zValue)
|
|
{
|
|
EVENT key = {zValue};
|
|
void* pResult = bsearch(&key,
|
|
this_unit.events,
|
|
N_EVENTS,
|
|
sizeof(EVENT),
|
|
event_compare);
|
|
|
|
if (pResult)
|
|
{
|
|
const EVENT* pItem = static_cast<const EVENT*>(pResult);
|
|
|
|
*pId = pItem->id;
|
|
}
|
|
|
|
return pResult != nullptr;
|
|
}
|
|
|
|
void set_log_facility(id_t id, int32_t facility)
|
|
{
|
|
bool rv = false;
|
|
mxb_assert((id >= 0) && (id < N_EVENTS));
|
|
|
|
// We silently strip away other than the relevant bits.
|
|
facility = facility & LOG_FACMASK;
|
|
|
|
EVENT& event = this_unit.events[id];
|
|
|
|
atomic_store_int32(&event.facility, facility);
|
|
}
|
|
|
|
int32_t get_log_facility(id_t id)
|
|
{
|
|
mxb_assert((id >= 0) && (id < N_EVENTS));
|
|
|
|
const EVENT& event = this_unit.events[id];
|
|
|
|
return atomic_load_int32(&event.facility);
|
|
}
|
|
|
|
void set_log_level(id_t id, int32_t level)
|
|
{
|
|
mxb_assert((id >= 0) && (id < N_EVENTS));
|
|
|
|
// We silently strip away other than the relevant bits.
|
|
level = level & LOG_PRIMASK;
|
|
|
|
EVENT& event = this_unit.events[id];
|
|
|
|
atomic_store_int32(&event.level, level);
|
|
}
|
|
|
|
int32_t get_log_level(id_t id)
|
|
{
|
|
mxb_assert((id >= 0) && (id < N_EVENTS));
|
|
|
|
const EVENT& event = this_unit.events[id];
|
|
|
|
return atomic_load_int32(&event.level);
|
|
}
|
|
|
|
result_t configure(const char* zName, const char* zValue)
|
|
{
|
|
result_t rv = IGNORED;
|
|
|
|
if (strncmp(zName, EVENT_PREFIX, sizeof(EVENT_PREFIX) - 1) == 0)
|
|
{
|
|
rv = INVALID;
|
|
|
|
string name(zName + sizeof(EVENT_PREFIX) - 1); // Character following '.'
|
|
|
|
auto i = name.find_first_of('.');
|
|
|
|
if (i != string::npos)
|
|
{
|
|
string event = name.substr(0, i);
|
|
string property = name.substr(i + 1);
|
|
|
|
id_t id;
|
|
if (from_string(&id, event.c_str()))
|
|
{
|
|
mxb_assert((id >= 0) && (id < N_EVENTS));
|
|
|
|
if (property == CN_FACILITY)
|
|
{
|
|
rv = configure_facility(id, zValue);
|
|
}
|
|
else if (property == CN_LEVEL)
|
|
{
|
|
rv = configure_level(id, zValue);
|
|
}
|
|
else
|
|
{
|
|
MXS_ERROR("%s is neither %s nor %s.", property.c_str(), CN_FACILITY, CN_LEVEL);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
MXS_ERROR("%s does not refer to a known event.", zValue);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
MXS_ERROR("%s is not a valid event configuration.", zName);
|
|
}
|
|
}
|
|
|
|
return rv;
|
|
}
|
|
|
|
void log(id_t event_id,
|
|
const char* modname,
|
|
const char* file,
|
|
int line,
|
|
const char* function,
|
|
const char* format,
|
|
...)
|
|
{
|
|
va_list valist;
|
|
|
|
mxb_assert((event_id >= 0) && (event_id < N_EVENTS));
|
|
|
|
const EVENT& event = this_unit.events[event_id];
|
|
|
|
int priority = atomic_load_int32(&event.facility) | atomic_load_int32(&event.level);
|
|
|
|
va_start(valist, format);
|
|
int len = vsnprintf(NULL, 0, format, valist);
|
|
va_end(valist);
|
|
|
|
if (len > BUFSIZ)
|
|
{
|
|
len = BUFSIZ;
|
|
}
|
|
|
|
char message[len + 1];
|
|
|
|
va_start(valist, format);
|
|
vsnprintf(message, len + 1, format, valist);
|
|
va_end(valist);
|
|
|
|
mxs_log_message(priority, modname, file, line, function, "%s", message);
|
|
}
|
|
} // event
|
|
} // maxscale
|