usbloadergx/source/libntfs/logging.c

/**
 * logging.c - Centralised logging.  Originated from the Linux-NTFS project.
 *
 * Copyright (c) 2005 Richard Russon
 * Copyright (c) 2005-2008 Szabolcs Szakacsits
 *
 * This program/include file is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as published
 * by the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program/include file is distributed in the hope that it will be
 * useful, but WITHOUT ANY WARRANTY; without even the implied warranty
 * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program (in the main directory of the NTFS-3G
 * distribution in the file COPYING); if not, write to the Free Software
 * Foundation,Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#ifdef HAVE_STDIO_H
#include <stdio.h>
#endif
#ifdef HAVE_ERRNO_H
#include <errno.h>
#endif
#ifdef HAVE_STDARG_H
#include <stdarg.h>
#endif
#ifdef HAVE_STRING_H
#include <string.h>
#endif
#ifdef HAVE_STDLIB_H
#include <stdlib.h>
#endif
#ifdef HAVE_SYSLOG_H
#include <syslog.h>
#endif

#include "logging.h"
#include "misc.h"

#ifndef PATH_SEP
#define PATH_SEP '/'
#endif

#ifdef DEBUG
static int tab;
#endif

/* Some gcc 3.x, 4.[01].X crash with internal compiler error. */
#if __GNUC__ <= 3 || (__GNUC__ == 4 && __GNUC_MINOR__ <= 1)
# define  BROKEN_GCC_FORMAT_ATTRIBUTE
#else
# define  BROKEN_GCC_FORMAT_ATTRIBUTE __attribute__((format(printf, 6, 0)))
#endif

/**
 * struct ntfs_logging - Control info for the logging system
 * @levels:	Bitfield of logging levels
 * @flags:	Flags which affect the output style
 * @handler:	Function to perform the actual logging
 */
struct ntfs_logging {
    u32 levels;
    u32 flags;
    ntfs_log_handler *handler BROKEN_GCC_FORMAT_ATTRIBUTE;
};

/**
 * ntfs_log
 * This struct controls all the logging within the library and tools.
 */
static struct ntfs_logging ntfs_log = {
#ifdef DEBUG
    NTFS_LOG_LEVEL_DEBUG | NTFS_LOG_LEVEL_TRACE | NTFS_LOG_LEVEL_ENTER |
    NTFS_LOG_LEVEL_LEAVE |
#endif
    NTFS_LOG_LEVEL_INFO | NTFS_LOG_LEVEL_QUIET | NTFS_LOG_LEVEL_WARNING |
    NTFS_LOG_LEVEL_ERROR | NTFS_LOG_LEVEL_PERROR | NTFS_LOG_LEVEL_CRITICAL |
    NTFS_LOG_LEVEL_PROGRESS,
    NTFS_LOG_FLAG_ONLYNAME,
#ifdef DEBUG
    ntfs_log_handler_outerr
#else
    ntfs_log_handler_null
#endif
};


/**
 * ntfs_log_get_levels - Get a list of the current logging levels
 *
 * Find out which logging levels are enabled.
 *
 * Returns:  Log levels in a 32-bit field
 */
u32 ntfs_log_get_levels(void) {
    return ntfs_log.levels;
}

/**
 * ntfs_log_set_levels - Enable extra logging levels
 * @levels:	32-bit field of log levels to set
 *
 * Enable one or more logging levels.
 * The logging levels are named: NTFS_LOG_LEVEL_*.
 *
 * Returns:  Log levels that were enabled before the call
 */
u32 ntfs_log_set_levels(u32 levels) {
    u32 old;
    old = ntfs_log.levels;
    ntfs_log.levels |= levels;
    return old;
}

/**
 * ntfs_log_clear_levels - Disable some logging levels
 * @levels:	32-bit field of log levels to clear
 *
 * Disable one or more logging levels.
 * The logging levels are named: NTFS_LOG_LEVEL_*.
 *
 * Returns:  Log levels that were enabled before the call
 */
u32 ntfs_log_clear_levels(u32 levels) {
    u32 old;
    old = ntfs_log.levels;
    ntfs_log.levels &= (~levels);
    return old;
}


/**
 * ntfs_log_get_flags - Get a list of logging style flags
 *
 * Find out which logging flags are enabled.
 *
 * Returns:  Logging flags in a 32-bit field
 */
u32 ntfs_log_get_flags(void) {
    return ntfs_log.flags;
}

/**
 * ntfs_log_set_flags - Enable extra logging style flags
 * @flags:	32-bit field of logging flags to set
 *
 * Enable one or more logging flags.
 * The log flags are named: NTFS_LOG_LEVEL_*.
 *
 * Returns:  Logging flags that were enabled before the call
 */
u32 ntfs_log_set_flags(u32 flags) {
    u32 old;
    old = ntfs_log.flags;
    ntfs_log.flags |= flags;
    return old;
}

/**
 * ntfs_log_clear_flags - Disable some logging styles
 * @flags:	32-bit field of logging flags to clear
 *
 * Disable one or more logging flags.
 * The log flags are named: NTFS_LOG_LEVEL_*.
 *
 * Returns:  Logging flags that were enabled before the call
 */
u32 ntfs_log_clear_flags(u32 flags) {
    u32 old;
    old = ntfs_log.flags;
    ntfs_log.flags &= (~flags);
    return old;
}


/**
 * ntfs_log_get_stream - Default output streams for logging levels
 * @level:	Log level
 *
 * By default, urgent messages are sent to "stderr".
 * Other messages are sent to "stdout".
 *
 * Returns:  "string"  Prefix to be used
 */
static FILE * ntfs_log_get_stream(u32 level) {
    FILE *stream;

    switch (level) {
    case NTFS_LOG_LEVEL_INFO:
    case NTFS_LOG_LEVEL_QUIET:
    case NTFS_LOG_LEVEL_PROGRESS:
    case NTFS_LOG_LEVEL_VERBOSE:
        stream = stdout;
        break;

    case NTFS_LOG_LEVEL_DEBUG:
    case NTFS_LOG_LEVEL_TRACE:
    case NTFS_LOG_LEVEL_ENTER:
    case NTFS_LOG_LEVEL_LEAVE:
    case NTFS_LOG_LEVEL_WARNING:
    case NTFS_LOG_LEVEL_ERROR:
    case NTFS_LOG_LEVEL_CRITICAL:
    case NTFS_LOG_LEVEL_PERROR:
    default:
        stream = stderr;
        break;
    }

    return stream;
}

/**
 * ntfs_log_get_prefix - Default prefixes for logging levels
 * @level:	Log level to be prefixed
 *
 * Prefixing the logging output can make it easier to parse.
 *
 * Returns:  "string"  Prefix to be used
 */
static const char * ntfs_log_get_prefix(u32 level) {
    const char *prefix;

    switch (level) {
    case NTFS_LOG_LEVEL_DEBUG:
        prefix = "DEBUG: ";
        break;
    case NTFS_LOG_LEVEL_TRACE:
        prefix = "TRACE: ";
        break;
    case NTFS_LOG_LEVEL_QUIET:
        prefix = "QUIET: ";
        break;
    case NTFS_LOG_LEVEL_INFO:
        prefix = "INFO: ";
        break;
    case NTFS_LOG_LEVEL_VERBOSE:
        prefix = "VERBOSE: ";
        break;
    case NTFS_LOG_LEVEL_PROGRESS:
        prefix = "PROGRESS: ";
        break;
    case NTFS_LOG_LEVEL_WARNING:
        prefix = "WARNING: ";
        break;
    case NTFS_LOG_LEVEL_ERROR:
        prefix = "ERROR: ";
        break;
    case NTFS_LOG_LEVEL_PERROR:
        prefix = "ERROR: ";
        break;
    case NTFS_LOG_LEVEL_CRITICAL:
        prefix = "CRITICAL: ";
        break;
    default:
        prefix = "";
        break;
    }

    return prefix;
}


/**
 * ntfs_log_set_handler - Provide an alternate logging handler
 * @handler:	function to perform the logging
 *
 * This alternate handler will be called for all future logging requests.
 * If no @handler is specified, logging will revert to the default handler.
 */
void ntfs_log_set_handler(ntfs_log_handler *handler) {
    if (handler) {
        ntfs_log.handler = handler;
#ifdef HAVE_SYSLOG_H
        if (handler == ntfs_log_handler_syslog)
            openlog("ntfs-3g", LOG_PID, LOG_USER);
#endif
    } else
        ntfs_log.handler = ntfs_log_handler_null;
}

/**
 * ntfs_log_redirect - Pass on the request to the real handler
 * @function:	Function in which the log line occurred
 * @file:	File in which the log line occurred
 * @line:	Line number on which the log line occurred
 * @level:	Level at which the line is logged
 * @data:	User specified data, possibly specific to a handler
 * @format:	printf-style formatting string
 * @...:	Arguments to be formatted
 *
 * This is just a redirector function.  The arguments are simply passed to the
 * main logging handler (as defined in the global logging struct @ntfs_log).
 *
 * Returns:  -1  Error occurred
 *            0  Message wasn't logged
 *          num  Number of output characters
 */
int ntfs_log_redirect(const char *function, const char *file,
                      int line, u32 level, void *data, const char *format, ...) {
    int olderr = errno;
    int ret;
    va_list args;

    if (!(ntfs_log.levels & level))		/* Don't log this message */
        return 0;

    va_start(args, format);
    errno = olderr;
    ret = ntfs_log.handler(function, file, line, level, data, format, args);
    va_end(args);

    errno = olderr;
    return ret;
}


/**
 * ntfs_log_handler_syslog - syslog logging handler
 * @function:	Function in which the log line occurred
 * @file:	File in which the log line occurred
 * @line:	Line number on which the log line occurred
 * @level:	Level at which the line is logged
 * @data:	User specified data, possibly specific to a handler
 * @format:	printf-style formatting string
 * @args:	Arguments to be formatted
 *
 * A simple syslog logging handler.  Ignores colors.
 *
 * Returns:  -1  Error occurred
 *            0  Message wasn't logged
 *          num  Number of output characters
 */


#ifdef HAVE_SYSLOG_H

#define LOG_LINE_LEN 	512

int ntfs_log_handler_syslog(const char *function  __attribute__((unused)),
                            const char *file __attribute__((unused)),
                            int line __attribute__((unused)), u32 level,
                            void *data __attribute__((unused)),
                            const char *format, va_list args) {
    char logbuf[LOG_LINE_LEN];
    int ret, olderr = errno;

#ifndef DEBUG
    if ((level & NTFS_LOG_LEVEL_PERROR) && errno == ENOSPC)
        return 1;
#endif
    ret = vsnprintf(logbuf, LOG_LINE_LEN, format, args);
    if (ret < 0) {
        vsyslog(LOG_NOTICE, format, args);
        ret = 1;
        goto out;
    }

    if ((LOG_LINE_LEN > ret + 3) && (level & NTFS_LOG_LEVEL_PERROR)) {
        strncat(logbuf, ": ", LOG_LINE_LEN - ret - 1);
        strncat(logbuf, strerror(olderr), LOG_LINE_LEN - (ret + 3));
        ret = strlen(logbuf);
    }

    syslog(LOG_NOTICE, "%s", logbuf);
out:
    errno = olderr;
    return ret;
}
#endif

/**
 * ntfs_log_handler_fprintf - Basic logging handler
 * @function:	Function in which the log line occurred
 * @file:	File in which the log line occurred
 * @line:	Line number on which the log line occurred
 * @level:	Level at which the line is logged
 * @data:	User specified data, possibly specific to a handler
 * @format:	printf-style formatting string
 * @args:	Arguments to be formatted
 *
 * A simple logging handler.  This is where the log line is finally displayed.
 * It is more likely that you will want to set the handler to either
 * ntfs_log_handler_outerr or ntfs_log_handler_stderr.
 *
 * Note: For this handler, @data is a pointer to a FILE output stream.
 *       If @data is NULL, nothing will be displayed.
 *
 * Returns:  -1  Error occurred
 *            0  Message wasn't logged
 *          num  Number of output characters
 */
int ntfs_log_handler_fprintf(const char *function, const char *file,
                             int line, u32 level, void *data, const char *format, va_list args) {
#ifdef DEBUG
    int i;
#endif
    int ret = 0;
    int olderr = errno;
    FILE *stream;

    if (!data)		/* Interpret data as a FILE stream. */
        return 0;	/* If it's NULL, we can't do anything. */
    stream = (FILE*)data;

#ifdef DEBUG
    if (level == NTFS_LOG_LEVEL_LEAVE) {
        if (tab)
            tab--;
        return 0;
    }

    for (i = 0; i < tab; i++)
        ret += fprintf(stream, " ");
#endif
    if ((ntfs_log.flags & NTFS_LOG_FLAG_ONLYNAME) &&
            (strchr(file, PATH_SEP)))		/* Abbreviate the filename */
        file = strrchr(file, PATH_SEP) + 1;

    if (ntfs_log.flags & NTFS_LOG_FLAG_PREFIX)	/* Prefix the output */
        ret += fprintf(stream, "%s", ntfs_log_get_prefix(level));

    if (ntfs_log.flags & NTFS_LOG_FLAG_FILENAME)	/* Source filename */
        ret += fprintf(stream, "%s ", file);

    if (ntfs_log.flags & NTFS_LOG_FLAG_LINE)	/* Source line number */
        ret += fprintf(stream, "(%d) ", line);

    if ((ntfs_log.flags & NTFS_LOG_FLAG_FUNCTION) || /* Source function */
            (level & NTFS_LOG_LEVEL_TRACE) || (level & NTFS_LOG_LEVEL_ENTER))
        ret += fprintf(stream, "%s(): ", function);

    ret += vfprintf(stream, format, args);

    if (level & NTFS_LOG_LEVEL_PERROR)
        ret += fprintf(stream, ": %s\n", strerror(olderr));

#ifdef DEBUG
    if (level == NTFS_LOG_LEVEL_ENTER)
        tab++;
#endif
    fflush(stream);
    errno = olderr;
    return ret;
}

/**
 * ntfs_log_handler_null - Null logging handler (no output)
 * @function:	Function in which the log line occurred
 * @file:	File in which the log line occurred
 * @line:	Line number on which the log line occurred
 * @level:	Level at which the line is logged
 * @data:	User specified data, possibly specific to a handler
 * @format:	printf-style formatting string
 * @args:	Arguments to be formatted
 *
 * This handler produces no output.  It provides a way to temporarily disable
 * logging, without having to change the levels and flags.
 *
 * Returns:  0  Message wasn't logged
 */
int ntfs_log_handler_null(const char *function __attribute__((unused)), const char *file __attribute__((unused)),
                          int line __attribute__((unused)), u32 level __attribute__((unused)), void *data __attribute__((unused)),
                          const char *format __attribute__((unused)), va_list args __attribute__((unused))) {
    return 0;
}

/**
 * ntfs_log_handler_stdout - All logs go to stdout
 * @function:	Function in which the log line occurred
 * @file:	File in which the log line occurred
 * @line:	Line number on which the log line occurred
 * @level:	Level at which the line is logged
 * @data:	User specified data, possibly specific to a handler
 * @format:	printf-style formatting string
 * @args:	Arguments to be formatted
 *
 * Display a log message to stdout.
 *
 * Note: For this handler, @data is a pointer to a FILE output stream.
 *       If @data is NULL, then stdout will be used.
 *
 * Note: This function calls ntfs_log_handler_fprintf to do the main work.
 *
 * Returns:  -1  Error occurred
 *            0  Message wasn't logged
 *          num  Number of output characters
 */
int ntfs_log_handler_stdout(const char *function, const char *file,
                            int line, u32 level, void *data, const char *format, va_list args) {
    if (!data)
        data = stdout;

    return ntfs_log_handler_fprintf(function, file, line, level, data, format, args);
}

/**
 * ntfs_log_handler_outerr - Logs go to stdout/stderr depending on level
 * @function:	Function in which the log line occurred
 * @file:	File in which the log line occurred
 * @line:	Line number on which the log line occurred
 * @level:	Level at which the line is logged
 * @data:	User specified data, possibly specific to a handler
 * @format:	printf-style formatting string
 * @args:	Arguments to be formatted
 *
 * Display a log message.  The output stream will be determined by the log
 * level.
 *
 * Note: For this handler, @data is a pointer to a FILE output stream.
 *       If @data is NULL, the function ntfs_log_get_stream will be called
 *
 * Note: This function calls ntfs_log_handler_fprintf to do the main work.
 *
 * Returns:  -1  Error occurred
 *            0  Message wasn't logged
 *          num  Number of output characters
 */
int ntfs_log_handler_outerr(const char *function, const char *file,
                            int line, u32 level, void *data, const char *format, va_list args) {
    if (!data)
        data = ntfs_log_get_stream(level);

    return ntfs_log_handler_fprintf(function, file, line, level, data, format, args);
}

/**
 * ntfs_log_handler_stderr - All logs go to stderr
 * @function:	Function in which the log line occurred
 * @file:	File in which the log line occurred
 * @line:	Line number on which the log line occurred
 * @level:	Level at which the line is logged
 * @data:	User specified data, possibly specific to a handler
 * @format:	printf-style formatting string
 * @args:	Arguments to be formatted
 *
 * Display a log message to stderr.
 *
 * Note: For this handler, @data is a pointer to a FILE output stream.
 *       If @data is NULL, then stdout will be used.
 *
 * Note: This function calls ntfs_log_handler_fprintf to do the main work.
 *
 * Returns:  -1  Error occurred
 *            0  Message wasn't logged
 *          num  Number of output characters
 */
int ntfs_log_handler_stderr(const char *function, const char *file,
                            int line, u32 level, void *data, const char *format, va_list args) {
    if (!data)
        data = stderr;

    return ntfs_log_handler_fprintf(function, file, line, level, data, format, args);
}


/**
 * ntfs_log_parse_option - Act upon command line options
 * @option:	Option flag
 *
 * Delegate some of the work of parsing the command line.  All the options begin
 * with "--log-".  Options cause log levels to be enabled in @ntfs_log (the
 * global logging structure).
 *
 * Note: The "colour" option changes the logging handler.
 *
 * Returns:  TRUE  Option understood
 *          FALSE  Invalid log option
 */
BOOL ntfs_log_parse_option(const char *option) {
    if (strcmp(option, "--log-debug") == 0) {
        ntfs_log_set_levels(NTFS_LOG_LEVEL_DEBUG);
        return TRUE;
    } else if (strcmp(option, "--log-verbose") == 0) {
        ntfs_log_set_levels(NTFS_LOG_LEVEL_VERBOSE);
        return TRUE;
    } else if (strcmp(option, "--log-quiet") == 0) {
        ntfs_log_clear_levels(NTFS_LOG_LEVEL_QUIET);
        return TRUE;
    } else if (strcmp(option, "--log-trace") == 0) {
        ntfs_log_set_levels(NTFS_LOG_LEVEL_TRACE);
        return TRUE;
    }

    ntfs_log_debug("Unknown logging option '%s'\n", option);
    return FALSE;
}