Changeset 9400 for trunk/src/ole32

trunk/src/ole32/compobj.c

-              r8620
+              r9400
 #include "wine/obj_storage.h"
 #include "wine/obj_channel.h"
-#include "wine/winbase16.h"
 #include "compobj_private.h"
-#include "ifs.h"
 #include "wine/debug.h"
 WINE_DEFAULT_DEBUG_CHANNEL(ole);
-/****************************************************************************
- *  COM External Lock structures and methods declaration
+ *
- *  This api provides a linked list to managed external references to
- *  COM objects.
+ *
- *  The public interface consists of three calls:
- *      COM_ExternalLockAddRef
- *      COM_ExternalLockRelease
- *      COM_ExternalLockFreeList
- */
-#define EL_END_OF_LIST 0
-#define EL_NOT_FOUND   0
-/*
- * Declaration of the static structure that manage the
- * external lock to COM  objects.
- */
-typedef struct COM_ExternalLock     COM_ExternalLock;
-typedef struct COM_ExternalLockList COM_ExternalLockList;
-struct COM_ExternalLock
+{
-  IUnknown         *pUnk;     /* IUnknown referenced */
-  ULONG            uRefCount; /* external lock counter to IUnknown object*/
-  COM_ExternalLock *next;     /* Pointer to next element in list */
-};
-struct COM_ExternalLockList
+{
-  COM_ExternalLock *head;     /* head of list */
-};
-/*
- * Declaration and initialization of the static structure that manages
- * the external lock to COM objects.
- */
-static COM_ExternalLockList elList = { EL_END_OF_LIST };
-/*
- * Public Interface to the external lock list
- */
-static void COM_ExternalLockFreeList();
-static void COM_ExternalLockAddRef(IUnknown *pUnk);
-static void COM_ExternalLockRelease(IUnknown *pUnk, BOOL bRelAll);
-void COM_ExternalLockDump(); /* testing purposes, not static to avoid warning */
-/*
- * Private methods used to managed the linked list
- */
-static BOOL COM_ExternalLockInsert(
-  IUnknown *pUnk);
-static void COM_ExternalLockDelete(
-  COM_ExternalLock *element);
-static COM_ExternalLock* COM_ExternalLockFind(
-  IUnknown *pUnk);
-static COM_ExternalLock* COM_ExternalLockLocate(
-  COM_ExternalLock *element,
-  IUnknown         *pUnk);
 /****************************************************************************
 …
  * TODO: Most of these things will have to be made thread-safe.
  */
-HINSTANCE16     COMPOBJ_hInstance = 0;
 HINSTANCE       COMPOBJ_hInstance32 = 0;
+static int      COMPOBJ_Attach = 0;
+LPMALLOC16 currentMalloc16=NULL;
+LPMALLOC currentMalloc32=NULL;
+HTASK16 hETask = 0;
+WORD Table_ETask[62];
+static HRESULT COM_GetRegisteredClassObject(REFCLSID rclsid, DWORD dwClsContext, LPUNKNOWN*  ppUnk);
+static void COM_RevokeAllClasses();
+static void COM_ExternalLockFreeList();
+/*****************************************************************************
+ * Appartment management stuff
+ *
+ * NOTE:
+ *  per Thread values are stored in the TEB on offset 0xF80
+ *
+ *  see www.microsoft.com/msj/1099/bugslayer/bugslayer1099.htm
+ *
+ */
+typedef struct {
+        unsigned char           threadingModell;        /* we use the COINIT flags */
+        unsigned long           threadID;
+        long                    AppartmentLockCount;
+} OleAppartmentData;
+typedef struct {
+        OleAppartmentData       *AppartmentData;
+} OleThreadData;
+/* not jet used
+static CRITICAL_SECTION csAppartmentData = CRITICAL_SECTION_INIT("csAppartmentData");
+*/
+/*
+ * the first STA created in a process is the main STA
+ */
+/* not jet used
+static OleAppartmentData * mainSTA;
+*/
+/*
+ * a Process can only have one MTA
+ */
+/* not jet used
+static OleAppartmentData * processMTA;
+*/
 /*
 …
 } RegisteredClass;
 static CRITICAL_SECTION csRegisteredClassList;
+static CRITICAL_SECTION csRegisteredClassList = CRITICAL_SECTION_INIT("csRegisteredClassList");
 static RegisteredClass* firstRegisteredClass = NULL;
+/* this open DLL table belongs in a per process table, but my guess is that
+ * it shouldn't live in the kernel, so I'll put them out here in DLL
+ * space assuming that there is one OLE32 per process.
+ */
+/*****************************************************************************
+ * This section contains OpenDllList definitions
+ *
+ * The OpenDllList contains only handles of dll loaded by CoGetClassObject or
+ * other functions what do LoadLibrary _without_ giving back a HMODULE.
+ * Without this list these handles would be freed never.
+ *
+ * FIXME: a DLL what says OK whenn asked for unloading is unloaded in the
+ * next unload-call but not before 600 sec.
+ */
 typedef struct tagOpenDll {
   HINSTANCE hLibrary;
 …
 } OpenDll;
 static CRITICAL_SECTION csOpenDllList;
+static CRITICAL_SECTION csOpenDllList = CRITICAL_SECTION_INIT("csOpenDllList");
 static OpenDll *openDllList = NULL; /* linked list of open dlls */
+/*****************************************************************************
+ * This section contains prototypes to internal methods for this
+ * module
+ */
+static HRESULT COM_GetRegisteredClassObject(REFCLSID    rclsid,
+                                            DWORD       dwClsContext,
+                                            LPUNKNOWN*  ppUnk);
+static void COM_RevokeAllClasses();
+static void COMPOBJ_DLLList_Add(HANDLE hLibrary);
+static void COMPOBJ_DllList_FreeUnused(int Timeout);
 …
 void COMPOBJ_InitProcess( void )
+{
-    InitializeCriticalSection( &csRegisteredClassList );
-    InitializeCriticalSection( &csOpenDllList );
+}
 void COMPOBJ_UninitProcess( void )
+{
+    DeleteCriticalSection( &csRegisteredClassList );
+    DeleteCriticalSection( &csOpenDllList );
+}
+/*****************************************************************************
+ * This section contains OpenDllList implemantation
+ */
+static void COMPOBJ_DLLList_Add(HANDLE hLibrary)
+{
+    OpenDll *ptr;
+    OpenDll *tmp;
+    TRACE("\n");
+    EnterCriticalSection( &csOpenDllList );
+    if (openDllList == NULL) {
+        /* empty list -- add first node */
+        openDllList = (OpenDll*)HeapAlloc(GetProcessHeap(),0, sizeof(OpenDll));
+        openDllList->hLibrary=hLibrary;
+        openDllList->next = NULL;
+    } else {
+        /* search for this dll */
+        int found = FALSE;
+        for (ptr = openDllList; ptr->next != NULL; ptr=ptr->next) {
+            if (ptr->hLibrary == hLibrary) {
+                found = TRUE;
+                break;
+            }
+        }
+        if (!found) {
+            /* dll not found, add it */
+            tmp = openDllList;
+            openDllList = (OpenDll*)HeapAlloc(GetProcessHeap(),0, sizeof(OpenDll));
+            openDllList->hLibrary = hLibrary;
+            openDllList->next = tmp;
+        }
+    }
+    LeaveCriticalSection( &csOpenDllList );
+}
+static void COMPOBJ_DllList_FreeUnused(int Timeout)
+{
+    OpenDll *curr, *next, *prev = NULL;
+    typedef HRESULT(*DllCanUnloadNowFunc)(void);
+    DllCanUnloadNowFunc DllCanUnloadNow;
+    TRACE("\n");
+    EnterCriticalSection( &csOpenDllList );
+    for (curr = openDllList; curr != NULL; ) {
+        DllCanUnloadNow = (DllCanUnloadNowFunc) GetProcAddress(curr->hLibrary, "DllCanUnloadNow");
+        if ( (DllCanUnloadNow != NULL) && (DllCanUnloadNow() == S_OK) ) {
+            next = curr->next;
+            TRACE("freeing 0x%08x\n", curr->hLibrary);
+            FreeLibrary(curr->hLibrary);
+            HeapFree(GetProcessHeap(), 0, curr);
+            if (curr == openDllList) {
+                openDllList = next;
+            } else {
+              prev->next = next;
+            }
+            curr = next;
+        } else {
+            prev = curr;
+            curr = curr->next;
+        }
+    }
+    LeaveCriticalSection( &csOpenDllList );
+}
 …
     TRACE("Returning version %d, build %d.\n", rmm, rup);
     return (rmm<<16)+rup;
+}
-/******************************************************************************
- *              CoInitialize    [COMPOBJ.2]
- * Set the win16 IMalloc used for memory management
- */
-HRESULT WINAPI CoInitialize16(
-        LPVOID lpReserved       /* [in] pointer to win16 malloc interface */
-) {
-    currentMalloc16 = (LPMALLOC16)lpReserved;
-    return S_OK;
+}
 …
   return hr;
+}
-/***********************************************************************
- *           CoUninitialize   [COMPOBJ.3]
- * Don't know what it does.
- * 3-Nov-98 -- this was originally misspelled, I changed it to what I
- *   believe is the correct spelling
- */
-void WINAPI CoUninitialize16(void)
+{
-  TRACE("()\n");
-  CoFreeAllLibraries();
+}
 …
+}
-#ifndef __WIN32OS2__
-/***********************************************************************
- *           CoGetMalloc    [COMPOBJ.4]
- * RETURNS
- *      The current win16 IMalloc
- */
-HRESULT WINAPI CoGetMalloc16(
-        DWORD dwMemContext,     /* [in] unknown */
-        LPMALLOC16 * lpMalloc   /* [out] current win16 malloc interface */
-) {
-    if(!currentMalloc16)
-        currentMalloc16 = IMalloc16_Constructor();
-    *lpMalloc = currentMalloc16;
-    return S_OK;
+}
-#endif
-/******************************************************************************
- *              CoGetMalloc     [OLE32.20]
+ *
- * RETURNS
- *      The current win32 IMalloc
- */
-HRESULT WINAPI CoGetMalloc(
-        DWORD dwMemContext,     /* [in] unknown */
-        LPMALLOC *lpMalloc      /* [out] current win32 malloc interface */
-) {
-    if(!currentMalloc32)
-        currentMalloc32 = IMalloc_Constructor();
-    *lpMalloc = currentMalloc32;
-    return S_OK;
+}
-#ifndef __WIN32OS2__
-/***********************************************************************
- *           CoCreateStandardMalloc [COMPOBJ.71]
- */
-HRESULT WINAPI CoCreateStandardMalloc16(DWORD dwMemContext,
-                                          LPMALLOC16 *lpMalloc)
+{
-    /* FIXME: docu says we shouldn't return the same allocator as in
-     * CoGetMalloc16 */
-    *lpMalloc = IMalloc16_Constructor();
-    return S_OK;
+}
-#endif
 /******************************************************************************
  *              CoDisconnectObject      [COMPOBJ.15]
 …
     TRACE("(%p, %lx)\n",lpUnk,reserved);
     return S_OK;
+}
-/***********************************************************************
- *           IsEqualGUID [COMPOBJ.18]
+ *
- * Compares two Unique Identifiers.
+ *
- * RETURNS
- *      TRUE if equal
- */
-BOOL16 WINAPI IsEqualGUID16(
-        GUID* g1,       /* [in] unique id 1 */
-        GUID* g2        /* [in] unique id 2 */
-) {
-    return !memcmp( g1, g2, sizeof(GUID) );
+}
-/******************************************************************************
- *              CLSIDFromString [COMPOBJ.20]
- * Converts a unique identifier from its string representation into
- * the GUID struct.
+ *
- * Class id: DWORD-WORD-WORD-BYTES[2]-BYTES[6]
+ *
- * RETURNS
- *      the converted GUID
- */
-HRESULT WINAPI CLSIDFromString16(
-        LPCOLESTR16 idstr,      /* [in] string representation of guid */
-        CLSID *id               /* [out] GUID converted from string */
-) {
-  BYTE *s = (BYTE *) idstr;
-  BYTE *p;
-  int   i;
-  BYTE table[256];
-  if (!s)
-          s = "{00000000-0000-0000-0000-000000000000}";
-  else {  /* validate the CLSID string */
-      if (strlen(s) != 38)
-          return CO_E_CLASSSTRING;
-      if ((s[0]!='{') || (s[9]!='-') || (s[14]!='-') || (s[19]!='-') || (s[24]!='-') || (s[37]!='}'))
-          return CO_E_CLASSSTRING;
-      for (i=1; i<37; i++)
+      {
-          if ((i == 9)||(i == 14)||(i == 19)||(i == 24)) continue;
-          if (!(((s[i] >= '0') && (s[i] <= '9'))  ||
-                ((s[i] >= 'a') && (s[i] <= 'f'))  ||
-                ((s[i] >= 'A') && (s[i] <= 'F')))
+             )
-              return CO_E_CLASSSTRING;
+      }
+  }
-  TRACE("%s -> %p\n", s, 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} */
-  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;
+}
 …
  *      the converted GUID
  */
+HRESULT WINAPI __CLSIDFromStringA(
+        LPCSTR idstr,           /* [in] string representation of guid */
+        CLSID *id)              /* [out] GUID converted from string */
+{
+  BYTE *s = (BYTE *) idstr;
+  int   i;
+  BYTE table[256];
+  if (!s)
+          s = "{00000000-0000-0000-0000-000000000000}";
+  else {  /* validate the CLSID string */
+      if (strlen(s) != 38)
+          return CO_E_CLASSSTRING;
+      if ((s[0]!='{') || (s[9]!='-') || (s[14]!='-') || (s[19]!='-') || (s[24]!='-') || (s[37]!='}'))
+          return CO_E_CLASSSTRING;
+      for (i=1; i<37; i++) {
+          if ((i == 9)||(i == 14)||(i == 19)||(i == 24)) continue;
+          if (!(((s[i] >= '0') && (s[i] <= '9'))  ||
+                ((s[i] >= 'a') && (s[i] <= 'f'))  ||
+                ((s[i] >= 'A') && (s[i] <= 'F'))))
+              return CO_E_CLASSSTRING;
+      }
+  }
+  TRACE("%s -> %p\n", s, 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} */
+  id->Data1 = (table[s[1]] << 28 | table[s[2]] << 24 | table[s[3]] << 20 | table[s[4]] << 16 |
+               table[s[5]] << 12 | table[s[6]] << 8  | table[s[7]] << 4  | table[s[8]]);
+  id->Data2 = table[s[10]] << 12 | table[s[11]] << 8 | table[s[12]] << 4 | table[s[13]];
+  id->Data3 = table[s[15]] << 12 | table[s[16]] << 8 | table[s[17]] << 4 | table[s[18]];
+  /* these are just sequential bytes */
+  id->Data4[0] = table[s[20]] << 4 | table[s[21]];
+  id->Data4[1] = table[s[22]] << 4 | table[s[23]];
+  id->Data4[2] = table[s[25]] << 4 | table[s[26]];
+  id->Data4[3] = table[s[27]] << 4 | table[s[28]];
+  id->Data4[4] = table[s[29]] << 4 | table[s[30]];
+  id->Data4[5] = table[s[31]] << 4 | table[s[32]];
+  id->Data4[6] = table[s[33]] << 4 | table[s[34]];
+  id->Data4[7] = table[s[35]] << 4 | table[s[36]];
+  return S_OK;
+}
+/*****************************************************************************/
 HRESULT WINAPI CLSIDFromString(
         LPCOLESTR idstr,        /* [in] string representation of GUID */
 …
     if (!WideCharToMultiByte( CP_ACP, 0, idstr, -1, xid, sizeof(xid), NULL, NULL ))
         return CO_E_CLASSSTRING;
+    ret = CLSIDFromString16(xid,id);
+    ret = __CLSIDFromStringA(xid,id);
     if(ret != S_OK) { /* It appears a ProgID is also valid */
         ret = CLSIDFromProgID(idstr, id);
 …
   return S_OK;
+}
+#ifndef __WIN32OS2__
+/******************************************************************************
+ *              StringFromCLSID [COMPOBJ.19]
+ * Converts a GUID into the respective string representation.
+ * The target string is allocated using the OLE IMalloc.
+ * RETURNS
+ *      the string representation and HRESULT
+ */
+HRESULT WINAPI StringFromCLSID16(
+        REFCLSID id,            /* [in] the GUID to be converted */
+        LPOLESTR16 *idstr       /* [out] a pointer to a to-be-allocated segmented pointer pointing to the resulting string */
+) {
+    extern BOOL WINAPI K32WOWCallback16Ex( DWORD vpfn16, DWORD dwFlags,
+                                           DWORD cbArgs, LPVOID pArgs, LPDWORD pdwRetCode );
+    LPMALLOC16  mllc;
+    HRESULT     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 (!K32WOWCallback16Ex(
+        (DWORD)((ICOM_VTABLE(IMalloc16)*)MapSL(
+            (SEGPTR)ICOM_VTBL(((LPMALLOC16)MapSL((SEGPTR)mllc))))
+        )->Alloc,
+        WCB16_CDECL,
+*sizeof(DWORD),
+        (LPVOID)args,
+        (LPDWORD)idstr
+    )) {
+        WARN("CallTo16 IMalloc16 failed\n");
+        return E_FAIL;
+    }
+    return WINE_StringFromCLSID(id,MapSL((SEGPTR)*idstr));
+}
+#endif
 /******************************************************************************
  *              StringFromCLSID [OLE32.151]
 …
 /******************************************************************************
- *              CLSIDFromProgID [COMPOBJ.61]
- * Converts a program id into the respective GUID. (By using a registry lookup)
- * RETURNS
- *      riid associated with the progid
- */
-HRESULT WINAPI CLSIDFromProgID16(
-        LPCOLESTR16 progid,     /* [in] program id as found in registry */
-        LPCLSID riid            /* [out] associated CLSID */
-) {
-        char    *buf,buf2[80];
-        DWORD   buf2len;
-        HRESULT err;
-        HKEY    xhkey;
-        buf = HeapAlloc(GetProcessHeap(),0,strlen(progid)+8);
-        sprintf(buf,"%s\\CLSID",progid);
-        if ((err=RegOpenKeyA(HKEY_CLASSES_ROOT,buf,&xhkey))) {
-                HeapFree(GetProcessHeap(),0,buf);
-                return CO_E_CLASSSTRING;
+        }
-        HeapFree(GetProcessHeap(),0,buf);
-        buf2len = sizeof(buf2);
-        if ((err=RegQueryValueA(xhkey,NULL,buf2,&buf2len))) {
-                RegCloseKey(xhkey);
-                return CO_E_CLASSSTRING;
+        }
-        RegCloseKey(xhkey);
-        return CLSIDFromString16(buf2,riid);
+}
-/******************************************************************************
  *              CLSIDFromProgID [OLE32.2]
  * Converts a program id into the respective GUID. (By using a registry lookup)
 …
+    }
     RegCloseKey(xhkey);
     return CLSIDFromString16(buf2,riid);
+    return __CLSIDFromStringA(buf2,riid);
+}
 …
     /* We have the CLSid we want back from the registry as a string, so
        lets convert it into a CLSID structure */
+    if ( (CLSIDFromString16(buf2,pclsid)) != NOERROR)
+    {
+    if ( (__CLSIDFromStringA(buf2,pclsid)) != NOERROR) {
        return E_INVALIDARG;
+    }
 …
         return S_OK;
+}
+#ifndef __WIN32OS2__
+/* FIXME: this function is not declared in the WINELIB headers. But where should it go ? */
+/***********************************************************************
+ *           LookupETask (COMPOBJ.94)
+ */
+HRESULT WINAPI LookupETask16(HTASK16 *hTask,LPVOID p) {
+        FIXME("(%p,%p),stub!\n",hTask,p);
+        if ((*hTask = GetCurrentTask()) == hETask) {
+                memcpy(p, Table_ETask, sizeof(Table_ETask));
+        }
+        return 0;
+}
+/* FIXME: this function is not declared in the WINELIB headers. But where should it go ? */
+/***********************************************************************
+ *           SetETask (COMPOBJ.95)
+ */
+HRESULT WINAPI SetETask16(HTASK16 hTask, LPVOID p) {
+        FIXME("(%04x,%p),stub!\n",hTask,p);
+        hETask = hTask;
+        return 0;
+}
+/* FIXME: this function is not declared in the WINELIB headers. But where should it go ? */
+/***********************************************************************
+ *           CALLOBJECTINWOW (COMPOBJ.201)
+ */
+HRESULT WINAPI CallObjectInWOW(LPVOID p1,LPVOID p2) {
+        FIXME("(%p,%p),stub!\n",p1,p2);
+        return 0;
+}
+/******************************************************************************
+ *              CoRegisterClassObject   [COMPOBJ.5]
+ *
+ * Don't know where it registers it ...
+ */
+HRESULT WINAPI CoRegisterClassObject16(
+        REFCLSID rclsid,
+        LPUNKNOWN pUnk,
+        DWORD dwClsContext, /* [in] CLSCTX flags indicating the context in which to run the executable */
+        DWORD flags,        /* [in] REGCLS flags indicating how connections are made */
+        LPDWORD lpdwRegister
+) {
+        char    buf[80];
+        WINE_StringFromCLSID(rclsid,buf);
+        FIXME("(%s,%p,0x%08lx,0x%08lx,%p),stub\n",
+                buf,pUnk,dwClsContext,flags,lpdwRegister
+        );
+        return 0;
+}
+/******************************************************************************
+ *      CoRevokeClassObject [COMPOBJ.6]
+ *
+ */
+HRESULT WINAPI CoRevokeClassObject16(DWORD dwRegister) /* [in] token on class obj */
+{
+    FIXME("(0x%08lx),stub!\n", dwRegister);
+    return 0;
+}
+/******************************************************************************
+ *      CoFileTimeToDosDateTime [COMPOBJ.30]
+ */
+BOOL16 WINAPI CoFileTimeToDosDateTime16(const FILETIME *ft, LPWORD lpDosDate, LPWORD lpDosTime)
+{
+    return FileTimeToDosDateTime(ft, lpDosDate, lpDosTime);
+}
+/******************************************************************************
+ *      CoDosDateTimeToFileTime [COMPOBJ.31]
+ */
+BOOL16 WINAPI CoDosDateTimeToFileTime16(WORD wDosDate, WORD wDosTime, FILETIME *ft)
+{
+    return DosDateTimeToFileTime(wDosDate, wDosTime, ft);
+}
+#endif
 /***
  * COM_GetRegisteredClassObject
 …
 /***********************************************************************
+ *      compobj_RegReadPath     [internal]
+ *
+ *      Reads a registry value and expands it when nessesary
+ */
+HRESULT compobj_RegReadPath(char * keyname, char * valuename, char * dst, int dstlen)
+{
+        HRESULT hres;
+        HKEY key;
+        DWORD keytype;
+        char src[MAX_PATH];
+        DWORD dwLength = dstlen;
+        if((hres = RegOpenKeyExA(HKEY_CLASSES_ROOT, keyname, 0, KEY_READ, &key)) == ERROR_SUCCESS) {
+          if( (hres = RegQueryValueExA(key, NULL, NULL, &keytype, (LPBYTE)src, &dwLength)) == ERROR_SUCCESS ) {
+            if (keytype == REG_EXPAND_SZ) {
+              if (dstlen <= ExpandEnvironmentStringsA(src, dst, dstlen)) hres = ERROR_MORE_DATA;
+            } else {
+              strncpy(dst, src, dstlen);
+            }
+          }
+          RegCloseKey (key);
+        }
+        return hres;
+}
+/***********************************************************************
  *           CoGetClassObject [COMPOBJ.7]
  *           CoGetClassObject [OLE32.16]
 …
     HRESULT     hres = E_UNEXPECTED;
     char        xclsid[80];
-    WCHAR ProviderName[MAX_PATH+1];
-    DWORD ProviderNameLen = sizeof(ProviderName);
     HINSTANCE hLibrary;
 #ifdef __WIN32OS2__
+    typedef HRESULT (* CALLBACK DllGetClassObjectFunc)(REFCLSID clsid,
+                             REFIID iid, LPVOID *ppv);
+    typedef HRESULT (* CALLBACK DllGetClassObjectFunc)(REFCLSID clsid, REFIID iid, LPVOID *ppv);
 #else
+    typedef HRESULT (CALLBACK *DllGetClassObjectFunc)(REFCLSID clsid,
+                             REFIID iid, LPVOID *ppv);
+    typedef HRESULT (CALLBACK *DllGetClassObjectFunc)(REFCLSID clsid, REFIID iid, LPVOID *ppv);
 #endif
     DllGetClassObjectFunc DllGetClassObject;
 …
     WINE_StringFromCLSID((LPCLSID)rclsid,xclsid);
+    TRACE("\n\tCLSID:\t%s,\n\tIID:\t%s\n",
+        debugstr_guid(rclsid),
+        debugstr_guid(iid)
+    );
+    TRACE("\n\tCLSID:\t%s,\n\tIID:\t%s\n", debugstr_guid(rclsid), debugstr_guid(iid));
     if (pServerInfo) {
 …
+    }
+    if ((CLSCTX_INPROC_SERVER|CLSCTX_INPROC_HANDLER) & dwClsContext) {
+        HKEY key;
+        char buf[200];
+        memset(ProviderName,0,sizeof(ProviderName));
+        sprintf(buf,"CLSID\\%s\\InprocServer32",xclsid);
+        if (((hres = RegOpenKeyExA(HKEY_CLASSES_ROOT, buf, 0, KEY_READ, &key)) != ERROR_SUCCESS) ||
+            ((hres = RegQueryValueExW(key,NULL,NULL,NULL,(LPBYTE)ProviderName,&ProviderNameLen)),
+             RegCloseKey (key),
+             hres != ERROR_SUCCESS))
+        {
+    /* first try: in-process */
+    if ((CLSCTX_INPROC_SERVER | CLSCTX_INPROC_HANDLER) & dwClsContext) {
+        char keyname[MAX_PATH];
+        char dllpath[MAX_PATH+1];
+        sprintf(keyname,"CLSID\\%s\\InprocServer32",xclsid);
+        if ( compobj_RegReadPath(keyname, NULL, dllpath, sizeof(dllpath)) != ERROR_SUCCESS) {
+            /* failure: CLSID is not found in registry */
+            WARN("class %s not registred\n", xclsid);
             hres = REGDB_E_CLASSNOTREG;
+        }
+        /* Don't ask me.  MSDN says that CoGetClassObject does NOT call CoLoadLibrary */
+        else if ((hLibrary = CoLoadLibrary(ProviderName, TRUE)) == 0)
+        {
+            FIXME("couldn't load InprocServer32 dll %s\n", debugstr_w(ProviderName));
+            hres = E_ACCESSDENIED; /* or should this be CO_E_DLLNOTFOUND? */
+        } else {
+          if ((hLibrary = LoadLibraryExA(dllpath, 0, LOAD_WITH_ALTERED_SEARCH_PATH)) == 0) {
+            /* failure: DLL could not be loaded */
+            ERR("couldn't load InprocServer32 dll %s\n", dllpath);
+            hres = E_ACCESSDENIED; /* FIXME: or should this be CO_E_DLLNOTFOUND? */
+          } else if (!(DllGetClassObject = (DllGetClassObjectFunc)GetProcAddress(hLibrary, "DllGetClassObject"))) {
+            /* failure: the dll did not export DllGetClassObject */
+            ERR("couldn't find function DllGetClassObject in %s\n", dllpath);
+            FreeLibrary( hLibrary );
+            hres = CO_E_DLLNOTFOUND;
+          } else {
+            /* OK: get the ClassObject */
+            COMPOBJ_DLLList_Add( hLibrary );
+            return DllGetClassObject(rclsid, iid, ppv);
+          }
+        }
+        else if (!(DllGetClassObject = (DllGetClassObjectFunc)GetProcAddress(hLibrary, "DllGetClassObject")))
+        {
+            /* not sure if this should be called here CoFreeLibrary(hLibrary);*/
+            FIXME("couldn't find function DllGetClassObject in %s\n", debugstr_w(ProviderName));
+            hres = E_ACCESSDENIED;
+        }
+        else
+        {
+            /* Ask the DLL for its class object. (there was a note here about
+             * class factories but this is good.
+             */
+            return DllGetClassObject(rclsid, iid, ppv);
+        }
+    }
+    }
     /* Next try out of process */
 …
     IStorage *pstg=0;
     HRESULT res;
     int nbElm=0,length=0,i=0;
     LONG sizeProgId=20;
+    int nbElm, length, i;
+    LONG sizeProgId;
     LPOLESTR *pathDec=0,absFile=0,progId=0;
+    WCHAR extention[100]={0};
+    TRACE("()\n");
+    LPWSTR extension;
+    static const WCHAR bkslashW[] = {'\\',0};
+    static const WCHAR dotW[] = {'.',0};
+    TRACE("%s, %p\n", debugstr_w(filePathName), pclsid);
     /* if the file contain a storage object the return the CLSID writen by IStorage_SetClass method*/
 …
     /* failed if the path represente a directory and not an absolute file name*/
     if (lstrcmpW(absFile,(LPOLESTR)"\\"))
+    if (!lstrcmpW(absFile, bkslashW))
         return MK_E_INVALIDEXTENSION;
     /* get the extension of the file */
+    extension = NULL;
     length=lstrlenW(absFile);
+    for(i=length-1; ( (i>=0) && (extention[i]=absFile[i]) );i--);
+    for(i = length-1; (i >= 0) && *(extension = &absFile[i]) != '.'; i--)
+        /* nothing */;
+    if (!extension || !lstrcmpW(extension, dotW))
+        return MK_E_INVALIDEXTENSION;
+    res=RegQueryValueW(HKEY_CLASSES_ROOT, extension, NULL, &sizeProgId);
     /* get the progId associated to the extension */
+    progId=CoTaskMemAlloc(sizeProgId);
+    res=RegQueryValueW(HKEY_CLASSES_ROOT,extention,progId,&sizeProgId);
+    if (res==ERROR_MORE_DATA){
+        progId = CoTaskMemRealloc(progId,sizeProgId);
+        res=RegQueryValueW(HKEY_CLASSES_ROOT,extention,progId,&sizeProgId);
+    }
+    progId = CoTaskMemAlloc(sizeProgId);
+    res = RegQueryValueW(HKEY_CLASSES_ROOT, extension, progId, &sizeProgId);
     if (res==ERROR_SUCCESS)
         /* return the clsid associated to the progId */
 …
     return MK_E_INVALIDEXTENSION;
+}
-/******************************************************************************
- *              CoRegisterMessageFilter [COMPOBJ.27]
- */
-HRESULT WINAPI CoRegisterMessageFilter16(
-        LPMESSAGEFILTER lpMessageFilter,
-        LPMESSAGEFILTER *lplpMessageFilter
-) {
-        FIXME("(%p,%p),stub!\n",lpMessageFilter,lplpMessageFilter);
-        return 0;
+}
 /***********************************************************************
  *           CoCreateInstance [COMPOBJ.13]
 …
 /***********************************************************************
+ *           CoLoadLibrary (OLE32.30)
+ */
+HINSTANCE WINAPI CoLoadLibrary(LPOLESTR lpszLibName, BOOL bAutoFree)
+{
+    TRACE("(%s, %d)\n", debugstr_w(lpszLibName), bAutoFree);
+    return LoadLibraryExW(lpszLibName, 0, LOAD_WITH_ALTERED_SEARCH_PATH);
+}
+/***********************************************************************
  *           CoFreeLibrary [OLE32.13]
+ *
+ * NOTES: don't belive the docu
  */
 void WINAPI CoFreeLibrary(HINSTANCE hLibrary)
+{
+    OpenDll *ptr, *prev;
+    OpenDll *tmp;
+    EnterCriticalSection( &csOpenDllList );
+    /* lookup library in linked list */
+    prev = NULL;
+    for (ptr = openDllList; ptr != NULL; ptr=ptr->next) {
+        if (ptr->hLibrary == hLibrary) {
+            break;
+        }
+        prev = ptr;
+    }
+    if (ptr == NULL) {
+        /* shouldn't happen if user passed in a valid hLibrary */
+        goto end;
+    }
+    /* assert: ptr points to the library entry to free */
+    /* free library and remove node from list */
+    FreeLibrary(hLibrary);
+    if (ptr == openDllList) {
+        tmp = openDllList->next;
+        HeapFree(GetProcessHeap(), 0, openDllList);
+        openDllList = tmp;
+    } else {
+        tmp = ptr->next;
+        HeapFree(GetProcessHeap(), 0, ptr);
+        prev->next = tmp;
+    }
+end:
+    LeaveCriticalSection( &csOpenDllList );
+        FreeLibrary(hLibrary);
+}
 …
 /***********************************************************************
  *           CoFreeAllLibraries [OLE32.12]
+ *
+ * NOTES: don't belive the docu
  */
 void WINAPI CoFreeAllLibraries(void)
+{
+    OpenDll *ptr, *tmp;
+    EnterCriticalSection( &csOpenDllList );
+    for (ptr = openDllList; ptr != NULL; ) {
+        tmp=ptr->next;
+        CoFreeLibrary(ptr->hLibrary);
+        ptr = tmp;
+    }
+    LeaveCriticalSection( &csOpenDllList );
+}
+        /* NOP */
+}
 …
  *           CoFreeUnusedLibraries [COMPOBJ.17]
  *           CoFreeUnusedLibraries [OLE32.14]
+ *
+ * FIXME: Calls to CoFreeUnusedLibraries from any thread always route
+ * through the main apartment's thread to call DllCanUnloadNow
  */
 void WINAPI CoFreeUnusedLibraries(void)
+{
+    OpenDll *ptr, *tmp;
+    typedef HRESULT(*DllCanUnloadNowFunc)(void);
+    DllCanUnloadNowFunc DllCanUnloadNow;
+    EnterCriticalSection( &csOpenDllList );
+    for (ptr = openDllList; ptr != NULL; ) {
+        DllCanUnloadNow = (DllCanUnloadNowFunc)
+            GetProcAddress(ptr->hLibrary, "DllCanUnloadNow");
+        if ( (DllCanUnloadNow != NULL) &&
+             (DllCanUnloadNow() == S_OK) ) {
+            tmp=ptr->next;
+            CoFreeLibrary(ptr->hLibrary);
+            ptr = tmp;
+        } else {
+            ptr=ptr->next;
+        }
+    }
+    LeaveCriticalSection( &csOpenDllList );
+    COMPOBJ_DllList_FreeUnused(0);
+}
 …
 /***********************************************************************
- *           CoTaskMemAlloc (OLE32.43)
- * RETURNS
- *      pointer to newly allocated block
- */
-LPVOID WINAPI CoTaskMemAlloc(
-        ULONG size      /* [in] size of memoryblock to be allocated */
-) {
-    LPMALLOC    lpmalloc;
-    HRESULT     ret = CoGetMalloc(0,&lpmalloc);
-    if (FAILED(ret))
-        return NULL;
-    return IMalloc_Alloc(lpmalloc,size);
+}
-/***********************************************************************
- *           CoTaskMemFree (OLE32.44)
- */
-VOID WINAPI CoTaskMemFree(
-        LPVOID ptr      /* [in] pointer to be freed */
-) {
-    LPMALLOC    lpmalloc;
-    HRESULT     ret = CoGetMalloc(0,&lpmalloc);
-    if (FAILED(ret))
-      return;
-    IMalloc_Free(lpmalloc, ptr);
+}
-/***********************************************************************
- *           CoTaskMemRealloc (OLE32.45)
- * RETURNS
- *      pointer to newly allocated block
- */
-LPVOID WINAPI CoTaskMemRealloc(
-  LPVOID pvOld,
-  ULONG  size)  /* [in] size of memoryblock to be allocated */
+{
-  LPMALLOC lpmalloc;
-  HRESULT  ret = CoGetMalloc(0,&lpmalloc);
-  if (FAILED(ret))
-    return NULL;
-  return IMalloc_Realloc(lpmalloc, pvOld, size);
+}
-/***********************************************************************
  *           CoLoadLibrary (OLE32.30)
  */
+HINSTANCE WINAPI CoLoadLibrary(LPOLESTR lpszLibName, BOOL bAutoFree)
+{
+    HINSTANCE hLibrary;
+    OpenDll *ptr;
+    OpenDll *tmp;
+    TRACE("(%s, %d)\n", debugstr_w(lpszLibName), bAutoFree);
+    hLibrary = LoadLibraryExW(lpszLibName, 0, LOAD_WITH_ALTERED_SEARCH_PATH);
+    if (!bAutoFree)
+        return hLibrary;
+    EnterCriticalSection( &csOpenDllList );
+    if (openDllList == NULL) {
+        /* empty list -- add first node */
+        openDllList = (OpenDll*)HeapAlloc(GetProcessHeap(),0, sizeof(OpenDll));
+        openDllList->hLibrary=hLibrary;
+        openDllList->next = NULL;
+static void COM_RevokeAllClasses()
+{
+  EnterCriticalSection( &csRegisteredClassList );
+  while (firstRegisteredClass!=0)
+  {
+    CoRevokeClassObject(firstRegisteredClass->dwCookie);
+  }
+  LeaveCriticalSection( &csRegisteredClassList );
+}
+/****************************************************************************
+ *  COM External Lock methods implementation
+ *
+ *  This api provides a linked list to managed external references to
+ *  COM objects.
+ *
+ *  The public interface consists of three calls:
+ *      COM_ExternalLockAddRef
+ *      COM_ExternalLockRelease
+ *      COM_ExternalLockFreeList
+ */
+#define EL_END_OF_LIST 0
+#define EL_NOT_FOUND   0
+/*
+ * Declaration of the static structure that manage the
+ * external lock to COM  objects.
+ */
+typedef struct COM_ExternalLock     COM_ExternalLock;
+typedef struct COM_ExternalLockList COM_ExternalLockList;
+struct COM_ExternalLock
+{
+  IUnknown         *pUnk;     /* IUnknown referenced */
+  ULONG            uRefCount; /* external lock counter to IUnknown object*/
+  COM_ExternalLock *next;     /* Pointer to next element in list */
+};
+struct COM_ExternalLockList
+{
+  COM_ExternalLock *head;     /* head of list */
+};
+/*
+ * Declaration and initialization of the static structure that manages
+ * the external lock to COM objects.
+ */
+static COM_ExternalLockList elList = { EL_END_OF_LIST };
+/*
+ * Private methods used to managed the linked list
+ */
+static COM_ExternalLock* COM_ExternalLockLocate(
+  COM_ExternalLock *element,
+  IUnknown         *pUnk);
+/****************************************************************************
+ * Internal - Insert a new IUnknown* to the linked list
+ */
+static BOOL COM_ExternalLockInsert(
+  IUnknown *pUnk)
+{
+  COM_ExternalLock *newLock      = NULL;
+  COM_ExternalLock *previousHead = NULL;
+  /*
+   * Allocate space for the new storage object
+   */
+  newLock = HeapAlloc(GetProcessHeap(), 0, sizeof(COM_ExternalLock));
+  if (newLock!=NULL) {
+    if ( elList.head == EL_END_OF_LIST ) {
+      elList.head = newLock;    /* The list is empty */
     } else {
+        /* search for this dll */
+        int found = FALSE;
+        for (ptr = openDllList; ptr->next != NULL; ptr=ptr->next) {
+            if (ptr->hLibrary == hLibrary) {
+                found = TRUE;
+                break;
+            }
+        }
+        if (!found) {
+            /* dll not found, add it */
+            tmp = openDllList;
+            openDllList = (OpenDll*)HeapAlloc(GetProcessHeap(),0, sizeof(OpenDll));
+            openDllList->hLibrary = hLibrary;
+            openDllList->next = tmp;
+        }
+    }
+    LeaveCriticalSection( &csOpenDllList );
+    return hLibrary;
+}
+/***********************************************************************
+ *           CoInitializeWOW (OLE32.27)
+ */
+HRESULT WINAPI CoInitializeWOW(DWORD x,DWORD y) {
+    FIXME("(0x%08lx,0x%08lx),stub!\n",x,y);
+    return 0;
+}
+/******************************************************************************
+ *              CoLockObjectExternal    [COMPOBJ.63]
+ */
+HRESULT WINAPI CoLockObjectExternal16(
+    LPUNKNOWN pUnk,             /* [in] object to be locked */
+    BOOL16 fLock,               /* [in] do lock */
+    BOOL16 fLastUnlockReleases  /* [in] ? */
+) {
+    FIXME("(%p,%d,%d),stub!\n",pUnk,fLock,fLastUnlockReleases);
+    return S_OK;
+      /* insert does it at the head */
+      previousHead  = elList.head;
+      elList.head = newLock;
+    }
+    /* Set new list item data member */
+    newLock->pUnk      = pUnk;
+    newLock->uRefCount = 1;
+    newLock->next      = previousHead;
+    return TRUE;
+  }
+  return FALSE;
+}
+/****************************************************************************
+ * Internal - Method that removes an item from the linked list.
+ */
+static void COM_ExternalLockDelete(
+  COM_ExternalLock *itemList)
+{
+  COM_ExternalLock *current = elList.head;
+  if ( current == itemList ) {
+    /* this section handles the deletion of the first node */
+    elList.head = itemList->next;
+    HeapFree( GetProcessHeap(), 0, itemList);
+  } else {
+    do {
+      if ( current->next == itemList ){   /* We found the item to free  */
+        current->next = itemList->next;  /* readjust the list pointers */
+        HeapFree( GetProcessHeap(), 0, itemList);
+        break;
+      }
+      /* Skip to the next item */
+      current = current->next;
+    } while ( current != EL_END_OF_LIST );
+  }
+}
+/****************************************************************************
+ * Internal - Recursivity agent for IUnknownExternalLockList_Find
+ *
+ * NOTES: how long can the list be ?? (recursive!!!)
+ */
+static COM_ExternalLock* COM_ExternalLockLocate( COM_ExternalLock *element, IUnknown *pUnk)
+{
+  if ( element == EL_END_OF_LIST )
+    return EL_NOT_FOUND;
+  else if ( element->pUnk == pUnk )    /* We found it */
+    return element;
+  else                                 /* Not the right guy, keep on looking */
+    return COM_ExternalLockLocate( element->next, pUnk);
+}
+/****************************************************************************
+ * Public - Method that increments the count for a IUnknown* in the linked
+ * list.  The item is inserted if not already in the list.
+ */
+static void COM_ExternalLockAddRef(IUnknown *pUnk)
+{
+  COM_ExternalLock *externalLock = COM_ExternalLockLocate(elList.head, pUnk);
+  /*
+   * Add an external lock to the object. If it was already externally
+   * locked, just increase the reference count. If it was not.
+   * add the item to the list.
+   */
+  if ( externalLock == EL_NOT_FOUND )
+    COM_ExternalLockInsert(pUnk);
+  else
+    externalLock->uRefCount++;
+  /*
+   * Add an internal lock to the object
+   */
+  IUnknown_AddRef(pUnk);
+}
+/****************************************************************************
+ * Public - Method that decrements the count for a IUnknown* in the linked
+ * list.  The item is removed from the list if its count end up at zero or if
+ * bRelAll is TRUE.
+ */
+static void COM_ExternalLockRelease(
+  IUnknown *pUnk,
+  BOOL   bRelAll)
+{
+  COM_ExternalLock *externalLock = COM_ExternalLockLocate(elList.head, pUnk);
+  if ( externalLock != EL_NOT_FOUND ) {
+    do {
+      externalLock->uRefCount--;  /* release external locks      */
+      IUnknown_Release(pUnk);     /* release local locks as well */
+      if ( bRelAll == FALSE ) break;  /* perform single release */
+    } while ( externalLock->uRefCount > 0 );
+    if ( externalLock->uRefCount == 0 )  /* get rid of the list entry */
+      COM_ExternalLockDelete(externalLock);
+  }
+}
+/****************************************************************************
+ * Public - Method that frees the content of the list.
+ */
+static void COM_ExternalLockFreeList()
+{
+  COM_ExternalLock *head;
+  head = elList.head;                 /* grab it by the head             */
+  while ( head != EL_END_OF_LIST ) {
+    COM_ExternalLockDelete(head);     /* get rid of the head stuff       */
+    head = elList.head;               /* get the new head...             */
+  }
+}
+/****************************************************************************
+ * Public - Method that dump the content of the list.
+ */
+void COM_ExternalLockDump()
+{
+  COM_ExternalLock *current = elList.head;
+  DPRINTF("\nExternal lock list contains:\n");
+  while ( current != EL_END_OF_LIST ) {
+    DPRINTF( "\t%p with %lu references count.\n", current->pUnk, current->uRefCount);
+    /* Skip to the next item */
+    current = current->next;
+  }
+}
 …
+{
+  if (fLock)
+  {
+    /*
+     * Increment the external lock coutner, COM_ExternalLockAddRef also
+     * increment the object's internal lock counter.
+     */
+    COM_ExternalLockAddRef( pUnk);
+  }
+  else
+  {
+    /*
+     * Decrement the external lock coutner, COM_ExternalLockRelease also
+     * decrement the object's internal lock counter.
+     */
+    COM_ExternalLockRelease( pUnk, fLastUnlockReleases);
+  }
+    return S_OK;
+}
+/***********************************************************************
+ *           CoGetState [COMPOBJ.115]
+ */
+HRESULT WINAPI CoGetState16(LPDWORD state)
+{
+    FIXME("(%p),stub!\n", state);
+    *state = 0;
+    return S_OK;
+}
+        if (fLock) {
+            /*
+             * Increment the external lock coutner, COM_ExternalLockAddRef also
+             * increment the object's internal lock counter.
+             */
+            COM_ExternalLockAddRef( pUnk);
+        } else {
+            /*
+             * Decrement the external lock coutner, COM_ExternalLockRelease also
+             * decrement the object's internal lock counter.
+             */
+            COM_ExternalLockRelease( pUnk, fLastUnlockReleases);
+        }
+        return S_OK;
+}
+/***********************************************************************
+ *           CoInitializeWOW (OLE32.27)
+ */
+HRESULT WINAPI CoInitializeWOW(DWORD x,DWORD y) {
+    FIXME("(0x%08lx,0x%08lx),stub!\n",x,y);
+    return 0;
+}
+static IUnknown * pUnkState = 0; /* FIXME: thread local */
+static int nStatCounter = 0;     /* global */
+static HMODULE hOleAut32 = 0;    /* global */
+/***********************************************************************
+ *           CoGetState [OLE32.24]
+ *
+ * NOTES: might be incomplete
+ */
+HRESULT WINAPI CoGetState(IUnknown ** ppv)
+{
+        FIXME("\n");
+        if(pUnkState) {
+            IUnknown_AddRef(pUnkState);
+            *ppv = pUnkState;
+            FIXME("-- %p\n", *ppv);
+            return S_OK;
+        }
+        *ppv = NULL;
+        return E_FAIL;
+}
 /***********************************************************************
  *           CoSetState [OLE32.42]
+ */
+HRESULT WINAPI CoSetState(LPDWORD state)
+{
+    FIXME("(%p),stub!\n", state);
+    if (state) *state = 0;
+    return S_OK;
+}
+/***********************************************************************
+ *          CoCreateFreeThreadedMarshaler [OLE32.5]
+ */
+HRESULT WINAPI CoCreateFreeThreadedMarshaler (LPUNKNOWN punkOuter, LPUNKNOWN* ppunkMarshal)
+{
+   FIXME ("(%p %p): stub\n", punkOuter, ppunkMarshal);
+   return S_OK;
+}
+/***
+ * COM_RevokeAllClasses
+ *
+ * This method is called when the COM libraries are uninitialized to
+ * release all the references to the class objects registered with
+ * the library
+ */
+static void COM_RevokeAllClasses()
+{
+  EnterCriticalSection( &csRegisteredClassList );
+  while (firstRegisteredClass!=0)
+  {
+    CoRevokeClassObject(firstRegisteredClass->dwCookie);
+  }
+  LeaveCriticalSection( &csRegisteredClassList );
+}
+/****************************************************************************
+ *  COM External Lock methods implementation
+ */
+/****************************************************************************
+ * Public - Method that increments the count for a IUnknown* in the linked
+ * list.  The item is inserted if not already in the list.
+ */
+static void COM_ExternalLockAddRef(
+  IUnknown *pUnk)
+{
+  COM_ExternalLock *externalLock = COM_ExternalLockFind(pUnk);
+  /*
+   * Add an external lock to the object. If it was already externally
+   * locked, just increase the reference count. If it was not.
+   * add the item to the list.
+   */
+  if ( externalLock == EL_NOT_FOUND )
+    COM_ExternalLockInsert(pUnk);
+  else
+    externalLock->uRefCount++;
+  /*
+   * Add an internal lock to the object
+   */
+  IUnknown_AddRef(pUnk);
+}
+/****************************************************************************
+ * Public - Method that decrements the count for a IUnknown* in the linked
+ * list.  The item is removed from the list if its count end up at zero or if
+ * bRelAll is TRUE.
+ */
+static void COM_ExternalLockRelease(
+  IUnknown *pUnk,
+  BOOL   bRelAll)
+{
+  COM_ExternalLock *externalLock = COM_ExternalLockFind(pUnk);
+  if ( externalLock != EL_NOT_FOUND )
+  {
+    do
+    {
+      externalLock->uRefCount--;  /* release external locks      */
+      IUnknown_Release(pUnk);     /* release local locks as well */
+      if ( bRelAll == FALSE )
+        break;  /* perform single release */
+    } while ( externalLock->uRefCount > 0 );
+    if ( externalLock->uRefCount == 0 )  /* get rid of the list entry */
+      COM_ExternalLockDelete(externalLock);
+  }
+}
+/****************************************************************************
+ * Public - Method that frees the content of the list.
+ */
+static void COM_ExternalLockFreeList()
+{
+  COM_ExternalLock *head;
+  head = elList.head;                 /* grab it by the head             */
+  while ( head != EL_END_OF_LIST )
+  {
+    COM_ExternalLockDelete(head);     /* get rid of the head stuff       */
+    head = elList.head;               /* get the new head...             */
+  }
+}
+/****************************************************************************
+ * Public - Method that dump the content of the list.
+ */
+void COM_ExternalLockDump()
+{
+  COM_ExternalLock *current = elList.head;
+  DPRINTF("\nExternal lock list contains:\n");
+  while ( current != EL_END_OF_LIST )
+  {
+      DPRINTF( "\t%p with %lu references count.\n", current->pUnk, current->uRefCount);
+    /* Skip to the next item */
+    current = current->next;
+  }
+}
+/****************************************************************************
+ * Internal - Find a IUnknown* in the linked list
+ */
+static COM_ExternalLock* COM_ExternalLockFind(
+  IUnknown *pUnk)
+{
+  return COM_ExternalLockLocate(elList.head, pUnk);
+}
+/****************************************************************************
+ * Internal - Recursivity agent for IUnknownExternalLockList_Find
+ */
+static COM_ExternalLock* COM_ExternalLockLocate(
+  COM_ExternalLock *element,
+  IUnknown         *pUnk)
+{
+  if ( element == EL_END_OF_LIST )
+    return EL_NOT_FOUND;
+  else if ( element->pUnk == pUnk )    /* We found it */
+    return element;
+  else                                 /* Not the right guy, keep on looking */
+    return COM_ExternalLockLocate( element->next, pUnk);
+}
+/****************************************************************************
+ * Internal - Insert a new IUnknown* to the linked list
+ */
+static BOOL COM_ExternalLockInsert(
+  IUnknown *pUnk)
+{
+  COM_ExternalLock *newLock      = NULL;
+  COM_ExternalLock *previousHead = NULL;
+  /*
+   * Allocate space for the new storage object
+   */
+  newLock = HeapAlloc(GetProcessHeap(), 0, sizeof(COM_ExternalLock));
+  if (newLock!=NULL)
+  {
+    if ( elList.head == EL_END_OF_LIST )
+    {
+      elList.head = newLock;    /* The list is empty */
+    }
+    else
+    {
+      /*
+       * insert does it at the head
+       */
+      previousHead  = elList.head;
+      elList.head = newLock;
+    }
+    /*
+     * Set new list item data member
+     */
+    newLock->pUnk      = pUnk;
+    newLock->uRefCount = 1;
+    newLock->next      = previousHead;
+    return TRUE;
+  }
+  else
+    return FALSE;
+}
+/****************************************************************************
+ * Internal - Method that removes an item from the linked list.
+ */
+static void COM_ExternalLockDelete(
+  COM_ExternalLock *itemList)
+{
+  COM_ExternalLock *current = elList.head;
+  if ( current == itemList )
+  {
+    /*
+     * this section handles the deletion of the first node
+     */
+    elList.head = itemList->next;
+    HeapFree( GetProcessHeap(), 0, itemList);
+  }
+  else
+  {
+    do
+    {
+      if ( current->next == itemList )   /* We found the item to free  */
+      {
+        current->next = itemList->next;  /* readjust the list pointers */
+        HeapFree( GetProcessHeap(), 0, itemList);
+        break;
+      }
+      /* Skip to the next item */
+      current = current->next;
+    } while ( current != EL_END_OF_LIST );
+  }
+}
+/***********************************************************************
+ *      DllEntryPoint                   [COMPOBJ.116]
+ *
+ *    Initialization code for the COMPOBJ DLL
+ *
+ * RETURNS:
+ */
+BOOL WINAPI COMPOBJ_DllEntryPoint(DWORD Reason, HINSTANCE16 hInst, WORD ds, WORD HeapSize, DWORD res1, WORD res2)
+{
+        TRACE("(%08lx, %04x, %04x, %04x, %08lx, %04x)\n", Reason, hInst, ds, HeapSize,
+ res1, res2);
+        switch(Reason)
+        {
+        case DLL_PROCESS_ATTACH:
+                if (!COMPOBJ_Attach++) COMPOBJ_hInstance = hInst;
+                break;
+        case DLL_PROCESS_DETACH:
+                if(!--COMPOBJ_Attach)
+                        COMPOBJ_hInstance = 0;
+                break;
+        }
+        return TRUE;
+}
+ *
+ * NOTES: FIXME: protect this with a crst
+ */
+HRESULT WINAPI CoSetState(IUnknown * pv)
+{
+        FIXME("(%p),stub!\n", pv);
+        if (pv) {
+            IUnknown_AddRef(pv);
+            nStatCounter++;
+            if (nStatCounter == 1) LoadLibraryA("OLEAUT32.DLL");
+        }
+        if (pUnkState) {
+            TRACE("-- release %p now\n", pUnkState);
+            IUnknown_Release(pUnkState);
+            nStatCounter--;
+            if (!nStatCounter) FreeLibrary(hOleAut32);
+        }
+        pUnkState = pv;
+        return S_OK;
+}
 /******************************************************************************
 …
     CLSIDFromString(wbuf,pClsidNew);
 done:
+  if (hkey) RegCloseKey(hkey);
+  return res;
+    if (hkey) RegCloseKey(hkey);
+    return res;
+}
 …
     return !memcmp(rguid1,rguid2,sizeof(GUID));
+}
+/***********************************************************************
+ *           CoInitializeSecurity [OLE32.164]
+ */
+HRESULT WINAPI CoInitializeSecurity(PSECURITY_DESCRIPTOR pSecDesc, LONG cAuthSvc,
+                                    SOLE_AUTHENTICATION_SERVICE* asAuthSvc,
+                                    void* pReserved1, DWORD dwAuthnLevel,
+                                    DWORD dwImpLevel, void* pReserved2,
+                                    DWORD dwCapabilities, void* pReserved3)
+{
+  FIXME("(%p,%ld,%p,%p,%ld,%ld,%p,%ld,%p) - stub!\n", pSecDesc, cAuthSvc,
+        asAuthSvc, pReserved1, dwAuthnLevel, dwImpLevel, pReserved2,
+        dwCapabilities, pReserved3);
+  return S_OK;
+}

trunk/src/ole32/compobj_private.h

r8620	r9400
125	125	int WINAPI FileMonikerImpl_DecomposePath(LPCOLESTR str, LPOLESTR** stringTable);
126	126
	127	HRESULT WINAPI __CLSIDFromStringA(LPCSTR idstr, CLSID *id);
	128
127	129	#endif /* __WINE_OLE_COMPOBJ_H */

trunk/src/ole32/datacache.c

r8620	r9400
827	827
828	828	if (FAILED(hres))
829		return hres;
	829	return (HMETAFILE)hres;
830	830
831	831	/*

trunk/src/ole32/filemoniker.c

-              r8620
+              r9400
     if (!IsEqualCLSID(&clsid,&CLSID_FileMoniker))
         return S_FALSE;
+    res=CreateBindCtx(0,&bind);
+    if (FAILED(res))
+        return res;
+    IMoniker_GetDisplayName(pmkOtherMoniker,bind,NULL,&filePath);
+    if (lstrcmpiW(filePath,
+                  This->filePathName)!=0)
+        return S_FALSE;
+    return S_OK;
+    res = CreateBindCtx(0,&bind);
+    if (FAILED(res)) return res;
+    if (SUCCEEDED(IMoniker_GetDisplayName(pmkOtherMoniker,bind,NULL,&filePath))) {
+        int result = lstrcmpiW(filePath, This->filePathName);
+        CoTaskMemFree(filePath);
+        if ( result == 0 ) return S_OK;
+    }
+    return S_FALSE;
+}
 …
     int len=lstrlenW(str);
+    TRACE("%s, %p\n", debugstr_w(str), *stringTable);
     strgtable =CoTaskMemAlloc(len*sizeof(LPOLESTR));

trunk/src/ole32/hglobalstream.c

-              r8620
+              r9400
 #include "winbase.h"
 #include "winerror.h"
+#include "winternl.h"
 #include "wine/debug.h"
 …
   /*
-   * The caller is allowed to pass in NULL as the new position return value.
-   * If it happens, we assign it to a dynamic variable to avoid special cases
-   * in the code below.
-   */
-  if (plibNewPosition == 0)
+  {
-    plibNewPosition = &newPosition;
+  }
-  /*
    * The file pointer is moved depending on the given "function"
    * parameter.
 …
+  {
     case STREAM_SEEK_SET:
       plibNewPosition->s.HighPart = 0;
       plibNewPosition->s.LowPart  = 0;
+      newPosition.s.HighPart = 0;
+      newPosition.s.LowPart = 0;
       break;
     case STREAM_SEEK_CUR:
       *plibNewPosition = This->currentPosition;
+      newPosition = This->currentPosition;
       break;
     case STREAM_SEEK_END:
       *plibNewPosition = This->streamSize;
+      newPosition = This->streamSize;
       break;
     default:
 …
   /*
-   * We don't support files with offsets of 64 bits.
-   */
-  assert(dlibMove.s.HighPart == 0);
-  /*
-   * Check if we end-up before the beginning of the file. That should trigger an
-   * error.
-   */
-  if ( (dlibMove.s.LowPart<0) && (plibNewPosition->s.LowPart < (ULONG)(-dlibMove.s.LowPart)) )
+  {
-    /*
-     * I don't know what error to send there.
-     */
-    return E_FAIL;
+  }
-  /*
    * Move the actual file pointer
    * If the file pointer ends-up after the end of the stream, the next Write operation will
    * make the file larger. This is how it is documented.
    */
+  plibNewPosition->s.LowPart += dlibMove.s.LowPart;
+  This->currentPosition = *plibNewPosition;
+#ifdef __WIN32OS2__
+  *(LARGE_INTEGER *)&newPosition = RtlpLargeIntegerAdd( (LARGE_INTEGER *)&newPosition, &dlibMove );
+#else
+  newPosition.QuadPart = RtlLargeIntegerAdd(newPosition.QuadPart, dlibMove.QuadPart);
+#endif
+  if (newPosition.QuadPart < 0) return STG_E_INVALIDFUNCTION;
+  if (plibNewPosition) *plibNewPosition = newPosition;
+  This->currentPosition = newPosition;
   return S_OK;
 …
                   IStream**    ppstm) /* [out] */
+{
+  FIXME("not implemented!\n");
+  return E_NOTIMPL;
+}
+  ULARGE_INTEGER dummy;
+  LARGE_INTEGER offset;
+  HRESULT hr;
+  HGLOBALStreamImpl* const This=(HGLOBALStreamImpl*)iface;
+  TRACE(" Cloning %p (deleteOnRelease=%d seek position=%ld)\n",iface,This->deleteOnRelease,(long)This->currentPosition.QuadPart);
+  hr=CreateStreamOnHGlobal(This->supportHandle, FALSE, ppstm);
+  if(FAILED(hr))
+    return hr;
+  offset.QuadPart=(LONGLONG)This->currentPosition.QuadPart;
+  HGLOBALStreamImpl_Seek(*ppstm,offset,STREAM_SEEK_SET,&dummy);
+  return S_OK;
+}

trunk/src/ole32/ifs.c

-              r8441
+              r9400
 #include "ole2.h"
 #include "windef.h"
+#include "winbase.h"
 #include "winerror.h"
 #include "wine/obj_base.h"
-#include "wine/winbase16.h"
-#include "ifs.h"
 #include "wine/debug.h"
+WINE_DEFAULT_DEBUG_CHANNEL(relay);
+/* --- IUnknown implementation */
+typedef struct
+{
+    /* IUnknown fields */
+    ICOM_VFIELD(IUnknown);
+    DWORD                  ref;
+} IUnknownImpl;
+/******************************************************************************
+ *              IUnknown_AddRef [VTABLE:IUNKNOWN.1]
+ */
+static ULONG WINAPI IUnknown_fnAddRef(LPUNKNOWN iface) {
+        ICOM_THIS(IUnknownImpl,iface);
+        TRACE("(%p)->AddRef()\n",This);
+        return ++(This->ref);
+}
+/******************************************************************************
+ * IUnknown_Release [VTABLE:IUNKNOWN.2]
+ */
+static ULONG WINAPI IUnknown_fnRelease(LPUNKNOWN iface) {
+        ICOM_THIS(IUnknownImpl,iface);
+        TRACE("(%p)->Release()\n",This);
+        if (!--(This->ref)) {
+                HeapFree(GetProcessHeap(),0,This);
+                return 0;
+        }
+        return This->ref;
+}
+/******************************************************************************
+ * IUnknown_QueryInterface [VTABLE:IUNKNOWN.0]
+ */
+static HRESULT WINAPI IUnknown_fnQueryInterface(LPUNKNOWN iface,REFIID refiid,LPVOID *obj) {
+        ICOM_THIS(IUnknownImpl,iface);
+        TRACE("(%p)->QueryInterface(%s,%p)\n",This,debugstr_guid(refiid),obj);
+        if (!memcmp(&IID_IUnknown,refiid,sizeof(IID_IUnknown))) {
+                *obj = This;
+                return 0;
+        }
+        return OLE_E_ENUM_NOMORE;
+}
+static ICOM_VTABLE(IUnknown) uvt =
+#ifdef __WIN32OS2__
+#define CRITICAL_SECTION_INIT(name) { (void *)(__FILE__ ": " name), -1, 0, 0, 0, 0 }
+#endif
+WINE_DEFAULT_DEBUG_CHANNEL(ole);
+/******************************************************************************
+ *      IMalloc32 implementation
+ *
+ * NOTES
+ *  For supporting CoRegisterMallocSpy the IMalloc implementation must know if
+ *  a given memory block was allocated with a spy active.
+ *
+ *****************************************************************************/
+/* set the vtable later */
+extern ICOM_VTABLE(IMalloc) VT_IMalloc32;
+typedef struct {
+        ICOM_VFIELD(IMalloc);
+        DWORD dummy;                /* nothing, we are static */
+        IMallocSpy * pSpy;          /* the spy when active */
+        DWORD SpyedAllocationsLeft; /* number of spyed allocations left */
+        BOOL SpyReleasePending;     /* CoRevokeMallocSpy called with spyed allocations left*/
+        LPVOID * SpyedBlocks;       /* root of the table */
+        int SpyedBlockTableLength;  /* size of the table*/
+} _Malloc32;
+/* this is the static object instance */
+_Malloc32 Malloc32 = {&VT_IMalloc32, 0, NULL, 0, 0, NULL, 0};
+/* with a spy active all calls from pre to post methods are threadsave */
+static CRITICAL_SECTION IMalloc32_SpyCS = CRITICAL_SECTION_INIT("IMalloc32_SpyCS");
+/* resize the old table */
+static int SetSpyedBlockTableLength ( int NewLength )
+{
+        Malloc32.SpyedBlocks = (LPVOID*)LocalReAlloc((HLOCAL)Malloc32.SpyedBlocks, NewLength, GMEM_ZEROINIT);
+        Malloc32.SpyedBlockTableLength = NewLength;
+        return Malloc32.SpyedBlocks ? 1 : 0;
+}
+/* add a location to the table */
+static int AddMemoryLocation(LPVOID * pMem)
+{
+        LPVOID * Current;
+        /* allocate the table if not already allocated */
+        if (!Malloc32.SpyedBlockTableLength) {
+            if (!SetSpyedBlockTableLength(0x1000)) return 0;
+        }
+        /* find a free location */
+        Current = Malloc32.SpyedBlocks;
+        while (*Current) {
+            Current++;
+            if (Current >= Malloc32.SpyedBlocks + Malloc32.SpyedBlockTableLength) {
+                /* no more space in table, grow it */
+                if (!SetSpyedBlockTableLength( Malloc32.SpyedBlockTableLength + 0x1000 )) return 0;
+            }
+        };
+        /* put the location in our table */
+        *Current = pMem;
+        Malloc32.SpyedAllocationsLeft++;
+        /*TRACE("%lu\n",Malloc32.SpyedAllocationsLeft);*/
+        return 1;
+}
+static int RemoveMemoryLocation(LPVOID * pMem)
+{
+        LPVOID * Current = Malloc32.SpyedBlocks;
+        /* find the location */
+        while (*Current != pMem) {
+            Current++;
+            if (Current >= Malloc32.SpyedBlocks + Malloc32.SpyedBlockTableLength)  return 0;      /* not found  */
+        }
+        /* location found */
+        Malloc32.SpyedAllocationsLeft--;
+        /*TRACE("%lu\n",Malloc32.SpyedAllocationsLeft);*/
+        *Current = NULL;
+        return 1;
+}
+/******************************************************************************
+ *      IMalloc32_QueryInterface        [VTABLE]
+ */
+static HRESULT WINAPI IMalloc_fnQueryInterface(LPMALLOC iface,REFIID refiid,LPVOID *obj) {
+        TRACE("(%s,%p)\n",debugstr_guid(refiid),obj);
+        if (IsEqualIID(&IID_IUnknown,refiid) || IsEqualIID(&IID_IMalloc,refiid)) {
+                *obj = (LPMALLOC)&Malloc32;
+                return S_OK;
+        }
+        return E_NOINTERFACE;
+}
+/******************************************************************************
+ *      IMalloc32_AddRefRelease         [VTABLE]
+ */
+static ULONG WINAPI IMalloc_fnAddRefRelease (LPMALLOC iface) {
+        return 1;
+}
+/******************************************************************************
+ *      IMalloc32_Alloc                 [VTABLE]
+ */
+static LPVOID WINAPI IMalloc_fnAlloc(LPMALLOC iface, DWORD cb) {
+        LPVOID addr;
+        TRACE("(%ld)\n",cb);
+        if(Malloc32.pSpy) {
+            EnterCriticalSection(&IMalloc32_SpyCS);
+            cb = IMallocSpy_PreAlloc(Malloc32.pSpy, cb);
+            if (0==cb) {
+                /* PreAlloc can force Alloc to fail */
+                LeaveCriticalSection(&IMalloc32_SpyCS);
+                return NULL;
+            }
+        }
+        addr = HeapAlloc(GetProcessHeap(),0,cb);
+        if(Malloc32.pSpy) {
+            addr = IMallocSpy_PostAlloc(Malloc32.pSpy, addr);
+            if (addr) AddMemoryLocation(addr);
+            LeaveCriticalSection(&IMalloc32_SpyCS);
+        }
+        TRACE("--(%p)\n",addr);
+        return addr;
+}
+/******************************************************************************
+ * IMalloc32_Realloc [VTABLE]
+ */
+static LPVOID WINAPI IMalloc_fnRealloc(LPMALLOC iface,LPVOID pv,DWORD cb) {
+        LPVOID pNewMemory;
+        TRACE("(%p,%ld)\n",pv,cb);
+        if(Malloc32.pSpy) {
+            LPVOID pRealMemory;
+            BOOL fSpyed;
+            EnterCriticalSection(&IMalloc32_SpyCS);
+            fSpyed = RemoveMemoryLocation(pv);
+            cb = IMallocSpy_PreRealloc(Malloc32.pSpy, pv, cb, &pRealMemory, fSpyed);
+            /* check if can release the spy */
+            if(Malloc32.SpyReleasePending && !Malloc32.SpyedAllocationsLeft) {
+                IMallocSpy_Release(Malloc32.pSpy);
+                Malloc32.SpyReleasePending = FALSE;
+                Malloc32.pSpy = NULL;
+            }
+            if (0==cb) {
+                /* PreRealloc can force Realloc to fail */
+                LeaveCriticalSection(&IMalloc32_SpyCS);
+                return NULL;
+            }
+            pv = pRealMemory;
+        }
+        pNewMemory = HeapReAlloc(GetProcessHeap(),0,pv,cb);
+        if(Malloc32.pSpy) {
+            pNewMemory = IMallocSpy_PostRealloc(Malloc32.pSpy, pNewMemory, TRUE);
+            if (pNewMemory) AddMemoryLocation(pNewMemory);
+            LeaveCriticalSection(&IMalloc32_SpyCS);
+        }
+        TRACE("--(%p)\n",pNewMemory);
+        return pNewMemory;
+}
+/******************************************************************************
+ * IMalloc32_Free [VTABLE]
+ */
+static VOID WINAPI IMalloc_fnFree(LPMALLOC iface,LPVOID pv) {
+        BOOL fSpyed = 0;
+        TRACE("(%p)\n",pv);
+        if(Malloc32.pSpy) {
+            EnterCriticalSection(&IMalloc32_SpyCS);
+            fSpyed = RemoveMemoryLocation(pv);
+            pv = IMallocSpy_PreFree(Malloc32.pSpy, pv, fSpyed);
+        }
+        HeapFree(GetProcessHeap(),0,pv);
+        if(Malloc32.pSpy) {
+            IMallocSpy_PostFree(Malloc32.pSpy, fSpyed);
+            /* check if can release the spy */
+            if(Malloc32.SpyReleasePending && !Malloc32.SpyedAllocationsLeft) {
+                IMallocSpy_Release(Malloc32.pSpy);
+                Malloc32.SpyReleasePending = FALSE;
+                Malloc32.pSpy = NULL;
+            }
+            LeaveCriticalSection(&IMalloc32_SpyCS);
+        }
+}
+/******************************************************************************
+ * IMalloc32_GetSize [VTABLE]
+ *
+ * NOTES
+ *  FIXME returns:
+ *      win95:  size allocated (4 byte boundarys)
+ *      win2k:  size originally requested !!! (allocated on 8 byte boundarys)
+ */
+static DWORD WINAPI IMalloc_fnGetSize(LPMALLOC iface,LPVOID pv) {
+        DWORD cb;
+        BOOL fSpyed = 0;
+        TRACE("(%p)\n",pv);
+        if(Malloc32.pSpy) {
+            EnterCriticalSection(&IMalloc32_SpyCS);
+            pv = IMallocSpy_PreGetSize(Malloc32.pSpy, pv, fSpyed);
+        }
+        cb = HeapSize(GetProcessHeap(),0,pv);
+        if(Malloc32.pSpy) {
+            cb = IMallocSpy_PostGetSize(Malloc32.pSpy, cb, fSpyed);
+            LeaveCriticalSection(&IMalloc32_SpyCS);
+        }
+        return cb;
+}
+/******************************************************************************
+ * IMalloc32_DidAlloc [VTABLE]
+ */
+static INT WINAPI IMalloc_fnDidAlloc(LPMALLOC iface,LPVOID pv) {
+        BOOL fSpyed = 0;
+        int didAlloc;
+        TRACE("(%p)\n",pv);
+        if(Malloc32.pSpy) {
+            EnterCriticalSection(&IMalloc32_SpyCS);
+            pv = IMallocSpy_PreDidAlloc(Malloc32.pSpy, pv, fSpyed);
+        }
+        didAlloc = -1;
+        if(Malloc32.pSpy) {
+            didAlloc = IMallocSpy_PostDidAlloc(Malloc32.pSpy, pv, fSpyed, didAlloc);
+            LeaveCriticalSection(&IMalloc32_SpyCS);
+        }
+        return didAlloc;
+}
+/******************************************************************************
+ * IMalloc32_HeapMinimize [VTABLE]
+ */
+static VOID WINAPI IMalloc_fnHeapMinimize(LPMALLOC iface) {
+        TRACE("()\n");
+        if(Malloc32.pSpy) {
+            EnterCriticalSection(&IMalloc32_SpyCS);
+            IMallocSpy_PreHeapMinimize(Malloc32.pSpy);
+        }
+        if(Malloc32.pSpy) {
+            IMallocSpy_PostHeapMinimize(Malloc32.pSpy);
+            LeaveCriticalSection(&IMalloc32_SpyCS);
+        }
+}
+#ifdef __WIN32OS2__
+       ICOM_VTABLE(IMalloc) VT_IMalloc32 =
+#else
+static ICOM_VTABLE(IMalloc) VT_IMalloc32 =
+#endif
+{
         ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
+        IUnknown_fnQueryInterface,
+        IUnknown_fnAddRef,
+        IUnknown_fnRelease
+        IMalloc_fnQueryInterface,
+        IMalloc_fnAddRefRelease,
+        IMalloc_fnAddRefRelease,
+        IMalloc_fnAlloc,
+        IMalloc_fnRealloc,
+        IMalloc_fnFree,
+        IMalloc_fnGetSize,
+        IMalloc_fnDidAlloc,
+        IMalloc_fnHeapMinimize
 };
 /******************************************************************************
+ * IUnknown_Constructor [INTERNAL]
+ */
+LPUNKNOWN
+IUnknown_Constructor() {
+        IUnknownImpl*   unk;
+        unk = (IUnknownImpl*)HeapAlloc(GetProcessHeap(),0,sizeof(IUnknownImpl));
+        ICOM_VTBL(unk)  = &uvt;
+        unk->ref        = 1;
+        return (LPUNKNOWN)unk;
+}
+#ifndef __WIN32OS2__
+/* --- IMalloc16 implementation */
+typedef struct
+{
+        /* IUnknown fields */
+        ICOM_VFIELD(IMalloc16);
+        DWORD                   ref;
+        /* IMalloc16 fields */
+} IMalloc16Impl;
+/******************************************************************************
+ *              IMalloc16_QueryInterface        [COMPOBJ.500]
+ */
+HRESULT WINAPI IMalloc16_fnQueryInterface(IMalloc16* iface,REFIID refiid,LPVOID *obj) {
+        ICOM_THIS(IMalloc16Impl,iface);
+        TRACE("(%p)->QueryInterface(%s,%p)\n",This,debugstr_guid(refiid),obj);
+        if (    !memcmp(&IID_IUnknown,refiid,sizeof(IID_IUnknown)) ||
+                !memcmp(&IID_IMalloc,refiid,sizeof(IID_IMalloc))
+        ) {
+                *obj = This;
+                return 0;
+        }
+        return OLE_E_ENUM_NOMORE;
+}
+/******************************************************************************
+ *              IMalloc16_AddRef        [COMPOBJ.501]
+ */
+ULONG WINAPI IMalloc16_fnAddRef(IMalloc16* iface) {
+        ICOM_THIS(IMalloc16Impl,iface);
+        TRACE("(%p)->AddRef()\n",This);
+        return 1; /* cannot be freed */
+}
+/******************************************************************************
+ *              IMalloc16_Release       [COMPOBJ.502]
+ */
+ULONG WINAPI IMalloc16_fnRelease(IMalloc16* iface) {
+        ICOM_THIS(IMalloc16Impl,iface);
+        TRACE("(%p)->Release()\n",This);
+        return 1; /* cannot be freed */
+}
+/******************************************************************************
+ * IMalloc16_Alloc [COMPOBJ.503]
+ */
+SEGPTR WINAPI IMalloc16_fnAlloc(IMalloc16* iface,DWORD cb) {
+        ICOM_THIS(IMalloc16Impl,iface);
+        TRACE("(%p)->Alloc(%ld)\n",This,cb);
+        return MapLS( HeapAlloc( GetProcessHeap(), 0, cb ) );
+}
+/******************************************************************************
+ * IMalloc16_Realloc [COMPOBJ.504]
+ */
+SEGPTR WINAPI IMalloc16_fnRealloc(IMalloc16* iface,SEGPTR pv,DWORD cb)
+{
+    SEGPTR ret;
+    ICOM_THIS(IMalloc16Impl,iface);
+    TRACE("(%p)->Realloc(%08lx,%ld)\n",This,pv,cb);
+    ret = MapLS( HeapReAlloc( GetProcessHeap(), 0, MapSL(pv), cb ) );
+    UnMapLS(pv);
+    return ret;
+}
+/******************************************************************************
+ * IMalloc16_Free [COMPOBJ.505]
+ */
+VOID WINAPI IMalloc16_fnFree(IMalloc16* iface,SEGPTR pv)
+{
+    void *ptr = MapSL(pv);
+    ICOM_THIS(IMalloc16Impl,iface);
+    TRACE("(%p)->Free(%08lx)\n",This,pv);
+    UnMapLS(pv);
+    HeapFree( GetProcessHeap(), 0, ptr );
+}
+/******************************************************************************
+ * IMalloc16_GetSize [COMPOBJ.506]
+ */
+DWORD WINAPI IMalloc16_fnGetSize(const IMalloc16* iface,SEGPTR pv)
+{
+        ICOM_CTHIS(IMalloc16Impl,iface);
+        TRACE("(%p)->GetSize(%08lx)\n",This,pv);
+        return HeapSize( GetProcessHeap(), 0, MapSL(pv) );
+}
+/******************************************************************************
+ * IMalloc16_DidAlloc [COMPOBJ.507]
+ */
+INT16 WINAPI IMalloc16_fnDidAlloc(const IMalloc16* iface,LPVOID pv) {
+        ICOM_CTHIS(IMalloc16,iface);
+        TRACE("(%p)->DidAlloc(%p)\n",This,pv);
+        return (INT16)-1;
+}
+/******************************************************************************
+ * IMalloc16_HeapMinimize [COMPOBJ.508]
+ */
+LPVOID WINAPI IMalloc16_fnHeapMinimize(IMalloc16* iface) {
+        ICOM_THIS(IMalloc16Impl,iface);
+        TRACE("(%p)->HeapMinimize()\n",This);
+        return NULL;
+}
+/******************************************************************************
+ * IMalloc16_Constructor [VTABLE]
+ */
+LPMALLOC16
+IMalloc16_Constructor()
+{
+    static ICOM_VTABLE(IMalloc16) vt16;
+    static SEGPTR msegvt16;
+    IMalloc16Impl* This;
+    HMODULE16 hcomp = GetModuleHandle16("COMPOBJ");
+    This = HeapAlloc( GetProcessHeap(), 0, sizeof(IMalloc16Impl) );
+    if (!msegvt16)
+    {
+#define VTENT(x) vt16.x = (void*)GetProcAddress16(hcomp,"IMalloc16_"#x);assert(vt16.x)
+        VTENT(QueryInterface);
+        VTENT(AddRef);
+        VTENT(Release);
+        VTENT(Alloc);
+        VTENT(Realloc);
+        VTENT(Free);
+        VTENT(GetSize);
+        VTENT(DidAlloc);
+        VTENT(HeapMinimize);
+#undef VTENT
+        msegvt16 = MapLS( &vt16 );
+ *      IMallocSpy implementation
+ *****************************************************************************/
+/* set the vtable later */
+extern ICOM_VTABLE(IMallocSpy) VT_IMallocSpy;
+typedef struct {
+        ICOM_VFIELD(IMallocSpy);
+        DWORD ref;
+} _MallocSpy;
+/* this is the static object instance */
+_MallocSpy MallocSpy = {&VT_IMallocSpy, 0};
+/******************************************************************************
+ *      IMalloc32_QueryInterface        [VTABLE]
+ */
+static HRESULT WINAPI IMallocSpy_fnQueryInterface(LPMALLOCSPY iface,REFIID refiid,LPVOID *obj)
+{
+        TRACE("(%s,%p)\n",debugstr_guid(refiid),obj);
+        if (IsEqualIID(&IID_IUnknown,refiid) || IsEqualIID(&IID_IMallocSpy,refiid)) {
+                *obj = (LPMALLOC)&MallocSpy;
+                return S_OK;
+        }
+        return E_NOINTERFACE;
+}
+/******************************************************************************
+ *      IMalloc32_AddRef                [VTABLE]
+ */
+static ULONG WINAPI IMallocSpy_fnAddRef (LPMALLOCSPY iface)
+{
+    ICOM_THIS (_MallocSpy, iface);
+    TRACE ("(%p)->(count=%lu)\n", This, This->ref);
+    return ++(This->ref);
+}
+/******************************************************************************
+ *      IMalloc32_AddRelease            [VTABLE]
+ *
+ * NOTES
+ *   Our MallocSpy is static. If the count reaches 0 we dump the leaks
+ */
+static ULONG WINAPI IMallocSpy_fnRelease (LPMALLOCSPY iface)
+{
+    ICOM_THIS (_MallocSpy, iface);
+    TRACE ("(%p)->(count=%lu)\n", This, This->ref);
+    if (!--(This->ref)) {
+        /* our allocation list MUST be empty here */
+    }
+    ICOM_VTBL(This) = (ICOM_VTABLE(IMalloc16)*)msegvt16;
+    This->ref = 1;
+    return (LPMALLOC16)MapLS( This );
+}
+    return This->ref;
+}
+static ULONG WINAPI IMallocSpy_fnPreAlloc(LPMALLOCSPY iface, ULONG cbRequest)
+{
+    ICOM_THIS (_MallocSpy, iface);
+    TRACE ("(%p)->(%lu)\n", This, cbRequest);
+    return cbRequest;
+}
+static PVOID WINAPI IMallocSpy_fnPostAlloc(LPMALLOCSPY iface, void* pActual)
+{
+    ICOM_THIS (_MallocSpy, iface);
+    TRACE ("(%p)->(%p)\n", This, pActual);
+    return pActual;
+}
+static PVOID WINAPI IMallocSpy_fnPreFree(LPMALLOCSPY iface, void* pRequest, BOOL fSpyed)
+{
+    ICOM_THIS (_MallocSpy, iface);
+    TRACE ("(%p)->(%p %u)\n", This, pRequest, fSpyed);
+    return pRequest;
+}
+static void  WINAPI IMallocSpy_fnPostFree(LPMALLOCSPY iface, BOOL fSpyed)
+{
+    ICOM_THIS (_MallocSpy, iface);
+    TRACE ("(%p)->(%u)\n", This, fSpyed);
+}
+static ULONG WINAPI IMallocSpy_fnPreRealloc(LPMALLOCSPY iface, void* pRequest, ULONG cbRequest, void** ppNewRequest, BOOL fSpyed)
+{
+    ICOM_THIS (_MallocSpy, iface);
+    TRACE ("(%p)->(%p %lu %u)\n", This, pRequest, cbRequest, fSpyed);
+    *ppNewRequest = pRequest;
+    return cbRequest;
+}
+static PVOID WINAPI IMallocSpy_fnPostRealloc(LPMALLOCSPY iface, void* pActual, BOOL fSpyed)
+{
+    ICOM_THIS (_MallocSpy, iface);
+    TRACE ("(%p)->(%p %u)\n", This, pActual, fSpyed);
+    return pActual;
+}
+static PVOID WINAPI IMallocSpy_fnPreGetSize(LPMALLOCSPY iface, void* pRequest, BOOL fSpyed)
+{
+    ICOM_THIS (_MallocSpy, iface);
+    TRACE ("(%p)->(%p %u)\n", This,  pRequest, fSpyed);
+    return pRequest;
+}
+static ULONG WINAPI IMallocSpy_fnPostGetSize(LPMALLOCSPY iface, ULONG cbActual, BOOL fSpyed)
+{
+    ICOM_THIS (_MallocSpy, iface);
+    TRACE ("(%p)->(%lu %u)\n", This, cbActual, fSpyed);
+    return cbActual;
+}
+static PVOID WINAPI IMallocSpy_fnPreDidAlloc(LPMALLOCSPY iface, void* pRequest, BOOL fSpyed)
+{
+    ICOM_THIS (_MallocSpy, iface);
+    TRACE ("(%p)->(%p %u)\n", This, pRequest, fSpyed);
+    return pRequest;
+}
+static int WINAPI IMallocSpy_fnPostDidAlloc(LPMALLOCSPY iface, void* pRequest, BOOL fSpyed, int fActual)
+{
+    ICOM_THIS (_MallocSpy, iface);
+    TRACE ("(%p)->(%p %u %u)\n", This, pRequest, fSpyed, fActual);
+    return fActual;
+}
+static int WINAPI IMallocSpy_fnPreHeapMinimize(LPMALLOCSPY iface)
+{
+    ICOM_THIS (_MallocSpy, iface);
+    TRACE ("(%p)->()\n", This);
+    return 0;
+}
+static int WINAPI IMallocSpy_fnPostHeapMinimize(LPMALLOCSPY iface)
+{
+    ICOM_THIS (_MallocSpy, iface);
+    TRACE ("(%p)->()\n", This);
+    return 0;
+}
+static void MallocSpyDumpLeaks() {
+        TRACE("leaks: %lu\n", Malloc32.SpyedAllocationsLeft);
+}
+#ifdef __WIN32OS2__
+       ICOM_VTABLE(IMallocSpy) VT_IMallocSpy =
+#else
+static ICOM_VTABLE(IMallocSpy) VT_IMallocSpy =
 #endif
+/* --- IMalloc32 implementation */
+typedef struct
+{
+        /* IUnknown fields */
+        ICOM_VFIELD(IMalloc);
+        DWORD                   ref;
+} IMalloc32Impl;
+/******************************************************************************
+ *              IMalloc32_QueryInterface        [VTABLE]
+ */
+static HRESULT WINAPI IMalloc_fnQueryInterface(LPMALLOC iface,REFIID refiid,LPVOID *obj) {
+        ICOM_THIS(IMalloc32Impl,iface);
+        TRACE("(%p)->QueryInterface(%s,%p)\n",This,debugstr_guid(refiid),obj);
+        if (    !memcmp(&IID_IUnknown,refiid,sizeof(IID_IUnknown)) ||
+                !memcmp(&IID_IMalloc,refiid,sizeof(IID_IMalloc))
+        ) {
+                *obj = This;
+                return S_OK;
+        }
+        return OLE_E_ENUM_NOMORE;
+}
+/******************************************************************************
+ *              IMalloc32_AddRef        [VTABLE]
+ */
+static ULONG WINAPI IMalloc_fnAddRef(LPMALLOC iface) {
+        ICOM_THIS(IMalloc32Impl,iface);
+        TRACE("(%p)->AddRef()\n",This);
+        return 1; /* cannot be freed */
+}
+/******************************************************************************
+ *              IMalloc32_Release       [VTABLE]
+ */
+static ULONG WINAPI IMalloc_fnRelease(LPMALLOC iface) {
+        ICOM_THIS(IMalloc32Impl,iface);
+        TRACE("(%p)->Release()\n",This);
+        return 1; /* cannot be freed */
+}
+/******************************************************************************
+ * IMalloc32_Alloc [VTABLE]
+ */
+static LPVOID WINAPI IMalloc_fnAlloc(LPMALLOC iface,DWORD cb) {
+        LPVOID addr;
+        ICOM_THIS(IMalloc32Impl,iface);
+        addr = HeapAlloc(GetProcessHeap(),0,cb);
+        TRACE("(%p)->Alloc(%ld) -> %p\n",This,cb,addr);
+        return addr;
+}
+/******************************************************************************
+ * IMalloc32_Realloc [VTABLE]
+ */
+static LPVOID WINAPI IMalloc_fnRealloc(LPMALLOC iface,LPVOID pv,DWORD cb) {
+        ICOM_THIS(IMalloc32Impl,iface);
+        TRACE("(%p)->Realloc(%p,%ld)\n",This,pv,cb);
+        return HeapReAlloc(GetProcessHeap(),0,pv,cb);
+}
+/******************************************************************************
+ * IMalloc32_Free [VTABLE]
+ */
+static VOID WINAPI IMalloc_fnFree(LPMALLOC iface,LPVOID pv) {
+        ICOM_THIS(IMalloc32Impl,iface);
+        TRACE("(%p)->Free(%p)\n",This,pv);
+        HeapFree(GetProcessHeap(),0,pv);
+}
+/******************************************************************************
+ * IMalloc32_GetSize [VTABLE]
+ */
+static DWORD WINAPI IMalloc_fnGetSize(LPMALLOC iface,LPVOID pv) {
+        ICOM_CTHIS(IMalloc,iface);
+        TRACE("(%p)->GetSize(%p)\n",This,pv);
+        return HeapSize(GetProcessHeap(),0,pv);
+}
+/******************************************************************************
+ * IMalloc32_DidAlloc [VTABLE]
+ */
+static INT WINAPI IMalloc_fnDidAlloc(LPMALLOC iface,LPVOID pv) {
+        ICOM_CTHIS(IMalloc32Impl,iface);
+        TRACE("(%p)->DidAlloc(%p)\n",This,pv);
+        return -1;
+}
+/******************************************************************************
+ * IMalloc32_HeapMinimize [VTABLE]
+ */
+static VOID WINAPI IMalloc_fnHeapMinimize(LPMALLOC iface) {
+        ICOM_THIS(IMalloc32Impl,iface);
+        TRACE("(%p)->HeapMinimize()\n",This);
+}
+static ICOM_VTABLE(IMalloc) VT_IMalloc32 =
+{
+    ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
+    IMalloc_fnQueryInterface,
+    IMalloc_fnAddRef,
+  IMalloc_fnRelease,
+  IMalloc_fnAlloc,
+  IMalloc_fnRealloc,
+  IMalloc_fnFree,
+  IMalloc_fnGetSize,
+  IMalloc_fnDidAlloc,
+  IMalloc_fnHeapMinimize
+{
+        ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
+        IMallocSpy_fnQueryInterface,
+        IMallocSpy_fnAddRef,
+        IMallocSpy_fnRelease,
+        IMallocSpy_fnPreAlloc,
+        IMallocSpy_fnPostAlloc,
+        IMallocSpy_fnPreFree,
+        IMallocSpy_fnPostFree,
+        IMallocSpy_fnPreRealloc,
+        IMallocSpy_fnPostRealloc,
+        IMallocSpy_fnPreGetSize,
+        IMallocSpy_fnPostGetSize,
+        IMallocSpy_fnPreDidAlloc,
+        IMallocSpy_fnPostDidAlloc,
+        IMallocSpy_fnPreHeapMinimize,
+        IMallocSpy_fnPostHeapMinimize
 };
 /******************************************************************************
+ * IMalloc32_Constructor [VTABLE]
+ */
+LPMALLOC
+IMalloc_Constructor() {
+        IMalloc32Impl* This;
+        This = (IMalloc32Impl*)HeapAlloc(GetProcessHeap(),0,sizeof(IMalloc32Impl));
+        ICOM_VTBL(This) = &VT_IMalloc32;
+        This->ref = 1;
+        return (LPMALLOC)This;
+}
+/****************************************************************************
+ * API Functions
+ */
+ *              CoGetMalloc     [OLE32.20]
+ *
+ * RETURNS
+ *      The win32 IMalloc
+ */
+HRESULT WINAPI CoGetMalloc(DWORD dwMemContext, LPMALLOC *lpMalloc)
+{
+        *lpMalloc = (LPMALLOC)&Malloc32;
+        return S_OK;
+}
+/***********************************************************************
+ *           CoTaskMemAlloc     [OLE32.43]
+ * RETURNS
+ *      pointer to newly allocated block
+ */
+LPVOID WINAPI CoTaskMemAlloc(ULONG size)
+{
+        return IMalloc_Alloc((LPMALLOC)&Malloc32,size);
+}
+/***********************************************************************
+ *           CoTaskMemFree      [OLE32.44]
+ */
+VOID WINAPI CoTaskMemFree(LPVOID ptr)
+{
+        IMalloc_Free((LPMALLOC)&Malloc32, ptr);
+}
+/***********************************************************************
+ *           CoTaskMemRealloc   [OLE32.45]
+ * RETURNS
+ *      pointer to newly allocated block
+ */
+LPVOID WINAPI CoTaskMemRealloc(LPVOID pvOld, ULONG size)
+{
+        return IMalloc_Realloc((LPMALLOC)&Malloc32, pvOld, size);
+}
+/***********************************************************************
+ *           CoRegisterMallocSpy        [OLE32.37]
+ *
+ * NOTES
+ *  if a mallocspy is already registered, we cant do it again since
+ *  only the spy knows, how to free a memory block
+ */
+HRESULT WINAPI CoRegisterMallocSpy(LPMALLOCSPY pMallocSpy)
+{
+        IMallocSpy* pSpy;
+        HRESULT hres = E_INVALIDARG;
+        TRACE("\n");
+        /* HACK TO ACTIVATE OUT SPY */
+        if (pMallocSpy == (LPVOID)-1) pMallocSpy =(IMallocSpy*)&MallocSpy;
+        if(Malloc32.pSpy) return CO_E_OBJISREG;
+        EnterCriticalSection(&IMalloc32_SpyCS);
+        if (SUCCEEDED(IUnknown_QueryInterface(pMallocSpy, &IID_IMallocSpy, (LPVOID*)&pSpy))) {
+            Malloc32.pSpy = pSpy;
+            hres = S_OK;
+        }
+        LeaveCriticalSection(&IMalloc32_SpyCS);
+        return hres;
+}
+/***********************************************************************
+ *           CoRevokeMallocSpy  [OLE32.41]
+ *
+ * NOTES
+ *  we can't rewoke a malloc spy as long as memory blocks allocated with
+ *  the spy are active since only the spy knows how to free them
+ */
+HRESULT WINAPI CoRevokeMallocSpy(void)
+{
+        HRESULT hres = S_OK;
+        TRACE("\n");
+        EnterCriticalSection(&IMalloc32_SpyCS);
+        /* if it's our spy it's time to dump the leaks */
+        if (Malloc32.pSpy == (IMallocSpy*)&MallocSpy) {
+            MallocSpyDumpLeaks();
+        }
+        if (Malloc32.SpyedAllocationsLeft) {
+            TRACE("SpyReleasePending with %lu allocations left\n", Malloc32.SpyedAllocationsLeft);
+            Malloc32.SpyReleasePending = TRUE;
+            hres = E_ACCESSDENIED;
+        } else {
+            IMallocSpy_Release(Malloc32.pSpy);
+            Malloc32.pSpy = NULL;
+        }
+        LeaveCriticalSection(&IMalloc32_SpyCS);
+        return S_OK;
+}
 /******************************************************************************

trunk/src/ole32/itemmoniker.c

-              r8620
+              r9400
     if (!This->itemName)
         return E_OUTOFMEMORY;
     strcpyW(This->itemName,lpszItem);
+    lstrcpyW(This->itemName,lpszItem);
     if (!lpszDelim)
 …
     delim = lpszDelim ? lpszDelim : emptystr;
     sizeStr2=strlenW(delim);
+    sizeStr2=lstrlenW(delim);
     This->itemDelimiter=HeapAlloc(GetProcessHeap(),0,sizeof(WCHAR)*(sizeStr2+1));
     if (!This->itemDelimiter) {
 …
         return E_OUTOFMEMORY;
+    }
     strcpyW(This->itemDelimiter,delim);
+    lstrcpyW(This->itemDelimiter,delim);
     return S_OK;
+}
 …
     LPOLESTR dispName1,dispName2;
     IBindCtx* bind;
     HRESULT res;
+    HRESULT res = S_FALSE;
     TRACE("(%p,%p)\n",iface,pmkOtherMoniker);
+    if (pmkOtherMoniker==NULL)
+        return S_FALSE;
+    /* This method returns S_OK if both monikers are item monikers and their display names are */
+    /* identical (using a case-insensitive comparison); otherwise, the method returns S_FALSE. */
+    IMoniker_GetClassID(pmkOtherMoniker,&clsid);
+    if (!IsEqualCLSID(&clsid,&CLSID_ItemMoniker))
+        return S_FALSE;
+    res=CreateBindCtx(0,&bind);
+    if (FAILED(res))
+        return res;
+    IMoniker_GetDisplayName(iface,bind,NULL,&dispName1);
+    IMoniker_GetDisplayName(pmkOtherMoniker,bind,NULL,&dispName2);
+    if (lstrcmpW(dispName1,dispName2)!=0)
+        return S_FALSE;
+    return S_OK;
+    if (!pmkOtherMoniker) return S_FALSE;
+    /* check if both are ItemMoniker */
+    if(FAILED (IMoniker_GetClassID(pmkOtherMoniker,&clsid))) return S_FALSE;
+    if(!IsEqualCLSID(&clsid,&CLSID_ItemMoniker)) return S_FALSE;
+    /* check if both displaynames are the same */
+    if(SUCCEEDED ((res = CreateBindCtx(0,&bind)))) {
+        if(SUCCEEDED (IMoniker_GetDisplayName(iface,bind,NULL,&dispName1))) {
+            if(SUCCEEDED (IMoniker_GetDisplayName(pmkOtherMoniker,bind,NULL,&dispName2))) {
+                if(lstrcmpW(dispName1,dispName2)==0) res = S_OK;
+                CoTaskMemFree(dispName2);
+            }
+            CoTaskMemFree(dispName1);
+        }
+    }
+    return res;
+}
 …
         return E_OUTOFMEMORY;
     strcpyW(*ppszDisplayName,This->itemDelimiter);
     strcatW(*ppszDisplayName,This->itemName);
+    lstrcpyW(*ppszDisplayName,This->itemDelimiter);
+    lstrcatW(*ppszDisplayName,This->itemName);
     return S_OK;

trunk/src/ole32/marshal.c

-              r8620
+              r9400
+  }
   hres = PIPE_GetNewPipeBuf(&mid,&chanbuf);
+  if (hres)
+    FIXME("Failed to get an rpc channel buffer for %s\n",debugstr_guid(riid));
+  IRpcProxyBuffer_Connect(rpcproxy,chanbuf);
+  IRpcProxyBuffer_Release(rpcproxy); /* no need */
+  if (hres) {
+    ERR("Failed to get an rpc channel buffer for %s\n",debugstr_guid(riid));
+  } else {
+    IRpcProxyBuffer_Connect(rpcproxy,chanbuf);
+    IRpcProxyBuffer_Release(rpcproxy); /* no need */
+  }
   IPSFactoryBuffer_Release(psfacbuf);
   return S_OK;
+  return hres;
+}
 …
         MESSAGE("       Wine registry by running: `regedit winedefault.reg'\n\n");
     } else {
+        FIXME("Failed to Marshal the interface, %lx?\n",hres);
+        if (IsEqualGUID(riid,&IID_IOleObject)) {
+            ERR("WINE currently cannot marshal IOleObject interfaces. This means you cannot embed/link OLE objects between applications.\n");
+        } else {
+            FIXME("Failed to marshal the interface %s, %lx?\n",debugstr_guid(riid),hres);
+        }
+    }
     goto release_marshal;

trunk/src/ole32/ole2stubs.c

r8620	r9400
98	98	FIXME("\n\t%s\n\t%s stub!\n", debugstr_guid(rclsid), debugstr_guid(riid));
99	99
100		if (SUCCEEDED((hres = CoCreateInstance(rclsid, 0, CLSCTX_INPROC_SERVER, riid, (LPVOID*)&pUnk))))
	100	if (SUCCEEDED((hres = CoCreateInstance(rclsid, 0, CLSCTX_INPROC_SERVER\|CLSCTX_INPROC_HANDLER\|CLSCTX_LOCAL_SERVER , riid, (LPVOID*)&pUnk))))
101	101	{
102	102	if (pClientSite)

trunk/src/ole32/ole32.def

r8553	r9400
168	168	WriteStringStream = _WriteStringStream@0 @162
169	169	CoInitializeEx = _CoInitializeEx@8 @163
170		;164 stub CoInitializeSecurity # stdcall (ptr long ptr ptr long long ptr long ptr) return 0,ERR_NOTIMPLEMENTED
	170	CoInitializeSecurity = _CoInitializeSecurity@36 @164
171	171	CoCreateInstanceEx = _CoCreateInstanceEx@24 @165
172	172	PropVariantClear = _PropVariantClear@4 @166

trunk/src/ole32/ole32.mak

-              r8445
+              r9400
 # $Id: ole32.mak,v 1.20 2002-05-16 19:26:29 sandervl Exp $
+# $Id: ole32.mak,v 1.21 2002-11-12 17:06:02 sandervl Exp $
+#
 …
 $(OBJDIR)\bindctx.obj \
 $(OBJDIR)\compositemoniker.obj \
+$(OBJDIR)\compobj.obj \
 $(OBJDIR)\datacache.obj \
 $(OBJDIR)\defaulthandler.obj \
 $(OBJDIR)\errorinfo.obj \
 $(OBJDIR)\filemoniker.obj \
+$(OBJDIR)\ftmarshal.obj \
 $(OBJDIR)\hglobalstream.obj \
 $(OBJDIR)\initialise.obj \
 …
 $(OBJDIR)\ole2.obj \
 $(OBJDIR)\oleobj.obj \
-$(OBJDIR)\compobj.obj \
 $(OBJDIR)\clipboard.obj \
 $(OBJDIR)\ole2stubs.obj \

trunk/src/ole32/ole32dbg.def

r8553	r9400
169	169
170	170	CoInitializeEx = _DbgCoInitializeEx@8 @163
171		;164 stub CoInitializeSecurity # stdcall (ptr long ptr ptr long long ptr long ptr) return 0,ERR_NOTIMPLEMENTED
	171	CoInitializeSecurity = _DbgCoInitializeSecurity@36 @164
172	172	CoCreateInstanceEx = _DbgCoCreateInstanceEx@24 @165
173	173	PropVariantClear = _DbgPropVariantClear@4 @166

trunk/src/ole32/stg_stream.c

-              r8636
+              r9400
 #include "winbase.h"
 #include "winerror.h"
 #include "ntddk.h"
+#include "winternl.h"
 #include "wine/debug.h"
 …
   plibNewPosition->QuadPart = RtlLargeIntegerAdd( plibNewPosition->QuadPart, dlibMove.QuadPart );
 #endif
   /*
    * tell the caller what we calculated

trunk/src/ole32/storage32.c

-              r8620
+              r9400
    * Create the block chain abstractions.
    */
+  This->rootBlockChain =
+    BlockChainStream_Construct(This, &This->rootStartBlock, PROPERTY_NULL);
+  This->smallBlockDepotChain = BlockChainStream_Construct(
+                                 This,
+                                 &This->smallBlockDepotStart,
+                                 PROPERTY_NULL);
+  if(!(This->rootBlockChain =
+       BlockChainStream_Construct(This, &This->rootStartBlock, PROPERTY_NULL)))
+    return STG_E_READFAULT;
+  if(!(This->smallBlockDepotChain =
+       BlockChainStream_Construct(This, &This->smallBlockDepotStart,
+                                  PROPERTY_NULL)))
+    return STG_E_READFAULT;
   /*
 …
+  {
     /* TODO CLEANUP */
     return E_FAIL;
+    return STG_E_READFAULT;
+  }
 …
    * Create the block chain abstraction for the small block root chain.
    */
+  This->smallBlockRootChain = BlockChainStream_Construct(
+                                This,
+                                NULL,
+                                This->rootPropertySetIndex);
+  if(!(This->smallBlockRootChain =
+       BlockChainStream_Construct(This, NULL, This->rootPropertySetIndex)))
+    return STG_E_READFAULT;
   return hr;
 …
  *          blockIndex - Index of the block to retrieve the chain
  *                       for.
+ *          nextBlockIndex - receives the return value.
+ *
  * Returns: This method returns the index of the next block in the chain.
 …
  * See Windows documentation for more details on IStorage methods.
  */
 ULONG StorageImpl_GetNextBlockInChain(
+HRESULT StorageImpl_GetNextBlockInChain(
   StorageImpl* This,
+  ULONG          blockIndex)
+  ULONG        blockIndex,
+  ULONG*       nextBlockIndex)
+{
   ULONG offsetInDepot    = blockIndex * sizeof (ULONG);
   ULONG depotBlockCount  = offsetInDepot / This->bigBlockSize;
   ULONG depotBlockOffset = offsetInDepot % This->bigBlockSize;
-  ULONG nextBlockIndex   = BLOCK_SPECIAL;
   void* depotBuffer;
   ULONG depotBlockIndexPos;
+  assert(depotBlockCount < This->bigBlockDepotCount);
+  int index;
+  *nextBlockIndex   = BLOCK_SPECIAL;
+  if(depotBlockCount >= This->bigBlockDepotCount)
+  {
+    WARN("depotBlockCount %ld, bigBlockDepotCount %ld\n", depotBlockCount,
+         This->bigBlockDepotCount);
+    return STG_E_READFAULT;
+  }
   /*
 …
     depotBuffer = StorageImpl_GetROBigBlock(This, depotBlockIndexPos);
+    if (depotBuffer!=0)
+    {
+      int index;
+      for (index = 0; index < NUM_BLOCKS_PER_DEPOT_BLOCK; index++)
+      {
+        StorageUtl_ReadDWord(depotBuffer, index*sizeof(ULONG), &nextBlockIndex);
+        This->blockDepotCached[index] = nextBlockIndex;
+      }
+      StorageImpl_ReleaseBigBlock(This, depotBuffer);
+    }
+  }
+  nextBlockIndex = This->blockDepotCached[depotBlockOffset/sizeof(ULONG)];
+  return nextBlockIndex;
+    if (!depotBuffer)
+      return STG_E_READFAULT;
+    for (index = 0; index < NUM_BLOCKS_PER_DEPOT_BLOCK; index++)
+    {
+      StorageUtl_ReadDWord(depotBuffer, index*sizeof(ULONG), nextBlockIndex);
+      This->blockDepotCached[index] = *nextBlockIndex;
+    }
+    StorageImpl_ReleaseBigBlock(This, depotBuffer);
+  }
+  *nextBlockIndex = This->blockDepotCached[depotBlockOffset/sizeof(ULONG)];
+  return S_OK;
+}
 …
     StorageUtl_WriteWord(headerBigBlock,  0x1c, (WORD)-2);
     StorageUtl_WriteDWord(headerBigBlock, 0x38, (DWORD)0x1000);
-    StorageUtl_WriteDWord(headerBigBlock, 0x40, (DWORD)0x0001);
+  }
 …
    * Write the information to the header.
    */
+  if (headerBigBlock!=0)
+  {
+    StorageUtl_WriteWord(
+      headerBigBlock,
+      OFFSET_BIGBLOCKSIZEBITS,
+      This->bigBlockSizeBits);
+    StorageUtl_WriteWord(
+      headerBigBlock,
+      OFFSET_SMALLBLOCKSIZEBITS,
+      This->smallBlockSizeBits);
+  StorageUtl_WriteWord(
+    headerBigBlock,
+    OFFSET_BIGBLOCKSIZEBITS,
+    This->bigBlockSizeBits);
+  StorageUtl_WriteWord(
+    headerBigBlock,
+    OFFSET_SMALLBLOCKSIZEBITS,
+    This->smallBlockSizeBits);
+  StorageUtl_WriteDWord(
+    headerBigBlock,
+    OFFSET_BBDEPOTCOUNT,
+    This->bigBlockDepotCount);
+  StorageUtl_WriteDWord(
+    headerBigBlock,
+    OFFSET_ROOTSTARTBLOCK,
+    This->rootStartBlock);
+  StorageUtl_WriteDWord(
+    headerBigBlock,
+    OFFSET_SBDEPOTSTART,
+    This->smallBlockDepotStart);
+  StorageUtl_WriteDWord(
+    headerBigBlock,
+    OFFSET_SBDEPOTCOUNT,
+    This->smallBlockDepotChain ?
+     BlockChainStream_GetCount(This->smallBlockDepotChain) : 0);
+  StorageUtl_WriteDWord(
+    headerBigBlock,
+    OFFSET_EXTBBDEPOTSTART,
+    This->extBigBlockDepotStart);
+  StorageUtl_WriteDWord(
+    headerBigBlock,
+    OFFSET_EXTBBDEPOTCOUNT,
+    This->extBigBlockDepotCount);
+  for (index = 0; index < COUNT_BBDEPOTINHEADER; index ++)
+  {
     StorageUtl_WriteDWord(
       headerBigBlock,
+      OFFSET_BBDEPOTCOUNT,
+      This->bigBlockDepotCount);
+    StorageUtl_WriteDWord(
+      headerBigBlock,
+      OFFSET_ROOTSTARTBLOCK,
+      This->rootStartBlock);
+    StorageUtl_WriteDWord(
+      headerBigBlock,
+      OFFSET_SBDEPOTSTART,
+      This->smallBlockDepotStart);
+    StorageUtl_WriteDWord(
+      headerBigBlock,
+      OFFSET_EXTBBDEPOTSTART,
+      This->extBigBlockDepotStart);
+    StorageUtl_WriteDWord(
+      headerBigBlock,
+      OFFSET_EXTBBDEPOTCOUNT,
+      This->extBigBlockDepotCount);
+    for (index = 0; index < COUNT_BBDEPOTINHEADER; index ++)
+    {
+      StorageUtl_WriteDWord(
+        headerBigBlock,
+        OFFSET_BBDEPOTSTART + (sizeof(ULONG)*index),
+        (This->bigBlockDepotStart[index]));
+    }
+      OFFSET_BBDEPOTSTART + (sizeof(ULONG)*index),
+      (This->bigBlockDepotStart[index]));
+  }
 …
                                            &bbHeadOfChain,
                                            PROPERTY_NULL);
+  if(!bbTempChain) return NULL;
   /*
    * Grow the big block chain.
 …
     newStream->tailIndex = blockIndex;
+    blockIndex = StorageImpl_GetNextBlockInChain(
+                   parentStorage,
+                   blockIndex);
+    if(FAILED(StorageImpl_GetNextBlockInChain(
+              parentStorage,
+              blockIndex,
+              &blockIndex)))
+    {
+      HeapFree(GetProcessHeap(), 0, newStream);
+      return NULL;
+    }
+  }
 …
     count++;
     blockIndex = StorageImpl_GetNextBlockInChain(
+    if(FAILED(StorageImpl_GetNextBlockInChain(
                    This->parentStorage,
+                   blockIndex);
+                   blockIndex,
+                   &blockIndex)))
+      return 0;
+  }
 …
   while ( (blockNoInSequence > 0) &&  (blockIndex != BLOCK_END_OF_CHAIN))
+  {
+    blockIndex =
+      StorageImpl_GetNextBlockInChain(This->parentStorage, blockIndex);
+    if(FAILED(StorageImpl_GetNextBlockInChain(This->parentStorage, blockIndex, &blockIndex)))
+      return FALSE;
     blockNoInSequence--;
+  }
 …
      * Step to the next big block.
      */
     blockIndex    =
       StorageImpl_GetNextBlockInChain(This->parentStorage, blockIndex);
+    if(FAILED(StorageImpl_GetNextBlockInChain(This->parentStorage, blockIndex, &blockIndex)))
+      return FALSE;
     bufferWalker += bytesToReadInBuffer;
 …
   while ( (blockNoInSequence > 0) &&  (blockIndex != BLOCK_END_OF_CHAIN))
+  {
     blockIndex =
+      StorageImpl_GetNextBlockInChain(This->parentStorage, blockIndex);
+    if(FAILED(StorageImpl_GetNextBlockInChain(This->parentStorage, blockIndex,
+                                              &blockIndex)))
+      return FALSE;
     blockNoInSequence--;
+  }
 …
      * Step to the next big block.
      */
     blockIndex    =
+      StorageImpl_GetNextBlockInChain(This->parentStorage, blockIndex);
+    if(FAILED(StorageImpl_GetNextBlockInChain(This->parentStorage, blockIndex,
+                                              &blockIndex)))
+      return FALSE;
     bufferWalker  += bytesToWrite;
     size          -= bytesToWrite;
 …
   while (count < numBlocks)
+  {
     blockIndex =
+      StorageImpl_GetNextBlockInChain(This->parentStorage, blockIndex);
+    if(FAILED(StorageImpl_GetNextBlockInChain(This->parentStorage, blockIndex,
+                                              &blockIndex)))
+      return FALSE;
     count++;
+  }
   /* Get the next block before marking the new end */
+  extraBlock =
+    StorageImpl_GetNextBlockInChain(This->parentStorage, blockIndex);
+  if(FAILED(StorageImpl_GetNextBlockInChain(This->parentStorage, blockIndex,
+                                            &extraBlock)))
+    return FALSE;
   /* Mark the new end of chain */
 …
   while (extraBlock != BLOCK_END_OF_CHAIN)
+  {
     blockIndex =
+      StorageImpl_GetNextBlockInChain(This->parentStorage, extraBlock);
+    if(FAILED(StorageImpl_GetNextBlockInChain(This->parentStorage, extraBlock,
+                                              &blockIndex)))
+      return FALSE;
     StorageImpl_FreeBigBlock(This->parentStorage, extraBlock);
     extraBlock = blockIndex;
 …
       currentBlock = blockIndex;
+      blockIndex =
+        StorageImpl_GetNextBlockInChain(This->parentStorage, currentBlock);
+      if(FAILED(StorageImpl_GetNextBlockInChain(This->parentStorage, currentBlock,
+                                                &blockIndex)))
+        return FALSE;
+    }
 …
  *    - BLOCK_UNUSED: small block 'blockIndex' is free
  */
 ULONG SmallBlockChainStream_GetNextBlockInChain(
+HRESULT SmallBlockChainStream_GetNextBlockInChain(
   SmallBlockChainStream* This,
+  ULONG                  blockIndex)
+  ULONG                  blockIndex,
+  ULONG*                 nextBlockInChain)
+{
   ULARGE_INTEGER offsetOfBlockInDepot;
   DWORD  buffer;
-  ULONG  nextBlockInChain = BLOCK_END_OF_CHAIN;
   ULONG  bytesRead;
   BOOL success;
+  *nextBlockInChain = BLOCK_END_OF_CHAIN;
   offsetOfBlockInDepot.s.HighPart = 0;
 …
   if (success)
+  {
+    StorageUtl_ReadDWord(&buffer, 0, &nextBlockInChain);
+  }
+  return nextBlockInChain;
+    StorageUtl_ReadDWord(&buffer, 0, nextBlockInChain);
+    return S_OK;
+  }
+  return STG_E_READFAULT;
+}
 …
+      {
         sbdIndex = nextBlock;
+        nextBlock =
+          StorageImpl_GetNextBlockInChain(This->parentStorage, sbdIndex);
+        StorageImpl_GetNextBlockInChain(This->parentStorage, sbdIndex, &nextBlock);
+      }
 …
   while ( (blockNoInSequence > 0) &&  (blockIndex != BLOCK_END_OF_CHAIN))
+  {
+    blockIndex = SmallBlockChainStream_GetNextBlockInChain(This, blockIndex);
+    if(FAILED(SmallBlockChainStream_GetNextBlockInChain(This, blockIndex,
+                                                        &blockIndex)))
+      return FALSE;
     blockNoInSequence--;
+  }
 …
      * Step to the next big block.
      */
+    blockIndex    = SmallBlockChainStream_GetNextBlockInChain(This, blockIndex);
+    if(FAILED(SmallBlockChainStream_GetNextBlockInChain(This, blockIndex, &blockIndex)))
+      return FALSE;
     bufferWalker += bytesToReadInBuffer;
     size         -= bytesToReadInBuffer;
 …
   while ( (blockNoInSequence > 0) &&  (blockIndex != BLOCK_END_OF_CHAIN))
+  {
     blockIndex = SmallBlockChainStream_GetNextBlockInChain(This, blockIndex);
+    if(FAILED(SmallBlockChainStream_GetNextBlockInChain(This, blockIndex, &blockIndex)))
+      return FALSE;
     blockNoInSequence--;
+  }
 …
      * Step to the next big block.
      */
+    blockIndex    = SmallBlockChainStream_GetNextBlockInChain(This, blockIndex);
+    if(FAILED(SmallBlockChainStream_GetNextBlockInChain(This, blockIndex,
+                                                        &blockIndex)))
+      return FALSE;
     bufferWalker  += bytesToWriteInBuffer;
     size          -= bytesToWriteInBuffer;
 …
   while (count < numBlocks)
+  {
+    blockIndex = SmallBlockChainStream_GetNextBlockInChain(This, blockIndex);
+    if(FAILED(SmallBlockChainStream_GetNextBlockInChain(This, blockIndex,
+                                                        &blockIndex)))
+      return FALSE;
     count++;
+  }
 …
+  {
     /* Get the next block before marking the new end */
+    extraBlock = SmallBlockChainStream_GetNextBlockInChain(This, blockIndex);
+    if(FAILED(SmallBlockChainStream_GetNextBlockInChain(This, blockIndex,
+                                                        &extraBlock)))
+      return FALSE;
     /* Mark the new end of chain */
 …
   while (extraBlock != BLOCK_END_OF_CHAIN)
+  {
+    blockIndex = SmallBlockChainStream_GetNextBlockInChain(This, extraBlock);
+    if(FAILED(SmallBlockChainStream_GetNextBlockInChain(This, extraBlock,
+                                                        &blockIndex)))
+      return FALSE;
     SmallBlockChainStream_FreeBlock(This, extraBlock);
     extraBlock = blockIndex;
 …
     oldNumBlocks++;
     currentBlock = blockIndex;
+    blockIndex = SmallBlockChainStream_GetNextBlockInChain(This, currentBlock);
+    if(FAILED(SmallBlockChainStream_GetNextBlockInChain(This, currentBlock, &blockIndex)))
+      return FALSE;
+  }
 …
     count++;
+    blockIndex = SmallBlockChainStream_GetNextBlockInChain(This, blockIndex);
+    if(FAILED(SmallBlockChainStream_GetNextBlockInChain(This, blockIndex, &blockIndex)))
+      return 0;
+  }
 …
          newStorage,
 ,
 ,
+,
          plkbyt,
          grfMode,

trunk/src/ole32/storage32.h

-              r8441
+              r9400
+ *
  * This include file contains definitions of types and function
  * prototypes that are used in the many files implementing the
+ * prototypes that are used in the many files implementing the
  * storage functionality
+ *
 …
 static const ULONG OFFSET_ROOTSTARTBLOCK     = 0x00000030;
 static const ULONG OFFSET_SBDEPOTSTART       = 0x0000003C;
+static const ULONG OFFSET_SBDEPOTCOUNT       = 0x00000040;
 static const ULONG OFFSET_EXTBBDEPOTSTART    = 0x00000044;
 static const ULONG OFFSET_EXTBBDEPOTCOUNT    = 0x00000048;
 …
 static const ULONG OFFSET_PS_PROPERTYTYPE    = 0x00000042;
 static const ULONG OFFSET_PS_PREVIOUSPROP    = 0x00000044;
 static const ULONG OFFSET_PS_NEXTPROP        = 0x00000048;
+static const ULONG OFFSET_PS_NEXTPROP        = 0x00000048;
 static const ULONG OFFSET_PS_DIRPROP         = 0x0000004C;
 static const ULONG OFFSET_PS_GUID            = 0x00000050;
 …
 static const ULONG OFFSET_PS_TSS2            = 0x0000006C;
 static const ULONG OFFSET_PS_TSD2            = 0x00000070;
 static const ULONG OFFSET_PS_STARTBLOCK      = 0x00000074;
 static const ULONG OFFSET_PS_SIZE            = 0x00000078;
+static const ULONG OFFSET_PS_STARTBLOCK      = 0x00000074;
+static const ULONG OFFSET_PS_SIZE            = 0x00000078;
 static const WORD  DEF_BIG_BLOCK_SIZE_BITS   = 0x0009;
 static const WORD  DEF_SMALL_BLOCK_SIZE_BITS = 0x0006;
 …
 #define PROPERTY_NAME_MAX_LEN    0x20
 #define PROPERTY_NAME_BUFFER_LEN 0x40
+#define PROPERTY_NAME_BUFFER_LEN 0x40
 #define PROPSET_BLOCK_SIZE 0x00000080
 …
+ *
  * The big block file is an abstraction of a flat file separated in
  * same sized blocks. The implementation for the methods described in
+ * same sized blocks. The implementation for the methods described in
  * this section appear in stg_bigblockfile.c
  */
 …
    */
   ULONG ref;
   /*
    * Ancestor storage (top level)
    */
   StorageImpl* ancestorStorage;
+  /*
+   * Ancestor storage (top level)
+   */
+  StorageImpl* ancestorStorage;
   /*
    * Index of the property for the root of
 …
    */
   ULONG rootPropertySetIndex;
   /*
+  /*
    * virtual Destructor method.
    */
 …
             REFIID             riid,
             void**             ppvObject);
 ULONG WINAPI StorageBaseImpl_AddRef(
+ULONG WINAPI StorageBaseImpl_AddRef(
             IStorage*        iface);
 ULONG WINAPI StorageBaseImpl_Release(
+ULONG WINAPI StorageBaseImpl_Release(
             IStorage*        iface);
 HRESULT WINAPI StorageBaseImpl_OpenStream(
+HRESULT WINAPI StorageBaseImpl_OpenStream(
             IStorage*        iface,
             const OLECHAR*   pwcsName,  /* [string][in] */
             void*              reserved1, /* [unique][in] */
             DWORD              grfMode,   /* [in] */
             DWORD              reserved2, /* [in] */
             IStream**        ppstm);    /* [out] */
 HRESULT WINAPI StorageBaseImpl_OpenStorage(
+            DWORD              grfMode,   /* [in] */
+            DWORD              reserved2, /* [in] */
+            IStream**        ppstm);    /* [out] */
+HRESULT WINAPI StorageBaseImpl_OpenStorage(
             IStorage*        iface,
             const OLECHAR*   pwcsName,      /* [string][unique][in] */
             IStorage*        pstgPriority,  /* [unique][in] */
             DWORD              grfMode,       /* [in] */
             SNB              snbExclude,    /* [unique][in] */
             DWORD              reserved,      /* [in] */
             IStorage**       ppstg);        /* [out] */
 HRESULT WINAPI StorageBaseImpl_EnumElements(
+            const OLECHAR*   pwcsName,      /* [string][unique][in] */
+            IStorage*        pstgPriority,  /* [unique][in] */
+            DWORD              grfMode,       /* [in] */
+            SNB              snbExclude,    /* [unique][in] */
+            DWORD              reserved,      /* [in] */
+            IStorage**       ppstg);        /* [out] */
+HRESULT WINAPI StorageBaseImpl_EnumElements(
             IStorage*        iface,
             DWORD              reserved1, /* [in] */
             void*              reserved2, /* [size_is][unique][in] */
             DWORD              reserved3, /* [in] */
             IEnumSTATSTG**     ppenum);   /* [out] */
 HRESULT WINAPI StorageBaseImpl_Stat(
+            DWORD              reserved1, /* [in] */
+            void*              reserved2, /* [size_is][unique][in] */
+            DWORD              reserved3, /* [in] */
+            IEnumSTATSTG**     ppenum);   /* [out] */
+HRESULT WINAPI StorageBaseImpl_Stat(
             IStorage*        iface,
             STATSTG*           pstatstg,     /* [out] */
             DWORD              grfStatFlag); /* [in] */
+            STATSTG*           pstatstg,     /* [out] */
+            DWORD              grfStatFlag); /* [in] */
 HRESULT WINAPI StorageBaseImpl_RenameElement(
 …
    */
   ULONG                 ref;
   struct StorageImpl* ancestorStorage;
+  struct StorageImpl* ancestorStorage;
   ULONG                 rootPropertySetIndex;
   void (*v_destructor)(struct StorageImpl*);
   /*
    * The following data members are specific to the Storage32Impl
 …
   BlockChainStream* rootBlockChain;
   BlockChainStream* smallBlockDepotChain;
   BlockChainStream* smallBlockRootChain;
+  BlockChainStream* smallBlockRootChain;
   /*
    * Pointer to the big block file abstraction
    */
   BigBlockFile* bigBlockFile;
+  BigBlockFile* bigBlockFile;
 };
 /*
  * Method declaration for the Storage32Impl class
  */
 HRESULT WINAPI StorageImpl_CreateStorage(
+ */
+HRESULT WINAPI StorageImpl_CreateStorage(
             IStorage*      iface,
             const OLECHAR* pwcsName,  /* [string][in] */
             DWORD            grfMode,   /* [in] */
             DWORD            dwStgFmt,  /* [in] */
             DWORD            reserved2, /* [in] */
             IStorage**     ppstg);    /* [out] */
 HRESULT WINAPI StorageImpl_CopyTo(
+            const OLECHAR* pwcsName,  /* [string][in] */
+            DWORD            grfMode,   /* [in] */
+            DWORD            dwStgFmt,  /* [in] */
+            DWORD            reserved2, /* [in] */
+            IStorage**     ppstg);    /* [out] */
+HRESULT WINAPI StorageImpl_CopyTo(
             IStorage*      iface,
             DWORD          ciidExclude,  /* [in] */
             const IID*     rgiidExclude, /* [size_is][unique][in] */
             SNB            snbExclude, /* [unique][in] */
             IStorage*    pstgDest);    /* [unique][in] */
 HRESULT WINAPI StorageImpl_MoveElementTo(
+            DWORD          ciidExclude,  /* [in] */
+            const IID*     rgiidExclude, /* [size_is][unique][in] */
+            SNB            snbExclude, /* [unique][in] */
+            IStorage*    pstgDest);    /* [unique][in] */
+HRESULT WINAPI StorageImpl_MoveElementTo(
             IStorage*      iface,
             const OLECHAR* pwcsName,    /* [string][in] */
             IStorage*      pstgDest,    /* [unique][in] */
             const OLECHAR* pwcsNewName, /* [string][in] */
             DWORD            grfFlags);   /* [in] */
 HRESULT WINAPI StorageImpl_Commit(
+            const OLECHAR* pwcsName,    /* [string][in] */
+            IStorage*      pstgDest,    /* [unique][in] */
+            const OLECHAR* pwcsNewName, /* [string][in] */
+            DWORD            grfFlags);   /* [in] */
+HRESULT WINAPI StorageImpl_Commit(
             IStorage*      iface,
             DWORD          grfCommitFlags); /* [in] */
 HRESULT WINAPI StorageImpl_Revert(
+            DWORD          grfCommitFlags); /* [in] */
+HRESULT WINAPI StorageImpl_Revert(
             IStorage*      iface);
 HRESULT WINAPI StorageImpl_DestroyElement(
+HRESULT WINAPI StorageImpl_DestroyElement(
             IStorage*      iface,
             const OLECHAR* pwcsName); /* [string][in] */
 HRESULT WINAPI StorageImpl_SetElementTimes(
+            const OLECHAR* pwcsName); /* [string][in] */
+HRESULT WINAPI StorageImpl_SetElementTimes(
             IStorage*      iface,
             const OLECHAR* pwcsName, /* [string][in] */
             const FILETIME*  pctime,   /* [in] */
             const FILETIME*  patime,   /* [in] */
             const FILETIME*  pmtime);  /* [in] */
 HRESULT WINAPI StorageImpl_SetStateBits(
+            const OLECHAR* pwcsName, /* [string][in] */
+            const FILETIME*  pctime,   /* [in] */
+            const FILETIME*  patime,   /* [in] */
+            const FILETIME*  pmtime);  /* [in] */
+HRESULT WINAPI StorageImpl_SetStateBits(
             IStorage*      iface,
             DWORD          grfStateBits, /* [in] */
             DWORD          grfMask);     /* [in] */
+            DWORD          grfStateBits, /* [in] */
+            DWORD          grfMask);     /* [in] */
 HRESULT WINAPI StorageImpl_Stat(IStorage* iface,
 …
             ULONG blockIndex);
+ULONG StorageImpl_GetNextBlockInChain(
+            StorageImpl* This,
+            ULONG blockIndex);
+HRESULT StorageImpl_GetNextBlockInChain(
+            StorageImpl* This,
+            ULONG blockIndex,
+            ULONG* nextBlockIndex);
 void StorageImpl_SetNextBlockInChain(
             StorageImpl* This,
             ULONG blockIndex,
       ULONG nextBlock);
+            ULONG nextBlock);
 HRESULT StorageImpl_LoadFileHeader(
 …
    */
   ULONG                      ref;
   struct StorageImpl* ancestorStorage;
+  struct StorageImpl* ancestorStorage;
   ULONG                    rootPropertySetIndex;
   void (*v_destructor)(struct StorageInternalImpl*);
 …
  */
 StorageInternalImpl* StorageInternalImpl_Construct(
             StorageImpl* ancestorStorage,
+            StorageImpl* ancestorStorage,
             ULONG          rootTropertyIndex);
 …
             StorageInternalImpl* This);
 HRESULT WINAPI StorageInternalImpl_Commit(
+HRESULT WINAPI StorageInternalImpl_Commit(
             IStorage*            iface,
             DWORD                  grfCommitFlags); /* [in] */
 HRESULT WINAPI StorageInternalImpl_Revert(
+            DWORD                  grfCommitFlags); /* [in] */
+HRESULT WINAPI StorageInternalImpl_Revert(
             IStorage*            iface);
 …
   ICOM_VFIELD(IEnumSTATSTG);    /* Needs to be the first item in the struct
                                          * since we want to cast this in a IEnumSTATSTG pointer */
   ULONG          ref;                   /* Reference count */
   StorageImpl* parentStorage;         /* Reference to the parent storage */
 …
             REFIID            riid,
             void**            ppvObject);
 ULONG WINAPI IEnumSTATSTGImpl_AddRef(
             IEnumSTATSTG*     iface);
+            IEnumSTATSTG*     iface);
 ULONG WINAPI IEnumSTATSTGImpl_Release(
             IEnumSTATSTG*     iface);
 HRESULT WINAPI IEnumSTATSTGImpl_Next(
             IEnumSTATSTG*     iface,
 …
             STATSTG*          rgelt,
             ULONG*            pceltFetched);
 HRESULT WINAPI IEnumSTATSTGImpl_Skip(
             IEnumSTATSTG*     iface,
             ULONG             celt);
 HRESULT WINAPI IEnumSTATSTGImpl_Reset(
             IEnumSTATSTG* iface);
 HRESULT WINAPI IEnumSTATSTGImpl_Clone(
             IEnumSTATSTG*     iface,
 …
   ICOM_VFIELD(IStream);  /* Needs to be the first item in the struct
                                     * since we want to cast this in a IStream pointer */
   /*
    * Reference count
 …
    */
   ULARGE_INTEGER     currentPosition;
   /*
    * The information in the stream is represented by a chain of small blocks
 …
 HRESULT WINAPI StgStreamImpl_QueryInterface(
                 IStream*      iface,
                 REFIID         riid,            /* [in] */
                 void**         ppvObject);  /* [iid_is][out] */
+                REFIID         riid,            /* [in] */
+                void**         ppvObject);  /* [iid_is][out] */
 ULONG WINAPI StgStreamImpl_AddRef(
                 IStream*      iface);
 ULONG WINAPI StgStreamImpl_Release(
                 IStream*      iface);
 HRESULT WINAPI StgStreamImpl_Read(
+HRESULT WINAPI StgStreamImpl_Read(
                 IStream*      iface,
                 void*          pv,        /* [length_is][size_is][out] */
                 ULONG          cb,        /* [in] */
                 ULONG*         pcbRead);  /* [out] */
+                ULONG          cb,        /* [in] */
+                ULONG*         pcbRead);  /* [out] */
 HRESULT WINAPI StgStreamImpl_Write(
                 IStream*      iface,
                 const void*    pv,          /* [size_is][in] */
                 ULONG          cb,          /* [in] */
                 ULONG*         pcbWritten); /* [out] */
 HRESULT WINAPI StgStreamImpl_Seek(
+                const void*    pv,          /* [size_is][in] */
+                ULONG          cb,          /* [in] */
+                ULONG*         pcbWritten); /* [out] */
+HRESULT WINAPI StgStreamImpl_Seek(
                 IStream*      iface,
                 LARGE_INTEGER   dlibMove,         /* [in] */
                 DWORD           dwOrigin,         /* [in] */
+                LARGE_INTEGER   dlibMove,         /* [in] */
+                DWORD           dwOrigin,         /* [in] */
                 ULARGE_INTEGER* plibNewPosition); /* [out] */
 HRESULT WINAPI StgStreamImpl_SetSize(
+HRESULT WINAPI StgStreamImpl_SetSize(
                 IStream*      iface,
                 ULARGE_INTEGER  libNewSize);  /* [in] */
 HRESULT WINAPI StgStreamImpl_CopyTo(
+                ULARGE_INTEGER  libNewSize);  /* [in] */
+HRESULT WINAPI StgStreamImpl_CopyTo(
                 IStream*      iface,
                 IStream*      pstm,         /* [unique][in] */
                 ULARGE_INTEGER  cb,           /* [in] */
                 ULARGE_INTEGER* pcbRead,      /* [out] */
                 ULARGE_INTEGER* pcbWritten);  /* [out] */
 HRESULT WINAPI StgStreamImpl_Commit(
+                IStream*      pstm,         /* [unique][in] */
+                ULARGE_INTEGER  cb,           /* [in] */
+                ULARGE_INTEGER* pcbRead,      /* [out] */
+                ULARGE_INTEGER* pcbWritten);  /* [out] */
+HRESULT WINAPI StgStreamImpl_Commit(
                 IStream*      iface,
                 DWORD           grfCommitFlags); /* [in] */
 HRESULT WINAPI StgStreamImpl_Revert(
+                DWORD           grfCommitFlags); /* [in] */
+HRESULT WINAPI StgStreamImpl_Revert(
                 IStream*  iface);
 HRESULT WINAPI StgStreamImpl_LockRegion(
+HRESULT WINAPI StgStreamImpl_LockRegion(
                 IStream*     iface,
                 ULARGE_INTEGER libOffset,   /* [in] */
                 ULARGE_INTEGER cb,          /* [in] */
                 DWORD          dwLockType); /* [in] */
 HRESULT WINAPI StgStreamImpl_UnlockRegion(
+                ULARGE_INTEGER libOffset,   /* [in] */
+                ULARGE_INTEGER cb,          /* [in] */
+                DWORD          dwLockType); /* [in] */
+HRESULT WINAPI StgStreamImpl_UnlockRegion(
                 IStream*     iface,
                 ULARGE_INTEGER libOffset,   /* [in] */
                 ULARGE_INTEGER cb,          /* [in] */
                 DWORD          dwLockType); /* [in] */
 HRESULT WINAPI StgStreamImpl_Stat(
+                ULARGE_INTEGER libOffset,   /* [in] */
+                ULARGE_INTEGER cb,          /* [in] */
+                DWORD          dwLockType); /* [in] */
+HRESULT WINAPI StgStreamImpl_Stat(
                 IStream*     iface,
                 STATSTG*       pstatstg,     /* [out] */
                 DWORD          grfStatFlag); /* [in] */
 HRESULT WINAPI StgStreamImpl_Clone(
+                DWORD          grfStatFlag); /* [in] */
+HRESULT WINAPI StgStreamImpl_Clone(
                 IStream*     iface,
                 IStream**    ppstm);       /* [out] */
+                IStream**    ppstm);       /* [out] */
 /********************************************************************************
  * The StorageUtl_ functions are miscelaneous utility functions. Most of which are
  * abstractions used to read values from file buffers without having to worry
+ * abstractions used to read values from file buffers without having to worry
  * about bit order
  */
 …
  */
 BlockChainStream* BlockChainStream_Construct(
                 StorageImpl* parentStorage,
+                StorageImpl* parentStorage,
                 ULONG*         headOfStreamPlaceHolder,
                 ULONG          propertyIndex);
 …
  */
 SmallBlockChainStream* SmallBlockChainStream_Construct(
                StorageImpl* parentStorage,
+               StorageImpl* parentStorage,
                ULONG          propertyIndex);
 …
                SmallBlockChainStream* This);
 ULONG SmallBlockChainStream_GetNextBlockInChain(
+HRESULT SmallBlockChainStream_GetNextBlockInChain(
                SmallBlockChainStream* This,
+               ULONG                  blockIndex);
+               ULONG                  blockIndex,
+               ULONG*                 nextBlockIndex);
 void SmallBlockChainStream_SetNextBlockInChain(
 …
 #endif /* __STORAGE32_H__ */

trunk/src/ole32/stubs.cpp

-              r7958
+              r9400
 /* $Id: stubs.cpp,v 1.21 2002-02-19 12:34:50 sandervl Exp $ */
+/* $Id: stubs.cpp,v 1.22 2002-11-12 17:06:03 sandervl Exp $ */
 /*
  * Win32 COM/OLE stubs for OS/2
 …
 //*******************************************************************************
 //*******************************************************************************
-HRESULT WIN32API CoRegisterMallocSpy(LPMALLOCSPY pMallocSpy)
+{
-    dprintf(("OLE32: CoRegisterMallocSpy - stub"));
-    return CO_E_OBJISREG;
+}
-//*******************************************************************************
-//*******************************************************************************
 HRESULT WIN32API CoReleaseMarshalData(IStream *pStm)
+{
     dprintf(("OLE32: CoReleaseMarshalData - stub"));
     return E_OUTOFMEMORY;
+}
-//*******************************************************************************
-//*******************************************************************************
-HRESULT WIN32API CoRevokeMallocSpy()
+{
-    dprintf(("OLE32: CoRevokeMallocSpy - stub"));
-    return E_ACCESSDENIED;
+}
 //*******************************************************************************
 …
+{
     dprintf(("OLE32: CoImpersonateClient - Stub"));
-    return(S_OK);
+}
-//*******************************************************************************
-//*******************************************************************************
-HRESULT WIN32API CoInitializeSecurity(          // DCOM - obj_clientserver.h
-    PSECURITY_DESCRIPTOR         pSecDesc,
-    LONG                         cAuthSvc,
-    SOLE_AUTHENTICATION_SERVICE *asAuthSvc,
-    void                        *pReserved1,
-    DWORD                        dwAuthnLevel,
-    DWORD                        dwImpLevel,
-    void                        *pReserved2,
-    DWORD                        dwCapabilities,
-    void                        *pReserved3 )
+{
-    dprintf(("OLE32: CoInitializeSecurity - Stub"));
     return(S_OK);
+}

Context Navigation

Legend:

trunk/src/ole32/compobj.c

trunk/src/ole32/compobj_private.h

trunk/src/ole32/datacache.c

trunk/src/ole32/filemoniker.c

trunk/src/ole32/hglobalstream.c

trunk/src/ole32/ifs.c

trunk/src/ole32/itemmoniker.c

trunk/src/ole32/marshal.c

trunk/src/ole32/ole2stubs.c

trunk/src/ole32/ole32.def

trunk/src/ole32/ole32.mak

trunk/src/ole32/ole32dbg.def

trunk/src/ole32/stg_stream.c

trunk/src/ole32/storage32.c

trunk/src/ole32/storage32.h

trunk/src/ole32/stubs.cpp

Download in other formats: