| /* |
| * COMPOBJ library |
| * |
| * Copyright 1995 Martin von Loewis |
| */ |
| |
| #define INITGUID |
| |
| #include <ctype.h> |
| #include <stdlib.h> |
| #include <string.h> |
| #include <time.h> |
| #include "ole.h" |
| #include "ole2.h" |
| #include "winerror.h" |
| #include "debug.h" |
| #include "file.h" |
| #include "compobj.h" |
| #include "heap.h" |
| #include "ldt.h" |
| #include "interfaces.h" |
| #include "shlobj.h" |
| #include "ddraw.h" |
| #include "dsound.h" |
| #include "dinput.h" |
| #include "d3d.h" |
| |
| LPMALLOC16 currentMalloc16=NULL; |
| LPMALLOC32 currentMalloc32=NULL; |
| |
| /*********************************************************************** |
| * CoBuildVersion [COMPOBJ.1] |
| */ |
| DWORD WINAPI CoBuildVersion() |
| { |
| dprintf_info(ole,"CoBuildVersion()\n"); |
| return (rmm<<16)+rup; |
| } |
| |
| /*********************************************************************** |
| * CoInitialize [COMPOBJ.2] |
| * lpReserved is an IMalloc pointer in 16bit OLE. |
| */ |
| HRESULT WINAPI CoInitialize16(LPMALLOC16 lpReserved) |
| { |
| currentMalloc16 = lpReserved; |
| return S_OK; |
| } |
| |
| /*********************************************************************** |
| * CoInitialize (OLE32.26) |
| * lpReserved is an IMalloc pointer in 32bit OLE. |
| */ |
| HRESULT WINAPI CoInitialize32(LPMALLOC32 lpReserved) |
| { |
| currentMalloc32 = lpReserved; |
| return S_OK; |
| } |
| |
| /*********************************************************************** |
| * CoUnitialize [COMPOBJ.3] |
| */ |
| void WINAPI CoUnitialize() |
| { |
| dprintf_info(ole,"CoUnitialize()\n"); |
| } |
| |
| /*********************************************************************** |
| * CoGetMalloc [COMPOBJ.4] |
| */ |
| HRESULT WINAPI CoGetMalloc16(DWORD dwMemContext, LPMALLOC16 * lpMalloc) |
| { |
| if(!currentMalloc16) |
| currentMalloc16 = IMalloc16_Constructor(); |
| *lpMalloc = currentMalloc16; |
| return S_OK; |
| } |
| |
| /*********************************************************************** |
| * CoGetMalloc (OLE32.4] |
| */ |
| HRESULT WINAPI CoGetMalloc32(DWORD dwMemContext, LPMALLOC32 *lpMalloc) |
| { |
| if(!currentMalloc32) |
| currentMalloc32 = IMalloc32_Constructor(); |
| *lpMalloc = currentMalloc32; |
| return S_OK; |
| } |
| |
| /*********************************************************************** |
| * CoDisconnectObject |
| */ |
| OLESTATUS WINAPI CoDisconnectObject( LPUNKNOWN lpUnk, DWORD reserved ) |
| { |
| dprintf_info(ole,"CoDisconnectObject:%p %lx\n",lpUnk,reserved); |
| return S_OK; |
| } |
| |
| /*********************************************************************** |
| * IsEqualGUID [COMPOBJ.18] |
| */ |
| BOOL16 WINAPI IsEqualGUID(GUID* g1, GUID* g2) |
| { |
| return !memcmp( g1, g2, sizeof(GUID) ); |
| } |
| |
| /*********************************************************************** |
| * CLSIDFromString [COMPOBJ.20] |
| */ |
| |
| /* Class id: DWORD-WORD-WORD-BYTES[2]-BYTES[6] */ |
| |
| OLESTATUS WINAPI CLSIDFromString16(const LPCOLESTR16 idstr, CLSID *id) |
| { |
| BYTE *s = (BYTE *) idstr; |
| BYTE *p; |
| int i; |
| BYTE table[256]; |
| |
| dprintf_info(ole,"ClsIDFromString() %s -> %p\n", idstr, id); |
| |
| /* quick lookup table */ |
| memset(table, 0, 256); |
| |
| for (i = 0; i < 10; i++) { |
| table['0' + i] = i; |
| } |
| for (i = 0; i < 6; i++) { |
| table['A' + i] = i+10; |
| table['a' + i] = i+10; |
| } |
| |
| /* in form {XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX} */ |
| |
| if (strlen(idstr) != 38) |
| return OLE_ERROR_OBJECT; |
| |
| p = (BYTE *) id; |
| |
| s++; /* skip leading brace */ |
| for (i = 0; i < 4; i++) { |
| p[3 - i] = table[*s]<<4 | table[*(s+1)]; |
| s += 2; |
| } |
| p += 4; |
| s++; /* skip - */ |
| |
| for (i = 0; i < 2; i++) { |
| p[1-i] = table[*s]<<4 | table[*(s+1)]; |
| s += 2; |
| } |
| p += 2; |
| s++; /* skip - */ |
| |
| for (i = 0; i < 2; i++) { |
| p[1-i] = table[*s]<<4 | table[*(s+1)]; |
| s += 2; |
| } |
| p += 2; |
| s++; /* skip - */ |
| |
| /* these are just sequential bytes */ |
| for (i = 0; i < 2; i++) { |
| *p++ = table[*s]<<4 | table[*(s+1)]; |
| s += 2; |
| } |
| s++; /* skip - */ |
| |
| for (i = 0; i < 6; i++) { |
| *p++ = table[*s]<<4 | table[*(s+1)]; |
| s += 2; |
| } |
| |
| return S_OK; |
| } |
| |
| /*********************************************************************** |
| * CLSIDFromString (OLE32.3) |
| */ |
| OLESTATUS WINAPI CLSIDFromString32(const LPCOLESTR32 idstr, CLSID *id) |
| { |
| LPOLESTR16 xid = HEAP_strdupWtoA(GetProcessHeap(),0,idstr); |
| OLESTATUS ret = CLSIDFromString16(xid,id); |
| |
| HeapFree(GetProcessHeap(),0,xid); |
| return ret; |
| } |
| |
| /*********************************************************************** |
| * StringFromCLSID [COMPOBJ.19] |
| */ |
| OLESTATUS WINAPI WINE_StringFromCLSID(const CLSID *id, LPSTR idstr) |
| { |
| static const char *hex = "0123456789ABCDEF"; |
| char *s; |
| int i; |
| |
| sprintf(idstr, "{%08lx-%04x-%04x-%02x%02x-", |
| id->Data1, id->Data2, id->Data3, |
| id->Data4[0], id->Data4[1]); |
| s = &idstr[25]; |
| |
| /* 6 hex bytes */ |
| for (i = 2; i < 8; i++) { |
| *s++ = hex[id->Data4[i]>>4]; |
| *s++ = hex[id->Data4[i] & 0xf]; |
| } |
| |
| *s++ = '}'; |
| *s++ = '\0'; |
| |
| for (i = strlen(idstr)-1; i >= 0; i--) { |
| idstr[i] = toupper(idstr[i]); |
| } |
| |
| dprintf_info(ole,"StringFromClsID: %p->%s\n", id, idstr); |
| |
| return OLE_OK; |
| } |
| |
| OLESTATUS WINAPI StringFromCLSID16(const CLSID *id, LPOLESTR16 *idstr) |
| { |
| LPMALLOC16 mllc; |
| OLESTATUS ret; |
| DWORD args[2]; |
| |
| ret = CoGetMalloc16(0,&mllc); |
| if (ret) return ret; |
| |
| args[0] = (DWORD)mllc; |
| args[1] = 40; |
| |
| /* No need for a Callback entry, we have WOWCallback16Ex which does |
| * everything we need. |
| */ |
| if (!WOWCallback16Ex( |
| (FARPROC16)((LPMALLOC16_VTABLE)PTR_SEG_TO_LIN( |
| ((LPMALLOC16)PTR_SEG_TO_LIN(mllc))->lpvtbl) |
| )->fnAlloc, |
| WCB16_CDECL, |
| 2, |
| (LPVOID)args, |
| (LPDWORD)idstr |
| )) { |
| fprintf(stderr,"CallTo16 IMalloc16 failed\n"); |
| return E_FAIL; |
| } |
| return WINE_StringFromCLSID(id,PTR_SEG_TO_LIN(*idstr)); |
| } |
| |
| OLESTATUS WINAPI StringFromCLSID32(const CLSID *id, LPOLESTR32 *idstr) |
| { |
| char buf[80]; |
| OLESTATUS ret; |
| LPMALLOC32 mllc; |
| |
| if ((ret=CoGetMalloc32(0,&mllc))) |
| return ret; |
| |
| ret=WINE_StringFromCLSID(id,buf); |
| if (!ret) { |
| *idstr = mllc->lpvtbl->fnAlloc(mllc,strlen(buf)*2+2); |
| lstrcpyAtoW(*idstr,buf); |
| } |
| return ret; |
| } |
| |
| |
| /*********************************************************************** |
| * CLSIDFromProgID [COMPOBJ.61] |
| */ |
| |
| OLESTATUS WINAPI CLSIDFromProgID16(LPCSTR progid,LPCLSID riid) |
| { |
| char *buf,buf2[80]; |
| DWORD buf2len; |
| HRESULT err; |
| HKEY xhkey; |
| |
| buf = HeapAlloc(GetProcessHeap(),0,strlen(progid)+8); |
| sprintf(buf,"%s\\CLSID",progid); |
| if ((err=RegOpenKey32A(HKEY_CLASSES_ROOT,buf,&xhkey))) { |
| HeapFree(GetProcessHeap(),0,buf); |
| return OLE_ERROR_GENERIC; |
| } |
| HeapFree(GetProcessHeap(),0,buf); |
| buf2len = sizeof(buf2); |
| if ((err=RegQueryValue32A(xhkey,NULL,buf2,&buf2len))) { |
| RegCloseKey(xhkey); |
| return OLE_ERROR_GENERIC; |
| } |
| RegCloseKey(xhkey); |
| return CLSIDFromString16(buf2,riid); |
| } |
| |
| /*********************************************************************** |
| * CLSIDFromProgID (OLE32.2) |
| */ |
| OLESTATUS WINAPI CLSIDFromProgID32(LPCOLESTR32 progid,LPCLSID riid) |
| { |
| LPOLESTR16 pid = HEAP_strdupWtoA(GetProcessHeap(),0,progid); |
| OLESTATUS ret = CLSIDFromProgID16(pid,riid); |
| |
| HeapFree(GetProcessHeap(),0,pid); |
| return ret; |
| } |
| |
| OLESTATUS WINAPI LookupETask(LPVOID p1,LPVOID p2) { |
| fprintf(stderr,"LookupETask(%p,%p),stub!\n",p1,p2); |
| return 0; |
| } |
| |
| OLESTATUS WINAPI CallObjectInWOW(LPVOID p1,LPVOID p2) { |
| fprintf(stderr,"CallObjectInWOW(%p,%p),stub!\n",p1,p2); |
| return 0; |
| } |
| |
| /*********************************************************************** |
| * CoRegisterClassObject [COMPOBJ.5] |
| */ |
| OLESTATUS WINAPI CoRegisterClassObject16( |
| REFCLSID rclsid, LPUNKNOWN pUnk,DWORD dwClsContext,DWORD flags, |
| LPDWORD lpdwRegister |
| ) { |
| char buf[80]; |
| |
| WINE_StringFromCLSID(rclsid,buf); |
| |
| fprintf(stderr,"CoRegisterClassObject(%s,%p,0x%08lx,0x%08lx,%p),stub\n", |
| buf,pUnk,dwClsContext,flags,lpdwRegister |
| ); |
| return 0; |
| } |
| |
| /*********************************************************************** |
| * CoRegisterClassObject (OLE32.36) |
| */ |
| OLESTATUS WINAPI CoRegisterClassObject32( |
| REFCLSID rclsid, LPUNKNOWN pUnk,DWORD dwClsContext,DWORD flags, |
| LPDWORD lpdwRegister |
| ) { |
| char buf[80]; |
| |
| WINE_StringFromCLSID(rclsid,buf); |
| |
| fprintf(stderr,"CoRegisterClassObject(%s,%p,0x%08lx,0x%08lx,%p),stub\n", |
| buf,pUnk,dwClsContext,flags,lpdwRegister |
| ); |
| return 0; |
| } |
| |
| /*********************************************************************** |
| * CoRegisterMessageFilter [COMPOBJ.27] |
| */ |
| OLESTATUS WINAPI CoRegisterMessageFilter16( |
| LPMESSAGEFILTER lpMessageFilter,LPMESSAGEFILTER *lplpMessageFilter |
| ) { |
| fprintf(stderr,"CoRegisterMessageFilter(%p,%p),stub!\n", |
| lpMessageFilter,lplpMessageFilter |
| ); |
| return 0; |
| } |
| |
| /*********************************************************************** |
| * CoCreateInstance [COMPOBJ.13, OLE32.7] |
| */ |
| HRESULT WINAPI CoCreateInstance(REFCLSID rclsid, LPUNKNOWN pUnkOuter, |
| DWORD dwClsContext, REFIID riid, LPVOID *ppv) |
| { |
| fprintf(stderr, "CoCreateInstance(): stub !\n"); |
| *ppv = NULL; |
| return S_OK; |
| } |
| |
| /*********************************************************************** |
| * CoFreeUnusedLibraries [COMPOBJ.17] |
| */ |
| void WINAPI CoFreeUnusedLibraries() |
| { |
| fprintf(stderr, "CoFreeUnusedLibraries(): stub !\n"); |
| } |
| |
| /*********************************************************************** |
| * CoFileTimeNow [COMPOBJ.82, OLE32.10] |
| * |
| * stores the current system time in lpFileTime |
| */ |
| HRESULT WINAPI CoFileTimeNow(FILETIME *lpFileTime) |
| { |
| DOSFS_UnixTimeToFileTime(time(NULL), lpFileTime, 0); |
| return S_OK; |
| } |
| |
| /*********************************************************************** |
| * CoTaskMemAlloc (OLE32.43) |
| */ |
| LPVOID WINAPI CoTaskMemAlloc(ULONG size) { |
| LPMALLOC32 lpmalloc; |
| HRESULT ret = CoGetMalloc32(0,&lpmalloc); |
| |
| if (ret) |
| return NULL; |
| return lpmalloc->lpvtbl->fnAlloc(lpmalloc,size); |
| } |
| |
| /*********************************************************************** |
| * CoTaskMemFree (OLE32.44) |
| */ |
| VOID WINAPI CoTaskMemFree(LPVOID ptr) { |
| LPMALLOC32 lpmalloc; |
| HRESULT ret = CoGetMalloc32(0,&lpmalloc); |
| |
| if (ret) return; |
| return lpmalloc->lpvtbl->fnFree(lpmalloc,ptr); |
| } |
| |
| /*********************************************************************** |
| * CoInitializeWOW (OLE32.27) |
| */ |
| HRESULT WINAPI CoInitializeWOW(DWORD x,DWORD y) { |
| fprintf(stderr,"CoInitializeWOW(0x%08lx,0x%08lx),stub!\n",x,y); |
| return 0; |
| } |