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 NTSTATUS STDCALL
  83 IoCheckShareAccess(IN ACCESS_MASK DesiredAccess,
  84                    IN ULONG DesiredShareAccess,
  85                    IN PFILE_OBJECT FileObject,
  86                    IN PSHARE_ACCESS ShareAccess,
  87                    IN BOOLEAN Update)
  88 {
  89   BOOLEAN ReadAccess;
  90   BOOLEAN WriteAccess;
  91   BOOLEAN DeleteAccess;
  92   BOOLEAN SharedRead;
  93   BOOLEAN SharedWrite;
  94   BOOLEAN SharedDelete;
  95
  96   ReadAccess = (DesiredAccess & (FILE_READ_DATA | FILE_EXECUTE));
  97   WriteAccess = (DesiredAccess & (FILE_READ_DATA | FILE_APPEND_DATA));
  98   DeleteAccess = (DesiredAccess & DELETE);
  99
 100   FileObject->ReadAccess = ReadAccess;
 101   FileObject->WriteAccess = WriteAccess;
 102   FileObject->DeleteAccess = DeleteAccess;
 103
 104   if (!ReadAccess && !WriteAccess && !DeleteAccess)
 105     {
 106       return(STATUS_SUCCESS);
 107     }
 108
 109   SharedRead = (DesiredShareAccess & FILE_SHARE_READ);
 110   SharedWrite = (DesiredShareAccess & FILE_SHARE_WRITE);
 111   SharedDelete = (DesiredShareAccess & FILE_SHARE_DELETE);
 112
 113   FileObject->SharedRead = SharedRead;
 114   FileObject->SharedWrite = SharedWrite;
 115   FileObject->SharedDelete = SharedDelete;
 116
 117   if (ReadAccess)
 118     {
 119       if (ShareAccess->SharedRead < ShareAccess->OpenCount)
 120         return(STATUS_SHARING_VIOLATION);
 121     }
 122
 123   if (WriteAccess)
 124     {
 125       if (ShareAccess->SharedWrite < ShareAccess->OpenCount)
 126         return(STATUS_SHARING_VIOLATION);
 127     }
 128
 129   if (DeleteAccess)
 130     {
 131       if (ShareAccess->SharedDelete < ShareAccess->OpenCount)
 132         return(STATUS_SHARING_VIOLATION);
 133     }
 134
 135   if (ShareAccess->Readers != 0)
 136     {
 137       if (SharedRead == FALSE)
 138         return(STATUS_SHARING_VIOLATION);
 139     }
 140
 141   if (ShareAccess->Writers != 0)
 142     {
 143       if (SharedWrite == FALSE)
 144         return(STATUS_SHARING_VIOLATION);
 145     }
 146
 147   if (ShareAccess->Deleters != 0)
 148     {
 149       if (SharedDelete == FALSE)
 150         return(STATUS_SHARING_VIOLATION);
 151     }
 152
 153   if (Update == TRUE)
 154     {
 155       ShareAccess->OpenCount++;
 156
 157       if (ReadAccess == TRUE)
 158         ShareAccess->Readers++;
 159
 160       if (WriteAccess == TRUE)
 161         ShareAccess->Writers++;
 162
 163       if (DeleteAccess == TRUE)
 164         ShareAccess->Deleters++;
 165
 166       if (SharedRead == TRUE)
 167         ShareAccess->SharedRead++;
 168
 169       if (SharedWrite == TRUE)
 170         ShareAccess->SharedWrite++;
 171
 172       if (SharedDelete == TRUE)
 173         ShareAccess->SharedDelete++;
 174     }
 175
 176   return(STATUS_SUCCESS);
 177 }
 178
 179
 180 VOID STDCALL
 181 IoRemoveShareAccess(IN PFILE_OBJECT FileObject,
 182                     IN PSHARE_ACCESS ShareAccess)
 183 {
 184   if ((FileObject->ReadAccess == FALSE) &&
 185       (FileObject->WriteAccess == FALSE) &&
 186       (FileObject->DeleteAccess == FALSE))
 187     {
 188       return;
 189     }
 190
 191   ShareAccess->OpenCount--;
 192
 193   if (FileObject->ReadAccess == TRUE)
 194     {
 195       ShareAccess->Readers--;
 196     }
 197
 198   if (FileObject->WriteAccess == TRUE)
 199     {
 200       ShareAccess->Writers--;
 201     }
 202
 203   if (FileObject->DeleteAccess == TRUE)
 204     {
 205       ShareAccess->Deleters--;
 206     }
 207
 208   if (FileObject->SharedRead == TRUE)
 209     {
 210       ShareAccess->SharedRead--;
 211     }
 212
 213   if (FileObject->SharedWrite == TRUE)
 214     {
 215       ShareAccess->SharedWrite--;
 216     }
 217
 218   if (FileObject->SharedDelete == TRUE)
 219     {
 220       ShareAccess->SharedDelete--;
 221     }
 222 }
 223
 224
 225 VOID STDCALL
 226 IoSetShareAccess(IN ACCESS_MASK DesiredAccess,
 227                  IN ULONG DesiredShareAccess,
 228                  IN PFILE_OBJECT FileObject,
 229                  OUT PSHARE_ACCESS ShareAccess)
 230 {
 231   BOOLEAN ReadAccess;
 232   BOOLEAN WriteAccess;
 233   BOOLEAN DeleteAccess;
 234   BOOLEAN SharedRead;
 235   BOOLEAN SharedWrite;
 236   BOOLEAN SharedDelete;
 237
 238   ReadAccess = (DesiredAccess & (FILE_READ_DATA | FILE_EXECUTE));
 239   WriteAccess = (DesiredAccess & (FILE_READ_DATA | FILE_APPEND_DATA));
 240   DeleteAccess = (DesiredAccess & DELETE);
 241
 242   FileObject->ReadAccess = ReadAccess;
 243   FileObject->WriteAccess = WriteAccess;
 244   FileObject->DeleteAccess = DeleteAccess;
 245
 246   if (!ReadAccess && !WriteAccess && !DeleteAccess)
 247     {
 248       FileObject->SharedRead = FALSE;
 249       FileObject->SharedWrite = FALSE;
 250       FileObject->SharedDelete = FALSE;
 251
 252       ShareAccess->OpenCount = 0;
 253       ShareAccess->Readers = 0;
 254       ShareAccess->Writers = 0;
 255       ShareAccess->Deleters = 0;
 256
 257       ShareAccess->SharedRead = 0;
 258       ShareAccess->SharedWrite = 0;
 259       ShareAccess->SharedDelete = 0;
 260     }
 261   else
 262     {
 263       SharedRead = (DesiredShareAccess & FILE_SHARE_READ);
 264       SharedWrite = (DesiredShareAccess & FILE_SHARE_WRITE);
 265       SharedDelete = (DesiredShareAccess & FILE_SHARE_DELETE);
 266
 267       FileObject->SharedRead = SharedRead;
 268       FileObject->SharedWrite = SharedWrite;
 269       FileObject->SharedDelete = SharedDelete;
 270
 271       ShareAccess->OpenCount = 1;
 272       ShareAccess->Readers = (ReadAccess) ? 1 : 0;
 273       ShareAccess->Writers = (WriteAccess) ? 1 : 0;
 274       ShareAccess->Deleters = (DeleteAccess) ? 1 : 0;
 275
 276       ShareAccess->SharedRead = (SharedRead) ? 1 : 0;
 277       ShareAccess->SharedWrite = (SharedWrite) ? 1 : 0;
 278       ShareAccess->SharedDelete = (SharedDelete) ? 1 : 0;
 279     }
 280 }
 281
 282 #ifndef LIBCAPTIVE
 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 #endif /* LIBCAPTIVE */
 343
 344 /* EOF */