Windows: disable short names in redirector option
[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:Cell */
268
269 } AFSVolumeInfoCB;
270
271
272 //
273 // Volume size information CB passed used to satisfy
274 // FileFsFullSizeInformation and FileFsSizeInformation
275 //
276
277 typedef struct _AFS_VOLUME_SIZE_INFORMATION
278 {
279
280     LARGE_INTEGER   TotalAllocationUnits;       /* Max Blocks (Quota or Partition) */
281
282     LARGE_INTEGER   AvailableAllocationUnits;   /* Blocks Avail (Quota or Partition) */
283
284     ULONG           SectorsPerAllocationUnit;   /* = 1 */
285
286     ULONG           BytesPerSector;             /* = 1024 */
287
288 } AFSVolumeSizeInfoCB;
289
290 //
291 // File create CB
292 //
293
294 typedef struct _AFS_FILE_CREATE_CB
295 {
296
297     AFSFileID       ParentId;
298
299     LARGE_INTEGER   AllocationSize;
300
301     ULONG           FileAttributes;
302
303     ULONG           EaSize;
304
305     char            EaBuffer[ 1];
306
307 } AFSFileCreateCB;
308
309 typedef struct _AFS_FILE_CREATE_RESULT_CB
310 {
311
312     LARGE_INTEGER   ParentDataVersion;
313
314     AFSDirEnumEntry DirEnum;
315
316 } AFSFileCreateResultCB;
317
318 //
319 // File open CB
320 //
321
322 typedef struct _AFS_FILE_OPEN_CB
323 {
324
325     AFSFileID       ParentId;
326
327     ULONG           DesiredAccess;
328
329     ULONG           ShareAccess;
330
331     ULONGLONG       ProcessId;
332
333     ULONGLONG       Identifier;
334
335 } AFSFileOpenCB;
336
337 typedef struct _AFS_FILE_OPEN_RESULT_CB
338 {
339
340     ULONG           GrantedAccess;
341
342     ULONG           FileAccess;
343
344 } AFSFileOpenResultCB;
345
346 typedef struct _AFS_FILE_ACCESS_RELEASE_CB
347 {
348
349     ULONG           FileAccess;
350
351     ULONGLONG       ProcessId;
352
353     ULONGLONG       Identifier;
354
355 } AFSFileAccessReleaseCB;
356
357 //
358 // IO Interace control blocks for extent processing when performing
359 // queries via the AFS_REQUEST_TYPE_REQUEST_FILE_EXTENTS or synchronous
360 // results from the service
361 //
362
363 typedef struct _AFS_FILE_EXTENT_CB
364 {
365
366     ULONG           Flags;
367
368     ULONG           Length;
369
370     LARGE_INTEGER   FileOffset;
371
372     LARGE_INTEGER   CacheOffset;
373
374     UCHAR           MD5[16];
375
376     ULONG           DirtyOffset;
377
378     ULONG           DirtyLength;
379
380 } AFSFileExtentCB;
381
382 typedef struct _AFS_REQUEST_EXTENTS_CB
383 {
384
385     ULONG           Flags;
386
387     LARGE_INTEGER   ByteOffset;
388
389     ULONG           Length;
390
391 } AFSRequestExtentsCB;
392
393 //
394 // Extent processing when the file system calls the service to
395 // release extents through the AFS_REQUEST_TYPE_RELEASE_FILE_EXTENTS interface
396 //
397
398 typedef struct _AFS_RELEASE_EXTENTS_CB
399 {
400
401     ULONG           Flags;
402
403     ULONG           ExtentCount;
404
405     LARGE_INTEGER   LastAccessTime;
406
407     LARGE_INTEGER   LastWriteTime;
408
409     LARGE_INTEGER   ChangeTime;
410
411     LARGE_INTEGER   CreateTime;
412
413     LARGE_INTEGER   AllocationSize;
414
415     AFSFileExtentCB FileExtents[ 1];
416
417 } AFSReleaseExtentsCB;
418
419 //
420 // This is the control structure used when the service passes the extent
421 // information via the IOCTL_AFS_SET_FILE_EXTENTS interface
422 //
423
424 typedef struct _AFS_SET_FILE_EXTENTS_CB
425 {
426
427     AFSFileID       FileId;
428
429     ULONG           ExtentCount;
430
431     ULONG           ResultStatus;
432
433     AFSFileExtentCB FileExtents[ 1];
434
435 } AFSSetFileExtentsCB;
436
437 //
438 // This is the control structure used when the service passes the extent
439 // information via the IOCTL_AFS_RELEASE_FILE_EXTENTS interface
440 //
441
442 #define AFS_RELEASE_EXTENTS_FLAGS_RELEASE_ALL       0x00000001
443
444 typedef struct _AFS_RELEASE_FILE_EXTENTS_CB
445 {
446
447     ULONG           Flags;
448
449     AFSFileID       FileId;
450
451     ULONG           ExtentCount;
452
453     LARGE_INTEGER   HeldExtentCount;
454
455     AFSFileExtentCB FileExtents[ 1];
456
457 } AFSReleaseFileExtentsCB;
458
459 //
460 // These are the control structures that the filesystem returns from a
461 // IOCTL_AFS_RELEASE_FILE_EXTENTS
462 //
463
464 typedef struct _AFS_RELEASE_FILE_EXTENTS_RESULT_FILE_CB
465 {
466     AFSFileID       FileId;
467
468     ULONG           Flags;
469
470     GUID            AuthGroup; /* Length: sizeof(GUID) */
471
472     ULONG           ExtentCount;
473
474     LARGE_INTEGER   LastAccessTime;
475
476     LARGE_INTEGER   LastWriteTime;
477
478     LARGE_INTEGER   ChangeTime;
479
480     LARGE_INTEGER   CreateTime;
481
482     LARGE_INTEGER   AllocationSize;
483
484     AFSFileExtentCB FileExtents[ 1];
485
486 } AFSReleaseFileExtentsResultFileCB;
487
488 typedef struct _AFS_RELEASE_FILE_EXTENTS_RESULT_CB
489 {
490     ULONG           SerialNumber;
491
492     ULONG           Flags;
493
494     ULONG           FileCount;
495
496     AFSReleaseFileExtentsResultFileCB Files[ 1];
497
498 } AFSReleaseFileExtentsResultCB;
499
500
501 typedef struct _AFS_EXTENT_FAILURE_CB
502 {
503
504     AFSFileID       FileId;
505
506     ULONG           FailureStatus;
507
508     GUID            AuthGroup;      // Length: sizeof(GUID) */
509
510 } AFSExtentFailureCB;
511
512 //
513 // File update CB
514 //
515
516 typedef struct _AFS_FILE_UPDATE_CB
517 {
518
519     AFSFileID       ParentId;
520
521     LARGE_INTEGER   LastAccessTime;
522
523     LARGE_INTEGER   LastWriteTime;
524
525     LARGE_INTEGER   ChangeTime;
526
527     LARGE_INTEGER   CreateTime;
528
529     LARGE_INTEGER   AllocationSize;
530
531     ULONG           FileAttributes;
532
533     ULONG           EaSize;
534
535     char            EaBuffer[ 1];
536
537 } AFSFileUpdateCB;
538
539 //
540 // File update CB result
541 //
542
543 typedef struct _AFS_FILE_UPDATE_RESULT_CB
544 {
545
546     LARGE_INTEGER   ParentDataVersion;
547
548     AFSDirEnumEntry DirEnum;
549
550 } AFSFileUpdateResultCB;
551
552 //
553 // File delete CB
554 //
555
556 typedef struct _AFS_FILE_DELETE_CB
557 {
558
559     AFSFileID       ParentId;        /* Must be directory */
560
561     ULONGLONG       ProcessId;
562
563                                      /* File Name and FileID in Common Request Block */
564
565 } AFSFileDeleteCB;
566
567 typedef struct _AFS_FILE_DELETE_RESULT_CB
568 {
569
570     LARGE_INTEGER   ParentDataVersion;
571
572 } AFSFileDeleteResultCB;
573
574 //
575 // File rename CB
576 //
577
578 typedef struct _AFS_FILE_RENAME_CB
579 {
580
581     AFSFileID       SourceParentId;        /* Must be directory */
582
583     AFSFileID       TargetParentId;        /* Must be directory */
584
585                                            /* Source Name and FileID in Common Request Block */
586
587     USHORT          TargetNameLength;
588
589     WCHAR           TargetName[ 1];
590
591 } AFSFileRenameCB;
592
593 typedef struct _AFS_FILE_RENAME_RESULT_CB
594 {
595
596     LARGE_INTEGER   SourceParentDataVersion;
597
598     LARGE_INTEGER   TargetParentDataVersion;
599
600     AFSDirEnumEntry DirEnum;
601
602 } AFSFileRenameResultCB;
603
604
605 //
606 // Control structures for AFS_REQUEST_TYPE_EVAL_TARGET_BY_ID
607 // and AFS_REQUEST_TYPE_EVAL_TARGET_BY_NAME
608 //
609 // The response to these requests is a AFSDirEnumEntry
610 //
611
612 typedef struct _AFS_FILE_EVAL_TARGET_CB
613 {
614
615     AFSFileID       ParentId;
616
617 } AFSEvalTargetCB;
618
619
620 typedef struct _AFS_FILE_EVAL_RESULT_CB
621 {
622
623     LARGE_INTEGER   ParentDataVersion;
624
625     AFSDirEnumEntry DirEnum;
626
627 } AFSFileEvalResultCB;
628
629
630 //
631 // Control structure for read and write requests through the PIOCtl interface
632 //
633 // CommRequest FileId field contains the active directory
634
635 typedef struct _AFS_PIOCTL_IO_CB
636 {
637     ULONG       RequestId;
638
639     AFSFileID   RootId;
640
641     ULONG       BufferLength;
642
643     void        *MappedBuffer;
644
645 } AFSPIOCtlIORequestCB;
646
647 //
648 // The returned information for the IO Request
649 //
650
651 typedef struct _AFS_PIOCTL_IO_RESULT_CB
652 {
653
654     ULONG       BytesProcessed;
655
656 } AFSPIOCtlIOResultCB;
657
658
659 //
660 // Control structure for open and close requests through the PIOCtl interface
661 //
662 // CommRequest FileId field contains the active directory
663 //
664 // There is no return structure.
665 //
666 typedef struct _AFS_PIOCTL_OPEN_CLOSE_CB
667 {
668
669     ULONG       RequestId;
670
671     AFSFileID   RootId;
672
673 } AFSPIOCtlOpenCloseRequestCB;
674
675 //
676 // Cache invalidation control block
677 //
678
679 typedef struct _AFS_INVALIDATE_CACHE_CB
680 {
681
682     AFSFileID   FileID;
683
684     ULONG       FileType;
685
686     BOOLEAN     WholeVolume;
687
688     ULONG       Reason;
689
690 } AFSInvalidateCacheCB;
691
692 //
693 // Network Status Control Block
694 //
695
696 typedef struct _AFS_NETWORK_STATUS_CB
697 {
698
699     BOOLEAN     Online;
700
701 } AFSNetworkStatusCB;
702
703 //
704 // Volume Status Control Block
705 //
706
707 typedef struct _AFS_VOLUME_STATUS_CB
708 {
709
710     AFSFileID   FileID;         // only cell and volume fields are set
711
712     BOOLEAN     Online;
713
714 } AFSVolumeStatusCB;
715
716
717 typedef struct _AFS_SYSNAME
718 {
719
720     ULONG       Length;         /* bytes */
721
722     WCHAR       String[AFS_MAX_SYSNAME_LENGTH];
723
724 } AFSSysName;
725
726 //
727 // SysName Notification Control Block
728 //   Sent as the buffer with IOCTL_AFS_SYSNAME_NOTIFICATION
729 //   There is no response
730 //
731
732 typedef struct _AFS_SYSNAME_NOTIFICATION_CB
733 {
734
735     ULONG       Architecture;
736
737     ULONG       NumberOfNames;
738
739     AFSSysName  SysNames[1];
740
741 } AFSSysNameNotificationCB;
742
743
744 //
745 // File System Status Query Control Block
746 //   Received as a response to IOCTL_AFS_STATUS_REQUEST
747 //
748 typedef struct _AFS_DRIVER_STATUS_RESPONSE_CB
749 {
750
751     ULONG       Status;         // bit flags - see below
752
753 } AFSDriverStatusRespCB;
754
755 // Bit flags
756 #define AFS_DRIVER_STATUS_READY         0
757 #define AFS_DRIVER_STATUS_NOT_READY     1
758 #define AFS_DRIVER_STATUS_NO_SERVICE    2
759
760 //
761 // Byte Range Lock Request
762 //
763 typedef struct _AFS_BYTE_RANGE_LOCK_REQUEST
764 {
765     ULONG               LockType;
766
767     LARGE_INTEGER       Offset;
768
769     LARGE_INTEGER       Length;
770
771 } AFSByteRangeLockRequest;
772
773 #define AFS_BYTE_RANGE_LOCK_TYPE_SHARED 0
774 #define AFS_BYTE_RANGE_LOCK_TYPE_EXCL   1
775
776
777 //
778 // Byte Range Lock Request Control Block
779 //
780 // Set ProcessId and FileId in the Comm Request Block
781 //
782 typedef struct _AFS_BYTE_RANGE_LOCK_REQUEST_CB
783 {
784
785     ULONG                       Count;
786
787     ULONGLONG                   ProcessId;
788
789     AFSByteRangeLockRequest     Request[1];
790
791 } AFSByteRangeLockRequestCB;
792
793 //
794 // Byte Range Lock Result
795 //
796 typedef struct _AFS_BYTE_RANGE_LOCK_RESULT
797 {
798
799     ULONG               LockType;
800
801     LARGE_INTEGER       Offset;
802
803     LARGE_INTEGER       Length;
804
805     ULONG               Status;
806
807 } AFSByteRangeLockResult;
808
809 //
810 // Byte Range Lock Results Control Block
811 //
812
813 typedef struct _AFS_BYTE_RANGE_LOCK_RESULT_CB
814 {
815
816     AFSFileID                   FileId;
817
818     ULONG                       Count;
819
820     AFSByteRangeLockResult      Result[1];
821
822 } AFSByteRangeLockResultCB;
823
824 //
825 // Set Byte Range Lock Results Control Block
826 //
827
828 typedef struct _AFS_SET_BYTE_RANGE_LOCK_RESULT_CB
829 {
830
831     ULONG                       SerialNumber;
832
833     AFSFileID                   FileId;
834
835     ULONG                       Count;
836
837     AFSByteRangeLockResult      Result[1];
838
839 } AFSSetByteRangeLockResultCB;
840
841
842 //
843 // Byte Range Unlock Request Control Block
844 //
845
846 typedef struct _AFS_BYTE_RANGE_UNLOCK_CB
847 {
848
849     ULONG                       Count;
850
851     ULONGLONG                   ProcessId;
852
853     AFSByteRangeLockRequest     Request[1];
854
855 } AFSByteRangeUnlockRequestCB;
856
857
858 //
859 // Byte Range Unlock Request Control Block
860 //
861
862 typedef struct _AFS_BYTE_RANGE_UNLOCK_RESULT_CB
863 {
864
865     ULONG                       Count;
866
867     AFSByteRangeLockResult      Result[1];
868
869 } AFSByteRangeUnlockResultCB;
870
871
872 //
873 // Control structure for read and write requests through the PIPE interface
874 //
875 // CommRequest FileId field contains the active directory
876
877 typedef struct _AFS_PIPE_IO_CB
878 {
879     ULONG       RequestId;
880
881     AFSFileID   RootId;
882
883     ULONG       BufferLength;
884
885 } AFSPipeIORequestCB;   // For read requests the buffer is mapped in the request cb block.
886                         // For write requests, the buffer immediately follows this structure
887
888 //
889 // The returned information for the Pipe IO Request. Note that this is
890 // only returned in the write request. Read request info is returned in
891 // the request cb
892 //
893
894 typedef struct _AFS_PIPE_IO_RESULT_CB
895 {
896
897     ULONG       BytesProcessed;
898
899 } AFSPipeIOResultCB;
900
901 //
902 // Control structure for set and query info requests through the PIPE interface
903 //
904
905 typedef struct _AFS_PIPE_INFO_CB
906 {
907
908     ULONG       RequestId;
909
910     AFSFileID   RootId;
911
912     ULONG       InformationClass;
913
914     ULONG       BufferLength;
915
916 } AFSPipeInfoRequestCB;   // For query info requests the buffer is mapped in the request cb block.
917                           // For set info requests, the buffer immediately follows this structure
918
919 //
920 // Control structure for open and close requests through the Pipe interface
921 //
922 // CommRequest FileId field contains the active directory
923 //
924 // There is no return structure.
925 //
926 typedef struct _AFS_PIPE_OPEN_CLOSE_CB
927 {
928
929     ULONG       RequestId;
930
931     AFSFileID   RootId;
932
933 } AFSPipeOpenCloseRequestCB;
934
935
936 //
937 // Hold Fid Request Control Block
938 //
939
940 typedef struct _AFS_HOLD_FID_REQUEST_CB
941 {
942
943     ULONG                       Count;
944
945     AFSFileID                   FileID[ 1];
946
947 } AFSHoldFidRequestCB;
948
949
950 typedef struct _AFS_FID_RESULT
951 {
952
953     AFSFileID                   FileID;
954
955     ULONG                       Status;
956
957 } AFSFidResult;
958
959 typedef struct _AFS_HOLD_FID_RESULT_CB
960 {
961
962     ULONG                       Count;
963
964     AFSFidResult                Result[ 1];
965
966 } AFSHoldFidResultCB;
967
968
969 //
970 // Release Fid Request Control Block
971 //
972
973 typedef struct _AFS_RELEASE_FID_REQUEST_CB
974 {
975
976     ULONG                       Count;
977
978     AFSFileID                   FileID[ 1];
979
980 } AFSReleaseFidRequestCB;
981
982 typedef struct _AFS_RELEASE_FID_RESULT_CB
983 {
984
985     ULONG                       Count;
986
987     AFSFidResult                Result[ 1];
988
989 } AFSReleaseFidResultCB;
990
991
992 //
993 // File cleanup CB
994 //
995
996 typedef struct _AFS_FILE_CLEANUP_CB
997 {
998
999     AFSFileID       ParentId;
1000
1001     LARGE_INTEGER   LastAccessTime;
1002
1003     LARGE_INTEGER   LastWriteTime;
1004
1005     LARGE_INTEGER   ChangeTime;
1006
1007     LARGE_INTEGER   CreateTime;
1008
1009     LARGE_INTEGER   AllocationSize;
1010
1011     ULONG           FileAttributes;
1012
1013     ULONGLONG       ProcessId;
1014
1015     ULONG           FileAccess;
1016
1017     ULONGLONG       Identifier;
1018
1019 } AFSFileCleanupCB;
1020
1021 typedef struct _AFS_FILE_CLEANUP_RESULT_CB
1022 {
1023
1024     LARGE_INTEGER   ParentDataVersion;
1025
1026 } AFSFileCleanupResultCB;
1027
1028
1029 //
1030 // Trace configuration cb
1031 //
1032
1033 typedef struct _AFS_DEBUG_TRACE_CONFIG_CB
1034 {
1035
1036     ULONG       TraceLevel;
1037
1038     ULONG       Subsystem;
1039
1040     ULONG       TraceBufferLength;
1041
1042     ULONG       DebugFlags;
1043
1044 } AFSTraceConfigCB;
1045
1046 //
1047 // Object Status Information request
1048 //
1049
1050 typedef struct _AFS_REDIR_GET_OBJECT_STATUS_CB
1051 {
1052
1053     AFSFileID       FileID;
1054
1055     USHORT          FileNameLength;
1056
1057     WCHAR           FileName[ 1];
1058
1059 } AFSGetStatusInfoCB;
1060
1061 typedef struct _AFS_REDIR_OBJECT_STATUS_CB
1062 {
1063
1064     AFSFileID               FileId;
1065
1066     AFSFileID               TargetFileId;
1067
1068     LARGE_INTEGER           Expiration;         /* FILETIME */
1069
1070     LARGE_INTEGER           DataVersion;
1071
1072     ULONG                   FileType;           /* File, Dir, MountPoint, Symlink */
1073
1074     ULONG                   ObjectFlags;
1075
1076     LARGE_INTEGER           CreationTime;       /* FILETIME */
1077
1078     LARGE_INTEGER           LastAccessTime;     /* FILETIME */
1079
1080     LARGE_INTEGER           LastWriteTime;      /* FILETIME */
1081
1082     LARGE_INTEGER           ChangeTime;         /* FILETIME */
1083
1084     ULONG                   FileAttributes;     /* NTFS FILE_ATTRIBUTE_xxxx see below */
1085
1086     LARGE_INTEGER           EndOfFile;
1087
1088     LARGE_INTEGER           AllocationSize;
1089
1090     ULONG                   EaSize;
1091
1092     ULONG                   Links;
1093
1094 } AFSStatusInfoCB;
1095
1096 //
1097 // Auth Group (Process and Thread) Processing
1098 //
1099 // afsredir.sys implements a set of generic Authentication Group
1100 // operations that can be executed by processes.  The model supports
1101 // one or more authentication groups per process.  A process may switch
1102 // the active AuthGroup for any thread to any other AuthGroup the process
1103 // is a member of.  However, processes cannot assign itself to an
1104 // AuthGroup that it is not presently a member of.  A process can reset
1105 // its AuthGroup to the SID-AuthGroup or can create a new AuthGroup that
1106 // has not previously been used.
1107 //
1108 //  IOCTL_AFS_AUTHGROUP_CREATE_AND_SET
1109 //      Creates a new AuthGroup and either activates it for
1110 //      the process or the current thread.  If set as the
1111 //      new process AuthGroup, the prior AuthGroup list is
1112 //      cleared.
1113 //
1114 //  IOCTL_AFS_AUTHGROUP_QUERY
1115 //      Returns a list of the AuthGroup GUIDS associated
1116 //      with the current process, the current process GUID,
1117 //      and the current thread GUID.
1118 //
1119 //  IOCTL_AFS_AUTHGROUP_SET
1120 //      Permits the current AuthGroup for the process or
1121 //      thread to be set to the specified GUID.  The GUID
1122 //      must be in the list of current values for the process.
1123 //
1124 //  IOCTL_AFS_AUTHGROUP_RESET
1125 //      Resets the current AuthGroup for the process or
1126 //      thread to the SID-AuthGroup
1127 //
1128 //  IOCTL_AFS_AUTHGROUP_SID_CREATE
1129 //      Given a SID as input, assigns a new AuthGroup GUID.
1130 //      (May only be executed by LOCAL_SYSTEM or the active SID)
1131 //
1132 //  IOCTL_AFS_AUTHGROUP_SID_QUERY
1133 //      Given a SID as input, returns the associated AuthGroup GUID.
1134 //
1135 //  IOCTL_AFS_AUTHGROUP_LOGON_CREATE
1136 //      Given a logon Session as input, assigns a new AuthGroup GUID.
1137 //      (May only be executed by LOCAL_SYSTEM.)
1138 //
1139 // New processes inherit only the active AuthGroup at the time of process
1140 // creation.  Either that of the active thread (if set) or the process.
1141 // All of the other AuthGroups associated with a parent process are
1142 // off-limits.
1143 //
1144
1145 //
1146 // Auth Group processing flags
1147 //
1148
1149 #define AFS_PAG_FLAGS_SET_AS_ACTIVE         0x00000001 // If set, the newly created authgroup is set to the active group
1150 #define AFS_PAG_FLAGS_THREAD_AUTH_GROUP     0x00000002 // If set, the request is targeted for the thread not the process
1151
1152 typedef struct _AFS_AUTH_GROUP_REQUEST
1153 {
1154
1155     USHORT              SIDLength; // If zero the SID of the caller is used
1156
1157     ULONG               SessionId; // If -1 the session id of the caller is used
1158
1159     ULONG               Flags;
1160
1161     GUID                AuthGroup; // The auth group for certain requests
1162
1163     WCHAR               SIDString[ 1];
1164
1165 } AFSAuthGroupRequestCB;
1166
1167 //
1168 // Reparse tag AFS Specific information buffer
1169 //
1170
1171 #define OPENAFS_SUBTAG_MOUNTPOINT 1
1172 #define OPENAFS_SUBTAG_SYMLINK    2
1173 #define OPENAFS_SUBTAG_UNC        3
1174
1175 #define OPENAFS_MOUNTPOINT_TYPE_NORMAL   L'#'
1176 #define OPENAFS_MOUNTPOINT_TYPE_RW       L'%'
1177
1178 typedef struct _AFS_REPARSE_TAG_INFORMATION
1179 {
1180
1181     ULONG SubTag;
1182
1183     union
1184     {
1185         struct
1186         {
1187             ULONG  Type;
1188             USHORT MountPointCellLength;
1189             USHORT MountPointVolumeLength;
1190             WCHAR  Buffer[1];
1191         } AFSMountPoint;
1192
1193         struct
1194         {
1195             BOOLEAN RelativeLink;
1196             USHORT  SymLinkTargetLength;
1197             WCHAR   Buffer[1];
1198         } AFSSymLink;
1199
1200         struct
1201         {
1202             USHORT UNCTargetLength;
1203             WCHAR  Buffer[1];
1204         } UNCReferral;
1205     };
1206
1207 } AFSReparseTagInfo;
1208
1209 #endif /* _AFS_USER_STRUCT_H */
1210