internal bool InitializeJob() { // Create a job object and add the process to it. We do this to ensure that we can kill the process and // all its children in one shot. Simply killing the process does not kill its children. NativeMethods.SECURITY_ATTRIBUTES jobSecAttributes = new NativeMethods.SECURITY_ATTRIBUTES(); jobSecAttributes.bInheritHandle = true; jobSecAttributes.lpSecurityDescriptor = IntPtr.Zero; jobSecAttributes.nLength = Marshal.SizeOf(typeof(NativeMethods.SECURITY_ATTRIBUTES)); IntPtr pointer = NativeMethods.CreateJobObject(ref jobSecAttributes, this.jobName); int createJobObjectWin32Error = Marshal.GetLastWin32Error(); this.SetHandle(pointer); if (this.IsInvalid) { var error = string.Format("In InitializeJob.JobHandle: Failed to SetInformation for job {0} because {1}", this.jobName, createJobObjectWin32Error); Debug.WriteLine(error); } else { // LimitFlags include JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE // to terminate all processes associated with the job when the last job handle is closed NativeMethods.JOBOBJECT_BASIC_LIMIT_INFORMATION basicInfo = new NativeMethods.JOBOBJECT_BASIC_LIMIT_INFORMATION(); NativeMethods.JOBOBJECT_EXTENDED_LIMIT_INFORMATION extendedInfo = new NativeMethods.JOBOBJECT_EXTENDED_LIMIT_INFORMATION { BasicLimitInformation = basicInfo }; extendedInfo.BasicLimitInformation.LimitFlags = NativeMethods.JOB_OBJECT_LIMIT.KILL_ON_JOB_CLOSE; int length = Marshal.SizeOf(typeof(NativeMethods.JOBOBJECT_EXTENDED_LIMIT_INFORMATION)); IntPtr extendedInfoPtr = Marshal.AllocHGlobal(length); Marshal.StructureToPtr(extendedInfo, extendedInfoPtr, false); bool result = NativeMethods.SetInformationJobObject(this, NativeMethods.JOBOBJECTINFOCLASS.JobObjectExtendedLimitInformation, ref extendedInfo, length); int setInformationJobObjectWin32Error = Marshal.GetLastWin32Error(); if (!result) { //this.logger.LogError("InitializeJob", "JobHandle : Failed to SetInformation for job '{0}' because '{1}'", this.jobName, setInformationJobObjectWin32Error); } else { return true; } } return false; }
private void CreatePipe(out SafeFileHandle parentHandle, out SafeFileHandle childHandle, bool parentInputs) { NativeMethods.SECURITY_ATTRIBUTES sECURITY_ATTRIBUTES = new NativeMethods.SECURITY_ATTRIBUTES(); sECURITY_ATTRIBUTES.bInheritHandle = true; SafeFileHandle safeFileHandle = null; try { if (parentInputs) { Process2.CreatePipeWithSecurityAttributes(out childHandle, out safeFileHandle, sECURITY_ATTRIBUTES, 0); } else { Process2.CreatePipeWithSecurityAttributes(out safeFileHandle, out childHandle, sECURITY_ATTRIBUTES, 0); } if (!NativeMethods.DuplicateHandle(new HandleRef(this, NativeMethods.GetCurrentProcess()), safeFileHandle, new HandleRef(this, NativeMethods.GetCurrentProcess()), out parentHandle, 0, false, 2)) { throw new Win32Exception(); } } finally { if (safeFileHandle != null && !safeFileHandle.IsInvalid) { safeFileHandle.Close(); } } }
/// <summary> /// Creates pipe with full access rights for everyone. /// </summary> /// <exception cref="System.InvalidOperationException">Pipe is already open.</exception> /// <exception cref="System.IO.IOException">Cannot create named pipe.</exception> public void CreateWithFullAccess() { if (this.SafeHandle != null) { throw new InvalidOperationException("Pipe is already open."); } var sec = new RawSecurityDescriptor(ControlFlags.DiscretionaryAclPresent, null, null, null, null); var sa = new NativeMethods.SECURITY_ATTRIBUTES(); sa.nLength = Marshal.SizeOf(typeof(NativeMethods.SECURITY_ATTRIBUTES)); sa.bInheritHandle = true; byte[] secBinary = new byte[sec.BinaryLength]; sec.GetBinaryForm(secBinary, 0); sa.lpSecurityDescriptor = Marshal.AllocHGlobal(secBinary.Length); Marshal.Copy(secBinary, 0, sa.lpSecurityDescriptor, secBinary.Length); this.SafeHandle = NativeMethods.CreateNamedPipe(this.FullPipeName, NativeMethods.PIPE_ACCESS_DUPLEX, NativeMethods.PIPE_TYPE_BYTE | NativeMethods.PIPE_READMODE_BYTE | NativeMethods.PIPE_WAIT, NativeMethods.PIPE_UNLIMITED_INSTANCES, 4096, 4096, NativeMethods.NMPWAIT_USE_DEFAULT_WAIT, ref sa); if (this.SafeHandle.IsInvalid) { throw new IOException("Cannot create named pipe.", new Win32Exception()); } }
internal void OpenFile(string fileName) { NativeMethods.SECURITY_ATTRIBUTES sa = new NativeMethods.SECURITY_ATTRIBUTES(); try { unsafe { // Disable PREsharp warning about not calling Marshal.GetLastWin32Error, // because we already check the handle for invalid value and // we are not particularly interested in specific Win32 error. #pragma warning disable 6523 long size; using (SafeFileHandle fileHandle = UnsafeNativeMethods.CreateFile( fileName, NativeMethods.GENERIC_READ, NativeMethods.FILE_SHARE_READ, null, NativeMethods.OPEN_EXISTING, 0, IntPtr.Zero )) { if (fileHandle.IsInvalid) { Util.ThrowWin32Exception(Marshal.GetLastWin32Error(), fileName); } UnsafeNativeMethods.LARGE_INTEGER fileSize = new UnsafeNativeMethods.LARGE_INTEGER(); if (!UnsafeNativeMethods.GetFileSizeEx(fileHandle, ref fileSize)) { throw new IOException(SR.Get(SRID.IOExceptionWithFileName, fileName)); } size = (long)fileSize.QuadPart; if (size == 0) { throw new FileFormatException(new Uri(fileName)); } _mappingHandle = UnsafeNativeMethods.CreateFileMapping( fileHandle, sa, UnsafeNativeMethods.PAGE_READONLY, 0, 0, null); } if (_mappingHandle.IsInvalid) { throw new IOException(SR.Get(SRID.IOExceptionWithFileName, fileName)); } _viewHandle = UnsafeNativeMethods.MapViewOfFileEx(_mappingHandle, UnsafeNativeMethods.FILE_MAP_READ, 0, 0, IntPtr.Zero, IntPtr.Zero); if (_viewHandle.IsInvalid) { throw new IOException(SR.Get(SRID.IOExceptionWithFileName, fileName)); } #pragma warning restore 6523 // Initialize() method demands UnmanagedCode permission, and OpenFile() is already marked as critical. new SecurityPermission(SecurityPermissionFlag.UnmanagedCode).Assert(); //Blessed Assert try { Initialize((byte *)_viewHandle.Memory, size, size, FileAccess.Read); } finally { SecurityPermission.RevertAssert(); } } } finally { sa.Release(); sa = null; } }