/**

 * WinPR: Windows Portable Runtime

 * Debugging Utils

 *

 * Copyright 2014 Armin Novak <armin.novak@thincast.com>

 * Copyright 2014 Thincast Technologies GmbH

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *     http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

#include <stdio.h>

#include <fcntl.h>

#include <winpr/string.h>

#if defined(HAVE_EXECINFO_H)

#include <execinfo.h>

#endif

#if defined(ANDROID)

#include <corkscrew/backtrace.h>

#endif

#if defined(_WIN32) || defined(_WIN64)

#include <io.h>

#include <windows.h>

#include <dbghelp.h>

#define write _write

#endif

#include <winpr/crt.h>

#include <winpr/wlog.h>

#include <winpr/debug.h>

#define TAG "com.winpr.utils.debug"

#define LOGT(...)                                           \

	do                                                      \

	{                                                       \

		WLog_Print(WLog_Get(TAG), WLOG_TRACE, __VA_ARGS__); \

	} while (0)

#define LOGD(...)                                           \

	do                                                      \

	{                                                       \

		WLog_Print(WLog_Get(TAG), WLOG_DEBUG, __VA_ARGS__); \

	} while (0)

#define LOGI(...)                                          \

	do                                                     \

	{                                                      \

		WLog_Print(WLog_Get(TAG), WLOG_INFO, __VA_ARGS__); \

	} while (0)

#define LOGW(...)                                          \

	do                                                     \

	{                                                      \

		WLog_Print(WLog_Get(TAG), WLOG_WARN, __VA_ARGS__); \

	} while (0)

#define LOGE(...)                                           \

	do                                                      \

	{                                                       \

		WLog_Print(WLog_Get(TAG), WLOG_ERROR, __VA_ARGS__); \

	} while (0)

#define LOGF(...)                                           \

	do                                                      \

	{                                                       \

		WLog_Print(WLog_Get(TAG), WLOG_FATAL, __VA_ARGS__); \

	} while (0)

static const char* support_msg = "Invalid stacktrace buffer! check if platform is supported!";

#if defined(HAVE_EXECINFO_H)

typedef struct

{

	void** buffer;

	size_t max;

	size_t used;

} t_execinfo;

#endif

#if defined(_WIN32) || defined(_WIN64)

typedef struct

{

	PVOID* stack;

	ULONG used;

	ULONG max;

} t_win_stack;

#endif

#if defined(ANDROID)

#include <pthread.h>

#include <dlfcn.h>

#include <unistd.h>

typedef struct

{

	backtrace_frame_t* buffer;

	size_t max;

	size_t used;

} t_corkscrew_data;

typedef struct

{

	void* hdl;

	ssize_t (*unwind_backtrace)(backtrace_frame_t* backtrace, size_t ignore_depth,

	                            size_t max_depth);

	ssize_t (*unwind_backtrace_thread)(pid_t tid, backtrace_frame_t* backtrace, size_t ignore_depth,

	                                   size_t max_depth);

	ssize_t (*unwind_backtrace_ptrace)(pid_t tid, const ptrace_context_t* context,

	                                   backtrace_frame_t* backtrace, size_t ignore_depth,

	                                   size_t max_depth);

	void (*get_backtrace_symbols)(const backtrace_frame_t* backtrace, size_t frames,

	                              backtrace_symbol_t* backtrace_symbols);

	void (*get_backtrace_symbols_ptrace)(const ptrace_context_t* context,

	                                     const backtrace_frame_t* backtrace, size_t frames,

	                                     backtrace_symbol_t* backtrace_symbols);

	void (*free_backtrace_symbols)(backtrace_symbol_t* backtrace_symbols, size_t frames);

	void (*format_backtrace_line)(unsigned frameNumber, const backtrace_frame_t* frame,

	                              const backtrace_symbol_t* symbol, char* buffer,

	                              size_t bufferSize);

} t_corkscrew;

static pthread_once_t initialized = PTHREAD_ONCE_INIT;

static t_corkscrew* fkt = NULL;

void load_library(void)

{

	static t_corkscrew lib;

	{

		lib.hdl = dlopen("libcorkscrew.so", RTLD_LAZY);

		if (!lib.hdl)

		{

			LOGF("dlopen error %s", dlerror());

			goto fail;

		}

		lib.unwind_backtrace = dlsym(lib.hdl, "unwind_backtrace");

		if (!lib.unwind_backtrace)

		{

			LOGF("dlsym error %s", dlerror());

			goto fail;

		}

		lib.unwind_backtrace_thread = dlsym(lib.hdl, "unwind_backtrace_thread");

		if (!lib.unwind_backtrace_thread)

		{

			LOGF("dlsym error %s", dlerror());

			goto fail;

		}

		lib.unwind_backtrace_ptrace = dlsym(lib.hdl, "unwind_backtrace_ptrace");

		if (!lib.unwind_backtrace_ptrace)

		{

			LOGF("dlsym error %s", dlerror());

			goto fail;

		}

		lib.get_backtrace_symbols = dlsym(lib.hdl, "get_backtrace_symbols");

		if (!lib.get_backtrace_symbols)

		{

			LOGF("dlsym error %s", dlerror());

			goto fail;

		}

		lib.get_backtrace_symbols_ptrace = dlsym(lib.hdl, "get_backtrace_symbols_ptrace");

		if (!lib.get_backtrace_symbols_ptrace)

		{

			LOGF("dlsym error %s", dlerror());

			goto fail;

		}

		lib.free_backtrace_symbols = dlsym(lib.hdl, "free_backtrace_symbols");

		if (!lib.free_backtrace_symbols)

		{

			LOGF("dlsym error %s", dlerror());

			goto fail;

		}

		lib.format_backtrace_line = dlsym(lib.hdl, "format_backtrace_line");

		if (!lib.format_backtrace_line)

		{

			LOGF("dlsym error %s", dlerror());

			goto fail;

		}

		fkt = &li;;

		return;

	}

fail:

{

	if (lib.hdl)

		dlclose(lib.hdl);

	fkt = NULL;

}

}

#endif

#if defined(_WIN32) && (NTDDI_VERSION <= NTDDI_WINXP)

typedef USHORT(WINAPI* PRTL_CAPTURE_STACK_BACK_TRACE_FN)(ULONG FramesToSkip, ULONG FramesToCapture,

                                                         PVOID* BackTrace, PULONG BackTraceHash);

static HMODULE g_NTDLL_Library = NULL;

static BOOL g_RtlCaptureStackBackTrace_Detected = FALSE;

static BOOL g_RtlCaptureStackBackTrace_Available = FALSE;

static PRTL_CAPTURE_STACK_BACK_TRACE_FN g_pRtlCaptureStackBackTrace = NULL;

USHORT RtlCaptureStackBackTrace(ULONG FramesToSkip, ULONG FramesToCapture, PVOID* BackTrace,

                                PULONG BackTraceHash)

{

	if (!g_RtlCaptureStackBackTrace_Detected)

	{

		g_NTDLL_Library = LoadLibraryA("kernel32.dll");

		if (g_NTDLL_Library)

		{

			g_pRtlCaptureStackBackTrace = (PRTL_CAPTURE_STACK_BACK_TRACE_FN)GetProcAddress(

			    g_NTDLL_Library, "RtlCaptureStackBackTrace");

			g_RtlCaptureStackBackTrace_Available = (g_pRtlCaptureStackBackTrace) ? TRUE : FALSE;

		}

		else

		{

			g_RtlCaptureStackBackTrace_Available = FALSE;

		}

		g_RtlCaptureStackBackTrace_Detected = TRUE;

	}

	if (g_RtlCaptureStackBackTrace_Available)

	{

		return (*g_pRtlCaptureStackBackTrace)(FramesToSkip, FramesToCapture, BackTrace,

		                                      BackTraceHash);

	}

	return 0;

}

#endif

void winpr_backtrace_free(void* buffer)

{

	if (!buffer)

	{

		LOGF(support_msg);

		return;

	}

#if defined(HAVE_EXECINFO_H)

	t_execinfo* data = (t_execinfo*)buffer;

	free(data->buffer);

	free(data);

#elif defined(ANDROID)

	t_corkscrew_data* data = (t_corkscrew_data*)buffer;

	free(data->buffer);

	free(data);

#elif defined(_WIN32) || defined(_WIN64)

	{

		t_win_stack* data = (t_win_stack*)buffer;

		free(data->stack);

		free(data);

	}

#else

	LOGF(support_msg);

#endif

}

void* winpr_backtrace(DWORD size)

{

#if defined(HAVE_EXECINFO_H)

	t_execinfo* data = calloc(1, sizeof(t_execinfo));

	if (!data)

		return NULL;

	data->buffer = calloc(size, sizeof(void*));

	if (!data->buffer)

	{

		free(data);

		return NULL;

	}

	data->max = size;

	data->used = backtrace(data->buffer, size);

	return data;

#elif defined(ANDROID)

	t_corkscrew_data* data = calloc(1, sizeof(t_corkscrew_data));

	if (!data)

		return NULL;

	data->buffer = calloc(size, sizeof(backtrace_frame_t));

	if (!data->buffer)

	{

		free(data);

		return NULL;

	}

	pthread_once(&initialized, load_library);

	data->max = size;

	data->used = fkt->unwind_backtrace(data->buffer, 0, size);

	return data;

#elif (defined(_WIN32) || defined(_WIN64)) && !defined(_UWP)

	HANDLE process = GetCurrentProcess();

	t_win_stack* data = calloc(1, sizeof(t_win_stack));

	if (!data)

		return NULL;

	data->max = size;

	data->stack = calloc(data->max, sizeof(PVOID));

	if (!data->stack)

	{

		free(data);

		return NULL;

	}

	SymInitialize(process, NULL, TRUE);

	data->used = RtlCaptureStackBackTrace(2, size, data->stack, NULL);

	return data;

#else

	LOGF(support_msg);

	return NULL;

#endif

}

char** winpr_backtrace_symbols(void* buffer, size_t* used)

{

	if (used)

		*used = 0;

	if (!buffer)

	{

		LOGF(support_msg);

		return NULL;

	}

#if defined(HAVE_EXECINFO_H)

	t_execinfo* data = (t_execinfo*)buffer;

	if (!data)

		return NULL;

	if (used)

		*used = data->used;

	return backtrace_symbols(data->buffer, data->used);

#elif defined(ANDROID)

	t_corkscrew_data* data = (t_corkscrew_data*)buffer;

	if (!data)

		return NULL;

	pthread_once(&initialized, load_library);

	if (!fkt)

	{

		LOGF(support_msg);

		return NULL;

	}

	else

	{

		size_t line_len = (data->max > 1024) ? data->max : 1024;

		size_t i;

		size_t array_size = data->used * sizeof(char*);

		size_t lines_size = data->used * line_len;

		char** vlines = calloc(1, array_size + lines_size);

		backtrace_symbol_t* symbols = calloc(data->used, sizeof(backtrace_symbol_t));

		if (!vlines || !symbols)

		{

			free(vlines);

			free(symbols);

			return NULL;

		}

		/* Set the pointers in the allocated buffer's initial array section */

		for (i = 0; i < data->used; i++)

			vlines[i] = (char*)vlines + array_size + i * line_len;

		fkt->get_backtrace_symbols(data->buffer, data->used, symbols);

		for (i = 0; i < data->used; i++)

			fkt->format_backtrace_line(i, &data->buffer[i], &symbols[i], vlines[i], line_len);

		fkt->free_backtrace_symbols(symbols, data->used);

		free(symbols);

		if (used)

			*used = data->used;

		return vlines;

	}

#elif (defined(_WIN32) || defined(_WIN64)) && !defined(_UWP)

	{

		size_t i;

		size_t line_len = 1024;

		HANDLE process = GetCurrentProcess();

		t_win_stack* data = (t_win_stack*)buffer;

		size_t array_size = data->used * sizeof(char*);

		size_t lines_size = data->used * line_len;

		char** vlines = calloc(1, array_size + lines_size);

		SYMBOL_INFO* symbol = calloc(1, sizeof(SYMBOL_INFO) + line_len * sizeof(char));

		IMAGEHLP_LINE64* line = (IMAGEHLP_LINE64*)calloc(1, sizeof(IMAGEHLP_LINE64));

		if (!vlines || !symbol || !line)

		{

			free(vlines);

			free(symbol);

			free(line);

			return NULL;

		}

		line->SizeOfStruct = sizeof(IMAGEHLP_LINE64);

		symbol->MaxNameLen = line_len;

		symbol->SizeOfStruct = sizeof(SYMBOL_INFO);

		/* Set the pointers in the allocated buffer's initial array section */

		for (i = 0; i < data->used; i++)

			vlines[i] = (char*)vlines + array_size + i * line_len;

		for (i = 0; i < data->used; i++)

		{

			DWORD64 address = (DWORD64)(data->stack[i]);

			DWORD displacement;

			SymFromAddr(process, address, 0, symbol);

			if (SymGetLineFromAddr64(process, address, &displacement, line))

			{

				sprintf_s(vlines[i], line_len, "%016" PRIx64 ": %s in %s:%" PRIu32, symbol->Address,

				          symbol->Name, line->FileName, line->LineNumber);

			}

			else

				sprintf_s(vlines[i], line_len, "%016" PRIx64 ": %s", symbol->Address, symbol->Name);

		}

		if (used)

			*used = data->used;

		free(symbol);

		free(line);

		return vlines;

	}

#else

	LOGF(support_msg);

	return NULL;

#endif

}

void winpr_backtrace_symbols_fd(void* buffer, int fd)

{

	if (!buffer)

	{

		LOGF(support_msg);

		return;

	}

#if defined(HAVE_EXECINFO_H)

	t_execinfo* data = (t_execinfo*)buffer;

	if (!data)

		return;

	backtrace_symbols_fd(data->buffer, data->used, fd);

#elif defined(_WIN32) || defined(_WIN64) || defined(ANDROID)

	{

		DWORD i;

		size_t used;

		char** lines;

		lines = winpr_backtrace_symbols(buffer, &used);

		if (lines)

		{

			for (i = 0; i < used; i++)

				write(fd, lines[i], strlen(lines[i]));

		}

	}

#else

	LOGF(support_msg);

#endif

}

void winpr_log_backtrace(const char* tag, DWORD level, DWORD size)

{

	winpr_log_backtrace_ex(WLog_Get(tag), level, size);

}

void winpr_log_backtrace_ex(wLog* log, DWORD level, DWORD size)

{

	size_t used, x;

	char** msg;

	void* stack = winpr_backtrace(20);

	if (!stack)

	{

		WLog_Print(log, WLOG_ERROR, "winpr_backtrace failed!\n");

		winpr_backtrace_free(stack);

		return;

	}

	msg = winpr_backtrace_symbols(stack, &used);

	if (msg)

	{

		for (x = 0; x < used; x++)

			WLog_Print(log, level, "%" PRIuz ": %s\n", x, msg[x]);

	}

	winpr_backtrace_free(stack);

}

char* winpr_strerror(DWORD dw, char* dmsg, size_t size)

{

#if defined(_WIN32)

	DWORD rc;

	DWORD nSize = 0;

	DWORD dwFlags = 0;

	LPTSTR msg = NULL;

	BOOL alloc = FALSE;

	dwFlags = FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS;

#ifdef FORMAT_MESSAGE_ALLOCATE_BUFFER

	alloc = TRUE;

	dwFlags |= FORMAT_MESSAGE_ALLOCATE_BUFFER;

#else

	nSize = (DWORD)(size * 2);

	msg = (LPTSTR)calloc(nSize, sizeof(TCHAR));

#endif

	rc = FormatMessage(dwFlags, NULL, dw, 0, alloc ? (LPTSTR)&msg : msg, nSize, NULL);

	if (rc)

	{

#if defined(UNICODE)

		WideCharToMultiByte(CP_ACP, 0, msg, rc, dmsg, size - 1, NULL, NULL);

#else  /* defined(UNICODE) */

		memcpy(dmsg, msg, min(rc, size - 1));

#endif /* defined(UNICODE) */

		dmsg[min(rc, size - 1)] = 0;

#ifdef FORMAT_MESSAGE_ALLOCATE_BUFFER

		LocalFree(msg);

#else

		free(msg);

#endif

	}

	else

	{

		_snprintf(dmsg, size, "FAILURE: 0x%08" PRIX32 "", GetLastError());

	}

#else  /* defined(_WIN32) */

	_snprintf(dmsg, size, "%s", strerror(dw));

#endif /* defined(_WIN32) */

	return dmsg;

}