git.oblomov.eu Git - wine/blob - dlls/shell32/shfldr_unixfs.c

   1 /*
   2  * UNIXFS - Shell namespace extension for the unix filesystem
   3  *
   4  * Copyright (C) 2005 Michael Jung
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 /*
  22  * As you know, windows and unix do have a different philosophy with regard to
  23  * the question of how a filesystem should be laid out. While we unix geeks
  24  * learned to love the 'one-tree-rooted-at-/' approach, windows has in fact
  25  * a whole forest of filesystem trees, each of which is typically identified by
  26  * a drive letter.
  27  *
  28  * We would like wine to integrate as smoothly as possible (that is without
  29  * sacrificing win32 compatibility) into the unix environment. For the
  30  * filesystem question, this means we really would like those windows
  31  * applications to work with unix path- and file-names. Unfortunately, this
  32  * seems to be impossible in general. Therefore we have those symbolic links
  33  * in wine's 'dosdevices' directory, which are used to simulate drives
  34  * to keep windows applications happy. And as a consequence, we have those
  35  * drive letters show up now and then in GUI applications running under wine,
  36  * which gets the unix hardcore fans all angry, shouting at us @#!&$%* wine
  37  * hackers that we are seducing the big companies not to port their applications
  38  * to unix.
  39  *
  40  * DOS paths do appear at various places in GUI applications. Sometimes, they
  41  * show up in the title bar of an application's window. They tend to accumulate
  42  * in the most-recently-used section of the file-menu. And I've even seen some
  43  * in a configuration dialog's edit control. In those examples, wine can't do a
  44  * lot about this, since path-names can't be told apart from ordinary strings
  45  * here. That's different in the file dialogs, though.
  46  *
  47  * With the introduction of the 'shell' in win32, Microsoft established an
  48  * abstraction layer on top of the filesystem, called the shell namespace (I was
  49  * told that Gnome's virtual filesystem is conceptually similar). In the shell
  50  * namespace, one doesn't use ascii- or unicode-strings to uniquely identify
  51  * objects. Instead Microsoft introduced item-identifier-lists (The c type is
  52  * called ITEMIDLIST) as an abstraction of path-names. As you probably would
  53  * have guessed, an item-identifier-list is a list of item-identifiers (whose
  54  * c type's funny name is SHITEMID), which are opaque binary objects. This means
  55  * that no application (apart from Microsoft Office) should make any assumptions
  56  * on the internal structure of these SHITEMIDs.
  57  *
  58  * Since the user prefers to be presented the good-old DOS file-names instead of
  59  * binary ITEMIDLISTs, a translation method between string-based file-names and
  60  * ITEMIDLISTs was established. At the core of this are the COM-Interface
  61  * IShellFolder and especially it's methods ParseDisplayName and
  62  * GetDisplayNameOf. Basically, you give a DOS-path (let's say C:\windows) to
  63  * ParseDisplayName and get a SHITEMID similar to <Desktop|My Computer|C:|windows|>.
  64  * Since it's opaque, you can't see the 'C', the 'windows' and the other stuff.
  65  * You can only figure out that the ITEMIDLIST is composed of four SHITEMIDS.
  66  * The file dialog applies IShellFolder's BindToObject method to bind to each of
  67  * those four objects (Desktop, My Computer, C: and windows. All of them have to
  68  * implement the IShellFolder interface.) and asks them how they would like to be
  69  * displayed (basically their icon and the string displayed). If the file dialog
  70  * asks <Desktop|My Computer|C:|windows> which sub-objects it contains (via
  71  * EnumObjects) it gets a list of opaque SHITEMIDs, which can be concatenated to
  72  * <Desktop|...|windows> to build a new ITEMIDLIST and browse, for instance,
  73  * into <system32>. This means the file dialog browses the shell namespace by
  74  * identifying objects via ITEMIDLISTs. Once the user has selected a location to
  75  * save his valuable file, the file dialog calls IShellFolder's GetDisplayNameOf
  76  * method to translate the ITEMIDLIST back to a DOS filename.
  77  *
  78  * It seems that one intention of the shell namespace concept was to make it
  79  * possible to have objects in the namespace, which don't have any counterpart
  80  * in the filesystem. The 'My Computer' shell folder object is one instance
  81  * which comes to mind (Go try to save a file into 'My Computer' on windows.)
  82  * So, to make matters a little more complex, before the file dialog asks a
  83  * shell namespace object for it's DOS path, it asks if it actually has one.
  84  * This is done via the IShellFolder::GetAttributesOf method, which sets the
  85  * SFGAO_FILESYSTEM if - and only if - it has.
  86  *
  87  * The two things, described in the previous two paragraphs, are what unixfs is
  88  * based on. So basically, if UnixDosFolder's ParseDisplayName method is called
  89  * with a 'c:\windows' path-name, it doesn't return an
  90  * <Desktop|My Computer|C:|windows|> ITEMIDLIST. Instead, it uses
  91  * shell32's wine_get_unix_path_name and the _posix_ (which means not the win32)
  92  * fileio api's to figure out that c: is mapped to - let's say -
  93  * /home/mjung/.wine/drive_c and then constructs a
  94  * <Desktop|/|home|mjung|.wine|drive_c> ITEMIDLIST. Which is what the file
  95  * dialog uses to display the folder and file objects, which is why you see a
  96  * unix path. When the user has found a nice place for his file and hits the
  97  * save button, the ITEMIDLIST of the selected folder object is passed to
  98  * GetDisplayNameOf, which returns a _DOS_ path name
  99  * (like H:\home_of_my_new_file out of <|Desktop|/|home|mjung|home_of_my_new_file|>).
 100  * Unixfs basically mounts your dos devices together in order to construct
 101  * a copy of your unix filesystem structure.
 102  *
 103  * But what if none of the symbolic links in 'dosdevices' points to '/', you
 104  * might ask ("And I don't want wine have access to my complete hard drive, you
 105  * *%&1#!"). No problem, as I stated above, unixfs uses the _posix_ apis to
 106  * construct the ITEMIDLISTs. Folders, which aren't accessible via a drive letter,
 107  * don't have the SFGAO_FILESYSTEM flag set. So the file dialogs shouldn't allow
 108  * the user to select such a folder for file storage (And if it does anyhow, it
 109  * will not be able to return a valid path, since there is none). Think of those
 110  * folders as a hierarchy of 'My Computer'-like folders, which happen to be a
 111  * shadow of your unix filesystem tree. And since all of this stuff doesn't
 112  * change anything at all in wine's fileio api's, windows applications will have
 113  * no more access rights as they had before.
 114  *
 115  * To sum it all up, you can still safely run wine with you root account (Just
 116  * kidding, don't do it.)
 117  *
 118  * If you are now standing in front of your computer, shouting hotly
 119  * "I am not convinced, Mr. Rumsfeld^H^H^H^H^H^H^H^H^H^H^H^H", fire up regedit
 120  * and delete HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\
 121  * Explorer\Desktop\Namespace\{9D20AAE8-0625-44B0-9CA7-71889C2254D9} and you
 122  * will be back in the pre-unixfs days.
 123  */
 124
 125 #include "config.h"
 126 #include "wine/port.h"
 127
 128 #include <stdio.h>
 129 #include <stdarg.h>
 130 #include <limits.h>
 131 #include <errno.h>
 132 #ifdef HAVE_DIRENT_H
 133 # include <dirent.h>
 134 #endif
 135 #include <stdlib.h>
 136 #ifdef HAVE_UNISTD_H
 137 # include <unistd.h>
 138 #endif
 139 #ifdef HAVE_SYS_STAT_H
 140 # include <sys/stat.h>
 141 #endif
 142 #ifdef HAVE_PWD_H
 143 # include <pwd.h>
 144 #endif
 145 #ifdef HAVE_GRP_H
 146 # include <grp.h>
 147 #endif
 148
 149 #define COBJMACROS
 150 #define NONAMELESSUNION
 151 #define NONAMELESSSTRUCT
 152
 153 #include "windef.h"
 154 #include "winbase.h"
 155 #include "winuser.h"
 156 #include "objbase.h"
 157 #include "winreg.h"
 158 #include "shlwapi.h"
 159 #include "winternl.h"
 160 #include "wine/debug.h"
 161
 162 #include "shell32_main.h"
 163 #include "shellfolder.h"
 164 #include "shfldr.h"
 165 #include "shresdef.h"
 166 #include "pidl.h"
 167 #include "debughlp.h"
 168
 169 WINE_DEFAULT_DEBUG_CHANNEL(shell);
 170
 171 #if !defined(__MINGW32__) && !defined(_MSC_VER)
 172
 173 #define ADJUST_THIS(c,m,p) ((c*)(((long)p)-(long)&(((c*)0)->lp##m##Vtbl)))
 174 #define STATIC_CAST(i,p) ((i*)&p->lp##i##Vtbl)
 175
 176 #define LEN_SHITEMID_FIXED_PART ((USHORT) \
 177     ( sizeof(USHORT)      /* SHITEMID's cb field. */ \
 178     + sizeof(PIDLTYPE)    /* PIDLDATA's type field. */ \
 179     + sizeof(FileStruct)  /* Well, the FileStruct. */ \
 180     - sizeof(char)        /* One char too much in FileStruct. */ \
 181     + sizeof(FileStructW) /* You name it. */ \
 182     - sizeof(WCHAR)       /* One WCHAR too much in FileStructW. */ \
 183     + sizeof(WORD) ))     /* Offset of FileStructW field in PIDL. */
 184
 185 #define PATHMODE_UNIX 0
 186 #define PATHMODE_DOS  1
 187
 188 static const WCHAR wFileSystemBindData[] = {
 189     'F','i','l','e',' ','S','y','s','t','e','m',' ','B','i','n','d',' ','D','a','t','a',0};
 190
 191 /* UnixFolder object layout and typedef.
 192  */
 193 typedef struct _UnixFolder {
 194     const IShellFolder2Vtbl       *lpIShellFolder2Vtbl;
 195     const IPersistFolder3Vtbl     *lpIPersistFolder3Vtbl;
 196     const IPersistPropertyBagVtbl *lpIPersistPropertyBagVtbl;
 197     const IDropTargetVtbl         *lpIDropTargetVtbl;
 198     const ISFHelperVtbl           *lpISFHelperVtbl;
 199     LONG         m_cRef;
 200     CHAR         *m_pszPath;     /* Target path of the shell folder (CP_UNIXCP) */
 201     LPITEMIDLIST m_pidlLocation; /* Location in the shell namespace */
 202     DWORD        m_dwPathMode;
 203     DWORD        m_dwAttributes;
 204     const CLSID  *m_pCLSID;
 205     DWORD        m_dwDropEffectsMask;
 206 } UnixFolder;
 207
 208 /* Will hold the registered clipboard format identifier for ITEMIDLISTS. */
 209 static UINT cfShellIDList = 0;
 210
 211 /******************************************************************************
 212  * UNIXFS_filename_from_shitemid [Internal]
 213  *
 214  *  Get CP_UNIXCP encoded filename corresponding to the first item of a pidl
 215  *
 216  * PARAMS
 217  *  pidl           [I] A simple SHITEMID
 218  *  pszPathElement [O] Filename in CP_UNIXCP encoding will be stored here
 219  *
 220  * RETURNS
 221  *  Success: Number of bytes necessary to store the CP_UNIXCP encoded filename
 222  *   _without_ the terminating NUL.
 223  *  Failure: 0
 224  *
 225  * NOTES
 226  *  Size of the buffer at pszPathElement has to be FILENAME_MAX. pszPathElement
 227  *  may be NULL, if you are only interested in the return value.
 228  */
 229 static int UNIXFS_filename_from_shitemid(LPCITEMIDLIST pidl, char* pszPathElement) {
 230     FileStructW *pFileStructW = _ILGetFileStructW(pidl);
 231     int cLen = 0;
 232
 233     if (pFileStructW) {
 234         cLen = WideCharToMultiByte(CP_UNIXCP, 0, pFileStructW->wszName, -1, pszPathElement,
 235             pszPathElement ? FILENAME_MAX : 0, 0, 0);
 236     } else {
 237         /* There might be pidls slipping in from shfldr_fs.c, which don't contain the
 238          * FileStructW field. In this case, we have to convert from CP_ACP to CP_UNIXCP. */
 239         char *pszText = _ILGetTextPointer(pidl);
 240         WCHAR *pwszPathElement = NULL;
 241         int cWideChars;
 242
 243         cWideChars = MultiByteToWideChar(CP_ACP, 0, pszText, -1, NULL, 0);
 244         if (!cWideChars) goto cleanup;
 245
 246         pwszPathElement = SHAlloc(cWideChars * sizeof(WCHAR));
 247         if (!pwszPathElement) goto cleanup;
 248
 249         cWideChars = MultiByteToWideChar(CP_ACP, 0, pszText, -1, pwszPathElement, cWideChars);
 250         if (!cWideChars) goto cleanup;
 251
 252         cLen = WideCharToMultiByte(CP_UNIXCP, 0, pwszPathElement, -1, pszPathElement,
 253             pszPathElement ? FILENAME_MAX : 0, 0, 0);
 254
 255     cleanup:
 256         SHFree(pwszPathElement);
 257     }
 258
 259     if (cLen) cLen--; /* Don't count terminating NUL! */
 260     return cLen;
 261 }
 262
 263 /******************************************************************************
 264  * UNIXFS_shitemid_len_from_filename [Internal]
 265  *
 266  * Computes the necessary length of a pidl to hold a path element
 267  *
 268  * PARAMS
 269  *  szPathElement    [I] The path element string in CP_UNIXCP encoding.
 270  *  ppszPathElement  [O] Path element string in CP_ACP encoding.
 271  *  ppwszPathElement [O] Path element string as WCHAR string.
 272  *
 273  * RETURNS
 274  *  Success: Length in bytes of a SHITEMID representing szPathElement
 275  *  Failure: 0
 276  *
 277  * NOTES
 278  *  Provide NULL values if not interested in pp(w)szPathElement. Otherwise
 279  *  caller is responsible to free ppszPathElement and ppwszPathElement with
 280  *  SHFree.
 281  */
 282 static USHORT UNIXFS_shitemid_len_from_filename(
 283     const char *szPathElement, char **ppszPathElement, WCHAR **ppwszPathElement)
 284 {
 285     USHORT cbPidlLen = 0;
 286     WCHAR *pwszPathElement = NULL;
 287     char *pszPathElement = NULL;
 288     int cWideChars, cChars;
 289
 290     /* There and Back Again: A Hobbit's Holiday. CP_UNIXCP might be some ANSI
 291      * codepage or it might be a real multi-byte encoding like utf-8. There is no
 292      * other way to figure out the length of the corresponding WCHAR and CP_ACP
 293      * strings without actually doing the full CP_UNIXCP -> WCHAR -> CP_ACP cycle. */
 294
 295     cWideChars = MultiByteToWideChar(CP_UNIXCP, 0, szPathElement, -1, NULL, 0);
 296     if (!cWideChars) goto cleanup;
 297
 298     pwszPathElement = SHAlloc(cWideChars * sizeof(WCHAR));
 299     if (!pwszPathElement) goto cleanup;
 300
 301     cWideChars = MultiByteToWideChar(CP_UNIXCP, 0, szPathElement, -1, pwszPathElement, cWideChars);
 302     if (!cWideChars) goto cleanup;
 303
 304     cChars = WideCharToMultiByte(CP_ACP, 0, pwszPathElement, -1, NULL, 0, 0, 0);
 305     if (!cChars) goto cleanup;
 306
 307     pszPathElement = SHAlloc(cChars);
 308     if (!pszPathElement) goto cleanup;
 309
 310     cChars = WideCharToMultiByte(CP_ACP, 0, pwszPathElement, -1, pszPathElement, cChars, 0, 0);
 311     if (!cChars) goto cleanup;
 312
 313     /* (cChars & 0x1) is for the potential alignment byte */
 314     cbPidlLen = LEN_SHITEMID_FIXED_PART + cChars + (cChars & 0x1) + cWideChars * sizeof(WCHAR);
 315
 316 cleanup:
 317     if (cbPidlLen && ppszPathElement)
 318         *ppszPathElement = pszPathElement;
 319     else
 320         SHFree(pszPathElement);
 321
 322     if (cbPidlLen && ppwszPathElement)
 323         *ppwszPathElement = pwszPathElement;
 324     else
 325         SHFree(pwszPathElement);
 326
 327     return cbPidlLen;
 328 }
 329
 330 /******************************************************************************
 331  * UNIXFS_is_pidl_of_type [Internal]
 332  *
 333  * Checks for the first SHITEMID of an ITEMIDLIST if it passes a filter.
 334  *
 335  * PARAMS
 336  *  pIDL    [I] The ITEMIDLIST to be checked.
 337  *  fFilter [I] Shell condition flags, which specify the filter.
 338  *
 339  * RETURNS
 340  *  TRUE, if pIDL is accepted by fFilter
 341  *  FALSE, otherwise
 342  */
 343 static inline BOOL UNIXFS_is_pidl_of_type(LPCITEMIDLIST pIDL, SHCONTF fFilter) {
 344     const PIDLDATA *pIDLData = _ILGetDataPointer(pIDL);
 345     if (!(fFilter & SHCONTF_INCLUDEHIDDEN) && pIDLData &&
 346         (pIDLData->u.file.uFileAttribs & FILE_ATTRIBUTE_HIDDEN))
 347     {
 348         return FALSE;
 349     }
 350     if (_ILIsFolder(pIDL) && (fFilter & SHCONTF_FOLDERS)) return TRUE;
 351     if (_ILIsValue(pIDL) && (fFilter & SHCONTF_NONFOLDERS)) return TRUE;
 352     return FALSE;
 353 }
 354
 355 /******************************************************************************
 356  * UNIXFS_get_unix_path [Internal]
 357  *
 358  * Convert an absolute dos path to an absolute unix path.
 359  * Evaluate "/.", "/.." and the symbolic links in $WINEPREFIX/dosdevices.
 360  *
 361  * PARAMS
 362  *  pszDosPath       [I] An absolute dos path
 363  *  pszCanonicalPath [O] Buffer of length FILENAME_MAX. Will receive the canonical path.
 364  *
 365  * RETURNS
 366  *  Success, TRUE
 367  *  Failure, FALSE - Path not existent, too long, insufficient rights, to many symlinks
 368  */
 369 static BOOL UNIXFS_get_unix_path(LPCWSTR pszDosPath, char *pszCanonicalPath)
 370 {
 371     char *pPathTail, *pElement, *pCanonicalTail, szPath[FILENAME_MAX], *pszUnixPath, has_failed = 0, mb_path[FILENAME_MAX];
 372     WCHAR wszDrive[] = { '?', ':', '\\', 0 }, dospath[PATH_MAX], *dospath_end;
 373     int cDriveSymlinkLen;
 374
 375     TRACE("(pszDosPath=%s, pszCanonicalPath=%p)\n", debugstr_w(pszDosPath), pszCanonicalPath);
 376
 377     if (!pszDosPath || pszDosPath[1] != ':')
 378         return FALSE;
 379
 380     /* Get the canonicalized unix path corresponding to the drive letter. */
 381     wszDrive[0] = pszDosPath[0];
 382     pszUnixPath = wine_get_unix_file_name(wszDrive);
 383     if (!pszUnixPath) return FALSE;
 384     cDriveSymlinkLen = strlen(pszUnixPath);
 385     pElement = realpath(pszUnixPath, szPath);
 386     HeapFree(GetProcessHeap(), 0, pszUnixPath);
 387     if (!pElement) return FALSE;
 388     if (szPath[strlen(szPath)-1] != '/') strcat(szPath, "/");
 389
 390     /* Append the part relative to the drive symbolic link target. */
 391     lstrcpyW(dospath, pszDosPath);
 392     dospath_end = dospath + lstrlenW(dospath);
 393     /* search for the most valid UNIX path possible, then append missing
 394      * path parts */
 395     while(!(pszUnixPath = wine_get_unix_file_name(dospath))){
 396         if(has_failed){
 397             *dospath_end = '/';
 398             --dospath_end;
 399         }else
 400             has_failed = 1;
 401         while(*dospath_end != '\\' && *dospath_end != '/'){
 402             --dospath_end;
 403             if(dospath_end < dospath)
 404                 break;
 405         }
 406         *dospath_end = '\0';
 407     }
 408     if(dospath_end < dospath)
 409         return FALSE;
 410     strcat(szPath, pszUnixPath + cDriveSymlinkLen);
 411     HeapFree(GetProcessHeap(), 0, pszUnixPath);
 412
 413     if(has_failed && WideCharToMultiByte(CP_UNIXCP, 0, dospath_end + 1, -1,
 414                 mb_path, FILENAME_MAX, NULL, NULL) > 0){
 415         strcat(szPath, "/");
 416         strcat(szPath, mb_path);
 417     }
 418
 419     /* pCanonicalTail always points to the end of the canonical path constructed
 420      * thus far. pPathTail points to the still to be processed part of the input
 421      * path. pElement points to the path element currently investigated.
 422      */
 423     *pszCanonicalPath = '\0';
 424     pCanonicalTail = pszCanonicalPath;
 425     pPathTail = szPath;
 426
 427     do {
 428         char cTemp;
 429
 430         pElement = pPathTail;
 431         pPathTail = strchr(pPathTail+1, '/');
 432         if (!pPathTail) /* Last path element may not be terminated by '/'. */
 433             pPathTail = pElement + strlen(pElement);
 434         /* Temporarily terminate the current path element. Will be restored later. */
 435         cTemp = *pPathTail;
 436         *pPathTail = '\0';
 437
 438         /* Skip "/." path elements */
 439         if (!strcmp("/.", pElement)) {
 440             *pPathTail = cTemp;
 441         } else if (!strcmp("/..", pElement)) {
 442             /* Remove last element in canonical path for "/.." elements, then skip. */
 443             char *pTemp = strrchr(pszCanonicalPath, '/');
 444             if (pTemp)
 445                 pCanonicalTail = pTemp;
 446             *pCanonicalTail = '\0';
 447             *pPathTail = cTemp;
 448         } else {
 449             /* Directory or file. Copy to canonical path */
 450             if (pCanonicalTail - pszCanonicalPath + pPathTail - pElement + 1 > FILENAME_MAX)
 451                 return FALSE;
 452
 453             memcpy(pCanonicalTail, pElement, pPathTail - pElement + 1);
 454             pCanonicalTail += pPathTail - pElement;
 455             *pPathTail = cTemp;
 456         }
 457     } while (pPathTail[0] == '/');
 458
 459     TRACE("--> %s\n", debugstr_a(pszCanonicalPath));
 460
 461     return TRUE;
 462 }
 463
 464 /******************************************************************************
 465  * UNIXFS_build_shitemid [Internal]
 466  *
 467  * Constructs a new SHITEMID for the last component of path 'pszUnixPath' into
 468  * buffer 'pIDL'.
 469  *
 470  * PARAMS
 471  *  pszUnixPath [I] An absolute path. The SHITEMID will be built for the last component.
 472  *  pbc         [I] Bind context for this action, used to determine if the file must exist
 473  *  pIDL        [O] SHITEMID will be constructed here.
 474  *
 475  * RETURNS
 476  *  Success: A pointer to the terminating '\0' character of path.
 477  *  Failure: NULL
 478  *
 479  * NOTES
 480  *  Minimum size of pIDL is SHITEMID_LEN_FROM_NAME_LEN(strlen(last_component_of_path)).
 481  *  If what you need is a PIDLLIST with a single SHITEMID, don't forget to append
 482  *  a 0 USHORT value.
 483  */
 484 static char* UNIXFS_build_shitemid(char *pszUnixPath, BOOL bMustExist, WIN32_FIND_DATAW *pFindData, void *pIDL) {
 485     LPPIDLDATA pIDLData;
 486     struct stat fileStat;
 487     WIN32_FIND_DATAW findData;
 488     char *pszComponentU, *pszComponentA;
 489     WCHAR *pwszComponentW;
 490     int cComponentULen, cComponentALen;
 491     USHORT cbLen;
 492     FileStructW *pFileStructW;
 493     WORD uOffsetW, *pOffsetW;
 494
 495     TRACE("(pszUnixPath=%s, bMustExsist=%s, pFindData=%p, pIDL=%p)\n",
 496             debugstr_a(pszUnixPath), bMustExist ? "T" : "F", pFindData, pIDL);
 497
 498     if (pFindData)
 499         memcpy(&findData, pFindData, sizeof(WIN32_FIND_DATAW));
 500     else {
 501         memset(&findData, 0, sizeof(WIN32_FIND_DATAW));
 502         findData.dwFileAttributes = FILE_ATTRIBUTE_DIRECTORY;
 503     }
 504
 505     /* We are only interested in regular files and directories. */
 506     if (stat(pszUnixPath, &fileStat)){
 507         if (bMustExist || errno != ENOENT)
 508             return NULL;
 509     } else {
 510         LARGE_INTEGER time;
 511
 512         if (S_ISDIR(fileStat.st_mode))
 513             findData.dwFileAttributes = FILE_ATTRIBUTE_DIRECTORY;
 514         else if (S_ISREG(fileStat.st_mode))
 515             findData.dwFileAttributes = FILE_ATTRIBUTE_NORMAL;
 516         else
 517             return NULL;
 518
 519         findData.nFileSizeLow = (DWORD)fileStat.st_size;
 520         findData.nFileSizeHigh = fileStat.st_size >> 32;
 521
 522         RtlSecondsSince1970ToTime(fileStat.st_mtime, &time);
 523         findData.ftLastWriteTime.dwLowDateTime = time.u.LowPart;
 524         findData.ftLastWriteTime.dwHighDateTime = time.u.HighPart;
 525         RtlSecondsSince1970ToTime(fileStat.st_atime, &time);
 526         findData.ftLastAccessTime.dwLowDateTime = time.u.LowPart;
 527         findData.ftLastAccessTime.dwHighDateTime = time.u.HighPart;
 528     }
 529
 530     /* Compute the SHITEMID's length and wipe it. */
 531     pszComponentU = strrchr(pszUnixPath, '/') + 1;
 532     cComponentULen = strlen(pszComponentU);
 533     cbLen = UNIXFS_shitemid_len_from_filename(pszComponentU, &pszComponentA, &pwszComponentW);
 534     if (!cbLen) return NULL;
 535     memset(pIDL, 0, cbLen);
 536     ((LPSHITEMID)pIDL)->cb = cbLen;
 537
 538     /* Set shell32's standard SHITEMID data fields. */
 539     pIDLData = _ILGetDataPointer(pIDL);
 540     pIDLData->type = (findData.dwFileAttributes&FILE_ATTRIBUTE_DIRECTORY) ? PT_FOLDER : PT_VALUE;
 541     pIDLData->u.file.dwFileSize = findData.nFileSizeLow;
 542     FileTimeToDosDateTime(&findData.ftLastWriteTime, &pIDLData->u.file.uFileDate,
 543             &pIDLData->u.file.uFileTime);
 544     pIDLData->u.file.uFileAttribs = 0;
 545     pIDLData->u.file.uFileAttribs |= findData.dwFileAttributes;
 546     if (pszComponentU[0] == '.') pIDLData->u.file.uFileAttribs |=  FILE_ATTRIBUTE_HIDDEN;
 547     cComponentALen = lstrlenA(pszComponentA) + 1;
 548     memcpy(pIDLData->u.file.szNames, pszComponentA, cComponentALen);
 549
 550     pFileStructW = (FileStructW*)(pIDLData->u.file.szNames + cComponentALen + (cComponentALen & 0x1));
 551     uOffsetW = (WORD)(((LPBYTE)pFileStructW) - ((LPBYTE)pIDL));
 552     pFileStructW->cbLen = cbLen - uOffsetW;
 553     FileTimeToDosDateTime(&findData.ftLastWriteTime, &pFileStructW->uCreationDate,
 554         &pFileStructW->uCreationTime);
 555     FileTimeToDosDateTime(&findData.ftLastAccessTime, &pFileStructW->uLastAccessDate,
 556         &pFileStructW->uLastAccessTime);
 557     lstrcpyW(pFileStructW->wszName, pwszComponentW);
 558
 559     pOffsetW = (WORD*)(((LPBYTE)pIDL) + cbLen - sizeof(WORD));
 560     *pOffsetW = uOffsetW;
 561
 562     SHFree(pszComponentA);
 563     SHFree(pwszComponentW);
 564
 565     return pszComponentU + cComponentULen;
 566 }
 567
 568 /******************************************************************************
 569  * UNIXFS_path_to_pidl [Internal]
 570  *
 571  * PARAMS
 572  *  pUnixFolder [I] If path is relative, pUnixFolder represents the base path
 573  *  path        [I] An absolute unix or dos path or a path relative to pUnixFolder
 574  *  ppidl       [O] The corresponding ITEMIDLIST. Release with SHFree/ILFree
 575  *
 576  * RETURNS
 577  *  Success: S_OK
 578  *  Failure: Error code, invalid params or out of memory
 579  *
 580  * NOTES
 581  *  pUnixFolder also carries the information if the path is expected to be unix or dos.
 582  */
 583 static HRESULT UNIXFS_path_to_pidl(UnixFolder *pUnixFolder, LPBC pbc, const WCHAR *path,
 584         LPITEMIDLIST *ppidl) {
 585     LPITEMIDLIST pidl;
 586     int cPidlLen, cPathLen;
 587     char *pSlash, *pNextSlash, szCompletePath[FILENAME_MAX], *pNextPathElement, *pszAPath;
 588     WCHAR *pwszPath;
 589     WIN32_FIND_DATAW find_data;
 590     BOOL must_exist = TRUE;
 591
 592     TRACE("pUnixFolder=%p, pbc=%p, path=%s, ppidl=%p\n", pUnixFolder, pbc, debugstr_w(path), ppidl);
 593
 594     if (!ppidl || !path)
 595         return E_INVALIDARG;
 596
 597     /* Build an absolute path and let pNextPathElement point to the interesting
 598      * relative sub-path. We need the absolute path to call 'stat', but the pidl
 599      * will only contain the relative part.
 600      */
 601     if ((pUnixFolder->m_dwPathMode == PATHMODE_DOS) && (path[1] == ':'))
 602     {
 603         /* Absolute dos path. Convert to unix */
 604         if (!UNIXFS_get_unix_path(path, szCompletePath))
 605             return E_FAIL;
 606         pNextPathElement = szCompletePath;
 607     }
 608     else if ((pUnixFolder->m_dwPathMode == PATHMODE_UNIX) && (path[0] == '/'))
 609     {
 610         /* Absolute unix path. Just convert to ANSI. */
 611         WideCharToMultiByte(CP_UNIXCP, 0, path, -1, szCompletePath, FILENAME_MAX, NULL, NULL);
 612         pNextPathElement = szCompletePath;
 613     }
 614     else
 615     {
 616         /* Relative dos or unix path. Concat with this folder's path */
 617         int cBasePathLen = strlen(pUnixFolder->m_pszPath);
 618         memcpy(szCompletePath, pUnixFolder->m_pszPath, cBasePathLen);
 619         WideCharToMultiByte(CP_UNIXCP, 0, path, -1, szCompletePath + cBasePathLen,
 620                             FILENAME_MAX - cBasePathLen, NULL, NULL);
 621         pNextPathElement = szCompletePath + cBasePathLen - 1;
 622
 623         /* If in dos mode, replace '\' with '/' */
 624         if (pUnixFolder->m_dwPathMode == PATHMODE_DOS) {
 625             char *pBackslash = strchr(pNextPathElement, '\\');
 626             while (pBackslash) {
 627                 *pBackslash = '/';
 628                 pBackslash = strchr(pBackslash, '\\');
 629             }
 630         }
 631     }
 632
 633     /* Special case for the root folder. */
 634     if (!strcmp(szCompletePath, "/")) {
 635         *ppidl = pidl = SHAlloc(sizeof(USHORT));
 636         if (!pidl) return E_FAIL;
 637         pidl->mkid.cb = 0; /* Terminate the ITEMIDLIST */
 638         return S_OK;
 639     }
 640
 641     /* Remove trailing slash, if present */
 642     cPathLen = strlen(szCompletePath);
 643     if (szCompletePath[cPathLen-1] == '/')
 644         szCompletePath[cPathLen-1] = '\0';
 645
 646     if ((szCompletePath[0] != '/') || (pNextPathElement[0] != '/')) {
 647         ERR("szCompletePath: %s, pNextPathElment: %s\n", szCompletePath, pNextPathElement);
 648         return E_FAIL;
 649     }
 650
 651     /* At this point, we have an absolute unix path in szCompletePath
 652      * and the relative portion of it in pNextPathElement. Both starting with '/'
 653      * and _not_ terminated by a '/'. */
 654     TRACE("complete path: %s, relative path: %s\n", szCompletePath, pNextPathElement);
 655
 656     /* Convert to CP_ACP and WCHAR */
 657     if (!UNIXFS_shitemid_len_from_filename(pNextPathElement, &pszAPath, &pwszPath))
 658         return E_FAIL;
 659
 660     /* Compute the length of the complete ITEMIDLIST */
 661     cPidlLen = 0;
 662     pSlash = pszAPath;
 663     while (pSlash) {
 664         pNextSlash = strchr(pSlash+1, '/');
 665         cPidlLen += LEN_SHITEMID_FIXED_PART + /* Fixed part length plus potential alignment byte. */
 666             (pNextSlash ? (pNextSlash - pSlash) & 0x1 : lstrlenA(pSlash) & 0x1);
 667         pSlash = pNextSlash;
 668     }
 669
 670     /* The USHORT is for the ITEMIDLIST terminator. The NUL terminators for the sub-path-strings
 671      * are accounted for by the '/' separators, which are not stored in the SHITEMIDs. Above we
 672      * have ensured that the number of '/'s exactly matches the number of sub-path-strings. */
 673     cPidlLen += lstrlenA(pszAPath) + lstrlenW(pwszPath) * sizeof(WCHAR) + sizeof(USHORT);
 674
 675     SHFree(pszAPath);
 676     SHFree(pwszPath);
 677
 678     *ppidl = pidl = SHAlloc(cPidlLen);
 679     if (!pidl) return E_FAIL;
 680
 681     if (pbc) {
 682         IUnknown *unk;
 683         IFileSystemBindData *fsb;
 684         HRESULT hr;
 685
 686         hr = IBindCtx_GetObjectParam(pbc, (LPOLESTR)wFileSystemBindData, &unk);
 687         if (SUCCEEDED(hr)) {
 688             hr = IUnknown_QueryInterface(unk, &IID_IFileSystemBindData, (LPVOID*)&fsb);
 689             if (SUCCEEDED(hr)) {
 690                 hr = IFileSystemBindData_GetFindData(fsb, &find_data);
 691                 if (FAILED(hr))
 692                     memset(&find_data, 0, sizeof(WIN32_FIND_DATAW));
 693
 694                 must_exist = FALSE;
 695                 IFileSystemBindData_Release(fsb);
 696             }
 697             IUnknown_Release(unk);
 698         }
 699     }
 700
 701     /* Concatenate the SHITEMIDs of the sub-directories. */
 702     while (*pNextPathElement) {
 703         pSlash = strchr(pNextPathElement+1, '/');
 704         if (pSlash) *pSlash = '\0';
 705         pNextPathElement = UNIXFS_build_shitemid(szCompletePath, must_exist,
 706                 must_exist&&!pSlash ? &find_data : NULL, pidl);
 707         if (pSlash) *pSlash = '/';
 708
 709         if (!pNextPathElement) {
 710             SHFree(*ppidl);
 711             *ppidl = NULL;
 712             return HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND);
 713         }
 714         pidl = ILGetNext(pidl);
 715     }
 716     pidl->mkid.cb = 0; /* Terminate the ITEMIDLIST */
 717
 718     if ((char *)pidl-(char *)*ppidl+sizeof(USHORT) != cPidlLen) /* We've corrupted the heap :( */
 719         ERR("Computed length of pidl incorrect. Please report.\n");
 720
 721     return S_OK;
 722 }
 723
 724 /******************************************************************************
 725  * UNIXFS_initialize_target_folder [Internal]
 726  *
 727  *  Initialize the m_pszPath member of an UnixFolder, given an absolute unix
 728  *  base path and a relative ITEMIDLIST. Leave the m_pidlLocation member, which
 729  *  specifies the location in the shell namespace alone.
 730  *
 731  * PARAMS
 732  *  This          [IO] The UnixFolder, whose target path is to be initialized
 733  *  szBasePath    [I]  The absolute base path
 734  *  pidlSubFolder [I]  Relative part of the path, given as an ITEMIDLIST
 735  *  dwAttributes  [I]  Attributes to add to the Folders m_dwAttributes member
 736  *                     (Used to pass the SFGAO_FILESYSTEM flag down the path)
 737  * RETURNS
 738  *  Success: S_OK,
 739  *  Failure: E_FAIL
 740  */
 741 static HRESULT UNIXFS_initialize_target_folder(UnixFolder *This, const char *szBasePath,
 742     LPCITEMIDLIST pidlSubFolder, DWORD dwAttributes)
 743 {
 744     LPCITEMIDLIST current = pidlSubFolder;
 745     DWORD dwPathLen = strlen(szBasePath)+1;
 746     char *pNextDir;
 747     WCHAR *dos_name;
 748
 749     /* Determine the path's length bytes */
 750     while (!_ILIsEmpty(current)) {
 751         dwPathLen += UNIXFS_filename_from_shitemid(current, NULL) + 1; /* For the '/' */
 752         current = ILGetNext(current);
 753     };
 754
 755     /* Build the path and compute the attributes*/
 756     This->m_dwAttributes =
 757             dwAttributes|SFGAO_FOLDER|SFGAO_HASSUBFOLDER|SFGAO_FILESYSANCESTOR|SFGAO_CANRENAME;
 758     This->m_pszPath = pNextDir = SHAlloc(dwPathLen);
 759     if (!This->m_pszPath) {
 760         WARN("SHAlloc failed!\n");
 761         return E_FAIL;
 762     }
 763     current = pidlSubFolder;
 764     strcpy(pNextDir, szBasePath);
 765     pNextDir += strlen(szBasePath);
 766     if (This->m_dwPathMode == PATHMODE_UNIX || IsEqualCLSID(&CLSID_MyDocuments, This->m_pCLSID))
 767         This->m_dwAttributes |= SFGAO_FILESYSTEM;
 768     while (!_ILIsEmpty(current)) {
 769         pNextDir += UNIXFS_filename_from_shitemid(current, pNextDir);
 770         *pNextDir++ = '/';
 771         current = ILGetNext(current);
 772     }
 773     *pNextDir='\0';
 774
 775     if (!(This->m_dwAttributes & SFGAO_FILESYSTEM) &&
 776         ((dos_name = wine_get_dos_file_name(This->m_pszPath))))
 777     {
 778         This->m_dwAttributes |= SFGAO_FILESYSTEM;
 779         HeapFree( GetProcessHeap(), 0, dos_name );
 780     }
 781
 782     return S_OK;
 783 }
 784
 785 /******************************************************************************
 786  * UNIXFS_copy [Internal]
 787  *
 788  *  Copy pwszDosSrc to pwszDosDst.
 789  *
 790  * PARAMS
 791  *  pwszDosSrc [I]  absolute path of the source
 792  *  pwszDosDst [I]  absolute path of the destination
 793  *
 794  * RETURNS
 795  *  Success: S_OK,
 796  *  Failure: E_FAIL
 797  */
 798 static HRESULT UNIXFS_copy(LPCWSTR pwszDosSrc, LPCWSTR pwszDosDst)
 799 {
 800     SHFILEOPSTRUCTW op;
 801     LPWSTR pwszSrc, pwszDst;
 802     HRESULT res = E_OUTOFMEMORY;
 803     UINT iSrcLen, iDstLen;
 804
 805     if (!pwszDosSrc || !pwszDosDst)
 806         return E_FAIL;
 807
 808     iSrcLen = lstrlenW(pwszDosSrc);
 809     iDstLen = lstrlenW(pwszDosDst);
 810     pwszSrc = HeapAlloc(GetProcessHeap(), 0, (iSrcLen + 2) * sizeof(WCHAR));
 811     pwszDst = HeapAlloc(GetProcessHeap(), 0, (iDstLen + 2) * sizeof(WCHAR));
 812
 813     if (pwszSrc && pwszDst) {
 814         lstrcpyW(pwszSrc, pwszDosSrc);
 815         lstrcpyW(pwszDst, pwszDosDst);
 816         /* double null termination */
 817         pwszSrc[iSrcLen + 1] = 0;
 818         pwszDst[iDstLen + 1] = 0;
 819
 820         ZeroMemory(&op, sizeof(op));
 821         op.hwnd = GetActiveWindow();
 822         op.wFunc = FO_COPY;
 823         op.pFrom = pwszSrc;
 824         op.pTo = pwszDst;
 825         op.fFlags = FOF_ALLOWUNDO;
 826         if (!SHFileOperationW(&op))
 827         {
 828             WARN("SHFileOperationW failed\n");
 829             res = E_FAIL;
 830         }
 831         else
 832             res = S_OK;
 833     }
 834
 835     HeapFree(GetProcessHeap(), 0, pwszSrc);
 836     HeapFree(GetProcessHeap(), 0, pwszDst);
 837     return res;
 838 }
 839
 840 /******************************************************************************
 841  * UnixFolder
 842  *
 843  * Class whose heap based instances represent unix filesystem directories.
 844  */
 845
 846 static void UnixFolder_Destroy(UnixFolder *pUnixFolder) {
 847     TRACE("(pUnixFolder=%p)\n", pUnixFolder);
 848
 849     SHFree(pUnixFolder->m_pszPath);
 850     ILFree(pUnixFolder->m_pidlLocation);
 851     SHFree(pUnixFolder);
 852 }
 853
 854 static HRESULT WINAPI UnixFolder_IShellFolder2_QueryInterface(IShellFolder2 *iface, REFIID riid,
 855     void **ppv)
 856 {
 857     UnixFolder *This = ADJUST_THIS(UnixFolder, IShellFolder2, iface);
 858
 859     TRACE("(iface=%p, riid=%s, ppv=%p)\n", iface, shdebugstr_guid(riid), ppv);
 860
 861     if (!ppv) return E_INVALIDARG;
 862
 863     if (IsEqualIID(&IID_IUnknown, riid) || IsEqualIID(&IID_IShellFolder, riid) ||
 864         IsEqualIID(&IID_IShellFolder2, riid))
 865     {
 866         *ppv = STATIC_CAST(IShellFolder2, This);
 867     } else if (IsEqualIID(&IID_IPersistFolder3, riid) || IsEqualIID(&IID_IPersistFolder2, riid) ||
 868                IsEqualIID(&IID_IPersistFolder, riid) || IsEqualIID(&IID_IPersist, riid))
 869     {
 870         *ppv = STATIC_CAST(IPersistFolder3, This);
 871     } else if (IsEqualIID(&IID_IPersistPropertyBag, riid)) {
 872         *ppv = STATIC_CAST(IPersistPropertyBag, This);
 873     } else if (IsEqualIID(&IID_ISFHelper, riid)) {
 874         *ppv = STATIC_CAST(ISFHelper, This);
 875     } else if (IsEqualIID(&IID_IDropTarget, riid)) {
 876         *ppv = STATIC_CAST(IDropTarget, This);
 877         if (!cfShellIDList)
 878             cfShellIDList = RegisterClipboardFormatW(CFSTR_SHELLIDLISTW);
 879     } else {
 880         *ppv = NULL;
 881         TRACE("Unimplemented interface %s\n", shdebugstr_guid(riid));
 882         return E_NOINTERFACE;
 883     }
 884
 885     IUnknown_AddRef((IUnknown*)*ppv);
 886     return S_OK;
 887 }
 888
 889 static ULONG WINAPI UnixFolder_IShellFolder2_AddRef(IShellFolder2 *iface) {
 890     UnixFolder *This = ADJUST_THIS(UnixFolder, IShellFolder2, iface);
 891
 892     TRACE("(iface=%p)\n", iface);
 893
 894     return InterlockedIncrement(&This->m_cRef);
 895 }
 896
 897 static ULONG WINAPI UnixFolder_IShellFolder2_Release(IShellFolder2 *iface) {
 898     UnixFolder *This = ADJUST_THIS(UnixFolder, IShellFolder2, iface);
 899     ULONG cRef;
 900
 901     TRACE("(iface=%p)\n", iface);
 902
 903     cRef = InterlockedDecrement(&This->m_cRef);
 904
 905     if (!cRef)
 906         UnixFolder_Destroy(This);
 907
 908     return cRef;
 909 }
 910
 911 static HRESULT WINAPI UnixFolder_IShellFolder2_ParseDisplayName(IShellFolder2* iface, HWND hwndOwner,
 912     LPBC pbc, LPOLESTR lpszDisplayName, ULONG* pchEaten, LPITEMIDLIST* ppidl,
 913     ULONG* pdwAttributes)
 914 {
 915     UnixFolder *This = ADJUST_THIS(UnixFolder, IShellFolder2, iface);
 916     HRESULT result;
 917
 918     TRACE("(iface=%p, hwndOwner=%p, pbc=%p, lpszDisplayName=%s, pchEaten=%p, ppidl=%p, "
 919           "pdwAttributes=%p) stub\n", iface, hwndOwner, pbc, debugstr_w(lpszDisplayName),
 920           pchEaten, ppidl, pdwAttributes);
 921
 922     result = UNIXFS_path_to_pidl(This, pbc, lpszDisplayName, ppidl);
 923     if (SUCCEEDED(result) && pdwAttributes && *pdwAttributes)
 924     {
 925         IShellFolder *pParentSF;
 926         LPCITEMIDLIST pidlLast;
 927         LPITEMIDLIST pidlComplete = ILCombine(This->m_pidlLocation, *ppidl);
 928         HRESULT hr;
 929
 930         hr = SHBindToParent(pidlComplete, &IID_IShellFolder, (LPVOID*)&pParentSF, &pidlLast);
 931         if (FAILED(hr)) {
 932             FIXME("SHBindToParent failed! hr = %08x\n", hr);
 933             ILFree(pidlComplete);
 934             return E_FAIL;
 935         }
 936         IShellFolder_GetAttributesOf(pParentSF, 1, &pidlLast, pdwAttributes);
 937         IShellFolder_Release(pParentSF);
 938         ILFree(pidlComplete);
 939     }
 940
 941     if (FAILED(result)) TRACE("FAILED!\n");
 942     return result;
 943 }
 944
 945 static IUnknown *UnixSubFolderIterator_Constructor(UnixFolder *pUnixFolder, SHCONTF fFilter);
 946
 947 static HRESULT WINAPI UnixFolder_IShellFolder2_EnumObjects(IShellFolder2* iface, HWND hwndOwner,
 948     SHCONTF grfFlags, IEnumIDList** ppEnumIDList)
 949 {
 950     UnixFolder *This = ADJUST_THIS(UnixFolder, IShellFolder2, iface);
 951     IUnknown *newIterator;
 952     HRESULT hr;
 953
 954     TRACE("(iface=%p, hwndOwner=%p, grfFlags=%08x, ppEnumIDList=%p)\n",
 955             iface, hwndOwner, grfFlags, ppEnumIDList);
 956
 957     if (!This->m_pszPath) {
 958         WARN("EnumObjects called on uninitialized UnixFolder-object!\n");
 959         return E_UNEXPECTED;
 960     }
 961
 962     newIterator = UnixSubFolderIterator_Constructor(This, grfFlags);
 963     hr = IUnknown_QueryInterface(newIterator, &IID_IEnumIDList, (void**)ppEnumIDList);
 964     IUnknown_Release(newIterator);
 965
 966     return hr;
 967 }
 968
 969 static HRESULT CreateUnixFolder(IUnknown *pUnkOuter, REFIID riid, LPVOID *ppv, const CLSID *pCLSID);
 970
 971 static HRESULT WINAPI UnixFolder_IShellFolder2_BindToObject(IShellFolder2* iface, LPCITEMIDLIST pidl,
 972     LPBC pbcReserved, REFIID riid, void** ppvOut)
 973 {
 974     UnixFolder *This = ADJUST_THIS(UnixFolder, IShellFolder2, iface);
 975     IPersistFolder3 *persistFolder;
 976     HRESULT hr;
 977     const CLSID *clsidChild;
 978
 979     TRACE("(iface=%p, pidl=%p, pbcReserver=%p, riid=%p, ppvOut=%p)\n",
 980             iface, pidl, pbcReserved, riid, ppvOut);
 981
 982     if (_ILIsEmpty(pidl))
 983         return E_INVALIDARG;
 984
 985     /* Don't bind to files */
 986     if (_ILIsValue(ILFindLastID(pidl)))
 987         return HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND);
 988
 989     if (IsEqualCLSID(This->m_pCLSID, &CLSID_FolderShortcut)) {
 990         /* Children of FolderShortcuts are ShellFSFolders on Windows.
 991          * Unixfs' counterpart is UnixDosFolder. */
 992         clsidChild = &CLSID_UnixDosFolder;
 993     } else {
 994         clsidChild = This->m_pCLSID;
 995     }
 996
 997     hr = CreateUnixFolder(NULL, &IID_IPersistFolder3, (void**)&persistFolder, clsidChild);
 998     if (FAILED(hr)) return hr;
 999     hr = IPersistFolder_QueryInterface(persistFolder, riid, ppvOut);
1000
1001     if (SUCCEEDED(hr)) {
1002         UnixFolder *subfolder = ADJUST_THIS(UnixFolder, IPersistFolder3, persistFolder);
1003         subfolder->m_pidlLocation = ILCombine(This->m_pidlLocation, pidl);
1004         hr = UNIXFS_initialize_target_folder(subfolder, This->m_pszPath, pidl,
1005                                              This->m_dwAttributes & SFGAO_FILESYSTEM);
1006     }
1007
1008     IPersistFolder3_Release(persistFolder);
1009
1010     return hr;
1011 }
1012
1013 static HRESULT WINAPI UnixFolder_IShellFolder2_BindToStorage(IShellFolder2* This, LPCITEMIDLIST pidl,
1014     LPBC pbcReserved, REFIID riid, void** ppvObj)
1015 {
1016     FIXME("stub\n");
1017     return E_NOTIMPL;
1018 }
1019
1020 static HRESULT WINAPI UnixFolder_IShellFolder2_CompareIDs(IShellFolder2* iface, LPARAM lParam,
1021     LPCITEMIDLIST pidl1, LPCITEMIDLIST pidl2)
1022 {
1023     BOOL isEmpty1, isEmpty2;
1024     HRESULT hr = E_FAIL;
1025     LPCITEMIDLIST firstpidl;
1026     IShellFolder2 *psf;
1027     int compare;
1028
1029     TRACE("(iface=%p, lParam=%ld, pidl1=%p, pidl2=%p)\n", iface, lParam, pidl1, pidl2);
1030
1031     isEmpty1 = _ILIsEmpty(pidl1);
1032     isEmpty2 = _ILIsEmpty(pidl2);
1033
1034     if (isEmpty1 && isEmpty2)
1035         return MAKE_HRESULT(SEVERITY_SUCCESS, 0, 0);
1036     else if (isEmpty1)
1037         return MAKE_HRESULT(SEVERITY_SUCCESS, 0, (WORD)-1);
1038     else if (isEmpty2)
1039         return MAKE_HRESULT(SEVERITY_SUCCESS, 0, (WORD)1);
1040
1041     compare = CompareStringA(LOCALE_USER_DEFAULT, NORM_IGNORECASE,
1042                              _ILGetTextPointer(pidl1), -1,
1043                              _ILGetTextPointer(pidl2), -1);
1044
1045     if ((compare != CSTR_EQUAL) && _ILIsFolder(pidl1) && !_ILIsFolder(pidl2))
1046         return MAKE_HRESULT(SEVERITY_SUCCESS, 0, (WORD)-1);
1047     if ((compare != CSTR_EQUAL) && !_ILIsFolder(pidl1) && _ILIsFolder(pidl2))
1048         return MAKE_HRESULT(SEVERITY_SUCCESS, 0, (WORD)1);
1049
1050     if ((compare == CSTR_LESS_THAN) || (compare == CSTR_GREATER_THAN))
1051         return MAKE_HRESULT(SEVERITY_SUCCESS, 0, (WORD)((compare == CSTR_LESS_THAN)?-1:1));
1052
1053     if (pidl1->mkid.cb < pidl2->mkid.cb)
1054         return MAKE_HRESULT(SEVERITY_SUCCESS, 0, (WORD)-1);
1055     else if (pidl1->mkid.cb > pidl2->mkid.cb)
1056         return MAKE_HRESULT(SEVERITY_SUCCESS, 0, (WORD)1);
1057
1058     firstpidl = pidl1;
1059     pidl1 = ILGetNext(pidl1);
1060     pidl2 = ILGetNext(pidl2);
1061
1062     isEmpty1 = _ILIsEmpty(pidl1);
1063     isEmpty2 = _ILIsEmpty(pidl2);
1064
1065     if (isEmpty1 && isEmpty2)
1066         return MAKE_HRESULT(SEVERITY_SUCCESS, 0, 0);
1067     else if (isEmpty1)
1068         return MAKE_HRESULT(SEVERITY_SUCCESS, 0, (WORD)-1);
1069     else if (isEmpty2)
1070         return MAKE_HRESULT(SEVERITY_SUCCESS, 0, (WORD)1);
1071     else if (SUCCEEDED(IShellFolder2_BindToObject(iface, firstpidl, NULL, &IID_IShellFolder, (void**)&psf))) {
1072         hr = IShellFolder_CompareIDs(psf, lParam, pidl1, pidl2);
1073         IShellFolder2_Release(psf);
1074     }
1075
1076     return hr;
1077 }
1078
1079 static HRESULT WINAPI UnixFolder_IShellFolder2_CreateViewObject(IShellFolder2* iface, HWND hwndOwner,
1080     REFIID riid, void** ppv)
1081 {
1082     HRESULT hr = E_INVALIDARG;
1083
1084     TRACE("(iface=%p, hwndOwner=%p, riid=%p, ppv=%p) stub\n", iface, hwndOwner, riid, ppv);
1085
1086     if (!ppv) return E_INVALIDARG;
1087     *ppv = NULL;
1088
1089     if (IsEqualIID(&IID_IShellView, riid)) {
1090         LPSHELLVIEW pShellView;
1091
1092         pShellView = IShellView_Constructor((IShellFolder*)iface);
1093         if (pShellView) {
1094             hr = IShellView_QueryInterface(pShellView, riid, ppv);
1095             IShellView_Release(pShellView);
1096         }
1097     } else if (IsEqualIID(&IID_IDropTarget, riid)) {
1098         hr = IShellFolder2_QueryInterface(iface, &IID_IDropTarget, ppv);
1099     }
1100
1101     return hr;
1102 }
1103
1104 static HRESULT WINAPI UnixFolder_IShellFolder2_GetAttributesOf(IShellFolder2* iface, UINT cidl,
1105     LPCITEMIDLIST* apidl, SFGAOF* rgfInOut)
1106 {
1107     UnixFolder *This = ADJUST_THIS(UnixFolder, IShellFolder2, iface);
1108     HRESULT hr = S_OK;
1109
1110     TRACE("(iface=%p, cidl=%u, apidl=%p, rgfInOut=%p)\n", iface, cidl, apidl, rgfInOut);
1111
1112     if (!rgfInOut || (cidl && !apidl))
1113         return E_INVALIDARG;
1114
1115     if (cidl == 0) {
1116         *rgfInOut &= This->m_dwAttributes;
1117     } else {
1118         char szAbsolutePath[FILENAME_MAX], *pszRelativePath;
1119         UINT i;
1120
1121         *rgfInOut = SFGAO_CANCOPY|SFGAO_CANMOVE|SFGAO_CANLINK|SFGAO_CANRENAME|SFGAO_CANDELETE|
1122                     SFGAO_HASPROPSHEET|SFGAO_DROPTARGET|SFGAO_FILESYSTEM;
1123         lstrcpyA(szAbsolutePath, This->m_pszPath);
1124         pszRelativePath = szAbsolutePath + lstrlenA(szAbsolutePath);
1125         for (i=0; i<cidl; i++) {
1126             if (!(This->m_dwAttributes & SFGAO_FILESYSTEM)) {
1127                 WCHAR *dos_name;
1128                 if (!UNIXFS_filename_from_shitemid(apidl[i], pszRelativePath))
1129                     return E_INVALIDARG;
1130                 if (!(dos_name = wine_get_dos_file_name( szAbsolutePath )))
1131                     *rgfInOut &= ~SFGAO_FILESYSTEM;
1132                 else
1133                     HeapFree( GetProcessHeap(), 0, dos_name );
1134             }
1135             if (_ILIsFolder(apidl[i]))
1136                 *rgfInOut |= SFGAO_FOLDER|SFGAO_HASSUBFOLDER|SFGAO_FILESYSANCESTOR;
1137         }
1138     }
1139
1140     return hr;
1141 }
1142
1143 static HRESULT WINAPI UnixFolder_IShellFolder2_GetUIObjectOf(IShellFolder2* iface, HWND hwndOwner,
1144     UINT cidl, LPCITEMIDLIST* apidl, REFIID riid, UINT* prgfInOut, void** ppvOut)
1145 {
1146     UnixFolder *This = ADJUST_THIS(UnixFolder, IShellFolder2, iface);
1147     UINT i;
1148     HRESULT hr;
1149
1150     TRACE("(iface=%p, hwndOwner=%p, cidl=%d, apidl=%p, riid=%s, prgfInOut=%p, ppv=%p)\n",
1151         iface, hwndOwner, cidl, apidl, debugstr_guid(riid), prgfInOut, ppvOut);
1152
1153     if (!cidl || !apidl || !riid || !ppvOut)
1154         return E_INVALIDARG;
1155
1156     for (i=0; i<cidl; i++)
1157         if (!apidl[i])
1158             return E_INVALIDARG;
1159
1160     if(cidl == 1) {
1161         hr = SHELL32_CreateExtensionUIObject(iface, *apidl, riid, ppvOut);
1162         if(hr != S_FALSE)
1163             return hr;
1164     }
1165
1166     if (IsEqualIID(&IID_IContextMenu, riid)) {
1167         *ppvOut = ISvItemCm_Constructor((IShellFolder*)iface, This->m_pidlLocation, apidl, cidl);
1168         return S_OK;
1169     } else if (IsEqualIID(&IID_IDataObject, riid)) {
1170         *ppvOut = IDataObject_Constructor(hwndOwner, This->m_pidlLocation, apidl, cidl);
1171         return S_OK;
1172     } else if (IsEqualIID(&IID_IExtractIconA, riid)) {
1173         LPITEMIDLIST pidl;
1174         if (cidl != 1) return E_INVALIDARG;
1175         pidl = ILCombine(This->m_pidlLocation, apidl[0]);
1176         *ppvOut = IExtractIconA_Constructor(pidl);
1177         SHFree(pidl);
1178         return S_OK;
1179     } else if (IsEqualIID(&IID_IExtractIconW, riid)) {
1180         LPITEMIDLIST pidl;
1181         if (cidl != 1) return E_INVALIDARG;
1182         pidl = ILCombine(This->m_pidlLocation, apidl[0]);
1183         *ppvOut = IExtractIconW_Constructor(pidl);
1184         SHFree(pidl);
1185         return S_OK;
1186     } else if (IsEqualIID(&IID_IDropTarget, riid)) {
1187         if (cidl != 1) return E_INVALIDARG;
1188         return IShellFolder2_BindToObject(iface, apidl[0], NULL, &IID_IDropTarget, ppvOut);
1189     } else if (IsEqualIID(&IID_IShellLinkW, riid)) {
1190         FIXME("IShellLinkW\n");
1191         return E_FAIL;
1192     } else if (IsEqualIID(&IID_IShellLinkA, riid)) {
1193         FIXME("IShellLinkA\n");
1194         return E_FAIL;
1195     } else {
1196         FIXME("Unknown interface %s in GetUIObjectOf\n", debugstr_guid(riid));
1197         return E_NOINTERFACE;
1198     }
1199 }
1200
1201 static HRESULT WINAPI UnixFolder_IShellFolder2_GetDisplayNameOf(IShellFolder2* iface,
1202     LPCITEMIDLIST pidl, SHGDNF uFlags, STRRET* lpName)
1203 {
1204     UnixFolder *This = ADJUST_THIS(UnixFolder, IShellFolder2, iface);
1205     SHITEMID emptyIDL = { 0, { 0 } };
1206     HRESULT hr = S_OK;
1207
1208     TRACE("(iface=%p, pidl=%p, uFlags=%x, lpName=%p)\n", iface, pidl, uFlags, lpName);
1209
1210     if ((GET_SHGDN_FOR(uFlags) & SHGDN_FORPARSING) &&
1211         (GET_SHGDN_RELATION(uFlags) != SHGDN_INFOLDER))
1212     {
1213         if (_ILIsEmpty(pidl)) {
1214             lpName->uType = STRRET_WSTR;
1215             if (This->m_dwPathMode == PATHMODE_UNIX) {
1216                 UINT len = MultiByteToWideChar(CP_UNIXCP, 0, This->m_pszPath, -1, NULL, 0);
1217                 lpName->u.pOleStr = SHAlloc(len * sizeof(WCHAR));
1218                 if (!lpName->u.pOleStr) return HRESULT_FROM_WIN32(GetLastError());
1219                 MultiByteToWideChar(CP_UNIXCP, 0, This->m_pszPath, -1, lpName->u.pOleStr, len);
1220             } else {
1221                 LPWSTR pwszDosFileName = wine_get_dos_file_name(This->m_pszPath);
1222                 if (!pwszDosFileName) return HRESULT_FROM_WIN32(GetLastError());
1223                 lpName->u.pOleStr = SHAlloc((lstrlenW(pwszDosFileName) + 1) * sizeof(WCHAR));
1224                 if (!lpName->u.pOleStr) return HRESULT_FROM_WIN32(GetLastError());
1225                 lstrcpyW(lpName->u.pOleStr, pwszDosFileName);
1226                 PathRemoveBackslashW(lpName->u.pOleStr);
1227                 HeapFree(GetProcessHeap(), 0, pwszDosFileName);
1228             }
1229         } else if (_ILIsValue(pidl)) {
1230             STRRET str;
1231             PWSTR path, file;
1232
1233             /* We are looking for the complete path to a file */
1234
1235             /* Get the complete path for the current folder object */
1236             hr = IShellFolder_GetDisplayNameOf(iface, (LPITEMIDLIST)&emptyIDL, uFlags, &str);
1237             if (SUCCEEDED(hr)) {
1238                 hr = StrRetToStrW(&str, NULL, &path);
1239                 if (SUCCEEDED(hr)) {
1240
1241                     /* Get the child filename */
1242                     hr = IShellFolder_GetDisplayNameOf(iface, pidl, SHGDN_FORPARSING | SHGDN_INFOLDER, &str);
1243                     if (SUCCEEDED(hr)) {
1244                         hr = StrRetToStrW(&str, NULL, &file);
1245                         if (SUCCEEDED(hr)) {
1246                             static const WCHAR slashW = '/';
1247                             UINT len_path = strlenW(path), len_file = strlenW(file);
1248
1249                             /* Now, combine them */
1250                             lpName->uType = STRRET_WSTR;
1251                             lpName->u.pOleStr = SHAlloc( (len_path + len_file + 2)*sizeof(WCHAR) );
1252                             lstrcpyW(lpName->u.pOleStr, path);
1253                             if (This->m_dwPathMode == PATHMODE_UNIX &&
1254                                lpName->u.pOleStr[len_path-1] != slashW) {
1255                                 lpName->u.pOleStr[len_path] = slashW;
1256                                 lpName->u.pOleStr[len_path+1] = '\0';
1257                             } else
1258                                 PathAddBackslashW(lpName->u.pOleStr);
1259                             lstrcatW(lpName->u.pOleStr, file);
1260
1261                             CoTaskMemFree(file);
1262                         } else
1263                             WARN("Failed to convert strret (file)\n");
1264                     }
1265                     CoTaskMemFree(path);
1266                 } else
1267                     WARN("Failed to convert strret (path)\n");
1268             }
1269         } else {
1270             IShellFolder *pSubFolder;
1271
1272             hr = IShellFolder_BindToObject(iface, pidl, NULL, &IID_IShellFolder, (void**)&pSubFolder);
1273             if (SUCCEEDED(hr)) {
1274                 hr = IShellFolder_GetDisplayNameOf(pSubFolder, (LPITEMIDLIST)&emptyIDL, uFlags, lpName);
1275                 IShellFolder_Release(pSubFolder);
1276             } else if (FAILED(hr) && !_ILIsPidlSimple(pidl)) {
1277                 LPITEMIDLIST pidl_parent = ILClone(pidl);
1278                 LPITEMIDLIST pidl_child = ILFindLastID(pidl);
1279
1280                 /* Might be a file, try binding to its parent */
1281                 ILRemoveLastID(pidl_parent);
1282                 hr = IShellFolder_BindToObject(iface, pidl_parent, NULL, &IID_IShellFolder, (void**)&pSubFolder);
1283                 if (SUCCEEDED(hr)) {
1284                     hr = IShellFolder_GetDisplayNameOf(pSubFolder, pidl_child, uFlags, lpName);
1285                     IShellFolder_Release(pSubFolder);
1286                 }
1287                 ILFree(pidl_parent);
1288             }
1289         }
1290     } else {
1291         WCHAR wszFileName[MAX_PATH];
1292         if (!_ILSimpleGetTextW(pidl, wszFileName, MAX_PATH)) return E_INVALIDARG;
1293         lpName->uType = STRRET_WSTR;
1294         lpName->u.pOleStr = SHAlloc((lstrlenW(wszFileName)+1)*sizeof(WCHAR));
1295         if (!lpName->u.pOleStr) return HRESULT_FROM_WIN32(GetLastError());
1296         lstrcpyW(lpName->u.pOleStr, wszFileName);
1297         if (!(GET_SHGDN_FOR(uFlags) & SHGDN_FORPARSING) && This->m_dwPathMode == PATHMODE_DOS &&
1298             !_ILIsFolder(pidl) && wszFileName[0] != '.' && SHELL_FS_HideExtension(wszFileName))
1299         {
1300             PathRemoveExtensionW(lpName->u.pOleStr);
1301         }
1302     }
1303
1304     TRACE("--> %s\n", debugstr_w(lpName->u.pOleStr));
1305
1306     return hr;
1307 }
1308
1309 static HRESULT WINAPI UnixFolder_IShellFolder2_SetNameOf(IShellFolder2* iface, HWND hwnd,
1310     LPCITEMIDLIST pidl, LPCOLESTR lpcwszName, SHGDNF uFlags, LPITEMIDLIST* ppidlOut)
1311 {
1312     UnixFolder *This = ADJUST_THIS(UnixFolder, IShellFolder2, iface);
1313
1314     static const WCHAR awcInvalidChars[] = { '\\', '/', ':', '*', '?', '"', '<', '>', '|' };
1315     char szSrc[FILENAME_MAX], szDest[FILENAME_MAX];
1316     WCHAR wszSrcRelative[MAX_PATH], *pwszExt = NULL;
1317     unsigned int i;
1318     int cBasePathLen = lstrlenA(This->m_pszPath), cNameLen;
1319     struct stat statDest;
1320     LPITEMIDLIST pidlSrc, pidlDest, pidlRelativeDest;
1321     LPOLESTR lpwszName;
1322     HRESULT hr;
1323
1324     TRACE("(iface=%p, hwnd=%p, pidl=%p, lpcwszName=%s, uFlags=0x%08x, ppidlOut=%p)\n",
1325           iface, hwnd, pidl, debugstr_w(lpcwszName), uFlags, ppidlOut);
1326
1327     /* prepare to fail */
1328     if (ppidlOut)
1329         *ppidlOut = NULL;
1330
1331     /* pidl has to contain a single non-empty SHITEMID */
1332     if (_ILIsDesktop(pidl) || !_ILIsPidlSimple(pidl) || !_ILGetTextPointer(pidl))
1333         return E_INVALIDARG;
1334
1335     /* check for invalid characters in lpcwszName. */
1336     for (i=0; i < sizeof(awcInvalidChars)/sizeof(*awcInvalidChars); i++)
1337         if (StrChrW(lpcwszName, awcInvalidChars[i]))
1338             return HRESULT_FROM_WIN32(ERROR_CANCELLED);
1339
1340     /* build source path */
1341     memcpy(szSrc, This->m_pszPath, cBasePathLen);
1342     UNIXFS_filename_from_shitemid(pidl, szSrc + cBasePathLen);
1343
1344     /* build destination path */
1345     memcpy(szDest, This->m_pszPath, cBasePathLen);
1346     WideCharToMultiByte(CP_UNIXCP, 0, lpcwszName, -1, szDest+cBasePathLen,
1347                         FILENAME_MAX-cBasePathLen, NULL, NULL);
1348
1349     /* If the filename's extension is hidden to the user, we have to append it. */
1350     if (!(uFlags & SHGDN_FORPARSING) &&
1351         _ILSimpleGetTextW(pidl, wszSrcRelative, MAX_PATH) &&
1352         SHELL_FS_HideExtension(wszSrcRelative))
1353     {
1354         int cLenDest = strlen(szDest);
1355         pwszExt = PathFindExtensionW(wszSrcRelative);
1356         WideCharToMultiByte(CP_UNIXCP, 0, pwszExt, -1, szDest + cLenDest,
1357             FILENAME_MAX - cLenDest, NULL, NULL);
1358     }
1359
1360     TRACE("src=%s dest=%s\n", szSrc, szDest);
1361
1362     /* Fail, if destination does already exist */
1363     if (!stat(szDest, &statDest))
1364         return E_FAIL;
1365
1366     /* Rename the file */
1367     if (rename(szSrc, szDest))
1368         return E_FAIL;
1369
1370     /* Build a pidl for the path of the renamed file */
1371     cNameLen = lstrlenW(lpcwszName) + 1;
1372     if(pwszExt)
1373         cNameLen += lstrlenW(pwszExt);
1374     lpwszName = SHAlloc(cNameLen*sizeof(WCHAR)); /* due to const correctness. */
1375     lstrcpyW(lpwszName, lpcwszName);
1376     if(pwszExt)
1377         lstrcatW(lpwszName, pwszExt);
1378
1379     hr = IShellFolder2_ParseDisplayName(iface, NULL, NULL, lpwszName, NULL, &pidlRelativeDest, NULL);
1380     SHFree(lpwszName);
1381     if (FAILED(hr)) {
1382         rename(szDest, szSrc); /* Undo the renaming */
1383         return E_FAIL;
1384     }
1385     pidlDest = ILCombine(This->m_pidlLocation, pidlRelativeDest);
1386     ILFree(pidlRelativeDest);
1387     pidlSrc = ILCombine(This->m_pidlLocation, pidl);
1388
1389     /* Inform the shell */
1390     if (_ILIsFolder(ILFindLastID(pidlDest)))
1391         SHChangeNotify(SHCNE_RENAMEFOLDER, SHCNF_IDLIST, pidlSrc, pidlDest);
1392     else
1393         SHChangeNotify(SHCNE_RENAMEITEM, SHCNF_IDLIST, pidlSrc, pidlDest);
1394
1395     if (ppidlOut)
1396         *ppidlOut = ILClone(ILFindLastID(pidlDest));
1397
1398     ILFree(pidlSrc);
1399     ILFree(pidlDest);
1400
1401     return S_OK;
1402 }
1403
1404 static HRESULT WINAPI UnixFolder_IShellFolder2_EnumSearches(IShellFolder2* iface,
1405     IEnumExtraSearch **ppEnum)
1406 {
1407     FIXME("stub\n");
1408     return E_NOTIMPL;
1409 }
1410
1411 static HRESULT WINAPI UnixFolder_IShellFolder2_GetDefaultColumn(IShellFolder2* iface,
1412     DWORD dwReserved, ULONG *pSort, ULONG *pDisplay)
1413 {
1414     TRACE("(iface=%p,dwReserved=%x,pSort=%p,pDisplay=%p)\n", iface, dwReserved, pSort, pDisplay);
1415
1416     if (pSort)
1417         *pSort = 0;
1418     if (pDisplay)
1419         *pDisplay = 0;
1420
1421     return S_OK;
1422 }
1423
1424 static HRESULT WINAPI UnixFolder_IShellFolder2_GetDefaultColumnState(IShellFolder2* iface,
1425     UINT iColumn, SHCOLSTATEF *pcsFlags)
1426 {
1427     FIXME("stub\n");
1428     return E_NOTIMPL;
1429 }
1430
1431 static HRESULT WINAPI UnixFolder_IShellFolder2_GetDefaultSearchGUID(IShellFolder2* iface,
1432     GUID *pguid)
1433 {
1434     FIXME("stub\n");
1435     return E_NOTIMPL;
1436 }
1437
1438 static HRESULT WINAPI UnixFolder_IShellFolder2_GetDetailsEx(IShellFolder2* iface,
1439     LPCITEMIDLIST pidl, const SHCOLUMNID *pscid, VARIANT *pv)
1440 {
1441     FIXME("stub\n");
1442     return E_NOTIMPL;
1443 }
1444
1445 #define SHELLVIEWCOLUMNS 7
1446
1447 static HRESULT WINAPI UnixFolder_IShellFolder2_GetDetailsOf(IShellFolder2* iface,
1448     LPCITEMIDLIST pidl, UINT iColumn, SHELLDETAILS *psd)
1449 {
1450     UnixFolder *This = ADJUST_THIS(UnixFolder, IShellFolder2, iface);
1451     HRESULT hr = E_FAIL;
1452     struct passwd *pPasswd;
1453     struct group *pGroup;
1454     struct stat statItem;
1455
1456     static const shvheader unixfs_header[SHELLVIEWCOLUMNS] = {
1457         {IDS_SHV_COLUMN1,  SHCOLSTATE_TYPE_STR  | SHCOLSTATE_ONBYDEFAULT, LVCFMT_RIGHT, 15},
1458         {IDS_SHV_COLUMN2,  SHCOLSTATE_TYPE_STR  | SHCOLSTATE_ONBYDEFAULT, LVCFMT_RIGHT, 10},
1459         {IDS_SHV_COLUMN3,  SHCOLSTATE_TYPE_STR  | SHCOLSTATE_ONBYDEFAULT, LVCFMT_RIGHT, 10},
1460         {IDS_SHV_COLUMN4,  SHCOLSTATE_TYPE_DATE | SHCOLSTATE_ONBYDEFAULT, LVCFMT_RIGHT, 12},
1461         {IDS_SHV_COLUMN5,  SHCOLSTATE_TYPE_STR  | SHCOLSTATE_ONBYDEFAULT, LVCFMT_RIGHT, 9},
1462         {IDS_SHV_COLUMN10, SHCOLSTATE_TYPE_STR  | SHCOLSTATE_ONBYDEFAULT, LVCFMT_RIGHT, 7},
1463         {IDS_SHV_COLUMN11, SHCOLSTATE_TYPE_STR  | SHCOLSTATE_ONBYDEFAULT, LVCFMT_RIGHT, 7}
1464     };
1465
1466     TRACE("(iface=%p, pidl=%p, iColumn=%d, psd=%p) stub\n", iface, pidl, iColumn, psd);
1467
1468     if (!psd || iColumn >= SHELLVIEWCOLUMNS)
1469         return E_INVALIDARG;
1470
1471     if (!pidl)
1472         return SHELL32_GetColumnDetails(unixfs_header, iColumn, psd);
1473
1474     if (iColumn == 4 || iColumn == 5 || iColumn == 6) {
1475         char szPath[FILENAME_MAX];
1476         strcpy(szPath, This->m_pszPath);
1477         if (!UNIXFS_filename_from_shitemid(pidl, szPath + strlen(szPath)))
1478             return E_INVALIDARG;
1479         if (stat(szPath, &statItem))
1480             return E_INVALIDARG;
1481     }
1482
1483     psd->str.u.cStr[0] = '\0';
1484     psd->str.uType = STRRET_CSTR;
1485
1486     switch (iColumn) {
1487         case 0:
1488             hr = IShellFolder2_GetDisplayNameOf(iface, pidl, SHGDN_NORMAL|SHGDN_INFOLDER, &psd->str);
1489             break;
1490         case 1:
1491             _ILGetFileSize(pidl, psd->str.u.cStr, MAX_PATH);
1492             break;
1493         case 2:
1494             _ILGetFileType (pidl, psd->str.u.cStr, MAX_PATH);
1495             break;
1496         case 3:
1497             _ILGetFileDate(pidl, psd->str.u.cStr, MAX_PATH);
1498             break;
1499         case 4:
1500             psd->str.u.cStr[0] = S_ISDIR(statItem.st_mode) ? 'd' : '-';
1501             psd->str.u.cStr[1] = (statItem.st_mode & S_IRUSR) ? 'r' : '-';
1502             psd->str.u.cStr[2] = (statItem.st_mode & S_IWUSR) ? 'w' : '-';
1503             psd->str.u.cStr[3] = (statItem.st_mode & S_IXUSR) ? 'x' : '-';
1504             psd->str.u.cStr[4] = (statItem.st_mode & S_IRGRP) ? 'r' : '-';
1505             psd->str.u.cStr[5] = (statItem.st_mode & S_IWGRP) ? 'w' : '-';
1506             psd->str.u.cStr[6] = (statItem.st_mode & S_IXGRP) ? 'x' : '-';
1507             psd->str.u.cStr[7] = (statItem.st_mode & S_IROTH) ? 'r' : '-';
1508             psd->str.u.cStr[8] = (statItem.st_mode & S_IWOTH) ? 'w' : '-';
1509             psd->str.u.cStr[9] = (statItem.st_mode & S_IXOTH) ? 'x' : '-';
1510             psd->str.u.cStr[10] = '\0';
1511             break;
1512         case 5:
1513             pPasswd = getpwuid(statItem.st_uid);
1514             if (pPasswd) strcpy(psd->str.u.cStr, pPasswd->pw_name);
1515             break;
1516         case 6:
1517             pGroup = getgrgid(statItem.st_gid);
1518             if (pGroup) strcpy(psd->str.u.cStr, pGroup->gr_name);
1519             break;
1520     }
1521
1522     return hr;
1523 }
1524
1525 static HRESULT WINAPI UnixFolder_IShellFolder2_MapColumnToSCID(IShellFolder2* iface, UINT iColumn,
1526     SHCOLUMNID *pscid)
1527 {
1528     FIXME("stub\n");
1529     return E_NOTIMPL;
1530 }
1531
1532 /* VTable for UnixFolder's IShellFolder2 interface.
1533  */
1534 static const IShellFolder2Vtbl UnixFolder_IShellFolder2_Vtbl = {
1535     UnixFolder_IShellFolder2_QueryInterface,
1536     UnixFolder_IShellFolder2_AddRef,
1537     UnixFolder_IShellFolder2_Release,
1538     UnixFolder_IShellFolder2_ParseDisplayName,
1539     UnixFolder_IShellFolder2_EnumObjects,
1540     UnixFolder_IShellFolder2_BindToObject,
1541     UnixFolder_IShellFolder2_BindToStorage,
1542     UnixFolder_IShellFolder2_CompareIDs,
1543     UnixFolder_IShellFolder2_CreateViewObject,
1544     UnixFolder_IShellFolder2_GetAttributesOf,
1545     UnixFolder_IShellFolder2_GetUIObjectOf,
1546     UnixFolder_IShellFolder2_GetDisplayNameOf,
1547     UnixFolder_IShellFolder2_SetNameOf,
1548     UnixFolder_IShellFolder2_GetDefaultSearchGUID,
1549     UnixFolder_IShellFolder2_EnumSearches,
1550     UnixFolder_IShellFolder2_GetDefaultColumn,
1551     UnixFolder_IShellFolder2_GetDefaultColumnState,
1552     UnixFolder_IShellFolder2_GetDetailsEx,
1553     UnixFolder_IShellFolder2_GetDetailsOf,
1554     UnixFolder_IShellFolder2_MapColumnToSCID
1555 };
1556
1557 static HRESULT WINAPI UnixFolder_IPersistFolder3_QueryInterface(IPersistFolder3* iface, REFIID riid,
1558     void** ppvObject)
1559 {
1560     return UnixFolder_IShellFolder2_QueryInterface(
1561         STATIC_CAST(IShellFolder2, ADJUST_THIS(UnixFolder, IPersistFolder3, iface)), riid, ppvObject);
1562 }
1563
1564 static ULONG WINAPI UnixFolder_IPersistFolder3_AddRef(IPersistFolder3* iface)
1565 {
1566     return UnixFolder_IShellFolder2_AddRef(
1567         STATIC_CAST(IShellFolder2, ADJUST_THIS(UnixFolder, IPersistFolder3, iface)));
1568 }
1569
1570 static ULONG WINAPI UnixFolder_IPersistFolder3_Release(IPersistFolder3* iface)
1571 {
1572     return UnixFolder_IShellFolder2_Release(
1573         STATIC_CAST(IShellFolder2, ADJUST_THIS(UnixFolder, IPersistFolder3, iface)));
1574 }
1575
1576 static HRESULT WINAPI UnixFolder_IPersistFolder3_GetClassID(IPersistFolder3* iface, CLSID* pClassID)
1577 {
1578     UnixFolder *This = ADJUST_THIS(UnixFolder, IPersistFolder3, iface);
1579
1580     TRACE("(iface=%p, pClassId=%p)\n", iface, pClassID);
1581
1582     if (!pClassID)
1583         return E_INVALIDARG;
1584
1585     *pClassID = *This->m_pCLSID;
1586     return S_OK;
1587 }
1588
1589 static HRESULT WINAPI UnixFolder_IPersistFolder3_Initialize(IPersistFolder3* iface, LPCITEMIDLIST pidl)
1590 {
1591     UnixFolder *This = ADJUST_THIS(UnixFolder, IPersistFolder3, iface);
1592     LPCITEMIDLIST current = pidl;
1593     char szBasePath[FILENAME_MAX] = "/";
1594
1595     TRACE("(iface=%p, pidl=%p)\n", iface, pidl);
1596
1597     /* Find the UnixFolderClass root */
1598     while (current->mkid.cb) {
1599         if ((_ILIsDrive(current) && IsEqualCLSID(This->m_pCLSID, &CLSID_ShellFSFolder)) ||
1600             (_ILIsSpecialFolder(current) && IsEqualCLSID(This->m_pCLSID, _ILGetGUIDPointer(current))))
1601         {
1602             break;
1603         }
1604         current = ILGetNext(current);
1605     }
1606
1607     if (current->mkid.cb) {
1608         if (_ILIsDrive(current)) {
1609             WCHAR wszDrive[4] = { '?', ':', '\\', 0 };
1610             wszDrive[0] = (WCHAR)*_ILGetTextPointer(current);
1611             if (!UNIXFS_get_unix_path(wszDrive, szBasePath))
1612                 return E_FAIL;
1613         } else if (IsEqualIID(&CLSID_MyDocuments, _ILGetGUIDPointer(current))) {
1614             WCHAR wszMyDocumentsPath[MAX_PATH];
1615             if (!SHGetSpecialFolderPathW(0, wszMyDocumentsPath, CSIDL_PERSONAL, FALSE))
1616                 return E_FAIL;
1617             PathAddBackslashW(wszMyDocumentsPath);
1618             if (!UNIXFS_get_unix_path(wszMyDocumentsPath, szBasePath))
1619                 return E_FAIL;
1620         }
1621         current = ILGetNext(current);
1622     } else if (_ILIsDesktop(pidl) || _ILIsValue(pidl) || _ILIsFolder(pidl)) {
1623         /* Path rooted at Desktop */
1624         WCHAR wszDesktopPath[MAX_PATH];
1625         if (!SHGetSpecialFolderPathW(0, wszDesktopPath, CSIDL_DESKTOPDIRECTORY, FALSE))
1626             return E_FAIL;
1627         PathAddBackslashW(wszDesktopPath);
1628         if (!UNIXFS_get_unix_path(wszDesktopPath, szBasePath))
1629             return E_FAIL;
1630         current = pidl;
1631     } else if (IsEqualCLSID(This->m_pCLSID, &CLSID_FolderShortcut)) {
1632         /* FolderShortcuts' Initialize method only sets the ITEMIDLIST, which
1633          * specifies the location in the shell namespace, but leaves the
1634          * target folder (m_pszPath) alone. See unit tests in tests/shlfolder.c */
1635         This->m_pidlLocation = ILClone(pidl);
1636         return S_OK;
1637     } else {
1638         ERR("Unknown pidl type!\n");
1639         pdump(pidl);
1640         return E_INVALIDARG;
1641     }
1642
1643     This->m_pidlLocation = ILClone(pidl);
1644     return UNIXFS_initialize_target_folder(This, szBasePath, current, 0);
1645 }
1646
1647 static HRESULT WINAPI UnixFolder_IPersistFolder3_GetCurFolder(IPersistFolder3* iface, LPITEMIDLIST* ppidl)
1648 {
1649     UnixFolder *This = ADJUST_THIS(UnixFolder, IPersistFolder3, iface);
1650
1651     TRACE ("(iface=%p, ppidl=%p)\n", iface, ppidl);
1652
1653     if (!ppidl)
1654         return E_POINTER;
1655     *ppidl = ILClone (This->m_pidlLocation);
1656     return S_OK;
1657 }
1658
1659 static HRESULT WINAPI UnixFolder_IPersistFolder3_InitializeEx(IPersistFolder3 *iface, IBindCtx *pbc,
1660     LPCITEMIDLIST pidlRoot, const PERSIST_FOLDER_TARGET_INFO *ppfti)
1661 {
1662     UnixFolder *This = ADJUST_THIS(UnixFolder, IPersistFolder3, iface);
1663     WCHAR wszTargetDosPath[MAX_PATH];
1664     char szTargetPath[FILENAME_MAX] = "";
1665
1666     TRACE("(iface=%p, pbc=%p, pidlRoot=%p, ppfti=%p)\n", iface, pbc, pidlRoot, ppfti);
1667
1668     /* If no PERSIST_FOLDER_TARGET_INFO is given InitializeEx is equivalent to Initialize. */
1669     if (!ppfti)
1670         return IPersistFolder3_Initialize(iface, pidlRoot);
1671
1672     if (ppfti->csidl != -1) {
1673         if (FAILED(SHGetFolderPathW(0, ppfti->csidl, NULL, 0, wszTargetDosPath)) ||
1674             !UNIXFS_get_unix_path(wszTargetDosPath, szTargetPath))
1675         {
1676             return E_FAIL;
1677         }
1678     } else if (*ppfti->szTargetParsingName) {
1679         lstrcpyW(wszTargetDosPath, ppfti->szTargetParsingName);
1680         PathAddBackslashW(wszTargetDosPath);
1681         if (!UNIXFS_get_unix_path(wszTargetDosPath, szTargetPath)) {
1682             return E_FAIL;
1683         }
1684     } else if (ppfti->pidlTargetFolder) {
1685         if (!SHGetPathFromIDListW(ppfti->pidlTargetFolder, wszTargetDosPath) ||
1686             !UNIXFS_get_unix_path(wszTargetDosPath, szTargetPath))
1687         {
1688             return E_FAIL;
1689         }
1690     } else {
1691         return E_FAIL;
1692     }
1693
1694     This->m_pszPath = SHAlloc(lstrlenA(szTargetPath)+1);
1695     if (!This->m_pszPath)
1696         return E_FAIL;
1697     lstrcpyA(This->m_pszPath, szTargetPath);
1698     This->m_pidlLocation = ILClone(pidlRoot);
1699     This->m_dwAttributes = (ppfti->dwAttributes != -1) ? ppfti->dwAttributes :
1700         (SFGAO_FOLDER|SFGAO_HASSUBFOLDER|SFGAO_FILESYSANCESTOR|SFGAO_CANRENAME|SFGAO_FILESYSTEM);
1701
1702     return S_OK;
1703 }
1704
1705 static HRESULT WINAPI UnixFolder_IPersistFolder3_GetFolderTargetInfo(IPersistFolder3 *iface,
1706     PERSIST_FOLDER_TARGET_INFO *ppfti)
1707 {
1708     FIXME("(iface=%p, ppfti=%p) stub\n", iface, ppfti);
1709     return E_NOTIMPL;
1710 }
1711
1712 /* VTable for UnixFolder's IPersistFolder interface.
1713  */
1714 static const IPersistFolder3Vtbl UnixFolder_IPersistFolder3_Vtbl = {
1715     UnixFolder_IPersistFolder3_QueryInterface,
1716     UnixFolder_IPersistFolder3_AddRef,
1717     UnixFolder_IPersistFolder3_Release,
1718     UnixFolder_IPersistFolder3_GetClassID,
1719     UnixFolder_IPersistFolder3_Initialize,
1720     UnixFolder_IPersistFolder3_GetCurFolder,
1721     UnixFolder_IPersistFolder3_InitializeEx,
1722     UnixFolder_IPersistFolder3_GetFolderTargetInfo
1723 };
1724
1725 static HRESULT WINAPI UnixFolder_IPersistPropertyBag_QueryInterface(IPersistPropertyBag* iface,
1726     REFIID riid, void** ppv)
1727 {
1728     return UnixFolder_IShellFolder2_QueryInterface(
1729         STATIC_CAST(IShellFolder2, ADJUST_THIS(UnixFolder, IPersistPropertyBag, iface)), riid, ppv);
1730 }
1731
1732 static ULONG WINAPI UnixFolder_IPersistPropertyBag_AddRef(IPersistPropertyBag* iface)
1733 {
1734     return UnixFolder_IShellFolder2_AddRef(
1735         STATIC_CAST(IShellFolder2, ADJUST_THIS(UnixFolder, IPersistPropertyBag, iface)));
1736 }
1737
1738 static ULONG WINAPI UnixFolder_IPersistPropertyBag_Release(IPersistPropertyBag* iface)
1739 {
1740     return UnixFolder_IShellFolder2_Release(
1741         STATIC_CAST(IShellFolder2, ADJUST_THIS(UnixFolder, IPersistPropertyBag, iface)));
1742 }
1743
1744 static HRESULT WINAPI UnixFolder_IPersistPropertyBag_GetClassID(IPersistPropertyBag* iface,
1745     CLSID* pClassID)
1746 {
1747     return UnixFolder_IPersistFolder3_GetClassID(
1748         STATIC_CAST(IPersistFolder3, ADJUST_THIS(UnixFolder, IPersistPropertyBag, iface)), pClassID);
1749 }
1750
1751 static HRESULT WINAPI UnixFolder_IPersistPropertyBag_InitNew(IPersistPropertyBag* iface)
1752 {
1753     FIXME("() stub\n");
1754     return E_NOTIMPL;
1755 }
1756
1757 static HRESULT WINAPI UnixFolder_IPersistPropertyBag_Load(IPersistPropertyBag *iface,
1758     IPropertyBag *pPropertyBag, IErrorLog *pErrorLog)
1759 {
1760      UnixFolder *This = ADJUST_THIS(UnixFolder, IPersistPropertyBag, iface);
1761      static const WCHAR wszTarget[] = { 'T','a','r','g','e','t', 0 }, wszNull[] = { 0 };
1762      PERSIST_FOLDER_TARGET_INFO pftiTarget;
1763      VARIANT var;
1764      HRESULT hr;
1765
1766      TRACE("(iface=%p, pPropertyBag=%p, pErrorLog=%p)\n", iface, pPropertyBag, pErrorLog);
1767
1768      if (!pPropertyBag)
1769          return E_POINTER;
1770
1771      /* Get 'Target' property from the property bag. */
1772      V_VT(&var) = VT_BSTR;
1773      hr = IPropertyBag_Read(pPropertyBag, wszTarget, &var, NULL);
1774      if (FAILED(hr))
1775          return E_FAIL;
1776      lstrcpyW(pftiTarget.szTargetParsingName, V_BSTR(&var));
1777      SysFreeString(V_BSTR(&var));
1778
1779      pftiTarget.pidlTargetFolder = NULL;
1780      lstrcpyW(pftiTarget.szNetworkProvider, wszNull);
1781      pftiTarget.dwAttributes = -1;
1782      pftiTarget.csidl = -1;
1783
1784      return UnixFolder_IPersistFolder3_InitializeEx(
1785                  STATIC_CAST(IPersistFolder3, This), NULL, NULL, &pftiTarget);
1786 }
1787
1788 static HRESULT WINAPI UnixFolder_IPersistPropertyBag_Save(IPersistPropertyBag *iface,
1789     IPropertyBag *pPropertyBag, BOOL fClearDirty, BOOL fSaveAllProperties)
1790 {
1791     FIXME("() stub\n");
1792     return E_NOTIMPL;
1793 }
1794
1795 /* VTable for UnixFolder's IPersistPropertyBag interface.
1796  */
1797 static const IPersistPropertyBagVtbl UnixFolder_IPersistPropertyBag_Vtbl = {
1798     UnixFolder_IPersistPropertyBag_QueryInterface,
1799     UnixFolder_IPersistPropertyBag_AddRef,
1800     UnixFolder_IPersistPropertyBag_Release,
1801     UnixFolder_IPersistPropertyBag_GetClassID,
1802     UnixFolder_IPersistPropertyBag_InitNew,
1803     UnixFolder_IPersistPropertyBag_Load,
1804     UnixFolder_IPersistPropertyBag_Save
1805 };
1806
1807 static HRESULT WINAPI UnixFolder_ISFHelper_QueryInterface(ISFHelper* iface, REFIID riid,
1808     void** ppvObject)
1809 {
1810     return UnixFolder_IShellFolder2_QueryInterface(
1811         STATIC_CAST(IShellFolder2, ADJUST_THIS(UnixFolder, ISFHelper, iface)), riid, ppvObject);
1812 }
1813
1814 static ULONG WINAPI UnixFolder_ISFHelper_AddRef(ISFHelper* iface)
1815 {
1816     return UnixFolder_IShellFolder2_AddRef(
1817         STATIC_CAST(IShellFolder2, ADJUST_THIS(UnixFolder, ISFHelper, iface)));
1818 }
1819
1820 static ULONG WINAPI UnixFolder_ISFHelper_Release(ISFHelper* iface)
1821 {
1822     return UnixFolder_IShellFolder2_Release(
1823         STATIC_CAST(IShellFolder2, ADJUST_THIS(UnixFolder, ISFHelper, iface)));
1824 }
1825
1826 static HRESULT WINAPI UnixFolder_ISFHelper_GetUniqueName(ISFHelper* iface, LPWSTR pwszName, UINT uLen)
1827 {
1828     UnixFolder *This = ADJUST_THIS(UnixFolder, ISFHelper, iface);
1829     IEnumIDList *pEnum;
1830     HRESULT hr;
1831     LPITEMIDLIST pidlElem;
1832     DWORD dwFetched;
1833     int i;
1834     WCHAR wszNewFolder[25];
1835     static const WCHAR wszFormat[] = { '%','s',' ','%','d',0 };
1836
1837     TRACE("(iface=%p, pwszName=%p, uLen=%u)\n", iface, pwszName, uLen);
1838
1839     LoadStringW(shell32_hInstance, IDS_NEWFOLDER, wszNewFolder, sizeof(wszNewFolder)/sizeof(WCHAR));
1840
1841     if (uLen < sizeof(wszNewFolder)/sizeof(WCHAR)+3)
1842         return E_INVALIDARG;
1843
1844     hr = IShellFolder2_EnumObjects(STATIC_CAST(IShellFolder2, This), 0,
1845                                    SHCONTF_FOLDERS|SHCONTF_NONFOLDERS|SHCONTF_INCLUDEHIDDEN, &pEnum);
1846     if (SUCCEEDED(hr)) {
1847         lstrcpynW(pwszName, wszNewFolder, uLen);
1848         IEnumIDList_Reset(pEnum);
1849         i = 2;
1850         while ((IEnumIDList_Next(pEnum, 1, &pidlElem, &dwFetched) == S_OK) && (dwFetched == 1)) {
1851             WCHAR wszTemp[MAX_PATH];
1852             _ILSimpleGetTextW(pidlElem, wszTemp, MAX_PATH);
1853             if (!lstrcmpiW(wszTemp, pwszName)) {
1854                 IEnumIDList_Reset(pEnum);
1855                 snprintfW(pwszName, uLen, wszFormat, wszNewFolder, i++);
1856                 if (i > 99) {
1857                     hr = E_FAIL;
1858                     break;
1859                 }
1860             }
1861         }
1862         IEnumIDList_Release(pEnum);
1863     }
1864     return hr;
1865 }
1866
1867 static HRESULT WINAPI UnixFolder_ISFHelper_AddFolder(ISFHelper* iface, HWND hwnd, LPCWSTR pwszName,
1868     LPITEMIDLIST* ppidlOut)
1869 {
1870     UnixFolder *This = ADJUST_THIS(UnixFolder, ISFHelper, iface);
1871     char szNewDir[FILENAME_MAX];
1872     int cBaseLen;
1873
1874     TRACE("(iface=%p, hwnd=%p, pwszName=%s, ppidlOut=%p)\n",
1875             iface, hwnd, debugstr_w(pwszName), ppidlOut);
1876
1877     if (ppidlOut)
1878         *ppidlOut = NULL;
1879
1880     if (!This->m_pszPath || !(This->m_dwAttributes & SFGAO_FILESYSTEM))
1881         return E_FAIL;
1882
1883     lstrcpynA(szNewDir, This->m_pszPath, FILENAME_MAX);
1884     cBaseLen = lstrlenA(szNewDir);
1885     WideCharToMultiByte(CP_UNIXCP, 0, pwszName, -1, szNewDir+cBaseLen, FILENAME_MAX-cBaseLen, 0, 0);
1886
1887     if (mkdir(szNewDir, 0777)) {
1888         char szMessage[256 + FILENAME_MAX];
1889         char szCaption[256];
1890
1891         LoadStringA(shell32_hInstance, IDS_CREATEFOLDER_DENIED, szCaption, sizeof(szCaption));
1892         sprintf(szMessage, szCaption, szNewDir);
1893         LoadStringA(shell32_hInstance, IDS_CREATEFOLDER_CAPTION, szCaption, sizeof(szCaption));
1894         MessageBoxA(hwnd, szMessage, szCaption, MB_OK | MB_ICONEXCLAMATION);
1895
1896         return E_FAIL;
1897     } else {
1898         LPITEMIDLIST pidlRelative;
1899
1900         /* Inform the shell */
1901         if (SUCCEEDED(UNIXFS_path_to_pidl(This, NULL, pwszName, &pidlRelative))) {
1902             LPITEMIDLIST pidlAbsolute = ILCombine(This->m_pidlLocation, pidlRelative);
1903             if (ppidlOut)
1904                 *ppidlOut = pidlRelative;
1905             else
1906                 ILFree(pidlRelative);
1907             SHChangeNotify(SHCNE_MKDIR, SHCNF_IDLIST, pidlAbsolute, NULL);
1908             ILFree(pidlAbsolute);
1909         } else return E_FAIL;
1910         return S_OK;
1911     }
1912 }
1913
1914 /*
1915  * Delete specified files by converting the path to DOS paths and calling
1916  * SHFileOperationW. If an error occurs it returns an error code. If the paths can't
1917  * be converted, S_FALSE is returned. In such situation DeleteItems will try to delete
1918  * the files using syscalls
1919  */
1920 static HRESULT UNIXFS_delete_with_shfileop(UnixFolder *This, UINT cidl, const LPCITEMIDLIST *apidl)
1921 {
1922     char szAbsolute[FILENAME_MAX], *pszRelative;
1923     LPWSTR wszPathsList, wszListPos;
1924     SHFILEOPSTRUCTW op;
1925     HRESULT ret;
1926     UINT i;
1927
1928     lstrcpyA(szAbsolute, This->m_pszPath);
1929     pszRelative = szAbsolute + lstrlenA(szAbsolute);
1930
1931     wszListPos = wszPathsList = HeapAlloc(GetProcessHeap(), 0, cidl*MAX_PATH*sizeof(WCHAR)+1);
1932     if (wszPathsList == NULL)
1933         return E_OUTOFMEMORY;
1934     for (i=0; i<cidl; i++) {
1935         LPWSTR wszDosPath;
1936
1937         if (!_ILIsFolder(apidl[i]) && !_ILIsValue(apidl[i]))
1938             continue;
1939         if (!UNIXFS_filename_from_shitemid(apidl[i], pszRelative))
1940         {
1941             HeapFree(GetProcessHeap(), 0, wszPathsList);
1942             return E_INVALIDARG;
1943         }
1944         wszDosPath = wine_get_dos_file_name(szAbsolute);
1945         if (wszDosPath == NULL || lstrlenW(wszDosPath) >= MAX_PATH)
1946         {
1947             HeapFree(GetProcessHeap(), 0, wszPathsList);
1948             HeapFree(GetProcessHeap(), 0, wszDosPath);
1949             return S_FALSE;
1950         }
1951         lstrcpyW(wszListPos, wszDosPath);
1952         wszListPos += lstrlenW(wszListPos)+1;
1953         HeapFree(GetProcessHeap(), 0, wszDosPath);
1954     }
1955     *wszListPos = 0;
1956
1957     ZeroMemory(&op, sizeof(op));
1958     op.hwnd = GetActiveWindow();
1959     op.wFunc = FO_DELETE;
1960     op.pFrom = wszPathsList;
1961     op.fFlags = FOF_ALLOWUNDO;
1962     if (!SHFileOperationW(&op))
1963     {
1964         WARN("SHFileOperationW failed\n");
1965         ret = E_FAIL;
1966     }
1967     else
1968         ret = S_OK;
1969
1970     HeapFree(GetProcessHeap(), 0, wszPathsList);
1971     return ret;
1972 }
1973
1974 static HRESULT UNIXFS_delete_with_syscalls(UnixFolder *This, UINT cidl, const LPCITEMIDLIST *apidl)
1975 {
1976     char szAbsolute[FILENAME_MAX], *pszRelative;
1977     static const WCHAR empty[] = {0};
1978     UINT i;
1979
1980     if (!SHELL_ConfirmYesNoW(GetActiveWindow(), ASK_DELETE_SELECTED, empty))
1981         return S_OK;
1982
1983     lstrcpyA(szAbsolute, This->m_pszPath);
1984     pszRelative = szAbsolute + lstrlenA(szAbsolute);
1985
1986     for (i=0; i<cidl; i++) {
1987         if (!UNIXFS_filename_from_shitemid(apidl[i], pszRelative))
1988             return E_INVALIDARG;
1989         if (_ILIsFolder(apidl[i])) {
1990             if (rmdir(szAbsolute))
1991                 return E_FAIL;
1992         } else if (_ILIsValue(apidl[i])) {
1993             if (unlink(szAbsolute))
1994                 return E_FAIL;
1995         }
1996     }
1997     return S_OK;
1998 }
1999
2000 static HRESULT WINAPI UnixFolder_ISFHelper_DeleteItems(ISFHelper* iface, UINT cidl,
2001     LPCITEMIDLIST* apidl)
2002 {
2003     UnixFolder *This = ADJUST_THIS(UnixFolder, ISFHelper, iface);
2004     char szAbsolute[FILENAME_MAX], *pszRelative;
2005     LPITEMIDLIST pidlAbsolute;
2006     HRESULT hr = S_OK;
2007     UINT i;
2008     struct stat st;
2009
2010     TRACE("(iface=%p, cidl=%d, apidl=%p)\n", iface, cidl, apidl);
2011
2012     hr = UNIXFS_delete_with_shfileop(This, cidl, apidl);
2013     if (hr == S_FALSE)
2014         hr = UNIXFS_delete_with_syscalls(This, cidl, apidl);
2015
2016     lstrcpyA(szAbsolute, This->m_pszPath);
2017     pszRelative = szAbsolute + lstrlenA(szAbsolute);
2018
2019     /* we need to manually send the notifies if the files doesn't exist */
2020     for (i=0; i<cidl; i++) {
2021         if (!UNIXFS_filename_from_shitemid(apidl[i], pszRelative))
2022             continue;
2023         pidlAbsolute = ILCombine(This->m_pidlLocation, apidl[i]);
2024         if (stat(szAbsolute, &st))
2025         {
2026             if (_ILIsFolder(apidl[i])) {
2027                 SHChangeNotify(SHCNE_RMDIR, SHCNF_IDLIST, pidlAbsolute, NULL);
2028             } else if (_ILIsValue(apidl[i])) {
2029                 SHChangeNotify(SHCNE_DELETE, SHCNF_IDLIST, pidlAbsolute, NULL);
2030             }
2031         }
2032         ILFree(pidlAbsolute);
2033     }
2034
2035     return hr;
2036 }
2037
2038 static HRESULT WINAPI UnixFolder_ISFHelper_CopyItems(ISFHelper* iface, IShellFolder *psfFrom,
2039     UINT cidl, LPCITEMIDLIST *apidl)
2040 {
2041     UnixFolder *This = ADJUST_THIS(UnixFolder, ISFHelper, iface);
2042     DWORD dwAttributes;
2043     UINT i;
2044     HRESULT hr;
2045     char szAbsoluteDst[FILENAME_MAX], *pszRelativeDst;
2046
2047     TRACE("(iface=%p, psfFrom=%p, cidl=%d, apidl=%p)\n", iface, psfFrom, cidl, apidl);
2048
2049     if (!psfFrom || !cidl || !apidl)
2050         return E_INVALIDARG;
2051
2052     /* All source items have to be filesystem items. */
2053     dwAttributes = SFGAO_FILESYSTEM;
2054     hr = IShellFolder_GetAttributesOf(psfFrom, cidl, apidl, &dwAttributes);
2055     if (FAILED(hr) || !(dwAttributes & SFGAO_FILESYSTEM))
2056         return E_INVALIDARG;
2057
2058     lstrcpyA(szAbsoluteDst, This->m_pszPath);
2059     pszRelativeDst = szAbsoluteDst + strlen(szAbsoluteDst);
2060
2061     for (i=0; i<cidl; i++) {
2062         WCHAR wszSrc[MAX_PATH];
2063         char szSrc[FILENAME_MAX];
2064         STRRET strret;
2065         HRESULT res;
2066         WCHAR *pwszDosSrc, *pwszDosDst;
2067
2068         /* Build the unix path of the current source item. */
2069         if (FAILED(IShellFolder_GetDisplayNameOf(psfFrom, apidl[i], SHGDN_FORPARSING, &strret)))
2070             return E_FAIL;
2071         if (FAILED(StrRetToBufW(&strret, apidl[i], wszSrc, MAX_PATH)))
2072             return E_FAIL;
2073         if (!UNIXFS_get_unix_path(wszSrc, szSrc))
2074             return E_FAIL;
2075
2076         /* Build the unix path of the current destination item */
2077         UNIXFS_filename_from_shitemid(apidl[i], pszRelativeDst);
2078
2079         pwszDosSrc = wine_get_dos_file_name(szSrc);
2080         pwszDosDst = wine_get_dos_file_name(szAbsoluteDst);
2081
2082         if (pwszDosSrc && pwszDosDst)
2083             res = UNIXFS_copy(pwszDosSrc, pwszDosDst);
2084         else
2085             res = E_OUTOFMEMORY;
2086
2087         HeapFree(GetProcessHeap(), 0, pwszDosSrc);
2088         HeapFree(GetProcessHeap(), 0, pwszDosDst);
2089
2090         if (res != S_OK)
2091             return res;
2092     }
2093     return S_OK;
2094 }
2095
2096 /* VTable for UnixFolder's ISFHelper interface
2097  */
2098 static const ISFHelperVtbl UnixFolder_ISFHelper_Vtbl = {
2099     UnixFolder_ISFHelper_QueryInterface,
2100     UnixFolder_ISFHelper_AddRef,
2101     UnixFolder_ISFHelper_Release,
2102     UnixFolder_ISFHelper_GetUniqueName,
2103     UnixFolder_ISFHelper_AddFolder,
2104     UnixFolder_ISFHelper_DeleteItems,
2105     UnixFolder_ISFHelper_CopyItems
2106 };
2107
2108 static HRESULT WINAPI UnixFolder_IDropTarget_QueryInterface(IDropTarget* iface, REFIID riid,
2109     void** ppvObject)
2110 {
2111     return UnixFolder_IShellFolder2_QueryInterface(
2112         STATIC_CAST(IShellFolder2, ADJUST_THIS(UnixFolder, IDropTarget, iface)), riid, ppvObject);
2113 }
2114
2115 static ULONG WINAPI UnixFolder_IDropTarget_AddRef(IDropTarget* iface)
2116 {
2117     return UnixFolder_IShellFolder2_AddRef(
2118         STATIC_CAST(IShellFolder2, ADJUST_THIS(UnixFolder, IDropTarget, iface)));
2119 }
2120
2121 static ULONG WINAPI UnixFolder_IDropTarget_Release(IDropTarget* iface)
2122 {
2123     return UnixFolder_IShellFolder2_Release(
2124         STATIC_CAST(IShellFolder2, ADJUST_THIS(UnixFolder, IDropTarget, iface)));
2125 }
2126
2127 #define HIDA_GetPIDLFolder(pida) (LPCITEMIDLIST)(((LPBYTE)pida)+(pida)->aoffset[0])
2128 #define HIDA_GetPIDLItem(pida, i) (LPCITEMIDLIST)(((LPBYTE)pida)+(pida)->aoffset[i+1])
2129
2130 static HRESULT WINAPI UnixFolder_IDropTarget_DragEnter(IDropTarget *iface, IDataObject *pDataObject,
2131     DWORD dwKeyState, POINTL pt, DWORD *pdwEffect)
2132 {
2133     UnixFolder *This = ADJUST_THIS(UnixFolder, IDropTarget, iface);
2134     FORMATETC format;
2135     STGMEDIUM medium;
2136
2137     TRACE("(iface=%p, pDataObject=%p, dwKeyState=%08x, pt={.x=%d, .y=%d}, pdwEffect=%p)\n",
2138         iface, pDataObject, dwKeyState, pt.x, pt.y, pdwEffect);
2139
2140     if (!pdwEffect || !pDataObject)
2141         return E_INVALIDARG;
2142
2143     /* Compute a mask of supported drop-effects for this shellfolder object and the given data
2144      * object. Dropping is only supported on folders, which represent filesystem locations. One
2145      * can't drop on file objects. And the 'move' drop effect is only supported, if the source
2146      * folder is not identical to the target folder. */
2147     This->m_dwDropEffectsMask = DROPEFFECT_NONE;
2148     InitFormatEtc(format, cfShellIDList, TYMED_HGLOBAL);
2149     if ((This->m_dwAttributes & SFGAO_FILESYSTEM) && /* Only drop to filesystem folders */
2150         _ILIsFolder(ILFindLastID(This->m_pidlLocation)) && /* Only drop to folders, not to files */
2151         SUCCEEDED(IDataObject_GetData(pDataObject, &format, &medium))) /* Only ShellIDList format */
2152     {
2153         LPIDA pidaShellIDList = GlobalLock(medium.u.hGlobal);
2154         This->m_dwDropEffectsMask |= DROPEFFECT_COPY|DROPEFFECT_LINK;
2155
2156         if (pidaShellIDList) { /* Files can only be moved between two different folders */
2157             if (!ILIsEqual(HIDA_GetPIDLFolder(pidaShellIDList), This->m_pidlLocation))
2158                 This->m_dwDropEffectsMask |= DROPEFFECT_MOVE;
2159             GlobalUnlock(medium.u.hGlobal);
2160         }
2161     }
2162
2163     *pdwEffect = KeyStateToDropEffect(dwKeyState) & This->m_dwDropEffectsMask;
2164
2165     return S_OK;
2166 }
2167
2168 static HRESULT WINAPI UnixFolder_IDropTarget_DragOver(IDropTarget *iface, DWORD dwKeyState,
2169     POINTL pt, DWORD *pdwEffect)
2170 {
2171     UnixFolder *This = ADJUST_THIS(UnixFolder, IDropTarget, iface);
2172
2173     TRACE("(iface=%p, dwKeyState=%08x, pt={.x=%d, .y=%d}, pdwEffect=%p)\n", iface, dwKeyState,
2174         pt.x, pt.y, pdwEffect);
2175
2176     if (!pdwEffect)
2177         return E_INVALIDARG;
2178
2179     *pdwEffect = KeyStateToDropEffect(dwKeyState) & This->m_dwDropEffectsMask;
2180
2181     return S_OK;
2182 }
2183
2184 static HRESULT WINAPI UnixFolder_IDropTarget_DragLeave(IDropTarget *iface) {
2185     UnixFolder *This = ADJUST_THIS(UnixFolder, IDropTarget, iface);
2186
2187     TRACE("(iface=%p)\n", iface);
2188
2189     This->m_dwDropEffectsMask = DROPEFFECT_NONE;
2190
2191     return S_OK;
2192 }
2193
2194 static HRESULT WINAPI UnixFolder_IDropTarget_Drop(IDropTarget *iface, IDataObject *pDataObject,
2195     DWORD dwKeyState, POINTL pt, DWORD *pdwEffect)
2196 {
2197     UnixFolder *This = ADJUST_THIS(UnixFolder, IDropTarget, iface);
2198     FORMATETC format;
2199     STGMEDIUM medium;
2200     HRESULT hr;
2201
2202     TRACE("(iface=%p, pDataObject=%p, dwKeyState=%d, pt={.x=%d, .y=%d}, pdwEffect=%p) semi-stub\n",
2203         iface, pDataObject, dwKeyState, pt.x, pt.y, pdwEffect);
2204
2205     InitFormatEtc(format, cfShellIDList, TYMED_HGLOBAL);
2206     hr = IDataObject_GetData(pDataObject, &format, &medium);
2207     if (FAILED(hr))
2208         return hr;
2209
2210     if (medium.tymed == TYMED_HGLOBAL) {
2211         IShellFolder *psfSourceFolder, *psfDesktopFolder;
2212         LPIDA pidaShellIDList = GlobalLock(medium.u.hGlobal);
2213         STRRET strret;
2214         UINT i;
2215
2216         if (!pidaShellIDList)
2217             return HRESULT_FROM_WIN32(GetLastError());
2218
2219         hr = SHGetDesktopFolder(&psfDesktopFolder);
2220         if (FAILED(hr)) {
2221             GlobalUnlock(medium.u.hGlobal);
2222             return hr;
2223         }
2224
2225         hr = IShellFolder_BindToObject(psfDesktopFolder, HIDA_GetPIDLFolder(pidaShellIDList), NULL,
2226                                        &IID_IShellFolder, (LPVOID*)&psfSourceFolder);
2227         IShellFolder_Release(psfDesktopFolder);
2228         if (FAILED(hr)) {
2229             GlobalUnlock(medium.u.hGlobal);
2230             return hr;
2231         }
2232
2233         for (i = 0; i < pidaShellIDList->cidl; i++) {
2234             WCHAR wszSourcePath[MAX_PATH];
2235
2236             hr = IShellFolder_GetDisplayNameOf(psfSourceFolder, HIDA_GetPIDLItem(pidaShellIDList, i),
2237                                                SHGDN_FORPARSING, &strret);
2238             if (FAILED(hr))
2239                 break;
2240
2241             hr = StrRetToBufW(&strret, NULL, wszSourcePath, MAX_PATH);
2242             if (FAILED(hr))
2243                 break;
2244
2245             switch (*pdwEffect) {
2246                 case DROPEFFECT_MOVE:
2247                     FIXME("Move %s to %s!\n", debugstr_w(wszSourcePath), This->m_pszPath);
2248                     break;
2249                 case DROPEFFECT_COPY:
2250                     FIXME("Copy %s to %s!\n", debugstr_w(wszSourcePath), This->m_pszPath);
2251                     break;
2252                 case DROPEFFECT_LINK:
2253                     FIXME("Link %s from %s!\n", debugstr_w(wszSourcePath), This->m_pszPath);
2254                     break;
2255             }
2256         }
2257
2258         IShellFolder_Release(psfSourceFolder);
2259         GlobalUnlock(medium.u.hGlobal);
2260         return hr;
2261     }
2262
2263     return E_NOTIMPL;
2264 }
2265
2266 /* VTable for UnixFolder's IDropTarget interface
2267  */
2268 static const IDropTargetVtbl UnixFolder_IDropTarget_Vtbl = {
2269     UnixFolder_IDropTarget_QueryInterface,
2270     UnixFolder_IDropTarget_AddRef,
2271     UnixFolder_IDropTarget_Release,
2272     UnixFolder_IDropTarget_DragEnter,
2273     UnixFolder_IDropTarget_DragOver,
2274     UnixFolder_IDropTarget_DragLeave,
2275     UnixFolder_IDropTarget_Drop
2276 };
2277
2278 /******************************************************************************
2279  * Unix[Dos]Folder_Constructor [Internal]
2280  *
2281  * PARAMS
2282  *  pUnkOuter [I] Outer class for aggregation. Currently ignored.
2283  *  riid      [I] Interface asked for by the client.
2284  *  ppv       [O] Pointer to an riid interface to the UnixFolder object.
2285  *
2286  * NOTES
2287  *  Those are the only functions exported from shfldr_unixfs.c. They are called from
2288  *  shellole.c's default class factory and thus have to exhibit a LPFNCREATEINSTANCE
2289  *  compatible signature.
2290  *
2291  *  The UnixDosFolder_Constructor sets the dwPathMode member to PATHMODE_DOS. This
2292  *  means that paths are converted from dos to unix and back at the interfaces.
2293  */
2294 static HRESULT CreateUnixFolder(IUnknown *pUnkOuter, REFIID riid, LPVOID *ppv, const CLSID *pCLSID)
2295 {
2296     HRESULT hr = E_FAIL;
2297     UnixFolder *pUnixFolder;
2298
2299     if (pUnkOuter) {
2300         FIXME("Aggregation not yet implemented!\n");
2301         return CLASS_E_NOAGGREGATION;
2302     }
2303
2304     pUnixFolder = SHAlloc((ULONG)sizeof(UnixFolder));
2305
2306     if(pUnixFolder) {
2307         pUnixFolder->lpIShellFolder2Vtbl = &UnixFolder_IShellFolder2_Vtbl;
2308         pUnixFolder->lpIPersistFolder3Vtbl = &UnixFolder_IPersistFolder3_Vtbl;
2309         pUnixFolder->lpIPersistPropertyBagVtbl = &UnixFolder_IPersistPropertyBag_Vtbl;
2310         pUnixFolder->lpISFHelperVtbl = &UnixFolder_ISFHelper_Vtbl;
2311         pUnixFolder->lpIDropTargetVtbl = &UnixFolder_IDropTarget_Vtbl;
2312         pUnixFolder->m_cRef = 0;
2313         pUnixFolder->m_pszPath = NULL;
2314         pUnixFolder->m_pidlLocation = NULL;
2315         pUnixFolder->m_dwPathMode = IsEqualCLSID(&CLSID_UnixFolder, pCLSID) ? PATHMODE_UNIX : PATHMODE_DOS;
2316         pUnixFolder->m_dwAttributes = 0;
2317         pUnixFolder->m_pCLSID = pCLSID;
2318         pUnixFolder->m_dwDropEffectsMask = DROPEFFECT_NONE;
2319
2320         UnixFolder_IShellFolder2_AddRef(STATIC_CAST(IShellFolder2, pUnixFolder));
2321         hr = UnixFolder_IShellFolder2_QueryInterface(STATIC_CAST(IShellFolder2, pUnixFolder), riid, ppv);
2322         UnixFolder_IShellFolder2_Release(STATIC_CAST(IShellFolder2, pUnixFolder));
2323     }
2324     return hr;
2325 }
2326
2327 HRESULT WINAPI UnixFolder_Constructor(IUnknown *pUnkOuter, REFIID riid, LPVOID *ppv) {
2328     TRACE("(pUnkOuter=%p, riid=%p, ppv=%p)\n", pUnkOuter, riid, ppv);
2329     return CreateUnixFolder(pUnkOuter, riid, ppv, &CLSID_UnixFolder);
2330 }
2331
2332 HRESULT WINAPI UnixDosFolder_Constructor(IUnknown *pUnkOuter, REFIID riid, LPVOID *ppv) {
2333     TRACE("(pUnkOuter=%p, riid=%p, ppv=%p)\n", pUnkOuter, riid, ppv);
2334     return CreateUnixFolder(pUnkOuter, riid, ppv, &CLSID_UnixDosFolder);
2335 }
2336
2337 HRESULT WINAPI FolderShortcut_Constructor(IUnknown *pUnkOuter, REFIID riid, LPVOID *ppv) {
2338     TRACE("(pUnkOuter=%p, riid=%p, ppv=%p)\n", pUnkOuter, riid, ppv);
2339     return CreateUnixFolder(pUnkOuter, riid, ppv, &CLSID_FolderShortcut);
2340 }
2341
2342 HRESULT WINAPI MyDocuments_Constructor(IUnknown *pUnkOuter, REFIID riid, LPVOID *ppv) {
2343     TRACE("(pUnkOuter=%p, riid=%p, ppv=%p)\n", pUnkOuter, riid, ppv);
2344     return CreateUnixFolder(pUnkOuter, riid, ppv, &CLSID_MyDocuments);
2345 }
2346
2347 /******************************************************************************
2348  * UnixSubFolderIterator
2349  *
2350  * Class whose heap based objects represent iterators over the sub-directories
2351  * of a given UnixFolder object.
2352  */
2353
2354 /* UnixSubFolderIterator object layout and typedef.
2355  */
2356 typedef struct _UnixSubFolderIterator {
2357     const IEnumIDListVtbl *lpIEnumIDListVtbl;
2358     LONG m_cRef;
2359     SHCONTF m_fFilter;
2360     DIR *m_dirFolder;
2361     char m_szFolder[FILENAME_MAX];
2362 } UnixSubFolderIterator;
2363
2364 static void UnixSubFolderIterator_Destroy(UnixSubFolderIterator *iterator) {
2365     TRACE("(iterator=%p)\n", iterator);
2366
2367     if (iterator->m_dirFolder)
2368         closedir(iterator->m_dirFolder);
2369     SHFree(iterator);
2370 }
2371
2372 static HRESULT WINAPI UnixSubFolderIterator_IEnumIDList_QueryInterface(IEnumIDList* iface,
2373     REFIID riid, void** ppv)
2374 {
2375     TRACE("(iface=%p, riid=%p, ppv=%p)\n", iface, riid, ppv);
2376
2377     if (!ppv) return E_INVALIDARG;
2378
2379     if (IsEqualIID(&IID_IUnknown, riid) || IsEqualIID(&IID_IEnumIDList, riid)) {
2380         *ppv = iface;
2381     } else {
2382         *ppv = NULL;
2383         return E_NOINTERFACE;
2384     }
2385
2386     IEnumIDList_AddRef(iface);
2387     return S_OK;
2388 }
2389
2390 static ULONG WINAPI UnixSubFolderIterator_IEnumIDList_AddRef(IEnumIDList* iface)
2391 {
2392     UnixSubFolderIterator *This = ADJUST_THIS(UnixSubFolderIterator, IEnumIDList, iface);
2393
2394     TRACE("(iface=%p)\n", iface);
2395
2396     return InterlockedIncrement(&This->m_cRef);
2397 }
2398
2399 static ULONG WINAPI UnixSubFolderIterator_IEnumIDList_Release(IEnumIDList* iface)
2400 {
2401     UnixSubFolderIterator *This = ADJUST_THIS(UnixSubFolderIterator, IEnumIDList, iface);
2402     ULONG cRef;
2403
2404     TRACE("(iface=%p)\n", iface);
2405
2406     cRef = InterlockedDecrement(&This->m_cRef);
2407
2408     if (!cRef)
2409         UnixSubFolderIterator_Destroy(This);
2410
2411     return cRef;
2412 }
2413
2414 static HRESULT WINAPI UnixSubFolderIterator_IEnumIDList_Next(IEnumIDList* iface, ULONG celt,
2415     LPITEMIDLIST* rgelt, ULONG* pceltFetched)
2416 {
2417     UnixSubFolderIterator *This = ADJUST_THIS(UnixSubFolderIterator, IEnumIDList, iface);
2418     ULONG i = 0;
2419
2420     /* This->m_dirFolder will be NULL if the user doesn't have access rights for the dir. */
2421     if (This->m_dirFolder) {
2422         char *pszRelativePath = This->m_szFolder + lstrlenA(This->m_szFolder);
2423         struct dirent *pDirEntry;
2424
2425         while (i < celt) {
2426             pDirEntry = readdir(This->m_dirFolder);
2427             if (!pDirEntry) break; /* No more entries */
2428             if (!strcmp(pDirEntry->d_name, ".") || !strcmp(pDirEntry->d_name, "..")) continue;
2429
2430             /* Temporarily build absolute path in This->m_szFolder. Then construct a pidl
2431              * and see if it passes the filter.
2432              */
2433             lstrcpyA(pszRelativePath, pDirEntry->d_name);
2434             rgelt[i] = SHAlloc(
2435                 UNIXFS_shitemid_len_from_filename(pszRelativePath, NULL, NULL)+sizeof(USHORT));
2436             if (!UNIXFS_build_shitemid(This->m_szFolder, TRUE, NULL, rgelt[i]) ||
2437                 !UNIXFS_is_pidl_of_type(rgelt[i], This->m_fFilter))
2438             {
2439                 SHFree(rgelt[i]);
2440                 continue;
2441             }
2442             memset(((PBYTE)rgelt[i])+rgelt[i]->mkid.cb, 0, sizeof(USHORT));
2443             i++;
2444         }
2445         *pszRelativePath = '\0'; /* Restore the original path in This->m_szFolder. */
2446     }
2447
2448     if (pceltFetched)
2449         *pceltFetched = i;
2450
2451     return (i == 0) ? S_FALSE : S_OK;
2452 }
2453
2454 static HRESULT WINAPI UnixSubFolderIterator_IEnumIDList_Skip(IEnumIDList* iface, ULONG celt)
2455 {
2456     LPITEMIDLIST *apidl;
2457     ULONG cFetched;
2458     HRESULT hr;
2459
2460     TRACE("(iface=%p, celt=%d)\n", iface, celt);
2461
2462     /* Call IEnumIDList::Next and delete the resulting pidls. */
2463     apidl = SHAlloc(celt * sizeof(LPITEMIDLIST));
2464     hr = IEnumIDList_Next(iface, celt, apidl, &cFetched);
2465     if (SUCCEEDED(hr))
2466         while (cFetched--)
2467             SHFree(apidl[cFetched]);
2468     SHFree(apidl);
2469
2470     return hr;
2471 }
2472
2473 static HRESULT WINAPI UnixSubFolderIterator_IEnumIDList_Reset(IEnumIDList* iface)
2474 {
2475     UnixSubFolderIterator *This = ADJUST_THIS(UnixSubFolderIterator, IEnumIDList, iface);
2476
2477     TRACE("(iface=%p)\n", iface);
2478
2479     if (This->m_dirFolder)
2480         rewinddir(This->m_dirFolder);
2481
2482     return S_OK;
2483 }
2484
2485 static HRESULT WINAPI UnixSubFolderIterator_IEnumIDList_Clone(IEnumIDList* This,
2486     IEnumIDList** ppenum)
2487 {
2488     FIXME("stub\n");
2489     return E_NOTIMPL;
2490 }
2491
2492 /* VTable for UnixSubFolderIterator's IEnumIDList interface.
2493  */
2494 static const IEnumIDListVtbl UnixSubFolderIterator_IEnumIDList_Vtbl = {
2495     UnixSubFolderIterator_IEnumIDList_QueryInterface,
2496     UnixSubFolderIterator_IEnumIDList_AddRef,
2497     UnixSubFolderIterator_IEnumIDList_Release,
2498     UnixSubFolderIterator_IEnumIDList_Next,
2499     UnixSubFolderIterator_IEnumIDList_Skip,
2500     UnixSubFolderIterator_IEnumIDList_Reset,
2501     UnixSubFolderIterator_IEnumIDList_Clone
2502 };
2503
2504 static IUnknown *UnixSubFolderIterator_Constructor(UnixFolder *pUnixFolder, SHCONTF fFilter) {
2505     UnixSubFolderIterator *iterator;
2506
2507     TRACE("(pUnixFolder=%p)\n", pUnixFolder);
2508
2509     iterator = SHAlloc((ULONG)sizeof(UnixSubFolderIterator));
2510     iterator->lpIEnumIDListVtbl = &UnixSubFolderIterator_IEnumIDList_Vtbl;
2511     iterator->m_cRef = 0;
2512     iterator->m_fFilter = fFilter;
2513     iterator->m_dirFolder = opendir(pUnixFolder->m_pszPath);
2514     lstrcpyA(iterator->m_szFolder, pUnixFolder->m_pszPath);
2515
2516     UnixSubFolderIterator_IEnumIDList_AddRef((IEnumIDList*)iterator);
2517
2518     return (IUnknown*)iterator;
2519 }
2520
2521 #else /* __MINGW32__ || _MSC_VER */
2522
2523 HRESULT WINAPI UnixFolder_Constructor(IUnknown *pUnkOuter, REFIID riid, LPVOID *ppv)
2524 {
2525     return E_NOTIMPL;
2526 }
2527
2528 HRESULT WINAPI UnixDosFolder_Constructor(IUnknown *pUnkOuter, REFIID riid, LPVOID *ppv)
2529 {
2530     return E_NOTIMPL;
2531 }
2532
2533 HRESULT WINAPI FolderShortcut_Constructor(IUnknown *pUnkOuter, REFIID riid, LPVOID *ppv)
2534 {
2535     return E_NOTIMPL;
2536 }
2537
2538 HRESULT WINAPI MyDocuments_Constructor(IUnknown *pUnkOuter, REFIID riid, LPVOID *ppv)
2539 {
2540     return E_NOTIMPL;
2541 }
2542
2543 #endif /* __MINGW32__ || _MSC_VER */
2544
2545 /******************************************************************************
2546  * UNIXFS_is_rooted_at_desktop [Internal]
2547  *
2548  * Checks if the unixfs namespace extension is rooted at desktop level.
2549  *
2550  * RETURNS
2551  *  TRUE, if unixfs is rooted at desktop level
2552  *  FALSE, if not.
2553  */
2554 BOOL UNIXFS_is_rooted_at_desktop(void) {
2555     HKEY hKey;
2556     WCHAR wszRootedAtDesktop[69 + CHARS_IN_GUID] = {
2557         'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\',
2558         'W','i','n','d','o','w','s','\\','C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
2559         'E','x','p','l','o','r','e','r','\\','D','e','s','k','t','o','p','\\',
2560         'N','a','m','e','S','p','a','c','e','\\',0 };
2561
2562     if (StringFromGUID2(&CLSID_UnixDosFolder, wszRootedAtDesktop + 69, CHARS_IN_GUID) &&
2563         RegOpenKeyExW(HKEY_LOCAL_MACHINE, wszRootedAtDesktop, 0, KEY_READ, &hKey) == ERROR_SUCCESS)
2564     {
2565         RegCloseKey(hKey);
2566         return TRUE;
2567     }
2568     return FALSE;
2569 }