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