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 VOID STDCALL
  39 IoUpdateShareAccess(PFILE_OBJECT FileObject,
  40                     PSHARE_ACCESS ShareAccess)
  41 {
  42    if ((FileObject->ReadAccess == FALSE) &&
  43        (FileObject->WriteAccess == FALSE) &&
  44        (FileObject->DeleteAccess == FALSE))
  45      {
  46         return;
  47      }
  48
  49    ShareAccess->OpenCount++;
  50
  51    if (FileObject->ReadAccess == TRUE)
  52      {
  53         ShareAccess->Readers++;
  54      }
  55
  56    if (FileObject->WriteAccess == TRUE)
  57      {
  58         ShareAccess->Writers++;
  59      }
  60
  61    if (FileObject->DeleteAccess == TRUE)
  62      {
  63         ShareAccess->Deleters++;
  64      }
  65
  66    if (FileObject->SharedRead == TRUE)
  67      {
  68         ShareAccess->SharedRead++;
  69      }
  70
  71    if (FileObject->SharedWrite == TRUE)
  72      {
  73         ShareAccess->SharedWrite++;
  74      }
  75
  76    if (FileObject->SharedDelete == TRUE)
  77      {
  78         ShareAccess->SharedDelete++;
  79      }
  80 }
  81
  82
  83 NTSTATUS STDCALL
  84 IoCheckShareAccess(IN ACCESS_MASK DesiredAccess,
  85                    IN ULONG DesiredShareAccess,
  86                    IN PFILE_OBJECT FileObject,
  87                    IN PSHARE_ACCESS ShareAccess,
  88                    IN BOOLEAN Update)
  89 {
  90   BOOLEAN ReadAccess;
  91   BOOLEAN WriteAccess;
  92   BOOLEAN DeleteAccess;
  93   BOOLEAN SharedRead;
  94   BOOLEAN SharedWrite;
  95   BOOLEAN SharedDelete;
  96
  97   ReadAccess = (DesiredAccess & (FILE_READ_DATA | FILE_EXECUTE));
  98   WriteAccess = (DesiredAccess & (FILE_READ_DATA | FILE_APPEND_DATA));
  99   DeleteAccess = (DesiredAccess & DELETE);
 100
 101   FileObject->ReadAccess = ReadAccess;
 102   FileObject->WriteAccess = WriteAccess;
 103   FileObject->DeleteAccess = DeleteAccess;
 104
 105   if (!ReadAccess && !WriteAccess && !DeleteAccess)
 106     {
 107       return(STATUS_SUCCESS);
 108     }
 109
 110   SharedRead = (DesiredShareAccess & FILE_SHARE_READ);
 111   SharedWrite = (DesiredShareAccess & FILE_SHARE_WRITE);
 112   SharedDelete = (DesiredShareAccess & FILE_SHARE_DELETE);
 113
 114   FileObject->SharedRead = SharedRead;
 115   FileObject->SharedWrite = SharedWrite;
 116   FileObject->SharedDelete = SharedDelete;
 117
 118   if (ReadAccess)
 119     {
 120       if (ShareAccess->SharedRead < ShareAccess->OpenCount)
 121         return(STATUS_SHARING_VIOLATION);
 122     }
 123
 124   if (WriteAccess)
 125     {
 126       if (ShareAccess->SharedWrite < ShareAccess->OpenCount)
 127         return(STATUS_SHARING_VIOLATION);
 128     }
 129
 130   if (DeleteAccess)
 131     {
 132       if (ShareAccess->SharedDelete < ShareAccess->OpenCount)
 133         return(STATUS_SHARING_VIOLATION);
 134     }
 135
 136   if (ShareAccess->Readers != 0)
 137     {
 138       if (SharedRead == FALSE)
 139         return(STATUS_SHARING_VIOLATION);
 140     }
 141
 142   if (ShareAccess->Writers != 0)
 143     {
 144       if (SharedWrite == FALSE)
 145         return(STATUS_SHARING_VIOLATION);
 146     }
 147
 148   if (ShareAccess->Deleters != 0)
 149     {
 150       if (SharedDelete == FALSE)
 151         return(STATUS_SHARING_VIOLATION);
 152     }
 153
 154   if (Update == TRUE)
 155     {
 156       ShareAccess->OpenCount++;
 157
 158       if (ReadAccess == TRUE)
 159         ShareAccess->Readers++;
 160
 161       if (WriteAccess == TRUE)
 162         ShareAccess->Writers++;
 163
 164       if (DeleteAccess == TRUE)
 165         ShareAccess->Deleters++;
 166
 167       if (SharedRead == TRUE)
 168         ShareAccess->SharedRead++;
 169
 170       if (SharedWrite == TRUE)
 171         ShareAccess->SharedWrite++;
 172
 173       if (SharedDelete == TRUE)
 174         ShareAccess->SharedDelete++;
 175     }
 176
 177   return(STATUS_SUCCESS);
 178 }
 179
 180
 181 VOID STDCALL
 182 IoRemoveShareAccess(IN PFILE_OBJECT FileObject,
 183                     IN PSHARE_ACCESS ShareAccess)
 184 {
 185   if ((FileObject->ReadAccess == FALSE) &&
 186       (FileObject->WriteAccess == FALSE) &&
 187       (FileObject->DeleteAccess == FALSE))
 188     {
 189       return;
 190     }
 191
 192   ShareAccess->OpenCount--;
 193
 194   if (FileObject->ReadAccess == TRUE)
 195     {
 196       ShareAccess->Readers--;
 197     }
 198
 199   if (FileObject->WriteAccess == TRUE)
 200     {
 201       ShareAccess->Writers--;
 202     }
 203
 204   if (FileObject->DeleteAccess == TRUE)
 205     {
 206       ShareAccess->Deleters--;
 207     }
 208
 209   if (FileObject->SharedRead == TRUE)
 210     {
 211       ShareAccess->SharedRead--;
 212     }
 213
 214   if (FileObject->SharedWrite == TRUE)
 215     {
 216       ShareAccess->SharedWrite--;
 217     }
 218
 219   if (FileObject->SharedDelete == TRUE)
 220     {
 221       ShareAccess->SharedDelete--;
 222     }
 223 }
 224
 225
 226 VOID STDCALL
 227 IoSetShareAccess(IN ACCESS_MASK DesiredAccess,
 228                  IN ULONG DesiredShareAccess,
 229                  IN PFILE_OBJECT FileObject,
 230                  OUT PSHARE_ACCESS ShareAccess)
 231 {
 232   BOOLEAN ReadAccess;
 233   BOOLEAN WriteAccess;
 234   BOOLEAN DeleteAccess;
 235   BOOLEAN SharedRead;
 236   BOOLEAN SharedWrite;
 237   BOOLEAN SharedDelete;
 238
 239   ReadAccess = (DesiredAccess & (FILE_READ_DATA | FILE_EXECUTE));
 240   WriteAccess = (DesiredAccess & (FILE_READ_DATA | FILE_APPEND_DATA));
 241   DeleteAccess = (DesiredAccess & DELETE);
 242
 243   FileObject->ReadAccess = ReadAccess;
 244   FileObject->WriteAccess = WriteAccess;
 245   FileObject->DeleteAccess = DeleteAccess;
 246
 247   if (!ReadAccess && !WriteAccess && !DeleteAccess)
 248     {
 249       FileObject->SharedRead = FALSE;
 250       FileObject->SharedWrite = FALSE;
 251       FileObject->SharedDelete = FALSE;
 252
 253       ShareAccess->OpenCount = 0;
 254       ShareAccess->Readers = 0;
 255       ShareAccess->Writers = 0;
 256       ShareAccess->Deleters = 0;
 257
 258       ShareAccess->SharedRead = 0;
 259       ShareAccess->SharedWrite = 0;
 260       ShareAccess->SharedDelete = 0;
 261     }
 262   else
 263     {
 264       SharedRead = (DesiredShareAccess & FILE_SHARE_READ);
 265       SharedWrite = (DesiredShareAccess & FILE_SHARE_WRITE);
 266       SharedDelete = (DesiredShareAccess & FILE_SHARE_DELETE);
 267
 268       FileObject->SharedRead = SharedRead;
 269       FileObject->SharedWrite = SharedWrite;
 270       FileObject->SharedDelete = SharedDelete;
 271
 272       ShareAccess->OpenCount = 1;
 273       ShareAccess->Readers = (ReadAccess) ? 1 : 0;
 274       ShareAccess->Writers = (WriteAccess) ? 1 : 0;
 275       ShareAccess->Deleters = (DeleteAccess) ? 1 : 0;
 276
 277       ShareAccess->SharedRead = (SharedRead) ? 1 : 0;
 278       ShareAccess->SharedWrite = (SharedWrite) ? 1 : 0;
 279       ShareAccess->SharedDelete = (SharedDelete) ? 1 : 0;
 280     }
 281 }
 282
 283
 284 NTSTATUS STDCALL
 285 IoCheckDesiredAccess(IN OUT PACCESS_MASK DesiredAccess,
 286                      IN ACCESS_MASK GrantedAccess)
 287 {
 288   RtlMapGenericMask(DesiredAccess,
 289                     IoFileObjectType->Mapping);
 290   if ((*DesiredAccess & GrantedAccess) != GrantedAccess)
 291     return(STATUS_ACCESS_DENIED);
 292
 293   return(STATUS_SUCCESS);
 294 }
 295
 296
 297 NTSTATUS STDCALL
 298 IoCheckEaBufferValidity(IN PFILE_FULL_EA_INFORMATION EaBuffer,
 299                         IN ULONG EaLength,
 300                         OUT PULONG ErrorOffset)
 301 {
 302   UNIMPLEMENTED;
 303   return(STATUS_NOT_IMPLEMENTED);
 304 }
 305
 306
 307 NTSTATUS STDCALL
 308 IoCheckFunctionAccess(IN ACCESS_MASK GrantedAccess,
 309                       IN UCHAR MajorFunction,
 310                       IN UCHAR MinorFunction,
 311                       IN ULONG IoControlCode,
 312                       IN PFILE_INFORMATION_CLASS FileInformationClass OPTIONAL,
 313                       IN PFS_INFORMATION_CLASS FsInformationClass OPTIONAL)
 314 {
 315   UNIMPLEMENTED;
 316   return(STATUS_NOT_IMPLEMENTED);
 317 }
 318
 319
 320 NTSTATUS STDCALL
 321 IoSetInformation(IN PFILE_OBJECT FileObject,
 322                  IN FILE_INFORMATION_CLASS FileInformationClass,
 323                  IN ULONG Length,
 324                  OUT PVOID FileInformation)
 325 {
 326   UNIMPLEMENTED;
 327   return(STATUS_NOT_IMPLEMENTED);
 328 }
 329
 330
 331 BOOLEAN STDCALL
 332 IoFastQueryNetworkAttributes(IN POBJECT_ATTRIBUTES ObjectAttributes,
 333                              IN ACCESS_MASK DesiredAccess,
 334                              IN ULONG OpenOptions,
 335                              OUT PIO_STATUS_BLOCK IoStatus,
 336                              OUT PFILE_NETWORK_OPEN_INFORMATION Buffer)
 337 {
 338   UNIMPLEMENTED;
 339   return(FALSE);
 340 }
 341
 342 /* EOF */