ntoskrnl/io/share.c

   1 /*
   2  *  ReactOS kernel
   3  *  Copyright (C) 1998, 1999, 2000, 2001 ReactOS Team
   4  *
   5  *  This program is free software; you can redistribute it and/or modify
   6  *  it under the terms of the GNU General Public License as published by
   7  *  the Free Software Foundation; either version 2 of the License, or
   8  *  (at your option) any later version.
   9  *
  10  *  This program is distributed in the hope that it will be useful,
  11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  *  GNU General Public License for more details.
  14  *
  15  *  You should have received a copy of the GNU General Public License
  16  *  along with this program; if not, write to the Free Software
  17  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18  */
  19 /* $Id$
  20  *
  21  * COPYRIGHT:       See COPYING in the top level directory
  22  * PROJECT:         ReactOS kernel
  23  * FILE:            ntoskrnl/io/share.c
  24  * PURPOSE:
  25  * PROGRAMMER:      David Welch (welch@mcmail.com)
  26  * UPDATE HISTORY:
  27  *                  Created 22/05/98
  28  */
  29
  30 /* INCLUDES *****************************************************************/
  31
  32 #include <ddk/ntddk.h>
  33
  34 #include <internal/debug.h>
  35
  36 /* FUNCTIONS *****************************************************************/
  37
  38 #ifndef LIBCAPTIVE
  39
  40 VOID STDCALL
  41 IoUpdateShareAccess(PFILE_OBJECT FileObject,
  42                     PSHARE_ACCESS ShareAccess)
  43 {
  44    if ((FileObject->ReadAccess == FALSE) &&
  45        (FileObject->WriteAccess == FALSE) &&
  46        (FileObject->DeleteAccess == FALSE))
  47      {
  48         return;
  49      }
  50
  51    ShareAccess->OpenCount++;
  52
  53    if (FileObject->ReadAccess == TRUE)
  54      {
  55         ShareAccess->Readers++;
  56      }
  57
  58    if (FileObject->WriteAccess == TRUE)
  59      {
  60         ShareAccess->Writers++;
  61      }
  62
  63    if (FileObject->DeleteAccess == TRUE)
  64      {
  65         ShareAccess->Deleters++;
  66      }
  67
  68    if (FileObject->SharedRead == TRUE)
  69      {
  70         ShareAccess->SharedRead++;
  71      }
  72
  73    if (FileObject->SharedWrite == TRUE)
  74      {
  75         ShareAccess->SharedWrite++;
  76      }
  77
  78    if (FileObject->SharedDelete == TRUE)
  79      {
  80         ShareAccess->SharedDelete++;
  81      }
  82 }
  83
  84
  85 NTSTATUS STDCALL
  86 IoCheckShareAccess(IN ACCESS_MASK DesiredAccess,
  87                    IN ULONG DesiredShareAccess,
  88                    IN PFILE_OBJECT FileObject,
  89                    IN PSHARE_ACCESS ShareAccess,
  90                    IN BOOLEAN Update)
  91 {
  92   BOOLEAN ReadAccess;
  93   BOOLEAN WriteAccess;
  94   BOOLEAN DeleteAccess;
  95   BOOLEAN SharedRead;
  96   BOOLEAN SharedWrite;
  97   BOOLEAN SharedDelete;
  98
  99   ReadAccess = (DesiredAccess & (FILE_READ_DATA | FILE_EXECUTE));
 100   WriteAccess = (DesiredAccess & (FILE_READ_DATA | FILE_APPEND_DATA));
 101   DeleteAccess = (DesiredAccess & DELETE);
 102
 103   FileObject->ReadAccess = ReadAccess;
 104   FileObject->WriteAccess = WriteAccess;
 105   FileObject->DeleteAccess = DeleteAccess;
 106
 107   if (!ReadAccess && !WriteAccess && !DeleteAccess)
 108     {
 109       return(STATUS_SUCCESS);
 110     }
 111
 112   SharedRead = (DesiredShareAccess & FILE_SHARE_READ);
 113   SharedWrite = (DesiredShareAccess & FILE_SHARE_WRITE);
 114   SharedDelete = (DesiredShareAccess & FILE_SHARE_DELETE);
 115
 116   FileObject->SharedRead = SharedRead;
 117   FileObject->SharedWrite = SharedWrite;
 118   FileObject->SharedDelete = SharedDelete;
 119
 120   if (ReadAccess)
 121     {
 122       if (ShareAccess->SharedRead < ShareAccess->OpenCount)
 123         return(STATUS_SHARING_VIOLATION);
 124     }
 125
 126   if (WriteAccess)
 127     {
 128       if (ShareAccess->SharedWrite < ShareAccess->OpenCount)
 129         return(STATUS_SHARING_VIOLATION);
 130     }
 131
 132   if (DeleteAccess)
 133     {
 134       if (ShareAccess->SharedDelete < ShareAccess->OpenCount)
 135         return(STATUS_SHARING_VIOLATION);
 136     }
 137
 138   if (ShareAccess->Readers != 0)
 139     {
 140       if (SharedRead == FALSE)
 141         return(STATUS_SHARING_VIOLATION);
 142     }
 143
 144   if (ShareAccess->Writers != 0)
 145     {
 146       if (SharedWrite == FALSE)
 147         return(STATUS_SHARING_VIOLATION);
 148     }
 149
 150   if (ShareAccess->Deleters != 0)
 151     {
 152       if (SharedDelete == FALSE)
 153         return(STATUS_SHARING_VIOLATION);
 154     }
 155
 156   if (Update == TRUE)
 157     {
 158       ShareAccess->OpenCount++;
 159
 160       if (ReadAccess == TRUE)
 161         ShareAccess->Readers++;
 162
 163       if (WriteAccess == TRUE)
 164         ShareAccess->Writers++;
 165
 166       if (DeleteAccess == TRUE)
 167         ShareAccess->Deleters++;
 168
 169       if (SharedRead == TRUE)
 170         ShareAccess->SharedRead++;
 171
 172       if (SharedWrite == TRUE)
 173         ShareAccess->SharedWrite++;
 174
 175       if (SharedDelete == TRUE)
 176         ShareAccess->SharedDelete++;
 177     }
 178
 179   return(STATUS_SUCCESS);
 180 }
 181
 182 #endif /* LIBCAPTIVE */
 183
 184 VOID STDCALL
 185 IoRemoveShareAccess(IN PFILE_OBJECT FileObject,
 186                     IN PSHARE_ACCESS ShareAccess)
 187 {
 188   if ((FileObject->ReadAccess == FALSE) &&
 189       (FileObject->WriteAccess == FALSE) &&
 190       (FileObject->DeleteAccess == FALSE))
 191     {
 192       return;
 193     }
 194
 195   ShareAccess->OpenCount--;
 196
 197   if (FileObject->ReadAccess == TRUE)
 198     {
 199       ShareAccess->Readers--;
 200     }
 201
 202   if (FileObject->WriteAccess == TRUE)
 203     {
 204       ShareAccess->Writers--;
 205     }
 206
 207   if (FileObject->DeleteAccess == TRUE)
 208     {
 209       ShareAccess->Deleters--;
 210     }
 211
 212   if (FileObject->SharedRead == TRUE)
 213     {
 214       ShareAccess->SharedRead--;
 215     }
 216
 217   if (FileObject->SharedWrite == TRUE)
 218     {
 219       ShareAccess->SharedWrite--;
 220     }
 221
 222   if (FileObject->SharedDelete == TRUE)
 223     {
 224       ShareAccess->SharedDelete--;
 225     }
 226 }
 227
 228
 229 VOID STDCALL
 230 IoSetShareAccess(IN ACCESS_MASK DesiredAccess,
 231                  IN ULONG DesiredShareAccess,
 232                  IN PFILE_OBJECT FileObject,
 233                  OUT PSHARE_ACCESS ShareAccess)
 234 {
 235   BOOLEAN ReadAccess;
 236   BOOLEAN WriteAccess;
 237   BOOLEAN DeleteAccess;
 238   BOOLEAN SharedRead;
 239   BOOLEAN SharedWrite;
 240   BOOLEAN SharedDelete;
 241
 242   ReadAccess = (DesiredAccess & (FILE_READ_DATA | FILE_EXECUTE));
 243   WriteAccess = (DesiredAccess & (FILE_READ_DATA | FILE_APPEND_DATA));
 244   DeleteAccess = (DesiredAccess & DELETE);
 245
 246   FileObject->ReadAccess = ReadAccess;
 247   FileObject->WriteAccess = WriteAccess;
 248   FileObject->DeleteAccess = DeleteAccess;
 249
 250   if (!ReadAccess && !WriteAccess && !DeleteAccess)
 251     {
 252       FileObject->SharedRead = FALSE;
 253       FileObject->SharedWrite = FALSE;
 254       FileObject->SharedDelete = FALSE;
 255
 256       ShareAccess->OpenCount = 0;
 257       ShareAccess->Readers = 0;
 258       ShareAccess->Writers = 0;
 259       ShareAccess->Deleters = 0;
 260
 261       ShareAccess->SharedRead = 0;
 262       ShareAccess->SharedWrite = 0;
 263       ShareAccess->SharedDelete = 0;
 264     }
 265   else
 266     {
 267       SharedRead = (DesiredShareAccess & FILE_SHARE_READ);
 268       SharedWrite = (DesiredShareAccess & FILE_SHARE_WRITE);
 269       SharedDelete = (DesiredShareAccess & FILE_SHARE_DELETE);
 270
 271       FileObject->SharedRead = SharedRead;
 272       FileObject->SharedWrite = SharedWrite;
 273       FileObject->SharedDelete = SharedDelete;
 274
 275       ShareAccess->OpenCount = 1;
 276       ShareAccess->Readers = (ReadAccess) ? 1 : 0;
 277       ShareAccess->Writers = (WriteAccess) ? 1 : 0;
 278       ShareAccess->Deleters = (DeleteAccess) ? 1 : 0;
 279
 280       ShareAccess->SharedRead = (SharedRead) ? 1 : 0;
 281       ShareAccess->SharedWrite = (SharedWrite) ? 1 : 0;
 282       ShareAccess->SharedDelete = (SharedDelete) ? 1 : 0;
 283     }
 284 }
 285
 286 #ifndef LIBCAPTIVE
 287
 288 NTSTATUS STDCALL
 289 IoCheckDesiredAccess(IN OUT PACCESS_MASK DesiredAccess,
 290                      IN ACCESS_MASK GrantedAccess)
 291 {
 292   RtlMapGenericMask(DesiredAccess,
 293                     IoFileObjectType->Mapping);
 294   if ((*DesiredAccess & GrantedAccess) != GrantedAccess)
 295     return(STATUS_ACCESS_DENIED);
 296
 297   return(STATUS_SUCCESS);
 298 }
 299
 300
 301 NTSTATUS STDCALL
 302 IoCheckEaBufferValidity(IN PFILE_FULL_EA_INFORMATION EaBuffer,
 303                         IN ULONG EaLength,
 304                         OUT PULONG ErrorOffset)
 305 {
 306   UNIMPLEMENTED;
 307   return(STATUS_NOT_IMPLEMENTED);
 308 }
 309
 310
 311 NTSTATUS STDCALL
 312 IoCheckFunctionAccess(IN ACCESS_MASK GrantedAccess,
 313                       IN UCHAR MajorFunction,
 314                       IN UCHAR MinorFunction,
 315                       IN ULONG IoControlCode,
 316                       IN PFILE_INFORMATION_CLASS FileInformationClass OPTIONAL,
 317                       IN PFS_INFORMATION_CLASS FsInformationClass OPTIONAL)
 318 {
 319   UNIMPLEMENTED;
 320   return(STATUS_NOT_IMPLEMENTED);
 321 }
 322
 323
 324 NTSTATUS STDCALL
 325 IoSetInformation(IN PFILE_OBJECT FileObject,
 326                  IN FILE_INFORMATION_CLASS FileInformationClass,
 327                  IN ULONG Length,
 328                  OUT PVOID FileInformation)
 329 {
 330   UNIMPLEMENTED;
 331   return(STATUS_NOT_IMPLEMENTED);
 332 }
 333
 334
 335 BOOLEAN STDCALL
 336 IoFastQueryNetworkAttributes(IN POBJECT_ATTRIBUTES ObjectAttributes,
 337                              IN ACCESS_MASK DesiredAccess,
 338                              IN ULONG OpenOptions,
 339                              OUT PIO_STATUS_BLOCK IoStatus,
 340                              OUT PFILE_NETWORK_OPEN_INFORMATION Buffer)
 341 {
 342   UNIMPLEMENTED;
 343   return(FALSE);
 344 }
 345
 346 #endif /* LIBCAPTIVE */
 347
 348 /* EOF */