2 * FileMonikers implementation
4 * Copyright 1999 Noomen Hamza
5 * Copyright 2007 Robert Shearman
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
27 #define NONAMELESSUNION
33 #include "wine/unicode.h"
34 #include "wine/debug.h"
38 #include "compobj_private.h"
40 WINE_DEFAULT_DEBUG_CHANNEL(ole
);
42 /* filemoniker data structure */
43 typedef struct FileMonikerImpl
{
44 IMoniker IMoniker_iface
;
45 IROTData IROTData_iface
;
47 LPOLESTR filePathName
; /* path string identified by this filemoniker */
48 IUnknown
*pMarshal
; /* custom marshaler */
51 static inline FileMonikerImpl
*impl_from_IMoniker(IMoniker
*iface
)
53 return CONTAINING_RECORD(iface
, FileMonikerImpl
, IMoniker_iface
);
56 static inline FileMonikerImpl
*impl_from_IROTData(IROTData
*iface
)
58 return CONTAINING_RECORD(iface
, FileMonikerImpl
, IROTData_iface
);
61 /* Local function used by filemoniker implementation */
62 static HRESULT
FileMonikerImpl_Construct(FileMonikerImpl
* iface
, LPCOLESTR lpszPathName
);
63 static HRESULT
FileMonikerImpl_Destroy(FileMonikerImpl
* iface
);
65 /*******************************************************************************
66 * FileMoniker_QueryInterface
69 FileMonikerImpl_QueryInterface(IMoniker
* iface
,REFIID riid
,void** ppvObject
)
71 FileMonikerImpl
*This
= impl_from_IMoniker(iface
);
73 TRACE("(%p,%s,%p)\n",This
,debugstr_guid(riid
),ppvObject
);
75 /* Perform a sanity check on the parameters.*/
79 /* Initialize the return parameter */
82 /* Compare the riid with the interface IDs implemented by this object.*/
83 if (IsEqualIID(&IID_IUnknown
, riid
) ||
84 IsEqualIID(&IID_IPersist
, riid
) ||
85 IsEqualIID(&IID_IPersistStream
,riid
) ||
86 IsEqualIID(&IID_IMoniker
, riid
)
90 else if (IsEqualIID(&IID_IROTData
, riid
))
91 *ppvObject
= &This
->IROTData_iface
;
92 else if (IsEqualIID(&IID_IMarshal
, riid
))
96 hr
= MonikerMarshal_Create(iface
, &This
->pMarshal
);
99 return IUnknown_QueryInterface(This
->pMarshal
, riid
, ppvObject
);
102 /* Check that we obtained an interface.*/
104 return E_NOINTERFACE
;
106 /* Query Interface always increases the reference count by one when it is successful */
107 IMoniker_AddRef(iface
);
112 /******************************************************************************
116 FileMonikerImpl_AddRef(IMoniker
* iface
)
118 FileMonikerImpl
*This
= impl_from_IMoniker(iface
);
120 TRACE("(%p)\n",iface
);
122 return InterlockedIncrement(&This
->ref
);
125 /******************************************************************************
126 * FileMoniker_Release
129 FileMonikerImpl_Release(IMoniker
* iface
)
131 FileMonikerImpl
*This
= impl_from_IMoniker(iface
);
134 TRACE("(%p)\n",iface
);
136 ref
= InterlockedDecrement(&This
->ref
);
138 /* destroy the object if there are no more references to it */
139 if (ref
== 0) FileMonikerImpl_Destroy(This
);
144 /******************************************************************************
145 * FileMoniker_GetClassID
147 static HRESULT WINAPI
148 FileMonikerImpl_GetClassID(IMoniker
* iface
, CLSID
*pClassID
)
150 TRACE("(%p,%p)\n",iface
,pClassID
);
155 *pClassID
= CLSID_FileMoniker
;
160 /******************************************************************************
161 * FileMoniker_IsDirty
163 * Note that the OLE-provided implementations of the IPersistStream::IsDirty
164 * method in the OLE-provided moniker interfaces always return S_FALSE because
165 * their internal state never changes.
167 static HRESULT WINAPI
168 FileMonikerImpl_IsDirty(IMoniker
* iface
)
171 TRACE("(%p)\n",iface
);
176 /******************************************************************************
179 * this function locates and reads from the stream the filePath string
180 * written by FileMonikerImpl_Save
182 static HRESULT WINAPI
183 FileMonikerImpl_Load(IMoniker
* iface
, IStream
* pStm
)
185 FileMonikerImpl
*This
= impl_from_IMoniker(iface
);
187 CHAR
* filePathA
= NULL
;
188 WCHAR
* filePathW
= NULL
;
191 DWORD dwbuffer
, bytesA
, bytesW
, len
;
195 TRACE("(%p,%p)\n",iface
,pStm
);
198 res
=IStream_Read(pStm
,&wbuffer
,sizeof(WORD
),&bread
);
199 if (bread
!=sizeof(WORD
))
201 WARN("Couldn't read 0 word\n");
205 /* read filePath string length (plus one) */
206 res
=IStream_Read(pStm
,&bytesA
,sizeof(DWORD
),&bread
);
207 if (bread
!= sizeof(DWORD
))
209 WARN("Couldn't read file string length\n");
213 /* read filePath string */
214 filePathA
=HeapAlloc(GetProcessHeap(),0,bytesA
);
221 res
=IStream_Read(pStm
,filePathA
,bytesA
,&bread
);
224 WARN("Couldn't read file path string\n");
228 /* read the unknown value */
229 IStream_Read(pStm
,&wbuffer
,sizeof(WORD
),&bread
);
230 if (bread
!= sizeof(WORD
))
232 WARN("Couldn't read unknown value\n");
236 /* read the DEAD constant */
237 IStream_Read(pStm
,&wbuffer
,sizeof(WORD
),&bread
);
238 if (bread
!= sizeof(WORD
))
240 WARN("Couldn't read DEAD constant\n");
246 res
=IStream_Read(pStm
,&dwbuffer
,sizeof(DWORD
),&bread
);
247 if (bread
!=sizeof(DWORD
))
249 WARN("Couldn't read 0 padding\n");
254 res
=IStream_Read(pStm
,&dwbuffer
,sizeof(DWORD
),&bread
);
255 if (bread
!=sizeof(DWORD
))
258 if (!dwbuffer
) /* No W-string */
261 len
=MultiByteToWideChar(CP_ACP
, MB_ERR_INVALID_CHARS
, filePathA
, bytesA
, NULL
, 0);
265 filePathW
=HeapAlloc(GetProcessHeap(),0,(len
+1)*sizeof(WCHAR
));
271 MultiByteToWideChar(CP_ACP
, MB_ERR_INVALID_CHARS
, filePathA
, -1, filePathW
, len
+1);
280 res
=IStream_Read(pStm
,&dwbuffer
,sizeof(DWORD
),&bread
);
281 if (bread
!=sizeof(DWORD
) || dwbuffer
!=bytesW
)
284 res
=IStream_Read(pStm
,&wbuffer
,sizeof(WORD
),&bread
);
285 if (bread
!=sizeof(WORD
) || wbuffer
!=0x3)
288 len
=bytesW
/sizeof(WCHAR
);
289 filePathW
=HeapAlloc(GetProcessHeap(),0,(len
+1)*sizeof(WCHAR
));
295 res
=IStream_Read(pStm
,filePathW
,bytesW
,&bread
);
302 HeapFree(GetProcessHeap(),0,filePathA
);
303 HeapFree(GetProcessHeap(),0,This
->filePathName
);
304 This
->filePathName
=filePathW
;
309 HeapFree(GetProcessHeap(), 0, filePathA
);
310 HeapFree(GetProcessHeap(), 0, filePathW
);
317 /******************************************************************************
320 * This function saves data of this object. In the beginning I thought
321 * that I have just to write the filePath string on Stream. But, when I
322 * tested this function with windows program samples, I noticed that it
323 * was not the case. This implementation is based on XP SP2. Other versions
324 * of Windows have minor variations.
326 * Data which must be written on stream is:
327 * 1) WORD constant: zero (not validated by Windows)
328 * 2) length of the path string ("\0" included)
329 * 3) path string type A
330 * 4) Unknown WORD value: Frequently 0xFFFF, but not always. If set very large,
331 * Windows returns E_OUTOFMEMORY
332 * 5) WORD Constant: 0xDEAD (not validated by Windows)
333 * 6) five DWORD constant: zero (not validated by Windows)
334 * 7) If we're only writing the multibyte version,
335 * write a zero DWORD and finish.
337 * 8) DWORD: double-length of the path string type W ("\0" not
339 * 9) WORD constant: 0x3
340 * 10) filePath unicode string.
343 static HRESULT WINAPI
344 FileMonikerImpl_Save(IMoniker
* iface
, IStream
* pStm
, BOOL fClearDirty
)
346 FileMonikerImpl
*This
= impl_from_IMoniker(iface
);
348 LPOLESTR filePathW
=This
->filePathName
;
350 DWORD bytesA
, bytesW
, len
;
352 static const WORD FFFF
= 0xFFFF; /* Constants */
353 static const WORD DEAD
= 0xDEAD;
354 static const DWORD ZERO
= 0;
355 static const WORD THREE
= 0x3;
358 BOOL bUsedDefault
, bWriteWide
;
360 TRACE("(%p,%p,%d)\n",iface
,pStm
,fClearDirty
);
366 res
=IStream_Write(pStm
,&ZERO
,sizeof(WORD
),NULL
);
367 if (FAILED(res
)) return res
;
369 /* write length of filePath string ( 0 included )*/
370 bytesA
= WideCharToMultiByte( CP_ACP
, 0, filePathW
, -1, NULL
, 0, NULL
, NULL
);
371 res
=IStream_Write(pStm
,&bytesA
,sizeof(DWORD
),NULL
);
372 if (FAILED(res
)) return res
;
374 /* write A string (with '\0') */
375 filePathA
=HeapAlloc(GetProcessHeap(),0,bytesA
);
377 return E_OUTOFMEMORY
;
378 WideCharToMultiByte( CP_ACP
, 0, filePathW
, -1, filePathA
, bytesA
, NULL
, &bUsedDefault
);
379 res
=IStream_Write(pStm
,filePathA
,bytesA
,NULL
);
380 HeapFree(GetProcessHeap(),0,filePathA
);
381 if (FAILED(res
)) return res
;
383 /* write a WORD 0xFFFF */
384 res
=IStream_Write(pStm
,&FFFF
,sizeof(WORD
),NULL
);
385 if (FAILED(res
)) return res
;
387 /* write a WORD 0xDEAD */
388 res
=IStream_Write(pStm
,&DEAD
,sizeof(WORD
),NULL
);
389 if (FAILED(res
)) return res
;
391 /* write 5 zero DWORDs */
394 res
=IStream_Write(pStm
,&ZERO
,sizeof(DWORD
),NULL
);
395 if (FAILED(res
)) return res
;
398 /* Write the wide version if:
399 * + couldn't convert to CP_ACP,
400 * or + it's a directory,
401 * or + there's a character > 0xFF
403 len
= lstrlenW(filePathW
);
404 bWriteWide
= (bUsedDefault
|| (len
> 0 && filePathW
[len
-1]=='\\' ));
408 for(pch
=filePathW
;*pch
;++pch
)
419 return IStream_Write(pStm
,&ZERO
,sizeof(DWORD
),NULL
);
421 /* write bytes needed for the filepathW (without 0) + 6 */
422 bytesW
= len
*sizeof(WCHAR
) + 6;
423 res
=IStream_Write(pStm
,&bytesW
,sizeof(DWORD
),NULL
);
424 if (FAILED(res
)) return res
;
426 /* try again, without the extra 6 */
428 res
=IStream_Write(pStm
,&bytesW
,sizeof(DWORD
),NULL
);
429 if (FAILED(res
)) return res
;
432 res
=IStream_Write(pStm
,&THREE
,sizeof(WORD
),NULL
);
433 if (FAILED(res
)) return res
;
435 /* write W string (no 0) */
436 return IStream_Write(pStm
,filePathW
,bytesW
,NULL
);
439 /******************************************************************************
440 * FileMoniker_GetSizeMax
442 static HRESULT WINAPI
443 FileMonikerImpl_GetSizeMax(IMoniker
* iface
, ULARGE_INTEGER
* pcbSize
)
445 FileMonikerImpl
*This
= impl_from_IMoniker(iface
);
447 TRACE("(%p,%p)\n",iface
,pcbSize
);
452 /* We could calculate exactly (see ...::Save()) but instead
453 * we'll make a quick over-estimate, like Windows (NT4, XP) does.
455 pcbSize
->u
.LowPart
= 0x38 + 4 * lstrlenW(This
->filePathName
);
456 pcbSize
->u
.HighPart
= 0;
461 /******************************************************************************
462 * FileMoniker_Destroy (local function)
463 *******************************************************************************/
464 HRESULT
FileMonikerImpl_Destroy(FileMonikerImpl
* This
)
466 TRACE("(%p)\n",This
);
468 if (This
->pMarshal
) IUnknown_Release(This
->pMarshal
);
469 HeapFree(GetProcessHeap(),0,This
->filePathName
);
470 HeapFree(GetProcessHeap(),0,This
);
475 /******************************************************************************
476 * FileMoniker_BindToObject
478 static HRESULT WINAPI
479 FileMonikerImpl_BindToObject(IMoniker
* iface
, IBindCtx
* pbc
, IMoniker
* pmkToLeft
,
480 REFIID riid
, VOID
** ppvResult
)
482 FileMonikerImpl
*This
= impl_from_IMoniker(iface
);
486 IRunningObjectTable
*prot
=0;
488 IClassFactory
*pcf
=0;
489 IClassActivator
*pca
=0;
493 TRACE("(%p,%p,%p,%s,%p)\n",iface
,pbc
,pmkToLeft
,debugstr_guid(riid
),ppvResult
);
497 res
=IBindCtx_GetRunningObjectTable(pbc
,&prot
);
500 /* if the requested class was loaded before ! we don't need to reload it */
501 res
= IRunningObjectTable_GetObject(prot
,iface
,&pObj
);
504 /* first activation of this class */
505 res
=GetClassFile(This
->filePathName
,&clsID
);
508 res
=CoCreateInstance(&clsID
,NULL
,CLSCTX_SERVER
,&IID_IPersistFile
,(void**)&ppf
);
511 res
=IPersistFile_Load(ppf
,This
->filePathName
,STGM_READ
);
515 IUnknown_AddRef(pObj
);
523 res
=IMoniker_BindToObject(pmkToLeft
,pbc
,NULL
,&IID_IClassFactory
,(void**)&pcf
);
525 if (res
==E_NOINTERFACE
){
527 res
=IMoniker_BindToObject(pmkToLeft
,pbc
,NULL
,&IID_IClassActivator
,(void**)&pca
);
529 if (res
==E_NOINTERFACE
)
530 return MK_E_INTERMEDIATEINTERFACENOTSUPPORTED
;
534 IClassFactory_CreateInstance(pcf
,NULL
,&IID_IPersistFile
,(void**)&ppf
);
536 res
=IPersistFile_Load(ppf
,This
->filePathName
,STGM_READ
);
541 IUnknown_AddRef(pObj
);
548 /*res=GetClassFile(This->filePathName,&clsID);
552 res=IClassActivator_GetClassObject(pca,&clsID,CLSCTX_ALL,0,&IID_IPersistFile,(void**)&ppf);
557 IUnknown_AddRef(pObj);
564 /* get the requested interface from the loaded class */
565 res
= IUnknown_QueryInterface(pObj
,riid
,ppvResult
);
567 IBindCtx_RegisterObjectBound(pbc
,*ppvResult
);
569 IUnknown_Release(pObj
);
573 IRunningObjectTable_Release(prot
);
576 IPersistFile_Release(ppf
);
579 IClassActivator_Release(pca
);
582 IClassFactory_Release(pcf
);
587 /******************************************************************************
588 * FileMoniker_BindToStorage
590 static HRESULT WINAPI
591 FileMonikerImpl_BindToStorage(IMoniker
* iface
, IBindCtx
* pbc
, IMoniker
* pmkToLeft
,
592 REFIID riid
, VOID
** ppvObject
)
598 TRACE("(%p,%p,%p,%s,%p)\n",iface
,pbc
,pmkToLeft
,debugstr_guid(riid
),ppvObject
);
600 if (pmkToLeft
==NULL
){
602 if (IsEqualIID(&IID_IStorage
, riid
)){
604 /* get the file name */
605 IMoniker_GetDisplayName(iface
,pbc
,pmkToLeft
,&filePath
);
607 res
=StgOpenStorage(filePath
,NULL
,STGM_READWRITE
|STGM_SHARE_DENY_WRITE
,NULL
,0,&pstg
);
612 CoTaskMemFree(filePath
);
615 if ( (IsEqualIID(&IID_IStream
, riid
)) || (IsEqualIID(&IID_ILockBytes
, riid
)) )
618 return E_NOINTERFACE
;
622 FIXME("(%p,%p,%p,%s,%p)\n",iface
,pbc
,pmkToLeft
,debugstr_guid(riid
),ppvObject
);
629 /******************************************************************************
631 ******************************************************************************/
632 static HRESULT WINAPI
633 FileMonikerImpl_Reduce(IMoniker
* iface
, IBindCtx
* pbc
, DWORD dwReduceHowFar
,
634 IMoniker
** ppmkToLeft
, IMoniker
** ppmkReduced
)
636 TRACE("(%p,%p,%d,%p,%p)\n",iface
,pbc
,dwReduceHowFar
,ppmkToLeft
,ppmkReduced
);
638 if (ppmkReduced
==NULL
)
641 IMoniker_AddRef(iface
);
645 return MK_S_REDUCED_TO_SELF
;
648 static void free_stringtable(LPOLESTR
*stringTable
)
652 for (i
=0; stringTable
[i
]!=NULL
; i
++)
653 CoTaskMemFree(stringTable
[i
]);
654 CoTaskMemFree(stringTable
);
657 /******************************************************************************
658 * FileMoniker_ComposeWith
660 static HRESULT WINAPI
661 FileMonikerImpl_ComposeWith(IMoniker
* iface
, IMoniker
* pmkRight
,
662 BOOL fOnlyIfNotGeneric
, IMoniker
** ppmkComposite
)
665 LPOLESTR str1
=0,str2
=0,*strDec1
=0,*strDec2
=0,newStr
=0;
666 static const WCHAR twoPoint
[]={'.','.',0};
667 static const WCHAR bkSlash
[]={'\\',0};
669 int i
=0,j
=0,lastIdx1
=0,lastIdx2
=0;
672 TRACE("(%p,%p,%d,%p)\n",iface
,pmkRight
,fOnlyIfNotGeneric
,ppmkComposite
);
674 if (ppmkComposite
==NULL
)
682 IMoniker_IsSystemMoniker(pmkRight
,&mkSys
);
684 /* check if we have two FileMonikers to compose or not */
685 if(mkSys
==MKSYS_FILEMONIKER
){
687 CreateBindCtx(0,&bind
);
689 IMoniker_GetDisplayName(iface
,bind
,NULL
,&str1
);
690 IMoniker_GetDisplayName(pmkRight
,bind
,NULL
,&str2
);
692 /* decompose pathnames of the two monikers : (to prepare the path merge operation ) */
693 lastIdx1
=FileMonikerImpl_DecomposePath(str1
,&strDec1
)-1;
694 lastIdx2
=FileMonikerImpl_DecomposePath(str2
,&strDec2
)-1;
696 if ((lastIdx1
==-1 && lastIdx2
>-1)||(lastIdx1
==1 && lstrcmpW(strDec1
[0],twoPoint
)==0))
699 if(lstrcmpW(strDec1
[lastIdx1
],bkSlash
)==0)
702 /* for each "..\" in the left of str2 remove the right element from str1 */
703 for(i
=0; ( (lastIdx1
>=0) && (strDec2
[i
]!=NULL
) && (lstrcmpW(strDec2
[i
],twoPoint
)==0) ); i
+=2){
708 /* the length of the composed path string is increased by the sum of the two paths' lengths */
709 newStr
=HeapAlloc(GetProcessHeap(),0,sizeof(WCHAR
)*(lstrlenW(str1
)+lstrlenW(str2
)+1));
712 /* new path is the concatenation of the rest of str1 and str2 */
713 for(*newStr
=0,j
=0;j
<=lastIdx1
;j
++)
714 strcatW(newStr
,strDec1
[j
]);
716 if ((strDec2
[i
]==NULL
&& lastIdx1
>-1 && lastIdx2
>-1) || lstrcmpW(strDec2
[i
],bkSlash
)!=0)
717 strcatW(newStr
,bkSlash
);
719 for(j
=i
;j
<=lastIdx2
;j
++)
720 strcatW(newStr
,strDec2
[j
]);
722 /* create a new moniker with the new string */
723 res
=CreateFileMoniker(newStr
,ppmkComposite
);
725 /* free string memory used by this function */
726 HeapFree(GetProcessHeap(),0,newStr
);
728 else res
= E_OUTOFMEMORY
;
731 free_stringtable(strDec1
);
732 free_stringtable(strDec2
);
739 else if(mkSys
==MKSYS_ANTIMONIKER
){
744 else if (fOnlyIfNotGeneric
){
747 return MK_E_NEEDGENERIC
;
751 return CreateGenericComposite(iface
,pmkRight
,ppmkComposite
);
754 /******************************************************************************
757 static HRESULT WINAPI
758 FileMonikerImpl_Enum(IMoniker
* iface
,BOOL fForward
, IEnumMoniker
** ppenumMoniker
)
760 TRACE("(%p,%d,%p)\n",iface
,fForward
,ppenumMoniker
);
762 if (ppenumMoniker
== NULL
)
765 *ppenumMoniker
= NULL
;
770 /******************************************************************************
771 * FileMoniker_IsEqual
773 static HRESULT WINAPI
774 FileMonikerImpl_IsEqual(IMoniker
* iface
,IMoniker
* pmkOtherMoniker
)
776 FileMonikerImpl
*This
= impl_from_IMoniker(iface
);
782 TRACE("(%p,%p)\n",iface
,pmkOtherMoniker
);
784 if (pmkOtherMoniker
==NULL
)
787 IMoniker_GetClassID(pmkOtherMoniker
,&clsid
);
789 if (!IsEqualCLSID(&clsid
,&CLSID_FileMoniker
))
792 res
= CreateBindCtx(0,&bind
);
793 if (FAILED(res
)) return res
;
796 if (SUCCEEDED(IMoniker_GetDisplayName(pmkOtherMoniker
,bind
,NULL
,&filePath
))) {
797 if (!lstrcmpiW(filePath
, This
->filePathName
))
799 CoTaskMemFree(filePath
);
802 IBindCtx_Release(bind
);
806 /******************************************************************************
809 static HRESULT WINAPI
810 FileMonikerImpl_Hash(IMoniker
* iface
,DWORD
* pdwHash
)
812 FileMonikerImpl
*This
= impl_from_IMoniker(iface
);
813 int h
= 0,i
,skip
,len
;
820 val
= This
->filePathName
;
824 for (i
= len
; i
> 0; i
--) {
825 h
= (h
* 37) + val
[off
++];
828 /* only sample some characters */
830 for (i
= len
; i
> 0; i
-= skip
, off
+= skip
) {
831 h
= (h
* 39) + val
[off
];
840 /******************************************************************************
841 * FileMoniker_IsRunning
843 static HRESULT WINAPI
844 FileMonikerImpl_IsRunning(IMoniker
* iface
, IBindCtx
* pbc
, IMoniker
* pmkToLeft
,
845 IMoniker
* pmkNewlyRunning
)
847 IRunningObjectTable
* rot
;
850 TRACE("(%p,%p,%p,%p)\n",iface
,pbc
,pmkToLeft
,pmkNewlyRunning
);
852 if ( (pmkNewlyRunning
!=NULL
) && (IMoniker_IsEqual(pmkNewlyRunning
,iface
)==S_OK
) )
858 res
=IBindCtx_GetRunningObjectTable(pbc
,&rot
);
863 res
= IRunningObjectTable_IsRunning(rot
,iface
);
865 IRunningObjectTable_Release(rot
);
870 /******************************************************************************
871 * FileMoniker_GetTimeOfLastChange
872 ******************************************************************************/
873 static HRESULT WINAPI
874 FileMonikerImpl_GetTimeOfLastChange(IMoniker
* iface
, IBindCtx
* pbc
,
875 IMoniker
* pmkToLeft
, FILETIME
* pFileTime
)
877 FileMonikerImpl
*This
= impl_from_IMoniker(iface
);
878 IRunningObjectTable
* rot
;
880 WIN32_FILE_ATTRIBUTE_DATA info
;
882 TRACE("(%p,%p,%p,%p)\n",iface
,pbc
,pmkToLeft
,pFileTime
);
890 res
=IBindCtx_GetRunningObjectTable(pbc
,&rot
);
895 res
= IRunningObjectTable_GetTimeOfLastChange(rot
,iface
,pFileTime
);
897 if (FAILED(res
)){ /* the moniker is not registered */
899 if (!GetFileAttributesExW(This
->filePathName
,GetFileExInfoStandard
,&info
))
900 return MK_E_NOOBJECT
;
902 *pFileTime
=info
.ftLastWriteTime
;
908 /******************************************************************************
909 * FileMoniker_Inverse
911 static HRESULT WINAPI
912 FileMonikerImpl_Inverse(IMoniker
* iface
,IMoniker
** ppmk
)
914 TRACE("(%p,%p)\n",iface
,ppmk
);
916 return CreateAntiMoniker(ppmk
);
919 /******************************************************************************
920 * FileMoniker_CommonPrefixWith
922 static HRESULT WINAPI
923 FileMonikerImpl_CommonPrefixWith(IMoniker
* iface
,IMoniker
* pmkOther
,IMoniker
** ppmkPrefix
)
926 LPOLESTR pathThis
= NULL
, pathOther
= NULL
, *stringTable1
= NULL
;
927 LPOLESTR
*stringTable2
= NULL
, commonPath
= NULL
;
930 ULONG nb1
,nb2
,i
,sameIdx
;
931 BOOL machineNameCase
= FALSE
;
934 if (ppmkPrefix
==NULL
)
942 /* check if we have the same type of moniker */
943 IMoniker_IsSystemMoniker(pmkOther
,&mkSys
);
944 if (mkSys
!= MKSYS_FILEMONIKER
)
945 return MonikerCommonPrefixWith(iface
, pmkOther
, ppmkPrefix
);
947 ret
= CreateBindCtx(0, &bindctx
);
951 /* create a string based on common part of the two paths */
952 ret
= IMoniker_GetDisplayName(iface
, bindctx
, NULL
, &pathThis
);
956 ret
= IMoniker_GetDisplayName(pmkOther
, bindctx
, NULL
, &pathOther
);
960 nb1
= FileMonikerImpl_DecomposePath(pathThis
, &stringTable1
);
966 nb2
= FileMonikerImpl_DecomposePath(pathOther
, &stringTable2
);
972 if (nb1
== 0 || nb2
== 0) {
977 commonPath
= CoTaskMemAlloc(sizeof(WCHAR
)*(min(lstrlenW(pathThis
),lstrlenW(pathOther
))+1));
984 for(sameIdx
=0; ( (stringTable1
[sameIdx
]!=NULL
) &&
985 (stringTable2
[sameIdx
]!=NULL
) &&
986 (lstrcmpiW(stringTable1
[sameIdx
],stringTable2
[sameIdx
])==0)); sameIdx
++);
988 if (sameIdx
> 1 && *stringTable1
[0]=='\\' && *stringTable2
[1]=='\\'){
989 machineNameCase
= TRUE
;
991 for(i
=2;i
<sameIdx
;i
++)
992 if( (*stringTable1
[i
]=='\\') && (i
+1 < sameIdx
) && (*stringTable1
[i
+1]=='\\') ){
993 machineNameCase
= FALSE
;
998 if (machineNameCase
&& *stringTable1
[sameIdx
-1]=='\\')
1001 if (machineNameCase
&& (sameIdx
<=3) && (nb1
> 3 || nb2
> 3) )
1002 ret
= MK_E_NOPREFIX
;
1005 for (i
= 0; i
< sameIdx
; i
++)
1006 strcatW(commonPath
,stringTable1
[i
]);
1007 ret
= CreateFileMoniker(commonPath
, ppmkPrefix
);
1011 IBindCtx_Release(bindctx
);
1012 CoTaskMemFree(pathThis
);
1013 CoTaskMemFree(pathOther
);
1014 CoTaskMemFree(commonPath
);
1015 if (stringTable1
) free_stringtable(stringTable1
);
1016 if (stringTable2
) free_stringtable(stringTable2
);
1021 /******************************************************************************
1022 * DecomposePath (local function)
1024 int FileMonikerImpl_DecomposePath(LPCOLESTR str
, LPOLESTR
** stringTable
)
1026 static const WCHAR bSlash
[] = {'\\',0};
1028 int i
=0,j
,tabIndex
=0, ret
=0;
1029 LPOLESTR
*strgtable
;
1031 int len
=lstrlenW(str
);
1033 TRACE("%s, %p\n", debugstr_w(str
), *stringTable
);
1035 strgtable
= CoTaskMemAlloc((len
+ 1)*sizeof(*strgtable
));
1037 if (strgtable
==NULL
)
1038 return E_OUTOFMEMORY
;
1040 word
= CoTaskMemAlloc((len
+ 1)*sizeof(WCHAR
));
1044 ret
= E_OUTOFMEMORY
;
1050 if(str
[i
]==bSlash
[0]){
1052 strgtable
[tabIndex
]=CoTaskMemAlloc(2*sizeof(WCHAR
));
1054 if (strgtable
[tabIndex
]==NULL
)
1056 ret
= E_OUTOFMEMORY
;
1060 strcpyW(strgtable
[tabIndex
++],bSlash
);
1067 for(j
=0; str
[i
]!=0 && str
[i
]!=bSlash
[0] ; i
++,j
++)
1072 strgtable
[tabIndex
]=CoTaskMemAlloc(sizeof(WCHAR
)*(j
+1));
1074 if (strgtable
[tabIndex
]==NULL
)
1076 ret
= E_OUTOFMEMORY
;
1080 strcpyW(strgtable
[tabIndex
++],word
);
1083 strgtable
[tabIndex
]=NULL
;
1085 *stringTable
=strgtable
;
1092 for (i
= 0; i
< tabIndex
; i
++)
1093 CoTaskMemFree(strgtable
[i
]);
1095 CoTaskMemFree(strgtable
);
1098 CoTaskMemFree(word
);
1103 /******************************************************************************
1104 * FileMoniker_RelativePathTo
1106 static HRESULT WINAPI
1107 FileMonikerImpl_RelativePathTo(IMoniker
* iface
,IMoniker
* pmOther
, IMoniker
** ppmkRelPath
)
1111 LPOLESTR str1
=0,str2
=0,*tabStr1
=0,*tabStr2
=0,relPath
=0;
1112 DWORD len1
=0,len2
=0,sameIdx
=0,j
=0;
1113 static const WCHAR back
[] ={'.','.','\\',0};
1115 TRACE("(%p,%p,%p)\n",iface
,pmOther
,ppmkRelPath
);
1117 if (ppmkRelPath
==NULL
)
1121 return E_INVALIDARG
;
1123 res
=CreateBindCtx(0,&bind
);
1127 res
=IMoniker_GetDisplayName(iface
,bind
,NULL
,&str1
);
1130 res
=IMoniker_GetDisplayName(pmOther
,bind
,NULL
,&str2
);
1134 len1
=FileMonikerImpl_DecomposePath(str1
,&tabStr1
);
1136 return E_OUTOFMEMORY
;
1137 len2
=FileMonikerImpl_DecomposePath(str2
,&tabStr2
);
1141 free_stringtable(tabStr1
);
1142 return E_OUTOFMEMORY
;
1145 /* count the number of similar items from the begin of the two paths */
1146 for(sameIdx
=0; ( (tabStr1
[sameIdx
]!=NULL
) &&
1147 (tabStr2
[sameIdx
]!=NULL
) &&
1148 (lstrcmpiW(tabStr1
[sameIdx
],tabStr2
[sameIdx
])==0)); sameIdx
++);
1150 /* begin the construction of relativePath */
1151 /* if the two paths have a consecutive similar item from the begin ! the relativePath will be composed */
1152 /* by "..\\" in the begin */
1153 relPath
=HeapAlloc(GetProcessHeap(),0,sizeof(WCHAR
)*(1+lstrlenW(str1
)+lstrlenW(str2
)));
1157 if (len2
>0 && !(len1
==1 && len2
==1 && sameIdx
==0))
1158 for(j
=sameIdx
;(tabStr1
[j
] != NULL
); j
++)
1159 if (*tabStr1
[j
]!='\\')
1160 strcatW(relPath
,back
);
1162 /* add items of the second path (similar items with the first path are not included) to the relativePath */
1163 for(j
=sameIdx
;tabStr2
[j
]!=NULL
;j
++)
1164 strcatW(relPath
,tabStr2
[j
]);
1166 res
=CreateFileMoniker(relPath
,ppmkRelPath
);
1168 free_stringtable(tabStr1
);
1169 free_stringtable(tabStr2
);
1170 CoTaskMemFree(str1
);
1171 CoTaskMemFree(str2
);
1172 HeapFree(GetProcessHeap(),0,relPath
);
1174 if (len1
==0 || len2
==0 || (len1
==1 && len2
==1 && sameIdx
==0))
1180 /******************************************************************************
1181 * FileMoniker_GetDisplayName
1183 static HRESULT WINAPI
1184 FileMonikerImpl_GetDisplayName(IMoniker
* iface
, IBindCtx
* pbc
,
1185 IMoniker
* pmkToLeft
, LPOLESTR
*ppszDisplayName
)
1187 FileMonikerImpl
*This
= impl_from_IMoniker(iface
);
1188 int len
=lstrlenW(This
->filePathName
);
1190 TRACE("(%p,%p,%p,%p)\n",iface
,pbc
,pmkToLeft
,ppszDisplayName
);
1192 if (ppszDisplayName
==NULL
)
1195 if (pmkToLeft
!=NULL
)
1196 return E_INVALIDARG
;
1198 *ppszDisplayName
=CoTaskMemAlloc(sizeof(WCHAR
)*(len
+1));
1199 if (*ppszDisplayName
==NULL
)
1200 return E_OUTOFMEMORY
;
1202 strcpyW(*ppszDisplayName
,This
->filePathName
);
1204 TRACE("-- %s\n", debugstr_w(*ppszDisplayName
));
1209 /******************************************************************************
1210 * FileMoniker_ParseDisplayName
1212 static HRESULT WINAPI
1213 FileMonikerImpl_ParseDisplayName(IMoniker
* iface
, IBindCtx
* pbc
, IMoniker
* pmkToLeft
,
1214 LPOLESTR pszDisplayName
, ULONG
* pchEaten
, IMoniker
** ppmkOut
)
1216 FIXME("(%p,%p,%p,%p,%p,%p),stub!\n",iface
,pbc
,pmkToLeft
,pszDisplayName
,pchEaten
,ppmkOut
);
1220 /******************************************************************************
1221 * FileMoniker_IsSystemMoniker
1223 static HRESULT WINAPI
1224 FileMonikerImpl_IsSystemMoniker(IMoniker
* iface
,DWORD
* pwdMksys
)
1226 TRACE("(%p,%p)\n",iface
,pwdMksys
);
1231 (*pwdMksys
)=MKSYS_FILEMONIKER
;
1236 /*******************************************************************************
1237 * FileMonikerIROTData_QueryInterface
1239 static HRESULT WINAPI
1240 FileMonikerROTDataImpl_QueryInterface(IROTData
*iface
,REFIID riid
,VOID
** ppvObject
)
1243 FileMonikerImpl
*This
= impl_from_IROTData(iface
);
1245 TRACE("(%p,%s,%p)\n",This
,debugstr_guid(riid
),ppvObject
);
1247 return FileMonikerImpl_QueryInterface(&This
->IMoniker_iface
, riid
, ppvObject
);
1250 /***********************************************************************
1251 * FileMonikerIROTData_AddRef
1254 FileMonikerROTDataImpl_AddRef(IROTData
*iface
)
1256 FileMonikerImpl
*This
= impl_from_IROTData(iface
);
1258 TRACE("(%p)\n",This
);
1260 return IMoniker_AddRef(&This
->IMoniker_iface
);
1263 /***********************************************************************
1264 * FileMonikerIROTData_Release
1267 FileMonikerROTDataImpl_Release(IROTData
* iface
)
1269 FileMonikerImpl
*This
= impl_from_IROTData(iface
);
1271 TRACE("(%p)\n",This
);
1273 return FileMonikerImpl_Release(&This
->IMoniker_iface
);
1276 /******************************************************************************
1277 * FileMonikerIROTData_GetComparisonData
1279 static HRESULT WINAPI
1280 FileMonikerROTDataImpl_GetComparisonData(IROTData
* iface
, BYTE
* pbData
,
1281 ULONG cbMax
, ULONG
* pcbData
)
1283 FileMonikerImpl
*This
= impl_from_IROTData(iface
);
1284 int len
= strlenW(This
->filePathName
)+1;
1288 TRACE("(%p, %u, %p)\n", pbData
, cbMax
, pcbData
);
1290 *pcbData
= sizeof(CLSID
) + len
* sizeof(WCHAR
);
1291 if (cbMax
< *pcbData
)
1292 return E_OUTOFMEMORY
;
1294 memcpy(pbData
, &CLSID_FileMoniker
, sizeof(CLSID
));
1295 pszFileName
= (LPWSTR
)(pbData
+sizeof(CLSID
));
1296 for (i
= 0; i
< len
; i
++)
1297 pszFileName
[i
] = toupperW(This
->filePathName
[i
]);
1303 * Virtual function table for the FileMonikerImpl class which include IPersist,
1304 * IPersistStream and IMoniker functions.
1306 static const IMonikerVtbl VT_FileMonikerImpl
=
1308 FileMonikerImpl_QueryInterface
,
1309 FileMonikerImpl_AddRef
,
1310 FileMonikerImpl_Release
,
1311 FileMonikerImpl_GetClassID
,
1312 FileMonikerImpl_IsDirty
,
1313 FileMonikerImpl_Load
,
1314 FileMonikerImpl_Save
,
1315 FileMonikerImpl_GetSizeMax
,
1316 FileMonikerImpl_BindToObject
,
1317 FileMonikerImpl_BindToStorage
,
1318 FileMonikerImpl_Reduce
,
1319 FileMonikerImpl_ComposeWith
,
1320 FileMonikerImpl_Enum
,
1321 FileMonikerImpl_IsEqual
,
1322 FileMonikerImpl_Hash
,
1323 FileMonikerImpl_IsRunning
,
1324 FileMonikerImpl_GetTimeOfLastChange
,
1325 FileMonikerImpl_Inverse
,
1326 FileMonikerImpl_CommonPrefixWith
,
1327 FileMonikerImpl_RelativePathTo
,
1328 FileMonikerImpl_GetDisplayName
,
1329 FileMonikerImpl_ParseDisplayName
,
1330 FileMonikerImpl_IsSystemMoniker
1333 /* Virtual function table for the IROTData class. */
1334 static const IROTDataVtbl VT_ROTDataImpl
=
1336 FileMonikerROTDataImpl_QueryInterface
,
1337 FileMonikerROTDataImpl_AddRef
,
1338 FileMonikerROTDataImpl_Release
,
1339 FileMonikerROTDataImpl_GetComparisonData
1342 /******************************************************************************
1343 * FileMoniker_Construct (local function)
1345 static HRESULT
FileMonikerImpl_Construct(FileMonikerImpl
* This
, LPCOLESTR lpszPathName
)
1348 int sizeStr
=lstrlenW(lpszPathName
);
1350 static const WCHAR twoPoint
[]={'.','.',0};
1351 static const WCHAR bkSlash
[]={'\\',0};
1354 TRACE("(%p,%s)\n",This
,debugstr_w(lpszPathName
));
1356 /* Initialize the virtual function table. */
1357 This
->IMoniker_iface
.lpVtbl
= &VT_FileMonikerImpl
;
1358 This
->IROTData_iface
.lpVtbl
= &VT_ROTDataImpl
;
1360 This
->pMarshal
= NULL
;
1362 This
->filePathName
=HeapAlloc(GetProcessHeap(),0,sizeof(WCHAR
)*(sizeStr
+1));
1364 if (This
->filePathName
==NULL
)
1365 return E_OUTOFMEMORY
;
1367 strcpyW(This
->filePathName
,lpszPathName
);
1369 nb
=FileMonikerImpl_DecomposePath(This
->filePathName
,&tabStr
);
1374 if (lstrcmpW(tabStr
[0],twoPoint
)!=0)
1379 if ( (lstrcmpW(tabStr
[i
],twoPoint
)!=0) && (lstrcmpW(tabStr
[i
],bkSlash
)!=0) ){
1385 if (lstrcmpW(tabStr
[i
],bkSlash
)==0 && i
<nb
-1 && lstrcmpW(tabStr
[i
+1],bkSlash
)==0){
1393 if (lstrcmpW(tabStr
[nb
-1],bkSlash
)==0)
1396 This
->filePathName
=HeapReAlloc(GetProcessHeap(),0,This
->filePathName
,(sizeStr
+1)*sizeof(WCHAR
));
1398 *This
->filePathName
=0;
1400 for(i
=0;tabStr
[i
]!=NULL
;i
++)
1401 strcatW(This
->filePathName
,tabStr
[i
]);
1404 strcatW(This
->filePathName
,bkSlash
);
1407 free_stringtable(tabStr
);
1412 /******************************************************************************
1413 * CreateFileMoniker (OLE32.@)
1414 ******************************************************************************/
1415 HRESULT WINAPI
CreateFileMoniker(LPCOLESTR lpszPathName
, IMoniker
**ppmk
)
1417 FileMonikerImpl
* newFileMoniker
;
1420 TRACE("(%s,%p)\n",debugstr_w(lpszPathName
),ppmk
);
1430 newFileMoniker
= HeapAlloc(GetProcessHeap(), 0, sizeof(FileMonikerImpl
));
1432 if (!newFileMoniker
)
1433 return E_OUTOFMEMORY
;
1435 hr
= FileMonikerImpl_Construct(newFileMoniker
,lpszPathName
);
1438 hr
= IMoniker_QueryInterface(&newFileMoniker
->IMoniker_iface
,&IID_IMoniker
,(void**)ppmk
);
1440 HeapFree(GetProcessHeap(),0,newFileMoniker
);
1445 /* find a character from a set in reverse without the string having to be null-terminated */
1446 static inline WCHAR
*memrpbrkW(const WCHAR
*ptr
, size_t n
, const WCHAR
*accept
)
1448 const WCHAR
*end
, *ret
= NULL
;
1449 for (end
= ptr
+ n
; ptr
< end
; ptr
++) if (strchrW(accept
, *ptr
)) ret
= ptr
;
1450 return (WCHAR
*)ret
;
1453 HRESULT
FileMoniker_CreateFromDisplayName(LPBC pbc
, LPCOLESTR szDisplayName
,
1454 LPDWORD pchEaten
, IMoniker
**ppmk
)
1457 static const WCHAR wszSeparators
[] = {':','\\','/','!',0};
1459 for (end
= szDisplayName
+ strlenW(szDisplayName
);
1460 end
&& (end
!= szDisplayName
);
1461 end
= memrpbrkW(szDisplayName
, end
- szDisplayName
, wszSeparators
))
1464 IRunningObjectTable
*rot
;
1465 IMoniker
*file_moniker
;
1466 LPWSTR file_display_name
;
1467 LPWSTR full_path_name
;
1468 DWORD full_path_name_len
;
1469 int len
= end
- szDisplayName
;
1471 file_display_name
= HeapAlloc(GetProcessHeap(), 0, (len
+ 1) * sizeof(WCHAR
));
1472 if (!file_display_name
) return E_OUTOFMEMORY
;
1473 memcpy(file_display_name
, szDisplayName
, len
* sizeof(WCHAR
));
1474 file_display_name
[len
] = '\0';
1476 hr
= CreateFileMoniker(file_display_name
, &file_moniker
);
1479 HeapFree(GetProcessHeap(), 0, file_display_name
);
1483 hr
= IBindCtx_GetRunningObjectTable(pbc
, &rot
);
1486 HeapFree(GetProcessHeap(), 0, file_display_name
);
1487 IMoniker_Release(file_moniker
);
1491 hr
= IRunningObjectTable_IsRunning(rot
, file_moniker
);
1492 IRunningObjectTable_Release(rot
);
1495 HeapFree(GetProcessHeap(), 0, file_display_name
);
1496 IMoniker_Release(file_moniker
);
1501 TRACE("found running file moniker for %s\n", debugstr_w(file_display_name
));
1503 *ppmk
= file_moniker
;
1504 HeapFree(GetProcessHeap(), 0, file_display_name
);
1508 full_path_name_len
= GetFullPathNameW(file_display_name
, 0, NULL
, NULL
);
1509 if (!full_path_name_len
)
1511 HeapFree(GetProcessHeap(), 0, file_display_name
);
1512 IMoniker_Release(file_moniker
);
1515 full_path_name
= HeapAlloc(GetProcessHeap(), 0, full_path_name_len
* sizeof(WCHAR
));
1516 if (!full_path_name
)
1518 HeapFree(GetProcessHeap(), 0, file_display_name
);
1519 IMoniker_Release(file_moniker
);
1520 return E_OUTOFMEMORY
;
1522 GetFullPathNameW(file_display_name
, full_path_name_len
, full_path_name
, NULL
);
1524 if (GetFileAttributesW(full_path_name
) == INVALID_FILE_ATTRIBUTES
)
1525 TRACE("couldn't open file %s\n", debugstr_w(full_path_name
));
1528 TRACE("got file moniker for %s\n", debugstr_w(szDisplayName
));
1530 *ppmk
= file_moniker
;
1531 HeapFree(GetProcessHeap(), 0, file_display_name
);
1532 HeapFree(GetProcessHeap(), 0, full_path_name
);
1535 HeapFree(GetProcessHeap(), 0, file_display_name
);
1536 HeapFree(GetProcessHeap(), 0, full_path_name
);
1537 IMoniker_Release(file_moniker
);
1540 return MK_E_CANTOPENFILE
;
1544 HRESULT WINAPI
FileMoniker_CreateInstance(IClassFactory
*iface
, IUnknown
*pUnk
, REFIID riid
, void **ppv
)
1546 FileMonikerImpl
* newFileMoniker
;
1548 static const WCHAR wszEmpty
[] = { 0 };
1550 TRACE("(%p, %s, %p)\n", pUnk
, debugstr_guid(riid
), ppv
);
1555 return CLASS_E_NOAGGREGATION
;
1557 newFileMoniker
= HeapAlloc(GetProcessHeap(), 0, sizeof(FileMonikerImpl
));
1558 if (!newFileMoniker
)
1559 return E_OUTOFMEMORY
;
1561 hr
= FileMonikerImpl_Construct(newFileMoniker
, wszEmpty
);
1564 hr
= IMoniker_QueryInterface(&newFileMoniker
->IMoniker_iface
, riid
, ppv
);
1566 HeapFree(GetProcessHeap(),0,newFileMoniker
);