libjaylink/log.c

   1 /*
   2  * This file is part of the libjaylink project.
   3  *
   4  * Copyright (C) 2014-2015 Marc Schink <jaylink-dev@marcschink.de>
   5  *
   6  * This program is free software: you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation, either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 #ifdef HAVE_CONFIG_H
  21 #include "config.h"
  22 #endif
  23
  24 #include <stdio.h>
  25 #include <stdarg.h>
  26
  27 #include "libjaylink.h"
  28 #include "libjaylink-internal.h"
  29
  30 /**
  31  * @file
  32  *
  33  * Logging functions.
  34  */
  35
  36 /**
  37  * Set the libjaylink log level.
  38  *
  39  * @param[in,out] ctx libjaylink context.
  40  * @param[in] level Log level to set.
  41  *
  42  * @retval JAYLINK_OK Success.
  43  * @retval JAYLINK_ERR_ARG Invalid arguments.
  44  *
  45  * @since 0.1.0
  46  */
  47 JAYLINK_API int jaylink_log_set_level(struct jaylink_context *ctx,
  48                 enum jaylink_log_level level)
  49 {
  50         if (!ctx)
  51                 return JAYLINK_ERR_ARG;
  52
  53         if (level > JAYLINK_LOG_LEVEL_DEBUG_IO)
  54                 return JAYLINK_ERR_ARG;
  55
  56         ctx->log_level = level;
  57
  58         return JAYLINK_OK;
  59 }
  60
  61 /**
  62  * Get the libjaylink log level.
  63  *
  64  * @param[in] ctx libjaylink context.
  65  * @param[out] level Log level on success, and undefined on failure.
  66  *
  67  * @retval JAYLINK_OK Success.
  68  * @retval JAYLINK_ERR_ARG Invalid arguments.
  69  *
  70  * @since 0.1.0
  71  */
  72 JAYLINK_API int jaylink_log_get_level(const struct jaylink_context *ctx,
  73                 enum jaylink_log_level *level)
  74 {
  75         if (!ctx || !level)
  76                 return JAYLINK_ERR_ARG;
  77
  78         *level = ctx->log_level;
  79
  80         return JAYLINK_OK;
  81 }
  82
  83 /**
  84  * Set the libjaylink log callback function.
  85  *
  86  * @param[in,out] ctx libjaylink context.
  87  * @param[in] callback Callback function to use, or NULL to use the default log
  88  *                     function.
  89  * @param[in] user_data User data to be passed to the callback function.
  90  *
  91  * @retval JAYLINK_OK Success.
  92  * @retval JAYLINK_ERR_ARG Invalid arguments.
  93  *
  94  * @since 0.1.0
  95  */
  96 JAYLINK_API int jaylink_log_set_callback(struct jaylink_context *ctx,
  97                 jaylink_log_callback callback, void *user_data)
  98 {
  99         if (!ctx)
 100                 return JAYLINK_ERR_ARG;
 101
 102         if (callback) {
 103                 ctx->log_callback = callback;
 104                 ctx->log_callback_data = user_data;
 105         } else {
 106                 ctx->log_callback = &log_vprintf;
 107                 ctx->log_callback_data = NULL;
 108         }
 109
 110         return JAYLINK_OK;
 111 }
 112
 113 /**
 114  * Set the libjaylink log domain.
 115  *
 116  * The log domain is a string which is used as prefix for all log messages to
 117  * differentiate them from messages of other libraries.
 118  *
 119  * The maximum length of the log domain is #JAYLINK_LOG_DOMAIN_MAX_LENGTH
 120  * bytes, excluding the trailing null-terminator. A log domain which exceeds
 121  * this length will be silently truncated.
 122  *
 123  * @param[in,out] ctx libjaylink context.
 124  * @param[in] domain Log domain to use. To set the default log domain, use
 125  *                   #JAYLINK_LOG_DOMAIN_DEFAULT.
 126  *
 127  * @retval JAYLINK_OK Success.
 128  * @retval JAYLINK_ERR_ARG Invalid arguments.
 129  * @retval JAYLINK_ERR Other error conditions.
 130  *
 131  * @since 0.1.0
 132  */
 133 JAYLINK_API int jaylink_log_set_domain(struct jaylink_context *ctx,
 134                 const char *domain)
 135 {
 136         int ret;
 137
 138         if (!ctx || !domain)
 139                 return JAYLINK_ERR_ARG;
 140
 141         ret = snprintf(ctx->log_domain, JAYLINK_LOG_DOMAIN_MAX_LENGTH + 1,
 142                 "%s", domain);
 143
 144         if (ret < 0)
 145                 return JAYLINK_ERR;
 146
 147         return JAYLINK_OK;
 148 }
 149
 150 /**
 151  * Get the libjaylink log domain.
 152  *
 153  * @param[in] ctx libjaylink context.
 154  *
 155  * @return A string which contains the current log domain on success, or NULL
 156  *         on failure. The string is null-terminated and must not be free'd by
 157  *         the caller.
 158  *
 159  * @since 0.1.0
 160  */
 161 JAYLINK_API const char *jaylink_log_get_domain(
 162                 const struct jaylink_context *ctx)
 163 {
 164         if (!ctx)
 165                 return NULL;
 166
 167         return ctx->log_domain;
 168 }
 169
 170 /** @private */
 171 JAYLINK_PRIV int log_vprintf(const struct jaylink_context *ctx,
 172                 enum jaylink_log_level level, const char *format, va_list args,
 173                 void *user_data)
 174 {
 175         (void)user_data;
 176
 177         /*
 178          * Filter out messages with higher verbosity than the verbosity of the
 179          * current log level.
 180          */
 181         if (level > ctx->log_level)
 182                 return 0;
 183
 184         if (ctx->log_domain[0] != '\0')
 185                 fprintf(stderr, "%s", ctx->log_domain);
 186
 187         vfprintf(stderr, format, args);
 188         fprintf(stderr, "\n");
 189
 190         return 0;
 191 }
 192
 193 /** @private */
 194 JAYLINK_PRIV void log_err(const struct jaylink_context *ctx,
 195                 const char *format, ...)
 196 {
 197         va_list args;
 198
 199         if (!ctx)
 200                 return;
 201
 202         va_start(args, format);
 203         ctx->log_callback(ctx, JAYLINK_LOG_LEVEL_ERROR, format, args,
 204                 ctx->log_callback_data);
 205         va_end(args);
 206 }
 207
 208 /** @private */
 209 JAYLINK_PRIV void log_warn(const struct jaylink_context *ctx,
 210                 const char *format, ...)
 211 {
 212         va_list args;
 213
 214         if (!ctx)
 215                 return;
 216
 217         va_start(args, format);
 218         ctx->log_callback(ctx, JAYLINK_LOG_LEVEL_WARNING, format, args,
 219                 ctx->log_callback_data);
 220         va_end(args);
 221 }
 222
 223 /** @private */
 224 JAYLINK_PRIV void log_info(const struct jaylink_context *ctx,
 225                 const char *format, ...)
 226 {
 227         va_list args;
 228
 229         if (!ctx)
 230                 return;
 231
 232         va_start(args, format);
 233         ctx->log_callback(ctx, JAYLINK_LOG_LEVEL_INFO, format, args,
 234                 ctx->log_callback_data);
 235         va_end(args);
 236 }
 237
 238 /** @private */
 239 JAYLINK_PRIV void log_dbg(const struct jaylink_context *ctx,
 240                 const char *format, ...)
 241 {
 242         va_list args;
 243
 244         if (!ctx)
 245                 return;
 246
 247         va_start(args, format);
 248         ctx->log_callback(ctx, JAYLINK_LOG_LEVEL_DEBUG, format, args,
 249                 ctx->log_callback_data);
 250         va_end(args);
 251 }
 252
 253 /** @private */
 254 JAYLINK_PRIV void log_dbgio(const struct jaylink_context *ctx,
 255                 const char *format, ...)
 256 {
 257         va_list args;
 258
 259         if (!ctx)
 260                 return;
 261
 262         va_start(args, format);
 263         ctx->log_callback(ctx, JAYLINK_LOG_LEVEL_DEBUG_IO, format, args,
 264                 ctx->log_callback_data);
 265         va_end(args);
 266 }