public long Skip(long bytes) { uint lowSought, highSought; if (!NativeMethods.BackupSeek(mFileHandle, NativeMethods.GetLowOrderDword(bytes), NativeMethods.GetHighOrderDword(bytes), out lowSought, out highSought, ref mContext)) { int errorCode = Marshal.GetLastWin32Error(); // Error Code 25 indicates a seek error, we just skip that here. if (errorCode != 0 && errorCode != 25) { Console.WriteLine("Error code = {0}", errorCode); NativeError.ThrowException(errorCode); } } return(((long)lowSought & 0xFFFFFFFF) | ((long)highSought << 32)); }
public virtual void Lock(long position, long length) { if (position < 0) { throw new ArgumentOutOfRangeException("position", position, "Position must not be negative."); } if (length < 0) { throw new ArgumentOutOfRangeException("length", length, "Length must not be negative."); } if (!NativeMethods.LockFile(mFileHandle, NativeMethods.GetLowOrderDword(position), NativeMethods.GetHighOrderDword(position), NativeMethods.GetLowOrderDword(length), NativeMethods.GetHighOrderDword(length))) { NativeError.ThrowException(); } }
public int Read(byte[] buffer, int offset, int count, bool processSecurity) { if (!CanRead) { throw new NotSupportedException("Stream does not support reading"); } if (buffer == null) { throw new ArgumentNullException("buffer"); } if (offset + count > buffer.Length) { throw new ArgumentException("The sum of offset and count is larger than the size of the buffer."); } if (offset < 0) { throw new ArgumentOutOfRangeException("offset", Resources.OffsetMustNotBeNegative); } if (count < 0) { throw new ArgumentOutOfRangeException("count", Resources.CountMustNotBeNegative); } using (SafeGlobalMemoryBufferHandle hBuf = new SafeGlobalMemoryBufferHandle(count)) { uint numberOfBytesRead; if (!NativeMethods.BackupRead(mFileHandle, hBuf, (uint)hBuf.Capacity, out numberOfBytesRead, false, processSecurity, ref mContext)) { NativeError.ThrowException(); } hBuf.CopyTo(buffer, offset, count); return((int)numberOfBytesRead); } }
private static NativeMethods.RemoteNameInfo GetMappedInfoInternal(string path) { if (path == null) { throw new ArgumentNullException("path", "The specified path cannot be NULL."); } if (IsLongPath(path)) { throw new ArgumentException("Long paths are not supported but this method."); } if (path.Length > NativeMethods.MAX_PATH) { throw new System.IO.PathTooLongException(); } int bufferSize = 0; SafeGlobalMemoryBufferHandle safeBuffer = new SafeGlobalMemoryBufferHandle(bufferSize); uint retVal; // first call is to get correct buffer size to store results. if ((retVal = NativeMethods.WNetGetUniversalName(path, NativeMethods.REMOTE_NAME_INFO_LEVEL, safeBuffer, ref bufferSize)) != Win32Errors.ERROR_MORE_DATA) { NativeError.ThrowException(retVal); } safeBuffer = new SafeGlobalMemoryBufferHandle(bufferSize); if ((retVal = NativeMethods.WNetGetUniversalName(path, NativeMethods.REMOTE_NAME_INFO_LEVEL, safeBuffer, ref bufferSize)) != Win32Errors.NO_ERROR) { NativeError.ThrowException(retVal); } return((NativeMethods.RemoteNameInfo)Marshal.PtrToStructure(safeBuffer.DangerousGetHandle(), typeof(NativeMethods.RemoteNameInfo))); }
public FileSecurity GetAccessControl() { IntPtr pSidOwner, pSidGroup, pDacl, pSacl; SafeLocalMemoryBufferHandle pSecurityDescriptor; uint errorCode = SecurityNativeMethods.GetSecurityInfo(mFileHandle, SecurityNativeMethods.SE_OBJECT_TYPE.SE_FILE_OBJECT, SecInfo.DACL_SECURITY_INFORMATION | SecInfo.GROUP_SECURITY_INFORMATION | SecInfo.OWNER_SECURITY_INFORMATION | SecInfo.LABEL_SECURITY_INFORMATION | SecInfo.SACL_SECURITY_INFORMATION, out pSidOwner, out pSidGroup, out pDacl, out pSacl, out pSecurityDescriptor); try { if (errorCode != 0) { NativeError.ThrowException(errorCode); } if (!SecurityNativeMethods.IsValidSecurityDescriptor(pSecurityDescriptor)) { throw new System.IO.IOException(Resources.InvalidSecurityDescriptorReturnedFromSystem); } uint length = SecurityNativeMethods.GetSecurityDescriptorLength(pSecurityDescriptor); byte[] managedBuffer = new byte[length]; pSecurityDescriptor.CopyTo(managedBuffer, 0, (int)length); FileSecurity fs = new FileSecurity(); fs.SetSecurityDescriptorBinaryForm(managedBuffer); return(fs); } finally { pSecurityDescriptor.Dispose(); } }
public static LinkTargetInfo GetLinkTargetInfo(SafeHandle device) { UInt32 bytesReturned; int lastError = 0; const int maxCapacity = 0x3FF0; SafeGlobalMemoryBufferHandle buffer = new SafeGlobalMemoryBufferHandle(512); try { do { if (!NativeMethods.DeviceIoControl(device, IoControlCode.FsctlGetReparsePoint, new SafeGlobalMemoryBufferHandle(), 0, buffer, (uint)buffer.Capacity, out bytesReturned, IntPtr.Zero)) { lastError = Marshal.GetLastWin32Error(); if (lastError == Win32Errors.ERROR_INSUFFICIENT_BUFFER && buffer.Capacity < maxCapacity) { buffer.Dispose(); buffer = null; buffer = new SafeGlobalMemoryBufferHandle(maxCapacity); continue; } NativeError.ThrowException(lastError); } else { break; } }while (true); IntPtr bufPtr = buffer.DangerousGetHandle(); ReparseDataBufferHeader header = (ReparseDataBufferHeader)Marshal.PtrToStructure(bufPtr, typeof(ReparseDataBufferHeader)); if (header.ReparseTag == ReparsePointTag.MountPoint) { MountPointReparseBuffer mpBuf = (MountPointReparseBuffer)Marshal.PtrToStructure(AddPtr(bufPtr, Marshal.OffsetOf(typeof(ReparseDataBufferHeader), "data")), typeof(MountPointReparseBuffer)); IntPtr dataPos = AddPtr(Marshal.OffsetOf(typeof(ReparseDataBufferHeader), "data"), Marshal.OffsetOf(typeof(MountPointReparseBuffer), "data")); byte[] dataBuffer = new byte[bytesReturned - dataPos.ToInt64()]; Marshal.Copy(AddPtr(bufPtr, dataPos), dataBuffer, 0, dataBuffer.Length); return(new LinkTargetInfo( Encoding.Unicode.GetString(dataBuffer, mpBuf.SubstituteNameOffset, mpBuf.SubstituteNameLength), Encoding.Unicode.GetString(dataBuffer, mpBuf.PrintNameOffset, mpBuf.PrintNameLength) )); } else if (header.ReparseTag == ReparsePointTag.SymLink) { SymbolicLinkReparseBuffer mpBuf = (SymbolicLinkReparseBuffer)Marshal.PtrToStructure(AddPtr(bufPtr, Marshal.OffsetOf(typeof(ReparseDataBufferHeader), "data")), typeof(SymbolicLinkReparseBuffer)); IntPtr dataPos = AddPtr(Marshal.OffsetOf(typeof(ReparseDataBufferHeader), "data"), Marshal.OffsetOf(typeof(SymbolicLinkReparseBuffer), "data")); byte[] dataBuffer = new byte[bytesReturned - dataPos.ToInt64()]; Marshal.Copy(AddPtr(bufPtr, dataPos), dataBuffer, 0, dataBuffer.Length); return(new SymbolicLinkTargetInfo( Encoding.Unicode.GetString(dataBuffer, mpBuf.SubstituteNameOffset, mpBuf.SubstituteNameLength), Encoding.Unicode.GetString(dataBuffer, mpBuf.PrintNameOffset, mpBuf.PrintNameLength), (SymbolicLinkType)mpBuf.Flags )); } else { throw new UnrecognizedReparsePointException(); } } finally { if (buffer != null) { buffer.Dispose(); } } }
internal static void SetSecurityInfo(SafeHandle handle, NativeMethods.SE_OBJECT_TYPE objectType, NativeObjectSecurity fileSecurity) { byte[] managedDescriptor = fileSecurity.GetSecurityDescriptorBinaryForm(); using (SafeGlobalMemoryBufferHandle hDescriptor = new SafeGlobalMemoryBufferHandle(managedDescriptor.Length)) { hDescriptor.CopyFrom(managedDescriptor, 0, managedDescriptor.Length); NativeMethods.SECURITY_DESCRIPTOR_CONTROL control; uint revision; if (!NativeMethods.GetSecurityDescriptorControl(hDescriptor, out control, out revision)) { NativeError.ThrowException(); } IntPtr pDacl; bool daclDefaulted, daclPresent; if (!NativeMethods.GetSecurityDescriptorDacl(hDescriptor, out daclPresent, out pDacl, out daclDefaulted)) { NativeError.ThrowException(); } IntPtr pSacl; bool saclDefaulted, saclPresent; if (!NativeMethods.GetSecurityDescriptorSacl(hDescriptor, out saclPresent, out pSacl, out saclDefaulted)) { NativeError.ThrowException(); } IntPtr pOwner; bool ownerDefaulted; if (!NativeMethods.GetSecurityDescriptorOwner(hDescriptor, out pOwner, out ownerDefaulted)) { NativeError.ThrowException(); } IntPtr pGroup; bool GroupDefaulted; if (!NativeMethods.GetSecurityDescriptorGroup(hDescriptor, out pGroup, out GroupDefaulted)) { NativeError.ThrowException(); } PrivilegeEnabler privilegeEnabler = null; NativeMethods.SECURITY_INFORMATION info = 0; if (daclPresent) { info |= NativeMethods.SECURITY_INFORMATION.DACL_SECURITY_INFORMATION; if ((control & NativeMethods.SECURITY_DESCRIPTOR_CONTROL.SE_DACL_PROTECTED) != 0) { info |= NativeMethods.SECURITY_INFORMATION.PROTECTED_DACL_SECURITY_INFORMATION; } else { info |= NativeMethods.SECURITY_INFORMATION.UNPROTECTED_DACL_SECURITY_INFORMATION; } } if (saclPresent) { info |= NativeMethods.SECURITY_INFORMATION.SACL_SECURITY_INFORMATION; if ((control & NativeMethods.SECURITY_DESCRIPTOR_CONTROL.SE_SACL_PROTECTED) != 0) { info |= NativeMethods.SECURITY_INFORMATION.PROTECTED_SACL_SECURITY_INFORMATION; } else { info |= NativeMethods.SECURITY_INFORMATION.UNPROTECTED_SACL_SECURITY_INFORMATION; } privilegeEnabler = new PrivilegeEnabler(Privilege.Security); } if (pOwner != IntPtr.Zero) { info |= NativeMethods.SECURITY_INFORMATION.OWNER_SECURITY_INFORMATION; } if (pGroup != IntPtr.Zero) { info |= NativeMethods.SECURITY_INFORMATION.GROUP_SECURITY_INFORMATION; } try { uint errorCode = NativeMethods.SetSecurityInfo(handle, objectType, info, pOwner, pGroup, pDacl, pSacl); if (errorCode != 0) { NativeError.ThrowException((int)errorCode); } } finally { if (privilegeEnabler != null) { privilegeEnabler.Dispose(); } } } }
public bool MoveNext() { mInfo = new FileSystemEntryInfo(); if (mHandle == null) { if (mTransaction == null) { mHandle = NativeMethods.FindFirstFileExW(mPath, NativeMethods.FINDEX_INFO_LEVELS.FindExInfoStandard, mInfo, mFindexSearchOptions, IntPtr.Zero, NativeMethods.FINDEX_FLAGS.FIND_FIRST_EX_NONE); } else { mHandle = NativeMethods.FindFirstFileTransactedW(mPath, NativeMethods.FINDEX_INFO_LEVELS.FindExInfoStandard, mInfo, mFindexSearchOptions, IntPtr.Zero, NativeMethods.FINDEX_FLAGS.FIND_FIRST_EX_NONE, mTransaction.SafeHandle); } if (mHandle.IsInvalid) { uint error = (uint)Marshal.GetLastWin32Error(); if (error == Win32Errors.ERROR_FILE_NOT_FOUND) { return(false); } else { NativeError.ThrowException(error, mPath, mPath); } } return(Filter()); } else if (mHandle.IsInvalid) { return(false); } else { if (!NativeMethods.FindNextFileW(mHandle, mInfo)) { uint error = (uint)Marshal.GetLastWin32Error(); if (error == Win32Errors.ERROR_NO_MORE_FILES) { mHandle.Close(); return(false); } else { NativeError.ThrowException(error); } } else { return(Filter()); } } // Actually unreachable code, but seems to be neccessary. return(false); }