/*
|
* BlueALSA - log.c
|
* Copyright (c) 2016-2018 Arkadiusz Bokowy
|
*
|
* This file is a part of bluez-alsa.
|
*
|
* This project is licensed under the terms of the MIT license.
|
*
|
*/
|
|
#include "shared/log.h"
|
|
#include <pthread.h>
|
#include <stdarg.h>
|
#include <stdio.h>
|
#include <stdlib.h>
|
#include <string.h>
|
#include <syslog.h>
|
|
#include "shared/rt.h"
|
|
|
/* internal logging identifier */
|
static char *_ident = NULL;
|
/* if true, system logging is enabled */
|
static bool _syslog = false;
|
/* if true, print logging time */
|
static bool _time = BLUEALSA_LOGTIME;
|
|
|
void log_open(const char *ident, bool syslog, bool time) {
|
|
free(_ident);
|
_ident = strdup(ident);
|
|
if ((_syslog = syslog) == true)
|
openlog(ident, 0, LOG_USER);
|
|
_time = time;
|
|
}
|
|
static void vlog(int priority, const char *format, va_list ap) {
|
|
int oldstate;
|
|
/* Threads cancellation is used extensively in the BlueALSA code. In order
|
* to prevent termination within the logging function (which might provide
|
* important information about what has happened), the thread cancellation
|
* has to be temporally disabled. */
|
pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &oldstate);
|
|
//if (_syslog) {
|
va_list ap_syslog;
|
va_copy(ap_syslog, ap);
|
vsyslog(priority, format, ap_syslog);
|
va_end(ap_syslog);
|
//}
|
|
flockfile(stderr);
|
|
if (_ident != NULL)
|
fprintf(stderr, "%s: ", _ident);
|
if (_time) {
|
struct timespec ts;
|
gettimestamp(&ts);
|
fprintf(stderr, "%lu.%.9lu: ", (long int)ts.tv_sec, ts.tv_nsec);
|
}
|
vfprintf(stderr, format, ap);
|
fputs("\n", stderr);
|
|
funlockfile(stderr);
|
|
pthread_setcancelstate(oldstate, NULL);
|
|
}
|
|
void error(const char *format, ...) {
|
va_list ap;
|
va_start(ap, format);
|
vlog(LOG_ERR, format, ap);
|
va_end(ap);
|
}
|
|
void warn(const char *format, ...) {
|
va_list ap;
|
va_start(ap, format);
|
vlog(LOG_WARNING, format, ap);
|
va_end(ap);
|
}
|
|
void info(const char *format, ...) {
|
va_list ap;
|
va_start(ap, format);
|
vlog(LOG_INFO, format, ap);
|
va_end(ap);
|
}
|
|
#if DEBUG
|
void _debug(const char *format, ...) {
|
va_list ap;
|
va_start(ap, format);
|
vlog(LOG_DEBUG, format, ap);
|
va_end(ap);
|
}
|
#endif
|
|
#if DEBUG
|
/**
|
* Dump memory using hexadecimal representation.
|
*
|
* @param label Label printed before the memory block output.
|
* @param mem Address of the memory block.
|
* @param len Number of bytes which should be printed. */
|
void hexdump(const char *label, const void *mem, size_t len) {
|
|
char *buf = malloc(len * 3 + 1);
|
char *p = buf;
|
|
while (len--) {
|
p += sprintf(p, " %02x", *(unsigned char *)mem & 0xFF);
|
mem += 1;
|
}
|
|
fprintf(stderr, "%s:%s\n", label, buf);
|
free(buf);
|
}
|
#endif
|
|
#if DEBUG && HAVE_REGISTER_PRINTF_SPECIFIER
|
/* Register 'B' specifier for printf() function family, so it can
|
* be used to print integer values in a binary representation. */
|
|
#include <printf.h>
|
|
static int printf_arginfo(const struct printf_info *info, size_t n, int *argtypes, int *size) {
|
(void)info;
|
if (n >= 1)
|
argtypes[0] = PA_INT;
|
return *size = 1;
|
}
|
|
static int printf_output(FILE *stream, const struct printf_info *info, const void * const *args) {
|
|
unsigned int v = *(unsigned int *)(args[0]);
|
bool output = false;
|
int len = 0;
|
int i;
|
|
if (info->alt)
|
fputs("0b", stream);
|
|
for (i = (sizeof(v) * 8) - 1; i >= 0; i--) {
|
char c = '0' + ((v >> i) & 1);
|
if (output || c == '1') {
|
fputc(c, stream);
|
output = true;
|
len++;
|
}
|
else if (i == info->width)
|
output = true;
|
}
|
|
return len;
|
}
|
|
void __attribute__ ((constructor)) _register_binary_specifier() {
|
register_printf_specifier('B', printf_output, printf_arginfo);
|
}
|
#endif
|
