update.h
Upload User: xhy777
Upload Date: 2007-02-14
Package Size: 24088k
Code Size: 11k
Category:

Windows Kernel

Development Platform:

Visual C++

  1. //+-------------------------------------------------------------------------
  2. //
  3. //  Microsoft Windows
  4. //
  5. //  Copyright (C) Microsoft Corporation, 1997 - 1999
  6. //
  7. //  File:       update.h
  8. //
  9. //--------------------------------------------------------------------------
  10. #ifndef _UPDATE_H_
  11. #define _UPDATE_H_
  12. #include <mobsync.h>
  13. #include "cscentry.h"
  14. #include "util.h"       // ENUM_REASON
  15. //
  16. // Flags used in CscUpdateCache
  17. //
  18. #define CSC_UPDATE_STARTNOW       0x00000002  // Don't wait for user confirmation to start update
  19. #define CSC_UPDATE_SELECTION      0x00000004  // Update current selection (CSC_NAMELIST_HDR buffer)
  20. #define CSC_UPDATE_PINFILES       0x00000008  // Pin files while updating them
  21. #define CSC_UPDATE_PIN_RECURSE    0x00000010  // Recurse into subfolders when pinning
  22. #define CSC_UPDATE_REINT          0x00000020  // Perform outward reintegration
  23. #define CSC_UPDATE_FILL_QUICK     0x00000040  // Perform quick inward sync (fill sparse files)
  24. #define CSC_UPDATE_FILL_ALL       0x00000080  // Perform full inward sync (overrides CSC_UPDATE_FILL_QUICK)
  25. #define CSC_UPDATE_NOTIFY_DONE    0x00000100  // Send CSCWM_DONESYNCING to notify window when done.
  26. #define CSC_UPDATE_SHOWUI_ALWAYS  0x00000200  // Nothing to sync but show SyncMgr UI anyway.
  27. #define CSC_UPDATE_IGNORE_ACCESS  0x00000400  // Default is to sync files with USER and/or GUEST access.
  28. #define CSC_UPDATE_RECONNECT      0x00000800  // Transition all servers online after syncing
  29. HRESULT CscRegisterHandler(BOOL bRegister=TRUE, LPUNKNOWN punkSyncMgr=NULL);
  30. HRESULT CscUpdateCache(DWORD dwUpdateFlags, CscFilenameList *pfnl=NULL);
  31. void BuildSilentFolderList(CscFilenameList *pfnlSilentFolders,
  32.                            CscFilenameList *pfnlSpecialFolders);
  33. class CCscUpdate;
  34. typedef CCscUpdate *PCSCUPDATE;
  35. typedef struct
  36. {
  37.     PCSCUPDATE      pThis;
  38.     SYNCMGRITEMID   ItemID;
  39.     HANDLE          hThread;
  40.     LPTSTR          pszShareName;
  41.     TCHAR           szDrive[4];
  42.     DWORD           dwSyncStatus;
  43.     LONG            cFilesToSync;
  44.     LONG            cFilesDone;
  45.     CscFilenameList *pUndoExclusionList;
  46.     DWORD           dwCscContext;
  47. } SYNCTHREADDATA, *PSYNCTHREADDATA;
  48. class CCscUpdate : ISyncMgrSynchronize
  49. {
  50. private:
  51.     LONG                            m_cRef;
  52.     CscFilenameList                *m_pFileList;
  53.     DWORD                           m_dwSyncFlags;
  54.     HDSA                            m_hSyncItems;
  55.     CSCEntryLog                     m_ShareLog;
  56.     LPSYNCMGRSYNCHRONIZECALLBACK    m_pSyncMgrCB;
  57.     HDPA                            m_hSyncThreads;
  58.     CRITICAL_SECTION                m_csThreadList;
  59.     HWND                            m_hwndDlgParent;
  60.     HANDLE                          m_hSyncMutex;
  61.     HANDLE                          m_hSyncInProgMutex;
  62.     CscFilenameList                *m_pConflictPinList;
  63.     CscFilenameList                *m_pSilentFolderList;
  64.     CscFilenameList                *m_pSpecialFolderList;
  65.     CscFilenameList                 m_ReconnectList;
  66. public:
  67.     CCscUpdate();
  68.     ~CCscUpdate();
  69.     static HRESULT WINAPI CreateInstance(REFIID riid, LPVOID *ppv);
  70.     // IUnknown methods
  71.     STDMETHODIMP         QueryInterface(REFIID riid, LPVOID *ppv);
  72.     STDMETHODIMP_(ULONG) AddRef();
  73.     STDMETHODIMP_(ULONG) Release();
  74.     // ISyncMgrSynchronize methods
  75.     STDMETHODIMP Initialize(DWORD dwReserved,
  76.                             DWORD dwSyncFlags,
  77.                             DWORD cbCookie,
  78.                             const BYTE *lpCookie);
  79.     STDMETHODIMP GetHandlerInfo(LPSYNCMGRHANDLERINFO *ppSyncMgrHandlerInfo);
  80.     STDMETHODIMP EnumSyncMgrItems(LPSYNCMGRENUMITEMS *ppenum);
  81.     STDMETHODIMP GetItemObject(REFSYNCMGRITEMID rItemID, REFIID riid, LPVOID *ppv);
  82.     STDMETHODIMP ShowProperties(HWND hWndParent, REFSYNCMGRITEMID rItemID);
  83.     STDMETHODIMP SetProgressCallback(LPSYNCMGRSYNCHRONIZECALLBACK pCallback);
  84.     STDMETHODIMP PrepareForSync(ULONG cbNumItems,
  85.                                 SYNCMGRITEMID *pItemIDs,
  86.                                 HWND hWndParent,
  87.                                 DWORD dwReserved);
  88.     STDMETHODIMP Synchronize(HWND hWndParent);
  89.     STDMETHODIMP SetItemStatus(REFSYNCMGRITEMID pItemID,
  90.                                DWORD dwSyncMgrStatus);
  91.     STDMETHODIMP ShowError(HWND hWndParent,
  92.                             REFSYNCMGRERRORID ErrorID);
  93. private:
  94.     HRESULT LogError(REFSYNCMGRITEMID rItemID,
  95.                      LPCTSTR pszText,
  96.                      DWORD dwLogLevel = SYNCMGRLOGLEVEL_ERROR,
  97.                      REFSYNCMGRERRORID ErrorID = GUID_NULL);
  98.     DWORD LogError(REFSYNCMGRITEMID rItemID,
  99.                    DWORD dwLogLevel,
  100.                    UINT nFormatID,
  101.                    ...);
  102.     DWORD LogError(REFSYNCMGRITEMID rItemID,
  103.                    UINT nFormatID,
  104.                    LPCTSTR pszName,
  105.                    DWORD dwErr,
  106.                    DWORD dwLogLevel = SYNCMGRLOGLEVEL_ERROR);
  107.     HRESULT SynchronizeShare(SYNCMGRITEMID *pItemID,
  108.                              LPCTSTR pszShareName,
  109.                              BOOL bRasConnected);
  110.     void  SetLastSyncTime(LPCTSTR pszShareName);
  111.     DWORD GetLastSyncTime(LPCTSTR pszShareName, LPFILETIME pft);
  112.     void  SyncThreadCompleted(PSYNCTHREADDATA pSyncData);
  113.     void  SyncCompleted(void);
  114.     DWORD CopyLocalFileWithDriveMapping(LPCTSTR pszSrc,
  115.                                         LPCTSTR pszDst,
  116.                                         LPCTSTR pszShare,
  117.                                         LPCTSTR pszDrive,
  118.                                         BOOL    bDirectory = FALSE);
  119.     DWORD HandleFileConflict(PSYNCTHREADDATA    pSyncData,
  120.                              LPCTSTR            pszName,
  121.                              DWORD              dwStatus,
  122.                              DWORD              dwHintFlags,
  123.                              LPWIN32_FIND_DATA  pFind32);
  124.     DWORD HandleDeleteConflict(PSYNCTHREADDATA   pSyncData,
  125.                                LPCTSTR           pszName,
  126.                                DWORD             dwStatus,
  127.                                DWORD             dwHintFlags,
  128.                                LPWIN32_FIND_DATA pFind32);
  129.     DWORD CscCallback(PSYNCTHREADDATA     pSyncData,
  130.                       LPCTSTR             pszName,
  131.                       DWORD               dwStatus,
  132.                       DWORD               dwHintFlags,
  133.                       DWORD               dwPinCount,
  134.                       LPWIN32_FIND_DATA   pFind32,
  135.                       DWORD               dwReason,
  136.                       DWORD               dwParam1,
  137.                       DWORD               dwParam2);
  138.     static void NotifySyncMgr(PSYNCTHREADDATA pSyncData,
  139.                               LPSYNCMGRPROGRESSITEM pspi);
  140.     static DWORD WINAPI _CscCallback(LPCTSTR             pszName,
  141.                                      DWORD               dwStatus,
  142.                                      DWORD               dwHintFlags,
  143.                                      DWORD               dwPinCount,
  144.                                      LPWIN32_FIND_DATA   pFind32,
  145.                                      DWORD               dwReason,
  146.                                      DWORD               dwParam1,
  147.                                      DWORD               dwParam2,
  148.                                      DWORD_PTR           dwContext);
  149.     BOOL PinLinkTarget(LPCTSTR pszName, PSYNCTHREADDATA pSyncData);
  150.     static DWORD WINAPI _PinNewFilesW32Callback(LPCTSTR             pszName,
  151.                                                 ENUM_REASON         eReason,
  152.                                                 LPWIN32_FIND_DATA   pFind32,
  153.                                                 LPARAM              lpContext);
  154.     static DWORD WINAPI _PinNewFilesCSCCallback(LPCTSTR             pszName,
  155.                                                 ENUM_REASON         eReason,
  156.                                                 DWORD               dwStatus,
  157.                                                 DWORD               dwHintFlags,
  158.                                                 DWORD               dwPinCount,
  159.                                                 LPWIN32_FIND_DATA   pFind32,
  160.                                                 LPARAM              lpContext);
  161.     static DWORD WINAPI _SyncThread(LPVOID pThreadData);
  162.     DWORD MergeShare(PSYNCTHREADDATA pSyncData);
  163.     DWORD FillShare(PSYNCTHREADDATA pSyncData, int cPinned, DWORD dwConnectionSpeed);
  164.     void PinFiles(PSYNCTHREADDATA pSyncData, BOOL bConflictPinList=FALSE);
  165.     void NotifyUndo(PSYNCTHREADDATA pSyncData, LPCTSTR pszName);
  166.     void UndoPinFiles(PSYNCTHREADDATA pSyncData);
  167.     static DWORD WINAPI _UndoProgress(LPCTSTR pszItem, LPARAM lpContext);
  168.     BOOL SkipEFSPin(PSYNCTHREADDATA pSyncData, LPCTSTR pszItem);
  169.     typedef enum
  170.     {
  171.         SyncStop = 0,
  172.         SyncPause,
  173.         SyncResume
  174.     } eSetSyncStatus;
  175.     HRESULT SetSyncThreadStatus(eSetSyncStatus status, REFGUID rItemID);
  176.     void GetSilentFolderList(void);
  177.     BOOL IsSilentFolder(LPCTSTR pszName)
  178.     { return (m_pSilentFolderList && m_pSilentFolderList->FileExists(pszName, false)); }
  179.     BOOL IsSilentShare(LPCTSTR pszShare)
  180.     { return (m_pSilentFolderList && m_pSilentFolderList->ShareExists(pszShare)); }
  181.     BOOL IsSpecialFolder(LPCTSTR pszName)
  182.     { return ((m_pSpecialFolderList && m_pSpecialFolderList->FileExists(pszName, false)) || IsSilentFolder(pszName)); }
  183.     BOOL IsSpecialFolderShare(LPCTSTR pszShare)
  184.     { return ((m_pSpecialFolderList && m_pSpecialFolderList->ShareExists(pszShare)) || IsSilentShare(pszShare)); }
  185.     friend class CUpdateEnumerator;
  186. };
  187. class CUpdateEnumerator : ISyncMgrEnumItems
  188. {
  189. private:
  190.     LONG                        m_cRef;
  191.     PCSCUPDATE                  m_pUpdate;
  192.     HANDLE                      m_hFind;
  193.     BOOL                        m_bEnumFileSelection;
  194.     INT                         m_cCheckedItemsEnumerated;
  195.     CscFilenameList::ShareIter  m_SelectionIterator;
  196. public:
  197.     CUpdateEnumerator(PCSCUPDATE pUpdate);
  198.     ~CUpdateEnumerator();
  199.     // IUnknown methods
  200.     STDMETHODIMP         QueryInterface(REFIID, LPVOID*);
  201.     STDMETHODIMP_(ULONG) AddRef();
  202.     STDMETHODIMP_(ULONG) Release();
  203.     // ISyncMgrEnumItems methods
  204.     STDMETHODIMP Next(ULONG celt, LPSYNCMGRITEM rgelt, PULONG pceltFetched);
  205.     STDMETHODIMP Skip(ULONG celt);
  206.     STDMETHODIMP Reset(void);
  207.     STDMETHODIMP Clone(LPSYNCMGRENUMITEMS *ppenum);
  208. };
  209. typedef CUpdateEnumerator *PUPDATEENUM;
  210. #endif  // _UPDATE_H_