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