int test_log_mask(struct harness_t *harness_p)
{
struct log_object_t foo;
/* Initialize the log objects. */
BTASSERT(log_object_init(&foo,
"foo",
LOG_UPTO(INFO)) == 0);
BTASSERT(log_object_get_log_mask(&foo) == 0x0f);
/* Log all. */
BTASSERT(log_object_set_log_mask(&foo, LOG_ALL) == 0);
BTASSERT(log_object_get_log_mask(&foo) == 0x1f);
/* Log none. */
BTASSERT(log_object_set_log_mask(&foo, LOG_NONE) == 0);
BTASSERT(log_object_get_log_mask(&foo) == 0x00);
/* Log error. */
BTASSERT(log_object_set_log_mask(&foo, LOG_MASK(ERROR)) == 0);
BTASSERT(log_object_get_log_mask(&foo) == 0x02);
/* Invalid levels are discarded. */
BTASSERT(log_object_set_log_mask(&foo, 0xf0) == 0);
BTASSERT(log_object_get_log_mask(&foo) == 0x10);
/* Is enabled for. */
BTASSERT(log_object_set_log_mask(&foo, LOG_MASK(ERROR)) == 0);
BTASSERT(log_object_is_enabled_for(&foo, LOG_INFO) == 0);
BTASSERT(log_object_is_enabled_for(&foo, LOG_ERROR) == 1);
thrd_set_log_mask(thrd_self(), 0x00);
BTASSERT(log_object_is_enabled_for(NULL, LOG_ERROR) == 0);
return (0);
}
/**
* HUP signal handler to toggle info log level on/off
* @param sig
*/
static void sighup_handler(int sig)
{
if ((logmask & LOG_MASK(LOG_INFO)) & LOG_MASK(LOG_INFO)) {
logmask = LOG_UPTO(LOG_NOTICE);
syslog(LOG_NOTICE, "logtrace: info level disabled");
} else {
logmask = LOG_UPTO(LOG_INFO);
syslog(LOG_NOTICE, "logtrace: info level enabled");
}
setlogmask(logmask);
}
int main(int argc, char *argv[])
{
evm_init_struct *evm_init_ptr;
usage_check(argc, argv);
log_mask = LOG_MASK(LOG_EMERG) | LOG_MASK(LOG_ALERT) | LOG_MASK(LOG_CRIT) | LOG_MASK(LOG_ERR);
/* Setup LOG_MASK according to startup arguments! */
if (evmlog_normal) {
log_mask |= LOG_MASK(LOG_WARNING);
log_mask |= LOG_MASK(LOG_NOTICE);
}
if ((evmlog_verbose) || (evmlog_trace))
log_mask |= LOG_MASK(LOG_INFO);
if (evmlog_debug)
log_mask |= LOG_MASK(LOG_DEBUG);
setlogmask(log_mask);
if ((evm_init_ptr = hello4_evm_init(1)) == NULL)
exit(EXIT_FAILURE);
if (hello4_evm_run(evm_init_ptr) < 0)
exit(EXIT_FAILURE);
exit(EXIT_SUCCESS);
}
int
ACE_Log_Msg_UNIX_Syslog::convert_log_mask (int lm_mask)
{
int syslog_mask = 0;
if (ACE_BIT_ENABLED (lm_mask, LM_TRACE)
|| ACE_BIT_ENABLED (lm_mask, LM_DEBUG))
ACE_SET_BITS (syslog_mask, LOG_MASK(LOG_DEBUG));
if (ACE_BIT_ENABLED (lm_mask, LM_STARTUP)
|| ACE_BIT_ENABLED (lm_mask, LM_SHUTDOWN)
|| ACE_BIT_ENABLED (lm_mask, LM_INFO))
ACE_SET_BITS (syslog_mask, LOG_MASK(LOG_INFO));
if (ACE_BIT_ENABLED (lm_mask, LM_NOTICE))
ACE_SET_BITS (syslog_mask, LOG_MASK(LOG_NOTICE));
if (ACE_BIT_ENABLED (lm_mask, LM_ERROR))
ACE_SET_BITS (syslog_mask, LOG_MASK(LOG_ERR));
if (ACE_BIT_ENABLED (lm_mask, LM_WARNING))
ACE_SET_BITS (syslog_mask, LOG_MASK(LOG_WARNING));
if (ACE_BIT_ENABLED (lm_mask, LM_CRITICAL))
ACE_SET_BITS (syslog_mask, LOG_MASK(LOG_CRIT));
if (ACE_BIT_ENABLED (lm_mask, LM_ALERT))
ACE_SET_BITS (syslog_mask, LOG_MASK(LOG_ALERT));
if (ACE_BIT_ENABLED (lm_mask, LM_EMERGENCY))
ACE_SET_BITS (syslog_mask, LOG_MASK(LOG_EMERG));
return syslog_mask;
}
int log_preopen(const char *dst, bool log_debug, bool log_info)
{
const char *syslog_prefix = "syslog:";
const char *file_prefix = "file:";
if (log_debug)
log_mask |= LOG_MASK(LOG_DEBUG);
if (log_info)
log_mask |= LOG_MASK(LOG_INFO);
if (strcmp(dst, "stderr") == 0) {
log_msg_next = stderr_msg;
}
else if (strncmp(dst, syslog_prefix, strlen(syslog_prefix)) == 0) {
const char *facility_name = dst + strlen(syslog_prefix);
int facility = -1;
struct {
char *name; int value;
} *ptpl, tpl[] = {
{ "daemon", LOG_DAEMON },
{ "local0", LOG_LOCAL0 },
{ "local1", LOG_LOCAL1 },
{ "local2", LOG_LOCAL2 },
{ "local3", LOG_LOCAL3 },
{ "local4", LOG_LOCAL4 },
{ "local5", LOG_LOCAL5 },
{ "local6", LOG_LOCAL6 },
{ "local7", LOG_LOCAL7 },
};
FOREACH(ptpl, tpl)
if (strcmp(facility_name, ptpl->name) == 0) {
facility = ptpl->value;
break;
}
if (facility == -1) {
log_error(LOG_ERR, "log_preopen(%s, ...): unknown syslog facility", dst);
return -1;
}
openlog("redsocks", LOG_NDELAY | LOG_PID, facility);
log_mask = setlogmask(0);
if (!log_debug)
log_mask &= ~(LOG_MASK(LOG_DEBUG));
if (!log_info)
log_mask &= ~(LOG_MASK(LOG_INFO));
setlogmask(log_mask);
log_msg_next = syslog_msg;
}
else if (strncmp(dst, file_prefix, strlen(file_prefix)) == 0) {
/*
* Handles a signal.
*/
static void signal_handler(
const int sig) /**< [in] Signal to be handled */
{
#ifdef SVR3SIGNALS
/*
* Some systems reset handler to SIG_DFL upon entry to handler.
* In that case, we reregister our handler.
*/
(void)signal(sig, signal_handler);
#endif
switch (sig) {
case SIGINT:
exit(1);
case SIGTERM:
(void)pthread_cancel(readerThread);
break;
case SIGUSR1:
if (NULL != reader) {
(void)pthread_mutex_lock(&mutex);
reportStatistics = 1;
(void)pthread_cond_signal(&cond);
(void)pthread_mutex_unlock(&mutex);
}
break;
case SIGUSR2: {
unsigned logMask = getulogmask();
if ((logMask & LOG_MASK(LOG_WARNING)) == 0) {
(void)setulogmask(LOG_UPTO(LOG_WARNING));
}
else if ((logMask & LOG_MASK(LOG_NOTICE)) == 0) {
(void)setulogmask(LOG_UPTO(LOG_NOTICE));
}
else if ((logMask & LOG_MASK(LOG_INFO)) == 0) {
(void)setulogmask(LOG_UPTO(LOG_INFO));
}
else if ((logMask & LOG_MASK(LOG_DEBUG)) == 0) {
(void)setulogmask(LOG_UPTO(LOG_DEBUG));
}
else {
(void)setulogmask(LOG_UPTO(LOG_ERR));
}
break;
}
}
return;
}
TEST(LDPCUnitTest, GetPeerMetadata) {
TLDPSettings *ldp_settings_obj = NULL;
char *metadata = NULL;
size_t bytes_read = 0;
LDPLOG = &ldp_log_console;
LDPLOG_setmask = &ldp_log_console_setlogmask;
LDPLOG_setmask(LOG_MASK(LOG_ERR));
openlog ("LDPCUnitTest", LOG_CONS | LOG_PID | LOG_NDELAY, LOG_LOCAL1); // This should use stdout, not syslog messages file
ldp_settings_obj = ldp_settings_create();
EXPECT_TRUE(ldp_settings_obj);
EXPECT_TRUE(ldp_settings_init(ldp_settings_obj) == 0);
LDPLOG(LOG_DEBUG, "about to call ldp_get_peer_metadata_as_bytes(%s)", "86753099");
metadata = ldp_get_peer_metadata_as_bytes("86753099", &bytes_read, NULL);
LDPLOG(LOG_DEBUG, "done with call to ldp_get_peer_metadata_as_bytes()");
EXPECT_TRUE(metadata != NULL);
if (metadata != NULL) {
LDPLOG(LOG_DEBUG, "read metadata = %s", metadata);
}
EXPECT_TRUE(bytes_read > 0);
LDPLOG(LOG_DEBUG, "Read = %d", bytes_read);
ldp_settings_destroy(&ldp_settings_obj);
EXPECT_EQ(NULL, ldp_settings_obj);
closelog();
}
extern int syslog(int priority, char *message, ... )
{
va_list a;
int n = 0;
int pos = 0;
if( !(logmask & LOG_MASK(priority)) ) return 0;
if( logfd == -1 ) openlog(NULL,LOG_NDELAY,0);
va_start(a,message);
if( logident ) pos += sprintf(logbuf,"SYSLOG: %s ",logident);
else pos += sprintf(logbuf,"SYSLOG: ");
for(;;)
{
char ch = *message++;
if( ch == 0 || (ch == '%' && *message == 'm'))
{
fbuf[n] = 0;
pos += vsprintf(logbuf+pos,fbuf,a);
if( ch == 0 ) break;
message++;
pos += vsprintf(logbuf+pos,sys_errlist[errno],a);
n = 0;
}
else if( n < 99 ) fbuf[n++] = ch;
}
n = strlen(logbuf);
if( logbuf[n-1] != '\n' ) logbuf[n++] = '\r',logbuf[n++] = '\n';
write(logfd,logbuf,n);
return 0;
}
/******************************************************************************
* vsyslog
*
* Generate a log message using FMT and using arguments pointed to by AP.
*/
void vsyslog( int pri, char* fmt, va_list ap )
{
static char *month[] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
"Jul", "Aug", "Sep", "Oct", "Nov", "Dec" };
SYSTEMTIME stm;
int len;
char *p;
if( !(LOG_MASK( LOG_PRI( pri )) & log_mask) )
return;
openlog( NULL, 0, pri & LOG_FACMASK );
if( !initialized )
return;
if( !(pri & LOG_FACMASK) )
pri |= syslog_facility;
GetLocalTime( &stm );
len = sprintf( datagramm, "<%d>%s %2d %02d:%02d:%02d %s %s%s: ",
pri,
month[ stm.wMonth - 1 ], stm.wDay, stm.wHour, stm.wMinute, stm.wSecond,
local_hostname, syslog_ident? syslog_ident : "", str_pid );
vsnprintf( datagramm + len, datagramm_size - len, fmt, ap );
p = strchr( datagramm, '\n' );
if( p )
*p = 0;
p = strchr( datagramm, '\r' );
if( p )
*p = 0;
sendto( sock, datagramm, strlen(datagramm), 0, (SOCKADDR*) &sa_logger, sizeof(SOCKADDR_IN) );
}
int
LogStderrV(int level, const char *msg, va_list args)
{
if (logFile == NULL || msg == NULL || !(logMask & LOG_MASK(level)))
return -1;
(void) LogErrorV(msg, args);
#if defined(HAVE_FLOCKFILE)
flockfile(stderr);
#endif
(void) fprintf(stderr, "%s: ", programName);
(void) vfprintf(stderr, msg, args);
if (errno != 0)
(void) fprintf(stderr, ": (%d) %s", errno, strerror(errno));
(void) fputs("\r\n", stderr);
(void) fflush(stderr);
#if defined(HAVE_FLOCKFILE)
funlockfile(stderr);
#endif
return 0;
}
void dleyna_log_init(const char *program, const char *version)
{
int option = LOG_NDELAY | LOG_PID;
int old;
#ifdef DLEYNA_DEBUG_ENABLED
option |= LOG_PERROR | LOG_CONS;
#endif
memset(&s_log_context, 0, sizeof(s_log_context));
s_log_context.log_domain = g_strdup(program);
prv_set_flags_from_param();
openlog(basename(program), option, LOG_DAEMON);
old = setlogmask(LOG_MASK(LOG_INFO));
syslog(LOG_INFO, "dLeyna core version %s", VERSION);
syslog(LOG_INFO, "%s version %s", program, version);
(void) setlogmask(s_log_context.mask);
s_log_context.old_mask = old;
s_log_context.old_handler = g_log_set_default_handler(
prv_handler,
&s_log_context);
#if DLEYNA_LOG_LEVEL & DLEYNA_LOG_LEVEL_INFO
if (s_log_context.log_type != DLEYNA_LOG_TYPE_SYSLOG) {
DLEYNA_LOG_INFO("dLeyna core version %s", VERSION);
DLEYNA_LOG_INFO("%s version %s", program, version);
}
#endif
}
TEST(LDPCUnitTest, GetPeers) {
TLDPSettings *ldp_settings_obj = NULL;
char **names = {0};
int name_count = 0;
LDPLOG = &ldp_log_console;
LDPLOG_setmask = &ldp_log_console_setlogmask;
LDPLOG_setmask(LOG_MASK(LOG_ERR));
openlog ("LDPCUnitTest", LOG_CONS | LOG_PID | LOG_NDELAY, LOG_LOCAL1); // This should use stdout, not syslog messages file
ldp_settings_obj = ldp_settings_create();
EXPECT_TRUE(ldp_settings_obj);
EXPECT_TRUE(ldp_settings_init(ldp_settings_obj) == 0);
LDPLOG(LOG_DEBUG, "about to call ldp_get_peers()");
names = ldp_get_peers(&name_count, NULL);
LDPLOG(LOG_DEBUG, "done with call to ldp_get_peers()");
EXPECT_TRUE(names != NULL);
EXPECT_TRUE(name_count >= 1);
LDPLOG(LOG_DEBUG, "Got name_count = %d", name_count);
for (int i = 0; i < name_count; i++) {
LDPLOG(LOG_DEBUG, "First name: %s", names[i]);
}
ldp_settings_destroy(&ldp_settings_obj);
EXPECT_EQ(NULL, ldp_settings_obj);
closelog();
}
static
void
cd_ConsoleLog (int priority, const char* format, ...)
{
/* Return on MASKed log priorities */
if (LOG_MASK(priority) & cd_mask) {
return;
}
static const char* names[] = {
"EMERG", "ALERT", "CRIT", "ERR", "WARNING", "NOTICE", "INFO", "DEBUG"
};
va_list ap;
va_start(ap, format);
CDString* priorityBuffer;
CDString* messageBuffer = CD_CreateStringFromFormatList(format, ap);
if (priority >= (sizeof(names) / sizeof(char*)) || priority < 0) {
priorityBuffer = CD_CreateStringFromCString("UNKNOWN");
}
else {
priorityBuffer = CD_CreateStringFromCString(names[priority]);
}
printf("%s: %s\n", CD_StringContent(priorityBuffer), CD_StringContent(messageBuffer));
fflush(stdout);
CD_DestroyString(priorityBuffer);
CD_DestroyString(messageBuffer);
va_end(ap);
}
void msu_log_init(const char *program)
{
int option = LOG_NDELAY | LOG_PID;
int old;
#ifdef MSU_DEBUG_ENABLED
option |= LOG_PERROR | LOG_CONS;
#endif
memset(&s_log_context, 0, sizeof(s_log_context));
prv_msu_log_set_flags_from_param();
openlog(basename(program), option, LOG_DAEMON);
old = setlogmask(LOG_MASK(LOG_INFO));
syslog(LOG_INFO, "Media Service UPnP version %s", VERSION);
(void) setlogmask(s_log_context.mask);
s_log_context.old_mask = old;
s_log_context.old_handler = g_log_set_default_handler(
prv_msu_log_handler,
&s_log_context);
if (s_log_context.log_type != MSU_LOG_TYPE_SYSLOG) {
MSU_LOG_INFO("Media Service UPnP version %s", VERSION);
}
}
/*
* ログ情報の出力
*
* CPUロック状態や実行コンテキストによらず動作できるように実装してある．
*/
ER
syslog_wri_log(uint_t prio, const SYSLOG *p_syslog)
{
SIL_PRE_LOC;
LOG_SYSLOG_WRI_LOG_ENTER(prio, p_syslog);
SIL_LOC_INT();
/*
* ログ時刻の設定
*/
((SYSLOG *) p_syslog)->logtim = _kernel_current_time;
/*
* ログバッファに記録
*/
if ((syslog_logmask & LOG_MASK(prio)) != 0U) {
syslog_buffer[syslog_tail] = *p_syslog;
syslog_tail++;
if (syslog_tail >= TCNT_SYSLOG_BUFFER) {
syslog_tail = 0U;
}
if (syslog_count < TCNT_SYSLOG_BUFFER) {
syslog_count++;
}
else {
syslog_head = syslog_tail;
syslog_lost++;
}
}
/*
* 低レベル出力
*/
if (((~syslog_lowmask_not) & LOG_MASK(prio)) != 0U) {
syslog_print(p_syslog, target_fput_log);
target_fput_log('\n');
}
SIL_UNL_INT();
LOG_SYSLOG_WRI_LOG_LEAVE(E_OK);
return(E_OK);
}
void __vsyslog(int priority, const char *message, va_list ap)
{
int cs;
if (!(log_mask & LOG_MASK(priority&7)) || (priority&~0x3ff)) return;
pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &cs);
LOCK(lock);
_vsyslog(priority, message, ap);
UNLOCK(lock);
pthread_setcancelstate(cs, 0);
}
static PyObject *
syslog_log_mask(PyObject *self, PyObject *args)
{
long mask;
long pri;
if (!PyArg_ParseTuple(args, "l:LOG_MASK", &pri))
return NULL;
mask = LOG_MASK(pri);
return PyInt_FromLong(mask);
}
int
main(int argc, char **argv)
{
openlog_team("SyslogTest", LOG_PID, LOG_USER);
log_team(LOG_ERR, "this is %.", "a test");
int mask = setlogmask_team(LOG_MASK(LOG_CRIT));
printf("team mask == %d\n", mask);
log_team(LOG_WARNING, "this is a warning (hidden)");
log_team(LOG_CRIT, "this is a critical condition (visible)");
setlogmask_team(mask);
syslog(LOG_WARNING, "thread warning (visible)");
syslog(LOG_CRIT, "thread critical condition (visible)");
syslog(LOG_CRIT, "thread critical condition (visible)");
setlogmask(LOG_MASK(LOG_WARNING));
log_team(LOG_WARNING | LOG_MAIL, "2. this is a warning from the MAIL facility (visible)");
log_team(LOG_CRIT, "2. this is a critical condition (visible)");
log_team(LOG_CRIT, "2. this is a critical condition (visible)");
log_team(LOG_CRIT, "2. this is a critical condition (visible)");
// test repeat message suppressing as well
openlog(NULL, LOG_PERROR, LOG_USER);
syslog(LOG_WARNING, "thread/perror warning (visible in stderr as well)");
syslog(LOG_CRIT, "thread/perror critical condition (hidden)");
openlog(NULL, LOG_CONS | LOG_PID, LOG_DAEMON);
syslog(LOG_WARNING, "thread/cons warning (visible in stderr only when there is no syslog_daemon)");
openlog("", 0, LOG_DAEMON);
syslog(LOG_WARNING, "thread warning without ident (visible)");
setlogmask(LOG_EMERG);
closelog();
// this should inherit the team log context on next logging entry
syslog(LOG_ALERT, "now what are we doing here? (visible)");
return 0;
}
int lc_syslog_setmask(lua_State* L) {
int level_idx = luaL_checkoption(L, 1, "notice", level_strings);
int mask = 0;
do {
mask |= LOG_MASK(level_constants[level_idx]);
} while(++level_idx <= 4);
setlogmask(mask);
return 0;
}
void async_vsyslog(struct async_syslog_state* state, int priority, const char *format, va_list ap) {
if (!(state->mask & LOG_MASK(LOG_PRI(priority))) || (priority &~ (LOG_PRIMASK|LOG_FACMASK)))
return;
if (state->buffer_get == state->buffer_put && !state->buffers_empty)
return;
connect_to_syslog(state);
add_to_log_buffer(state, priority, format, ap);
write_to_syslog(state);
}
static int Psetlogmask(lua_State* L) /** setlogmask(priority...) */
{
int argno = lua_gettop(L);
int mask = 0;
int i;
for (i=1; i <= argno; i++)
mask |= LOG_MASK(luaL_checkint(L,i));
return pushresult(L, setlogmask(mask),"setlogmask");
}
/* There are three ways to generate log messages:
* 1. Kernel routines can call the log() function. These messages can be
* read by any user process that openS and readS the /dev/klog device.
* 2. Most user processes (daemons) call the syslog() function to generate
* log messages. This causes the message to be sent to the UNIX domain
* datagram socket /dev/log.
* 3. A user process on this host, or on some other host that is connected
* to this host by a TCP/IP network, can send log messages to UDP port 514.
* Note that the syslog() function never generates these UDP datagrams:
* they require explicit network programming by the process generating the
* log message.
* 这三种方式最终将数据传给syslogd守护进程,由syslogd来负责将数据写入文件,
* 或者显示到控制台,或者再传给其他的主机(host).
* #include <syslog.h>
* void openlog(const char *ident, int option, int facility);
* void syslog(int priority, const char *format, ...);
* void closelog(void);
* Calling openlog() is optional. If it's not called, the first time syslog
* is called, openlog() is called automatically. Calling closelog() is also
* optional--it just closes the descriptor that was being used to
* communicate with the syslogd daemon.
* openlog()函数的第一个参数可以指定一个嵌入到每条log开头的字符串.如果没有
* 调用openlog()函数就直接调用syslog(),则syslog()默认会用所执行的命令名来
* 嵌入到每条log开头,这一点是实际测试发现的,书中和man手册都没有提到这个规则
* 关于 option, facility, priority 参数的具体取值要看一下man手册.
*
* int setlogmask(int mask);
* Returns: previous log priority mask value.
* A process has a log priority mask that determines which calls to syslog
* may be logged. All other calls will be ignored. Logging is enabled for
* the priorities that have the corresponding bit set in mask. The initial
* mask is such that logging is enabled for all priorities. If the mask
* argument is 0, the current logmask is not modified.
* The eight priorities are LOG_EMERG, LOG_ALERT, LOG_CRIT, LOG_ERR,
* LOG_WARNING, LOG_NOTIE, LOG_INFO, and LOG_DEBUG. The bit corresponding to
* a priority p is LOG_MASK(p).
*
* In addition to syslog(), many platforms provide a variant that handles
* variable argument lists.
* #include <syslog.h>
* #include <stdarg.h>
* void vsyslog(int priority, const char *format, va_list arg);
*/
int main(void)
{
/* 这里虽然指定了log的优先级,但是查看/var/log/user.log文件,里面没有体现
* 出来这些优先级,也就是log里面没有字段来表示log的优先级.
*/
syslog(LOG_ERR, "zhong cheng juan shu");
/* 调用openlog()指定log前缀为 "TIAN" */
openlog("TIAN", LOG_CONS | LOG_PID, LOG_USER);
syslog(LOG_ALERT, "tian xia you qing ren");
/* 上面调用openlog()指定了LOG_PID选项,当时觉得下面调用closelog()后,这个
* LOG_PID选项应该会失效,但是实际执行结果不是这样,后面的log语句也带上了
* 进程ID,所以执行closelog()后,LOG_PID选项还是生效的.但奇怪的是,"TIAN"
* 前缀却失效了,后面的log语句没有带有这个"TIAN"前缀.如果删掉closelog()
* 语句,后面的log语句的确是带有"TIAN"前缀的,可能是因为LOG_PID选项是
* openlog()函数独有的,所以closelog()函数不会让LOG_PID选项失效吧.
*/
closelog();
/* 要调用LOG_MASK()来将log优先级转换为对应的log mask.直接写为
* setlogmask(LOG_ERR); 不会得到预期的结果.
*/
setlogmask(LOG_MASK(LOG_ERR));
/* 上面将log mask设置为了LOG_ERR,则下面LOG_CRIT优先级的log将不会被
* 写入到log文件,且这句log会被忽略.即使后面将log mask设置为LOG_CRIT,
* 这句log也不会被写入到log文件中.
*/
syslog(LOG_CRIT, "how are you");
/* LOG_ERR优先级的log能够写入到log文件 */
syslog(LOG_ERR, "fine....");
/* 将log mask设置为 LOG_CRIT后,下面的LOG_CRIT优先级log就能写入到log文件
*/
setlogmask(LOG_MASK(LOG_CRIT));
syslog(LOG_CRIT, "how are you again");
return 0;
}
int main(int argc, char **argv)
{
openlog("ntpc", LOG_PID, LOG_USER);
if (!nvram_contains_word("log_events", "ntp")) {
setlogmask(LOG_MASK(LOG_EMERG)); // can't set to 0
}
if (strstr(argv[0], "ntpsync") != NULL) return ntpsync_main(argc, argv);
if (strstr(argv[0], "ntpstep") != NULL) return ntpstep_main(argc, argv);
return ntpc_main(argc, argv);
}
int log_level_change(int argc, char *argv[])
{
const unsigned buffer_size = 200;
int result = -1;
if (argc > 1) {
g_syslog_mask = LOG_MASK(atoi(argv[1]));
}
printf("log level mask = 0x%x \n", g_syslog_mask);
return result;
}
int log_init()
{
/* Initialize globals. */
LOG_FCL = 0;
LOG_FCL_SIZE = 0;
LOG_FDS = 0;
LOG_FDS_OPEN = 0;
/* Setup initial state. */
int ret = KNOT_EOK;
int emask = LOG_MASK(LOG_WARNING)|LOG_MASK(LOG_ERR)|LOG_MASK(LOG_FATAL);
int imask = LOG_MASK(LOG_INFO)|LOG_MASK(LOG_NOTICE);
/* Add debug messages. */
emask |= LOG_MASK(LOG_DEBUG);
ret = log_setup(0);
log_levels_set(LOGT_SYSLOG, LOG_ANY, emask);
log_levels_set(LOGT_STDERR, LOG_ANY, emask);
log_levels_set(LOGT_STDOUT, LOG_ANY, imask);
setlogmask(LOG_UPTO(LOG_DEBUG));
openlog(PACKAGE_NAME, LOG_PID, LOG_DAEMON);
return ret;
}
static int
extract_syslog_mask(s48_call_t call, s48_ref_t sch_syslog_mask)
{
long syslog_mask = s48_extract_long_2(call, sch_syslog_mask);
return
(00001 & syslog_mask ? LOG_MASK(LOG_EMERG) : 0) |
(00002 & syslog_mask ? LOG_MASK(LOG_ALERT) : 0) |
(00004 & syslog_mask ? LOG_MASK(LOG_CRIT) : 0) |
(00010 & syslog_mask ? LOG_MASK(LOG_ERR) : 0) |
(00010 & syslog_mask ? LOG_MASK(LOG_WARNING) : 0) |
(00010 & syslog_mask ? LOG_MASK(LOG_NOTICE) : 0) |
(00010 & syslog_mask ? LOG_MASK(LOG_INFO) : 0) |
(00020 & syslog_mask ? LOG_MASK(LOG_DEBUG) : 0);
}
static void
_stderr_vsyslog(int perrno, int priority, const char *format, va_list args)
{
if (!(LOG_MASK(priority) & stderr_logmask))
return;
const char *levelstr = stderr_level_prefix_fn(priority);
fprintf(stderr, "%s", levelstr);
char *eformat = strrep(format, "%m", strerror(perrno));
vfprintf(stderr, eformat, args);
if (eformat != format)
free(eformat);
fprintf(stderr, "\n");
}
int
LogPrintV(int level, const char *msg, va_list args)
{
time_t now;
int length;
char stamp[20]; /* yyyy-mm-dd HH:MM:SS */
struct tm local;
char buffer[MAX_LOG_LINE_SIZE], *buf;
if (logFile == NULL || msg == NULL || !(logMask & LOG_MASK(level)))
return -1;
now = time(NULL);
(void) localtime_r(&now, &local);
(void) strftime(stamp, sizeof (stamp), "%Y-%m-%dT%H:%M:%S", &local);
length = snprintf(
buffer, sizeof (buffer), "%s %s:%lu %s ",
stamp, programName, (unsigned long) getpid(), logLevels[level]
);
length += vsnprintf(buffer+length, sizeof (buffer)-length, msg, args);
/* Replace ASCII control character, particularly CRLF. */
for (buf = buffer; *buf != '\0'; buf++) {
switch (*buf) {
case '\r': case '\n':
*buf = ' ';
case '\t':
continue;
}
if (iscntrl(*buf))
*buf = '?';
}
#if defined(HAVE_FLOCKFILE)
flockfile(logFile);
#endif
(void) fputs(buffer, logFile);
(void) fputs("\r\n", logFile);
(void) fflush(logFile);
#if defined(HAVE_FLOCKFILE)
funlockfile(logFile);
#endif
return 0;
}
/******************************************************************************
* sys_setlogmask(...)
* Sets the mask used by syslog() to decide whether a certain priority is
* going to be logged (if preprocessor define USE_SYSLOG).
*****************************************************************************/
void
sys_setlogmask(int mask)
{
sys_log_mask = mask;
#if USE_SYSLOG
int msk = (mask & ILOG_DEBUG) ? LOG_MASK(LOG_DEBUG) : 0 |
(mask & ILOG_INFO) ? LOG_MASK(LOG_INFO) : 0 |
(mask & ILOG_NOTICE) ? LOG_MASK(LOG_NOTICE) : 0 |
(mask & ILOG_WARNING) ? LOG_MASK(LOG_WARNING) : 0 |
(mask & ILOG_ERR) ? LOG_MASK(LOG_ERR) : 0 |
(mask & ILOG_CRIT) ? LOG_MASK(LOG_CRIT) : 0 |
(mask & ILOG_ALERT) ? LOG_MASK(LOG_ALERT) : 0 |
(mask & ILOG_EMERG) ? LOG_MASK(LOG_EMERG) : 0;
setlogmask(msk);
#endif
}
int lowvsyslog(int priority, FAR const IPTR char *fmt, va_list ap)
{
int ret = 0;
/* Check if this priority is enabled */
if ((g_syslog_mask & LOG_MASK(priority)) != 0)
{
/* Yes.. let vsylog_internal to the deed */
ret = lowvsyslog_internal(fmt, ap);
}
return ret;
}
