Git conversion: Make reactos the root directory, move rosapps, rostests, wallpapers into modules, and delete rossubsys.

sdk/lib/3rdparty/libmpg123/compat/compat.c

@@ -0,0 +1,665 @@
+/*
+	compat: Some compatibility functions (basic memory & string stuff in separate file)
+
+	The mpg123 code is determined to keep it's legacy. A legacy of old, old UNIX.
+	So anything possibly somewhat advanced should be considered to be put here, with proper #ifdef;-)
+
+	copyright 2007-2016 by the mpg123 project - free software under the terms of the LGPL 2.1
+	see COPYING and AUTHORS files in distribution or http://mpg123.org
+	initially written by Thomas Orgis, Windows Unicode stuff by JonY.
+*/
+
+#include "config.h"
+/* This source file does need _POSIX_SOURCE to get some sigaction. */
+#define _POSIX_SOURCE
+#include "compat.h"
+
+#ifdef _MSC_VER
+#include <io.h>
+
+#if(defined(WINAPI_FAMILY) && (WINAPI_FAMILY==WINAPI_FAMILY_APP))
+#define WINDOWS_UWP
+#endif
+
+#endif
+#ifdef HAVE_SYS_STAT_H
+#  include <sys/stat.h>
+#endif
+#ifdef HAVE_DIRENT_H
+#  include <dirent.h>
+#endif
+
+/* Win32 is only supported with unicode now. These headers also cover
+   module stuff. The WANT_WIN32_UNICODE macro is synonymous with
+   "want windows-specific API, and only the unicode variants of which". */
+#ifdef WANT_WIN32_UNICODE
+#include <wchar.h>
+#include <windows.h>
+#include <winnls.h>
+#include <shlwapi.h>
+#endif
+
+#ifdef USE_MODULES
+#  ifdef HAVE_DLFCN_H
+#    include <dlfcn.h>
+#  endif
+#endif
+
+#include "debug.h"
+
+#ifndef WINDOWS_UWP
+
+char *compat_getenv(const char* name)
+{
+	char *ret = NULL;
+#ifdef WANT_WIN32_UNICODE
+	wchar_t *env;
+	wchar_t *wname = NULL;
+	if(win32_utf8_wide(name, &wname, NULL) > 0)
+	{
+		env = _wgetenv(wname);
+		free(wname);
+		if(env)
+			win32_wide_utf8(env, &ret, NULL);
+	}
+#else
+	ret = getenv(name);
+	if(ret)
+		ret = compat_strdup(ret);
+#endif
+	return ret;
+}
+
+#ifdef WANT_WIN32_UNICODE
+
+/* Convert unix UTF-8 (or ASCII) paths to Windows wide character paths. */
+static wchar_t* u2wpath(const char *upath)
+{
+	wchar_t* wpath, *p;
+	if(!upath || win32_utf8_wide(upath, &wpath, NULL) < 1)
+		return NULL;
+	for(p=wpath; *p; ++p)
+		if(*p == L'/')
+			*p = L'\\';
+	return wpath;
+}
+
+/* Convert Windows wide character paths to unix UTF-8. */
+static char* w2upath(const wchar_t *wpath)
+{
+	char* upath, *p;
+	if(!wpath || win32_wide_utf8(wpath, &upath, NULL) < 1)
+		return NULL;
+	for(p=upath; *p; ++p)
+		if(*p == '\\')
+			*p = '/';
+	return upath;
+}
+
+/* An absolute path that is too long and not already marked with
+   \\?\ can be marked as a long one and still work. */
+static int wpath_need_elongation(wchar_t *wpath)
+{
+	if( wpath && !PathIsRelativeW(wpath)
+	&&	wcslen(wpath) > MAX_PATH-1
+	&&	wcsncmp(L"\\\\?\\", wpath, 4) )
+		return 1;
+	else
+		return 0;
+}
+
+/* Take any wide windows path and turn it into a path that is allowed
+   to be longer than MAX_PATH, if it is not already. */
+static wchar_t* wlongpath(wchar_t *wpath)
+{
+	size_t len, plen;
+	const wchar_t *prefix = L"";
+	wchar_t *wlpath = NULL;
+	if(!wpath)
+		return NULL;
+
+	/* Absolute paths that do not start with \\?\ get that prepended
+	   to allow them being long. */
+	if(!PathIsRelativeW(wpath) && wcsncmp(L"\\\\?\\", wpath, 4))
+	{
+		if(wcslen(wpath) >= 2 && PathIsUNCW(wpath))
+		{
+			/* \\server\path -> \\?\UNC\server\path */
+			prefix = L"\\\\?\\UNC";
+			++wpath; /* Skip the first \. */
+		}
+		else /* c:\some/path -> \\?\c:\some\path */
+			prefix = L"\\\\?\\";
+	}
+	plen = wcslen(prefix);
+	len = plen + wcslen(wpath);
+	wlpath = malloc(len+1*sizeof(wchar_t));
+	if(wlpath)
+	{
+		/* Brute force memory copying, swprintf is too dandy. */
+		memcpy(wlpath, prefix, sizeof(wchar_t)*plen);
+		memcpy(wlpath+plen, wpath, sizeof(wchar_t)*(len-plen));
+		wlpath[len] = 0;
+	}
+	return wlpath;
+}
+
+/* Convert unix path to wide windows path, optionally marking
+   it as long path if necessary. */
+static wchar_t* u2wlongpath(const char *upath)
+{
+	wchar_t *wpath  = NULL;
+	wchar_t *wlpath = NULL;
+	wpath = u2wpath(upath);
+	if(wpath_need_elongation(wpath))
+	{
+		wlpath = wlongpath(wpath);
+		free(wpath);
+		wpath = wlpath;
+	}
+	return wpath;
+}
+
+#endif
+
+#else
+
+static wchar_t* u2wlongpath(const char *upath)
+{
+	wchar_t* wpath, *p;
+	if (!upath || win32_utf8_wide(upath, &wpath, NULL) < 1)
+		return NULL;
+	for (p = wpath; *p; ++p)
+		if (*p == L'/')
+			*p = L'\\';
+	return wpath;
+}
+
+#endif
+
+/* Always add a default permission mask in case of flags|O_CREAT. */
+int compat_open(const char *filename, int flags)
+{
+	int ret;
+#if defined (WANT_WIN32_UNICODE)
+	wchar_t *frag = NULL;
+
+	frag = u2wlongpath(filename);
+	/* Fallback to plain open when ucs-2 conversion fails */
+	if(!frag)
+		goto open_fallback;
+
+	/*Try _wopen */
+	ret = _wopen(frag, flags|_O_BINARY, _S_IREAD | _S_IWRITE);
+	if(ret != -1 )
+		goto open_ok; /* msdn says -1 means failure */
+
+open_fallback:
+#endif
+
+#if (defined(WIN32) && !defined (__CYGWIN__))
+	/* MSDN says POSIX function is deprecated beginning in Visual C++ 2005 */
+	/* Try plain old _open(), if it fails, do nothing */
+	ret = _open(filename, flags|_O_BINARY, _S_IREAD | _S_IWRITE);
+#else
+	ret = open(filename, flags, S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH|S_IWOTH);
+#endif
+
+#if defined (WANT_WIN32_UNICODE)
+open_ok:
+	free(frag);
+#endif
+
+	return ret;
+}
+
+/* Moved over from wav.c, logic with fallbacks added from the
+   example of compat_open(). */
+FILE* compat_fopen(const char *filename, const char *mode)
+{
+	FILE* stream = NULL;
+#ifdef WANT_WIN32_UNICODE
+	int cnt = 0;
+	wchar_t *wname = NULL;
+	wchar_t *wmode = NULL;
+
+	wname = u2wlongpath(filename);
+	if(!wname)
+		goto fopen_fallback;
+	cnt = win32_utf8_wide(mode, &wmode, NULL);
+	if( (wmode == NULL) || (cnt == 0))
+		goto fopen_fallback;
+
+	stream = _wfopen(wname, wmode);
+	if(stream) goto fopen_ok;
+
+fopen_fallback:
+#endif
+	stream = fopen(filename, mode);
+#ifdef WANT_WIN32_UNICODE
+
+fopen_ok:
+	free(wmode);
+	free(wname);
+#endif
+	return stream;
+}
+
+FILE* compat_fdopen(int fd, const char *mode)
+{
+	return fdopen(fd, mode);
+}
+
+int compat_close(int infd)
+{
+#if (defined(WIN32) && !defined (__CYGWIN__)) /* MSDN says POSIX function is deprecated beginning in Visual C++ 2005 */
+	return _close(infd);
+#else
+	return close(infd);
+#endif
+}
+
+int compat_fclose(FILE *stream)
+{
+	return fclose(stream);
+}
+
+/* Windows Unicode stuff */
+
+#ifdef WANT_WIN32_UNICODE
+int win32_wide_utf8(const wchar_t * const wptr, char **mbptr, size_t * buflen)
+{
+  size_t len;
+  char *buf;
+  int ret = 0;
+
+  len = WideCharToMultiByte(CP_UTF8, 0, wptr, -1, NULL, 0, NULL, NULL); /* Get utf-8 string length */
+  buf = calloc(len + 1, sizeof (char)); /* Can we assume sizeof char always = 1? */
+
+  if(!buf) len = 0;
+  else {
+    if (len != 0) ret = WideCharToMultiByte(CP_UTF8, 0, wptr, -1, buf, len, NULL, NULL); /*Do actual conversion*/
+    buf[len] = '0'; /* Must terminate */
+  }
+  *mbptr = buf; /* Set string pointer to allocated buffer */
+  if(buflen != NULL) *buflen = (len) * sizeof (char); /* Give length of allocated memory if needed. */
+  return ret;
+}
+
+int win32_utf8_wide(const char *const mbptr, wchar_t **wptr, size_t *buflen)
+{
+  size_t len;
+  wchar_t *buf;
+  int ret = 0;
+
+  len = MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, mbptr, -1, NULL, 0); /* Get converted size */
+  buf = calloc(len + 1, sizeof (wchar_t)); /* Allocate memory accordingly */
+
+  if(!buf) len = 0;
+  else {
+    if (len != 0) ret = MultiByteToWideChar (CP_UTF8, MB_ERR_INVALID_CHARS, mbptr, -1, buf, len); /* Do conversion */
+    buf[len] = L'0'; /* Must terminate */
+  }
+  *wptr = buf; /* Set string pointer to allocated buffer */
+  if (buflen != NULL) *buflen = len * sizeof (wchar_t); /* Give length of allocated memory if needed. */
+  return ret; /* Number of characters written */
+}
+#endif
+
+#ifndef WINDOWS_UWP
+
+/*
+	The Windows file and path stuff is an extract of jon_y's win32 loader
+	prototype from the loader_rework branch. It's been divided in to
+	reusable functons by ThOr in the hope to work out some generic-looking
+	loader code for both POSIX and Windows. The routines might be
+	helpful for consistent path work in other parts of mpg123, too.
+
+	This all is about getting some working code on a wide range of
+	systems while staying somewhat sane. If it does ridiculously inefficient
+	things with extraneous copies and grabbing of functions that made
+	it late to some official APIs, that's still fine with us.
+*/
+
+char* compat_catpath(const char *prefix, const char* path)
+{
+	char *ret = NULL;
+#ifdef WANT_WIN32_UNICODE
+	wchar_t *wprefix = NULL; /* Wide windows versions of */
+	wchar_t *wpath   = NULL; /* input arguments. */
+	wchar_t *locwret = NULL; /* Tmp return value from LocalAlloc */
+	/*
+		This variation of combinepath can work with long and UNC paths, but
+		is not officially exposed in any DLLs, It also allocates all its buffers
+		internally via LocalAlloc, avoiding buffer overflow problems.
+		ThOr: I presume this hack is for supporting pre-8 Windows, as
+		from Windows 8 on, this is documented in the API.
+	*/
+	HRESULT (__stdcall *mypac)( const wchar_t *in, const wchar_t* more
+	,	unsigned long flags, wchar_t **out ) = NULL;
+	HMODULE pathcch = NULL;
+
+	if(!prefix && !path)
+		goto catpath_end;
+	wprefix = u2wpath(prefix);
+	wpath   = u2wpath(path);
+	if((prefix && !wprefix) || (path && !wpath))
+		goto catpath_end;
+
+	/* Again: I presume this whole fun is to get at PathAllocCombine
+	   even when pathcch.h is not available (like in MinGW32). */
+	if( (pathcch = GetModuleHandleA("kernelbase")) )
+		mypac = (void *)GetProcAddress(pathcch, "PathAllocCombine");
+	if(mypac) /* PATHCCH_ALLOW_LONG_PATH = 1 per API docs */
+	{
+		debug("Actually calling PathAllocCombine!");
+		mypac(wprefix, wpath, 1, &locwret);
+	}
+	else
+	{
+		/* Playing safe, if we'd care much about performance, this would be on
+		   the stack. */
+		locwret = LocalAlloc(LPTR, sizeof(wchar_t)*MAX_PATH);
+		if(locwret)
+			PathCombineW(locwret, wprefix, wpath);
+	}
+	ret = w2upath(locwret);
+
+catpath_end:
+	LocalFree(locwret);
+	free(wprefix);
+	free(wpath);
+#else
+	size_t len, prelen, patlen;
+
+	if(path && path[0] == '/')
+		prefix = NULL; /* Absolute path stays as it is. */
+	prelen = prefix ? strlen(prefix) : 0;
+	patlen = path   ? strlen(path)   : 0;
+	/* Concatenate the two, put a / in between if both present. */
+	len = ((prefix && path) ? 1 : 0) + prelen + patlen;
+	ret = malloc(len+1);
+	if(ret)
+	{
+		size_t off=0;
+		memcpy(ret, prefix, prelen);
+		if(prefix && path)
+			ret[prelen+(off++)] = '/';
+		memcpy(ret+prelen+off, path, patlen);
+		ret[len] = 0;
+	}
+#endif
+	return ret;
+}
+
+int compat_isdir(const char *path)
+{
+	int ret = 0;
+#ifdef WANT_WIN32_UNICODE
+	wchar_t *wpath;
+	wpath = u2wlongpath(path);
+	if(wpath)
+	{
+		DWORD attr = GetFileAttributesW(wpath);
+		if(attr != INVALID_FILE_ATTRIBUTES && attr & FILE_ATTRIBUTE_DIRECTORY)
+			ret=1;
+		free(wpath);
+	}
+#else
+	struct stat sb;
+	if(path && !stat(path, &sb))
+	{
+		if(S_ISDIR(sb.st_mode))
+			ret=1;
+	}
+#endif
+	return ret;
+}
+
+struct compat_dir
+{
+	char *path;
+#ifdef WANT_WIN32_UNICODE
+	int gotone; /* Got a result stored from FindFirstFileW. */
+	WIN32_FIND_DATAW d;
+	HANDLE ffn;
+#else
+	DIR* dir;
+#endif
+};
+
+struct compat_dir* compat_diropen(char *path)
+{
+	struct compat_dir *cd;
+	if(!path)
+		return NULL;
+	cd = malloc(sizeof(*cd));
+	if(!cd)
+		return NULL;
+#ifdef WANT_WIN32_UNICODE
+	cd->gotone = 0;
+	{
+		char *pattern;
+		wchar_t *wpattern;
+		pattern = compat_catpath(path, "*");
+		wpattern = u2wlongpath(pattern);
+		if(wpattern)
+		{
+			cd->ffn = FindFirstFileW(wpattern, &(cd->d));
+			if(cd->ffn == INVALID_HANDLE_VALUE)
+			{
+				/* FindClose() only needed after successful first find, right? */
+				free(cd);
+				cd = NULL;
+			}
+			else
+				cd->gotone = 1;
+		}
+		free(wpattern);
+		free(pattern);
+	}
+#else
+	cd->dir = opendir(path);
+	if(!cd->dir)
+	{
+		free(cd);
+		cd = NULL;
+	}
+#endif
+	if(cd)
+	{
+		cd->path = compat_strdup(path);
+		if(!cd->path)
+		{
+			compat_dirclose(cd);
+			cd = NULL;
+		}
+	}
+	return cd;
+}
+
+void compat_dirclose(struct compat_dir *cd)
+{
+	if(cd)
+	{
+		free(cd->path);
+#ifdef WANT_WIN32_UNICODE
+		FindClose(cd->ffn);
+#else
+		closedir(cd->dir);
+#endif
+		free(cd);
+	}
+}
+
+char* compat_nextfile(struct compat_dir *cd)
+{
+	if(!cd)
+		return NULL;
+#ifdef WANT_WIN32_UNICODE
+	while(cd->gotone || FindNextFileW(cd->ffn, &(cd->d)))
+	{
+		cd->gotone = 0;
+		if(!(cd->d.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY))
+		{
+			char *ret;
+			win32_wide_utf8(cd->d.cFileName, &ret, NULL);
+			return ret;
+		}
+	}
+#else
+	{
+		struct dirent *dp;
+		while((dp = readdir(cd->dir)))
+		{
+			struct stat fst;
+			char *fullpath = compat_catpath(cd->path, dp->d_name);
+			if(fullpath && !stat(fullpath, &fst) && S_ISREG(fst.st_mode))
+			{
+				free(fullpath);
+				return compat_strdup(dp->d_name);
+			}
+			free(fullpath);
+		}
+	}
+#endif
+	return NULL;
+}
+
+char* compat_nextdir(struct compat_dir *cd)
+{
+	if(!cd)
+		return NULL;
+#ifdef WANT_WIN32_UNICODE
+	while(cd->gotone || FindNextFileW(cd->ffn, &(cd->d)))
+	{
+		cd->gotone = 0;
+		if(cd->d.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
+		{
+			char *ret;
+			win32_wide_utf8(cd->d.cFileName, &ret, NULL);
+			return ret;
+		}
+	}
+#else
+	{
+		struct dirent *dp;
+		while((dp = readdir(cd->dir)))
+		{
+			struct stat fst;
+			char *fullpath = compat_catpath(cd->path, dp->d_name);
+			if(fullpath && !stat(fullpath, &fst) && S_ISDIR(fst.st_mode))
+			{
+				free(fullpath);
+				return compat_strdup(dp->d_name);
+			}
+			free(fullpath);
+		}
+	}
+#endif
+	return NULL;
+}
+
+#endif
+
+#ifdef USE_MODULES
+/*
+	This is what I expected the platform-specific dance for dynamic module
+	support to be. Little did I know about the peculiarities of (long)
+	paths and directory/file search on Windows.
+*/
+
+void *compat_dlopen(const char *path)
+{
+	void *handle = NULL;
+#ifdef WANT_WIN32_UNICODE
+	wchar_t *wpath;
+	wpath = u2wlongpath(path);
+	if(wpath)
+		handle = LoadLibraryW(wpath);
+	free(wpath);
+#else
+	handle = dlopen(path, RTLD_NOW);
+#endif
+	return handle;
+}
+
+void *compat_dlsym(void *handle, const char *name)
+{
+	void *sym = NULL;
+	if(!handle)
+		return NULL;
+#ifdef WANT_WIN32_UNICODE
+	sym = GetProcAddress(handle, name);
+#else
+	sym = dlsym(handle, name);
+#endif
+	return sym;
+}
+
+void compat_dlclose(void *handle)
+{
+	if(!handle)
+		return;
+#ifdef WANT_WIN32_UNICODE
+	FreeLibrary(handle);
+#else
+	dlclose(handle);
+#endif
+}
+
+#endif /* USE_MODULES */
+
+
+/* This shall survive signals and any return value less than given byte count
+   is an error */
+size_t unintr_write(int fd, void const *buffer, size_t bytes)
+{
+	size_t written = 0;
+	while(bytes)
+	{
+		ssize_t part = write(fd, (char*)buffer+written, bytes);
+		if(part < 0 && errno != EINTR)
+			break;
+		bytes   -= part;
+		written += part;
+	}
+	return written;
+}
+
+/* Same for reading the data. */
+size_t unintr_read(int fd, void *buffer, size_t bytes)
+{
+	size_t got = 0;
+	while(bytes)
+	{
+		ssize_t part = read(fd, (char*)buffer+got, bytes);
+		if(part < 0 && errno != EINTR)
+			break;
+		bytes -= part;
+		got   += part;
+	}
+	return got;
+}
+
+#ifndef NO_CATCHSIGNAL
+#if (!defined(WIN32) || defined (__CYGWIN__)) && defined(HAVE_SIGNAL_H)
+void (*catchsignal(int signum, void(*handler)()))()
+{
+	struct sigaction new_sa;
+	struct sigaction old_sa;
+
+#ifdef DONT_CATCH_SIGNALS
+	fprintf (stderr, "Not catching any signals.\n");
+	return ((void (*)()) -1);
+#endif
+
+	new_sa.sa_handler = handler;
+	sigemptyset(&new_sa.sa_mask);
+	new_sa.sa_flags = 0;
+	if(sigaction(signum, &new_sa, &old_sa) == -1)
+		return ((void (*)()) -1);
+	return (old_sa.sa_handler);
+}
+#endif
+#endif