reactos/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 <ntoskrnl.h>
  33 #include <internal/debug.h>
  34
  35 /* FUNCTIONS *****************************************************************/
  36
  37 /*
  38  * @implemented
  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 /*
  86  * @implemented
  87  */
  88 NTSTATUS STDCALL
  89 IoCheckShareAccess(IN ACCESS_MASK DesiredAccess,
  90                    IN ULONG DesiredShareAccess,
  91                    IN PFILE_OBJECT FileObject,
  92                    IN PSHARE_ACCESS ShareAccess,
  93                    IN BOOLEAN Update)
  94 {
  95   BOOLEAN ReadAccess;
  96   BOOLEAN WriteAccess;
  97   BOOLEAN DeleteAccess;
  98   BOOLEAN SharedRead;
  99   BOOLEAN SharedWrite;
 100   BOOLEAN SharedDelete;
 101
 102   ReadAccess = (DesiredAccess & (FILE_READ_DATA | FILE_EXECUTE));
 103   WriteAccess = (DesiredAccess & (FILE_WRITE_DATA | FILE_APPEND_DATA));
 104   DeleteAccess = (DesiredAccess & DELETE);
 105
 106   FileObject->ReadAccess = ReadAccess;
 107   FileObject->WriteAccess = WriteAccess;
 108   FileObject->DeleteAccess = DeleteAccess;
 109
 110   if (!ReadAccess && !WriteAccess && !DeleteAccess)
 111     {
 112       return(STATUS_SUCCESS);
 113     }
 114
 115   SharedRead = (DesiredShareAccess & FILE_SHARE_READ);
 116   SharedWrite = (DesiredShareAccess & FILE_SHARE_WRITE);
 117   SharedDelete = (DesiredShareAccess & FILE_SHARE_DELETE);
 118
 119   FileObject->SharedRead = SharedRead;
 120   FileObject->SharedWrite = SharedWrite;
 121   FileObject->SharedDelete = SharedDelete;
 122
 123   if (ReadAccess)
 124     {
 125       if (ShareAccess->SharedRead < ShareAccess->OpenCount)
 126         return(STATUS_SHARING_VIOLATION);
 127     }
 128
 129   if (WriteAccess)
 130     {
 131       if (ShareAccess->SharedWrite < ShareAccess->OpenCount)
 132         return(STATUS_SHARING_VIOLATION);
 133     }
 134
 135   if (DeleteAccess)
 136     {
 137       if (ShareAccess->SharedDelete < ShareAccess->OpenCount)
 138         return(STATUS_SHARING_VIOLATION);
 139     }
 140
 141   if (ShareAccess->Readers != 0)
 142     {
 143       if (SharedRead == FALSE)
 144         return(STATUS_SHARING_VIOLATION);
 145     }
 146
 147   if (ShareAccess->Writers != 0)
 148     {
 149       if (SharedWrite == FALSE)
 150         return(STATUS_SHARING_VIOLATION);
 151     }
 152
 153   if (ShareAccess->Deleters != 0)
 154     {
 155       if (SharedDelete == FALSE)
 156         return(STATUS_SHARING_VIOLATION);
 157     }
 158
 159   if (Update == TRUE)
 160     {
 161       ShareAccess->OpenCount++;
 162
 163       if (ReadAccess == TRUE)
 164         ShareAccess->Readers++;
 165
 166       if (WriteAccess == TRUE)
 167         ShareAccess->Writers++;
 168
 169       if (DeleteAccess == TRUE)
 170         ShareAccess->Deleters++;
 171
 172       if (SharedRead == TRUE)
 173         ShareAccess->SharedRead++;
 174
 175       if (SharedWrite == TRUE)
 176         ShareAccess->SharedWrite++;
 177
 178       if (SharedDelete == TRUE)
 179         ShareAccess->SharedDelete++;
 180     }
 181
 182   return(STATUS_SUCCESS);
 183 }
 184
 185
 186 /*
 187  * @implemented
 188  */
 189 VOID STDCALL
 190 IoRemoveShareAccess(IN PFILE_OBJECT FileObject,
 191                     IN PSHARE_ACCESS ShareAccess)
 192 {
 193   if ((FileObject->ReadAccess == FALSE) &&
 194       (FileObject->WriteAccess == FALSE) &&
 195       (FileObject->DeleteAccess == FALSE))
 196     {
 197       return;
 198     }
 199
 200   ShareAccess->OpenCount--;
 201
 202   if (FileObject->ReadAccess == TRUE)
 203     {
 204       ShareAccess->Readers--;
 205     }
 206
 207   if (FileObject->WriteAccess == TRUE)
 208     {
 209       ShareAccess->Writers--;
 210     }
 211
 212   if (FileObject->DeleteAccess == TRUE)
 213     {
 214       ShareAccess->Deleters--;
 215     }
 216
 217   if (FileObject->SharedRead == TRUE)
 218     {
 219       ShareAccess->SharedRead--;
 220     }
 221
 222   if (FileObject->SharedWrite == TRUE)
 223     {
 224       ShareAccess->SharedWrite--;
 225     }
 226
 227   if (FileObject->SharedDelete == TRUE)
 228     {
 229       ShareAccess->SharedDelete--;
 230     }
 231 }
 232
 233
 234 /*
 235  * @implemented
 236  */
 237 VOID STDCALL
 238 IoSetShareAccess(IN ACCESS_MASK DesiredAccess,
 239                  IN ULONG DesiredShareAccess,
 240                  IN PFILE_OBJECT FileObject,
 241                  OUT PSHARE_ACCESS ShareAccess)
 242 {
 243   BOOLEAN ReadAccess;
 244   BOOLEAN WriteAccess;
 245   BOOLEAN DeleteAccess;
 246   BOOLEAN SharedRead;
 247   BOOLEAN SharedWrite;
 248   BOOLEAN SharedDelete;
 249
 250   ReadAccess = (DesiredAccess & (FILE_READ_DATA | FILE_EXECUTE));
 251   WriteAccess = (DesiredAccess & (FILE_WRITE_DATA | FILE_APPEND_DATA));
 252   DeleteAccess = (DesiredAccess & DELETE);
 253
 254   FileObject->ReadAccess = ReadAccess;
 255   FileObject->WriteAccess = WriteAccess;
 256   FileObject->DeleteAccess = DeleteAccess;
 257
 258   if (!ReadAccess && !WriteAccess && !DeleteAccess)
 259     {
 260       FileObject->SharedRead = FALSE;
 261       FileObject->SharedWrite = FALSE;
 262       FileObject->SharedDelete = FALSE;
 263
 264       ShareAccess->OpenCount = 0;
 265       ShareAccess->Readers = 0;
 266       ShareAccess->Writers = 0;
 267       ShareAccess->Deleters = 0;
 268
 269       ShareAccess->SharedRead = 0;
 270       ShareAccess->SharedWrite = 0;
 271       ShareAccess->SharedDelete = 0;
 272     }
 273   else
 274     {
 275       SharedRead = (DesiredShareAccess & FILE_SHARE_READ);
 276       SharedWrite = (DesiredShareAccess & FILE_SHARE_WRITE);
 277       SharedDelete = (DesiredShareAccess & FILE_SHARE_DELETE);
 278
 279       FileObject->SharedRead = SharedRead;
 280       FileObject->SharedWrite = SharedWrite;
 281       FileObject->SharedDelete = SharedDelete;
 282
 283       ShareAccess->OpenCount = 1;
 284       ShareAccess->Readers = (ReadAccess) ? 1 : 0;
 285       ShareAccess->Writers = (WriteAccess) ? 1 : 0;
 286       ShareAccess->Deleters = (DeleteAccess) ? 1 : 0;
 287
 288       ShareAccess->SharedRead = (SharedRead) ? 1 : 0;
 289       ShareAccess->SharedWrite = (SharedWrite) ? 1 : 0;
 290       ShareAccess->SharedDelete = (SharedDelete) ? 1 : 0;
 291     }
 292 }
 293
 294
 295 /*
 296  * @implemented
 297  */
 298 NTSTATUS STDCALL
 299 IoCheckDesiredAccess(IN OUT PACCESS_MASK DesiredAccess,
 300                      IN ACCESS_MASK GrantedAccess)
 301 {
 302   RtlMapGenericMask(DesiredAccess,
 303                     IoFileObjectType->Mapping);
 304   if ((*DesiredAccess & GrantedAccess) != GrantedAccess)
 305     return(STATUS_ACCESS_DENIED);
 306
 307   return(STATUS_SUCCESS);
 308 }
 309
 310
 311 /*
 312  * @unimplemented
 313  */
 314 NTSTATUS STDCALL
 315 IoCheckEaBufferValidity(IN PFILE_FULL_EA_INFORMATION EaBuffer,
 316                         IN ULONG EaLength,
 317                         OUT PULONG ErrorOffset)
 318 {
 319   UNIMPLEMENTED;
 320   return(STATUS_NOT_IMPLEMENTED);
 321 }
 322
 323
 324 /*
 325  * @unimplemented
 326  */
 327 NTSTATUS STDCALL
 328 IoCheckFunctionAccess(IN ACCESS_MASK GrantedAccess,
 329                       IN UCHAR MajorFunction,
 330                       IN UCHAR MinorFunction,
 331                       IN ULONG IoControlCode,
 332                       IN PVOID ExtraData OPTIONAL,
 333                       IN PVOID ExtraData2 OPTIONAL)
 334 {
 335   UNIMPLEMENTED;
 336   return(STATUS_NOT_IMPLEMENTED);
 337 }
 338
 339
 340 /*
 341  * @unimplemented
 342  */
 343 NTSTATUS STDCALL
 344 IoSetInformation(IN PFILE_OBJECT FileObject,
 345                  IN FILE_INFORMATION_CLASS FileInformationClass,
 346                  IN ULONG Length,
 347                  OUT PVOID FileInformation)
 348 {
 349   UNIMPLEMENTED;
 350   return(STATUS_NOT_IMPLEMENTED);
 351 }
 352
 353
 354 /*
 355  * @unimplemented
 356  */
 357 BOOLEAN STDCALL
 358 IoFastQueryNetworkAttributes(IN POBJECT_ATTRIBUTES ObjectAttributes,
 359                              IN ACCESS_MASK DesiredAccess,
 360                              IN ULONG OpenOptions,
 361                              OUT PIO_STATUS_BLOCK IoStatus,
 362                              OUT PFILE_NETWORK_OPEN_INFORMATION Buffer)
 363 {
 364   UNIMPLEMENTED;
 365   return(FALSE);
 366 }
 367
 368 /* EOF */