1 files changed, 443 insertions, 52 deletions

diff --git a/src/libstrongswan/utils/backtrace.c b/src/libstrongswan/utils/backtrace.c
index cb83d9830..93031908a 100644
--- a/src/libstrongswan/utils/backtrace.c
+++ b/src/libstrongswan/utils/backtrace.c
@@ -27,6 +27,8 @@
 
 #include "backtrace.h"
 
+#include <utils/debug.h>
+
 typedef struct private_backtrace_t private_backtrace_t;
 
 /**
@@ -50,16 +52,344 @@ struct private_backtrace_t {
 	void *frames[];
 };
 
+/**
+ * Forward declaration of method getter
+ */
+static backtrace_t get_methods();
+
+/**
+ * Write a format string with arguments to a FILE line, if it is NULL to DBG
+ */
+static void println(FILE *file, char *format, ...)
+{
+	char buf[512];
+	va_list args;
+
+	va_start(args, format);
+	if (file)
+	{
+		vfprintf(file, format, args);
+		fputs("\n", file);
+	}
+	else
+	{
+		vsnprintf(buf, sizeof(buf), format, args);
+		DBG1(DBG_LIB, "%s", buf);
+	}
+	va_end(args);
+}
+
+#ifdef HAVE_DLADDR
+
+/**
+ * Same as tty_escape_get(), but for a potentially NULL FILE*
+ */
+static char* esc(FILE *file, tty_escape_t escape)
+{
+	if (file)
+	{
+		return tty_escape_get(fileno(file), escape);
+	}
+	return "";
+}
+
+#ifdef HAVE_BFD_H
+
+#include <bfd.h>
+#include <collections/hashtable.h>
+#include <threading/mutex.h>
+
+/**
+ * Hashtable-cached bfd handle
+ */
+typedef struct {
+	/** binary file name on disk */
+	char *filename;
+	/** bfd handle */
+	bfd *abfd;
+	/** loaded symbols */
+	asymbol **syms;
+} bfd_entry_t;
+
+/**
+ * Destroy a bfd_entry
+ */
+static void bfd_entry_destroy(bfd_entry_t *this)
+{
+	free(this->filename);
+	free(this->syms);
+	bfd_close(this->abfd);
+	free(this);
+}
+
+/**
+ * Data to pass to find_addr()
+ */
+typedef struct {
+	/** used bfd entry */
+	bfd_entry_t *entry;
+	/** backtrace address */
+	bfd_vma vma;
+	/** stream to log to */
+	FILE *file;
+	/** TRUE if complete */
+	bool found;
+} bfd_find_data_t;
+
+/**
+ * bfd entry cache
+ */
+static hashtable_t *bfds;
+
+static mutex_t *bfd_mutex;
+
+/**
+ * Hashtable hash function
+ */
+static u_int bfd_hash(char *key)
+{
+	return chunk_hash(chunk_create(key, strlen(key)));
+}
+
+/**
+ * Hashtable equals function
+ */
+static bool bfd_equals(char *a, char *b)
+{
+	return streq(a, b);
+}
+
+/**
+ * See header.
+ */
+void backtrace_init()
+{
+	bfd_init();
+	bfds = hashtable_create((hashtable_hash_t)bfd_hash,
+							(hashtable_equals_t)bfd_equals, 8);
+	bfd_mutex = mutex_create(MUTEX_TYPE_DEFAULT);
+}
+
+/**
+ * See header.
+ */
+void backtrace_deinit()
+{
+	enumerator_t *enumerator;
+	bfd_entry_t *entry;
+	char *key;
+
+	enumerator = bfds->create_enumerator(bfds);
+	while (enumerator->enumerate(enumerator, &key, &entry))
+	{
+		bfds->remove_at(bfds, enumerator);
+		bfd_entry_destroy(entry);
+	}
+	enumerator->destroy(enumerator);
+
+	bfds->destroy(bfds);
+	bfd_mutex->destroy(bfd_mutex);
+}
+
+/**
+ * Find and print information to an address
+ */
+static void find_addr(bfd *abfd, asection *section, bfd_find_data_t *data)
+{
+	bfd_size_type size;
+	bfd_vma vma;
+	const char *source;
+	const char *function;
+	char fbuf[512] = "", sbuf[512] = "";
+	u_int line;
+
+	if (!data->found || (bfd_get_section_flags(abfd, section) & SEC_ALLOC) != 0)
+	{
+		vma = bfd_get_section_vma(abfd, section);
+		if (data->vma >= vma)
+		{
+			size = bfd_get_section_size(section);
+			if (data->vma < vma + size)
+			{
+				data->found = bfd_find_nearest_line(abfd, section,
+											data->entry->syms, data->vma - vma,
+											&source, &function, &line);
+				if (data->found)
+				{
+					if (source || function)
+					{
+						if (function)
+						{
+							snprintf(fbuf, sizeof(fbuf), "%s%s() ",
+								esc(data->file, TTY_FG_BLUE), function);
+						}
+						if (source)
+						{
+							snprintf(sbuf, sizeof(sbuf), "%s@ %s:%d",
+								esc(data->file, TTY_FG_GREEN), source, line);
+						}
+						println(data->file, "    -> %s%s%s", fbuf, sbuf,
+								esc(data->file, TTY_FG_DEF));
+					}
+				}
+			}
+		}
+	}
+}
+
+/**
+ * Find a cached bfd entry, create'n'cache if not found
+ */
+static bfd_entry_t *get_bfd_entry(char *filename)
+{
+	bool dynamic = FALSE, ok = FALSE;
+	bfd_entry_t *entry;
+	long size;
+
+	/* check cache */
+	entry = bfds->get(bfds, filename);
+	if (entry)
+	{
+		return entry;
+	}
+
+	INIT(entry,
+		.abfd = bfd_openr(filename, NULL),
+	);
+
+	if (!entry->abfd)
+	{
+		free(entry);
+		return NULL;
+	}
+#ifdef BFD_DECOMPRESS
+	entry->abfd->flags |= BFD_DECOMPRESS;
+#endif
+	if (bfd_check_format(entry->abfd, bfd_archive) == 0 &&
+		bfd_check_format_matches(entry->abfd, bfd_object, NULL))
+	{
+		if (bfd_get_file_flags(entry->abfd) & HAS_SYMS)
+		{
+			size = bfd_get_symtab_upper_bound(entry->abfd);
+			if (size == 0)
+			{
+				size = bfd_get_dynamic_symtab_upper_bound(entry->abfd);
+			}
+			if (size >= 0)
+			{
+				entry->syms = malloc(size);
+				if (dynamic)
+				{
+					ok = bfd_canonicalize_dynamic_symtab(entry->abfd,
+														 entry->syms) >= 0;
+				}
+				else
+				{
+					ok = bfd_canonicalize_symtab(entry->abfd,
+												 entry->syms) >= 0;
+				}
+			}
+		}
+	}
+	if (ok)
+	{
+		entry->filename = strdup(filename);
+		bfds->put(bfds, entry->filename, entry);
+		return entry;
+	}
+	bfd_entry_destroy(entry);
+	return NULL;
+}
+
+/**
+ * Print the source file with line number to file, libbfd variant
+ */
+static void print_sourceline(FILE *file, char *filename, void *ptr, void *base)
+{
+	bfd_entry_t *entry;
+	bfd_find_data_t data = {
+		.file = file,
+		.vma = (uintptr_t)ptr,
+	};
+	bool old = FALSE;
+
+	bfd_mutex->lock(bfd_mutex);
+	if (lib->leak_detective)
+	{
+		old = lib->leak_detective->set_state(lib->leak_detective, FALSE);
+	}
+	entry = get_bfd_entry(filename);
+	if (entry)
+	{
+		data.entry = entry;
+		bfd_map_over_sections(entry->abfd, (void*)find_addr, &data);
+	}
+	if (lib->leak_detective)
+	{
+		lib->leak_detective->set_state(lib->leak_detective, old);
+	}
+	bfd_mutex->unlock(bfd_mutex);
+}
+
+#else /* !HAVE_BFD_H */
+
+void backtrace_init() {}
+void backtrace_deinit() {}
+
+/**
+ * Print the source file with line number to file, slow addr2line variant
+ */
+static void print_sourceline(FILE *file, char *filename, void *ptr, void* base)
+{
+	char buf[1024];
+	FILE *output;
+	int c, i = 0;
+
+#ifdef __APPLE__
+	snprintf(buf, sizeof(buf), "atos -o %s -l %p %p 2>&1 | tail -n1",
+			 filename, base, ptr);
+#else /* !__APPLE__ */
+	snprintf(buf, sizeof(buf), "addr2line -e %s %p", filename, ptr);
+#endif /* __APPLE__ */
+
+
+	output = popen(buf, "r");
+	if (output)
+	{
+		while (i < sizeof(buf))
+		{
+			c = getc(output);
+			if (c == '\n' || c == EOF)
+			{
+				buf[i++] = 0;
+				break;
+			}
+			buf[i++] = c;
+		}
+		pclose(output);
+
+		println(file, "    -> %s%s%s", esc(file, TTY_FG_GREEN), buf,
+				esc(file, TTY_FG_DEF));
+	}
+}
+
+#endif /* HAVE_BFD_H */
+
+#else /* !HAVE_DLADDR */
+
+void backtrace_init() {}
+void backtrace_deinit() {}
+
+#endif /* HAVE_DLADDR */
+
 METHOD(backtrace_t, log_, void,
 	private_backtrace_t *this, FILE *file, bool detailed)
 {
-#ifdef HAVE_BACKTRACE
+#if defined(HAVE_BACKTRACE) || defined(HAVE_LIBUNWIND_H)
 	size_t i;
-	char **strings;
-
-	strings = backtrace_symbols(this->frames, this->frame_count);
+	char **strings = NULL;
 
-	fprintf(file, " dumping %d stack frame addresses:\n", this->frame_count);
+	println(file, " dumping %d stack frame addresses:", this->frame_count);
 	for (i = 0; i < this->frame_count; i++)
 	{
 #ifdef HAVE_DLADDR
@@ -67,9 +397,6 @@ METHOD(backtrace_t, log_, void,
 
 		if (dladdr(this->frames[i], &info))
 		{
-			char cmd[1024];
-			FILE *output;
-			int c;
 			void *ptr = this->frames[i];
 
 			if (strstr(info.dli_fname, ".so"))
@@ -78,53 +405,48 @@ METHOD(backtrace_t, log_, void,
 			}
 			if (info.dli_sname)
 			{
-				fprintf(file, "  \e[33m%s\e[0m @ %p (\e[31m%s\e[0m+0x%tx) [%p]\n",
-						info.dli_fname, info.dli_fbase, info.dli_sname,
-						this->frames[i] - info.dli_saddr, this->frames[i]);
+				println(file, "  %s%s%s @ %p (%s%s%s+0x%tx) [%p]",
+						esc(file, TTY_FG_YELLOW), info.dli_fname,
+						esc(file, TTY_FG_DEF), info.dli_fbase,
+						esc(file, TTY_FG_RED), info.dli_sname,
+						esc(file, TTY_FG_DEF), this->frames[i] - info.dli_saddr,
+						this->frames[i]);
 			}
 			else
 			{
-				fprintf(file, "  \e[33m%s\e[0m @ %p [%p]\n", info.dli_fname,
-						info.dli_fbase, this->frames[i]);
+				println(file, "  %s%s%s @ %p [%p]",
+						esc(file, TTY_FG_YELLOW), info.dli_fname,
+						esc(file, TTY_FG_DEF), info.dli_fbase, this->frames[i]);
 			}
-			if (detailed)
+			if (detailed && info.dli_fname[0])
 			{
-				fprintf(file, "    -> \e[32m");
-				snprintf(cmd, sizeof(cmd), "addr2line -e %s %p",
-						 info.dli_fname, ptr);
-				output = popen(cmd, "r");
-				if (output)
-				{
-					while (TRUE)
-					{
-						c = getc(output);
-						if (c == '\n' || c == EOF)
-						{
-							break;
-						}
-						fputc(c, file);
-					}
-					pclose(output);
-				}
-				else
-				{
-	#endif /* HAVE_DLADDR */
-					fprintf(file, "    %s\n", strings[i]);
-	#ifdef HAVE_DLADDR
-				}
-				fprintf(file, "\n\e[0m");
+				print_sourceline(file, (char*)info.dli_fname,
+								 ptr, info.dli_fbase);
 			}
 		}
 		else
+#endif /* HAVE_DLADDR */
 		{
-			fprintf(file, "    %s\n", strings[i]);
+#ifdef HAVE_BACKTRACE
+			if (!strings)
+			{
+				strings = backtrace_symbols(this->frames, this->frame_count);
+			}
+			if (strings)
+			{
+				println(file, "    %s", strings[i]);
+			}
+			else
+#endif /* HAVE_BACKTRACE */
+			{
+				println(file, "    %p", this->frames[i]);
+			}
 		}
-#endif /* HAVE_DLADDR */
 	}
-	free (strings);
-#else /* !HAVE_BACKTRACE */
-	fprintf(file, "C library does not support backtrace().\n");
-#endif /* HAVE_BACKTRACE */
+	free(strings);
+#else /* !HAVE_BACKTRACE && !HAVE_LIBUNWIND_H */
+	println(file, "no support for backtrace()/libunwind");
+#endif /* HAVE_BACKTRACE/HAVE_LIBUNWIND_H */
 }
 
 METHOD(backtrace_t, contains_function, bool,
@@ -214,12 +536,69 @@ METHOD(backtrace_t, create_frame_enumerator, enumerator_t*,
 	return &enumerator->public;
 }
 
+METHOD(backtrace_t, clone, backtrace_t*,
+	private_backtrace_t *this)
+{
+	private_backtrace_t *clone;
+
+	clone = malloc(sizeof(private_backtrace_t) +
+				   this->frame_count * sizeof(void*));
+	memcpy(clone->frames, this->frames, this->frame_count * sizeof(void*));
+	clone->frame_count = this->frame_count;
+
+	clone->public = get_methods();
+
+	return &clone->public;
+}
+
 METHOD(backtrace_t, destroy, void,
 	private_backtrace_t *this)
 {
 	free(this);
 }
 
+#ifdef HAVE_LIBUNWIND_H
+#define UNW_LOCAL_ONLY
+#include <libunwind.h>
+
+/**
+ * libunwind variant for glibc backtrace()
+ */
+static inline int backtrace_unwind(void **frames, int count)
+{
+	unw_context_t context;
+	unw_cursor_t cursor;
+	unw_word_t ip;
+	int depth = 0;
+
+	unw_getcontext(&context);
+	unw_init_local(&cursor, &context);
+	do
+	{
+		unw_get_reg(&cursor, UNW_REG_IP, &ip);
+		frames[depth++] = (void*)ip;
+	}
+	while (depth < count && unw_step(&cursor) > 0);
+
+	return depth;
+}
+#endif /* HAVE_UNWIND */
+
+/**
+ * Get implementation methods of backtrace_t
+ */
+static backtrace_t get_methods()
+{
+	return (backtrace_t) {
+		.log = _log_,
+		.contains_function = _contains_function,
+		.equals = _equals,
+		.clone = _clone,
+		.create_frame_enumerator = _create_frame_enumerator,
+		.destroy = _destroy,
+	};
+}
+
 /**
  * See header
  */
@@ -229,7 +608,9 @@ backtrace_t *backtrace_create(int skip)
 	void *frames[50];
 	int frame_count = 0;
 
-#ifdef HAVE_BACKTRACE
+#ifdef HAVE_LIBUNWIND_H
+	frame_count = backtrace_unwind(frames, countof(frames));
+#elif defined(HAVE_BACKTRACE)
 	frame_count = backtrace(frames, countof(frames));
 #endif /* HAVE_BACKTRACE */
 	frame_count = max(frame_count - skip, 0);
@@ -237,14 +618,24 @@ backtrace_t *backtrace_create(int skip)
 	memcpy(this->frames, frames + skip, frame_count * sizeof(void*));
 	this->frame_count = frame_count;
 
-	this->public = (backtrace_t) {
-		.log = _log_,
-		.contains_function = _contains_function,
-		.equals = _equals,
-		.create_frame_enumerator = _create_frame_enumerator,
-		.destroy = _destroy,
-	};
+	this->public = get_methods();
 
 	return &this->public;
 }
 
+/**
+ * See header
+ */
+void backtrace_dump(char *label, FILE *file, bool detailed)
+{
+	backtrace_t *backtrace;
+
+	backtrace = backtrace_create(2);
+
+	if (label)
+	{
+		println(file, "Debug backtrace: %s", label);
+	}
+	backtrace->log(backtrace, file, detailed);
+	backtrace->destroy(backtrace);
+}