private void InitializeMessage(PortMessage existingMessage, MemoryRegion data, short dataLength)
        {
            if (dataLength > Win32.PortMessageMaxDataLength)
                throw new ArgumentOutOfRangeException("Data length is too large.");
            if (dataLength < 0)
                throw new ArgumentOutOfRangeException("Data length cannot be negative.");

            _message = new PortMessageStruct
            {
                DataLength = dataLength, 
                TotalLength = (short)(PortMessageStruct.SizeOf + dataLength), 
                DataInfoOffset = 0
            };

            if (existingMessage != null)
            {
                _message.ClientId = existingMessage.ClientId;
                _message.MessageId = existingMessage.MessageId;
            }

            _data = data;

            _referencedData = data;
            _referencedData.Reference();
        }
Beispiel #2
0
        public void Reset()
        {
            IRQ.Unset();
            memoryBuffer = new MemoryRegion[NumberOfPackets];
            for(var i = 0; i < memoryBuffer.Length; ++i)
            {
                memoryBuffer[i] = new MemoryRegion();
            }
           
            rxFifo.Clear();
            txFifo.Clear();
            sentFifo.Clear();

            currentBank = Bank.Bank0;
            transmitControl = 0x0000;
            receiveControl = 0x0000;
            configuration = 0xA0B1;
            generalPurposeRegister = 0x0000;
            control = 0x1210;
            packetNumber = 0x00;
            allocationResult = 0x0;
            pointer = 0x0000;
            interruptMask = 0x0;
            interruptStatus = TxEmptyInterrupt;
            earlyReceive = 0x001f;
            Update();
        }
Beispiel #3
0
 public SymbolNode(
     string name,
     int index, 
     int functionIndex,
     Type datatype,
     bool isArgument, 
     int runtimeIndex,
     MemoryRegion memregion = MemoryRegion.InvalidRegion, 
     int scope = -1,
     CompilerDefinitions.AccessModifier access = CompilerDefinitions.AccessModifier.Public,
     bool isStatic = false,
     int codeBlockId = Constants.kInvalidIndex)
 {
     this.name           = name;
     isTemp         = name.StartsWith("%");
     isSSATemp = name.StartsWith(Constants.kSSATempPrefix); 
     this.index          = index;
     this.functionIndex = functionIndex;
     this.absoluteFunctionIndex = functionIndex;
     this.datatype       = datatype;
     this.isArgument     = isArgument;
     this.memregion      = memregion;
     this.classScope     = scope;
     this.absoluteClassScope = scope;
     runtimeTableIndex = runtimeIndex;
     this.access = access;
     this.isStatic = isStatic;
     this.codeBlockId = codeBlockId;
 }
Beispiel #4
0
        internal PortMessage(MemoryRegion headerAndData)
        {
            _message = headerAndData.ReadStruct<PortMessageStruct>();
            _data = new MemoryRegion(headerAndData, _portMessageSize, _message.DataLength);

            _referencedData = headerAndData;
            _referencedData.Reference();
        }
Beispiel #5
0
 public SymbolNode()
 {
     name = string.Empty;
     memregion       = MemoryRegion.InvalidRegion;
     classScope      = Constants.kInvalidIndex;
     functionIndex   = Constants.kGlobalScope;
     absoluteClassScope = Constants.kGlobalScope;
     absoluteFunctionIndex = Constants.kGlobalScope;
     isStatic        = false;
     isTemp          = false;
 }
        internal SsObjectAttributes(MemoryRegion data)
        {
            KphSsObjectAttributes oaInfo = data.ReadStruct<KphSsObjectAttributes>();

            if (oaInfo.ObjectNameOffset != 0)
                this.ObjectName = new SsUnicodeString(new MemoryRegion(data, oaInfo.ObjectNameOffset));

            this.Original = oaInfo.ObjectAttributes;

            if (oaInfo.RootDirectoryOffset != 0)
                this.RootDirectory = new SsHandle(new MemoryRegion(data, oaInfo.RootDirectoryOffset));
        }
Beispiel #7
0
        public static void UnpackCredentials(
            MemoryRegion buffer,
            CredPackFlags flags,
            out string domainName,
            out string userName,
            out string password
            )
        {
            using (var domainNameBuffer = new MemoryAlloc(0x100))
            using (var userNameBuffer = new MemoryAlloc(0x100))
            using (var passwordBuffer = new MemoryAlloc(0x100))
            {
                int domainNameSize = domainNameBuffer.Size / 2 - 1;
                int userNameSize = userNameBuffer.Size / 2 - 1;
                int passwordSize = passwordBuffer.Size / 2 - 1;

                if (!Win32.CredUnPackAuthenticationBuffer(
                    flags,
                    buffer,
                    buffer.Size,
                    userNameBuffer,
                    ref userNameSize,
                    domainNameBuffer,
                    ref domainNameSize,
                    passwordBuffer,
                    ref passwordSize
                    ))
                {
                    domainNameBuffer.ResizeNew(domainNameSize * 2 + 2);
                    userNameBuffer.ResizeNew(userNameSize * 2 + 2);
                    passwordBuffer.ResizeNew(passwordSize * 2 + 2);

                    if (!Win32.CredUnPackAuthenticationBuffer(
                        flags,
                        buffer,
                        buffer.Size,
                        userNameBuffer,
                        ref userNameSize,
                        domainNameBuffer,
                        ref domainNameSize,
                        passwordBuffer,
                        ref passwordSize
                        ))
                        Win32.Throw();
                }

                domainName = domainNameBuffer.ReadUnicodeString(0);
                userName = userNameBuffer.ReadUnicodeString(0);
                password = passwordBuffer.ReadUnicodeString(0);
            }
        }
        internal SsUnicodeString(MemoryRegion data)
        {
            KphSsUnicodeString unicodeStringInfo = data.ReadStruct<KphSsUnicodeString>();

            this.Original = new UnicodeString()
            {
                Length = unicodeStringInfo.Length,
                MaximumLength = unicodeStringInfo.MaximumLength,
                Buffer = unicodeStringInfo.Pointer
            };
            this.String = data.ReadUnicodeString(
                KphSsUnicodeString.BufferOffset,
                unicodeStringInfo.Length / 2
                );
        }
Beispiel #9
0
        public SsBytes(MemoryRegion data)
        {
            KphSsBytes bytes;
            byte[] buffer;

            bytes = data.ReadStruct<KphSsBytes>();
            buffer = new byte[bytes.Length];
            System.Runtime.InteropServices.Marshal.Copy(
                data.Memory.Increment(KphSsBytes.BufferOffset),
                buffer,
                0,
                buffer.Length
                );

            this.Bytes = buffer;
        }
Beispiel #10
0
        internal SsHandle(MemoryRegion data)
        {
            KphSsHandle handleInfo = data.ReadStruct<KphSsHandle>(0, KphSsHandle.SizeOf, 0);

            if (handleInfo.TypeNameOffset != 0)
            {
                this.TypeName = SsLogger.ReadWString(new MemoryRegion(data, handleInfo.TypeNameOffset));
            }

            if (handleInfo.NameOffset != 0)
            {
                this.Name = SsLogger.ReadWString(new MemoryRegion(data, handleInfo.NameOffset));
            }

            this.ProcessId = handleInfo.ClientId.ProcessId;
            this.ThreadId = handleInfo.ClientId.ThreadId;
        }
 public SecurityDescriptor()
 {
     NtStatus status;
     _memory = new MemoryAlloc(Win32.SecurityDescriptorMinLength);
     if ((status = Win32.RtlCreateSecurityDescriptor(
         _memory,
         Win32.SecurityDescriptorRevision
         )) >= NtStatus.Error)
     {
         _memory.Dispose();
         _memory = null;
         this.DisableOwnership(false);
         Win32.ThrowLastError(status);
     }
     _memory.Reference();
     _memory.Dispose();
 }
Beispiel #12
0
        public Ace(IntPtr memory, bool copy)
            : base(copy)
        {
            if (copy)
            {
                Ace existingAce = new Ace(memory);

                _memory = new MemoryAlloc(existingAce.Size);
                _memory.WriteMemory(0, existingAce, 0, existingAce.Size);
            }
            else
            {
                _memory = new MemoryRegion(memory);
            }

            this.Read();
        }
Beispiel #13
0
        public void EnumLocks(DebugEnumLocksDelegate callback)
        {
            var debugInfo = this.GetDebugInformation();

            if (debugInfo.Locks == IntPtr.Zero)
                throw new InvalidOperationException("Lock information does not exist.");

            MemoryRegion locksInfo = new MemoryRegion(debugInfo.Locks);
            var locks = locksInfo.ReadStruct<RtlProcessLocks>();

            for (int i = 0; i < locks.NumberOfLocks; i++)
            {
                var lock_ = locksInfo.ReadStruct<RtlProcessLockInformation>(sizeof(int), i);

                if (!callback(new LockInformation(lock_)))
                    break;
            }
        }
Beispiel #14
0
        public void EnumHeaps(DebugEnumHeapsDelegate callback)
        {
            var debugInfo = this.GetDebugInformation();

            if (debugInfo.Heaps == IntPtr.Zero)
                throw new InvalidOperationException("Heap information does not exist.");

            MemoryRegion heapInfo = new MemoryRegion(debugInfo.Heaps);
            var heaps = heapInfo.ReadStruct<RtlProcessHeaps>();

            for (int i = 0; i < heaps.NumberOfHeaps; i++)
            {
                var heap = heapInfo.ReadStruct<RtlHeapInformation>(RtlProcessHeaps.HeapsOffset, i);

                if (!callback(new HeapInformation(heap)))
                    break;
            }
        }
Beispiel #15
0
 public SymbolNode(
     string name,
     int index, 
     int heapIndex, 
     int functionIndex,
     ProtoCore.Type datatype,
     ProtoCore.Type enforcedType,
     int size,
     int datasize, 
     bool isArgument, 
     int runtimeIndex,
     MemoryRegion memregion = MemoryRegion.kInvalidRegion, 
     bool isArray = false, 
     List<int> arraySizeList = null, 
     int scope = -1,
     ProtoCore.CompilerDefinitions.AccessModifier access = ProtoCore.CompilerDefinitions.AccessModifier.kPublic,
     bool isStatic = false,
     int codeBlockId = ProtoCore.DSASM.Constants.kInvalidIndex)
 {
     this.name           = name;
     isTemp         = name.StartsWith("%");
     this.index          = index;
     this.functionIndex = functionIndex;
     this.absoluteFunctionIndex = functionIndex;
     this.datatype       = datatype;
     this.staticType   = enforcedType;
     this.size           = size;
     this.datasize       = datasize;
     this.isArgument     = isArgument;
     this.arraySizeList  = arraySizeList;
     this.memregion      = memregion;
     this.classScope     = scope;
     this.absoluteClassScope = scope;
     runtimeTableIndex = runtimeIndex;
     this.access = access;
     this.isStatic = isStatic;
     this.codeBlockId = codeBlockId;
 }
Beispiel #16
0
 internal void SetHeader(MemoryRegion data)
 {
     _message = data.ReadStruct<PortMessageStruct>();
 }
Beispiel #17
0
        private void BufferWorkerThreadStart()
        {
            int cursor = 0;

            _bufferWorkerThreadHandle = ThreadHandle.OpenCurrent(ThreadAccess.All);

            _bufferWorkerThreadReadyEvent.Set();

            while (!_terminating)
            {
                NtStatus status;
                KphSsBlockHeader blockHeader;

                status = _readSemaphore.Wait(true);

                if (status == NtStatus.Alerted)
                    return;

                if (_buffer.Size - cursor < Marshal.SizeOf(typeof(KphSsBlockHeader)))
                    cursor = 0;

                blockHeader = _buffer.ReadStruct<KphSsBlockHeader>(cursor, 0);

                if (blockHeader.Type == KphSsBlockType.Reset)
                {
                    cursor = 0;
                    blockHeader = _buffer.ReadStruct<KphSsBlockHeader>(cursor, 0);
                }

                if (blockHeader.Type == KphSsBlockType.Event)
                {
                    var eventBlock = _buffer.ReadStruct<KphSsEventBlock>(cursor, 0);
                    int[] arguments;
                    IntPtr[] stackTrace;

                    arguments = new int[eventBlock.NumberOfArguments];
                    stackTrace = new IntPtr[eventBlock.TraceCount];

                    for (int i = 0; i < arguments.Length; i++)
                        arguments[i] = _buffer.ReadInt32(cursor + eventBlock.ArgumentsOffset, i);
                    for (int i = 0; i < stackTrace.Length; i++)
                        stackTrace[i] = _buffer.ReadIntPtr(cursor + eventBlock.TraceOffset, i);

                    SsEvent ssEvent = new SsEvent();

                    ssEvent.Time = DateTime.FromFileTime(eventBlock.Time);
                    ssEvent.ThreadId = eventBlock.ClientId.ThreadId;
                    ssEvent.ProcessId = eventBlock.ClientId.ProcessId;
                    ssEvent.Arguments = arguments;
                    ssEvent.StackTrace = stackTrace;

                    ssEvent.ArgumentsCopyFailed =
                        (eventBlock.Flags & KphSsEventFlags.CopyArgumentsFailed) == KphSsEventFlags.CopyArgumentsFailed;
                    ssEvent.ArgumentsProbeFailed =
                        (eventBlock.Flags & KphSsEventFlags.ProbeArgumentsFailed) == KphSsEventFlags.ProbeArgumentsFailed;
                    ssEvent.CallNumber = eventBlock.Number;

                    if ((eventBlock.Flags & KphSsEventFlags.UserMode) == KphSsEventFlags.UserMode)
                        ssEvent.Mode = KProcessorMode.UserMode;
                    else
                        ssEvent.Mode = KProcessorMode.KernelMode;

                    if (this.EventBlockReceived != null)
                        this.EventBlockReceived(ssEvent);
                }
                else if (blockHeader.Type == KphSsBlockType.Argument)
                {
                    var argBlock = _buffer.ReadStruct<KphSsArgumentBlock>(cursor, 0);
                    MemoryRegion dataRegion;
                    SsData ssArg = null;

                    dataRegion = new MemoryRegion(_buffer, cursor + KphSsArgumentBlock.DataOffset);

                    switch (argBlock.Type)
                    {
                        case KphSsArgumentType.Int8:
                            {
                                SsSimple simpleArg = new SsSimple();

                                simpleArg.Argument = argBlock.Data.Int8;
                                simpleArg.Type = typeof(Byte);
                                ssArg = simpleArg;
                            }
                            break;
                        case KphSsArgumentType.Int16:
                            {
                                SsSimple simpleArg = new SsSimple();

                                simpleArg.Argument = argBlock.Data.Int16;
                                simpleArg.Type = typeof(Int16);
                                ssArg = simpleArg;
                            }
                            break;
                        case KphSsArgumentType.Int32:
                            {
                                SsSimple simpleArg = new SsSimple();

                                simpleArg.Argument = argBlock.Data.Int32;
                                simpleArg.Type = typeof(Int32);
                                ssArg = simpleArg;
                            }
                            break;
                        case KphSsArgumentType.Int64:
                            {
                                SsSimple simpleArg = new SsSimple();

                                simpleArg.Argument = argBlock.Data.Int64;
                                simpleArg.Type = typeof(Int64);
                                ssArg = simpleArg;
                            }
                            break;
                        case KphSsArgumentType.Handle:
                            {
                                ssArg = new SsHandle(dataRegion);
                            }
                            break;
                        case KphSsArgumentType.UnicodeString:
                            {
                                ssArg = new SsUnicodeString(dataRegion);
                            }
                            break;
                        case KphSsArgumentType.ObjectAttributes:
                            {
                                ssArg = new SsObjectAttributes(dataRegion);
                            }
                            break;
                        case KphSsArgumentType.ClientId:
                            {
                                ssArg = new SsClientId(dataRegion);
                            }
                            break;
                    }

                    ssArg.Index = argBlock.Index;

                    if (ssArg != null)
                    {
                        if (this.ArgumentBlockReceived != null)
                            this.ArgumentBlockReceived(ssArg);
                    }
                }

                cursor += blockHeader.Size;

                _writeSemaphore.Release();
            }
        }
Beispiel #18
0
        internal static string ReadWString(MemoryRegion data)
        {
            KphSsWString wString = data.ReadStruct<KphSsWString>();

            return data.ReadUnicodeString(KphSsWString.BufferOffset, wString.Length / 2);
        }
        internal MemoryRegion[] GetMemoryRanges()
        {
            MemoryRegion[] regions = new MemoryRegion[ranges.Length];

            for (int i = 0; i < regions.Length; i++)
                regions[i] = new MemoryRegion { BaseAddress = ranges[i].MemoryStart, MemoryEnd = ranges[i].MemoryEnd };
            return regions;
        }
 /// <summary>
 /// Creates a security descriptor from memory.
 /// </summary>
 /// <param name="memory">The memory region to use. This object will be referenced.</param>
 public SecurityDescriptor(MemoryRegion memory)
 {
     _memory = memory;
     _memory.Reference();
     this.Read();
 }
Beispiel #21
0
 public SsClientId(MemoryRegion data)
 {
     this.Original = data.ReadStruct<ClientId>();
 }
 public object GetProfileData(MemoryRegion buffer)
 {
     return null;
 }
        public void ReadAuthData(MemoryRegion buffer)
        {
            Msv1_0_InteractiveLogon info = buffer.ReadStruct<Msv1_0_InteractiveLogon>();

            // Fix up relative addresses.
            if (info.LogonDomainName.Buffer.CompareTo(buffer.Size) < 0)
                info.LogonDomainName.Buffer = info.LogonDomainName.Buffer.Increment(buffer);
            if (info.UserName.Buffer.CompareTo(buffer.Size) < 0)
                info.UserName.Buffer = info.UserName.Buffer.Increment(buffer);
            if (info.Password.Buffer.CompareTo(buffer.Size) < 0)
                info.Password.Buffer = info.Password.Buffer.Increment(buffer);

            _domainName = info.LogonDomainName.Text;
            _userName = info.UserName.Text;
            _password = info.Password.Text;
        }
 public AsyncIoContext BeginTransceive(MemoryRegion inBuffer, MemoryRegion outBuffer)
 {
     return this.BeginFsControl(FsCtlTransceive, inBuffer, outBuffer);
 }
Beispiel #25
0
        private SymbolNode Allocate(
            int classIndex,  // In which class table this variable will be allocated to ?
            int classScope,  // Variable's class scope. For example, it is a variable in base class
            int funcIndex,   // In which function this variable is defined? 
            string ident, 
            ProtoCore.Type datatype, 
            bool isStatic = false,
            ProtoCore.CompilerDefinitions.AccessModifier access = ProtoCore.CompilerDefinitions.AccessModifier.Public,
            MemoryRegion region = MemoryRegion.MemStack,
            int line = -1,
            int col = -1,
            GraphNode graphNode = null
            )
        {
            bool allocateForBaseVar = classScope < classIndex;
            bool isProperty = classIndex != Constants.kInvalidIndex && funcIndex == Constants.kInvalidIndex;
            if (!allocateForBaseVar && !isProperty && core.ClassTable.IndexOf(ident) != ProtoCore.DSASM.Constants.kInvalidIndex)
                buildStatus.LogSemanticError(String.Format(Resources.ClassNameAsVariableError, ident), null, line, col, graphNode);

            ProtoCore.DSASM.SymbolNode symbolnode = new ProtoCore.DSASM.SymbolNode();
            symbolnode.name = ident;
            symbolnode.isTemp = ident.StartsWith("%");
            symbolnode.isSSATemp = CoreUtils.IsSSATemp(ident);
            symbolnode.functionIndex = funcIndex;
            symbolnode.absoluteFunctionIndex = funcIndex;
            symbolnode.datatype = datatype;
            symbolnode.staticType = TypeSystem.BuildPrimitiveTypeObject(PrimitiveType.Var, Constants.kArbitraryRank);
            symbolnode.isArgument = false;
            symbolnode.memregion = region;
            symbolnode.classScope = classScope;
            symbolnode.absoluteClassScope = classScope;
            symbolnode.runtimeTableIndex = codeBlock.symbolTable.RuntimeIndex;
            symbolnode.isStatic = isStatic;
            symbolnode.access = access;
            symbolnode.codeBlockId = codeBlock.codeBlockId;
            if (this.isEmittingImportNode)
                symbolnode.ExternLib = core.CurrentDSFileName;

            int symbolindex = ProtoCore.DSASM.Constants.kInvalidIndex;

            if (IsInLanguageBlockDefinedInFunction())
            {
                symbolnode.classScope = Constants.kGlobalScope;
                symbolnode.functionIndex = Constants.kGlobalScope;
            }

            if (ProtoCore.DSASM.Constants.kInvalidIndex != classIndex && !IsInLanguageBlockDefinedInFunction())
            {
                // NOTE: the following comment and code is OBSOLETE - member
                // variable is not supported now
                // 
                // Yu Ke: it is possible that class table contains same-named 
                // symbols if a class inherits some member variables from base 
                // class, so we need to check name + class index + function 
                // index.
                // 
                //if (core.classTable.list[classIndex].symbols.IndexOf(ident, classIndex, funcIndex) != (int)ProtoCore.DSASM.Constants.kInvalidIndex)
                //    return null;

                symbolindex = core.ClassTable.ClassNodes[classIndex].Symbols.IndexOf(ident);
                if (symbolindex != ProtoCore.DSASM.Constants.kInvalidIndex)
                {
                    ProtoCore.DSASM.SymbolNode node = core.ClassTable.ClassNodes[classIndex].Symbols.symbolList[symbolindex];
                    if (node.functionIndex == ProtoCore.DSASM.Constants.kGlobalScope &&
                        funcIndex == ProtoCore.DSASM.Constants.kGlobalScope)
                        return null;
                }

                symbolindex = core.ClassTable.ClassNodes[classIndex].Symbols.Append(symbolnode);
                if (symbolindex == ProtoCore.DSASM.Constants.kInvalidIndex)
                {
                    return null;
                }

                if (isStatic)
                {
                    Validity.Assert(funcIndex == ProtoCore.DSASM.Constants.kGlobalScope);
                    ProtoCore.DSASM.SymbolNode staticSymbolnode = new ProtoCore.DSASM.SymbolNode();
                    staticSymbolnode.name = ident;
                    staticSymbolnode.isTemp = ident.StartsWith("%");
                    staticSymbolnode.isSSATemp = CoreUtils.IsSSATemp(ident);
                    staticSymbolnode.functionIndex = funcIndex;
                    staticSymbolnode.datatype = datatype;
                    staticSymbolnode.staticType = TypeSystem.BuildPrimitiveTypeObject(PrimitiveType.Var, Constants.kArbitraryRank);
                    staticSymbolnode.isArgument = false;
                    staticSymbolnode.memregion = region;
                    staticSymbolnode.classScope = classScope;
                    staticSymbolnode.runtimeTableIndex = codeBlock.symbolTable.RuntimeIndex;
                    staticSymbolnode.isStatic = isStatic;
                    staticSymbolnode.access = access;
                    staticSymbolnode.codeBlockId = codeBlock.codeBlockId;
                    if (this.isEmittingImportNode)
                        staticSymbolnode.ExternLib = core.CurrentDSFileName;

                    // If inherits a static property from base class, that propery
                    // symbol should have been added to code block's symbol table,
                    // so we just update symbolTableIndex 
                    int staticSymbolindex = codeBlock.symbolTable.IndexOf(ident, classScope);
                    if (staticSymbolindex == ProtoCore.DSASM.Constants.kInvalidIndex)
                    {
                        AllocateVar(staticSymbolnode);
                        staticSymbolindex = codeBlock.symbolTable.Append(staticSymbolnode);
                        if (staticSymbolindex == ProtoCore.DSASM.Constants.kInvalidIndex)
                        {
                            return null;
                        }
                        staticSymbolnode.symbolTableIndex = staticSymbolindex;
                    }
                    symbolnode.symbolTableIndex = staticSymbolindex;
                }
                else
                {
                    AllocateVar(symbolnode);
                }
            }
            else
            {               
                AllocateVar(symbolnode);

                symbolindex = codeBlock.symbolTable.Append(symbolnode);
                if (symbolindex == ProtoCore.DSASM.Constants.kInvalidIndex)
                {
                    return null;
                }
                symbolnode.symbolTableIndex = symbolindex;
                
            }

            if (ProtoCore.DSASM.Constants.kInvalidIndex == symbolindex)
            {
                return null;
            }
            return symbolnode;
        }
Beispiel #26
0
 public PortMessage(MemoryRegion data, short dataLength)
     : this(null, data, dataLength)
 {
 }
Beispiel #27
0
 public PortMessage(PortMessage existingMessage, MemoryRegion data, short dataLength)
 {
     this.InitializeMessage(existingMessage, data, dataLength);
 }
Beispiel #28
0
        public static SecPkgInfo[] GetSSPackages()
        {
            int result;
            int count;
            IntPtr packages;

            result = Win32.EnumerateSecurityPackages(out count, out packages);

            if (result != 0)
                Win32.Throw(result);

            var alloc = new MemoryRegion(packages);

            try
            {
                SecPkgInfo[] array = new SecPkgInfo[count];

                for (int i = 0; i < count; i++)
                    array[i] = alloc.ReadStruct<SecPkgInfo>(i);

                return array;
            }
            finally
            {
                Win32.FreeContextBuffer(packages);
            }
        }
Beispiel #29
0
        public static string GetMessage(IntPtr dllHandle, int messageTableId, int messageLanguageId, int messageId)
        {
            NtStatus status;
            IntPtr messageEntry;
            string message;

            status = Win32.RtlFindMessage(
                dllHandle,
                messageTableId,
                messageLanguageId,
                messageId,
                out messageEntry
                );

            if (status.IsError())
                return null;

            var region = new MemoryRegion(messageEntry);
            var entry = region.ReadStruct<MessageResourceEntry>();

            // Read the message, depending on format.
            if ((entry.Flags & MessageResourceFlags.Unicode) == MessageResourceFlags.Unicode)
            {
                message = region.ReadUnicodeString(MessageResourceEntry.TextOffset);
            }
            else
            {
                message = region.ReadAnsiString(MessageResourceEntry.TextOffset);
            }

            return message;
        }
Beispiel #30
0
        public static AceType GetType(IntPtr ace)
        {
            MemoryRegion memory = new MemoryRegion(ace);

            return memory.ReadStruct<AceHeader>().AceType;
        }