1 // Licensed under the Apache License, Version 2.0
2 // <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
3 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option.
4 // All files in the project carrying such notice may not be copied, modified, or distributed
5 // except according to those terms.
6 //! Declaration of backup interfaces.
7 use ctypes::c_void;
8 use shared::guiddef::IID;
9 use shared::minwindef::{BOOL, BYTE, DWORD, UINT};
10 use shared::wtypes::BSTR;
11 use um::unknwnbase::{IUnknown, IUnknownVtbl};
12 use um::vss::{
13     IVssAsync, IVssEnumObject, VSS_BACKUP_TYPE, VSS_ID, VSS_OBJECT_TYPE, VSS_PWSZ,
14     VSS_RESTORE_TYPE, VSS_ROLLFORWARD_TYPE, VSS_SNAPSHOT_PROP, VSS_WRITER_STATE
15 };
16 use um::vswriter::{
17     IVssWMDependency, IVssWMFiledesc, IVssWriterComponentsVtbl, VSS_COMPONENT_TYPE,
18     VSS_FILE_RESTORE_STATUS, VSS_RESTOREMETHOD_ENUM, VSS_SOURCE_TYPE, VSS_USAGE_TYPE,
19     VSS_WRITERRESTORE_ENUM
20 };
21 use um::winnt::{HRESULT, LONG, LPCWSTR};
22 DEFINE_GUID!{IID_IVssExamineWriterMetadata,
23     0x902fcf7f, 0xb7fd, 0x42f8, 0x81, 0xf1, 0xb2, 0xe4, 0x00, 0xb1, 0xe5, 0xbd}
24 DEFINE_GUID!{IID_IVssExamineWriterMetadataEx,
25     0x0c0e5ec0, 0xca44, 0x472b, 0xb7, 0x02, 0xe6, 0x52, 0xdb, 0x1c, 0x04, 0x51}
26 DEFINE_GUID!{IID_IVssBackupComponents,
27     0x665c1d5f, 0xc218, 0x414d, 0xa0, 0x5d, 0x7f, 0xef, 0x5f, 0x9d, 0x5c, 0x86}
28 DEFINE_GUID!{IID_IVssBackupComponentsEx,
29     0x963f03ad, 0x9e4c, 0x4a34, 0xac, 0x15, 0xe4, 0xb6, 0x17, 0x4e, 0x50, 0x36}
30 STRUCT!{struct VSS_COMPONENTINFO {
31     type_: VSS_COMPONENT_TYPE, // type is a keyword in rust
32     bstrLogicalPath: BSTR,
33     bstrComponentName: BSTR,
34     bstrCaption: BSTR,
35     pbIcon: *mut BYTE,
36     cbIcon: UINT,
37     bRestoreMetadata: bool,
38     bNotifyOnBackupComplete: bool,
39     bSelectable: bool,
40     bSelectableForRestore: bool,
41     dwComponentFlags: DWORD,
42     cFileCount: UINT,
43     cDatabases: UINT,
44     cLogFiles: UINT,
45     cDependencies: UINT,
46 }}
47 pub type PVSSCOMPONENTINFO = *const VSS_COMPONENTINFO;
48 RIDL!{#[uuid(0x00000000, 0x0000, 0x0000, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00)]
49 interface IVssWMComponent(IVssWMComponentVtbl): IUnknown(IUnknownVtbl) {
50     fn GetComponentInfo(
51         ppInfo: *mut PVSSCOMPONENTINFO,
52     ) -> HRESULT,
53     fn FreeComponentInfo(
54         pInfo: PVSSCOMPONENTINFO,
55     ) -> HRESULT,
56     fn GetFile(
57         iFile: UINT,
58         ppFiledesc: *mut *mut IVssWMFiledesc,
59     ) -> HRESULT,
60     fn GetDatabaseFile(
61         iDBFile: UINT,
62         ppFiledesc: *mut *mut IVssWMFiledesc,
63     ) -> HRESULT,
64     fn GetDatabaseLogFile(
65         iDbLogFile: UINT,
66         ppFiledesc: *mut *mut IVssWMFiledesc,
67     ) -> HRESULT,
68     fn GetDependency(
69         iDependency: UINT,
70         ppDependency: *mut *mut IVssWMDependency,
71     ) -> HRESULT,
72 }}
73 RIDL!{#[uuid(0x902fcf7f, 0xb7fd, 0x42f8, 0x81, 0xf1, 0xb2, 0xe4, 0x00, 0xb1, 0xe5, 0xbd)]
74 interface IVssExamineWriterMetadata(IVssExamineWriterMetadataVtbl): IUnknown(IUnknownVtbl) {
75     fn GetIdentity(
76         pidInstance: *mut VSS_ID,
77         pidWriter: *mut VSS_ID,
78         pbstrWriterName: *mut BSTR,
79         pUsage: *mut VSS_USAGE_TYPE,
80         pSource: *mut VSS_SOURCE_TYPE,
81     ) -> HRESULT,
82     fn GetFileCounts(
83         pcIncludeFiles: *mut UINT,
84         pcExcludeFiles: *mut UINT,
85         pcComponents: *mut UINT,
86     ) -> HRESULT,
87     fn GetIncludeFile(
88         iFile: UINT,
89         ppFiledesc: *mut *mut IVssWMFiledesc,
90     ) -> HRESULT,
91     fn GetExcludeFile(
92         iFile: UINT,
93         ppFiledesc: *mut *mut IVssWMFiledesc,
94     ) -> HRESULT,
95     fn GetComponent(
96         iComponent: UINT,
97         ppComponent: *mut *mut IVssWMComponent,
98     ) -> HRESULT,
99     fn GetRestoreMethod(
100         pMethod: *mut VSS_RESTOREMETHOD_ENUM,
101         pbstrService: *mut BSTR,
102         pbstrUserProcedure: *mut BSTR,
103         pwriterRestore: *mut VSS_WRITERRESTORE_ENUM,
104         pbRebootRequired: *mut bool,
105         pcMappings: *mut UINT,
106     ) -> HRESULT,
107     fn GetAlternateLocationMapping(
108         iMapping: UINT,
109         ppFiledesc: *mut *mut IVssWMFiledesc,
110     ) -> HRESULT,
111     fn GetBackupSchema(
112         pdwSchemaMask: *mut DWORD,
113     ) -> HRESULT,
114     fn GetDocument(
115         pDoc: *mut c_void,
116     ) -> HRESULT, //TODO IXMLDOMDocument,
117     fn SaveAsXML(
118         pbstrXML: *mut BSTR,
119     ) -> HRESULT,
120     fn LoadFromXML(
121         pbstrXML: *mut BSTR,
122     ) -> HRESULT,
123 }}
124 RIDL!{#[uuid(0x0c0e5ec0, 0xca44, 0x472b, 0xb7, 0x02, 0xe6, 0x52, 0xdb, 0x1c, 0x04, 0x51)]
125 interface IVssExamineWriterMetadataEx(IVssExamineWriterMetadataExVtbl):
126     IVssExamineWriterMetadata(IVssExamineWriterMetadataVtbl) {
127     fn GetIdentityEx(
128         pidInstance: *mut VSS_ID,
129         pidWriter: *mut VSS_ID,
130         pbstrWriterName: *mut BSTR,
131         pbstrInstanceName: *mut BSTR,
132         pUsage: *mut VSS_USAGE_TYPE,
133         pSource: *mut VSS_SOURCE_TYPE,
134     ) -> HRESULT,
135 }}
136 RIDL!{#[uuid(0xce115780, 0xa611, 0x431b, 0xb5, 0x7f, 0xc3, 0x83, 0x03, 0xab, 0x6a, 0xee)]
137 interface IVssExamineWriterMetadataEx2(IVssExamineWriterMetadataEx2Vtbl):
138     IVssExamineWriterMetadataEx(IVssExamineWriterMetadataExVtbl) {
139     fn GetVersion(
140         pdwMajorVersion: *mut DWORD,
141         pdwMinorVersion: *mut DWORD,
142     ) -> HRESULT,
143     fn GetExcludeFromSnapshotCount(
144         pcExcludedFromSnapshot: *mut UINT,
145     ) -> HRESULT,
146     fn GetExcludeFromSnapshotFile(
147         iFile: UINT,
148         ppFiledesc: *mut *mut IVssWMFiledesc,
149     ) -> HRESULT,
150 }}
151 #[repr(C)]
152 pub struct IVssWriterComponentsExt {
153     pub lpVtbl: *const IVssWriterComponentsExtVtbl,
154 }
155 #[repr(C)]
156 pub struct IVssWriterComponentsExtVtbl {
157     pub parent1: IVssWriterComponentsVtbl,
158     pub parent2: IUnknownVtbl,
159 }
160 RIDL!{#[uuid(0x665c1d5f, 0xc218, 0x414d, 0xa0, 0x5d, 0x7f, 0xef, 0x5f, 0x9d, 0x5c, 0x86)]
161 interface IVssBackupComponents(IVssBackupComponentsVtbl): IUnknown(IUnknownVtbl) {
162     fn GetWriterComponentsCount(
163         pcComponents: *mut UINT,
164     ) -> HRESULT,
165     fn GetWriterComponents(
166         iWriter: UINT,
167         ppWriter: *mut *mut IVssWriterComponentsExt,
168     ) -> HRESULT,
169     fn InitializeForBackup(
170         bstrXML: BSTR,
171     ) -> HRESULT,
172     fn SetBackupState(
173         bSelectComponents: bool,
174         bBackupBootableSystemState: bool,
175         backupType: VSS_BACKUP_TYPE,
176         bPartialFileSupport: bool,
177     ) -> HRESULT,
178     fn InitializeForRestore(
179         bstrXML: BSTR,
180     ) -> HRESULT,
181     fn SetRestoreState(
182         restoreType: VSS_RESTORE_TYPE,
183     ) -> HRESULT,
184     fn GatherWriterMetadata(
185         pAsync: *mut *mut IVssAsync,
186     ) -> HRESULT,
187     fn GetWriterMetadataCount(
188         pcWriters: *mut UINT,
189     ) -> HRESULT,
190     fn GetWriterMetadata(
191         iWriter: UINT,
192         pidInstance: *mut VSS_ID,
193         ppMetadata: *mut *mut IVssExamineWriterMetadata,
194     ) -> HRESULT,
195     fn FreeWriterMetadata() -> HRESULT,
196     fn AddComponent(
197         instanceId: VSS_ID,
198         writerId: VSS_ID,
199         ct: VSS_COMPONENT_TYPE,
200         wszLogicalPath: LPCWSTR,
201         wszComponentName: LPCWSTR,
202     ) -> HRESULT,
203     fn PrepareForBackup(
204         ppAsync: *mut *mut IVssAsync,
205     ) -> HRESULT,
206     fn AbortBackup() -> HRESULT,
207     fn GatherWriterStatus(
208         ppAsync: *mut *mut IVssAsync,
209     ) -> HRESULT,
210     fn GetWriterStatusCount(
211         pcWriters: *mut UINT,
212     ) -> HRESULT,
213     fn FreeWriterStatus() -> HRESULT,
214     fn GetWriterStatus(
215         iWriter: UINT,
216         pidInstance: *mut VSS_ID,
217         pidWriter: *mut VSS_ID,
218         pbstrWriter: *mut BSTR,
219         pnStatus: *mut VSS_WRITER_STATE,
220         phResultFailure: *mut HRESULT,
221     ) -> HRESULT,
222     fn SetBackupSucceeded(
223         instanceId: VSS_ID,
224         writerId: VSS_ID,
225         ct: VSS_COMPONENT_TYPE,
226         wszLogicalPath: LPCWSTR,
227         wszComponentName: LPCWSTR,
228         bSucceded: bool,
229     ) -> HRESULT,
230     fn SetBackupOptions(
231         writerId: VSS_ID,
232         ct: VSS_COMPONENT_TYPE,
233         wszLogicalPath: LPCWSTR,
234         wszComponentName: LPCWSTR,
235         wszBackupOptions: LPCWSTR,
236     ) -> HRESULT,
237     fn SetSelectedForRestore(
238         writerId: VSS_ID,
239         ct: VSS_COMPONENT_TYPE,
240         wszLogicalPath: LPCWSTR,
241         wszComponentName: LPCWSTR,
242         bSelectedForRestore: bool,
243     ) -> HRESULT,
244     fn SetRestoreOptions(
245         writerId: VSS_ID,
246         ct: VSS_COMPONENT_TYPE,
247         wszLogicalPath: LPCWSTR,
248         wszComponentName: LPCWSTR,
249         wszRestoreOptions: LPCWSTR,
250     ) -> HRESULT,
251     fn SetAdditionalRestores(
252         writerId: VSS_ID,
253         ct: VSS_COMPONENT_TYPE,
254         wszLogicalPath: LPCWSTR,
255         wszComponentName: LPCWSTR,
256         bAdditionalRestores: bool,
257     ) -> HRESULT,
258     fn SetPreviousBackupStamp(
259         writerId: VSS_ID,
260         ct: VSS_COMPONENT_TYPE,
261         wszLogicalPath: LPCWSTR,
262         wszComponentName: LPCWSTR,
263         wszPreviousBackupStamp: LPCWSTR,
264     ) -> HRESULT,
265     fn SaveAsXML(
266         pbstrXML: *mut BSTR,
267     ) -> HRESULT,
268     fn BackupComplete(
269         ppAsync: *mut *mut IVssAsync,
270     ) -> HRESULT,
271     fn AddAlternativeLocationMapping(
272         writerId: VSS_ID,
273         ct: VSS_COMPONENT_TYPE,
274         wszLogicalPath: LPCWSTR,
275         wszComponentName: LPCWSTR,
276         wszPath: LPCWSTR,
277         wszFilespec: LPCWSTR,
278         bRecursive: bool,
279         wszDestination: LPCWSTR,
280     ) -> HRESULT,
281     fn AddRestoreSubcomponent(
282         writerId: VSS_ID,
283         ct: VSS_COMPONENT_TYPE,
284         wszLogicalPath: LPCWSTR,
285         wszComponentName: LPCWSTR,
286         wszSubComponentLogicalPath: LPCWSTR,
287         wszSubComponentName: LPCWSTR,
288         bRepair: bool,
289     ) -> HRESULT,
290     fn SetFileRestoreStatus(
291         writerId: VSS_ID,
292         ct: VSS_COMPONENT_TYPE,
293         wszLogicalPath: LPCWSTR,
294         wszComponentName: LPCWSTR,
295         status: VSS_FILE_RESTORE_STATUS,
296     ) -> HRESULT,
297     fn AddNewTarget(
298         writerId: VSS_ID,
299         ct: VSS_COMPONENT_TYPE,
300         wszLogicalPath: LPCWSTR,
301         wszComponentName: LPCWSTR,
302         wszPath: LPCWSTR,
303         wszFileName: LPCWSTR,
304         bRecursive: bool,
305         wszAlternatePath: LPCWSTR,
306     ) -> HRESULT,
307     fn SetRangesFilePath(
308         writerId: VSS_ID,
309         ct: VSS_COMPONENT_TYPE,
310         wszLogicalPath: LPCWSTR,
311         wszComponentName: LPCWSTR,
312         iPartialFile: UINT,
313         wszRangesFile: LPCWSTR,
314     ) -> HRESULT,
315     fn PreRestore(
316         ppAsync: *mut *mut IVssAsync,
317     ) -> HRESULT,
318     fn PostRestore(
319         ppAsync: *mut *mut IVssAsync,
320     ) -> HRESULT,
321     fn SetContext(
322         lContext: LONG,
323     ) -> HRESULT,
324     fn StartSnapshotSet(
325         pSnapshotSetId: *mut VSS_ID,
326     ) -> HRESULT,
327     fn AddToSnapshotSet(
328         pwszVolumeName: VSS_PWSZ,
329         ProviderId: VSS_ID,
330         pidSnapshot: *mut VSS_ID,
331     ) -> HRESULT,
332     fn DoSnapshotSet(
333         ppAsync: *mut *mut IVssAsync,
334     ) -> HRESULT,
335     fn DeleteSnapshots(
336         SourceObjectId: VSS_ID,
337         eSourceObjectType: VSS_OBJECT_TYPE,
338         bForceDelete: BOOL,
339         plDeletedSnapshots: *mut LONG,
340         pNondeletedSnapshotID: *mut VSS_ID,
341     ) -> HRESULT,
342     fn ImportSnapshots(
343         ppAsync: *mut *mut IVssAsync,
344     ) -> HRESULT,
345     fn BreakSnapshotSet(
346         SnapshotSetId: VSS_ID,
347     ) -> HRESULT,
348     fn GetSnapshotProperties(
349         SnapshotId: VSS_ID,
350         pProp: *mut VSS_SNAPSHOT_PROP,
351     ) -> HRESULT,
352     fn Query(
353         QueriedObjectId: VSS_ID,
354         eQueriedObjectType: VSS_OBJECT_TYPE,
355         eReturnedObjectsType: VSS_OBJECT_TYPE,
356         ppEnum: *mut *mut IVssEnumObject,
357     ) -> HRESULT,
358     fn IsVolumeSupported(
359         ProviderId: VSS_ID,
360         pwszVolumeName: VSS_PWSZ,
361         pbSupportedByThisProvider: *mut BOOL,
362     ) -> HRESULT,
363     fn DisableWriterClasses(
364         rgWriterClassId: *const VSS_ID,
365         cClassId: UINT,
366     ) -> HRESULT,
367     fn EnableWriterClasses(
368         rgWriterClassId: *const VSS_ID,
369         cClassId: UINT,
370     ) -> HRESULT,
371     fn DisableWriterInstances(
372         rgWriterInstanceId: *const VSS_ID,
373         cInstanceId: UINT,
374     ) -> HRESULT,
375     fn ExposeSnapshot(
376         SnapshotId: VSS_ID,
377         wszPathFromRoot: VSS_PWSZ,
378         lAttributes: LONG,
379         wszExpose: VSS_PWSZ,
380         pwszExposed: VSS_PWSZ,
381     ) -> HRESULT,
382     fn RevertToSnapshot(
383         SnapshotId: VSS_ID,
384         bForceDismount: BOOL,
385     ) -> HRESULT,
386     fn QueryRevertStatus(
387         pwszVolume: VSS_PWSZ,
388         ppAsync: *mut *mut IVssAsync,
389     ) -> HRESULT,
390 }}
391 RIDL!{#[uuid(0x963f03ad, 0x9e4c, 0x4a34, 0xac, 0x15, 0xe4, 0xb6, 0x17, 0x4e, 0x50, 0x36)]
392 interface IVssBackupComponentsEx(IVssBackupComponentsExVtbl):
393     IVssBackupComponents(IVssBackupComponentsVtbl) {
394     fn GetWriterMetadataEx(
395         iWriter: UINT,
396         pidInstance: *mut VSS_ID,
397         ppMetadata: *mut *mut IVssExamineWriterMetadataEx,
398     ) -> HRESULT,
399     fn SetSelectedForRestoreEx(
400         writerId: VSS_ID,
401         ct: VSS_COMPONENT_TYPE,
402         wszLogicalPath: LPCWSTR,
403         wszComponentName: LPCWSTR,
404         bSelectedForRestore: bool,
405         instanceId: VSS_ID,
406     ) -> HRESULT,
407 }}
408 RIDL!{#[uuid(0xacfe2b3a, 0x22c9, 0x4ef8, 0xbd, 0x03, 0x2f, 0x9c, 0xa2, 0x30, 0x08, 0x4e)]
409 interface IVssBackupComponentsEx2(IVssBackupComponentsEx2Vtbl):
410     IVssBackupComponentsEx(IVssBackupComponentsExVtbl) {
411     fn UnexposeSnapshot(
412         snapshotId: VSS_ID,
413     ) -> HRESULT,
414     fn SetAuthoritativeRestore(
415         writerId: VSS_ID,
416         ct: VSS_COMPONENT_TYPE,
417         wszLogicalPath: LPCWSTR,
418         wszComponentName: LPCWSTR,
419         bAuth: bool,
420     ) -> HRESULT,
421     fn SetRollForward(
422         writerId: VSS_ID,
423         ct: VSS_COMPONENT_TYPE,
424         wszLogicalPath: LPCWSTR,
425         wszComponentName: LPCWSTR,
426         rollType: VSS_ROLLFORWARD_TYPE,
427         wszRollForwardPoint: LPCWSTR,
428     ) -> HRESULT,
429     fn SetRestoreName(
430         writerId: VSS_ID,
431         ct: VSS_COMPONENT_TYPE,
432         wszLogicalPath: LPCWSTR,
433         wszComponentName: LPCWSTR,
434         wszRestoreName: LPCWSTR,
435     ) -> HRESULT,
436     fn BreakSnapshotSetEx(
437         SnapshotSetID: VSS_ID,
438         dwBreakFlags: DWORD,
439         ppAsync: *mut *mut IVssAsync,
440     ) -> HRESULT,
441     fn PreFastRecovery(
442         SnapshotSetID: VSS_ID,
443         dwPreFastRecoveryFlags: DWORD,
444         ppAsync: *mut *mut IVssAsync,
445     ) -> HRESULT,
446     fn FastRecovery(
447         SnapshotSetID: VSS_ID,
448         dwFastRecoveryFlags: DWORD,
449         ppAsync: *mut *mut IVssAsync,
450     ) -> HRESULT,
451 }}
452 RIDL!{#[uuid(0xc191bfbc, 0xb602, 0x4675, 0x8b, 0xd1, 0x67, 0xd6, 0x42, 0xf5, 0x29, 0xd5)]
453 interface IVssBackupComponentsEx3(IVssBackupComponentsEx3Vtbl):
454     IVssBackupComponentsEx2(IVssBackupComponentsEx2Vtbl) {
455     fn GetWriterStatusEx(
456         iWriter: UINT,
457         pidInstance: *mut VSS_ID,
458         pidWriter: *mut VSS_ID,
459         pbstrWriter: *mut BSTR,
460         pnStatus: *mut VSS_WRITER_STATE,
461         phrFailureWriter: *mut HRESULT,
462         phrApplication: *mut HRESULT,
463         pbstrApplicationMessage: *mut BSTR,
464     ) -> HRESULT,
465     fn AddSnapshotToRecoverySet(
466         snapshotId: VSS_ID,
467         dwFlags: DWORD,
468         pwszDestinationVolume: VSS_PWSZ,
469     ) -> HRESULT,
470     fn RecoverSet(
471         dwFlags: DWORD,
472         ppAsync: *mut *mut IVssAsync,
473     ) -> HRESULT,
474     fn GetSessionId(
475         idSession: *mut VSS_ID,
476     ) -> HRESULT,
477 }}
478 RIDL!{#[uuid(0xf434c2fd, 0xb553, 0x4961, 0xa9, 0xf9, 0xa8, 0xe9, 0x0b, 0x67, 0x3e, 0x53)]
479 interface IVssBackupComponentsEx4(IVssBackupComponentsEx4Vtbl):
480     IVssBackupComponentsEx3(IVssBackupComponentsEx3Vtbl) {
481     fn GetRootAndLogicalPrefixPaths(
482         pwszFilePath: VSS_PWSZ,
483         ppwszRootPath: *mut VSS_PWSZ,
484         ppwszLogicalPrefix: *mut VSS_PWSZ,
485         bNormalizeFQDNforRootPath: BOOL,
486     ) -> HRESULT,
487 }}
488 pub const VSS_SW_BOOTABLE_STATE: DWORD = 1;
489 extern "system" {
490     #[link_name="CreateVssBackupComponentsInternal"]
CreateVssBackupComponents( ppBackup: *mut *mut IVssBackupComponents, ) -> HRESULT491     pub fn CreateVssBackupComponents(
492         ppBackup: *mut *mut IVssBackupComponents,
493     ) -> HRESULT;
494     #[link_name="CreateVssExamineWriterMetadataInternal"]
CreateVssExamineWriterMetadata( bstrXML: BSTR, ppMetadata: *mut *mut IVssExamineWriterMetadata, ) -> HRESULT495     pub fn CreateVssExamineWriterMetadata(
496         bstrXML: BSTR,
497         ppMetadata: *mut *mut IVssExamineWriterMetadata,
498     ) -> HRESULT;
499     #[link_name="IsVolumeSnapshottedInternal"]
IsVolumeSnapshotted( pwszVolumeName: VSS_PWSZ, pbSnapshotsPresent: *mut BOOL, plSnapshotCapability: *mut LONG, ) -> HRESULT500     pub fn IsVolumeSnapshotted(
501         pwszVolumeName: VSS_PWSZ,
502         pbSnapshotsPresent: *mut BOOL,
503         plSnapshotCapability: *mut LONG,
504     ) -> HRESULT;
505     #[link_name="VssFreeSnapshotPropertiesInternal"]
VssFreeSnapshotProperties( pProp: *mut VSS_SNAPSHOT_PROP, )506     pub fn VssFreeSnapshotProperties(
507         pProp: *mut VSS_SNAPSHOT_PROP,
508     );
509     #[link_name="GetProviderMgmtInterfaceInternal"]
GetProviderMgmtInterface( ProviderId: VSS_ID, InterfaceId: IID, ppItf: *mut *mut IUnknown, ) -> HRESULT510     pub fn GetProviderMgmtInterface(
511         ProviderId: VSS_ID,
512         InterfaceId: IID,
513         ppItf: *mut *mut IUnknown,
514     ) -> HRESULT;
515     #[link_name="ShouldBlockRevertInternal"]
ShouldBlockRevert( wszVolumeName: LPCWSTR, pbBlock: *mut bool, ) -> HRESULT516     pub fn ShouldBlockRevert(
517         wszVolumeName: LPCWSTR,
518         pbBlock: *mut bool,
519     ) -> HRESULT;
520 }
521