xref: /external/ltrace/prototype.c

/*
 * This file is part of ltrace.
 * Copyright (C) 2012 Petr Machata, Red Hat Inc.
 *
 * This program 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 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; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
 * 02110-1301 USA
 */

#include <alloca.h>
#include <errno.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>

#include "callback.h"
#include "param.h"
#include "prototype.h"
#include "type.h"
#include "options.h"
#include "read_config_file.h"
#include "backend.h"

struct protolib_cache g_protocache;
static struct protolib legacy_typedefs;

void
prototype_init(struct prototype *proto)
{
	VECT_INIT(&proto->params, struct param);

	proto->return_info = NULL;
	proto->own_return_info = 0;
}

static void
param_destroy_cb(struct param *param, void *data)
{
	param_destroy(param);
}

void
prototype_destroy(struct prototype *proto)
{
	if (proto == NULL)
		return;
	if (proto->own_return_info) {
		type_destroy(proto->return_info);
		free(proto->return_info);
	}

	VECT_DESTROY(&proto->params, struct param, &param_destroy_cb, NULL);
}

int
prototype_push_param(struct prototype *proto, struct param *param)
{
	return VECT_PUSHBACK(&proto->params, param);
}

size_t
prototype_num_params(struct prototype *proto)
{
	return vect_size(&proto->params);
}

void
prototype_destroy_nth_param(struct prototype *proto, size_t n)
{
	assert(n < prototype_num_params(proto));
	VECT_ERASE(&proto->params, struct param, n, n+1,
		   &param_destroy_cb, NULL);
}

struct param *
prototype_get_nth_param(struct prototype *proto, size_t n)
{
	assert(n < prototype_num_params(proto));
	return VECT_ELEMENT(&proto->params, struct param, n);
}

struct each_param_data {
	struct prototype *proto;
	enum callback_status (*cb)(struct prototype *, struct param *, void *);
	void *data;
};

static enum callback_status
each_param_cb(struct param *param, void *data)
{
	struct each_param_data *cb_data = data;
	return (cb_data->cb)(cb_data->proto, param, cb_data->data);
}

struct param *
prototype_each_param(struct prototype *proto, struct param *start_after,
		     enum callback_status (*cb)(struct prototype *,
						struct param *, void *),
		     void *data)
{
	struct each_param_data cb_data = { proto, cb, data };
	return VECT_EACH(&proto->params, struct param, start_after,
			 &each_param_cb, &cb_data);
}

void
named_type_init(struct named_type *named,
		struct arg_type_info *info, int own_type)
{
	named->info = info;
	named->own_type = own_type;
	named->forward = 0;
}

void
named_type_destroy(struct named_type *named)
{
	if (named->own_type) {
		type_destroy(named->info);
		free(named->info);
	}
}

void
protolib_init(struct protolib *plib)
{
	DICT_INIT(&plib->prototypes, const char *, struct prototype,
		  dict_hash_string, dict_eq_string, NULL);

	DICT_INIT(&plib->named_types, const char *, struct named_type,
		  dict_hash_string, dict_eq_string, NULL);

	VECT_INIT(&plib->imports, struct protolib *);
}

static void
destroy_prototype_cb(struct prototype *proto, void *data)
{
	prototype_destroy(proto);
}

static void
destroy_named_type_cb(struct named_type *named, void *data)
{
	named_type_destroy(named);
}

void
protolib_destroy(struct protolib *plib)
{
	VECT_DESTROY(&plib->imports, struct prototype *, NULL, NULL);

	DICT_DESTROY(&plib->prototypes, const char *, struct prototype,
		     dict_dtor_string, destroy_prototype_cb, NULL);

	DICT_DESTROY(&plib->named_types, const char *, struct named_type,
		     dict_dtor_string, destroy_named_type_cb, NULL);
}

static struct protolib **
each_import(struct protolib *plib, struct protolib **start_after,
	    enum callback_status (*cb)(struct protolib **, void *), void *data)
{
	assert(plib != NULL);
	return VECT_EACH(&plib->imports, struct protolib *,
			 start_after, cb, data);
}

static enum callback_status
is_or_imports(struct protolib **plibp, void *data)
{
	assert(plibp != NULL);
	assert(*plibp != NULL);
	struct protolib *import = data;
	if (*plibp == import
	    || each_import(*plibp, NULL, &is_or_imports, import) != NULL)
		return CBS_STOP;
	else
		return CBS_CONT;
}

int
protolib_add_import(struct protolib *plib, struct protolib *import)
{
	assert(plib != NULL);
	assert(import != NULL);
	if (is_or_imports(&import, plib) == CBS_STOP) {
		fprintf(stderr, "Recursive import rejected.\n");
		return -2;
	}

	return VECT_PUSHBACK(&plib->imports, &import) < 0 ? -1 : 0;
}

static int
clone_if_not_own(const char **strp, int own)
{
	assert(*strp != NULL);

	if (!own) {
		*strp = strdup(*strp);
		if (*strp == NULL)
			return -1;
	}

	return 0;
}

static int
bailout(const char *name, int own)
{
	int save_errno = errno;
	if (own)
		free((char *)name);
	errno = save_errno;
	return -1;
}

int
protolib_add_prototype(struct protolib *plib, const char *name, int own_name,
		       struct prototype *proto)
{
	assert(plib != NULL);
	if (clone_if_not_own(&name, own_name) < 0)
		return -1;
	if (DICT_INSERT(&plib->prototypes, &name, proto) < 0)
		return bailout(name, own_name);
	return 0;
}

int
protolib_add_named_type(struct protolib *plib, const char *name, int own_name,
			struct named_type *named)
{
	assert(plib != NULL);
	if (clone_if_not_own(&name, own_name) < 0)
		return -1;
	if (DICT_INSERT(&plib->named_types, &name, named) < 0)
		return bailout(name, own_name);
	return 0;
}

struct lookup {
	const char *name;
	void *result;
	struct dict *(*getter)(struct protolib *plib);
};

static struct dict *
get_prototypes(struct protolib *plib)
{
	assert(plib != NULL);
	return &plib->prototypes;
}

static struct dict *
get_named_types(struct protolib *plib)
{
	assert(plib != NULL);
	return &plib->named_types;
}

static enum callback_status
protolib_lookup_rec(struct protolib **plibp, void *data)
{
	assert(plibp != NULL);
	assert(*plibp != NULL);
	struct lookup *lookup = data;
	struct dict *dict = (*lookup->getter)(*plibp);

	lookup->result = dict_find(dict, &lookup->name);
	if (lookup->result != NULL)
		return CBS_STOP;

	if (each_import(*plibp, NULL, &protolib_lookup_rec, lookup) != NULL) {
		assert(lookup->result != NULL);
		return CBS_STOP;
	}

	return CBS_CONT;
}

static void *
protolib_lookup(struct protolib *plib, const char *name,
		struct dict *(*getter)(struct protolib *))
{
	assert(plib != NULL);
	struct lookup lookup = { name, NULL, getter };
	if (protolib_lookup_rec(&plib, &lookup) == CBS_STOP)
		assert(lookup.result != NULL);
	else
		assert(lookup.result == NULL);
	return lookup.result;
}

struct prototype *
protolib_lookup_prototype(struct protolib *plib, const char *name)
{
	assert(plib != NULL);
	return protolib_lookup(plib, name, &get_prototypes);
}

struct named_type *
protolib_lookup_type(struct protolib *plib, const char *name)
{
	assert(plib != NULL);
	return protolib_lookup(plib, name, &get_named_types);
}

static void
destroy_protolib_cb(struct protolib **plibp, void *data)
{
	assert(plibp != NULL);
	assert(*plibp != NULL);
	protolib_destroy(*plibp);
}

void
protolib_cache_destroy(struct protolib_cache *cache)
{
	DICT_DESTROY(&cache->protolibs, const char *, struct protolib *,
		     dict_dtor_string, destroy_protolib_cb, NULL);
}

struct load_config_data {
	struct protolib_cache *self;
	const char *key;
	struct protolib *result;
};

static struct protolib *
consider_config_dir(struct protolib_cache *cache,
		    const char *path, const char *key)
{
	size_t len = sizeof ".conf";
	char slash[2] = {'/'};
	char *buf = alloca(strlen(path) + 1 + strlen(key) + len);
	strcpy(stpcpy(stpcpy(stpcpy(buf, path), slash), key), ".conf");

	return protolib_cache_file(cache, buf, 0);
}

static enum callback_status
consider_confdir_cb(struct opt_F_t *entry, void *d)
{
	if (opt_F_get_kind(entry) != OPT_F_DIR)
		return CBS_CONT;
	struct load_config_data *data = d;

	data->result = consider_config_dir(data->self,
					   entry->pathname, data->key);
	return data->result != NULL ? CBS_STOP : CBS_CONT;
}

static int
load_dash_F_dirs(struct protolib_cache *cache,
		 const char *key, struct protolib **retp)
{
	struct load_config_data data = {cache, key};

	if (VECT_EACH(&opt_F, struct opt_F_t, NULL,
		      consider_confdir_cb, &data) == NULL)
		/* Not found.  That's fine.  */
		return 0;

	if (data.result == NULL)
		/* There were errors.  */
		return -1;

	*retp = data.result;
	return 0;
}

static int
load_config(struct protolib_cache *cache,
	    const char *key, int private, struct protolib **retp)
{
	const char **dirs = NULL;
	if (os_get_config_dirs(private, &dirs) < 0
	    || dirs == NULL)
		return -1;

	for (; *dirs != NULL; ++dirs) {
		struct protolib *plib = consider_config_dir(cache, *dirs, key);
		if (plib != NULL) {
			*retp = plib;
			break;
		}
	}

	return 0;
}

static int
add_ltrace_conf(struct protolib_cache *cache)
{
	/* Look into private config directories for .ltrace.conf and
	 * into system config directories for ltrace.conf.  If it's
	 * found, add it to implicit import module.  */
	struct protolib *plib = NULL;
	const char *home = NULL;
	if (os_get_ltrace_conf_filename(&home) < 0
	    || (home != NULL
		&& (plib = consider_config_dir(cache, home, ".ltrace")) != NULL
		&& protolib_add_import(&cache->imports, plib) < 0)
	    || (plib == NULL && load_config(cache, "ltrace", 0, &plib) < 0)
	    || (plib != NULL && protolib_add_import(&cache->imports, plib) < 0))
		/* N.B. If plib is non-NULL, it has been already
		 * cached.  We don't therefore destroy it on
		 * failures.  */
		return -1;

	/* Never mind whether we've found anything.  It's fine if the
	 * config is absent.  */
	return 0;
}

static enum callback_status
add_imports_cb(struct opt_F_t *entry, void *data)
{
	struct protolib_cache *self = data;
	if (opt_F_get_kind(entry) != OPT_F_FILE)
		return CBS_CONT;

	struct protolib *new_import
		= protolib_cache_file(self, entry->pathname, 0);

	if (new_import == NULL
	    || protolib_add_import(&self->imports, new_import) < 0)
		/* N.B. If new_import is non-NULL, it has been already
		 * cached.  We don't therefore destroy it on
		 * failures.  */
		return CBS_STOP;

	return CBS_CONT;
}

int
protolib_cache_init(struct protolib_cache *cache, struct protolib *import)
{
	DICT_INIT(&cache->protolibs, const char *, struct protolib *,
		  dict_hash_string, dict_eq_string, NULL);
	protolib_init(&cache->imports);

	/* At this point the cache is consistent.  This is important,
	 * because next we will use it to cache files that we load
	 * due to -F.
	 *
	 * But we are about to construct the implicit import module,
	 * which means this module can't be itself imported to the
	 * files that we load now.  So remember that we are still
	 * bootstrapping.  */
	cache->bootstrap = 1;

	if (protolib_add_import(&cache->imports, &legacy_typedefs) < 0
	    || (import != NULL
		&& protolib_add_import(&cache->imports, import) < 0)
	    || add_ltrace_conf(cache) < 0
	    || VECT_EACH(&opt_F, struct opt_F_t, NULL,
			 add_imports_cb, cache) != NULL) {
		protolib_cache_destroy(cache);
		return -1;
	}

	cache->bootstrap = 0;
	return 0;
}

static enum callback_status
add_import_cb(struct protolib **importp, void *data)
{
	struct protolib *plib = data;
	if (protolib_add_import(plib, *importp) < 0)
		return CBS_STOP;
	else
		return CBS_CONT;
}

static struct protolib *
build_default_config(struct protolib_cache *cache, const char *key)
{
	struct protolib *new_plib = malloc(sizeof(*new_plib));
	if (new_plib == NULL) {
		fprintf(stderr, "Couldn't create config module %s: %s\n",
			key, strerror(errno));
		return NULL;
	}

	protolib_init(new_plib);

	/* If bootstrapping, copy over imports from implicit import
	 * module to new_plib.  We can't reference the implicit
	 * import module itself, because new_plib will become part of
	 * this same implicit import module itself.  */
	if ((cache->bootstrap && each_import(&cache->imports, NULL,
					     add_import_cb, new_plib) != NULL)
	    || (!cache->bootstrap
		&& protolib_add_import(new_plib, &cache->imports) < 0)) {

		fprintf(stderr,
			"Couldn't add imports to config module %s: %s\n",
			key, strerror(errno));
		protolib_destroy(new_plib);
		free(new_plib);
		return NULL;
	}

	return new_plib;
}

static void
attempt_to_cache(struct protolib_cache *cache,
		 const char *key, struct protolib *plib)
{
	if (protolib_cache_protolib(cache, key, 1, plib) == 0
	    || plib == NULL)
		/* Never mind failing to store a NULL.  */
		return;

	/* Returning a protolib that hasn't been cached would leak
	 * that protolib, but perhaps it's less bad then giving up
	 * outright.  At least print an error message.  */
	fprintf(stderr, "Couldn't cache prototype library for %s\n", key);
}

struct protolib *
protolib_cache_search(struct protolib_cache *cache,
		      const char *key, int own_key, int allow_private)
{
	struct protolib *plib = NULL;
	if (DICT_FIND_VAL(&cache->protolibs, &key, &plib) == 0)
		return plib;

	if (clone_if_not_own(&key, own_key) < 0) {
		fprintf(stderr, "Couldn't cache %s: %s\n",
			key, strerror(errno));
		return NULL;
	}

	/* The order is: -F directories, private directories, system
	 * directories.  If the config file is not found anywhere,
	 * build a default one.  */
	if (load_dash_F_dirs(cache, key, &plib) < 0
	    || (plib == NULL && allow_private
		&& load_config(cache, key, 1, &plib) < 0)
	    || (plib == NULL
		&& load_config(cache, key, 0, &plib) < 0)
	    || (plib == NULL
		&& (plib = build_default_config(cache, key)) == NULL))
		fprintf(stderr,
			"Error occurred when attempting to load a prototype "
			"library for %s.\n", key);

	/* Whatever came out of this (even NULL), store it in the
	 * cache.  */
	attempt_to_cache(cache, key, plib);
	return plib;
}

struct protolib *
protolib_cache_file(struct protolib_cache *cache,
		    const char *filename, int own_filename)
{
	{
		struct protolib *plib;
		if (DICT_FIND_VAL(&cache->protolibs, &filename, &plib) == 0)
			return plib;
	}

	FILE *stream = fopen(filename, "r");
	if (stream == NULL)
		return NULL;

	if (clone_if_not_own(&filename, own_filename) < 0) {
		fprintf(stderr, "Couldn't cache %s: %s\n",
			filename, strerror(errno));
		fclose(stream);
		return NULL;
	}

	struct protolib *new_plib = build_default_config(cache, filename);
	if (new_plib == NULL
	    || read_config_file(stream, filename, new_plib) < 0) {
		fclose(stream);
		if (own_filename)
			free((char *)filename);
		if (new_plib != NULL) {
			protolib_destroy(new_plib);
			free(new_plib);
		}
		return NULL;
	}

	attempt_to_cache(cache, filename, new_plib);
	fclose(stream);
	return new_plib;
}

int
protolib_cache_protolib(struct protolib_cache *cache,
			const char *filename, int own_filename,
			struct protolib *plib)
{
	if (clone_if_not_own(&filename, own_filename) < 0) {
		fprintf(stderr, "Couldn't cache %s: %s\n",
			filename, strerror(errno));
		return -1;
	}

	int rc = DICT_INSERT(&cache->protolibs, &filename, &plib);
	if (rc < 0 && own_filename)
		free((char *)filename);
	return rc;
}

void
init_global_config(void)
{
	protolib_init(&legacy_typedefs);
	struct arg_type_info *void_info = type_get_simple(ARGTYPE_VOID);
	static struct arg_type_info ptr_info;
	type_init_pointer(&ptr_info, void_info, 0);

	static struct named_type voidptr_type;
	named_type_init(&voidptr_type, &ptr_info, 0);

	if (protolib_add_named_type(&legacy_typedefs, "addr", 0,
				    &voidptr_type) < 0
	    || protolib_add_named_type(&legacy_typedefs, "file", 0,
				       &voidptr_type) < 0) {
		fprintf(stderr,
			"Couldn't initialize aliases `addr' and `file'.\n");
		exit(1);
	}

	if (protolib_cache_init(&g_protocache, NULL) < 0) {
		fprintf(stderr, "Couldn't init prototype cache\n");
		abort();
	}
}

void
destroy_global_config(void)
{
	protolib_cache_destroy(&g_protocache);
	protolib_destroy(&legacy_typedefs);
}