Windows: GetVolumeInfo cell name
[openafs.git] / src / WINNT / afsrdr / common / AFSUserStructs.h
1 /*
2  * Copyright (c) 2008-2011 Kernel Drivers, LLC.
3  * Copyright (c) 2009-2011 Your File System, Inc.
4  * All rights reserved.
5  *
6  * Redistribution and use in source and binary forms, with or without
7  * modification, are permitted provided that the following conditions
8  * are met:
9  *
10  * - Redistributions of source code must retain the above copyright notice,
11  *   this list of conditions and the following disclaimer.
12  * - Redistributions in binary form must reproduce the above copyright
13  *   notice,
14  *   this list of conditions and the following disclaimer in the
15  *   documentation
16  *   and/or other materials provided with the distribution.
17  * - Neither the name of Kernel Drivers, LLC nor the names of its
18  *   contributors may be
19  *   used to endorse or promote products derived from this software without
20  *   specific prior written permission from Kernel Drivers, LLC
21  *   and Your File System, Inc.
22  *
23  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
24  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
25  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
26  * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
27  * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
28  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
29  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
30  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
31  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
32  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
33  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
34  */
35
36 #ifndef _AFS_USER_STRUCT_H
37 #define _AFS_USER_STRUCT_H
38
39 typedef struct _AFS_FILE_ID
40 {
41
42     ULONG    Hash;
43
44     ULONG    Cell;
45
46     ULONG    Volume;
47
48     ULONG    Vnode;
49
50     ULONG    Unique;
51
52 } AFSFileID;
53
54 //
55 // This control structure is the request block passed to the filter. The filter will populate the structure
56 // when it requires a request to be handled by the service.
57 //
58
59 typedef struct _AFS_COMM_REQUEST_BLOCK
60 {
61
62     AFSFileID       FileId;             /* Initialize unused elements to 0 */
63
64     ULONG           RequestType;
65
66     ULONG           RequestIndex;    /* Must return to caller */
67
68     ULONG           RequestFlags;    /* AFS_REQUEST_FLAG_xxxx */
69
70     ULONG           NameLength;      // Length of the name in bytes
71
72     ULONG           DataOffset;       // This offset is from the end of the structure, including the name
73
74     ULONG           DataLength;
75
76     GUID            AuthGroup;      // Length: sizeof(GUID) */
77
78     ULONG           ResultBufferLength;    /* Do not exceed this length in response */
79
80     LONG            QueueCount;     // Current outstanding requests in the queue
81
82     WCHAR           Name[ 1];
83
84 } AFSCommRequest;
85
86
87 //
88 // This is the result block passed back to the redirector after a request has been handled
89 //
90
91 typedef struct _AFS_COMM_RESULT_BLOCK
92 {
93
94     ULONG           RequestIndex;        /* Must match the AFSCommRequest value */
95
96     ULONG           ResultStatus;        /* NTSTATUS_xxx */
97
98     ULONG           ResultBufferLength;    /* Not to exceed AFSCommRequest ResultBufferLength */
99
100     ULONG           Reserved;           /* To ease Quad Alignment */
101
102     char            ResultData[ 1];
103
104 } AFSCommResult;
105
106 //
107 // Control block passed to IOCTL_AFS_INITIALIZE_REDIRECTOR_DEVICE
108 //
109
110 #define AFS_REDIR_INIT_FLAG_HIDE_DOT_FILES          0x00000001
111 #define AFS_REDIR_INIT_NO_PAGING_FILE               0x00000002
112 #define AFS_REDIR_INIT_FLAG_DISABLE_SHORTNAMES      0x00000004
113
114 typedef struct _AFS_REDIR_INIT_INFO_CB
115 {
116
117     ULONG       Flags;
118
119     ULONG       MaximumChunkLength;     // Maximum RPC length issued so we should limit
120                                         // requests for data to this length
121
122     AFSFileID   GlobalFileId;           // AFS FID of the Global root.afs volume
123
124     LARGE_INTEGER  ExtentCount;         // Number of extents in the current data cache
125
126     ULONG       CacheBlockSize;         // Size, in bytes, of the current cache block
127
128     ULONG       MaxPathLinkCount;       // Number of symlinks / mountpoints that may
129                                         // be cross during the evaluation of any path
130
131     ULONG       NameArrayLength;        // Number of components that should be allocated
132                                         // in each name array chunk.  Name arrays are
133                                         // dynamic and will be increased in size as
134                                         // needed by this amount
135
136     LARGE_INTEGER MemoryCacheOffset;    // The offset in the afsd_service process memory
137                                         // space at which the extents are allocated
138     LARGE_INTEGER MemoryCacheLength;    // and the length of the allocated region
139
140     ULONG       DumpFileLocationOffset; // Offset from the beginning of this structure to
141                                         // the start of the directory where dump files
142                                         // are to be stored. The path must be fully
143                                         // qualified such as C:\Windows\Temp
144
145     ULONG       DumpFileLocationLength; // Length, in bytes, of the DumpFileLocation path
146
147     ULONG       CacheFileNameLength;    // size, in bytes, of the cache file name
148
149     WCHAR       CacheFileName[ 1];      // Fully qualified cache file name in the form
150                                         // C:\OPenAFSDir\CacheFile.dat
151
152 } AFSRedirectorInitInfo;
153
154 //
155 // Directory query CB
156 //
157
158 typedef struct _AFS_DIR_QUERY_CB
159 {
160
161     ULONG_PTR        EnumHandle;  // If this is 0 then it is a new query,
162                                   // otherwise it is the FileIndex of the last
163                                   // entry processed.
164
165 } AFSDirQueryCB;
166
167 //
168 // Directory enumeration control block
169 // Entries are aligned on a QuadWord boundary
170 //
171
172 typedef struct _AFS_DIR_ENUM_ENTRY
173 {
174
175     AFSFileID       FileId;
176
177     ULONG           FileIndex;          /* Incremented  */
178
179     LARGE_INTEGER   Expiration;         /* FILETIME */
180
181     LARGE_INTEGER   DataVersion;
182
183     ULONG           FileType;           /* File, Dir, MountPoint, Symlink */
184
185     LARGE_INTEGER   CreationTime;       /* FILETIME */
186
187     LARGE_INTEGER   LastAccessTime;     /* FILETIME */
188
189     LARGE_INTEGER   LastWriteTime;      /* FILETIME */
190
191     LARGE_INTEGER   ChangeTime;         /* FILETIME */
192
193     LARGE_INTEGER   EndOfFile;
194
195     LARGE_INTEGER   AllocationSize;
196
197     ULONG           FileAttributes;     /* NTFS FILE_ATTRIBUTE_xxxx see below */
198
199     ULONG           FileNameLength;
200
201     ULONG           EaSize;
202
203     ULONG           Links;
204
205     ULONG           FileNameOffset;     /* From beginning of this structure */
206
207     ULONG           TargetNameOffset;   /* From beginning of this structure */
208
209     ULONG           TargetNameLength;
210
211     AFSFileID       TargetFileId;       /* Target fid for mp's and symlinks */
212
213     CCHAR           ShortNameLength;
214
215     WCHAR           ShortName[12];
216
217     ULONG           NTStatus;           /* Error code during enumeration */
218
219     /* Long Filename and Target (Symlink and MountPoint only) to follow without NULs */
220
221 } AFSDirEnumEntry;
222
223
224 typedef struct _AFS_DIR_ENUM_RESP
225 {
226
227     ULONG_PTR       EnumHandle;
228
229     LARGE_INTEGER   SnapshotDataVersion; /* DV at time Name/FID list was generated */
230
231     LARGE_INTEGER   CurrentDataVersion;   /* DV at time this header was constructed */
232
233     AFSDirEnumEntry Entry[ 1];     /* Each entry is Quad aligned */
234
235 } AFSDirEnumResp;
236
237 //
238 // Volume information CB passed in the create request
239 //
240
241 typedef struct _AFS_VOLUME_INFORMATION
242 {
243
244     LARGE_INTEGER   TotalAllocationUnits;       /* Volume Max Blocks (Partition or Quota) */
245
246     LARGE_INTEGER   AvailableAllocationUnits;   /* Volume Blocks Avail (Partition or Quota) */
247
248     LARGE_INTEGER   VolumeCreationTime;         /* AFS Last Update - Not Creation */
249
250     ULONG           Characteristics;            /* FILE_READ_ONLY_DEVICE (if readonly)
251                                                  * FILE_REMOTE_DEVICE (always)
252                                                  */
253
254     ULONG           FileSystemAttributes;       /* FILE_CASE_PRESERVED_NAMES (always)
255                                                    FILE_UNICODE_ON_DISK      (always) */
256
257     ULONG           SectorsPerAllocationUnit;   /* = 1 */
258
259     ULONG           BytesPerSector;             /* = 1024 */
260
261     ULONG           CellID;                     /* AFS Cell ID */
262
263     ULONG           VolumeID;                   /* AFS Volume ID */
264
265     ULONG           VolumeLabelLength;
266
267     WCHAR           VolumeLabel[128];           /* Volume */
268
269     ULONG           CellLength;
270
271     WCHAR           Cell[128];                  /* Cell */
272
273 } AFSVolumeInfoCB;
274
275
276 //
277 // Volume size information CB passed used to satisfy
278 // FileFsFullSizeInformation and FileFsSizeInformation
279 //
280
281 typedef struct _AFS_VOLUME_SIZE_INFORMATION
282 {
283
284     LARGE_INTEGER   TotalAllocationUnits;       /* Max Blocks (Quota or Partition) */
285
286     LARGE_INTEGER   AvailableAllocationUnits;   /* Blocks Avail (Quota or Partition) */
287
288     ULONG           SectorsPerAllocationUnit;   /* = 1 */
289
290     ULONG           BytesPerSector;             /* = 1024 */
291
292 } AFSVolumeSizeInfoCB;
293
294 //
295 // File create CB
296 //
297
298 typedef struct _AFS_FILE_CREATE_CB
299 {
300
301     AFSFileID       ParentId;
302
303     LARGE_INTEGER   AllocationSize;
304
305     ULONG           FileAttributes;
306
307     ULONG           EaSize;
308
309     char            EaBuffer[ 1];
310
311 } AFSFileCreateCB;
312
313 typedef struct _AFS_FILE_CREATE_RESULT_CB
314 {
315
316     LARGE_INTEGER   ParentDataVersion;
317
318     AFSDirEnumEntry DirEnum;
319
320 } AFSFileCreateResultCB;
321
322 //
323 // File open CB
324 //
325
326 typedef struct _AFS_FILE_OPEN_CB
327 {
328
329     AFSFileID       ParentId;
330
331     ULONG           DesiredAccess;
332
333     ULONG           ShareAccess;
334
335     ULONGLONG       ProcessId;
336
337     ULONGLONG       Identifier;
338
339 } AFSFileOpenCB;
340
341 typedef struct _AFS_FILE_OPEN_RESULT_CB
342 {
343
344     ULONG           GrantedAccess;
345
346     ULONG           FileAccess;
347
348     ULONG           Authenticated;
349
350 } AFSFileOpenResultCB;
351
352 typedef struct _AFS_FILE_ACCESS_RELEASE_CB
353 {
354
355     ULONG           FileAccess;
356
357     ULONGLONG       ProcessId;
358
359     ULONGLONG       Identifier;
360
361 } AFSFileAccessReleaseCB;
362
363 //
364 // IO Interace control blocks for extent processing when performing
365 // queries via the AFS_REQUEST_TYPE_REQUEST_FILE_EXTENTS or synchronous
366 // results from the service
367 //
368
369 typedef struct _AFS_FILE_EXTENT_CB
370 {
371
372     ULONG           Flags;
373
374     ULONG           Length;
375
376     LARGE_INTEGER   FileOffset;
377
378     LARGE_INTEGER   CacheOffset;
379
380     UCHAR           MD5[16];
381
382     ULONG           DirtyOffset;
383
384     ULONG           DirtyLength;
385
386 } AFSFileExtentCB;
387
388 typedef struct _AFS_REQUEST_EXTENTS_CB
389 {
390
391     ULONG           Flags;
392
393     LARGE_INTEGER   ByteOffset;
394
395     ULONG           Length;
396
397 } AFSRequestExtentsCB;
398
399 //
400 // Extent processing when the file system calls the service to
401 // release extents through the AFS_REQUEST_TYPE_RELEASE_FILE_EXTENTS interface
402 //
403
404 typedef struct _AFS_RELEASE_EXTENTS_CB
405 {
406
407     ULONG           Flags;
408
409     ULONG           ExtentCount;
410
411     LARGE_INTEGER   LastAccessTime;
412
413     LARGE_INTEGER   LastWriteTime;
414
415     LARGE_INTEGER   ChangeTime;
416
417     LARGE_INTEGER   CreateTime;
418
419     LARGE_INTEGER   AllocationSize;
420
421     AFSFileExtentCB FileExtents[ 1];
422
423 } AFSReleaseExtentsCB;
424
425 //
426 // This is the control structure used when the service passes the extent
427 // information via the IOCTL_AFS_SET_FILE_EXTENTS interface
428 //
429
430 typedef struct _AFS_SET_FILE_EXTENTS_CB
431 {
432
433     AFSFileID       FileId;
434
435     ULONG           ExtentCount;
436
437     ULONG           ResultStatus;
438
439     AFSFileExtentCB FileExtents[ 1];
440
441 } AFSSetFileExtentsCB;
442
443 //
444 // This is the control structure used when the service passes the extent
445 // information via the IOCTL_AFS_RELEASE_FILE_EXTENTS interface
446 //
447
448 #define AFS_RELEASE_EXTENTS_FLAGS_RELEASE_ALL       0x00000001
449
450 typedef struct _AFS_RELEASE_FILE_EXTENTS_CB
451 {
452
453     ULONG           Flags;
454
455     AFSFileID       FileId;
456
457     ULONG           ExtentCount;
458
459     LARGE_INTEGER   HeldExtentCount;
460
461     AFSFileExtentCB FileExtents[ 1];
462
463 } AFSReleaseFileExtentsCB;
464
465 //
466 // These are the control structures that the filesystem returns from a
467 // IOCTL_AFS_RELEASE_FILE_EXTENTS
468 //
469
470 typedef struct _AFS_RELEASE_FILE_EXTENTS_RESULT_FILE_CB
471 {
472     AFSFileID       FileId;
473
474     ULONG           Flags;
475
476     GUID            AuthGroup; /* Length: sizeof(GUID) */
477
478     ULONG           ExtentCount;
479
480     LARGE_INTEGER   LastAccessTime;
481
482     LARGE_INTEGER   LastWriteTime;
483
484     LARGE_INTEGER   ChangeTime;
485
486     LARGE_INTEGER   CreateTime;
487
488     LARGE_INTEGER   AllocationSize;
489
490     AFSFileExtentCB FileExtents[ 1];
491
492 } AFSReleaseFileExtentsResultFileCB;
493
494 typedef struct _AFS_RELEASE_FILE_EXTENTS_RESULT_CB
495 {
496     ULONG           SerialNumber;
497
498     ULONG           Flags;
499
500     ULONG           FileCount;
501
502     AFSReleaseFileExtentsResultFileCB Files[ 1];
503
504 } AFSReleaseFileExtentsResultCB;
505
506
507 typedef struct _AFS_EXTENT_FAILURE_CB
508 {
509
510     AFSFileID       FileId;
511
512     ULONG           FailureStatus;
513
514     GUID            AuthGroup;      // Length: sizeof(GUID) */
515
516 } AFSExtentFailureCB;
517
518 //
519 // File update CB
520 //
521
522 typedef struct _AFS_FILE_UPDATE_CB
523 {
524
525     AFSFileID       ParentId;
526
527     LARGE_INTEGER   LastAccessTime;
528
529     LARGE_INTEGER   LastWriteTime;
530
531     LARGE_INTEGER   ChangeTime;
532
533     LARGE_INTEGER   CreateTime;
534
535     LARGE_INTEGER   AllocationSize;
536
537     ULONG           FileAttributes;
538
539     ULONG           EaSize;
540
541     char            EaBuffer[ 1];
542
543 } AFSFileUpdateCB;
544
545 //
546 // File update CB result
547 //
548
549 typedef struct _AFS_FILE_UPDATE_RESULT_CB
550 {
551
552     LARGE_INTEGER   ParentDataVersion;
553
554     AFSDirEnumEntry DirEnum;
555
556 } AFSFileUpdateResultCB;
557
558 //
559 // File delete CB
560 //
561
562 typedef struct _AFS_FILE_DELETE_CB
563 {
564
565     AFSFileID       ParentId;        /* Must be directory */
566
567     ULONGLONG       ProcessId;
568
569                                      /* File Name and FileID in Common Request Block */
570
571 } AFSFileDeleteCB;
572
573 typedef struct _AFS_FILE_DELETE_RESULT_CB
574 {
575
576     LARGE_INTEGER   ParentDataVersion;
577
578 } AFSFileDeleteResultCB;
579
580 //
581 // File rename CB
582 //
583
584 typedef struct _AFS_FILE_RENAME_CB
585 {
586
587     AFSFileID       SourceParentId;        /* Must be directory */
588
589     AFSFileID       TargetParentId;        /* Must be directory */
590
591                                            /* Source Name and FileID in Common Request Block */
592
593     USHORT          TargetNameLength;
594
595     WCHAR           TargetName[ 1];
596
597 } AFSFileRenameCB;
598
599 typedef struct _AFS_FILE_RENAME_RESULT_CB
600 {
601
602     LARGE_INTEGER   SourceParentDataVersion;
603
604     LARGE_INTEGER   TargetParentDataVersion;
605
606     AFSDirEnumEntry DirEnum;
607
608 } AFSFileRenameResultCB;
609
610
611 //
612 // File Hard Link CB
613 //
614
615 typedef struct _AFS_FILE_HARDLINK_CB
616 {
617
618     AFSFileID       SourceParentId;        /* Must be directory */
619
620     AFSFileID       TargetParentId;        /* Must be directory */
621
622     BOOLEAN         bReplaceIfExists;
623
624                                            /* Source Name and FileID in Common Request Block */
625
626     USHORT          TargetNameLength;
627
628     WCHAR           TargetName[ 1];
629
630 } AFSFileHardLinkCB;
631
632 typedef struct _AFS_FILE_HARDLINK_RESULT_CB
633 {
634
635     LARGE_INTEGER   SourceParentDataVersion;
636
637     LARGE_INTEGER   TargetParentDataVersion;
638
639     AFSDirEnumEntry DirEnum;
640
641 } AFSFileHardLinkResultCB;
642
643
644 //
645 // Control structures for AFS_REQUEST_TYPE_EVAL_TARGET_BY_ID
646 // and AFS_REQUEST_TYPE_EVAL_TARGET_BY_NAME
647 //
648 // The response to these requests is a AFSDirEnumEntry
649 //
650
651 typedef struct _AFS_FILE_EVAL_TARGET_CB
652 {
653
654     AFSFileID       ParentId;
655
656 } AFSEvalTargetCB;
657
658
659 typedef struct _AFS_FILE_EVAL_RESULT_CB
660 {
661
662     LARGE_INTEGER   ParentDataVersion;
663
664     AFSDirEnumEntry DirEnum;
665
666 } AFSFileEvalResultCB;
667
668
669 //
670 // Control structure for read and write requests through the PIOCtl interface
671 //
672 // CommRequest FileId field contains the active directory
673
674 typedef struct _AFS_PIOCTL_IO_CB
675 {
676     ULONG       RequestId;
677
678     AFSFileID   RootId;
679
680     ULONG       BufferLength;
681
682     void        *MappedBuffer;
683
684 } AFSPIOCtlIORequestCB;
685
686 //
687 // The returned information for the IO Request
688 //
689
690 typedef struct _AFS_PIOCTL_IO_RESULT_CB
691 {
692
693     ULONG       BytesProcessed;
694
695 } AFSPIOCtlIOResultCB;
696
697
698 //
699 // Control structure for open and close requests through the PIOCtl interface
700 //
701 // CommRequest FileId field contains the active directory
702 //
703 // There is no return structure.
704 //
705 typedef struct _AFS_PIOCTL_OPEN_CLOSE_CB
706 {
707
708     ULONG       RequestId;
709
710     AFSFileID   RootId;
711
712 } AFSPIOCtlOpenCloseRequestCB;
713
714 //
715 // Cache invalidation control block
716 //
717
718 typedef struct _AFS_INVALIDATE_CACHE_CB
719 {
720
721     AFSFileID   FileID;
722
723     ULONG       FileType;
724
725     BOOLEAN     WholeVolume;
726
727     ULONG       Reason;
728
729 } AFSInvalidateCacheCB;
730
731 //
732 // Network Status Control Block
733 //
734
735 typedef struct _AFS_NETWORK_STATUS_CB
736 {
737
738     BOOLEAN     Online;
739
740 } AFSNetworkStatusCB;
741
742 //
743 // Volume Status Control Block
744 //
745
746 typedef struct _AFS_VOLUME_STATUS_CB
747 {
748
749     AFSFileID   FileID;         // only cell and volume fields are set
750
751     BOOLEAN     Online;
752
753 } AFSVolumeStatusCB;
754
755
756 typedef struct _AFS_SYSNAME
757 {
758
759     ULONG       Length;         /* bytes */
760
761     WCHAR       String[AFS_MAX_SYSNAME_LENGTH];
762
763 } AFSSysName;
764
765 //
766 // SysName Notification Control Block
767 //   Sent as the buffer with IOCTL_AFS_SYSNAME_NOTIFICATION
768 //   There is no response
769 //
770
771 typedef struct _AFS_SYSNAME_NOTIFICATION_CB
772 {
773
774     ULONG       Architecture;
775
776     ULONG       NumberOfNames;
777
778     AFSSysName  SysNames[1];
779
780 } AFSSysNameNotificationCB;
781
782
783 //
784 // File System Status Query Control Block
785 //   Received as a response to IOCTL_AFS_STATUS_REQUEST
786 //
787 typedef struct _AFS_DRIVER_STATUS_RESPONSE_CB
788 {
789
790     ULONG       Status;         // bit flags - see below
791
792 } AFSDriverStatusRespCB;
793
794 // Bit flags
795 #define AFS_DRIVER_STATUS_READY         0
796 #define AFS_DRIVER_STATUS_NOT_READY     1
797 #define AFS_DRIVER_STATUS_NO_SERVICE    2
798
799 //
800 // Byte Range Lock Request
801 //
802 typedef struct _AFS_BYTE_RANGE_LOCK_REQUEST
803 {
804     ULONG               LockType;
805
806     LARGE_INTEGER       Offset;
807
808     LARGE_INTEGER       Length;
809
810 } AFSByteRangeLockRequest;
811
812 #define AFS_BYTE_RANGE_LOCK_TYPE_SHARED 0
813 #define AFS_BYTE_RANGE_LOCK_TYPE_EXCL   1
814
815
816 //
817 // Byte Range Lock Request Control Block
818 //
819 // Set ProcessId and FileId in the Comm Request Block
820 //
821 typedef struct _AFS_BYTE_RANGE_LOCK_REQUEST_CB
822 {
823
824     ULONG                       Count;
825
826     ULONGLONG                   ProcessId;
827
828     AFSByteRangeLockRequest     Request[1];
829
830 } AFSByteRangeLockRequestCB;
831
832 //
833 // Byte Range Lock Result
834 //
835 typedef struct _AFS_BYTE_RANGE_LOCK_RESULT
836 {
837
838     ULONG               LockType;
839
840     LARGE_INTEGER       Offset;
841
842     LARGE_INTEGER       Length;
843
844     ULONG               Status;
845
846 } AFSByteRangeLockResult;
847
848 //
849 // Byte Range Lock Results Control Block
850 //
851
852 typedef struct _AFS_BYTE_RANGE_LOCK_RESULT_CB
853 {
854
855     AFSFileID                   FileId;
856
857     ULONG                       Count;
858
859     AFSByteRangeLockResult      Result[1];
860
861 } AFSByteRangeLockResultCB;
862
863 //
864 // Set Byte Range Lock Results Control Block
865 //
866
867 typedef struct _AFS_SET_BYTE_RANGE_LOCK_RESULT_CB
868 {
869
870     ULONG                       SerialNumber;
871
872     AFSFileID                   FileId;
873
874     ULONG                       Count;
875
876     AFSByteRangeLockResult      Result[1];
877
878 } AFSSetByteRangeLockResultCB;
879
880
881 //
882 // Byte Range Unlock Request Control Block
883 //
884
885 typedef struct _AFS_BYTE_RANGE_UNLOCK_CB
886 {
887
888     ULONG                       Count;
889
890     ULONGLONG                   ProcessId;
891
892     AFSByteRangeLockRequest     Request[1];
893
894 } AFSByteRangeUnlockRequestCB;
895
896
897 //
898 // Byte Range Unlock Request Control Block
899 //
900
901 typedef struct _AFS_BYTE_RANGE_UNLOCK_RESULT_CB
902 {
903
904     ULONG                       Count;
905
906     AFSByteRangeLockResult      Result[1];
907
908 } AFSByteRangeUnlockResultCB;
909
910
911 //
912 // Control structure for read and write requests through the PIPE interface
913 //
914 // CommRequest FileId field contains the active directory
915
916 typedef struct _AFS_PIPE_IO_CB
917 {
918     ULONG       RequestId;
919
920     AFSFileID   RootId;
921
922     ULONG       BufferLength;
923
924 } AFSPipeIORequestCB;   // For read requests the buffer is mapped in the request cb block.
925                         // For write requests, the buffer immediately follows this structure
926
927 //
928 // The returned information for the Pipe IO Request. Note that this is
929 // only returned in the write request. Read request info is returned in
930 // the request cb
931 //
932
933 typedef struct _AFS_PIPE_IO_RESULT_CB
934 {
935
936     ULONG       BytesProcessed;
937
938 } AFSPipeIOResultCB;
939
940 //
941 // Control structure for set and query info requests through the PIPE interface
942 //
943
944 typedef struct _AFS_PIPE_INFO_CB
945 {
946
947     ULONG       RequestId;
948
949     AFSFileID   RootId;
950
951     ULONG       InformationClass;
952
953     ULONG       BufferLength;
954
955 } AFSPipeInfoRequestCB;   // For query info requests the buffer is mapped in the request cb block.
956                           // For set info requests, the buffer immediately follows this structure
957
958 //
959 // Control structure for open and close requests through the Pipe interface
960 //
961 // CommRequest FileId field contains the active directory
962 //
963 // There is no return structure.
964 //
965 typedef struct _AFS_PIPE_OPEN_CLOSE_CB
966 {
967
968     ULONG       RequestId;
969
970     AFSFileID   RootId;
971
972 } AFSPipeOpenCloseRequestCB;
973
974
975 //
976 // Hold Fid Request Control Block
977 //
978
979 typedef struct _AFS_HOLD_FID_REQUEST_CB
980 {
981
982     ULONG                       Count;
983
984     AFSFileID                   FileID[ 1];
985
986 } AFSHoldFidRequestCB;
987
988
989 typedef struct _AFS_FID_RESULT
990 {
991
992     AFSFileID                   FileID;
993
994     ULONG                       Status;
995
996 } AFSFidResult;
997
998 typedef struct _AFS_HOLD_FID_RESULT_CB
999 {
1000
1001     ULONG                       Count;
1002
1003     AFSFidResult                Result[ 1];
1004
1005 } AFSHoldFidResultCB;
1006
1007
1008 //
1009 // Release Fid Request Control Block
1010 //
1011
1012 typedef struct _AFS_RELEASE_FID_REQUEST_CB
1013 {
1014
1015     ULONG                       Count;
1016
1017     AFSFileID                   FileID[ 1];
1018
1019 } AFSReleaseFidRequestCB;
1020
1021 typedef struct _AFS_RELEASE_FID_RESULT_CB
1022 {
1023
1024     ULONG                       Count;
1025
1026     AFSFidResult                Result[ 1];
1027
1028 } AFSReleaseFidResultCB;
1029
1030
1031 //
1032 // File cleanup CB
1033 //
1034
1035 typedef struct _AFS_FILE_CLEANUP_CB
1036 {
1037
1038     AFSFileID       ParentId;
1039
1040     LARGE_INTEGER   LastAccessTime;
1041
1042     LARGE_INTEGER   LastWriteTime;
1043
1044     LARGE_INTEGER   ChangeTime;
1045
1046     LARGE_INTEGER   CreateTime;
1047
1048     LARGE_INTEGER   AllocationSize;
1049
1050     ULONG           FileAttributes;
1051
1052     ULONGLONG       ProcessId;
1053
1054     ULONG           FileAccess;
1055
1056     ULONGLONG       Identifier;
1057
1058 } AFSFileCleanupCB;
1059
1060 typedef struct _AFS_FILE_CLEANUP_RESULT_CB
1061 {
1062
1063     LARGE_INTEGER   ParentDataVersion;
1064
1065 } AFSFileCleanupResultCB;
1066
1067
1068 //
1069 // Trace configuration cb
1070 //
1071
1072 typedef struct _AFS_DEBUG_TRACE_CONFIG_CB
1073 {
1074
1075     ULONG       TraceLevel;
1076
1077     ULONG       Subsystem;
1078
1079     ULONG       TraceBufferLength;
1080
1081     ULONG       DebugFlags;
1082
1083 } AFSTraceConfigCB;
1084
1085 //
1086 // Object Status Information request
1087 //
1088
1089 typedef struct _AFS_REDIR_GET_OBJECT_STATUS_CB
1090 {
1091
1092     AFSFileID       FileID;
1093
1094     USHORT          FileNameLength;
1095
1096     WCHAR           FileName[ 1];
1097
1098 } AFSGetStatusInfoCB;
1099
1100 typedef struct _AFS_REDIR_OBJECT_STATUS_CB
1101 {
1102
1103     AFSFileID               FileId;
1104
1105     AFSFileID               TargetFileId;
1106
1107     LARGE_INTEGER           Expiration;         /* FILETIME */
1108
1109     LARGE_INTEGER           DataVersion;
1110
1111     ULONG                   FileType;           /* File, Dir, MountPoint, Symlink */
1112
1113     ULONG                   ObjectFlags;
1114
1115     LARGE_INTEGER           CreationTime;       /* FILETIME */
1116
1117     LARGE_INTEGER           LastAccessTime;     /* FILETIME */
1118
1119     LARGE_INTEGER           LastWriteTime;      /* FILETIME */
1120
1121     LARGE_INTEGER           ChangeTime;         /* FILETIME */
1122
1123     ULONG                   FileAttributes;     /* NTFS FILE_ATTRIBUTE_xxxx see below */
1124
1125     LARGE_INTEGER           EndOfFile;
1126
1127     LARGE_INTEGER           AllocationSize;
1128
1129     ULONG                   EaSize;
1130
1131     ULONG                   Links;
1132
1133 } AFSStatusInfoCB;
1134
1135 //
1136 // Auth Group (Process and Thread) Processing
1137 //
1138 // afsredir.sys implements a set of generic Authentication Group
1139 // operations that can be executed by processes.  The model supports
1140 // one or more authentication groups per process.  A process may switch
1141 // the active AuthGroup for any thread to any other AuthGroup the process
1142 // is a member of.  However, processes cannot assign itself to an
1143 // AuthGroup that it is not presently a member of.  A process can reset
1144 // its AuthGroup to the SID-AuthGroup or can create a new AuthGroup that
1145 // has not previously been used.
1146 //
1147 //  IOCTL_AFS_AUTHGROUP_CREATE_AND_SET
1148 //      Creates a new AuthGroup and either activates it for
1149 //      the process or the current thread.  If set as the
1150 //      new process AuthGroup, the prior AuthGroup list is
1151 //      cleared.
1152 //
1153 //  IOCTL_AFS_AUTHGROUP_QUERY
1154 //      Returns a list of the AuthGroup GUIDS associated
1155 //      with the current process, the current process GUID,
1156 //      and the current thread GUID.
1157 //
1158 //  IOCTL_AFS_AUTHGROUP_SET
1159 //      Permits the current AuthGroup for the process or
1160 //      thread to be set to the specified GUID.  The GUID
1161 //      must be in the list of current values for the process.
1162 //
1163 //  IOCTL_AFS_AUTHGROUP_RESET
1164 //      Resets the current AuthGroup for the process or
1165 //      thread to the SID-AuthGroup
1166 //
1167 //  IOCTL_AFS_AUTHGROUP_SID_CREATE
1168 //      Given a SID as input, assigns a new AuthGroup GUID.
1169 //      (May only be executed by LOCAL_SYSTEM or the active SID)
1170 //
1171 //  IOCTL_AFS_AUTHGROUP_SID_QUERY
1172 //      Given a SID as input, returns the associated AuthGroup GUID.
1173 //
1174 //  IOCTL_AFS_AUTHGROUP_LOGON_CREATE
1175 //      Given a logon Session as input, assigns a new AuthGroup GUID.
1176 //      (May only be executed by LOCAL_SYSTEM.)
1177 //
1178 // New processes inherit only the active AuthGroup at the time of process
1179 // creation.  Either that of the active thread (if set) or the process.
1180 // All of the other AuthGroups associated with a parent process are
1181 // off-limits.
1182 //
1183
1184 //
1185 // Auth Group processing flags
1186 //
1187
1188 #define AFS_PAG_FLAGS_SET_AS_ACTIVE         0x00000001 // If set, the newly created authgroup is set to the active group
1189 #define AFS_PAG_FLAGS_THREAD_AUTH_GROUP     0x00000002 // If set, the request is targeted for the thread not the process
1190
1191 typedef struct _AFS_AUTH_GROUP_REQUEST
1192 {
1193
1194     USHORT              SIDLength; // If zero the SID of the caller is used
1195
1196     ULONG               SessionId; // If -1 the session id of the caller is used
1197
1198     ULONG               Flags;
1199
1200     GUID                AuthGroup; // The auth group for certain requests
1201
1202     WCHAR               SIDString[ 1];
1203
1204 } AFSAuthGroupRequestCB;
1205
1206 //
1207 // Reparse tag AFS Specific information buffer
1208 //
1209
1210 #define OPENAFS_SUBTAG_MOUNTPOINT 1
1211 #define OPENAFS_SUBTAG_SYMLINK    2
1212 #define OPENAFS_SUBTAG_UNC        3
1213
1214 #define OPENAFS_MOUNTPOINT_TYPE_NORMAL   L'#'
1215 #define OPENAFS_MOUNTPOINT_TYPE_RW       L'%'
1216
1217 typedef struct _AFS_REPARSE_TAG_INFORMATION
1218 {
1219
1220     ULONG SubTag;
1221
1222     union
1223     {
1224         struct
1225         {
1226             ULONG  Type;
1227             USHORT MountPointCellLength;
1228             USHORT MountPointVolumeLength;
1229             WCHAR  Buffer[1];
1230         } AFSMountPoint;
1231
1232         struct
1233         {
1234             BOOLEAN RelativeLink;
1235             USHORT  SymLinkTargetLength;
1236             WCHAR   Buffer[1];
1237         } AFSSymLink;
1238
1239         struct
1240         {
1241             USHORT UNCTargetLength;
1242             WCHAR  Buffer[1];
1243         } UNCReferral;
1244     };
1245
1246 } AFSReparseTagInfo;
1247
1248 #endif /* _AFS_USER_STRUCT_H */
1249