static int scconf_replace_str_list(scconf_block * block, const char *option, const char *value)
{
scconf_list *list = NULL;
scconf_item *item;
char *lstitem = NULL;
char *next;
while (value != NULL) {
if ((next=strchr(value, ',')) != NULL) {
lstitem = strndup(value, next-value);
next++;
}
else {
lstitem = strdup(value);
}
if (lstitem == NULL)
return 1;
scconf_list_add(&list, lstitem);
value = next;
free(lstitem);
}
item = scconf_item_add(NULL, block, NULL, SCCONF_ITEM_TYPE_VALUE, option, list);
/* now clear out the item list */
scconf_list_destroy(item->value.list);
item->value.list = list; /* adopt */
return 0;
}
void scconf_item_destroy(scconf_item * item)
{
scconf_item *next;
while (item) {
next = item->next;
switch (item->type) {
case SCCONF_ITEM_TYPE_COMMENT:
if (item->value.comment) {
free(item->value.comment);
}
item->value.comment = NULL;
break;
case SCCONF_ITEM_TYPE_BLOCK:
scconf_block_destroy(item->value.block);
break;
case SCCONF_ITEM_TYPE_VALUE:
scconf_list_destroy(item->value.list);
break;
}
if (item->key) {
free(item->key);
}
item->key = NULL;
free(item);
item = next;
}
}
void scconf_block_destroy(scconf_block * block)
{
if (block) {
scconf_list_destroy(block->name);
scconf_item_destroy(block->items);
free(block);
}
}
const char *scconf_put_str(scconf_block * block, const char *option, const char *value)
{
scconf_list *list = NULL;
scconf_list_add(&list, value);
scconf_item_add(NULL, block, NULL, SCCONF_ITEM_TYPE_VALUE, option, list);
scconf_list_destroy(list);
return value;
}
static void scconf_parse_reset_state(scconf_parser * parser)
{
if (parser) {
if (parser->key) {
free(parser->key);
}
scconf_list_destroy(parser->name);
parser->key = NULL;
parser->name = NULL;
parser->state = 0;
}
}
static const char *scconf_replace_str(scconf_block * block, const char *option, const char *value)
{
scconf_list *list = NULL;
scconf_item *item;
scconf_list_add(&list, value);
item = scconf_item_add(NULL, block, NULL, SCCONF_ITEM_TYPE_VALUE, option, list);
/* now clear out the item list */
scconf_list_destroy(item->value.list);
item->value.list = list; /* adopt */
return value;
}
scconf_item *scconf_item_add(scconf_context * config, scconf_block * block, scconf_item * item, int type, const char *key, const void *data)
{
scconf_parser parser;
scconf_block *dst = NULL;
if (!config && !block)
return NULL;
if (!data)
return NULL;
memset(&parser, 0, sizeof(scconf_parser));
parser.config = config ? config : NULL;
parser.key = key ? strdup(key) : NULL;
parser.block = block ? block : config->root;
parser.name = NULL;
parser.last_item = scconf_get_last_item(parser.block);
parser.current_item = item;
if (type == SCCONF_ITEM_TYPE_BLOCK) {
scconf_block_copy((const scconf_block *) data, &dst);
scconf_list_copy(dst->name, &parser.name);
}
scconf_item_add_internal(&parser, type);
if (parser.current_item) {
switch (parser.current_item->type) {
case SCCONF_ITEM_TYPE_COMMENT:
parser.current_item->value.comment = strdup((const char *) data);
break;
case SCCONF_ITEM_TYPE_BLOCK:
if (!dst)
return NULL;
dst->parent = parser.block;
parser.current_item->value.block = dst;
scconf_list_destroy(parser.name);
break;
case SCCONF_ITEM_TYPE_VALUE:
scconf_list_copy((const scconf_list *) data, &parser.current_item->value.list);
break;
}
} else {
/* FIXME is it an error if item is NULL? */
}
return parser.current_item;
}
int main(int argc, char **argv)
{
#ifdef ADD_TEST
scconf_block *foo_block = NULL;
scconf_item *foo_item = NULL;
scconf_list *foo_list = NULL;
#endif
scconf_context *conf = NULL;
scconf_entry entry[] =
{
{"ldap", SCCONF_CALLBACK, SCCONF_VERBOSE | SCCONF_ALL_BLOCKS, (void *) ldap_cb, NULL},
{"card", SCCONF_CALLBACK, SCCONF_VERBOSE | SCCONF_ALL_BLOCKS, (void *) card_cb, NULL},
{NULL, 0, 0, NULL, NULL}
};
char *in = NULL, *out = NULL;
int r;
if (argc != 3) {
printf("Usage: test-conf <in.conf> <out.conf>\n");
return 1;
}
in = argv[argc - 2];
out = argv[argc - 1];
conf = scconf_new(in);
if (!conf) {
printf("scconf_new failed\n");
return 1;
}
if (scconf_parse(conf) < 1) {
printf("scconf_parse failed: %s\n", conf->errmsg);
scconf_free(conf);
return 1;
}
conf->debug = 1;
if (scconf_parse_entries(conf, NULL, entry) != 0) {
printf("scconf_parse_entries failed\n");
scconf_free(conf);
return 1;
}
#ifdef ADD_TEST
scconf_list_add(&foo_list, "value1");
scconf_list_add(&foo_list, "value2");
foo_block = (scconf_block *) scconf_find_block(conf, NULL, "foo");
foo_block = scconf_block_add(conf, foo_block, "block1", foo_list);
foo_block = scconf_block_add(conf, foo_block, "block2", foo_list);
scconf_list_add(&foo_list, "value3");
/* this will not segfault as type SCCONF_ITEM_TYPE_COMMENT is used */
scconf_item_add(conf, foo_block, foo_item, SCCONF_ITEM_TYPE_COMMENT, NULL, "# comment1");
scconf_item_add(conf, foo_block, foo_item, SCCONF_ITEM_TYPE_VALUE, "list1", foo_list);
foo_block = NULL;
scconf_item_add(conf, foo_block, foo_item, SCCONF_ITEM_TYPE_BLOCK, "block3", (void *) scconf_find_block(conf, NULL, "foo"));
scconf_item_add(conf, foo_block, foo_item, SCCONF_ITEM_TYPE_VALUE, "list2", foo_list);
scconf_item_add(conf, foo_block, foo_item, SCCONF_ITEM_TYPE_COMMENT, NULL, "# comment2");
if (write_entries(conf, foo_list) != 0) {
printf("scconf_write_entries failed\n");
scconf_free(conf);
return 1;
}
scconf_list_destroy(foo_list);
#endif
if ((r = scconf_write(conf, out)) != 0) {
printf("scconf_write: %s\n", strerror(r));
} else {
printf("Successfully rewrote file \"%s\" as \"%s\"\n", in, out);
}
scconf_free(conf);
return 0;
}
int sc_context_create(sc_context_t **ctx_out, const sc_context_param_t *parm)
{
sc_context_t *ctx;
struct _sc_ctx_options opts;
int r;
char *driver;
if (ctx_out == NULL || parm == NULL)
return SC_ERROR_INVALID_ARGUMENTS;
ctx = calloc(1, sizeof(sc_context_t));
if (ctx == NULL)
return SC_ERROR_OUT_OF_MEMORY;
memset(&opts, 0, sizeof(opts));
/* set the application name if set in the parameter options */
if (parm->app_name != NULL)
ctx->app_name = strdup(parm->app_name);
else
ctx->app_name = strdup("default");
if (ctx->app_name == NULL) {
sc_release_context(ctx);
return SC_ERROR_OUT_OF_MEMORY;
}
ctx->flags = parm->flags;
set_defaults(ctx, &opts);
if (0 != list_init(&ctx->readers)) {
sc_release_context(ctx);
return SC_ERROR_OUT_OF_MEMORY;
}
list_attributes_seeker(&ctx->readers, reader_list_seeker);
/* set thread context and create mutex object (if specified) */
if (parm->thread_ctx != NULL)
ctx->thread_ctx = parm->thread_ctx;
r = sc_mutex_create(ctx, &ctx->mutex);
if (r != SC_SUCCESS) {
sc_release_context(ctx);
return r;
}
#if defined(ENABLE_OPENSSL) && defined(OPENSSL_SECURE_MALLOC_SIZE)
if (!CRYPTO_secure_malloc_initialized()) {
CRYPTO_secure_malloc_init(OPENSSL_SECURE_MALLOC_SIZE, OPENSSL_SECURE_MALLOC_SIZE/8);
}
#endif
process_config_file(ctx, &opts);
sc_log(ctx, "==================================="); /* first thing in the log */
sc_log(ctx, "opensc version: %s", sc_get_version());
#ifdef ENABLE_PCSC
ctx->reader_driver = sc_get_pcsc_driver();
#elif defined(ENABLE_CRYPTOTOKENKIT)
ctx->reader_driver = sc_get_cryptotokenkit_driver();
#elif defined(ENABLE_CTAPI)
ctx->reader_driver = sc_get_ctapi_driver();
#elif defined(ENABLE_OPENCT)
ctx->reader_driver = sc_get_openct_driver();
#endif
r = ctx->reader_driver->ops->init(ctx);
if (r != SC_SUCCESS) {
sc_release_context(ctx);
return r;
}
driver = getenv("OPENSC_DRIVER");
if (driver) {
scconf_list *list = NULL;
scconf_list_add(&list, driver);
set_drivers(&opts, list);
scconf_list_destroy(list);
}
load_card_drivers(ctx, &opts);
load_card_atrs(ctx);
del_drvs(&opts);
sc_ctx_detect_readers(ctx);
*ctx_out = ctx;
return SC_SUCCESS;
}
