blob: cbbc16a6afb7bf8d44c75054af979498c36d4a10 [file] [log] [blame]
/*
abc - something with abc
Copyright (C) 2011 Someone <someone@example.com>
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library 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
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include <stdio.h>
#include <stdlib.h>
#include <stddef.h>
#include <stdarg.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <ctype.h>
#include <abc/libabc.h>
#include "libabc-private.h"
/**
* SECTION:libabc
* @short_description: libabc context
*
* The context contains the default values for the library user,
* and is passed to all library operations.
*/
/**
* abc_ctx:
*
* Opaque object representing the library context.
*/
struct abc_ctx {
int refcount;
void (*log_fn)(struct abc_ctx *ctx,
int priority, const char *file, int line, const char *fn,
const char *format, va_list args);
void *userdata;
int log_priority;
};
void abc_log(struct abc_ctx *ctx,
int priority, const char *file, int line, const char *fn,
const char *format, ...)
{
va_list args;
va_start(args, format);
ctx->log_fn(ctx, priority, file, line, fn, format, args);
va_end(args);
}
static void log_stderr(struct abc_ctx *ctx,
int priority, const char *file, int line, const char *fn,
const char *format, va_list args)
{
fprintf(stderr, "libabc: %s: ", fn);
vfprintf(stderr, format, args);
}
/**
* abc_get_userdata:
* @ctx: abc library context
*
* Retrieve stored data pointer from library context. This might be useful
* to access from callbacks like a custom logging function.
*
* Returns: stored userdata
**/
ABC_EXPORT void *abc_get_userdata(struct abc_ctx *ctx)
{
if (ctx == NULL)
return NULL;
return ctx->userdata;
}
/**
* abc_set_userdata:
* @ctx: abc library context
* @userdata: data pointer
*
* Store custom @userdata in the library context.
**/
ABC_EXPORT void abc_set_userdata(struct abc_ctx *ctx, void *userdata)
{
if (ctx == NULL)
return;
ctx->userdata = userdata;
}
static int log_priority(const char *priority)
{
char *endptr;
int prio;
prio = strtol(priority, &endptr, 10);
if (endptr[0] == '\0' || isspace(endptr[0]))
return prio;
if (strncmp(priority, "err", 3) == 0)
return LOG_ERR;
if (strncmp(priority, "info", 4) == 0)
return LOG_INFO;
if (strncmp(priority, "debug", 5) == 0)
return LOG_DEBUG;
return 0;
}
/**
* abc_new:
*
* Create abc library context. This reads the abc configuration
* and fills in the default values.
*
* The initial refcount is 1, and needs to be decremented to
* release the resources of the abc library context.
*
* Returns: a new abc library context
**/
ABC_EXPORT int abc_new(struct abc_ctx **ctx)
{
const char *env;
struct abc_ctx *c;
c = calloc(1, sizeof(struct abc_ctx));
if (!c)
return -ENOMEM;
c->refcount = 1;
c->log_fn = log_stderr;
c->log_priority = LOG_ERR;
/* environment overwrites config */
env = secure_getenv("ABC_LOG");
if (env != NULL)
abc_set_log_priority(c, log_priority(env));
info(c, "ctx %p created\n", c);
dbg(c, "log_priority=%d\n", c->log_priority);
*ctx = c;
return 0;
}
/**
* abc_ref:
* @ctx: abc library context
*
* Take a reference of the abc library context.
*
* Returns: the passed abc library context
**/
ABC_EXPORT struct abc_ctx *abc_ref(struct abc_ctx *ctx)
{
if (ctx == NULL)
return NULL;
ctx->refcount++;
return ctx;
}
/**
* abc_unref:
* @ctx: abc library context
*
* Drop a reference of the abc library context. If the refcount
* reaches zero, the resources of the context will be released.
*
**/
ABC_EXPORT struct abc_ctx *abc_unref(struct abc_ctx *ctx)
{
if (ctx == NULL)
return NULL;
ctx->refcount--;
if (ctx->refcount > 0)
return ctx;
info(ctx, "context %p released\n", ctx);
free(ctx);
return NULL;
}
/**
* abc_set_log_fn:
* @ctx: abc library context
* @log_fn: function to be called for logging messages
*
* The built-in logging writes to stderr. It can be
* overridden by a custom function, to plug log messages
* into the user's logging functionality.
*
**/
ABC_EXPORT void abc_set_log_fn(struct abc_ctx *ctx,
void (*log_fn)(struct abc_ctx *ctx,
int priority, const char *file,
int line, const char *fn,
const char *format, va_list args))
{
ctx->log_fn = log_fn;
info(ctx, "custom logging function %p registered\n", log_fn);
}
/**
* abc_get_log_priority:
* @ctx: abc library context
*
* Returns: the current logging priority
**/
ABC_EXPORT int abc_get_log_priority(struct abc_ctx *ctx)
{
return ctx->log_priority;
}
/**
* abc_set_log_priority:
* @ctx: abc library context
* @priority: the new logging priority
*
* Set the current logging priority. The value controls which messages
* are logged.
**/
ABC_EXPORT void abc_set_log_priority(struct abc_ctx *ctx, int priority)
{
ctx->log_priority = priority;
}
struct abc_list_entry;
struct abc_list_entry *abc_list_entry_get_next(struct abc_list_entry *list_entry);
const char *abc_list_entry_get_name(struct abc_list_entry *list_entry);
const char *abc_list_entry_get_value(struct abc_list_entry *list_entry);
struct abc_thing {
struct abc_ctx *ctx;
int refcount;
};
ABC_EXPORT struct abc_thing *abc_thing_ref(struct abc_thing *thing)
{
if (!thing)
return NULL;
thing->refcount++;
return thing;
}
ABC_EXPORT struct abc_thing *abc_thing_unref(struct abc_thing *thing)
{
if (thing == NULL)
return NULL;
thing->refcount--;
if (thing->refcount > 0)
return thing;
dbg(thing->ctx, "context %p released\n", thing);
free(thing);
return NULL;
}
ABC_EXPORT struct abc_ctx *abc_thing_get_ctx(struct abc_thing *thing)
{
return thing->ctx;
}
ABC_EXPORT int abc_thing_new_from_string(struct abc_ctx *ctx, const char *string, struct abc_thing **thing)
{
struct abc_thing *t;
t = calloc(1, sizeof(struct abc_thing));
if (!t)
return -ENOMEM;
t->refcount = 1;
t->ctx = ctx;
*thing = t;
return 0;
}
ABC_EXPORT struct abc_list_entry *abc_thing_get_some_list_entry(struct abc_thing *thing)
{
return NULL;
}