1 /*
2 * FileMonikers implementation
3 *
4 * Copyright 1999 Noomen Hamza
5 * Copyright 2007 Robert Shearman
6 *
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.
11 *
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.
16 *
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
20 */
21
22 #include <assert.h>
23 #include <stdarg.h>
24 #include <string.h>
25
26 #define COBJMACROS
27 #define NONAMELESSUNION
28 #define NONAMELESSSTRUCT
29
30 #include "windef.h"
31 #include "winbase.h"
32 #include "winerror.h"
33 #include "winnls.h"
34 #include "wine/unicode.h"
35 #include "wine/debug.h"
36 #include "objbase.h"
37 #include "moniker.h"
38
39 #include "compobj_private.h"
40
41 WINE_DEFAULT_DEBUG_CHANNEL(ole);
42
43 /* filemoniker data structure */
44 typedef struct FileMonikerImpl{
45 IMoniker IMoniker_iface;
46 IROTData IROTData_iface;
47 LONG ref;
48 LPOLESTR filePathName; /* path string identified by this filemoniker */
49 IUnknown *pMarshal; /* custom marshaler */
50 } FileMonikerImpl;
51
52 static inline FileMonikerImpl *impl_from_IMoniker(IMoniker *iface)
53 {
54 return CONTAINING_RECORD(iface, FileMonikerImpl, IMoniker_iface);
55 }
56
57 static inline FileMonikerImpl *impl_from_IROTData(IROTData *iface)
58 {
59 return CONTAINING_RECORD(iface, FileMonikerImpl, IROTData_iface);
60 }
61
62 /* Local function used by filemoniker implementation */
63 static HRESULT FileMonikerImpl_Construct(FileMonikerImpl* iface, LPCOLESTR lpszPathName);
64 static HRESULT FileMonikerImpl_Destroy(FileMonikerImpl* iface);
65
66 /*******************************************************************************
67 * FileMoniker_QueryInterface
68 */
69 static HRESULT WINAPI
70 FileMonikerImpl_QueryInterface(IMoniker* iface,REFIID riid,void** ppvObject)
71 {
72 FileMonikerImpl *This = impl_from_IMoniker(iface);
73
74 TRACE("(%p,%s,%p)\n",This,debugstr_guid(riid),ppvObject);
75
76 /* Perform a sanity check on the parameters.*/
77 if ( ppvObject==0 )
78 return E_INVALIDARG;
79
80 /* Initialize the return parameter */
81 *ppvObject = 0;
82
83 /* Compare the riid with the interface IDs implemented by this object.*/
84 if (IsEqualIID(&IID_IUnknown, riid) ||
85 IsEqualIID(&IID_IPersist, riid) ||
86 IsEqualIID(&IID_IPersistStream,riid) ||
87 IsEqualIID(&IID_IMoniker, riid)
88 )
89 *ppvObject = iface;
90
91 else if (IsEqualIID(&IID_IROTData, riid))
92 *ppvObject = &This->IROTData_iface;
93 else if (IsEqualIID(&IID_IMarshal, riid))
94 {
95 HRESULT hr = S_OK;
96 if (!This->pMarshal)
97 hr = MonikerMarshal_Create(iface, &This->pMarshal);
98 if (hr != S_OK)
99 return hr;
100 return IUnknown_QueryInterface(This->pMarshal, riid, ppvObject);
101 }
102
103 /* Check that we obtained an interface.*/
104 if ((*ppvObject)==0)
105 return E_NOINTERFACE;
106
107 /* Query Interface always increases the reference count by one when it is successful */
108 IMoniker_AddRef(iface);
109
110 return S_OK;
111 }
112
113 /******************************************************************************
114 * FileMoniker_AddRef
115 */
116 static ULONG WINAPI
117 FileMonikerImpl_AddRef(IMoniker* iface)
118 {
119 FileMonikerImpl *This = impl_from_IMoniker(iface);
120
121 TRACE("(%p)\n",iface);
122
123 return InterlockedIncrement(&This->ref);
124 }
125
126 /******************************************************************************
127 * FileMoniker_Release
128 */
129 static ULONG WINAPI
130 FileMonikerImpl_Release(IMoniker* iface)
131 {
132 FileMonikerImpl *This = impl_from_IMoniker(iface);
133 ULONG ref;
134
135 TRACE("(%p)\n",iface);
136
137 ref = InterlockedDecrement(&This->ref);
138
139 /* destroy the object if there's no more reference on it */
140 if (ref == 0) FileMonikerImpl_Destroy(This);
141
142 return ref;
143 }
144
145 /******************************************************************************
146 * FileMoniker_GetClassID
147 */
148 static HRESULT WINAPI
149 FileMonikerImpl_GetClassID(IMoniker* iface, CLSID *pClassID)
150 {
151 TRACE("(%p,%p)\n",iface,pClassID);
152
153 if (pClassID==NULL)
154 return E_POINTER;
155
156 *pClassID = CLSID_FileMoniker;
157
158 return S_OK;
159 }
160
161 /******************************************************************************
162 * FileMoniker_IsDirty
163 *
164 * Note that the OLE-provided implementations of the IPersistStream::IsDirty
165 * method in the OLE-provided moniker interfaces always return S_FALSE because
166 * their internal state never changes.
167 */
168 static HRESULT WINAPI
169 FileMonikerImpl_IsDirty(IMoniker* iface)
170 {
171
172 TRACE("(%p)\n",iface);
173
174 return S_FALSE;
175 }
176
177 /******************************************************************************
178 * FileMoniker_Load
179 *
180 * this function locates and reads from the stream the filePath string
181 * written by FileMonikerImpl_Save
182 */
183 static HRESULT WINAPI
184 FileMonikerImpl_Load(IMoniker* iface, IStream* pStm)
185 {
186 FileMonikerImpl *This = impl_from_IMoniker(iface);
187 HRESULT res;
188 CHAR* filePathA = NULL;
189 WCHAR* filePathW = NULL;
190 ULONG bread;
191 WORD wbuffer;
192 DWORD dwbuffer, bytesA, bytesW, len;
193 int i;
194
195
196 TRACE("(%p,%p)\n",iface,pStm);
197
198 /* first WORD */
199 res=IStream_Read(pStm,&wbuffer,sizeof(WORD),&bread);
200 if (bread!=sizeof(WORD))
201 {
202 WARN("Couldn't read 0 word\n");
203 goto fail;
204 }
205
206 /* read filePath string length (plus one) */
207 res=IStream_Read(pStm,&bytesA,sizeof(DWORD),&bread);
208 if (bread != sizeof(DWORD))
209 {
210 WARN("Couldn't read file string length\n");
211 goto fail;
212 }
213
214 /* read filePath string */
215 filePathA=HeapAlloc(GetProcessHeap(),0,bytesA);
216 if (!filePathA)
217 {
218 res = E_OUTOFMEMORY;
219 goto fail;
220 }
221
222 res=IStream_Read(pStm,filePathA,bytesA,&bread);
223 if (bread != bytesA)
224 {
225 WARN("Couldn't read file path string\n");
226 goto fail;
227 }
228
229 /* read the unknown value */
230 IStream_Read(pStm,&wbuffer,sizeof(WORD),&bread);
231 if (bread != sizeof(WORD))
232 {
233 WARN("Couldn't read unknown value\n");
234 goto fail;
235 }
236
237 /* read the DEAD constant */
238 IStream_Read(pStm,&wbuffer,sizeof(WORD),&bread);
239 if (bread != sizeof(WORD))
240 {
241 WARN("Couldn't read DEAD constant\n");
242 goto fail;
243 }
244
245 for(i=0;i<5;i++)
246 {
247 res=IStream_Read(pStm,&dwbuffer,sizeof(DWORD),&bread);
248 if (bread!=sizeof(DWORD))
249 {
250 WARN("Couldn't read 0 padding\n");
251 goto fail;
252 }
253 }
254
255 res=IStream_Read(pStm,&dwbuffer,sizeof(DWORD),&bread);
256 if (bread!=sizeof(DWORD))
257 goto fail;
258
259 if (!dwbuffer) /* No W-string */
260 {
261 bytesA--;
262 len=MultiByteToWideChar(CP_ACP, MB_ERR_INVALID_CHARS, filePathA, bytesA, NULL, 0);
263 if (!len)
264 goto fail;
265
266 filePathW=HeapAlloc(GetProcessHeap(),0,(len+1)*sizeof(WCHAR));
267 if (!filePathW)
268 {
269 res = E_OUTOFMEMORY;
270 goto fail;
271 }
272 MultiByteToWideChar(CP_ACP, MB_ERR_INVALID_CHARS, filePathA, -1, filePathW, len+1);
273 goto succeed;
274 }
275
276 if (dwbuffer < 6)
277 goto fail;
278
279 bytesW=dwbuffer - 6;
280
281 res=IStream_Read(pStm,&dwbuffer,sizeof(DWORD),&bread);
282 if (bread!=sizeof(DWORD) || dwbuffer!=bytesW)
283 goto fail;
284
285 res=IStream_Read(pStm,&wbuffer,sizeof(WORD),&bread);
286 if (bread!=sizeof(WORD) || wbuffer!=0x3)
287 goto fail;
288
289 len=bytesW/sizeof(WCHAR);
290 filePathW=HeapAlloc(GetProcessHeap(),0,(len+1)*sizeof(WCHAR));
291 if(!filePathW)
292 {
293 res = E_OUTOFMEMORY;
294 goto fail;
295 }
296 res=IStream_Read(pStm,filePathW,bytesW,&bread);
297 if (bread!=bytesW)
298 goto fail;
299
300 filePathW[len]=0;
301
302 succeed:
303 HeapFree(GetProcessHeap(),0,filePathA);
304 HeapFree(GetProcessHeap(),0,This->filePathName);
305 This->filePathName=filePathW;
306
307 return S_OK;
308
309 fail:
310 HeapFree(GetProcessHeap(), 0, filePathA);
311 HeapFree(GetProcessHeap(), 0, filePathW);
312
313 if (SUCCEEDED(res))
314 res = E_FAIL;
315 return res;
316 }
317
318 /******************************************************************************
319 * FileMoniker_Save
320 *
321 * This function saves data of this object. In the beginning I thought
322 * that I have just to write the filePath string on Stream. But, when I
323 * tested this function with windows program samples, I noticed that it
324 * was not the case. This implementation is based on XP SP2. Other versions
325 * of Windows have minor variations.
326 *
327 * Data which must be written on stream is:
328 * 1) WORD constant: zero (not validated by Windows)
329 * 2) length of the path string ("\0" included)
330 * 3) path string type A
331 * 4) Unknown WORD value: Frequently 0xFFFF, but not always. If set very large,
332 * Windows returns E_OUTOFMEMORY
333 * 5) WORD Constant: 0xDEAD (not validated by Windows)
334 * 6) five DWORD constant: zero (not validated by Windows)
335 * 7) If we're only writing the multibyte version,
336 * write a zero DWORD and finish.
337 *
338 * 8) DWORD: double-length of the path string type W ("\0" not
339 * included)
340 * 9) WORD constant: 0x3
341 * 10) filePath unicode string.
342 *
343 */
344 static HRESULT WINAPI
345 FileMonikerImpl_Save(IMoniker* iface, IStream* pStm, BOOL fClearDirty)
346 {
347 FileMonikerImpl *This = impl_from_IMoniker(iface);
348 HRESULT res;
349 LPOLESTR filePathW=This->filePathName;
350 CHAR* filePathA;
351 DWORD bytesA, bytesW, len;
352
353 static const WORD FFFF = 0xFFFF; /* Constants */
354 static const WORD DEAD = 0xDEAD;
355 static const DWORD ZERO = 0;
356 static const WORD THREE = 0x3;
357
358 int i;
359 BOOL bUsedDefault, bWriteWide;
360
361 TRACE("(%p,%p,%d)\n",iface,pStm,fClearDirty);
362
363 if (pStm==NULL)
364 return E_POINTER;
365
366 /* write a 0 WORD */
367 res=IStream_Write(pStm,&ZERO,sizeof(WORD),NULL);
368 if (FAILED(res)) return res;
369
370 /* write length of filePath string ( 0 included )*/
371 bytesA = WideCharToMultiByte( CP_ACP, 0, filePathW, -1, NULL, 0, NULL, NULL );
372 res=IStream_Write(pStm,&bytesA,sizeof(DWORD),NULL);
373 if (FAILED(res)) return res;
374
375 /* write A string (with '\0') */
376 filePathA=HeapAlloc(GetProcessHeap(),0,bytesA);
377 if (!filePathA)
378 return E_OUTOFMEMORY;
379 WideCharToMultiByte( CP_ACP, 0, filePathW, -1, filePathA, bytesA, NULL, &bUsedDefault);
380 res=IStream_Write(pStm,filePathA,bytesA,NULL);
381 HeapFree(GetProcessHeap(),0,filePathA);
382 if (FAILED(res)) return res;
383
384 /* write a WORD 0xFFFF */
385 res=IStream_Write(pStm,&FFFF,sizeof(WORD),NULL);
386 if (FAILED(res)) return res;
387
388 /* write a WORD 0xDEAD */
389 res=IStream_Write(pStm,&DEAD,sizeof(WORD),NULL);
390 if (FAILED(res)) return res;
391
392 /* write 5 zero DWORDs */
393 for(i=0;i<5;i++)
394 {
395 res=IStream_Write(pStm,&ZERO,sizeof(DWORD),NULL);
396 if (FAILED(res)) return res;
397 }
398
399 /* Write the wide version if:
400 * + couldn't convert to CP_ACP,
401 * or + it's a directory,
402 * or + there's a character > 0xFF
403 */
404 len = lstrlenW(filePathW);
405 bWriteWide = (bUsedDefault || (len > 0 && filePathW[len-1]=='\\' ));
406 if (!bWriteWide)
407 {
408 WCHAR* pch;
409 for(pch=filePathW;*pch;++pch)
410 {
411 if (*pch > 0xFF)
412 {
413 bWriteWide = TRUE;
414 break;
415 }
416 }
417 }
418
419 if (!bWriteWide)
420 return IStream_Write(pStm,&ZERO,sizeof(DWORD),NULL);
421
422 /* write bytes needed for the filepathW (without 0) + 6 */
423 bytesW = len*sizeof(WCHAR) + 6;
424 res=IStream_Write(pStm,&bytesW,sizeof(DWORD),NULL);
425 if (FAILED(res)) return res;
426
427 /* try again, without the extra 6 */
428 bytesW -= 6;
429 res=IStream_Write(pStm,&bytesW,sizeof(DWORD),NULL);
430 if (FAILED(res)) return res;
431
432 /* write a WORD 3 */
433 res=IStream_Write(pStm,&THREE,sizeof(WORD),NULL);
434 if (FAILED(res)) return res;
435
436 /* write W string (no 0) */
437 return IStream_Write(pStm,filePathW,bytesW,NULL);
438 }
439
440 /******************************************************************************
441 * FileMoniker_GetSizeMax
442 */
443 static HRESULT WINAPI
444 FileMonikerImpl_GetSizeMax(IMoniker* iface, ULARGE_INTEGER* pcbSize)
445 {
446 FileMonikerImpl *This = impl_from_IMoniker(iface);
447
448 TRACE("(%p,%p)\n",iface,pcbSize);
449
450 if (!pcbSize)
451 return E_POINTER;
452
453 /* We could calculate exactly (see ...::Save()) but instead
454 * we'll make a quick over-estimate, like Windows (NT4, XP) does.
455 */
456 pcbSize->u.LowPart = 0x38 + 4 * lstrlenW(This->filePathName);
457 pcbSize->u.HighPart = 0;
458
459 return S_OK;
460 }
461
462 /******************************************************************************
463 * FileMoniker_Destroy (local function)
464 *******************************************************************************/
465 HRESULT FileMonikerImpl_Destroy(FileMonikerImpl* This)
466 {
467 TRACE("(%p)\n",This);
468
469 if (This->pMarshal) IUnknown_Release(This->pMarshal);
470 HeapFree(GetProcessHeap(),0,This->filePathName);
471 HeapFree(GetProcessHeap(),0,This);
472
473 return S_OK;
474 }
475
476 /******************************************************************************
477 * FileMoniker_BindToObject
478 */
479 static HRESULT WINAPI
480 FileMonikerImpl_BindToObject(IMoniker* iface, IBindCtx* pbc, IMoniker* pmkToLeft,
481 REFIID riid, VOID** ppvResult)
482 {
483 FileMonikerImpl *This = impl_from_IMoniker(iface);
484 HRESULT res=E_FAIL;
485 CLSID clsID;
486 IUnknown* pObj=0;
487 IRunningObjectTable *prot=0;
488 IPersistFile *ppf=0;
489 IClassFactory *pcf=0;
490 IClassActivator *pca=0;
491
492 *ppvResult=0;
493
494 TRACE("(%p,%p,%p,%s,%p)\n",iface,pbc,pmkToLeft,debugstr_guid(riid),ppvResult);
495
496 if(pmkToLeft==NULL){
497
498 res=IBindCtx_GetRunningObjectTable(pbc,&prot);
499
500 if (SUCCEEDED(res)){
501 /* if the requested class was loaded before ! we don't need to reload it */
502 res = IRunningObjectTable_GetObject(prot,iface,&pObj);
503
504 if (res==S_FALSE){
505 /* first activation of this class */
506 res=GetClassFile(This->filePathName,&clsID);
507 if (SUCCEEDED(res)){
508
509 res=CoCreateInstance(&clsID,NULL,CLSCTX_ALL,&IID_IPersistFile,(void**)&ppf);
510 if (SUCCEEDED(res)){
511
512 res=IPersistFile_Load(ppf,This->filePathName,STGM_READ);
513 if (SUCCEEDED(res)){
514
515 pObj=(IUnknown*)ppf;
516 IUnknown_AddRef(pObj);
517 }
518 }
519 }
520 }
521 }
522 }
523 else{
524 res=IMoniker_BindToObject(pmkToLeft,pbc,NULL,&IID_IClassFactory,(void**)&pcf);
525
526 if (res==E_NOINTERFACE){
527
528 res=IMoniker_BindToObject(pmkToLeft,pbc,NULL,&IID_IClassActivator,(void**)&pca);
529
530 if (res==E_NOINTERFACE)
531 return MK_E_INTERMEDIATEINTERFACENOTSUPPORTED;
532 }
533 if (pcf!=NULL){
534
535 IClassFactory_CreateInstance(pcf,NULL,&IID_IPersistFile,(void**)&ppf);
536
537 res=IPersistFile_Load(ppf,This->filePathName,STGM_READ);
538
539 if (SUCCEEDED(res)){
540
541 pObj=(IUnknown*)ppf;
542 IUnknown_AddRef(pObj);
543 }
544 }
545 if (pca!=NULL){
546
547 FIXME("()\n");
548
549 /*res=GetClassFile(This->filePathName,&clsID);
550
551 if (SUCCEEDED(res)){
552
553 res=IClassActivator_GetClassObject(pca,&clsID,CLSCTX_ALL,0,&IID_IPersistFile,(void**)&ppf);
554
555 if (SUCCEEDED(res)){
556
557 pObj=(IUnknown*)ppf;
558 IUnknown_AddRef(pObj);
559 }
560 }*/
561 }
562 }
563
564 if (pObj!=NULL){
565 /* get the requested interface from the loaded class */
566 res= IUnknown_QueryInterface(pObj,riid,ppvResult);
567
568 IBindCtx_RegisterObjectBound(pbc,*ppvResult);
569
570 IUnknown_Release(pObj);
571 }
572
573 if (prot!=NULL)
574 IRunningObjectTable_Release(prot);
575
576 if (ppf!=NULL)
577 IPersistFile_Release(ppf);
578
579 if (pca!=NULL)
580 IClassActivator_Release(pca);
581
582 if (pcf!=NULL)
583 IClassFactory_Release(pcf);
584
585 return res;
586 }
587
588 /******************************************************************************
589 * FileMoniker_BindToStorage
590 */
591 static HRESULT WINAPI
592 FileMonikerImpl_BindToStorage(IMoniker* iface, IBindCtx* pbc, IMoniker* pmkToLeft,
593 REFIID riid, VOID** ppvObject)
594 {
595 LPOLESTR filePath=0;
596 IStorage *pstg=0;
597 HRESULT res;
598
599 TRACE("(%p,%p,%p,%s,%p)\n",iface,pbc,pmkToLeft,debugstr_guid(riid),ppvObject);
600
601 if (pmkToLeft==NULL){
602
603 if (IsEqualIID(&IID_IStorage, riid)){
604
605 /* get the file name */
606 IMoniker_GetDisplayName(iface,pbc,pmkToLeft,&filePath);
607
608 /* verify if the file contains a storage object */
609 res=StgIsStorageFile(filePath);
610
611 if(res==S_OK){
612
613 res=StgOpenStorage(filePath,NULL,STGM_READWRITE|STGM_SHARE_DENY_WRITE,NULL,0,&pstg);
614
615 if (SUCCEEDED(res)){
616
617 *ppvObject=pstg;
618
619 IStorage_AddRef(pstg);
620
621 return res;
622 }
623 }
624 CoTaskMemFree(filePath);
625 }
626 else
627 if ( (IsEqualIID(&IID_IStream, riid)) || (IsEqualIID(&IID_ILockBytes, riid)) )
628 return E_FAIL;
629 else
630 return E_NOINTERFACE;
631 }
632 else {
633
634 FIXME("(%p,%p,%p,%s,%p)\n",iface,pbc,pmkToLeft,debugstr_guid(riid),ppvObject);
635
636 return E_NOTIMPL;
637 }
638 return res;
639 }
640
641 /******************************************************************************
642 * FileMoniker_Reduce
643 ******************************************************************************/
644 static HRESULT WINAPI
645 FileMonikerImpl_Reduce(IMoniker* iface, IBindCtx* pbc, DWORD dwReduceHowFar,
646 IMoniker** ppmkToLeft, IMoniker** ppmkReduced)
647 {
648 TRACE("(%p,%p,%d,%p,%p)\n",iface,pbc,dwReduceHowFar,ppmkToLeft,ppmkReduced);
649
650 if (ppmkReduced==NULL)
651 return E_POINTER;
652
653 IMoniker_AddRef(iface);
654
655 *ppmkReduced=iface;
656
657 return MK_S_REDUCED_TO_SELF;
658 }
659
660 /******************************************************************************
661 * FileMoniker_ComposeWith
662 */
663 static HRESULT WINAPI
664 FileMonikerImpl_ComposeWith(IMoniker* iface, IMoniker* pmkRight,
665 BOOL fOnlyIfNotGeneric, IMoniker** ppmkComposite)
666 {
667 HRESULT res;
668 LPOLESTR str1=0,str2=0,*strDec1=0,*strDec2=0,newStr=0;
669 static const WCHAR twoPoint[]={'.','.',0};
670 static const WCHAR bkSlash[]={'\\',0};
671 IBindCtx *bind=0;
672 int i=0,j=0,lastIdx1=0,lastIdx2=0;
673 DWORD mkSys;
674
675 TRACE("(%p,%p,%d,%p)\n",iface,pmkRight,fOnlyIfNotGeneric,ppmkComposite);
676
677 if (ppmkComposite==NULL)
678 return E_POINTER;
679
680 if (pmkRight==NULL)
681 return E_INVALIDARG;
682
683 *ppmkComposite=0;
684
685 IMoniker_IsSystemMoniker(pmkRight,&mkSys);
686
687 /* check if we have two FileMonikers to compose or not */
688 if(mkSys==MKSYS_FILEMONIKER){
689
690 CreateBindCtx(0,&bind);
691
692 IMoniker_GetDisplayName(iface,bind,NULL,&str1);
693 IMoniker_GetDisplayName(pmkRight,bind,NULL,&str2);
694
695 /* decompose pathnames of the two monikers : (to prepare the path merge operation ) */
696 lastIdx1=FileMonikerImpl_DecomposePath(str1,&strDec1)-1;
697 lastIdx2=FileMonikerImpl_DecomposePath(str2,&strDec2)-1;
698
699 if ((lastIdx1==-1 && lastIdx2>-1)||(lastIdx1==1 && lstrcmpW(strDec1[0],twoPoint)==0))
700 return MK_E_SYNTAX;
701
702 if(lstrcmpW(strDec1[lastIdx1],bkSlash)==0)
703 lastIdx1--;
704
705 /* for etch "..\" in the left of str2 remove the right element from str1 */
706 for(i=0; ( (lastIdx1>=0) && (strDec2[i]!=NULL) && (lstrcmpW(strDec2[i],twoPoint)==0) ) ;i+=2){
707
708 lastIdx1-=2;
709 }
710
711 /* the length of the composed path string is raised by the sum of the two paths lengths */
712 newStr=HeapAlloc(GetProcessHeap(),0,sizeof(WCHAR)*(lstrlenW(str1)+lstrlenW(str2)+1));
713
714 if (newStr==NULL)
715 return E_OUTOFMEMORY;
716
717 /* new path is the concatenation of the rest of str1 and str2 */
718 for(*newStr=0,j=0;j<=lastIdx1;j++)
719 strcatW(newStr,strDec1[j]);
720
721 if ((strDec2[i]==NULL && lastIdx1>-1 && lastIdx2>-1) || lstrcmpW(strDec2[i],bkSlash)!=0)
722 strcatW(newStr,bkSlash);
723
724 for(j=i;j<=lastIdx2;j++)
725 strcatW(newStr,strDec2[j]);
726
727 /* create a new moniker with the new string */
728 res=CreateFileMoniker(newStr,ppmkComposite);
729
730 /* free all strings space memory used by this function */
731 HeapFree(GetProcessHeap(),0,newStr);
732
733 for(i=0; strDec1[i]!=NULL;i++)
734 CoTaskMemFree(strDec1[i]);
735 for(i=0; strDec2[i]!=NULL;i++)
736 CoTaskMemFree(strDec2[i]);
737 CoTaskMemFree(strDec1);
738 CoTaskMemFree(strDec2);
739
740 CoTaskMemFree(str1);
741 CoTaskMemFree(str2);
742
743 return res;
744 }
745 else if(mkSys==MKSYS_ANTIMONIKER){
746
747 *ppmkComposite=NULL;
748 return S_OK;
749 }
750 else if (fOnlyIfNotGeneric){
751
752 *ppmkComposite=NULL;
753 return MK_E_NEEDGENERIC;
754 }
755 else
756
757 return CreateGenericComposite(iface,pmkRight,ppmkComposite);
758 }
759
760 /******************************************************************************
761 * FileMoniker_Enum
762 */
763 static HRESULT WINAPI
764 FileMonikerImpl_Enum(IMoniker* iface,BOOL fForward, IEnumMoniker** ppenumMoniker)
765 {
766 TRACE("(%p,%d,%p)\n",iface,fForward,ppenumMoniker);
767
768 if (ppenumMoniker == NULL)
769 return E_POINTER;
770
771 *ppenumMoniker = NULL;
772
773 return S_OK;
774 }
775
776 /******************************************************************************
777 * FileMoniker_IsEqual
778 */
779 static HRESULT WINAPI
780 FileMonikerImpl_IsEqual(IMoniker* iface,IMoniker* pmkOtherMoniker)
781 {
782 FileMonikerImpl *This = impl_from_IMoniker(iface);
783 CLSID clsid;
784 LPOLESTR filePath;
785 IBindCtx* bind;
786 HRESULT res;
787
788 TRACE("(%p,%p)\n",iface,pmkOtherMoniker);
789
790 if (pmkOtherMoniker==NULL)
791 return S_FALSE;
792
793 IMoniker_GetClassID(pmkOtherMoniker,&clsid);
794
795 if (!IsEqualCLSID(&clsid,&CLSID_FileMoniker))
796 return S_FALSE;
797
798 res = CreateBindCtx(0,&bind);
799 if (FAILED(res)) return res;
800
801 res = S_FALSE;
802 if (SUCCEEDED(IMoniker_GetDisplayName(pmkOtherMoniker,bind,NULL,&filePath))) {
803 if (!lstrcmpiW(filePath, This->filePathName))
804 res = S_OK;
805 CoTaskMemFree(filePath);
806 }
807
808 IBindCtx_Release(bind);
809 return res;
810 }
811
812 /******************************************************************************
813 * FileMoniker_Hash
814 */
815 static HRESULT WINAPI
816 FileMonikerImpl_Hash(IMoniker* iface,DWORD* pdwHash)
817 {
818 FileMonikerImpl *This = impl_from_IMoniker(iface);
819 int h = 0,i,skip,len;
820 int off = 0;
821 LPOLESTR val;
822
823 if (pdwHash==NULL)
824 return E_POINTER;
825
826 val = This->filePathName;
827 len = lstrlenW(val);
828
829 if (len < 16) {
830 for (i = len ; i > 0; i--) {
831 h = (h * 37) + val[off++];
832 }
833 } else {
834 /* only sample some characters */
835 skip = len / 8;
836 for (i = len ; i > 0; i -= skip, off += skip) {
837 h = (h * 39) + val[off];
838 }
839 }
840
841 *pdwHash=h;
842
843 return S_OK;
844 }
845
846 /******************************************************************************
847 * FileMoniker_IsRunning
848 */
849 static HRESULT WINAPI
850 FileMonikerImpl_IsRunning(IMoniker* iface, IBindCtx* pbc, IMoniker* pmkToLeft,
851 IMoniker* pmkNewlyRunning)
852 {
853 IRunningObjectTable* rot;
854 HRESULT res;
855
856 TRACE("(%p,%p,%p,%p)\n",iface,pbc,pmkToLeft,pmkNewlyRunning);
857
858 if ( (pmkNewlyRunning!=NULL) && (IMoniker_IsEqual(pmkNewlyRunning,iface)==S_OK) )
859 return S_OK;
860
861 if (pbc==NULL)
862 return E_POINTER;
863
864 res=IBindCtx_GetRunningObjectTable(pbc,&rot);
865
866 if (FAILED(res))
867 return res;
868
869 res = IRunningObjectTable_IsRunning(rot,iface);
870
871 IRunningObjectTable_Release(rot);
872
873 return res;
874 }
875
876 /******************************************************************************
877 * FileMoniker_GetTimeOfLastChange
878 ******************************************************************************/
879 static HRESULT WINAPI
880 FileMonikerImpl_GetTimeOfLastChange(IMoniker* iface, IBindCtx* pbc,
881 IMoniker* pmkToLeft, FILETIME* pFileTime)
882 {
883 FileMonikerImpl *This = impl_from_IMoniker(iface);
884 IRunningObjectTable* rot;
885 HRESULT res;
886 WIN32_FILE_ATTRIBUTE_DATA info;
887
888 TRACE("(%p,%p,%p,%p)\n",iface,pbc,pmkToLeft,pFileTime);
889
890 if (pFileTime==NULL)
891 return E_POINTER;
892
893 if (pmkToLeft!=NULL)
894 return E_INVALIDARG;
895
896 res=IBindCtx_GetRunningObjectTable(pbc,&rot);
897
898 if (FAILED(res))
899 return res;
900
901 res= IRunningObjectTable_GetTimeOfLastChange(rot,iface,pFileTime);
902
903 if (FAILED(res)){ /* the moniker is not registered */
904
905 if (!GetFileAttributesExW(This->filePathName,GetFileExInfoStandard,&info))
906 return MK_E_NOOBJECT;
907
908 *pFileTime=info.ftLastWriteTime;
909 }
910
911 return S_OK;
912 }
913
914 /******************************************************************************
915 * FileMoniker_Inverse
916 */
917 static HRESULT WINAPI
918 FileMonikerImpl_Inverse(IMoniker* iface,IMoniker** ppmk)
919 {
920 TRACE("(%p,%p)\n",iface,ppmk);
921
922 return CreateAntiMoniker(ppmk);
923 }
924
925 /******************************************************************************
926 * FileMoniker_CommonPrefixWith
927 */
928 static HRESULT WINAPI
929 FileMonikerImpl_CommonPrefixWith(IMoniker* iface,IMoniker* pmkOther,IMoniker** ppmkPrefix)
930 {
931
932 LPOLESTR pathThis,pathOther,*stringTable1,*stringTable2,commonPath;
933 IBindCtx *pbind;
934 DWORD mkSys;
935 ULONG nb1,nb2,i,sameIdx;
936 BOOL machimeNameCase=FALSE;
937
938 if (ppmkPrefix==NULL)
939 return E_POINTER;
940
941 if (pmkOther==NULL)
942 return E_INVALIDARG;
943
944 *ppmkPrefix=0;
945
946 /* check if we have the same type of moniker */
947 IMoniker_IsSystemMoniker(pmkOther,&mkSys);
948
949 if(mkSys==MKSYS_FILEMONIKER){
950 HRESULT ret;
951
952 ret = CreateBindCtx(0,&pbind);
953 if (FAILED(ret))
954 return ret;
955
956 /* create a string based on common part of the two paths */
957
958 ret = IMoniker_GetDisplayName(iface,pbind,NULL,&pathThis);
959 if (FAILED(ret))
960 return ret;
961 ret = IMoniker_GetDisplayName(pmkOther,pbind,NULL,&pathOther);
962 if (FAILED(ret))
963 return ret;
964
965 nb1=FileMonikerImpl_DecomposePath(pathThis,&stringTable1);
966 if (FAILED(nb1))
967 return nb1;
968 nb2=FileMonikerImpl_DecomposePath(pathOther,&stringTable2);
969 if (FAILED(nb2))
970 return nb2;
971
972 if (nb1==0 || nb2==0)
973 return MK_E_NOPREFIX;
974
975 commonPath=HeapAlloc(GetProcessHeap(),0,sizeof(WCHAR)*(min(lstrlenW(pathThis),lstrlenW(pathOther))+1));
976 if (!commonPath)
977 return E_OUTOFMEMORY;
978
979 *commonPath=0;
980
981 for(sameIdx=0; ( (stringTable1[sameIdx]!=NULL) &&
982 (stringTable2[sameIdx]!=NULL) &&
983 (lstrcmpiW(stringTable1[sameIdx],stringTable2[sameIdx])==0)); sameIdx++);
984
985 if (sameIdx > 1 && *stringTable1[0]=='\\' && *stringTable2[1]=='\\'){
986
987 machimeNameCase=TRUE;
988
989 for(i=2;i<sameIdx;i++)
990
991 if( (*stringTable1[i]=='\\') && (i+1 < sameIdx) && (*stringTable1[i+1]=='\\') ){
992 machimeNameCase=FALSE;
993 break;
994 }
995 }
996
997 if (machimeNameCase && *stringTable1[sameIdx-1]=='\\')
998 sameIdx--;
999
1000 if (machimeNameCase && (sameIdx<=3) && (nb1 > 3 || nb2 > 3) )
1001 ret = MK_E_NOPREFIX;
1002 else
1003 {
1004 for(i=0;i<sameIdx;i++)
1005 strcatW(commonPath,stringTable1[i]);
1006
1007 for(i=0;i<nb1;i++)
1008 CoTaskMemFree(stringTable1[i]);
1009
1010 CoTaskMemFree(stringTable1);
1011
1012 for(i=0;i<nb2;i++)
1013 CoTaskMemFree(stringTable2[i]);
1014
1015 CoTaskMemFree(stringTable2);
1016
1017 ret = CreateFileMoniker(commonPath,ppmkPrefix);
1018 }
1019 HeapFree(GetProcessHeap(),0,commonPath);
1020 return ret;
1021 }
1022 else
1023 return MonikerCommonPrefixWith(iface,pmkOther,ppmkPrefix);
1024 }
1025
1026 /******************************************************************************
1027 * DecomposePath (local function)
1028 */
1029 int FileMonikerImpl_DecomposePath(LPCOLESTR str, LPOLESTR** stringTable)
1030 {
1031 static const WCHAR bSlash[] = {'\\',0};
1032 LPOLESTR word;
1033 int i=0,j,tabIndex=0, ret=0;
1034 LPOLESTR *strgtable ;
1035
1036 int len=lstrlenW(str);
1037
1038 TRACE("%s, %p\n", debugstr_w(str), *stringTable);
1039
1040 strgtable = CoTaskMemAlloc((len + 1)*sizeof(*strgtable));
1041
1042 if (strgtable==NULL)
1043 return E_OUTOFMEMORY;
1044
1045 word = CoTaskMemAlloc((len + 1)*sizeof(WCHAR));
1046
1047 if (word==NULL)
1048 {
1049 ret = E_OUTOFMEMORY;
1050 goto lend;
1051 }
1052
1053 while(str[i]!=0){
1054
1055 if(str[i]==bSlash[0]){
1056
1057 strgtable[tabIndex]=CoTaskMemAlloc(2*sizeof(WCHAR));
1058
1059 if (strgtable[tabIndex]==NULL)
1060 {
1061 ret = E_OUTOFMEMORY;
1062 goto lend;
1063 }
1064
1065 strcpyW(strgtable[tabIndex++],bSlash);
1066
1067 i++;
1068
1069 }
1070 else {
1071
1072 for(j=0; str[i]!=0 && str[i]!=bSlash[0] ; i++,j++)
1073 word[j]=str[i];
1074
1075 word[j]=0;
1076
1077 strgtable[tabIndex]=CoTaskMemAlloc(sizeof(WCHAR)*(j+1));
1078
1079 if (strgtable[tabIndex]==NULL)
1080 {
1081 ret = E_OUTOFMEMORY;
1082 goto lend;
1083 }
1084
1085 strcpyW(strgtable[tabIndex++],word);
1086 }
1087 }
1088 strgtable[tabIndex]=NULL;
1089
1090 *stringTable=strgtable;
1091
1092 ret = tabIndex;
1093
1094 lend:
1095 if (ret < 0)
1096 {
1097 for (i = 0; i < tabIndex; i++)
1098 CoTaskMemFree(strgtable[i]);
1099
1100 CoTaskMemFree(strgtable);
1101 }
1102
1103 if (word)
1104 CoTaskMemFree(word);
1105
1106 return ret;
1107 }
1108
1109 /******************************************************************************
1110 * FileMoniker_RelativePathTo
1111 */
1112 static HRESULT WINAPI
1113 FileMonikerImpl_RelativePathTo(IMoniker* iface,IMoniker* pmOther, IMoniker** ppmkRelPath)
1114 {
1115 IBindCtx *bind;
1116 HRESULT res;
1117 LPOLESTR str1=0,str2=0,*tabStr1=0,*tabStr2=0,relPath=0;
1118 DWORD len1=0,len2=0,sameIdx=0,j=0;
1119 static const WCHAR back[] ={'.','.','\\',0};
1120
1121 TRACE("(%p,%p,%p)\n",iface,pmOther,ppmkRelPath);
1122
1123 if (ppmkRelPath==NULL)
1124 return E_POINTER;
1125
1126 if (pmOther==NULL)
1127 return E_INVALIDARG;
1128
1129 res=CreateBindCtx(0,&bind);
1130 if (FAILED(res))
1131 return res;
1132
1133 res=IMoniker_GetDisplayName(iface,bind,NULL,&str1);
1134 if (FAILED(res))
1135 return res;
1136 res=IMoniker_GetDisplayName(pmOther,bind,NULL,&str2);
1137 if (FAILED(res))
1138 return res;
1139
1140 len1=FileMonikerImpl_DecomposePath(str1,&tabStr1);
1141 len2=FileMonikerImpl_DecomposePath(str2,&tabStr2);
1142
1143 if (FAILED(len1) || FAILED(len2))
1144 return E_OUTOFMEMORY;
1145
1146 /* count the number of similar items from the begin of the two paths */
1147 for(sameIdx=0; ( (tabStr1[sameIdx]!=NULL) &&
1148 (tabStr2[sameIdx]!=NULL) &&
1149 (lstrcmpiW(tabStr1[sameIdx],tabStr2[sameIdx])==0)); sameIdx++);
1150
1151 /* begin the construction of relativePath */
1152 /* if the two paths have a consecutive similar item from the begin ! the relativePath will be composed */
1153 /* by "..\\" in the begin */
1154 relPath=HeapAlloc(GetProcessHeap(),0,sizeof(WCHAR)*(1+lstrlenW(str1)+lstrlenW(str2)));
1155
1156 *relPath=0;
1157
1158 if (len2>0 && !(len1==1 && len2==1 && sameIdx==0))
1159 for(j=sameIdx;(tabStr1[j] != NULL); j++)
1160 if (*tabStr1[j]!='\\')
1161 strcatW(relPath,back);
1162
1163 /* add items of the second path (similar items with the first path are not included) to the relativePath */
1164 for(j=sameIdx;tabStr2[j]!=NULL;j++)
1165 strcatW(relPath,tabStr2[j]);
1166
1167 res=CreateFileMoniker(relPath,ppmkRelPath);
1168
1169 for(j=0; tabStr1[j]!=NULL;j++)
1170 CoTaskMemFree(tabStr1[j]);
1171 for(j=0; tabStr2[j]!=NULL;j++)
1172 CoTaskMemFree(tabStr2[j]);
1173 CoTaskMemFree(tabStr1);
1174 CoTaskMemFree(tabStr2);
1175 CoTaskMemFree(str1);
1176 CoTaskMemFree(str2);
1177 HeapFree(GetProcessHeap(),0,relPath);
1178
1179 if (len1==0 || len2==0 || (len1==1 && len2==1 && sameIdx==0))
1180 return MK_S_HIM;
1181
1182 return res;
1183 }
1184
1185 /******************************************************************************
1186 * FileMoniker_GetDisplayName
1187 */
1188 static HRESULT WINAPI
1189 FileMonikerImpl_GetDisplayName(IMoniker* iface, IBindCtx* pbc,
1190 IMoniker* pmkToLeft, LPOLESTR *ppszDisplayName)
1191 {
1192 FileMonikerImpl *This = impl_from_IMoniker(iface);
1193 int len=lstrlenW(This->filePathName);
1194
1195 TRACE("(%p,%p,%p,%p)\n",iface,pbc,pmkToLeft,ppszDisplayName);
1196
1197 if (ppszDisplayName==NULL)
1198 return E_POINTER;
1199
1200 if (pmkToLeft!=NULL)
1201 return E_INVALIDARG;
1202
1203 *ppszDisplayName=CoTaskMemAlloc(sizeof(WCHAR)*(len+1));
1204 if (*ppszDisplayName==NULL)
1205 return E_OUTOFMEMORY;
1206
1207 strcpyW(*ppszDisplayName,This->filePathName);
1208
1209 TRACE("-- %s\n", debugstr_w(*ppszDisplayName));
1210
1211 return S_OK;
1212 }
1213
1214 /******************************************************************************
1215 * FileMoniker_ParseDisplayName
1216 */
1217 static HRESULT WINAPI
1218 FileMonikerImpl_ParseDisplayName(IMoniker* iface, IBindCtx* pbc, IMoniker* pmkToLeft,
1219 LPOLESTR pszDisplayName, ULONG* pchEaten, IMoniker** ppmkOut)
1220 {
1221 FIXME("(%p,%p,%p,%p,%p,%p),stub!\n",iface,pbc,pmkToLeft,pszDisplayName,pchEaten,ppmkOut);
1222 return E_NOTIMPL;
1223 }
1224
1225 /******************************************************************************
1226 * FileMoniker_IsSystemMoniker
1227 */
1228 static HRESULT WINAPI
1229 FileMonikerImpl_IsSystemMoniker(IMoniker* iface,DWORD* pwdMksys)
1230 {
1231 TRACE("(%p,%p)\n",iface,pwdMksys);
1232
1233 if (!pwdMksys)
1234 return E_POINTER;
1235
1236 (*pwdMksys)=MKSYS_FILEMONIKER;
1237
1238 return S_OK;
1239 }
1240
1241 /*******************************************************************************
1242 * FileMonikerIROTData_QueryInterface
1243 */
1244 static HRESULT WINAPI
1245 FileMonikerROTDataImpl_QueryInterface(IROTData *iface,REFIID riid,VOID** ppvObject)
1246 {
1247
1248 FileMonikerImpl *This = impl_from_IROTData(iface);
1249
1250 TRACE("(%p,%s,%p)\n",This,debugstr_guid(riid),ppvObject);
1251
1252 return FileMonikerImpl_QueryInterface(&This->IMoniker_iface, riid, ppvObject);
1253 }
1254
1255 /***********************************************************************
1256 * FileMonikerIROTData_AddRef
1257 */
1258 static ULONG WINAPI
1259 FileMonikerROTDataImpl_AddRef(IROTData *iface)
1260 {
1261 FileMonikerImpl *This = impl_from_IROTData(iface);
1262
1263 TRACE("(%p)\n",This);
1264
1265 return IMoniker_AddRef(&This->IMoniker_iface);
1266 }
1267
1268 /***********************************************************************
1269 * FileMonikerIROTData_Release
1270 */
1271 static ULONG WINAPI
1272 FileMonikerROTDataImpl_Release(IROTData* iface)
1273 {
1274 FileMonikerImpl *This = impl_from_IROTData(iface);
1275
1276 TRACE("(%p)\n",This);
1277
1278 return FileMonikerImpl_Release(&This->IMoniker_iface);
1279 }
1280
1281 /******************************************************************************
1282 * FileMonikerIROTData_GetComparisonData
1283 */
1284 static HRESULT WINAPI
1285 FileMonikerROTDataImpl_GetComparisonData(IROTData* iface, BYTE* pbData,
1286 ULONG cbMax, ULONG* pcbData)
1287 {
1288 FileMonikerImpl *This = impl_from_IROTData(iface);
1289 int len = strlenW(This->filePathName)+1;
1290 int i;
1291 LPWSTR pszFileName;
1292
1293 TRACE("(%p, %u, %p)\n", pbData, cbMax, pcbData);
1294
1295 *pcbData = sizeof(CLSID) + len * sizeof(WCHAR);
1296 if (cbMax < *pcbData)
1297 return E_OUTOFMEMORY;
1298
1299 memcpy(pbData, &CLSID_FileMoniker, sizeof(CLSID));
1300 pszFileName = (LPWSTR)(pbData+sizeof(CLSID));
1301 for (i = 0; i < len; i++)
1302 pszFileName[i] = toupperW(This->filePathName[i]);
1303
1304 return S_OK;
1305 }
1306
1307 /*
1308 * Virtual function table for the FileMonikerImpl class which include IPersist,
1309 * IPersistStream and IMoniker functions.
1310 */
1311 static const IMonikerVtbl VT_FileMonikerImpl =
1312 {
1313 FileMonikerImpl_QueryInterface,
1314 FileMonikerImpl_AddRef,
1315 FileMonikerImpl_Release,
1316 FileMonikerImpl_GetClassID,
1317 FileMonikerImpl_IsDirty,
1318 FileMonikerImpl_Load,
1319 FileMonikerImpl_Save,
1320 FileMonikerImpl_GetSizeMax,
1321 FileMonikerImpl_BindToObject,
1322 FileMonikerImpl_BindToStorage,
1323 FileMonikerImpl_Reduce,
1324 FileMonikerImpl_ComposeWith,
1325 FileMonikerImpl_Enum,
1326 FileMonikerImpl_IsEqual,
1327 FileMonikerImpl_Hash,
1328 FileMonikerImpl_IsRunning,
1329 FileMonikerImpl_GetTimeOfLastChange,
1330 FileMonikerImpl_Inverse,
1331 FileMonikerImpl_CommonPrefixWith,
1332 FileMonikerImpl_RelativePathTo,
1333 FileMonikerImpl_GetDisplayName,
1334 FileMonikerImpl_ParseDisplayName,
1335 FileMonikerImpl_IsSystemMoniker
1336 };
1337
1338 /* Virtual function table for the IROTData class. */
1339 static const IROTDataVtbl VT_ROTDataImpl =
1340 {
1341 FileMonikerROTDataImpl_QueryInterface,
1342 FileMonikerROTDataImpl_AddRef,
1343 FileMonikerROTDataImpl_Release,
1344 FileMonikerROTDataImpl_GetComparisonData
1345 };
1346
1347 /******************************************************************************
1348 * FileMoniker_Construct (local function)
1349 */
1350 static HRESULT FileMonikerImpl_Construct(FileMonikerImpl* This, LPCOLESTR lpszPathName)
1351 {
1352 int nb=0,i;
1353 int sizeStr=lstrlenW(lpszPathName);
1354 LPOLESTR *tabStr=0;
1355 static const WCHAR twoPoint[]={'.','.',0};
1356 static const WCHAR bkSlash[]={'\\',0};
1357 BYTE addBkSlash;
1358
1359 TRACE("(%p,%s)\n",This,debugstr_w(lpszPathName));
1360
1361 /* Initialize the virtual function table. */
1362 This->IMoniker_iface.lpVtbl = &VT_FileMonikerImpl;
1363 This->IROTData_iface.lpVtbl = &VT_ROTDataImpl;
1364 This->ref = 0;
1365 This->pMarshal = NULL;
1366
1367 This->filePathName=HeapAlloc(GetProcessHeap(),0,sizeof(WCHAR)*(sizeStr+1));
1368
1369 if (This->filePathName==NULL)
1370 return E_OUTOFMEMORY;
1371
1372 strcpyW(This->filePathName,lpszPathName);
1373
1374 nb=FileMonikerImpl_DecomposePath(This->filePathName,&tabStr);
1375
1376 if (nb > 0 ){
1377
1378 addBkSlash=1;
1379 if (lstrcmpW(tabStr[0],twoPoint)!=0)
1380 addBkSlash=0;
1381 else
1382 for(i=0;i<nb;i++){
1383
1384 if ( (lstrcmpW(tabStr[i],twoPoint)!=0) && (lstrcmpW(tabStr[i],bkSlash)!=0) ){
1385 addBkSlash=0;
1386 break;
1387 }
1388 else
1389
1390 if (lstrcmpW(tabStr[i],bkSlash)==0 && i<nb-1 && lstrcmpW(tabStr[i+1],bkSlash)==0){
1391 *tabStr[i]=0;
1392 sizeStr--;
1393 addBkSlash=0;
1394 break;
1395 }
1396 }
1397
1398 if (lstrcmpW(tabStr[nb-1],bkSlash)==0)
1399 addBkSlash=0;
1400
1401 This->filePathName=HeapReAlloc(GetProcessHeap(),0,This->filePathName,(sizeStr+1)*sizeof(WCHAR));
1402
1403 *This->filePathName=0;
1404
1405 for(i=0;tabStr[i]!=NULL;i++)
1406 strcatW(This->filePathName,tabStr[i]);
1407
1408 if (addBkSlash)
1409 strcatW(This->filePathName,bkSlash);
1410 }
1411
1412 for(i=0; tabStr[i]!=NULL;i++)
1413 CoTaskMemFree(tabStr[i]);
1414 CoTaskMemFree(tabStr);
1415
1416 return S_OK;
1417 }
1418
1419 /******************************************************************************
1420 * CreateFileMoniker (OLE32.@)
1421 ******************************************************************************/
1422 HRESULT WINAPI CreateFileMoniker(LPCOLESTR lpszPathName, IMoniker **ppmk)
1423 {
1424 FileMonikerImpl* newFileMoniker;
1425 HRESULT hr;
1426
1427 TRACE("(%s,%p)\n",debugstr_w(lpszPathName),ppmk);
1428
1429 if (!ppmk)
1430 return E_POINTER;
1431
1432 if(!lpszPathName)
1433 return MK_E_SYNTAX;
1434
1435 *ppmk=NULL;
1436
1437 newFileMoniker = HeapAlloc(GetProcessHeap(), 0, sizeof(FileMonikerImpl));
1438
1439 if (!newFileMoniker)
1440 return E_OUTOFMEMORY;
1441
1442 hr = FileMonikerImpl_Construct(newFileMoniker,lpszPathName);
1443
1444 if (SUCCEEDED(hr))
1445 hr = IMoniker_QueryInterface(&newFileMoniker->IMoniker_iface,&IID_IMoniker,(void**)ppmk);
1446 else
1447 HeapFree(GetProcessHeap(),0,newFileMoniker);
1448
1449 return hr;
1450 }
1451
1452 /* find a character from a set in reverse without the string having to be null-terminated */
1453 static inline WCHAR *memrpbrkW(const WCHAR *ptr, size_t n, const WCHAR *accept)
1454 {
1455 const WCHAR *end, *ret = NULL;
1456 for (end = ptr + n; ptr < end; ptr++) if (strchrW(accept, *ptr)) ret = ptr;
1457 return (WCHAR *)ret;
1458 }
1459
1460 HRESULT FileMoniker_CreateFromDisplayName(LPBC pbc, LPCOLESTR szDisplayName,
1461 LPDWORD pchEaten, IMoniker **ppmk)
1462 {
1463 LPCWSTR end;
1464 static const WCHAR wszSeparators[] = {':','\\','/','!',0};
1465
1466 for (end = szDisplayName + strlenW(szDisplayName);
1467 end && (end != szDisplayName);
1468 end = memrpbrkW(szDisplayName, end - szDisplayName, wszSeparators))
1469 {
1470 HRESULT hr;
1471 IRunningObjectTable *rot;
1472 IMoniker *file_moniker;
1473 LPWSTR file_display_name;
1474 LPWSTR full_path_name;
1475 DWORD full_path_name_len;
1476 int len = end - szDisplayName;
1477
1478 file_display_name = HeapAlloc(GetProcessHeap(), 0, (len + 1) * sizeof(WCHAR));
1479 if (!file_display_name) return E_OUTOFMEMORY;
1480 memcpy(file_display_name, szDisplayName, len * sizeof(WCHAR));
1481 file_display_name[len] = '\0';
1482
1483 hr = CreateFileMoniker(file_display_name, &file_moniker);
1484 if (FAILED(hr))
1485 {
1486 HeapFree(GetProcessHeap(), 0, file_display_name);
1487 return hr;
1488 }
1489
1490 hr = IBindCtx_GetRunningObjectTable(pbc, &rot);
1491 if (FAILED(hr))
1492 {
1493 HeapFree(GetProcessHeap(), 0, file_display_name);
1494 IMoniker_Release(file_moniker);
1495 return hr;
1496 }
1497
1498 hr = IRunningObjectTable_IsRunning(rot, file_moniker);
1499 IRunningObjectTable_Release(rot);
1500 if (FAILED(hr))
1501 {
1502 HeapFree(GetProcessHeap(), 0, file_display_name);
1503 IMoniker_Release(file_moniker);
1504 return hr;
1505 }
1506 if (hr == S_OK)
1507 {
1508 TRACE("found running file moniker for %s\n", debugstr_w(file_display_name));
1509 *pchEaten = len;
1510 *ppmk = file_moniker;
1511 HeapFree(GetProcessHeap(), 0, file_display_name);
1512 return S_OK;
1513 }
1514
1515 full_path_name_len = GetFullPathNameW(file_display_name, 0, NULL, NULL);
1516 if (!full_path_name_len)
1517 {
1518 HeapFree(GetProcessHeap(), 0, file_display_name);
1519 IMoniker_Release(file_moniker);
1520 return MK_E_SYNTAX;
1521 }
1522 full_path_name = HeapAlloc(GetProcessHeap(), 0, full_path_name_len * sizeof(WCHAR));
1523 if (!full_path_name)
1524 {
1525 HeapFree(GetProcessHeap(), 0, file_display_name);
1526 IMoniker_Release(file_moniker);
1527 return E_OUTOFMEMORY;
1528 }
1529 GetFullPathNameW(file_display_name, full_path_name_len, full_path_name, NULL);
1530
1531 if (GetFileAttributesW(full_path_name) == INVALID_FILE_ATTRIBUTES)
1532 TRACE("couldn't open file %s\n", debugstr_w(full_path_name));
1533 else
1534 {
1535 TRACE("got file moniker for %s\n", debugstr_w(szDisplayName));
1536 *pchEaten = len;
1537 *ppmk = file_moniker;
1538 HeapFree(GetProcessHeap(), 0, file_display_name);
1539 HeapFree(GetProcessHeap(), 0, full_path_name);
1540 return S_OK;
1541 }
1542 HeapFree(GetProcessHeap(), 0, file_display_name);
1543 HeapFree(GetProcessHeap(), 0, full_path_name);
1544 IMoniker_Release(file_moniker);
1545 }
1546
1547 return MK_E_CANTOPENFILE;
1548 }
1549
1550
1551 static HRESULT WINAPI FileMonikerCF_QueryInterface(LPCLASSFACTORY iface,
1552 REFIID riid, LPVOID *ppv)
1553 {
1554 *ppv = NULL;
1555 if (IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IClassFactory))
1556 {
1557 *ppv = iface;
1558 IUnknown_AddRef(iface);
1559 return S_OK;
1560 }
1561 return E_NOINTERFACE;
1562 }
1563
1564 static ULONG WINAPI FileMonikerCF_AddRef(LPCLASSFACTORY iface)
1565 {
1566 return 2; /* non-heap based object */
1567 }
1568
1569 static ULONG WINAPI FileMonikerCF_Release(LPCLASSFACTORY iface)
1570 {
1571 return 1; /* non-heap based object */
1572 }
1573
1574 static HRESULT WINAPI FileMonikerCF_CreateInstance(LPCLASSFACTORY iface,
1575 LPUNKNOWN pUnk, REFIID riid, LPVOID *ppv)
1576 {
1577 FileMonikerImpl* newFileMoniker;
1578 HRESULT hr;
1579 static const WCHAR wszEmpty[] = { 0 };
1580
1581 TRACE("(%p, %s, %p)\n", pUnk, debugstr_guid(riid), ppv);
1582
1583 *ppv = NULL;
1584
1585 if (pUnk)
1586 return CLASS_E_NOAGGREGATION;
1587
1588 newFileMoniker = HeapAlloc(GetProcessHeap(), 0, sizeof(FileMonikerImpl));
1589 if (!newFileMoniker)
1590 return E_OUTOFMEMORY;
1591
1592 hr = FileMonikerImpl_Construct(newFileMoniker, wszEmpty);
1593
1594 if (SUCCEEDED(hr))
1595 hr = IMoniker_QueryInterface(&newFileMoniker->IMoniker_iface, riid, ppv);
1596 if (FAILED(hr))
1597 HeapFree(GetProcessHeap(),0,newFileMoniker);
1598
1599 return hr;
1600 }
1601
1602 static HRESULT WINAPI FileMonikerCF_LockServer(LPCLASSFACTORY iface, BOOL fLock)
1603 {
1604 FIXME("(%d), stub!\n",fLock);
1605 return S_OK;
1606 }
1607
1608 static const IClassFactoryVtbl FileMonikerCFVtbl =
1609 {
1610 FileMonikerCF_QueryInterface,
1611 FileMonikerCF_AddRef,
1612 FileMonikerCF_Release,
1613 FileMonikerCF_CreateInstance,
1614 FileMonikerCF_LockServer
1615 };
1616 static const IClassFactoryVtbl *FileMonikerCF = &FileMonikerCFVtbl;
1617
1618 HRESULT FileMonikerCF_Create(REFIID riid, LPVOID *ppv)
1619 {
1620 return IClassFactory_QueryInterface((IClassFactory *)&FileMonikerCF, riid, ppv);
1621 }
1622
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.