ReactOS Development > Doxygen

00001 /*
00002  * PROJECT:     Recycle bin management
00003  * LICENSE:     GPL v2 - See COPYING in the top level directory
00004  * FILE:        lib/recyclebin/recyclebin.c
00005  * PURPOSE:     Public interface
00006  * PROGRAMMERS: Copyright 2006-2007 Herv� Poussineau (hpoussin@reactos.org)
00007  */
00008 
00009 #define COBJMACROS
00010 #include "recyclebin_private.h"
00011 #include <stdio.h>
00012 
00013 WINE_DEFAULT_DEBUG_CHANNEL(recyclebin);
00014 
00015 BOOL WINAPI
00016 CloseRecycleBinHandle(
00017     IN HANDLE hDeletedFile)
00018 {
00019     IRecycleBinFile *rbf = (IRecycleBinFile *)hDeletedFile;
00020     HRESULT hr;
00021 
00022     TRACE("(%p)\n", hDeletedFile);
00023 
00024     hr = IRecycleBinFile_Release(rbf);
00025     if (SUCCEEDED(hr))
00026         return TRUE;
00027     if (HRESULT_FACILITY(hr) == FACILITY_WIN32)
00028         SetLastError(HRESULT_CODE(hr));
00029     else
00030         SetLastError(ERROR_GEN_FAILURE);
00031     return FALSE;
00032 }
00033 
00034 BOOL WINAPI
00035 DeleteFileToRecycleBinA(
00036     IN LPCSTR FileName)
00037 {
00038     int len;
00039     LPWSTR FileNameW = NULL;
00040     BOOL ret = FALSE;
00041 
00042     TRACE("(%s)\n", debugstr_a(FileName));
00043 
00044     /* Check parameters */
00045     if (FileName == NULL)
00046     {
00047         SetLastError(ERROR_INVALID_PARAMETER);
00048         goto cleanup;
00049     }
00050 
00051     len = MultiByteToWideChar(CP_ACP, 0, FileName, -1, NULL, 0);
00052     if (len == 0)
00053         goto cleanup;
00054     FileNameW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
00055     if (!FileNameW)
00056     {
00057         SetLastError(ERROR_NOT_ENOUGH_MEMORY);
00058         goto cleanup;
00059     }
00060     if (MultiByteToWideChar(CP_ACP, 0, FileName, -1, FileNameW, len) == 0)
00061         goto cleanup;
00062 
00063     ret = DeleteFileToRecycleBinW(FileNameW);
00064 
00065 cleanup:
00066     HeapFree(GetProcessHeap(), 0, FileNameW);
00067     return ret;
00068 }
00069 
00070 BOOL WINAPI
00071 DeleteFileToRecycleBinW(
00072     IN LPCWSTR FileName)
00073 {
00074     IRecycleBin *prb;
00075     HRESULT hr;
00076 
00077     TRACE("(%s)\n", debugstr_w(FileName));
00078 
00079     hr = GetDefaultRecycleBin(NULL, &prb);
00080     if (!SUCCEEDED(hr))
00081         goto cleanup;
00082 
00083     hr = IRecycleBin_DeleteFile(prb, FileName);
00084     IRecycleBin_Release(prb);
00085 
00086 cleanup:
00087     if (SUCCEEDED(hr))
00088         return TRUE;
00089     if (HRESULT_FACILITY(hr) == FACILITY_WIN32)
00090         SetLastError(HRESULT_CODE(hr));
00091     else
00092         SetLastError(ERROR_GEN_FAILURE);
00093     return FALSE;
00094 }
00095 
00096 BOOL WINAPI
00097 DeleteFileHandleToRecycleBin(
00098     IN HANDLE hDeletedFile)
00099 {
00100     IRecycleBinFile *rbf = (IRecycleBinFile *)hDeletedFile;
00101     HRESULT hr;
00102 
00103     TRACE("(%p)\n", hDeletedFile);
00104 
00105     hr = IRecycleBinFile_Delete(rbf);
00106 
00107     if (SUCCEEDED(hr))
00108         return TRUE;
00109     if (HRESULT_FACILITY(hr) == FACILITY_WIN32)
00110         SetLastError(HRESULT_CODE(hr));
00111     else
00112         SetLastError(ERROR_GEN_FAILURE);
00113     return FALSE;
00114 }
00115 
00116 BOOL WINAPI
00117 EmptyRecycleBinA(
00118     IN LPCSTR pszRoot OPTIONAL)
00119 {
00120     int len;
00121     LPWSTR szRootW = NULL;
00122     BOOL ret = FALSE;
00123 
00124     TRACE("(%s)\n", debugstr_a(pszRoot));
00125 
00126     if (pszRoot)
00127     {
00128         len = MultiByteToWideChar(CP_ACP, 0, pszRoot, -1, NULL, 0);
00129         if (len == 0)
00130             goto cleanup;
00131         szRootW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
00132         if (!szRootW)
00133         {
00134             SetLastError(ERROR_NOT_ENOUGH_MEMORY);
00135             goto cleanup;
00136         }
00137         if (MultiByteToWideChar(CP_ACP, 0, pszRoot, -1, szRootW, len) == 0)
00138             goto cleanup;
00139     }
00140 
00141     ret = EmptyRecycleBinW(szRootW);
00142 
00143 cleanup:
00144     HeapFree(GetProcessHeap(), 0, szRootW);
00145     return ret;
00146 }
00147 
00148 BOOL WINAPI
00149 EmptyRecycleBinW(
00150     IN LPCWSTR pszRoot OPTIONAL)
00151 {
00152     IRecycleBin *prb;
00153     HRESULT hr;
00154 
00155     TRACE("(%s)\n", debugstr_w(pszRoot));
00156 
00157     hr = GetDefaultRecycleBin(pszRoot, &prb);
00158     if (!SUCCEEDED(hr))
00159         goto cleanup;
00160 
00161     hr = IRecycleBin_EmptyRecycleBin(prb);
00162     IRecycleBin_Release(prb);
00163 
00164 cleanup:
00165     if (SUCCEEDED(hr))
00166         return TRUE;
00167     if (HRESULT_FACILITY(hr) == FACILITY_WIN32)
00168         SetLastError(HRESULT_CODE(hr));
00169     else
00170         SetLastError(ERROR_GEN_FAILURE);
00171     return FALSE;
00172 }
00173 
00174 BOOL WINAPI
00175 EnumerateRecycleBinA(
00176     IN LPCSTR pszRoot OPTIONAL,
00177     IN PENUMERATE_RECYCLEBIN_CALLBACK pFnCallback,
00178     IN PVOID Context OPTIONAL)
00179 {
00180     int len;
00181     LPWSTR szRootW = NULL;
00182     BOOL ret = FALSE;
00183 
00184     TRACE("(%s, %p, %p)\n", debugstr_a(pszRoot), pFnCallback, Context);
00185 
00186     if (pszRoot)
00187     {
00188         len = MultiByteToWideChar(CP_ACP, 0, pszRoot, -1, NULL, 0);
00189         if (len == 0)
00190             goto cleanup;
00191         szRootW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
00192         if (!szRootW)
00193         {
00194             SetLastError(ERROR_NOT_ENOUGH_MEMORY);
00195             goto cleanup;
00196         }
00197         if (MultiByteToWideChar(CP_ACP, 0, pszRoot, -1, szRootW, len) == 0)
00198             goto cleanup;
00199     }
00200 
00201     ret = EnumerateRecycleBinW(szRootW, pFnCallback, Context);
00202 
00203 cleanup:
00204     HeapFree(GetProcessHeap(), 0, szRootW);
00205     return ret;
00206 }
00207 
00208 BOOL WINAPI
00209 EnumerateRecycleBinW(
00210     IN LPCWSTR pszRoot OPTIONAL,
00211     IN PENUMERATE_RECYCLEBIN_CALLBACK pFnCallback,
00212     IN PVOID Context OPTIONAL)
00213 {
00214     IRecycleBin *prb = NULL;
00215     IRecycleBinEnumList *prbel = NULL;
00216     IRecycleBinFile *prbf;
00217     HRESULT hr;
00218 
00219     TRACE("(%s, %p, %p)\n", debugstr_w(pszRoot), pFnCallback, Context);
00220 
00221     hr = GetDefaultRecycleBin(NULL, &prb);
00222     if (!SUCCEEDED(hr))
00223         goto cleanup;
00224 
00225     hr = IRecycleBin_EnumObjects(prb, &prbel);
00226     if (!SUCCEEDED(hr))
00227         goto cleanup;
00228     while (TRUE)
00229     {
00230         hr = IRecycleBinEnumList_Next(prbel, 1, &prbf, NULL);
00231         if (hr == S_FALSE)
00232         {
00233             hr = S_OK;
00234             goto cleanup;
00235         }
00236         else if (!SUCCEEDED(hr))
00237             goto cleanup;
00238         if (!pFnCallback(Context, (HANDLE)prbf))
00239         {
00240             hr = HRESULT_FROM_WIN32(GetLastError());
00241             goto cleanup;
00242         }
00243     }
00244 
00245 cleanup:
00246     if (prb)
00247         IRecycleBin_Release(prb);
00248     if (prbel)
00249         IRecycleBinEnumList_Release(prbel);
00250     if (SUCCEEDED(hr))
00251         return TRUE;
00252     if (HRESULT_FACILITY(hr) == FACILITY_WIN32)
00253         SetLastError(HRESULT_CODE(hr));
00254     else
00255         SetLastError(ERROR_GEN_FAILURE);
00256     return FALSE;
00257 }
00258 
00259 BOOL WINAPI
00260 GetDeletedFileDetailsA(
00261     IN HANDLE hDeletedFile,
00262     IN DWORD BufferSize,
00263     IN OUT PDELETED_FILE_DETAILS_A FileDetails OPTIONAL,
00264     OUT LPDWORD RequiredSize OPTIONAL)
00265 {
00266     PDELETED_FILE_DETAILS_W FileDetailsW = NULL;
00267     DWORD BufferSizeW = 0;
00268     BOOL ret = FALSE;
00269 
00270     TRACE("(%p, %lu, %p, %p)\n", hDeletedFile, BufferSize, FileDetails, RequiredSize);
00271 
00272     if (BufferSize >= FIELD_OFFSET(DELETED_FILE_DETAILS_A, FileName))
00273     {
00274         BufferSizeW = FIELD_OFFSET(DELETED_FILE_DETAILS_W, FileName)
00275             + (BufferSize - FIELD_OFFSET(DELETED_FILE_DETAILS_A, FileName)) * sizeof(WCHAR);
00276     }
00277     if (FileDetails && BufferSizeW)
00278     {
00279         FileDetailsW = HeapAlloc(GetProcessHeap(), 0, BufferSizeW);
00280         if (!FileDetailsW)
00281         {
00282             SetLastError(ERROR_NOT_ENOUGH_MEMORY);
00283             goto cleanup;
00284         }
00285     }
00286 
00287     ret = GetDeletedFileDetailsW(hDeletedFile, BufferSizeW, FileDetailsW, RequiredSize);
00288     if (!ret)
00289         goto cleanup;
00290 
00291     if (FileDetails)
00292     {
00293         CopyMemory(FileDetails, FileDetailsW, FIELD_OFFSET(DELETED_FILE_DETAILS_A, FileName));
00294         if (0 == WideCharToMultiByte(CP_ACP, 0, FileDetailsW->FileName, -1, FileDetails->FileName, BufferSize - FIELD_OFFSET(DELETED_FILE_DETAILS_A, FileName), NULL, NULL))
00295             goto cleanup;
00296     }
00297     ret = TRUE;
00298 
00299 cleanup:
00300     HeapFree(GetProcessHeap(), 0, FileDetailsW);
00301     return ret;
00302 }
00303 
00304 BOOL WINAPI
00305 GetDeletedFileDetailsW(
00306     IN HANDLE hDeletedFile,
00307     IN DWORD BufferSize,
00308     IN OUT PDELETED_FILE_DETAILS_W FileDetails OPTIONAL,
00309     OUT LPDWORD RequiredSize OPTIONAL)
00310 {
00311     IRecycleBinFile *rbf = (IRecycleBinFile *)hDeletedFile;
00312     HRESULT hr;
00313     SIZE_T NameSize, Needed;
00314 
00315     TRACE("(%p, %lu, %p, %p)\n", hDeletedFile, BufferSize, FileDetails, RequiredSize);
00316 
00317     hr = IRecycleBinFile_GetFileName(rbf, 0, NULL, &NameSize);
00318     if (!SUCCEEDED(hr))
00319         goto cleanup;
00320     Needed = FIELD_OFFSET(DELETED_FILE_DETAILS_W, FileName) + NameSize;
00321     if (RequiredSize)
00322         *RequiredSize = (DWORD)Needed;
00323     if (Needed > BufferSize)
00324     {
00325         hr = HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER);
00326         goto cleanup;
00327     }
00328     hr = IRecycleBinFile_GetFileName(rbf, NameSize, FileDetails->FileName, NULL);
00329     if (!SUCCEEDED(hr))
00330         goto cleanup;
00331     hr = IRecycleBinFile_GetLastModificationTime(rbf, &FileDetails->LastModification);
00332     if (!SUCCEEDED(hr))
00333         goto cleanup;
00334     hr = IRecycleBinFile_GetDeletionTime(rbf, &FileDetails->DeletionTime);
00335     if (!SUCCEEDED(hr))
00336         goto cleanup;
00337     hr = IRecycleBinFile_GetFileSize(rbf, &FileDetails->FileSize);
00338     if (!SUCCEEDED(hr))
00339         goto cleanup;
00340     hr = IRecycleBinFile_GetPhysicalFileSize(rbf, &FileDetails->PhysicalFileSize);
00341     if (!SUCCEEDED(hr))
00342         goto cleanup;
00343     hr = IRecycleBinFile_GetAttributes(rbf, &FileDetails->Attributes);
00344     if (!SUCCEEDED(hr))
00345         goto cleanup;
00346 
00347 cleanup:
00348     if (SUCCEEDED(hr))
00349         return TRUE;
00350     if (HRESULT_FACILITY(hr) == FACILITY_WIN32)
00351         SetLastError(HRESULT_CODE(hr));
00352     else
00353         SetLastError(ERROR_GEN_FAILURE);
00354     return FALSE;
00355 }
00356 
00357 BOOL WINAPI
00358 GetRecycleBinDetails(
00359     IN LPCWSTR pszVolume OPTIONAL,
00360     OUT ULARGE_INTEGER *pulTotalItems,
00361     OUT ULARGE_INTEGER *pulTotalSize)
00362 {
00363     pulTotalItems->QuadPart = 0;
00364     pulTotalSize->QuadPart = 0;
00365     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
00366     return FALSE;
00367 }
00368 
00369 BOOL WINAPI
00370 RestoreFile(
00371     IN HANDLE hDeletedFile)
00372 {
00373     IRecycleBinFile *rbf = (IRecycleBinFile *)hDeletedFile;
00374     HRESULT hr;
00375 
00376     TRACE("(%p)\n", hDeletedFile);
00377 
00378     hr = IRecycleBinFile_Restore(rbf);
00379     if (SUCCEEDED(hr))
00380         return TRUE;
00381     if (HRESULT_FACILITY(hr) == FACILITY_WIN32)
00382         SetLastError(HRESULT_CODE(hr));
00383     else
00384         SetLastError(ERROR_GEN_FAILURE);
00385     return FALSE;
00386 }
00387 
00388 HRESULT WINAPI
00389 GetDefaultRecycleBin(
00390     IN LPCWSTR pszVolume OPTIONAL,
00391     OUT IRecycleBin **pprb)
00392 {
00393     IUnknown *pUnk;
00394     HRESULT hr;
00395 
00396     TRACE("(%s, %p)\n", debugstr_w(pszVolume), pprb);
00397 
00398     if (!pprb)
00399         return E_POINTER;
00400 
00401     if (!pszVolume)
00402         hr = RecycleBinGeneric_Constructor(&pUnk);
00403     else
00404     {
00405         /* FIXME: do a better validation! */
00406         if (wcslen(pszVolume) != 3 || pszVolume[1] != ':' || pszVolume[2] != '\\')
00407             return HRESULT_FROM_WIN32(ERROR_INVALID_NAME);
00408 
00409         /* For now, only support this type of recycle bins... */
00410         hr = RecycleBin5_Constructor(pszVolume, &pUnk);
00411     }
00412     if (!SUCCEEDED(hr))
00413         return hr;
00414     hr = IUnknown_QueryInterface(pUnk, &IID_IRecycleBin, (void **)pprb);
00415     IUnknown_Release(pUnk);
00416     return hr;
00417 }
Generated on Sat May 26 2012 04:35:16 for ReactOS by
1.7.6.1