Example #1
0
        public async Task <int> SendOutputReportAsync(Win32HidOutputReport report,
                                                      CancellationToken cancellationToken = default(CancellationToken))
        {
            if (report == null)
            {
                throw new ArgumentNullException(nameof(report));
            }

            var outputBuffer = report.GetOutputBuffer();

            log.Trace("Sending output report:\r\n\r\n " + outputBuffer.ToHexString());
            log.Trace(outputBuffer.ToLoggableAsHex("Sending output report:"));
            try
            {
                return(await Kernel32Dll.WriteFileAsync(Handle, outputBuffer, cancellationToken));
            }
            catch (Win32Exception exception)
            {
                log.Error("Sending output report failed", exception);
                throw ExceptionConversion.ConvertException(exception);
            }
            catch (Exception exception)
            {
                log.Error("Sending output report failed", exception);
                throw;
            }
        }
Example #2
0
File: Ini.cs Project: mo5h/omeo
 /// <summary>
 /// Write Data to the INI File
 /// </summary>
 /// <param name="Section"></param>
 /// Section name
 /// <param name="Key"></param>
 /// Key Name
 /// <param name="Value"></param>
 /// Value Name
 public void WriteString(string Section, string Key, string Value)
 {
     Value = Value.Replace("\r", "\\0x0d");
     Value = Value.Replace("\n", "\\0x0a");
     Value = Value.Replace("\"", "\\\"");
     Kernel32Dll.WritePrivateProfileStringW(Section, Key, Value, path);
 }
Example #3
0
        /// <summary>
        /// Finds the Trillian installation path and initializes the list of available profiles.
        /// </summary>
        public TrillianProfileManager()
        {
            string trillianDir = GetTrillianDirectory();

            if (trillianDir == null)
            {
                return;
            }

            string globalDir = GetGlobalDirectory(trillianDir);

            if (globalDir != null)
            {
                string iniPath      = Path.Combine(globalDir, "profiles.ini");
                var    profileCount = (int)Kernel32Dll.GetPrivateProfileIntW("Profiles", "num", 0, iniPath);
                for (int i = 0; i < profileCount; i++)
                {
                    string section = "Profile" + i.ToString("D3");

                    string sName = Kernel32Dll.Helpers.GetProfileString(iniPath, section, "Name", "");
                    if (sName.Length > 0)
                    {
                        var prefType = (int)Kernel32Dll.GetPrivateProfileIntW(section, "Preferences Type", 0, iniPath);
                        var profile  = new TrillianProfile(trillianDir, sName, prefType);
                        if (profile.IsValid())
                        {
                            _profiles.Add(profile);
                        }
                    }
                }
            }
        }
Example #4
0
        public NativeDll(string path)
        {
            _dllHandle = Kernel32Dll.LoadLibrary(path);

            if (_dllHandle == IntPtr.Zero)
            {
                throw new InteropException("LoadLibrary failed to load native.dll");
            }

            IntPtr procAddress = IntPtr.Zero;

            if ((procAddress = Kernel32Dll.GetProcAddress(_dllHandle, "SetupSubclass")) == IntPtr.Zero)
            {
                throw new InteropException("SetupSubclass function is not present in native.dll");
            }
            _setupSubclassFunc = (BoolActionOnIntPtr)Marshal.GetDelegateForFunctionPointer(procAddress, typeof(BoolActionOnIntPtr));

            if ((procAddress = Kernel32Dll.GetProcAddress(_dllHandle, "TearDownSubclass")) == IntPtr.Zero)
            {
                throw new InteropException("TearDownSubclass function is not present in native.dll");
            }
            _tearDownFunc = (BoolAction)Marshal.GetDelegateForFunctionPointer(procAddress, typeof(BoolAction));

            if ((procAddress = Kernel32Dll.GetProcAddress(_dllHandle, "IsSubclassed")) == IntPtr.Zero)
            {
                throw new InteropException("TearDownSubclass function is not present in native.dll");
            }
            _isSubclassedFunc = (BoolAction)Marshal.GetDelegateForFunctionPointer(procAddress, typeof(BoolAction));
        }
Example #5
0
        private int GetIdleTicks()
        {
            WindowsAPI.GetLastInputInfo(ref _LASTINPUTINFO);
            int idleTicks = (int)(Kernel32Dll.GetTickCount() - _LASTINPUTINFO.dwTime);

            return(idleTicks);
        }
Example #6
0
 protected virtual void Dispose(bool isDiposing)
 {
     if (_dllHandle != IntPtr.Zero)
     {
         Kernel32Dll.FreeLibrary(_dllHandle);
         _dllHandle = IntPtr.Zero;
     }
 }
Example #7
0
        /// <summary>
        /// A kick for the MILCORE to query for the display settings again, this time with our improved data.
        /// </summary>
        private static void Execute_InvalidateMil()
        {
            // Send an update to all the top-level windows on our thread
            Win32Declarations.EnumWindows(delegate(IntPtr hWnd, IntPtr lParam)
            {
                int dwDummy;
                if (Win32Declarations.GetWindowThreadProcessId(hWnd, out dwDummy) == Kernel32Dll.GetCurrentThreadId())
                {
                    User32Dll.Helpers.SendMessageW(hWnd, WindowsMessages.WM_SETTINGCHANGE, (IntPtr)Win32Declarations.SPI_SETFONTSMOOTHING, IntPtr.Zero);
                    User32Dll.Helpers.SendMessageW(hWnd, WindowsMessages.WM_SETTINGCHANGE, (IntPtr)Win32Declarations.SPI_SETFONTSMOOTHINGTYPE, IntPtr.Zero);
                }

                return(true);                // Go on
            }, 0);
        }
Example #8
0
        static unsafe void Test(Win32HidDevice device)
        {
            var init = new InitializationPacket();

            init.CommandIdentifier = (byte)U2FHidCommand.Init;
            init.ChannelIdentifier = U2FHID_BROADCAST_CID;
            init.PayloadLength     = 8;
            var caps = device.Information.Capabilities;

            var buffer = new byte[caps.InputReportByteLength];

            fixed(byte *pBuffer = buffer)
            {
                Marshal.StructureToPtr(init, new IntPtr(pBuffer + 1), false);

                buffer[0]  = 0x00;
                buffer[8]  = 0xCA;
                buffer[9]  = 0xFE;
                buffer[10] = 0xBA;
                buffer[11] = 0xBE;
                buffer[12] = 0xDE;
                buffer[13] = 0xAD;
                buffer[14] = 0xBA;
                buffer[15] = 0xBE;

                WriteBuffer(buffer);

                var task   = Kernel32Dll.WriteFileAsync(device.Handle, new IntPtr(pBuffer), buffer.Length);
                var writen = task.Result;

                Console.WriteLine("Writen {0} bytes", writen);
            }

            var bufferOut = new byte[caps.OutputReportByteLength];

            fixed(byte *pBuffer = bufferOut)
            {
                var intPtr = new IntPtr(pBuffer);
                var task   = Kernel32Dll.ReadFileAsync(device.Handle, intPtr, bufferOut.Length);
                var read   = task.Result;

                Console.WriteLine("Read {0} bytes", read);
            }

            WriteBuffer(bufferOut);

            Wink(device, bufferOut[16], bufferOut[17], bufferOut[18], bufferOut[19]);
        }
Example #9
0
        public async Task <HidInputReport> GetInputReportAsync(
            CancellationToken cancellationToken = default(CancellationToken))
        {
            try
            {
                var bytes = await Kernel32Dll.ReadFileAsync <byte>(Handle,
                                                                   Information.Capabilities.InputReportByteLength, cancellationToken);

                log.Trace(bytes.ToLoggableAsHex("Received input report:"));
                return(new HidInputReport(bytes));
            }
            catch (Win32Exception exception)
            {
                log.Error("Receiving input report failed", exception);
                throw ExceptionConversion.ConvertException(exception);
            }
            catch (Exception exception)
            {
                log.Error("Receiving input report failed", exception);
                throw;
            }
        }
Example #10
0
        static unsafe void Wink(Win32HidDevice device, byte b1, byte b2, byte b3, byte b4)
        {
            var msg = new FidoU2FHidMessage(
                (uint)(unchecked (b1 << 24 | b2 << 16 | b3 << 8 | b4)),
                U2FHidCommand.Wink);

            device.WriteFidoU2FHidMessageAsync(msg, CancellationToken.None).Wait();

            var caps = device.Information.Capabilities;

            var bufferOut = new byte[caps.OutputReportByteLength];

            fixed(byte *pBuffer = bufferOut)
            {
                var intPtr = new IntPtr(pBuffer);
                var task   = Kernel32Dll.ReadFileAsync(device.Handle, intPtr, bufferOut.Length);
                var read   = task.Result;

                Console.WriteLine("Read {0} bytes", read);
            }

            WriteBuffer(bufferOut);
        }
Example #11
0
 public int CloseHandle(IntPtr handle)
 {
     return(Kernel32Dll.CloseHandle(handle));
 }
Example #12
0
 public bool FreeMemory(int address, int memorySize)
 {
     return(Kernel32Dll.VirtualFreeEx(_processHandle, (IntPtr)address, memorySize, FreeType.Release));
 }
Example #13
0
 public void WaitForSingleObject(IntPtr threadHandle)
 {
     Kernel32Dll.WaitForSingleObject(threadHandle, Infinite);
 }
Example #14
0
 public IntPtr CreateRemoteThread(int address)
 {
     return(Kernel32Dll.CreateRemoteThread(_processHandle, (IntPtr)0, 0, (IntPtr)address, (IntPtr)0, 0, (IntPtr)0));
 }
Example #15
0
 public int AllocateMemory(int memorySize)
 {
     return((int)Kernel32Dll.VirtualAllocEx(_processHandle, (IntPtr)0, (uint)memorySize, 0x1000, 0x40));
 }
Example #16
0
        private bool ReadProcessMemory(IntPtr lpBaseAddress, [In, Out] byte[] lpBuffer, UInt32 nSize)
        {
            uint lpNumberOfBytesRead = 0;

            return(Kernel32Dll.ReadProcessMemory(_processHandle, lpBaseAddress, lpBuffer, nSize, ref lpNumberOfBytesRead));
        }
Example #17
0
        private bool WriteProcessMemory(IntPtr lpBaseAddress, byte[] lpBuffer, UInt32 nSize)
        {
            uint lpNumberOfBytesWritten = 0;

            return(Kernel32Dll.WriteProcessMemory(_processHandle, lpBaseAddress, lpBuffer, nSize, ref lpNumberOfBytesWritten));
        }
 public static bool IsCoreApiDllAlreadyLoaded()
 {
     return(Kernel32Dll.GetModuleHandleW(CoreApiDll.LibraryName) != IntPtr.Zero);
 }