root/libs/loader/win32.c

/*
 * $Id$
 *
 * Originally distributed under LPGL 2.1 (or later) by the Wine project.
 *
 * Modified for use with MPlayer, detailed CVS changelog at
 * http://www.mplayerhq.hu/cgi-bin/cvsweb.cgi/main/
 *
 * File now distributed as part of VLC media player with no modifications.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
 */

/***********************************************************

Win32 emulation code. Functions that emulate
responses from corresponding Win32 API calls.
Since we are not going to be able to load
virtually any DLL, we can only implement this
much, adding needed functions with each new codec.

Basic principle of implementation: it's not good
for DLL to know too much about its environment.

************************************************************/

#include "config.h"

#ifdef MPLAYER
#ifdef USE_QTX_CODECS
#define QTX
#endif
#define REALPLAYER
//#define LOADLIB_TRY_NATIVE
#endif

#ifdef QTX
#define PSEUDO_SCREEN_WIDTH     /*640*/800
#define PSEUDO_SCREEN_HEIGHT    /*480*/600
#endif

#include "wine/winbase.h"
#include "wine/winreg.h"
#include "wine/winnt.h"
#include "wine/winerror.h"
#include "wine/debugtools.h"
#include "wine/module.h"
#include "wine/winuser.h"

#include <stdio.h>
#include "win32.h"

#include "registry.h"
#include "loader.h"
#include "com.h"
#include "ext.h"

#include <stdlib.h>
#include <assert.h>
#include <stdarg.h>
#include <ctype.h>
#include <pthread.h>
#include <errno.h>
#ifdef HAVE_MALLOC_H
#include <malloc.h>
#endif
#include <time.h>
#include <math.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/types.h>
#include <dirent.h>
#include <sys/time.h>
#include <sys/timeb.h>
#ifdef  HAVE_KSTAT
#include <kstat.h>
#endif

#if HAVE_VSSCANF
int vsscanf( const char *str, const char *format, va_list ap);
#else
/* system has no vsscanf.  try to provide one */
static int vsscanf( const char *str, const char *format, va_list ap)
{
    long p1 = va_arg(ap, long);
    long p2 = va_arg(ap, long);
    long p3 = va_arg(ap, long);
    long p4 = va_arg(ap, long);
    long p5 = va_arg(ap, long);
    return sscanf(str, format, p1, p2, p3, p4, p5);
}
#endif

static char* def_path = WIN32_PATH;

static void do_cpuid(unsigned int ax, unsigned int *regs)
{
    __asm__ __volatile__
        (
         "pushl %%ebx; pushl %%ecx; pushl %%edx;"
         ".byte  0x0f, 0xa2;"
         "movl   %%eax, (%2);"
         "movl   %%ebx, 4(%2);"
         "movl   %%ecx, 8(%2);"
         "movl   %%edx, 12(%2);"
         "popl %%edx; popl %%ecx; popl %%ebx;"
         : "=a" (ax)
         :  "0" (ax), "S" (regs)
        );
}
static unsigned int c_localcount_tsc()
{
    int a;
    __asm__ __volatile__
        (
         "rdtsc\n\t"
         :"=a"(a)
         :
         :"edx"
        );
    return a;
}
static void c_longcount_tsc(long long* z)
{
    __asm__ __volatile__
        (
         "pushl %%ebx\n\t"
         "movl %%eax, %%ebx\n\t"
         "rdtsc\n\t"
         "movl %%eax, 0(%%ebx)\n\t"
         "movl %%edx, 4(%%ebx)\n\t"
         "popl %%ebx\n\t"
         ::"a"(z)
         :"edx"
        );
}
static unsigned int c_localcount_notsc()
{
    struct timeval tv;
    unsigned limit=~0;
    limit/=1000000;
    gettimeofday(&tv, 0);
    return limit*tv.tv_usec;
}
static void c_longcount_notsc(long long* z)
{
    struct timeval tv;
    unsigned long long result;
    unsigned limit=~0;
    if(!z)return;
    limit/=1000000;
    gettimeofday(&tv, 0);
    result=tv.tv_sec;
    result<<=32;
    result+=limit*tv.tv_usec;
    *z=result;
}
static unsigned int localcount_stub(void);
static void longcount_stub(long long*);
static unsigned int (*localcount)()=localcount_stub;
static void (*longcount)(long long*)=longcount_stub;

static pthread_mutex_t memmut;

static unsigned int localcount_stub(void)
{
    unsigned int regs[4];
    do_cpuid(1, regs);
    if ((regs[3] & 0x00000010) != 0)
    {
        localcount=c_localcount_tsc;
        longcount=c_longcount_tsc;
    }
    else
    {
        localcount=c_localcount_notsc;
        longcount=c_longcount_notsc;
    }
    return localcount();
}
static void longcount_stub(long long* z)
{
    unsigned int regs[4];
    do_cpuid(1, regs);
    if ((regs[3] & 0x00000010) != 0)
    {
        localcount=c_localcount_tsc;
        longcount=c_longcount_tsc;
    }
    else
    {
        localcount=c_localcount_notsc;
        longcount=c_longcount_notsc;
    }
    longcount(z);
}

#ifdef MPLAYER
#include "../mp_msg.h"
#endif
int LOADER_DEBUG=1; // active only if compiled with -DDETAILED_OUT
//#define DETAILED_OUT
static inline void dbgprintf(const char* fmt, ...)
{
#ifdef DETAILED_OUT
    if(LOADER_DEBUG)
    {
        FILE* f;
        va_list va;
        va_start(va, fmt);
        f=fopen("./log", "a");
        vprintf(fmt, va);
        fflush(stdout);
        if(f)
        {
            vfprintf(f, fmt, va);
            fsync(fileno(f));
            fclose(f);
        }
        va_end(va);
    }
#endif
#ifdef MPLAYER
    if (verbose > 2)
    {
        va_list va;
        
        va_start(va, fmt);
        vprintf(fmt, va);
//      mp_dbg(MSGT_WIN32, MSGL_DBG3, fmt, va);
        va_end(va);
    }
  fflush(stdout);
#endif
}


char export_names[300][32]={
    "name1",
    //"name2",
    //"name3"
};
//#define min(x,y) ((x)<(y)?(x):(y))

void destroy_event(void* event);

struct th_list_t;
typedef struct th_list_t{
    int id;
    void* thread;
    struct th_list_t* next;
    struct th_list_t* prev;
} th_list;


// have to be cleared by GARBAGE COLLECTOR
static unsigned char* heap=NULL;
static int heap_counter=0;
static tls_t* g_tls=NULL;
static th_list* list=NULL;

static void test_heap(void)
{
    int offset=0;
    if(heap==0)
        return;
    while(offset<heap_counter)
    {
        if(*(int*)(heap+offset)!=0x433476)
        {
            printf("Heap corruption at address %d\n", offset);
            return;
        }
        offset+=8+*(int*)(heap+offset+4);
    }
    for(;offset<min(offset+1000, 20000000); offset++)
        if(heap[offset]!=0xCC)
        {
            printf("Free heap corruption at address %d\n", offset);
        }
}
#undef MEMORY_DEBUG

#ifdef MEMORY_DEBUG

static void* my_mreq(int size, int to_zero)
{
    static int test=0;
    test++;
    if(test%10==0)printf("Memory: %d bytes allocated\n", heap_counter);
    //    test_heap();
    if(heap==NULL)
    {
        heap=malloc(20000000);
        memset(heap, 0xCC,20000000);
    }
    if(heap==0)
    {
        printf("No enough memory\n");
        return 0;
    }
    if(heap_counter+size>20000000)
    {
        printf("No enough memory\n");
        return 0;
    }
    *(int*)(heap+heap_counter)=0x433476;
    heap_counter+=4;
    *(int*)(heap+heap_counter)=size;
    heap_counter+=4;
    printf("Allocated %d bytes of memory: sys %d, user %d-%d\n", size, heap_counter-8, heap_counter, heap_counter+size);
    if(to_zero)
        memset(heap+heap_counter, 0, size);
    else
        memset(heap+heap_counter, 0xcc, size);  // make crash reproducable
    heap_counter+=size;
    return heap+heap_counter-size;
}
static int my_release(char* memory)
{
    //    test_heap();
    if(memory==NULL)
    {
        printf("ERROR: free(0)\n");
        return 0;
    }
    if(*(int*)(memory-8)!=0x433476)
    {
        printf("MEMORY CORRUPTION !!!!!!!!!!!!!!!!!!!\n");
        return 0;
    }
    printf("Freed %d bytes of memory\n", *(int*)(memory-4));
    //    memset(memory-8, *(int*)(memory-4), 0xCC);
    return 0;
}

#else
#define GARBAGE
typedef struct alloc_header_t alloc_header;
struct alloc_header_t
{
    // let's keep allocated data 16 byte aligned
    alloc_header* prev;
    alloc_header* next;
    long deadbeef;
    long size;
    long type;
    long reserved1;
    long reserved2;
    long reserved3;
};

#ifdef GARBAGE
static alloc_header* last_alloc = NULL;
static int alccnt = 0;
#endif

#define AREATYPE_CLIENT 0
#define AREATYPE_EVENT 1
#define AREATYPE_MUTEX 2
#define AREATYPE_COND 3
#define AREATYPE_CRITSECT 4

/* -- critical sections -- */
struct CRITSECT
{
    pthread_t id;
    pthread_mutex_t mutex;
    int locked;
    long deadbeef;
};

void* mreq_private(int size, int to_zero, int type);
void* mreq_private(int size, int to_zero, int type)
{
    int nsize = size + sizeof(alloc_header);
    alloc_header* header = (alloc_header* ) malloc(nsize);
    if (!header)
        return 0;
    if (to_zero)
        memset(header, 0, nsize);
#ifdef GARBAGE
    if (!last_alloc)
    {
        pthread_mutex_init(&memmut, NULL);
        pthread_mutex_lock(&memmut);
    }
    else
    {
        pthread_mutex_lock(&memmut);
        last_alloc->next = header;  /* set next */
    }

    header->prev = last_alloc;
    header->next = 0;
    last_alloc = header;
    alccnt++;
    pthread_mutex_unlock(&memmut);
#endif
    header->deadbeef = 0xdeadbeef;
    header->size = size;
    header->type = type;

    //if (alccnt < 40000) printf("MY_REQ: %p\t%d   t:%d  (cnt:%d)\n",  header, size, type, alccnt);
    return header + 1;
}

static int my_release(void* memory)
{
    alloc_header* header = (alloc_header*) memory - 1;
#ifdef GARBAGE
    alloc_header* prevmem;
    alloc_header* nextmem;

    if (memory == 0)
        return 0;

    if (header->deadbeef != (long) 0xdeadbeef)
    {
        dbgprintf("FATAL releasing corrupted memory! %p  0x%lx  (%d)\n", header, header->deadbeef, alccnt);
        return 0;
    }

    pthread_mutex_lock(&memmut);

    switch(header->type)
    {
    case AREATYPE_EVENT:
        destroy_event(memory);
        break;
    case AREATYPE_COND:
        pthread_cond_destroy((pthread_cond_t*)memory);
        break;
    case AREATYPE_MUTEX:
        pthread_mutex_destroy((pthread_mutex_t*)memory);
        break;
    case AREATYPE_CRITSECT:
        pthread_mutex_destroy(&((struct CRITSECT*)memory)->mutex);
        break;
    default:
        //memset(memory, 0xcc, header->size);
        ;
    }

    header->deadbeef = 0;
    prevmem = header->prev;
    nextmem = header->next;

    if (prevmem)
        prevmem->next = nextmem;
    if (nextmem)
        nextmem->prev = prevmem;

    if (header == last_alloc)
        last_alloc = prevmem;

    alccnt--;

    if (last_alloc)
        pthread_mutex_unlock(&memmut);
    else
        pthread_mutex_destroy(&memmut);

    //if (alccnt < 40000) printf("MY_RELEASE: %p\t%ld    (%d)\n", header, header->size, alccnt);
#else
    if (memory == 0)
        return 0;
#endif
    //memset(header + 1, 0xcc, header->size);
    free(header);
    return 0;
}
#endif

static inline void* my_mreq(int size, int to_zero)
{
    return mreq_private(size, to_zero, AREATYPE_CLIENT);
}

static int my_size(void* memory)
{
    if(!memory) return 0;
    return ((alloc_header*)memory)[-1].size;
}

static void* my_realloc(void* memory, int size)
{
    void *ans = memory;
    int osize;
    if (memory == NULL)
        return my_mreq(size, 0);
    osize = my_size(memory);
    if (osize < size)
    {
        ans = my_mreq(size, 0);
        memcpy(ans, memory, osize);
        my_release(memory);
    }
    return ans;
}

/*
 *
 *  WINE  API  - native implementation for several win32 libraries
 *
 */

static int WINAPI ext_unknown()
{
    printf("Unknown func called\n");
    return 0;
}

static int  WINAPI expGetVolumeInformationA( const char *root, char *label,
                                       unsigned int label_len, unsigned int *serial,
                                       unsigned int *filename_len,unsigned int *flags,
                                       char *fsname, unsigned int fsname_len )
{
dbgprintf("GetVolumeInformationA( %s, 0x%x, %ld, 0x%x, 0x%x, 0x%x, 0x%x, %ld) => 1\n",
                      root,label,label_len,serial,filename_len,flags,fsname,fsname_len);
//hack Do not return any real data - do nothing
return 1;
}

static unsigned int WINAPI expGetDriveTypeA( const char *root )
{
 dbgprintf("GetDriveTypeA( %s ) => %d\n",root,DRIVE_FIXED);
 // hack return as Fixed Drive Type
 return DRIVE_FIXED;
}

static unsigned int WINAPI expGetLogicalDriveStringsA( unsigned int len, char *buffer )
{
 dbgprintf("GetLogicalDriveStringsA(%d, 0x%x) => 4\n",len,buffer);
 // hack only have one drive c:\ in this hack
  *buffer++='c';
  *buffer++=':';
  *buffer++='\\';
  *buffer++='\0';
  *buffer= '\0';
return 4; // 1 drive * 4 bytes (includes null)
}


static int WINAPI expIsBadWritePtr(void* ptr, unsigned int count)
{
    int result = (count == 0 || ptr != 0) ? 0 : 1;
    dbgprintf("IsBadWritePtr(0x%x, 0x%x) => %d\n", ptr, count, result);
    return result;
}
static int WINAPI expIsBadReadPtr(void* ptr, unsigned int count)
{
    int result = (count == 0 || ptr != 0) ? 0 : 1;
    dbgprintf("IsBadReadPtr(0x%x, 0x%x) => %d\n", ptr, count, result);
    return result;
}
static int WINAPI expDisableThreadLibraryCalls(int module)
{
    dbgprintf("DisableThreadLibraryCalls(0x%x) => 0\n", module);
    return 0;
}

static HMODULE WINAPI expGetDriverModuleHandle(DRVR* pdrv)
{
    HMODULE result;
    if (pdrv==NULL)
        result=0;
    else
        result=pdrv->hDriverModule;
    dbgprintf("GetDriverModuleHandle(%p) => %p\n", pdrv, result);
    return result;
}

#define MODULE_HANDLE_kernel32  ((HMODULE)0x120)
#define MODULE_HANDLE_user32    ((HMODULE)0x121)
#ifdef QTX
#define MODULE_HANDLE_wininet   ((HMODULE)0x122)
#define MODULE_HANDLE_ddraw     ((HMODULE)0x123)
#define MODULE_HANDLE_advapi32  ((HMODULE)0x124)
#endif
#define MODULE_HANDLE_comdlg32  ((HMODULE)0x125)
#define MODULE_HANDLE_msvcrt    ((HMODULE)0x126)
#define MODULE_HANDLE_ole32     ((HMODULE)0x127)
#define MODULE_HANDLE_winmm     ((HMODULE)0x128)

static HMODULE WINAPI expGetModuleHandleA(const char* name)
{
    WINE_MODREF* wm;
    HMODULE result;
    if(!name)
#ifdef QTX
        result=1;
#else
        result=0;
#endif
    else
    {
        wm=MODULE_FindModule(name);
        if(wm==0)result=0;
        else
            result=(HMODULE)(wm->module);
    }
    if(!result)
    {
        if(name && (strcasecmp(name, "kernel32")==0 || !strcasecmp(name, "kernel32.dll")))
            result=MODULE_HANDLE_kernel32;
#ifdef QTX
        if(name && strcasecmp(name, "user32")==0)
            result=MODULE_HANDLE_user32;
#endif
    }
    dbgprintf("GetModuleHandleA('%s') => 0x%x\n", name, result);
    return result;
}

static void* WINAPI expCreateThread(void* pSecAttr, long dwStackSize,
                                    void* lpStartAddress, void* lpParameter,
                                    long dwFlags, long* dwThreadId)
{
    pthread_t *pth;
    //    printf("CreateThread:");
    pth = (pthread_t*) my_mreq(sizeof(pthread_t), 0);
    pthread_create(pth, NULL, (void*(*)(void*))lpStartAddress, lpParameter);
    if(dwFlags)
        printf( "WARNING: CreateThread flags not supported\n");
    if(dwThreadId)
        *dwThreadId=(long)pth;
    if(list==NULL)
    {
        list=my_mreq(sizeof(th_list), 1);
        list->next=list->prev=NULL;
    }
    else
    {
        list->next=my_mreq(sizeof(th_list), 0);
        list->next->prev=list;
        list->next->next=NULL;
        list=list->next;
    }
    list->thread=pth;
    dbgprintf("CreateThread(0x%x, 0x%x, 0x%x, 0x%x, 0x%x, 0x%x) => 0x%x\n",
              pSecAttr, dwStackSize, lpStartAddress, lpParameter, dwFlags, dwThreadId, pth);
    return pth;
}

struct mutex_list_t;

struct mutex_list_t
{
    char type;
    pthread_mutex_t *pm;
    pthread_cond_t  *pc;
    char state;
    char reset;
    char name[128];
    int  semaphore;
    struct mutex_list_t* next;
    struct mutex_list_t* prev;
};
typedef struct mutex_list_t mutex_list;
static mutex_list* mlist=NULL;

void destroy_event(void* event)
{
    mutex_list* pp=mlist;
    //    printf("garbage collector: destroy_event(%x)\n", event);
    while(pp)
    {
        if(pp==(mutex_list*)event)
        {
            if(pp->next)
                pp->next->prev=pp->prev;
            if(pp->prev)
                pp->prev->next=pp->next;
            if(mlist==(mutex_list*)event)
                mlist=mlist->prev;
            /*
             pp=mlist;
             while(pp)
             {
             printf("%x => ", pp);
             pp=pp->prev;
             }
             printf("0\n");
             */
            return;
        }
        pp=pp->prev;
    }
}

static void* WINAPI expCreateEventA(void* pSecAttr, char bManualReset,
                                    char bInitialState, const char* name)
{
    pthread_mutex_t *pm;
    pthread_cond_t  *pc;
    /*
     mutex_list* pp;
     pp=mlist;
     while(pp)
     {
     printf("%x => ", pp);
     pp=pp->prev;
     }
     printf("0\n");
     */
    if(mlist!=NULL)
    {
        mutex_list* pp=mlist;
        if(name!=NULL)
            do
        {
            if((strcmp(pp->name, name)==0) && (pp->type==0))
            {
                dbgprintf("CreateEventA(0x%x, 0x%x, 0x%x, 0x%x='%s') => 0x%x\n",
                          pSecAttr, bManualReset, bInitialState, name, name, pp->pm);
                return pp->pm;
            }
        }while((pp=pp->prev) != NULL);
    }
    pm=mreq_private(sizeof(pthread_mutex_t), 0, AREATYPE_MUTEX);
    pthread_mutex_init(pm, NULL);
    pc=mreq_private(sizeof(pthread_cond_t), 0, AREATYPE_COND);
    pthread_cond_init(pc, NULL);
    if(mlist==NULL)
    {
        mlist=mreq_private(sizeof(mutex_list), 00, AREATYPE_EVENT);
        mlist->next=mlist->prev=NULL;
    }
    else
    {
        mlist->next=mreq_private(sizeof(mutex_list), 00, AREATYPE_EVENT);
        mlist->next->prev=mlist;
        mlist->next->next=NULL;
        mlist=mlist->next;
    }
    mlist->type=0; /* Type Event */
    mlist->pm=pm;
    mlist->pc=pc;
    mlist->state=bInitialState;
    mlist->reset=bManualReset;
    if(name)
        strncpy(mlist->name, name, 127);
    else
        mlist->name[0]=0;
    if(pm==NULL)
        dbgprintf("ERROR::: CreateEventA failure\n");
    /*
     if(bInitialState)
     pthread_mutex_lock(pm);
     */
    if(name)
        dbgprintf("CreateEventA(0x%x, 0x%x, 0x%x, 0x%x='%s') => 0x%x\n",
                  pSecAttr, bManualReset, bInitialState, name, name, mlist);
    else
        dbgprintf("CreateEventA(0x%x, 0x%x, 0x%x, NULL) => 0x%x\n",
                  pSecAttr, bManualReset, bInitialState, mlist);
    return mlist;
}

static void* WINAPI expSetEvent(void* event)
{
    mutex_list *ml = (mutex_list *)event;
    dbgprintf("SetEvent(%x) => 0x1\n", event);
    pthread_mutex_lock(ml->pm);
    if (ml->state == 0) {
        ml->state = 1;
        pthread_cond_signal(ml->pc);
    }
    pthread_mutex_unlock(ml->pm);

    return (void *)1;
}
static void* WINAPI expResetEvent(void* event)
{
    mutex_list *ml = (mutex_list *)event;
    dbgprintf("ResetEvent(0x%x) => 0x1\n", event);
    pthread_mutex_lock(ml->pm);
    ml->state = 0;
    pthread_mutex_unlock(ml->pm);

    return (void *)1;
}

static void* WINAPI expWaitForSingleObject(void* object, int duration)
{
    mutex_list *ml = (mutex_list *)object;
    // FIXME FIXME FIXME - this value is sometime unititialize !!!
    int ret = WAIT_FAILED;
    mutex_list* pp=mlist;
    if(object == (void*)0xcfcf9898)
    {
        /**
         From GetCurrentThread() documentation:
         A pseudo handle is a special constant that is interpreted as the current thread handle. The calling thread can use this handle to specify itself whenever a thread handle is required. Pseudo handles are not inherited by child processes.

         This handle has the maximum possible access to the thread object. For systems that support security descriptors, this is the maximum access allowed by the security descriptor for the calling process. For systems that do not support security descriptors, this is THREAD_ALL_ACCESS.

         The function cannot be used by one thread to create a handle that can be used by other threads to refer to the first thread. The handle is always interpreted as referring to the thread that is using it. A thread can create a "real" handle to itself that can be used by other threads, or inherited by other processes, by specifying the pseudo handle as the source handle in a call to the DuplicateHandle function.
         **/
        dbgprintf("WaitForSingleObject(thread_handle) called\n");
        return (void*)WAIT_FAILED;
    }
    dbgprintf("WaitForSingleObject(0x%x, duration %d) =>\n",object, duration);

    // loop below was slightly fixed - its used just for checking if
    // this object really exists in our list
    if (!ml)
        return (void*) ret;
    while (pp && (pp->pm != ml->pm))
        pp = pp->prev;
    if (!pp) {
        dbgprintf("WaitForSingleObject: NotFound\n");
        return (void*)ret;
    }

    pthread_mutex_lock(ml->pm);

    switch(ml->type) {
    case 0: /* Event */
        if (duration == 0) { /* Check Only */
            if (ml->state == 1) ret = WAIT_FAILED;
            else                   ret = WAIT_OBJECT_0;
        }
        if (duration == -1) { /* INFINITE */
            if (ml->state == 0)
                pthread_cond_wait(ml->pc,ml->pm);
            if (ml->reset)
                ml->state = 0;
            ret = WAIT_OBJECT_0;
        }
        if (duration > 0) {  /* Timed Wait */
            struct timespec abstime;
            struct timeval now;
            gettimeofday(&now, 0);
            abstime.tv_sec = now.tv_sec + (now.tv_usec+duration)/1000000;
            abstime.tv_nsec = ((now.tv_usec+duration)%1000000)*1000;
            if (ml->state == 0)
                ret=pthread_cond_timedwait(ml->pc,ml->pm,&abstime);
            if (ret == ETIMEDOUT) ret = WAIT_TIMEOUT;
            else                  ret = WAIT_OBJECT_0;
            if (ml->reset)
                ml->state = 0;
        }
        break;
    case 1:  /* Semaphore */
        if (duration == 0) {
            if(ml->semaphore==0) ret = WAIT_FAILED;
            else {
                ml->semaphore++;
                ret = WAIT_OBJECT_0;
            }
        }
        if (duration == -1) {
            if (ml->semaphore==0)
                pthread_cond_wait(ml->pc,ml->pm);
            ml->semaphore--;
        }
        break;
    }
    pthread_mutex_unlock(ml->pm);

    dbgprintf("WaitForSingleObject(0x%x, %d): 0x%x => 0x%x \n",object,duration,ml,ret);
    return (void *)ret;
}

#ifdef QTX
static void* WINAPI expWaitForMultipleObjects(int count, const void** objects,
                    int WaitAll, int duration)
{
    int i;
    void *object;
    void *ret;

    dbgprintf("WaitForMultipleObjects(%d, 0x%x, %d, duration %d) =>\n",
        count, objects, WaitAll, duration);
    
    for (i = 0; i < count; i++)
    {
        object = (void *)objects[i];
        ret = expWaitForSingleObject(object, duration);
        if (WaitAll)
            dbgprintf("WaitAll flag not yet supported...\n");
        else
            return ret;
    }
    return NULL;
}

static void WINAPI expExitThread(int retcode)
{
    dbgprintf("ExitThread(%d)\n", retcode);
    pthread_exit(&retcode);
}

static HANDLE WINAPI expCreateMutexA(void *pSecAttr,
                    char bInitialOwner, const char *name)
{
    HANDLE mlist = (HANDLE)expCreateEventA(pSecAttr, 0, 0, name);
    
    if (name)
        dbgprintf("CreateMutexA(0x%x, %d, '%s') => 0x%x\n",
            pSecAttr, bInitialOwner, name, mlist);
    else
        dbgprintf("CreateMutexA