reactos/base/shell/explorer/shell/shellfs.cpp

   1 /*
   2  * Copyright 2003, 2004, 2005, 2006 Martin Fuchs
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  17  */
  18
  19
  20  //
  21  // Explorer clone
  22  //
  23  // shellfs.cpp
  24  //
  25  // Martin Fuchs, 23.07.2003
  26  //
  27
  28
  29 #include <precomp.h>
  30
  31 bool ShellDirectory::fill_w32fdata_shell(LPCITEMIDLIST pidl, SFGAOF attribs, WIN32_FIND_DATA* pw32fdata, BY_HANDLE_FILE_INFORMATION* pbhfi, bool do_access)
  32 {
  33         CONTEXT("ShellDirectory::fill_w32fdata_shell()");
  34
  35         bool bhfi_valid = false;
  36
  37         if (do_access && !( (attribs&SFGAO_FILESYSTEM) && SUCCEEDED(
  38                                 SHGetDataFromIDList(_folder, pidl, SHGDFIL_FINDDATA, pw32fdata, sizeof(WIN32_FIND_DATA))) )) {
  39                 WIN32_FILE_ATTRIBUTE_DATA fad;
  40                 IDataObject* pDataObj;
  41
  42                 STGMEDIUM medium = {0, {0}, 0};
  43                 FORMATETC fmt = {(USHORT)g_Globals._cfStrFName, 0, DVASPECT_CONTENT, -1, TYMED_HGLOBAL};
  44
  45                 HRESULT hr = _folder->GetUIObjectOf(0, 1, &pidl, IID_IDataObject, 0, (LPVOID*)&pDataObj);
  46
  47                 if (SUCCEEDED(hr)) {
  48                         hr = pDataObj->GetData(&fmt, &medium);
  49
  50                         pDataObj->Release();
  51
  52                         if (SUCCEEDED(hr)) {
  53                                 LPCTSTR path = (LPCTSTR)GlobalLock(medium.UNION_MEMBER(hGlobal));
  54
  55                                 if (path) {
  56                                          // fill with drive names "C:", ...
  57                                         assert(_tcslen(path) < GlobalSize(medium.UNION_MEMBER(hGlobal)));
  58                                         _tcscpy(pw32fdata->cFileName, path);
  59
  60                                         UINT sem_org = SetErrorMode(SEM_FAILCRITICALERRORS);
  61
  62                                         if (GetFileAttributesEx(path, GetFileExInfoStandard, &fad)) {
  63                                                 pw32fdata->dwFileAttributes = fad.dwFileAttributes;
  64                                                 pw32fdata->ftCreationTime = fad.ftCreationTime;
  65                                                 pw32fdata->ftLastAccessTime = fad.ftLastAccessTime;
  66                                                 pw32fdata->ftLastWriteTime = fad.ftLastWriteTime;
  67
  68                                                 if (!(fad.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)) {
  69                                                          // copy file size
  70                                                         pw32fdata->nFileSizeLow = fad.nFileSizeLow;
  71                                                         pw32fdata->nFileSizeHigh = fad.nFileSizeHigh;
  72                                                 } else {
  73                                                          // ignore FILE_ATTRIBUTE_HIDDEN attribute of NTFS drives - this would hide those drives in ShellBrowser
  74                                                         if (pw32fdata->dwFileAttributes & FILE_ATTRIBUTE_HIDDEN) {
  75                                                                 if (path[1]==':' && path[2]=='\\' && !path[3])  // Is it a drive path?
  76                                                                         pw32fdata->dwFileAttributes &= ~FILE_ATTRIBUTE_HIDDEN;
  77                                                         }
  78                                                 }
  79                                         }
  80
  81                                         HANDLE hFile = CreateFile(path, GENERIC_READ, FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
  82                                                                                                 0, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, 0);
  83
  84                                         if (hFile != INVALID_HANDLE_VALUE) {
  85                                                 if (GetFileInformationByHandle(hFile, pbhfi))
  86                                                         bhfi_valid = true;
  87
  88                                                 CloseHandle(hFile);
  89                                         }
  90
  91                                         SetErrorMode(sem_org);
  92
  93                                         GlobalUnlock(medium.UNION_MEMBER(hGlobal));
  94                                         GlobalFree(medium.UNION_MEMBER(hGlobal));
  95                                 }
  96                         }
  97                 }
  98         }
  99
 100         if (!do_access || !(attribs&SFGAO_FILESYSTEM))  // Archiv files should not be displayed as folders in explorer view.
 101                 if (attribs & (SFGAO_FOLDER|SFGAO_HASSUBFOLDER))
 102                         pw32fdata->dwFileAttributes |= FILE_ATTRIBUTE_DIRECTORY;
 103
 104         if (attribs & SFGAO_READONLY)
 105                 pw32fdata->dwFileAttributes |= FILE_ATTRIBUTE_READONLY;
 106
 107         if (attribs & SFGAO_COMPRESSED)
 108                 pw32fdata->dwFileAttributes |= FILE_ATTRIBUTE_COMPRESSED;
 109
 110         return bhfi_valid;
 111 }
 112
 113
 114 ShellPath ShellEntry::create_absolute_pidl() const
 115 {
 116         CONTEXT("ShellEntry::create_absolute_pidl()");
 117
 118         if (_up)
 119         {
 120                 if (_up->_etype == ET_SHELL) {
 121                         ShellDirectory* dir = static_cast<ShellDirectory*>(_up);
 122
 123                         if (dir->_pidl->mkid.cb)        // Caching of absolute PIDLs could enhance performance.
 124                                 return _pidl.create_absolute_pidl(dir->create_absolute_pidl());
 125                 } else
 126                         return _pidl.create_absolute_pidl(_up->create_absolute_pidl());
 127         }
 128         return _pidl;
 129 }
 130
 131
 132  // get full path of a shell entry
 133 bool ShellEntry::get_path(PTSTR path, size_t path_count) const
 134 {
 135         if (!path || path_count==0)
 136                 return false;
 137 /*
 138         path[0] = TEXT('\0');
 139
 140         if (FAILED(path_from_pidl(get_parent_folder(), &*_pidl, path, path_count)))
 141                 return false;
 142 */
 143         FileSysShellPath fs_path(create_absolute_pidl());
 144         LPCTSTR ret = fs_path;
 145
 146         if (ret) {
 147                 lstrcpyn(path, ret, path_count);
 148                 return true;
 149         } else
 150                 return false;
 151 }
 152
 153
 154  // get full path of a shell folder
 155 bool ShellDirectory::get_path(PTSTR path, size_t path_count) const
 156 {
 157         CONTEXT("ShellDirectory::get_path()");
 158
 159         if (!path || path_count==0)
 160                 return false;
 161
 162         path[0] = TEXT('\0');
 163
 164         if (_folder.empty())
 165                 return false;
 166
 167         SFGAOF attribs = SFGAO_FILESYSTEM;
 168
 169         // Split pidl into current and parent folder PIDLs
 170         ShellPath pidlParent, pidlFolder;
 171         _pidl.split(pidlParent, pidlFolder);
 172
 173         if (FAILED(const_cast<ShellFolder&>(_folder)->GetAttributesOf(1, (LPCITEMIDLIST*)&pidlFolder, &attribs)))
 174                 return false;
 175
 176         if (!(attribs & SFGAO_FILESYSTEM))
 177                 return false;
 178
 179         if (FAILED(path_from_pidl(get_parent_folder(), &*_pidl, path, path_count)))
 180                 return false;
 181
 182         return true;
 183 }
 184
 185
 186 BOOL ShellEntry::launch_entry(HWND hwnd, UINT nCmdShow)
 187 {
 188         CONTEXT("ShellEntry::launch_entry()");
 189
 190         SHELLEXECUTEINFO shexinfo;
 191
 192         shexinfo.cbSize = sizeof(SHELLEXECUTEINFO);
 193         shexinfo.fMask = SEE_MASK_INVOKEIDLIST; // SEE_MASK_IDLIST is also possible.
 194         shexinfo.hwnd = hwnd;
 195         shexinfo.lpVerb = NULL;
 196         shexinfo.lpFile = NULL;
 197         shexinfo.lpParameters = NULL;
 198         shexinfo.lpDirectory = NULL;
 199         shexinfo.nShow = nCmdShow;
 200
 201         ShellPath shell_path = create_absolute_pidl();
 202         shexinfo.lpIDList = &*shell_path;
 203
 204          // add PIDL to the recent file list
 205         SHAddToRecentDocs(SHARD_PIDL, shexinfo.lpIDList);
 206
 207         BOOL ret = TRUE;
 208
 209         if (!ShellExecuteEx(&shexinfo)) {
 210                 display_error(hwnd, GetLastError());
 211                 ret = FALSE;
 212         }
 213
 214         return ret;
 215 }
 216
 217
 218 HRESULT ShellEntry::do_context_menu(HWND hwnd, const POINT& pptScreen, CtxMenuInterfaces& cm_ifs)
 219 {
 220         ShellDirectory* dir = static_cast<ShellDirectory*>(_up);
 221
 222         ShellFolder folder = dir? dir->_folder: GetDesktopFolder();
 223         LPCITEMIDLIST pidl = _pidl;
 224
 225         return ShellFolderContextMenu(folder, hwnd, 1, &pidl, pptScreen.x, pptScreen.y, cm_ifs);
 226 }
 227
 228
 229 HRESULT ShellEntry::GetUIObjectOf(HWND hWnd, REFIID riid, LPVOID* ppvOut)
 230 {
 231         LPCITEMIDLIST pidl = _pidl;
 232
 233         return get_parent_folder()->GetUIObjectOf(hWnd, 1, &pidl, riid, NULL, ppvOut);
 234 }
 235
 236
 237 ShellFolder Entry::get_shell_folder() const
 238 {
 239         return ShellFolder(create_absolute_pidl());
 240 }
 241
 242 ShellFolder ShellEntry::get_shell_folder() const
 243 {
 244         return get_parent_folder();
 245 }
 246
 247 ShellFolder ShellDirectory::get_shell_folder() const
 248 {
 249         return _folder;
 250 }
 251
 252
 253 void ShellDirectory::read_directory(int scan_flags)
 254 {
 255         CONTEXT("ShellDirectory::read_directory()");
 256
 257         int level = _level + 1;
 258
 259         Entry* first_entry = NULL;
 260         Entry* last = NULL;
 261
 262         /*if (_folder.empty())
 263                 return;*/
 264
 265 #ifndef _NO_WIN_FS
 266         TCHAR buffer[_MAX_PATH+_MAX_FNAME];
 267
 268         if (!(scan_flags&SCAN_NO_FILESYSTEM) && get_path(buffer, COUNTOF(buffer)) && _tcsncmp(buffer,TEXT("::{"),3)) {
 269                 Entry* entry = NULL;    // eliminate useless GCC warning by initializing entry
 270
 271                 LPTSTR p = buffer + _tcslen(buffer);
 272
 273                 lstrcpy(p, TEXT("\\*"));
 274
 275                 WIN32_FIND_DATA w32fd;
 276                 HANDLE hFind = FindFirstFile(buffer, &w32fd);
 277
 278                 if (hFind != INVALID_HANDLE_VALUE) {
 279                         do {
 280                                  // ignore hidden files (usefull in the start menu)
 281                                 if (w32fd.dwFileAttributes & FILE_ATTRIBUTE_HIDDEN)
 282                                         continue;
 283
 284                                  // ignore directory entries "." and ".."
 285                                 if ((w32fd.dwFileAttributes&FILE_ATTRIBUTE_DIRECTORY) &&
 286                                         w32fd.cFileName[0]==TEXT('.') &&
 287                                         (w32fd.cFileName[1]==TEXT('\0') ||
 288                                         (w32fd.cFileName[1]==TEXT('.') && w32fd.cFileName[2]==TEXT('\0'))))
 289                                         continue;
 290
 291                                 lstrcpy(p+1, w32fd.cFileName);
 292
 293                                 if (w32fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
 294                                         entry = new WinDirectory(this, buffer);
 295                                 else
 296                                         entry = new WinEntry(this);
 297
 298                                 if (!first_entry)
 299                                         first_entry = entry;
 300
 301                                 if (last)
 302                                         last->_next = entry;
 303
 304                                 memcpy(&entry->_data, &w32fd, sizeof(WIN32_FIND_DATA));
 305
 306                                 entry->_level = level;
 307
 308                                 if (!(scan_flags & SCAN_DONT_ACCESS)) {
 309                                         HANDLE hFile = CreateFile(buffer, GENERIC_READ, FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
 310                                                                                                 0, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, 0);
 311
 312                                         if (hFile != INVALID_HANDLE_VALUE) {
 313                                                 if (GetFileInformationByHandle(hFile, &entry->_bhfi))
 314                                                         entry->_bhfi_valid = true;
 315
 316 #ifdef BACKUP_READ_IMPLEMENTED
 317                                                 if (ScanNTFSStreams(entry, hFile))
 318                                                         entry->_scanned = true; // There exist named NTFS sub-streams in this file.
 319 #endif
 320
 321                                                 CloseHandle(hFile);
 322                                         }
 323                                 }
 324
 325                                  // set file type name
 326                                 LPCTSTR ext = g_Globals._ftype_mgr.set_type(entry);
 327
 328                                 DWORD attribs = SFGAO_FILESYSTEM;
 329
 330                                 if (w32fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
 331                                         attribs |= SFGAO_FOLDER|SFGAO_HASSUBFOLDER;
 332
 333                                 if (w32fd.dwFileAttributes & FILE_ATTRIBUTE_READONLY)
 334                                         attribs |= SFGAO_READONLY;
 335
 336                                 //if (w32fd.dwFileAttributes & FILE_ATTRIBUTE_HIDDEN)
 337                                 //      attribs |= SFGAO_HIDDEN;
 338
 339                                 if (w32fd.dwFileAttributes & FILE_ATTRIBUTE_COMPRESSED)
 340                                         attribs |= SFGAO_COMPRESSED;
 341
 342                                 if (ext && !_tcsicmp(ext, _T(".lnk"))) {
 343                                         attribs |= SFGAO_LINK;
 344                                         w32fd.dwFileAttributes |= ATTRIBUTE_SYMBOLIC_LINK;
 345                                 }
 346
 347                                 entry->_shell_attribs = attribs;
 348
 349                                 if (w32fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
 350                                         entry->_icon_id = ICID_FOLDER;
 351                                 else if (!(scan_flags & SCAN_DONT_EXTRACT_ICONS))
 352                                         entry->_icon_id = entry->safe_extract_icon();   // Assume small icon, we can extract the large icon later on demand.
 353
 354                                 last = entry;
 355                         } while(FindNextFile(hFind, &w32fd));
 356
 357                         FindClose(hFind);
 358                 }
 359         }
 360         else // SCAN_NO_FILESYSTEM
 361 #endif
 362         {
 363                 ShellItemEnumerator enumerator(_folder, SHCONTF_FOLDERS|SHCONTF_NONFOLDERS|SHCONTF_INCLUDEHIDDEN|SHCONTF_SHAREABLE|SHCONTF_STORAGE);
 364
 365                 TCHAR name[MAX_PATH];
 366                 TCHAR path[MAX_PATH];
 367                 HRESULT hr_next = S_OK;
 368
 369                 do {
 370 #define FETCH_ITEM_COUNT        32
 371                         LPITEMIDLIST pidls[FETCH_ITEM_COUNT];
 372                         ULONG cnt = 0;
 373
 374                         memset(pidls, 0, sizeof(pidls));
 375
 376                         hr_next = enumerator->Next(FETCH_ITEM_COUNT, pidls, &cnt);
 377
 378                         /* don't break yet now: Registry Explorer Plugin returns E_FAIL!
 379                         if (!SUCCEEDED(hr_next))
 380                                 break; */
 381
 382                         if (hr_next == S_FALSE)
 383                                 break;
 384
 385                         for(ULONG n=0; n<cnt; ++n) {
 386                                 WIN32_FIND_DATA w32fd;
 387                                 BY_HANDLE_FILE_INFORMATION bhfi;
 388                                 bool bhfi_valid = false;
 389
 390                                 memset(&w32fd, 0, sizeof(WIN32_FIND_DATA));
 391
 392                                 SFGAOF attribs_before = ~SFGAO_READONLY & ~SFGAO_VALIDATE;
 393                                 SFGAOF attribs = attribs_before;
 394                                 HRESULT hr = _folder->GetAttributesOf(1, (LPCITEMIDLIST*)&pidls[n], &attribs);
 395                                 bool removeable = false;
 396
 397                                 if (SUCCEEDED(hr) && attribs!=attribs_before) {
 398                                          // avoid accessing floppy drives when browsing "My Computer"
 399                                         if (attribs & SFGAO_REMOVABLE) {
 400                                                 attribs |= SFGAO_HASSUBFOLDER;
 401                                                 removeable = true;
 402                                         } else if (!(scan_flags & SCAN_DONT_ACCESS)) {
 403                                                 SFGAOF attribs2 = SFGAO_READONLY;
 404
 405                                                 HRESULT hr = _folder->GetAttributesOf(1, (LPCITEMIDLIST*)&pidls[n], &attribs2);
 406
 407                                                 if (SUCCEEDED(hr))
 408                                                         attribs |= attribs2;
 409                                         }
 410                                 } else
 411                                         attribs = 0;
 412
 413                                 bhfi_valid = fill_w32fdata_shell(pidls[n], attribs, &w32fd, &bhfi,
 414                                                                                                  !(scan_flags&SCAN_DONT_ACCESS) && !removeable);
 415
 416                                 try {
 417                                         Entry* entry = NULL;    // eliminate useless GCC warning by initializing entry
 418
 419                                         if (w32fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
 420                                                 entry = new ShellDirectory(this, pidls[n], _hwnd);
 421                                         else
 422                                                 entry = new ShellEntry(this, pidls[n]);
 423
 424                                         if (!first_entry)
 425                                                 first_entry = entry;
 426
 427                                         if (last)
 428                                                 last->_next = entry;
 429
 430                                         memcpy(&entry->_data, &w32fd, sizeof(WIN32_FIND_DATA));
 431
 432                                         if (bhfi_valid)
 433                                                 memcpy(&entry->_bhfi, &bhfi, sizeof(BY_HANDLE_FILE_INFORMATION));
 434
 435                                          // store path in entry->_data.cFileName in case fill_w32fdata_shell() didn't already fill it
 436                                         if (!entry->_data.cFileName[0])
 437                                                 if (SUCCEEDED(path_from_pidl(_folder, pidls[n], path, COUNTOF(path))))
 438                                                         _tcscpy(entry->_data.cFileName, path);
 439
 440                                         if (SUCCEEDED(name_from_pidl(_folder, pidls[n], name, COUNTOF(name), SHGDN_INFOLDER|0x2000/*0x2000=SHGDN_INCLUDE_NONFILESYS*/))) {
 441                                                 if (!entry->_data.cFileName[0])
 442                                                         _tcscpy(entry->_data.cFileName, name);
 443                                                 else if (_tcscmp(entry->_display_name, name))
 444                                                         entry->_display_name = _tcsdup(name);   // store display name separate from file name; sort display by file name
 445                                         }
 446
 447                                         if (attribs & SFGAO_LINK)
 448                                                 w32fd.dwFileAttributes |= ATTRIBUTE_SYMBOLIC_LINK;
 449
 450                                         entry->_level = level;
 451                                         entry->_shell_attribs = attribs;
 452                                         entry->_bhfi_valid = bhfi_valid;
 453
 454                                          // set file type name
 455                                         g_Globals._ftype_mgr.set_type(entry);
 456
 457                                          // get icons for files and virtual objects
 458                                         if (!(entry->_data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) ||
 459                                                 !(attribs & SFGAO_FILESYSTEM)) {
 460                                                 if (!(scan_flags & SCAN_DONT_EXTRACT_ICONS))
 461                                                         entry->_icon_id = entry->safe_extract_icon();   // Assume small icon, we can extract the large icon later on demand.
 462                                         } else if (entry->_data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
 463                                                 entry->_icon_id = ICID_FOLDER;
 464                                         else
 465                                                 entry->_icon_id = ICID_NONE;    // don't try again later
 466
 467                                         last = entry;
 468                                 } catch(COMException& e) {
 469                                         HandleException(e, _hwnd);
 470                                 }
 471                         }
 472                 } while(SUCCEEDED(hr_next));
 473         }
 474
 475         if (last)
 476                 last->_next = NULL;
 477
 478         _down = first_entry;
 479         _scanned = true;
 480 }
 481
 482 const void* ShellDirectory::get_next_path_component(const void* p) const
 483 {
 484         LPITEMIDLIST pidl = (LPITEMIDLIST)p;
 485
 486         if (!pidl || !pidl->mkid.cb)
 487                 return NULL;
 488
 489          // go to next element
 490         pidl = (LPITEMIDLIST)((LPBYTE)pidl+pidl->mkid.cb);
 491
 492         return pidl;
 493 }
 494
 495 Entry* ShellDirectory::find_entry(const void* p)
 496 {
 497         LPITEMIDLIST pidl = (LPITEMIDLIST) p;
 498
 499          // handle special case of empty trailing id list entry
 500         if (!pidl->mkid.cb)
 501                 return this;
 502
 503         for(Entry*entry=_down; entry; entry=entry->_next)
 504                 if (entry->_etype == ET_SHELL) {
 505                         ShellEntry* se = static_cast<ShellEntry*>(entry);
 506
 507                         if (se->_pidl && se->_pidl->mkid.cb==pidl->mkid.cb && !memcmp(se->_pidl, pidl, se->_pidl->mkid.cb))
 508                                 return entry;
 509                 } else {
 510                         const ShellPath& sp = entry->create_absolute_pidl();
 511                         static DynamicFct<LPITEMIDLIST(WINAPI*)(LPCITEMIDLIST)> ILFindLastID(TEXT("SHELL32"), "ILFindLastID");
 512
 513                         if (ILFindLastID) {
 514                                 LPCITEMIDLIST entry_pidl = (*ILFindLastID)(sp);
 515
 516                                 if (entry_pidl && entry_pidl->mkid.cb==pidl->mkid.cb && !memcmp(entry_pidl, pidl, entry_pidl->mkid.cb))
 517                                         return entry;
 518                         }
 519                 }
 520
 521         return NULL;
 522 }
 523
 524 int ShellDirectory::extract_icons(ICONCACHE_FLAGS flags)
 525 {
 526         int cnt = 0;
 527
 528         for(Entry*entry=_down; entry; entry=entry->_next)
 529                 if (entry->_icon_id == ICID_UNKNOWN) {
 530                         entry->_icon_id = entry->extract_icon(flags);
 531
 532                         if (entry->_icon_id != ICID_NONE)
 533                                 ++cnt;
 534                 }
 535
 536         return cnt;
 537 }