reactos/ntoskrnl/io/share.c

   1 /* $Id: share.c,v 1.5 2002/01/21 11:42:04 ekohl Exp $
   2  *
   3  * COPYRIGHT:       See COPYING in the top level directory
   4  * PROJECT:         ReactOS kernel
   5  * FILE:            ntoskrnl/io/share.c
   6  * PURPOSE:
   7  * PROGRAMMER:      David Welch (welch@mcmail.com)
   8  * UPDATE HISTORY:
   9  *                  Created 22/05/98
  10  */
  11
  12 /* INCLUDES *****************************************************************/
  13
  14 #include <ddk/ntddk.h>
  15
  16 #include <internal/debug.h>
  17
  18 /* FUNCTIONS *****************************************************************/
  19
  20 VOID STDCALL
  21 IoUpdateShareAccess(PFILE_OBJECT FileObject,
  22                     PSHARE_ACCESS ShareAccess)
  23 {
  24    if ((FileObject->ReadAccess == FALSE) &&
  25        (FileObject->WriteAccess == FALSE) &&
  26        (FileObject->DeleteAccess == FALSE))
  27      {
  28         return;
  29      }
  30
  31    ShareAccess->OpenCount++;
  32
  33    if (FileObject->ReadAccess == TRUE)
  34      {
  35         ShareAccess->Readers++;
  36      }
  37
  38    if (FileObject->WriteAccess == TRUE)
  39      {
  40         ShareAccess->Writers++;
  41      }
  42
  43    if (FileObject->DeleteAccess == TRUE)
  44      {
  45         ShareAccess->Deleters++;
  46      }
  47
  48    if (FileObject->SharedRead == TRUE)
  49      {
  50         ShareAccess->SharedRead++;
  51      }
  52
  53    if (FileObject->SharedWrite == TRUE)
  54      {
  55         ShareAccess->SharedWrite++;
  56      }
  57
  58    if (FileObject->SharedDelete == TRUE)
  59      {
  60         ShareAccess->SharedDelete++;
  61      }
  62 }
  63
  64
  65 NTSTATUS STDCALL
  66 IoCheckShareAccess(ACCESS_MASK DesiredAccess,
  67                    ULONG DesiredShareAccess,
  68                    PFILE_OBJECT FileObject,
  69                    PSHARE_ACCESS ShareAccess,
  70                    BOOLEAN Update)
  71 {
  72    BOOLEAN ReadAccess;
  73    BOOLEAN WriteAccess;
  74    BOOLEAN DeleteAccess;
  75    BOOLEAN SharedRead;
  76    BOOLEAN SharedWrite;
  77    BOOLEAN SharedDelete;
  78
  79    ReadAccess = (DesiredAccess & (FILE_READ_DATA | FILE_EXECUTE));
  80    WriteAccess = (DesiredAccess & (FILE_READ_DATA | FILE_APPEND_DATA));
  81    DeleteAccess = (DesiredAccess & DELETE);
  82
  83    FileObject->ReadAccess = ReadAccess;
  84    FileObject->WriteAccess = WriteAccess;
  85    FileObject->DeleteAccess = DeleteAccess;
  86
  87    if (!ReadAccess && !WriteAccess && !DeleteAccess)
  88      {
  89         return (STATUS_SUCCESS);
  90      }
  91
  92    SharedRead = (DesiredShareAccess & FILE_SHARE_READ);
  93    SharedWrite = (DesiredShareAccess & FILE_SHARE_WRITE);
  94    SharedDelete = (DesiredShareAccess & FILE_SHARE_DELETE);
  95
  96    FileObject->SharedRead = SharedRead;
  97    FileObject->SharedWrite = SharedWrite;
  98    FileObject->SharedDelete = SharedDelete;
  99
 100    if (ReadAccess)
 101      {
 102         if (ShareAccess->SharedRead < ShareAccess->OpenCount)
 103           return (STATUS_SHARING_VIOLATION);
 104      }
 105
 106    if (WriteAccess)
 107      {
 108         if (ShareAccess->SharedWrite < ShareAccess->OpenCount)
 109           return (STATUS_SHARING_VIOLATION);
 110      }
 111
 112    if (DeleteAccess)
 113      {
 114         if (ShareAccess->SharedDelete < ShareAccess->OpenCount)
 115           return (STATUS_SHARING_VIOLATION);
 116      }
 117
 118    if (ShareAccess->Readers != 0)
 119      {
 120         if (SharedRead == FALSE)
 121           return (STATUS_SHARING_VIOLATION);
 122      }
 123
 124    if (ShareAccess->Writers != 0)
 125      {
 126         if (SharedWrite == FALSE)
 127           return (STATUS_SHARING_VIOLATION);
 128      }
 129
 130    if (ShareAccess->Deleters != 0)
 131      {
 132         if (SharedDelete == FALSE)
 133           return (STATUS_SHARING_VIOLATION);
 134      }
 135
 136    if (Update == TRUE)
 137      {
 138         ShareAccess->OpenCount++;
 139
 140         if (ReadAccess == TRUE)
 141           ShareAccess->Readers++;
 142
 143         if (WriteAccess == TRUE)
 144           ShareAccess->Writers++;
 145
 146         if (DeleteAccess == TRUE)
 147           ShareAccess->Deleters++;
 148
 149         if (SharedRead == TRUE)
 150           ShareAccess->SharedRead++;
 151
 152         if (SharedWrite == TRUE)
 153           ShareAccess->SharedWrite++;
 154
 155         if (SharedDelete == TRUE)
 156           ShareAccess->SharedDelete++;
 157      }
 158
 159    return (STATUS_SUCCESS);
 160 }
 161
 162
 163 VOID STDCALL
 164 IoRemoveShareAccess(PFILE_OBJECT FileObject,
 165                     PSHARE_ACCESS ShareAccess)
 166 {
 167    if ((FileObject->ReadAccess == FALSE) &&
 168        (FileObject->WriteAccess == FALSE) &&
 169        (FileObject->DeleteAccess == FALSE))
 170      {
 171         return;
 172      }
 173
 174    ShareAccess->OpenCount--;
 175
 176    if (FileObject->ReadAccess == TRUE)
 177      {
 178         ShareAccess->Readers--;
 179      }
 180
 181    if (FileObject->WriteAccess == TRUE)
 182      {
 183         ShareAccess->Writers--;
 184      }
 185
 186    if (FileObject->DeleteAccess == TRUE)
 187      {
 188         ShareAccess->Deleters--;
 189      }
 190
 191    if (FileObject->SharedRead == TRUE)
 192      {
 193         ShareAccess->SharedRead--;
 194      }
 195
 196    if (FileObject->SharedWrite == TRUE)
 197      {
 198         ShareAccess->SharedWrite--;
 199      }
 200
 201    if (FileObject->SharedDelete == TRUE)
 202      {
 203         ShareAccess->SharedDelete--;
 204      }
 205 }
 206
 207
 208 VOID STDCALL
 209 IoSetShareAccess(ACCESS_MASK DesiredAccess,
 210                  ULONG DesiredShareAccess,
 211                  PFILE_OBJECT FileObject,
 212                  PSHARE_ACCESS ShareAccess)
 213 {
 214    BOOLEAN ReadAccess;
 215    BOOLEAN WriteAccess;
 216    BOOLEAN DeleteAccess;
 217    BOOLEAN SharedRead;
 218    BOOLEAN SharedWrite;
 219    BOOLEAN SharedDelete;
 220
 221    ReadAccess = (DesiredAccess & (FILE_READ_DATA | FILE_EXECUTE));
 222    WriteAccess = (DesiredAccess & (FILE_READ_DATA | FILE_APPEND_DATA));
 223    DeleteAccess = (DesiredAccess & DELETE);
 224
 225    FileObject->ReadAccess = ReadAccess;
 226    FileObject->WriteAccess = WriteAccess;
 227    FileObject->DeleteAccess = DeleteAccess;
 228
 229    if (!ReadAccess && !WriteAccess && !DeleteAccess)
 230      {
 231         FileObject->SharedRead = FALSE;
 232         FileObject->SharedWrite = FALSE;
 233         FileObject->SharedDelete = FALSE;
 234
 235         ShareAccess->OpenCount = 0;
 236         ShareAccess->Readers = 0;
 237         ShareAccess->Writers = 0;
 238         ShareAccess->Deleters = 0;
 239
 240         ShareAccess->SharedRead = 0;
 241         ShareAccess->SharedWrite = 0;
 242         ShareAccess->SharedDelete = 0;
 243      }
 244    else
 245      {
 246         SharedRead = (DesiredShareAccess & FILE_SHARE_READ);
 247         SharedWrite = (DesiredShareAccess & FILE_SHARE_WRITE);
 248         SharedDelete = (DesiredShareAccess & FILE_SHARE_DELETE);
 249
 250         FileObject->SharedRead = SharedRead;
 251         FileObject->SharedWrite = SharedWrite;
 252         FileObject->SharedDelete = SharedDelete;
 253
 254         ShareAccess->OpenCount = 1;
 255         ShareAccess->Readers = (ReadAccess) ? 1 : 0;
 256         ShareAccess->Writers = (WriteAccess) ? 1 : 0;
 257         ShareAccess->Deleters = (DeleteAccess) ? 1 : 0;
 258
 259         ShareAccess->SharedRead = (SharedRead) ? 1 : 0;
 260         ShareAccess->SharedWrite = (SharedWrite) ? 1 : 0;
 261         ShareAccess->SharedDelete = (SharedDelete) ? 1 : 0;
 262      }
 263 }
 264
 265
 266 NTSTATUS STDCALL
 267 IoCheckDesiredAccess(IN OUT PACCESS_MASK DesiredAccess,
 268                      IN ACCESS_MASK GrantedAccess)
 269 {
 270   UNIMPLEMENTED;
 271   return(STATUS_NOT_IMPLEMENTED);
 272 }
 273
 274
 275 NTSTATUS STDCALL
 276 IoCheckEaBufferValidity(IN PFILE_FULL_EA_INFORMATION EaBuffer,
 277                         IN ULONG EaLength,
 278                         OUT PULONG ErrorOffset)
 279 {
 280   UNIMPLEMENTED;
 281   return(STATUS_NOT_IMPLEMENTED);
 282 }
 283
 284
 285 NTSTATUS STDCALL
 286 IoCheckFunctionAccess(IN ACCESS_MASK GrantedAccess,
 287                       IN UCHAR MajorFunction,
 288                       IN UCHAR MinorFunction,
 289                       IN ULONG IoControlCode,
 290                       IN PFILE_INFORMATION_CLASS FileInformationClass OPTIONAL,
 291                       IN PFS_INFORMATION_CLASS FsInformationClass OPTIONAL)
 292 {
 293   UNIMPLEMENTED;
 294   return(STATUS_NOT_IMPLEMENTED);
 295 }
 296
 297
 298 NTSTATUS STDCALL
 299 IoSetInformation(IN PFILE_OBJECT FileObject,
 300                  IN FILE_INFORMATION_CLASS FileInformationClass,
 301                  IN ULONG Length,
 302                  OUT PVOID FileInformation)
 303 {
 304   UNIMPLEMENTED;
 305   return(STATUS_NOT_IMPLEMENTED);
 306 }
 307
 308
 309 BOOLEAN STDCALL
 310 IoFastQueryNetworkAttributes(IN POBJECT_ATTRIBUTES ObjectAttributes,
 311                              IN ACCESS_MASK DesiredAccess,
 312                              IN ULONG OpenOptions,
 313                              OUT PIO_STATUS_BLOCK IoStatus,
 314                              OUT PFILE_NETWORK_OPEN_INFORMATION Buffer)
 315 {
 316   UNIMPLEMENTED;
 317   return(FALSE);
 318 }
 319
 320 /* EOF */