Beispiel #1
0
        private static IntPtr OpenDeviceIO(string devicePath, DeviceMode deviceMode, uint deviceAccess, ShareMode shareMode)
        {
            var security = new NativeMethods.SecurityAttributes();
            var flags    = 0;

            if (deviceMode == DeviceMode.Overlapped)
            {
                flags = NativeMethods.FileFlagOverlapped;
            }

            security.lpSecurityDescriptor = IntPtr.Zero;
            security.bInheritHandle       = true;
            security.nLength = Marshal.SizeOf(security);

            return(NativeMethods.CreateFile(devicePath, deviceAccess, (int)shareMode, ref security, NativeMethods.OpenExisting, flags, 0));
        }
Beispiel #2
0
        protected HidDeviceData ReadData(int timeout)
        {
            var buffer = new byte[] { };
            var status = HidDeviceData.ReadStatus.NoDataRead;

            if (_deviceCapabilities.InputReportByteLength > 0)
            {
                uint bytesRead = 0;

                buffer = CreateInputBuffer();

                if (_deviceReadMode == DeviceMode.Overlapped)
                {
                    var security       = new NativeMethods.SecurityAttributes();
                    var overlapped     = new NativeOverlapped();
                    var overlapTimeout = timeout <= 0 ? NativeMethods.WaitInfinite : timeout;

                    security.lpSecurityDescriptor = IntPtr.Zero;
                    security.bInheritHandle       = true;
                    security.nLength = Marshal.SizeOf(security);

                    overlapped.OffsetLow   = 0;
                    overlapped.OffsetHigh  = 0;
                    overlapped.EventHandle = NativeMethods.CreateEvent(ref security, Convert.ToInt32(true), Convert.ToInt32(true), string.Empty);

                    try
                    {
                        var resultReadFile = NativeMethods.ReadFile(Handle, buffer, (uint)buffer.Length, out bytesRead, ref overlapped);

                        if (!resultReadFile && Marshal.GetLastWin32Error() == NativeMethods.ErrorIOPending)
                        {
                            var resultWaitForSingleObject = NativeMethods.WaitForSingleObject(overlapped.EventHandle, overlapTimeout);

                            switch (resultWaitForSingleObject)
                            {
                            case NativeMethods.WaitObject0:
                            {
                                var resultGetOverlappedResult = NativeMethods.GetOverlappedResult(Handle, ref overlapped, out bytesRead, true);
                                NativeMethods.ResetEvent(overlapped.EventHandle);
                                status = HidDeviceData.ReadStatus.Success;
                                break;
                            }

                            case NativeMethods.WaitTimeout:
                                status = HidDeviceData.ReadStatus.WaitTimedOut;
                                buffer = new byte[] {};
                                break;

                            case NativeMethods.WaitFailed:
                                status = HidDeviceData.ReadStatus.WaitFail;
                                buffer = new byte[] {};
                                break;

                            default:
                                status = HidDeviceData.ReadStatus.NoDataRead;
                                buffer = new byte[] {};
                                break;
                            }
                        }
                        else
                        {
                            NativeMethods.ResetEvent(overlapped.EventHandle);
                        }
                    }
                    catch { status = HidDeviceData.ReadStatus.ReadError; }
                    finally { CloseDeviceIO(overlapped.EventHandle); }

                    /* ORIG!!
                     * overlapped.EventHandle = NativeMethods.CreateEvent(ref security, Convert.ToInt32(false), Convert.ToInt32(true), string.Empty);
                     * try
                     * {
                     *  NativeMethods.ReadFile(Handle, buffer, (uint)buffer.Length, out bytesRead, ref overlapped);
                     *
                     *  var result = NativeMethods.WaitForSingleObject(overlapped.EventHandle, overlapTimeout);
                     *
                     *  switch (result)
                     *  {
                     *      case NativeMethods.WAIT_OBJECT_0:
                     *      {
                     *          status = HidDeviceData.ReadStatus.Success;
                     *          break;
                     *      }
                     *      case NativeMethods.WAIT_TIMEOUT:
                     *          status = HidDeviceData.ReadStatus.WaitTimedOut;
                     *          buffer = new byte[] { };
                     *          break;
                     *      case NativeMethods.WAIT_FAILED:
                     *          status = HidDeviceData.ReadStatus.WaitFail;
                     *          buffer = new byte[] { };
                     *          break;
                     *      default:
                     *          status = HidDeviceData.ReadStatus.NoDataRead;
                     *          buffer = new byte[] { };
                     *          break;
                     *  }
                     * }
                     * catch { status = HidDeviceData.ReadStatus.ReadError; }
                     * finally { CloseDeviceIO(overlapped.EventHandle); }*/
                }
                else
                {
                    try
                    {
                        var overlapped = new NativeOverlapped();

                        NativeMethods.ReadFile(Handle, buffer, (uint)buffer.Length, out bytesRead, ref overlapped);
                        status = HidDeviceData.ReadStatus.Success;
                    }
                    catch { status = HidDeviceData.ReadStatus.ReadError; }
                }
            }
            return(new HidDeviceData(buffer, status));
        }
Beispiel #3
0
        private bool WriteData(byte[] data, int timeout)
        {
            if (_deviceCapabilities.OutputReportByteLength <= 0)
            {
                return(false);
            }

            var  buffer       = CreateOutputBuffer();
            uint bytesWritten = 0;

            Array.Copy(data, 0, buffer, 0, Math.Min(data.Length, _deviceCapabilities.OutputReportByteLength));

            if (_deviceWriteMode == DeviceMode.Overlapped)
            {
                var security   = new NativeMethods.SecurityAttributes();
                var overlapped = new NativeOverlapped();

                var overlapTimeout = timeout <= 0 ? NativeMethods.WaitInfinite : timeout;

                security.lpSecurityDescriptor = IntPtr.Zero;
                security.bInheritHandle       = true;
                security.nLength = Marshal.SizeOf(security);

                overlapped.OffsetLow   = 0;
                overlapped.OffsetHigh  = 0;
                overlapped.EventHandle = NativeMethods.CreateEvent(ref security, Convert.ToInt32(true), Convert.ToInt32(true), "");

                try
                {
                    var writeFileResult = NativeMethods.WriteFile(Handle, buffer, (uint)buffer.Length, out bytesWritten, ref overlapped);

                    if (!writeFileResult && Marshal.GetLastWin32Error() == NativeMethods.ErrorIOPending)
                    {
                        var waitForSingleObjectResult = NativeMethods.WaitForSingleObject(overlapped.EventHandle, overlapTimeout);

                        switch (waitForSingleObjectResult)
                        {
                        case NativeMethods.WaitObject0:
                            return(true);

                        case NativeMethods.WaitTimeout:
                            return(false);

                        case NativeMethods.WaitFailed:
                            return(false);

                        default:
                            return(false);
                        }
                    }
                    NativeMethods.ResetEvent(overlapped.EventHandle);
                    return(false);
                }
                catch
                {
                    NativeMethods.ResetEvent(overlapped.EventHandle);
                    return(false);
                }


                /*
                 * ORIG!!!
                 * overlapped.EventHandle = NativeMethods.CreateEvent(ref security, Convert.ToInt32(false), Convert.ToInt32(true), "");
                 *
                 * try
                 * {
                 *  NativeMethods.WriteFile(Handle, buffer, (uint)buffer.Length, out bytesWritten, ref overlapped);
                 * }
                 * catch { return false; }
                 *
                 * var result = NativeMethods.WaitForSingleObject(overlapped.EventHandle, overlapTimeout);
                 *
                 * switch (result)
                 * {
                 *  case NativeMethods.WAIT_OBJECT_0:
                 *      return true;
                 *  case NativeMethods.WAIT_TIMEOUT:
                 *      return false;
                 *  case NativeMethods.WAIT_FAILED:
                 *      return false;
                 *  default:
                 *      return false;
                 * }
                 */
            }
            else
            {
                try
                {
                    var overlapped = new NativeOverlapped();
                    return(NativeMethods.WriteFile(Handle, buffer, (uint)buffer.Length, out bytesWritten, ref overlapped));
                }
                catch
                {
                    return(false);
                }
            }
        }