compat.h File Reference

#include "config.h"
#include "intsym.h"
#include <errno.h>
#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include <signal.h>
#include <unistd.h>
#include <sys/types.h>
#include <inttypes.h>
#include <stdint.h>
#include <limits.h>
#include <string.h>
#include <strings.h>
#include <sys/time.h>
#include <fcntl.h>
#include "true.h"

Include dependency graph for compat.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	inline
#define	SIZE_MAX   ((size_t)-1)
#define	SSIZE_MAX   ((size_t)-1/2)
#define	ULONG_MAX   ((unsigned long)-1)
#define	atobigint   atoll
#define	OFF_P   "li"
#define	SIZE_P   "lu"
#define	SSIZE_P   "li"

Typedefs
typedef unsigned char	byte
typedef long	off_p
typedef unsigned long	size_p
typedef long	ssize_p

Functions
void *	safe_realloc (void *ptr, size_t size)
char *	compat_strdup (const char *s)
char *	compat_getenv (const char *name)
int	compat_open (const char *filename, int flags)
FILE *	compat_fopen (const char *filename, const char *mode)
FILE *	compat_fdopen (int fd, const char *mode)
int	compat_close (int infd)
int	compat_fclose (FILE *stream)
int	win32_wide_utf8 (const wchar_t *const wptr, char **mbptr, size_t *buflen)
int	win32_utf8_wide (const char *const mbptr, wchar_t **wptr, size_t *buflen)
char *	compat_catpath (const char *prefix, const char *path)
int	compat_isdir (const char *path)
struct compat_dir *	compat_diropen (char *path)
void	compat_dirclose (struct compat_dir *)
char *	compat_nextfile (struct compat_dir *)
char *	compat_nextdir (struct compat_dir *)
size_t	unintr_write (int fd, void const *buffer, size_t bytes)
size_t	unintr_read (int fd, void *buffer, size_t bytes)
size_t	unintr_fwrite (const void *ptr, size_t size, size_t nmemb, FILE *stream)

Variables
void(*)()	catchsignal (int signum, void(*handler)())

Macro Definition Documentation

atobigint

#define atobigint   atoll

Definition at line 99 of file compat.h.

inline

#define inline

Definition at line 23 of file compat.h.

OFF_P

#define OFF_P   "li"

Definition at line 131 of file compat.h.

SIZE_MAX

#define SIZE_MAX   ((size_t)-1)

Definition at line 66 of file compat.h.

SIZE_P

#define SIZE_P   "lu"

Definition at line 139 of file compat.h.

SSIZE_MAX

#define SSIZE_MAX   ((size_t)-1/2)

Definition at line 69 of file compat.h.

SSIZE_P

#define SSIZE_P   "li"

Definition at line 147 of file compat.h.

ULONG_MAX

#define ULONG_MAX   ((unsigned long)-1)

Definition at line 72 of file compat.h.

Typedef Documentation

byte

typedef unsigned char byte

Definition at line 104 of file compat.h.

off_p

typedef long off_p

Definition at line 132 of file compat.h.

size_p

typedef unsigned long size_p

Definition at line 140 of file compat.h.

ssize_p

typedef long ssize_p

Definition at line 148 of file compat.h.

Function Documentation

compat_catpath()

char * compat_catpath	(	const char *	prefix,
		const char *	path
	)

Definition at line 324 of file compat.c.

{
    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;
}

compat_close()

int compat_close

(

int

infd

)

Closing a file handle can be platform specific. This function takes a file descriptor that is to be closed.

Parameters

[in]

infd

File descriptor to be closed.

Returns

0 if the file was successfully closed. A return value of -1 indicates an error.

Definition at line 253 of file compat.c.

{
#if (defined(WIN32) && !defined (__CYGWIN__)) /* MSDN says POSIX function is deprecated beginning in Visual C++ 2005 */
    return _close(infd);
#else
    return close(infd);
#endif
}

compat_dirclose()

void compat_dirclose

(

struct compat_dir *

cd

)

Definition at line 481 of file compat.c.

{
    if(cd)
    {
        free(cd->path);
#ifdef WANT_WIN32_UNICODE
        FindClose(cd->ffn);
#else
        closedir(cd->dir);
#endif
        free(cd);
    }
}

compat_diropen()

struct compat_dir * compat_diropen

(

char *

path

)

Definition at line 431 of file compat.c.

{
    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;
}

compat_fclose()

int compat_fclose

(

FILE *

stream

)

Definition at line 262 of file compat.c.

{
    return fclose(stream);
}

compat_fdopen()

FILE * compat_fdopen	(	int	fd,
		const char *	mode
	)

Also fdopen to avoid having to define POSIX macros in various source files.

Definition at line 248 of file compat.c.

{
    return fdopen(fd, mode);
}

compat_fopen()

FILE * compat_fopen	(	const char *	filename,
		const char *	mode
	)

Definition at line 218 of file compat.c.

{
    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;
}

compat_getenv()

char * compat_getenv

(

const char *

name

)

Definition at line 52 of file compat.c.

{
    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;
}

compat_isdir()

int compat_isdir

(

const char *

path

)

Definition at line 395 of file compat.c.

{
    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;
}

compat_nextdir()

char * compat_nextdir

(

struct compat_dir *

cd

)

Definition at line 529 of file compat.c.

{
    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;
}

compat_nextfile()

char * compat_nextfile

(

struct compat_dir *

cd

)

Definition at line 495 of file compat.c.

{
    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;
}

compat_open()

int compat_open	(	const char *	filename,
		int	flags
	)

Opening a file handle can be different. This function here is defined to take a path in native encoding (ISO8859 / UTF-8 / ...), or, when MS Windows Unicode support is enabled, an UTF-8 string that will be converted back to native UCS-2 (wide character) before calling the system's open function.

Parameters

[in]	wptr	Pointer to wide string.
[in]	mbptr	Pointer to multibyte string.

Returns

file descriptor (>=0) or error code.

Definition at line 181 of file compat.c.

{
    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;
}

compat_strdup()

char * compat_strdup

(

const char *

s

)

Definition at line 32 of file compat_str.c.

{
    char *dest = NULL;
    if(src)
    {
        size_t len;
        len = strlen(src)+1;
        if((dest = malloc(len)))
            memcpy(dest, src, len);
    }
    return dest;
}

safe_realloc()

void * safe_realloc	(	void *	ptr,
		size_t	size
	)

Definition at line 16 of file compat_str.c.

{
    if(ptr == NULL) return malloc(size);
    else return realloc(ptr, size);
}

unintr_fwrite()

size_t unintr_fwrite	(	const void *	ptr,
		size_t	size,
		size_t	nmemb,
		FILE *	stream
	)

unintr_read()

size_t unintr_read	(	int	fd,
		void *	buffer,
		size_t	bytes
	)

Definition at line 631 of file compat.c.

{
    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;
}

unintr_write()

size_t unintr_write	(	int	fd,
		void const *	buffer,
		size_t	bytes
	)

Definition at line 616 of file compat.c.

{
    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;
}

win32_utf8_wide()

int win32_utf8_wide	(	const char *const	mbptr,
		wchar_t **	wptr,
		size_t *	buflen
	)

win32_mbc2uni Converts a null terminated UTF-8 string to a UCS-2 equivalent. Caller is supposed to free allocated buffer.

Parameters

[out]	mbptr	Pointer to multibyte string.
[in]	wptr	Pointer to wide string.
[out]	buflen	Optional parameter for length of allocated buffer.

Returns

status of WideCharToMultiByte conversion.

MultiByteToWideChar - https://learn.microsoft.com/en-us/windows/win32/api/stringapiset/nf-stringapiset-multibytetowidechar

win32_wide_utf8()

int win32_wide_utf8	(	const wchar_t *const	wptr,
		char **	mbptr,
		size_t *	buflen
	)

win32_uni2mbc Converts a null terminated UCS-2 string to a multibyte (UTF-8) equivalent. Caller is supposed to free allocated buffer.

Parameters

[in]	wptr	Pointer to wide string.
[out]	mbptr	Pointer to multibyte string.
[out]	buflen	Optional parameter for length of allocated buffer.

Returns

status of WideCharToMultiByte conversion.

WideCharToMultiByte - https://learn.microsoft.com/en-us/windows/win32/api/stringapiset/nf-stringapiset-widechartomultibyte

Variable Documentation

catchsignal

void(*)() catchsignal(int signum, void(*handler)())	(	int	signum,
		void(*)()	handler
	)

Definition at line 291 of file compat.h.