compat.c File Reference

#include "config.h"
#include "compat.h"
#include "debug.h"

Include dependency graph for compat.c:

Go to the source code of this file.

Classes
struct	compat_dir

Macros
#define	_POSIX_SOURCE

Functions
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)
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 *cd)
char *	compat_nextfile (struct compat_dir *cd)
char *	compat_nextdir (struct compat_dir *cd)
size_t	unintr_write (int fd, void const *buffer, size_t bytes)
size_t	unintr_read (int fd, void *buffer, size_t bytes)

Macro Definition Documentation

_POSIX_SOURCE

#define _POSIX_SOURCE

Definition at line 14 of file compat.c.

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

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