[proxmark3-svn] / client / whereami.c

// (‑●‑●)> released under the WTFPL v2 license, by Gregory Pakosz (@gpakosz)
// https://github.com/gpakosz/whereami

// in case you want to #include "whereami.c" in a larger compilation unit
#if !defined(WHEREAMI_H)
#include <whereami.h>
#endif

#ifdef __cplusplus
extern "C" {
#endif

#if !defined(WAI_MALLOC) || !defined(WAI_FREE) || !defined(WAI_REALLOC)
#include <stdlib.h>
#endif

#if !defined(WAI_MALLOC)
#define WAI_MALLOC(size) malloc(size)
#endif

#if !defined(WAI_FREE)
#define WAI_FREE(p) free(p)
#endif

#if !defined(WAI_REALLOC)
#define WAI_REALLOC(p, size) realloc(p, size)
#endif

#ifndef WAI_NOINLINE
#if defined(_MSC_VER)
#define WAI_NOINLINE __declspec(noinline)
#elif defined(__GNUC__)
#define WAI_NOINLINE __attribute__((noinline))
#else
#error unsupported compiler
#endif
#endif

#if defined(_MSC_VER)
#define WAI_RETURN_ADDRESS() _ReturnAddress()
#elif defined(__GNUC__)
#define WAI_RETURN_ADDRESS() __builtin_extract_return_addr(__builtin_return_address(0))
#else
#error unsupported compiler
#endif

#if defined(_WIN32)

#define WIN32_LEAN_AND_MEAN
#if defined(_MSC_VER)
#pragma warning(push, 3)
#endif
#include <windows.h>
#if defined(_MSC_VER)
#pragma warning(pop)
#endif

static int WAI_PREFIX(getModulePath_)(HMODULE module, char* out, int capacity, int* dirname_length)
{
  wchar_t buffer1[MAX_PATH];
  wchar_t buffer2[MAX_PATH];
  wchar_t* path = NULL;
  int length = -1;

  for (;;)
  {
    DWORD size;
    int length_, length__;

    size = GetModuleFileNameW(module, buffer1, sizeof(buffer1) / sizeof(buffer1[0]));

    if (size == 0)
      break;
    else if (size == (DWORD)(sizeof(buffer1) / sizeof(buffer1[0])))
    {
      DWORD size_ = size;
      do
      {
        wchar_t* path_;

        path_ = (wchar_t*)WAI_REALLOC(path, sizeof(wchar_t) * size_ * 2);
        if (!path_)
          break;
        size_ *= 2;
        path = path_;
        size = GetModuleFileNameW(module, path, size_);
      }
      while (size == size_);

      if (size == size_)
        break;
    }
    else
      path = buffer1;

    if (!_wfullpath(buffer2, path, MAX_PATH))
      break;
    length_ = (int)wcslen(buffer2);
    length__ = WideCharToMultiByte(CP_UTF8, 0, buffer2, length_ , out, capacity, NULL, NULL);

    if (length__ == 0)
      length__ = WideCharToMultiByte(CP_UTF8, 0, buffer2, length_, NULL, 0, NULL, NULL);
    if (length__ == 0)
      break;

    if (length__ <= capacity && dirname_length)
    {
      int i;

      for (i = length__ - 1; i >= 0; --i)
      {
        if (out[i] == '\\')
        {
          *dirname_length = i;
          break;
        }
      }
    }

    length = length__;

    break;
  }

  if (path != buffer1)
    WAI_FREE(path);

  return length;
}

WAI_NOINLINE
WAI_FUNCSPEC
int WAI_PREFIX(getExecutablePath)(char* out, int capacity, int* dirname_length)
{
  return WAI_PREFIX(getModulePath_)(NULL, out, capacity, dirname_length);
}

/*
WAI_NOINLINE
WAI_FUNCSPEC
int WAI_PREFIX(getModulePath)(char* out, int capacity, int* dirname_length)
{
  HMODULE module;
  int length = -1;

#if defined(_MSC_VER)
#pragma warning(push)
#pragma warning(disable: 4054)
#endif
  if (GetModuleHandleEx(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS | GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT, (LPCTSTR)WAI_RETURN_ADDRESS(), &module))
#if defined(_MSC_VER)
#pragma warning(pop)
#endif
  {
    length = WAI_PREFIX(getModulePath_)(module, out, capacity, dirname_length);
  }

  return length;
}
*/

#elif defined(__linux__)

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <linux/limits.h>
#ifndef __STDC_FORMAT_MACROS
#define __STDC_FORMAT_MACROS
#endif
#include <inttypes.h>

#if !defined(WAI_PROC_SELF_EXE)
#define WAI_PROC_SELF_EXE "/proc/self/exe"
#endif

WAI_FUNCSPEC
int WAI_PREFIX(getExecutablePath)(char* out, int capacity, int* dirname_length)
{
  char buffer[PATH_MAX];
  char* resolved = NULL;
  int length = -1;

  for (;;)
  {
    resolved = realpath(WAI_PROC_SELF_EXE, buffer);
    if (!resolved)
      break;

    length = (int)strlen(resolved);
    if (length <= capacity)
    {
      memcpy(out, resolved, length);

      if (dirname_length)
      {
        int i;

        for (i = length - 1; i >= 0; --i)
        {
          if (out[i] == '/')
          {
            *dirname_length = i;
            break;
          }
        }
      }
    }

    break;
  }

  return length;
}

#if !defined(WAI_PROC_SELF_MAPS_RETRY)
#define WAI_PROC_SELF_MAPS_RETRY 5
#endif

#if !defined(WAI_PROC_SELF_MAPS)
#define WAI_PROC_SELF_MAPS "/proc/self/maps"
#endif

#if defined(__ANDROID__) || defined(ANDROID)
#include <fcntl.h>
#include <sys/mman.h>
#endif

WAI_NOINLINE
WAI_FUNCSPEC
int WAI_PREFIX(getModulePath)(char* out, int capacity, int* dirname_length)
{
  int length = -1;
  FILE* maps = NULL;
  int i;

  for (i = 0; i < WAI_PROC_SELF_MAPS_RETRY; ++i)
  {
    maps = fopen(WAI_PROC_SELF_MAPS, "r");
    if (!maps)
      break;

    for (;;)
    {
      char buffer[PATH_MAX < 1024 ? 1024 : PATH_MAX];
      uint64_t low, high;
      char perms[5];
      uint64_t offset;
      uint32_t major, minor;
      char path[PATH_MAX];
      uint32_t inode;

      if (!fgets(buffer, sizeof(buffer), maps))
        break;

      if (sscanf(buffer, "%" PRIx64 "-%" PRIx64 " %s %" PRIx64 " %x:%x %u %s\n", &low, &high, perms, &offset, &major, &minor, &inode, path) == 8)
      {
        uint64_t addr = (uint64_t)(uintptr_t)WAI_RETURN_ADDRESS();
        if (low <= addr && addr <= high)
        {
          char* resolved;

          resolved = realpath(path, buffer);
          if (!resolved)
            break;

          length = (int)strlen(resolved);
#if defined(__ANDROID__) || defined(ANDROID)
          if (length > 4
              &&buffer[length - 1] == 'k'
              &&buffer[length - 2] == 'p'
              &&buffer[length - 3] == 'a'
              &&buffer[length - 4] == '.')
          {
            int fd = open(path, O_RDONLY);
            char* begin;
            char* p;

            begin = (char*)mmap(0, offset, PROT_READ, MAP_SHARED, fd, 0);
            p = begin + offset;

            while (p >= begin) // scan backwards
            {
              if (*((uint32_t*)p) == 0x04034b50UL) // local file header found
              {
                uint16_t length_ = *((uint16_t*)(p + 26));

                if (length + 2 + length_ < (int)sizeof(buffer))
                {
                  memcpy(&buffer[length], "!/", 2);
                  memcpy(&buffer[length + 2], p + 30, length_);
                  length += 2 + length_;
                }

                break;
              }

              p -= 4;
            }

            munmap(begin, offset);
            close(fd);
          }
#endif
          if (length <= capacity)
          {
            memcpy(out, resolved, length);

            if (dirname_length)
            {
              int i;

              for (i = length - 1; i >= 0; --i)
              {
                if (out[i] == '/')
                {
                  *dirname_length = i;
                  break;
                }
              }
            }
          }

          break;
        }
      }
    }

    fclose(maps);

    if (length != -1)
      break;
  }

  return length;
}

#elif defined(__APPLE__)

#define _DARWIN_BETTER_REALPATH
#include <mach-o/dyld.h>
#include <limits.h>
#include <stdlib.h>
#include <string.h>
#include <dlfcn.h>

WAI_FUNCSPEC
int WAI_PREFIX(getExecutablePath)(char* out, int capacity, int* dirname_length)
{
  char buffer1[PATH_MAX];
  char buffer2[PATH_MAX];
  char* path = buffer1;
  char* resolved = NULL;
  int length = -1;

  for (;;)
  {
    uint32_t size = (uint32_t)sizeof(buffer1);
    if (_NSGetExecutablePath(path, &size) == -1)
    {
      path = (char*)WAI_MALLOC(size);
      if (!_NSGetExecutablePath(path, &size))
        break;
    }

    resolved = realpath(path, buffer2);
    if (!resolved)
      break;

    length = (int)strlen(resolved);
    if (length <= capacity)
    {
      memcpy(out, resolved, length);

      if (dirname_length)
      {
        int i;

        for (i = length - 1; i >= 0; --i)
        {
          if (out[i] == '/')
          {
            *dirname_length = i;
            break;
          }
        }
      }
    }

    break;
  }

  if (path != buffer1)
    WAI_FREE(path);

  return length;
}

WAI_NOINLINE
WAI_FUNCSPEC
int WAI_PREFIX(getModulePath)(char* out, int capacity, int* dirname_length)
{
  char buffer[PATH_MAX];
  char* resolved = NULL;
  int length = -1;

  for(;;)
  {
    Dl_info info;

    if (dladdr(WAI_RETURN_ADDRESS(), &info))
    {
      resolved = realpath(info.dli_fname, buffer);
      if (!resolved)
        break;

      length = (int)strlen(resolved);
      if (length <= capacity)
      {
        memcpy(out, resolved, length);

        if (dirname_length)
        {
          int i;

          for (i = length - 1; i >= 0; --i)
          {
            if (out[i] == '/')
            {
              *dirname_length = i;
              break;
            }
          }
        }
      }
    }

    break;
  }

  return length;
}

#elif defined(__QNXNTO__)

#include <limits.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <dlfcn.h>

#if !defined(WAI_PROC_SELF_EXE)
#define WAI_PROC_SELF_EXE "/proc/self/exefile"
#endif

WAI_FUNCSPEC
int WAI_PREFIX(getExecutablePath)(char* out, int capacity, int* dirname_length)
{
  char buffer1[PATH_MAX];
  char buffer2[PATH_MAX];
  char* resolved = NULL;
  FILE* self_exe = NULL;
  int length = -1;

  for (;;)
  {
    self_exe = fopen(WAI_PROC_SELF_EXE, "r");
    if (!self_exe)
      break;

    if (!fgets(buffer1, sizeof(buffer1), self_exe))
      break;

    resolved = realpath(buffer1, buffer2);
    if (!resolved)
      break;

    length = (int)strlen(resolved);
    if (length <= capacity)
    {
      memcpy(out, resolved, length);

      if (dirname_length)
      {
        int i;

        for (i = length - 1; i >= 0; --i)
        {
          if (out[i] == '/')
          {
            *dirname_length = i;
            break;
          }
        }
      }
    }

    break;
  }

  fclose(self_exe);

  return length;
}

WAI_FUNCSPEC
int WAI_PREFIX(getModulePath)(char* out, int capacity, int* dirname_length)
{
  char buffer[PATH_MAX];
  char* resolved = NULL;
  int length = -1;

  for(;;)
  {
    Dl_info info;

    if (dladdr(WAI_RETURN_ADDRESS(), &info))
    {
      resolved = realpath(info.dli_fname, buffer);
      if (!resolved)
        break;

      length = (int)strlen(resolved);
      if (length <= capacity)
      {
        memcpy(out, resolved, length);

        if (dirname_length)
        {
          int i;

          for (i = length - 1; i >= 0; --i)
          {
            if (out[i] == '/')
            {
              *dirname_length = i;
              break;
            }
          }
        }
      }
    }

    break;
  }

  return length;
}

#elif defined(__DragonFly__) || defined(__FreeBSD__) || \
      defined(__FreeBSD_kernel__) || defined(__NetBSD__)

#include <limits.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/sysctl.h>
#include <dlfcn.h>

WAI_FUNCSPEC
int WAI_PREFIX(getExecutablePath)(char* out, int capacity, int* dirname_length)
{
  char buffer1[PATH_MAX];
  char buffer2[PATH_MAX];
  char* path = buffer1;
  char* resolved = NULL;
  int length = -1;

  for (;;)
  {
    int mib[4] = { CTL_KERN, KERN_PROC, KERN_PROC_PATHNAME, -1 };
    size_t size = sizeof(buffer1);

    if (sysctl(mib, (u_int)(sizeof(mib) / sizeof(mib[0])), path, &size, NULL, 0) != 0)
        break;

    resolved = realpath(path, buffer2);
    if (!resolved)
      break;

    length = (int)strlen(resolved);
    if (length <= capacity)
    {
      memcpy(out, resolved, length);

      if (dirname_length)
      {
        int i;

        for (i = length - 1; i >= 0; --i)
        {
          if (out[i] == '/')
          {
            *dirname_length = i;
            break;
          }
        }
      }
    }

    break;
  }

  if (path != buffer1)
    WAI_FREE(path);

  return length;
}

WAI_NOINLINE
WAI_FUNCSPEC
int WAI_PREFIX(getModulePath)(char* out, int capacity, int* dirname_length)
{
  char buffer[PATH_MAX];
  char* resolved = NULL;
  int length = -1;

  for(;;)
  {
    Dl_info info;

    if (dladdr(WAI_RETURN_ADDRESS(), &info))
    {
      resolved = realpath(info.dli_fname, buffer);
      if (!resolved)
        break;

      length = (int)strlen(resolved);
      if (length <= capacity)
      {
        memcpy(out, resolved, length);

        if (dirname_length)
        {
          int i;

          for (i = length - 1; i >= 0; --i)
          {
            if (out[i] == '/')
            {
              *dirname_length = i;
              break;
            }
          }
        }
      }
    }

    break;
  }

  return length;
}

#else

#error unsupported platform

#endif

#ifdef __cplusplus
}
#endif
Commit	Line	Data
b804b9cd	1	// (‑●‑●)> released under the WTFPL v2 license, by Gregory Pakosz (@gpakosz)
	2	// https://github.com/gpakosz/whereami
	3
	4	// in case you want to #include "whereami.c" in a larger compilation unit
	5	#if !defined(WHEREAMI_H)
	6	#include <whereami.h>
	7	#endif
	8
	9	#ifdef __cplusplus
	10	extern "C" {
	11	#endif
	12
	13	#if !defined(WAI_MALLOC) \|\| !defined(WAI_FREE) \|\| !defined(WAI_REALLOC)
	14	#include <stdlib.h>
	15	#endif
	16
	17	#if !defined(WAI_MALLOC)
	18	#define WAI_MALLOC(size) malloc(size)
	19	#endif
	20
	21	#if !defined(WAI_FREE)
	22	#define WAI_FREE(p) free(p)
	23	#endif
	24
	25	#if !defined(WAI_REALLOC)
	26	#define WAI_REALLOC(p, size) realloc(p, size)
	27	#endif
	28
	29	#ifndef WAI_NOINLINE
	30	#if defined(_MSC_VER)
	31	#define WAI_NOINLINE __declspec(noinline)
	32	#elif defined(__GNUC__)
	33	#define WAI_NOINLINE __attribute__((noinline))
	34	#else
	35	#error unsupported compiler
	36	#endif
	37	#endif
	38
	39	#if defined(_MSC_VER)
	40	#define WAI_RETURN_ADDRESS() _ReturnAddress()
	41	#elif defined(__GNUC__)
	42	#define WAI_RETURN_ADDRESS() __builtin_extract_return_addr(__builtin_return_address(0))
	43	#else
	44	#error unsupported compiler
	45	#endif
	46
	47	#if defined(_WIN32)
	48
	49	#define WIN32_LEAN_AND_MEAN
	50	#if defined(_MSC_VER)
	51	#pragma warning(push, 3)
	52	#endif
	53	#include <windows.h>
	54	#if defined(_MSC_VER)
	55	#pragma warning(pop)
	56	#endif
	57
	58	static int WAI_PREFIX(getModulePath_)(HMODULE module, char* out, int capacity, int* dirname_length)
	59	{
	60	wchar_t buffer1[MAX_PATH];
	61	wchar_t buffer2[MAX_PATH];
	62	wchar_t* path = NULL;
	63	int length = -1;
	64
65	for (;;)
66	{
67	DWORD size;
68	int length_, length__;
69
70	size = GetModuleFileNameW(module, buffer1, sizeof(buffer1) / sizeof(buffer1[0]));
71
72	if (size == 0)
73	break;
74	else if (size == (DWORD)(sizeof(buffer1) / sizeof(buffer1[0])))
75	{
76	DWORD size_ = size;
77	do
78	{
79	wchar_t* path_;
80
81	path_ = (wchar_t)WAI_REALLOC(path, sizeof(wchar_t) size_ * 2);
82	if (!path_)
83	break;
84	size_ *= 2;
85	path = path_;
86	size = GetModuleFileNameW(module, path, size_);
87	}
88	while (size == size_);
89
90	if (size == size_)
91	break;
92	}
93	else
94	path = buffer1;
95
96	if (!_wfullpath(buffer2, path, MAX_PATH))
97	break;
98	length_ = (int)wcslen(buffer2);
99	length__ = WideCharToMultiByte(CP_UTF8, 0, buffer2, length_ , out, capacity, NULL, NULL);
100
101	if (length__ == 0)
102	length__ = WideCharToMultiByte(CP_UTF8, 0, buffer2, length_, NULL, 0, NULL, NULL);
103	if (length__ == 0)
104	break;
105
106	if (length__ <= capacity && dirname_length)
107	{
108	int i;
109
110	for (i = length__ - 1; i >= 0; --i)
111	{
112	if (out[i] == '\\')
113	{
114	*dirname_length = i;
115	break;
116	}
117	}
118	}
119
120	length = length__;
121
122	break;
123	}
124
125	if (path != buffer1)
126	WAI_FREE(path);
127
128	return length;
129	}
130
131	WAI_NOINLINE
132	WAI_FUNCSPEC
133	int WAI_PREFIX(getExecutablePath)(char* out, int capacity, int* dirname_length)
134	{
135	return WAI_PREFIX(getModulePath_)(NULL, out, capacity, dirname_length);
136	}
137
d32691f1	138	/*
b804b9cd	139	WAI_NOINLINE
	140	WAI_FUNCSPEC
	141	int WAI_PREFIX(getModulePath)(char* out, int capacity, int* dirname_length)
	142	{
	143	HMODULE module;
	144	int length = -1;
	145
	146	#if defined(_MSC_VER)
	147	#pragma warning(push)
	148	#pragma warning(disable: 4054)
	149	#endif
d32691f1	150	if (GetModuleHandleEx(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS \| GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT, (LPCTSTR)WAI_RETURN_ADDRESS(), &module))
b804b9cd	151	#if defined(_MSC_VER)
	152	#pragma warning(pop)
	153	#endif
	154	{
	155	length = WAI_PREFIX(getModulePath_)(module, out, capacity, dirname_length);
	156	}
	157
	158	return length;
	159	}
d32691f1	160	*/
b804b9cd	161
	162	#elif defined(__linux__)
	163
	164	#include <stdio.h>
	165	#include <stdlib.h>
	166	#include <string.h>
	167	#include <linux/limits.h>
	168	#ifndef __STDC_FORMAT_MACROS
	169	#define __STDC_FORMAT_MACROS
	170	#endif
	171	#include <inttypes.h>
	172
	173	#if !defined(WAI_PROC_SELF_EXE)
	174	#define WAI_PROC_SELF_EXE "/proc/self/exe"
	175	#endif
	176
	177	WAI_FUNCSPEC
	178	int WAI_PREFIX(getExecutablePath)(char* out, int capacity, int* dirname_length)
	179	{
	180	char buffer[PATH_MAX];
	181	char* resolved = NULL;
	182	int length = -1;
	183
	184	for (;;)
	185	{
	186	resolved = realpath(WAI_PROC_SELF_EXE, buffer);
	187	if (!resolved)
	188	break;
	189
	190	length = (int)strlen(resolved);
	191	if (length <= capacity)
	192	{
	193	memcpy(out, resolved, length);
	194
	195	if (dirname_length)
	196	{
	197	int i;
	198
	199	for (i = length - 1; i >= 0; --i)
	200	{
	201	if (out[i] == '/')
	202	{
	203	*dirname_length = i;
	204	break;
	205	}
	206	}
	207	}
	208	}
	209
	210	break;
	211	}
	212
	213	return length;
	214	}
	215
	216	#if !defined(WAI_PROC_SELF_MAPS_RETRY)
	217	#define WAI_PROC_SELF_MAPS_RETRY 5
	218	#endif
	219
	220	#if !defined(WAI_PROC_SELF_MAPS)
	221	#define WAI_PROC_SELF_MAPS "/proc/self/maps"
	222	#endif
	223
	224	#if defined(__ANDROID__) \|\| defined(ANDROID)
225	#include <fcntl.h>
226	#include <sys/mman.h>
227	#endif
228
229	WAI_NOINLINE
230	WAI_FUNCSPEC
231	int WAI_PREFIX(getModulePath)(char* out, int capacity, int* dirname_length)
232	{
233	int length = -1;
234	FILE* maps = NULL;
235	int i;
236
237	for (i = 0; i < WAI_PROC_SELF_MAPS_RETRY; ++i)
238	{
239	maps = fopen(WAI_PROC_SELF_MAPS, "r");
240	if (!maps)
241	break;
242
243	for (;;)
244	{
245	char buffer[PATH_MAX < 1024 ? 1024 : PATH_MAX];
246	uint64_t low, high;
247	char perms[5];
248	uint64_t offset;
249	uint32_t major, minor;
250	char path[PATH_MAX];
251	uint32_t inode;
252
253	if (!fgets(buffer, sizeof(buffer), maps))
254	break;
255
256	if (sscanf(buffer, "%" PRIx64 "-%" PRIx64 " %s %" PRIx64 " %x:%x %u %s\n", &low, &high, perms, &offset, &major, &minor, &inode, path) == 8)
257	{
258	uint64_t addr = (uint64_t)(uintptr_t)WAI_RETURN_ADDRESS();
259	if (low <= addr && addr <= high)
260	{
261	char* resolved;
262
263	resolved = realpath(path, buffer);
264	if (!resolved)
265	break;
266
267	length = (int)strlen(resolved);
268	#if defined(__ANDROID__) \|\| defined(ANDROID)
269	if (length > 4
270	&&buffer[length - 1] == 'k'
271	&&buffer[length - 2] == 'p'
272	&&buffer[length - 3] == 'a'
273	&&buffer[length - 4] == '.')
274	{
275	int fd = open(path, O_RDONLY);
276	char* begin;
277	char* p;
278
279	begin = (char*)mmap(0, offset, PROT_READ, MAP_SHARED, fd, 0);
280	p = begin + offset;
281
282	while (p >= begin) // scan backwards
283	{
284	if (((uint32_t)p) == 0x04034b50UL) // local file header found
285	{
286	uint16_t length_ = ((uint16_t)(p + 26));
287
288	if (length + 2 + length_ < (int)sizeof(buffer))
289	{
290	memcpy(&buffer[length], "!/", 2);
291	memcpy(&buffer[length + 2], p + 30, length_);
292	length += 2 + length_;
293	}
294
295	break;
296	}
297
298	p -= 4;
299	}
300
301	munmap(begin, offset);
302	close(fd);
303	}
304	#endif
305	if (length <= capacity)
306	{
307	memcpy(out, resolved, length);
308
309	if (dirname_length)
310	{
311	int i;
312
313	for (i = length - 1; i >= 0; --i)
314	{
315	if (out[i] == '/')
316	{
317	*dirname_length = i;
318	break;
319	}
320	}
321	}
322	}
323
324	break;
325	}
326	}
327	}
328
329	fclose(maps);
330
331	if (length != -1)
332	break;
333	}
334
335	return length;
336	}
337
338	#elif defined(__APPLE__)
339
340	#define _DARWIN_BETTER_REALPATH
341	#include <mach-o/dyld.h>
342	#include <limits.h>
343	#include <stdlib.h>
344	#include <string.h>
345	#include <dlfcn.h>
346
347	WAI_FUNCSPEC
348	int WAI_PREFIX(getExecutablePath)(char* out, int capacity, int* dirname_length)
349	{
350	char buffer1[PATH_MAX];
351	char buffer2[PATH_MAX];
352	char* path = buffer1;
353	char* resolved = NULL;
354	int length = -1;
355
356	for (;;)
357	{
358	uint32_t size = (uint32_t)sizeof(buffer1);
359	if (_NSGetExecutablePath(path, &size) == -1)
360	{
361	path = (char*)WAI_MALLOC(size);
362	if (!_NSGetExecutablePath(path, &size))
363	break;
364	}
365
366	resolved = realpath(path, buffer2);
367	if (!resolved)
368	break;
369
370	length = (int)strlen(resolved);
371	if (length <= capacity)
372	{
373	memcpy(out, resolved, length);
374
375	if (dirname_length)
376	{
377	int i;
378
379	for (i = length - 1; i >= 0; --i)
380	{
381	if (out[i] == '/')
382	{
383	*dirname_length = i;
384	break;
385	}
386	}
387	}
388	}
389
390	break;
391	}
392
393	if (path != buffer1)
394	WAI_FREE(path);
395
396	return length;
397	}
398
399	WAI_NOINLINE
400	WAI_FUNCSPEC
401	int WAI_PREFIX(getModulePath)(char* out, int capacity, int* dirname_length)
402	{
403	char buffer[PATH_MAX];
404	char* resolved = NULL;
405	int length = -1;
406
407	for(;;)
408	{
409	Dl_info info;
410
411	if (dladdr(WAI_RETURN_ADDRESS(), &info))
412	{
413	resolved = realpath(info.dli_fname, buffer);
414	if (!resolved)
415	break;
416
417	length = (int)strlen(resolved);
418	if (length <= capacity)
419	{
420	memcpy(out, resolved, length);
421
422	if (dirname_length)
423	{
424	int i;
425
426	for (i = length - 1; i >= 0; --i)
427	{
428	if (out[i] == '/')
429	{
430	*dirname_length = i;
431	break;
432	}
433	}
434	}
435	}
436	}
437
438	break;
439	}
440
441	return length;
442	}
443
444	#elif defined(__QNXNTO__)
445
446	#include <limits.h>
447	#include <stdio.h>
448	#include <stdlib.h>
449	#include <string.h>
450	#include <dlfcn.h>
451
452	#if !defined(WAI_PROC_SELF_EXE)
453	#define WAI_PROC_SELF_EXE "/proc/self/exefile"
454	#endif
455
456	WAI_FUNCSPEC
457	int WAI_PREFIX(getExecutablePath)(char* out, int capacity, int* dirname_length)
458	{
459	char buffer1[PATH_MAX];
460	char buffer2[PATH_MAX];
461	char* resolved = NULL;
462	FILE* self_exe = NULL;
463	int length = -1;
464
465	for (;;)
466	{
467	self_exe = fopen(WAI_PROC_SELF_EXE, "r");
468	if (!self_exe)
469	break;
470
471	if (!fgets(buffer1, sizeof(buffer1), self_exe))
472	break;
473
474	resolved = realpath(buffer1, buffer2);
475	if (!resolved)
476	break;
477
478	length = (int)strlen(resolved);
479	if (length <= capacity)
480	{
481	memcpy(out, resolved, length);
482
483	if (dirname_length)
484	{
485	int i;
486
487	for (i = length - 1; i >= 0; --i)
488	{
489	if (out[i] == '/')
490	{
491	*dirname_length = i;
492	break;
493	}
494	}
495	}
496	}
497
498	break;
499	}
500
501	fclose(self_exe);
502
503	return length;
504	}
505
506	WAI_FUNCSPEC
507	int WAI_PREFIX(getModulePath)(char* out, int capacity, int* dirname_length)
508	{
509	char buffer[PATH_MAX];
510	char* resolved = NULL;
511	int length = -1;
512
513	for(;;)
514	{
515	Dl_info info;
516
517	if (dladdr(WAI_RETURN_ADDRESS(), &info))
518	{
519	resolved = realpath(info.dli_fname, buffer);
520	if (!resolved)
521	break;
522
523	length = (int)strlen(resolved);
524	if (length <= capacity)
525	{
526	memcpy(out, resolved, length);
527
528	if (dirname_length)
529	{
530	int i;
531
532	for (i = length - 1; i >= 0; --i)
533	{
534	if (out[i] == '/')
535	{
536	*dirname_length = i;
537	break;
538	}
539	}
540	}
541	}
542	}
543
544	break;
545	}
546
547	return length;
548	}
549
550	#elif defined(__DragonFly__) \|\| defined(__FreeBSD__) \|\| \
551	defined(__FreeBSD_kernel__) \|\| defined(__NetBSD__)
552
553	#include <limits.h>
554	#include <stdlib.h>
555	#include <string.h>
556	#include <sys/types.h>
557	#include <sys/sysctl.h>
558	#include <dlfcn.h>
559
560	WAI_FUNCSPEC
561	int WAI_PREFIX(getExecutablePath)(char* out, int capacity, int* dirname_length)
562	{
563	char buffer1[PATH_MAX];
564	char buffer2[PATH_MAX];
565	char* path = buffer1;
566	char* resolved = NULL;
567	int length = -1;
568
569	for (;;)
570	{
571	int mib[4] = { CTL_KERN, KERN_PROC, KERN_PROC_PATHNAME, -1 };
572	size_t size = sizeof(buffer1);
573
574	if (sysctl(mib, (u_int)(sizeof(mib) / sizeof(mib[0])), path, &size, NULL, 0) != 0)
575	break;
576
577	resolved = realpath(path, buffer2);
578	if (!resolved)
579	break;
580
581	length = (int)strlen(resolved);
582	if (length <= capacity)
583	{
584	memcpy(out, resolved, length);
585
586	if (dirname_length)
587	{
588	int i;
589
590	for (i = length - 1; i >= 0; --i)
591	{
592	if (out[i] == '/')
593	{
594	*dirname_length = i;
595	break;
596	}
597	}
598	}
599	}
600
601	break;
602	}
603
604	if (path != buffer1)
605	WAI_FREE(path);
606
607	return length;
608	}
609
610	WAI_NOINLINE
611	WAI_FUNCSPEC
612	int WAI_PREFIX(getModulePath)(char* out, int capacity, int* dirname_length)
613	{
614	char buffer[PATH_MAX];
615	char* resolved = NULL;
616	int length = -1;
617
618	for(;;)
619	{
620	Dl_info info;
621
622	if (dladdr(WAI_RETURN_ADDRESS(), &info))
623	{
624	resolved = realpath(info.dli_fname, buffer);
625	if (!resolved)
626	break;
627
628	length = (int)strlen(resolved);
629	if (length <= capacity)
630	{
631	memcpy(out, resolved, length);
632
633	if (dirname_length)
634	{
635	int i;
636
637	for (i = length - 1; i >= 0; --i)
638	{
639	if (out[i] == '/')
640	{
641	*dirname_length = i;
642	break;
643	}
644	}
645	}
646	}
647	}
648
649	break;
650	}
651
652	return length;
653	}
654
655	#else
656
657	#error unsupported platform
658
659	#endif
660
661	#ifdef __cplusplus
662	}
663	#endif