Upload files to "src"

src/lib.rs

@@ -0,0 +1,79 @@
+#![crate_type = "cdylib"]
+
+use windows::{ Win32::Foundation::*, Win32::System::SystemServices::*, };
+use windows::core::GUID;
+use windows::Win32::Devices::DeviceAndDriverInstallation::{HDEVINFO, SP_DEVICE_INTERFACE_DATA};
+use windows::Win32::Devices::Usb::WINUSB_INTERFACE_HANDLE;
+use crate::windows_usb::{WinUsbDevice, WRITE_DIRECTION};
+
+mod windows_usb;
+
+
+
+
+
+#[unsafe(no_mangle)]
+
+pub extern "C" fn initialize_usb() -> HANDLE{
+
+    let sr = GUID {
+        data1: 0x72F7D87D,
+        data2: 0x287C,
+        data3: 0x4E07,
+        data4: [0x98, 0x58, 0x7D, 0x07, 0x90, 0x1C, 0xC6, 0x38],
+    };
+
+
+
+    let mut class_guid = GUID {
+        data1: 0x88bae032,
+        data2: 0x5a81,
+        data3: 0x49f0,
+        data4: [0xbc, 0x3d, 0xa4, 0xff, 0x13, 0x82, 0x16, 0xd6],
+    };
+
+
+    let mut device = WinUsbDevice::new(
+        &mut class_guid as *mut GUID,
+        sr,
+        HDEVINFO::default(),
+        SP_DEVICE_INTERFACE_DATA::default(),
+        String::from(""),
+        HANDLE::default(),
+        WINUSB_INTERFACE_HANDLE::default(),
+    );
+
+    device.get_device_info();
+    device.enumerate_devices();
+    
+    device.setup_device_details(0);
+    
+    device.get_device_handle().expect("Failed to get handle");
+    device.initialize();
+
+    device.device_handle
+}
+
+#[unsafe(no_mangle)]
+pub extern "C" fn write_usb(device: &mut WinUsbDevice, data: *const u8, len: usize) {
+
+    let slice = unsafe {
+        assert!(!data.is_null());
+        std::slice::from_raw_parts(data, len)
+    };
+
+    device.write_data(&slice);
+
+
+
+    // device.get_device_information();
+
+    //
+    // device.get_device_interface_settings();
+    // device.get_pipe_endpoint(WRITE_DIRECTION);
+    // device.reset_endpoint();
+
+
+
+
+}

src/main.rs

@@ -0,0 +1,86 @@
+use windows::core::GUID;
+use windows::Win32::Devices::DeviceAndDriverInstallation::{HDEVINFO, SP_DEVICE_INTERFACE_DATA};
+use windows::Win32::Devices::Usb::WINUSB_INTERFACE_HANDLE;
+use windows::Win32::Foundation::HANDLE;
+use crate::windows_usb::{WinUsbDevice, READ_DIRECTION, WRITE_DIRECTION};
+use std::thread;
+use std::time::Duration;
+
+mod windows_usb;
+
+fn main() {
+    let mut sr = GUID {
+        data1: 0x72F7D87D,
+        data2: 0x287C,
+        data3: 0x4E07,
+        data4: [0x98, 0x58, 0x7D, 0x07, 0x90, 0x1C, 0xC6, 0x38],
+    };
+
+
+
+    let mut class_guid = GUID {
+        data1: 0x88bae032,
+        data2: 0x5a81,
+        data3: 0x49f0,
+        data4: [0xbc, 0x3d, 0xa4, 0xff, 0x13, 0x82, 0x16, 0xd6],
+    };
+
+
+    // let sr = GUID {
+    //     data1: 0xf18a0e88,
+    //     data2: 0xc30c,
+    //     data3: 0x11d0,
+    //     data4: [0x88, 0x15, 0x00, 0xa0, 0xc9, 0x06, 0xbe, 0xd8],
+    // };
+
+
+
+
+    let mut device = WinUsbDevice::new(
+        class_guid,
+        sr,
+        HDEVINFO::default(),
+        SP_DEVICE_INTERFACE_DATA::default(),
+        String::from(""),
+        HANDLE::default(),
+        WINUSB_INTERFACE_HANDLE::default(),
+    );
+    //
+    // pub fn init_usb(device) {
+    //     device.get_device_info();
+    // }
+
+
+    device.get_guid();
+
+    //
+    device.get_device_info();
+    device.enumerate_devices();
+    unsafe {
+        device.setup_device_details(0);
+    }
+    device.get_device_handle().expect("Failed to get handle");
+
+    // device.get_device_information();
+    device.initialize().expect("Failed To Initialize WinUSB Handle");
+
+    device.query_interface_settings();
+    device.get_pipe_endpoint(WRITE_DIRECTION);
+    device.reset_endpoint();
+
+    let data:[u8;22] = [0, 0, 0, 1, 73, 50, 0, 14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+
+    device.write_data(data.as_ref());
+
+    //
+    //
+    //
+    // unsafe { device.read_data(); }
+
+    // device.get_pipe_number(WRITE_DIRECTION);
+    // device.get_endpoint_status();
+
+    //
+
+
+}

src/sru.rs

@@ -0,0 +1 @@
+enum Commands {}

src/windows_usb.rs

@@ -0,0 +1,690 @@
+use std::ascii::escape_default;
+use std::ffi::{c_void, CStr};
+use std::io::ErrorKind::Deadlock;
+use std::ptr::{addr_of_mut, null, null_mut, slice_from_raw_parts};
+use std::str::{from_utf8, FromStr};
+use std::{ptr, slice, thread, time};
+use hex::FromHexError;
+use windows::Win32::Foundation::{FALSE, GENERIC_ACCESS_RIGHTS, GENERIC_ALL, GENERIC_READ, GENERIC_WRITE, INVALID_HANDLE_VALUE};
+use windows::Win32::Security::{
+    PSECURITY_DESCRIPTOR, SECURITY_ATTRIBUTES, SECURITY_DESCRIPTOR, SECURITY_NULL_SID_AUTHORITY,
+};
+
+use windows::Win32::Storage::FileSystem::{
+    CreateFileW, FILE_FLAG_OVERLAPPED, FILE_SHARE_MODE, FILE_SHARE_READ, FILE_SHARE_WRITE,
+    OPEN_EXISTING,
+};
+use windows::Win32::{
+    Devices::DeviceAndDriverInstallation::{
+        DIGCF_ALLCLASSES, DIGCF_INTERFACEDEVICE, DIGCF_PRESENT, SP_DEVICE_INTERFACE_DATA,
+        SP_DEVINFO_DATA, SetupDiEnumDeviceInfo, SetupDiEnumDeviceInterfaces, SetupDiGetClassDevsA,
+        SetupDiGetClassDevsW,
+    },
+    Devices::Usb::{
+        IOCTL_GENERICUSBFN_GET_PIPE_STATE, WINUSB_INTERFACE_HANDLE, WinUsb_GetAssociatedInterface,
+        WinUsb_Initialize, WinUsb_QueryDeviceInformation, WinUsb_QueryInterfaceSettings,
+        WinUsb_QueryPipe,
+    },
+    Foundation::{GetLastError, HANDLE, HINSTANCE, HWND, LPARAM, LRESULT, WPARAM},
+    Storage::FileSystem::CreateFileA,
+    System::IO::DeviceIoControl,
+    System::Registry::RegOpenKeyExW,
+    UI::WindowsAndMessaging::{
+        CS_HREDRAW, CS_VREDRAW, CW_USEDEFAULT, CreateWindowExA, DefWindowProcW, DestroyWindow,
+        DispatchMessageA, GetMessageA, HCURSOR, HICON, MSG, PostQuitMessage, RegisterClassW,
+        WINDOW_EX_STYLE, WNDCLASSW, WS_OVERLAPPEDWINDOW,
+    },
+};
+use windows::core::{GUID, HSTRING, PCSTR, PCWSTR, PWSTR, w};
+
+use windows::Win32::Devices::DeviceAndDriverInstallation::{
+    DIGCF_DEVICEINTERFACE, HDEVINFO, SP_DEVICE_INTERFACE_DETAIL_DATA_W,
+    SetupDiDestroyDeviceInfoList, SetupDiGetDeviceInterfaceDetailW,
+};
+use windows::Win32::Devices::Usb::{USB_INTERFACE_DESCRIPTOR, WINUSB_PIPE_INFORMATION, WinUsb_ReadPipe, WinUsb_ResetPipe, WinUsb_WritePipe, WinUsb_GetOverlappedResult, WinUsb_GetPowerPolicy};
+use windows::Win32::System::IO::OVERLAPPED;
+use windows::Win32::System::Registry::{
+    HKEY, HKEY_LOCAL_MACHINE, KEY_ALL_ACCESS, KEY_ENUMERATE_SUB_KEYS, KEY_QUERY_VALUE, KEY_READ,
+    REG_DWORD, REG_VALUE_TYPE, RRF_RT_ANY, RegCloseKey, RegEnumKeyExW, RegGetValueW,
+    RegQueryInfoKeyW, RegQueryValueExW,
+};
+
+const SYNC: [u8; 8] = [0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01];
+const ACKS: [u8; 8] = [0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03];
+pub const WRITE_DIRECTION: u8 = 0x00;
+pub const READ_DIRECTION: u8 = 0x01;
+const IOCTL_USBCL_GET_ENDPOINT_NUMBER: u32 =
+    (((0x00000022) << 16) | ((0) << 14) | ((0x4000 + 0x0a) << 2) | (0));
+
+enum IoControlCode {
+    EndpointStatus = 2293788,
+}
+
+pub struct WinUsbDevice {
+    class_guid: GUID,
+    sru_guid: GUID,
+    h_dev_info: HDEVINFO,
+    interface: SP_DEVICE_INTERFACE_DATA,
+    device_path: String,
+    pub device_handle: HANDLE,
+    winusb_handle: WINUSB_INTERFACE_HANDLE,
+}
+
+impl WinUsbDevice {
+    pub fn new(
+        class_guid: GUID,
+        sru_guid: GUID,
+        h_dev_info: HDEVINFO,
+        interface: SP_DEVICE_INTERFACE_DATA,
+        device_path: String,
+        device_handle: HANDLE,
+        winusb_handle: WINUSB_INTERFACE_HANDLE,
+    ) -> Self {
+        Self {
+            class_guid,
+            sru_guid,
+            h_dev_info,
+            interface,
+            device_path,
+            device_handle,
+            winusb_handle,
+        }
+    }
+
+    pub fn get_device_info(&mut self) {
+        let en: PCWSTR = PCWSTR::null();
+        let hw: HWND = HWND::default();
+        let class_guid: *const GUID = &self.sru_guid;
+        let sru_device_info: windows_core::Result<HDEVINFO>;
+
+        unsafe {
+            sru_device_info = SetupDiGetClassDevsW(
+                Option::from(class_guid),
+                en,
+                Option::from(hw),
+                DIGCF_PRESENT | DIGCF_DEVICEINTERFACE,
+            )
+        };
+
+        if sru_device_info.is_err() {
+            println!("Error getting SRU device path");
+            let er = unsafe { GetLastError() };
+            println!("{:#?}", er);
+
+        } else {
+            println!("device path: {:?}", sru_device_info);
+            self.h_dev_info = sru_device_info.unwrap();
+        }
+    }
+
+    pub fn enumerate_devices(&mut self) {
+        let dev_info_data: *const SP_DEVINFO_DATA = 0 as *const SP_DEVINFO_DATA;
+        self.interface.cbSize = size_of::<SP_DEVINFO_DATA>() as u32;
+        let device_interface: windows_core::Result<()>;
+
+        device_interface = unsafe {
+            SetupDiEnumDeviceInterfaces(
+                self.h_dev_info,
+                Option::from(dev_info_data),
+                &self.sru_guid,
+                0,
+                &mut self.interface,
+            )
+        };
+
+        if device_interface.is_err() {
+            println!("Error enumerating device interfaces");
+            let er = unsafe { GetLastError() };
+            println!("{:#?}", er);
+        }
+
+        else{
+            println!("device interface: {:?}", device_interface);
+        }
+    }
+
+    pub fn setup_device_details(&mut self, size: u32) {
+        let mut ulsize = size;
+        let mut buffer = vec![0 as u32; ulsize as usize];
+
+        let b: Option<*mut SP_DEVICE_INTERFACE_DETAIL_DATA_W> =
+            Some(buffer.as_mut_ptr() as *mut SP_DEVICE_INTERFACE_DETAIL_DATA_W);
+
+
+        self.interface.cbSize = size_of::<SP_DEVICE_INTERFACE_DATA>() as u32;
+        self.interface.InterfaceClassGuid = self.sru_guid;
+
+        let mut buf = Option::Some(b);
+        if ulsize == 0{
+            buf = None;
+        }
+        else{
+
+            buf = Option::from(b);
+        }
+
+        // Returns error initially. This is expected, Just used to get size
+        let set: Result<_, _> = unsafe {
+            SetupDiGetDeviceInterfaceDetailW(
+                self.h_dev_info,
+                &mut self.interface,
+                buf.unwrap(),
+                ulsize,
+                Some(&mut ulsize),
+                None,
+            )
+        };
+
+        if set.is_err() {
+
+            let er = unsafe { GetLastError() };
+
+            if er.0 == 122{
+                self.setup_device_details(ulsize);
+            }
+            else{println!("{:#?}", er);}
+
+        }
+        else { println!("device interface details: {:?}", set); }
+
+
+
+
+        unsafe {
+            *b.unwrap() = SP_DEVICE_INTERFACE_DETAIL_DATA_W {
+                cbSize: size_of::<SP_DEVICE_INTERFACE_DETAIL_DATA_W>() as u32,
+                DevicePath: Default::default(),
+            };
+        }
+
+        // let set: Result<_, _> = unsafe {
+        //     SetupDiGetDeviceInterfaceDetailW(
+        //         self.h_dev_info,
+        //         &mut self.interface,
+        //         b,
+        //         ulsize,
+        //         Some(&mut ulsize),
+        //         None,
+        //     )
+        // };
+
+        unsafe {
+            let b = b.unwrap();
+            let device_path_ptr = unsafe { ptr::addr_of!((*b).DevicePath) as *const u16 };
+
+            let test = unsafe { slice::from_raw_parts(device_path_ptr, ulsize as usize) };
+
+            self.device_path = String::from_utf16((test))
+                .expect("REASON")
+                .trim_matches(char::from(0))
+                .parse()
+                .unwrap();
+
+            println!("{:#?}", self.device_path);
+        }
+    }
+
+    pub fn get_device_handle(&mut self) -> Result<u32, u32> {
+
+        let file_name = PCWSTR(HSTRING::from(self.device_path.clone()).as_ptr());
+        let desired_access = FILE_FLAG_OVERLAPPED;
+        let share_mode: FILE_SHARE_MODE = Default::default();
+        let security_attributes = None;
+        let creation_disposition = GENERIC_READ | GENERIC_WRITE;
+
+        unsafe {
+            let handle = CreateFileW(
+                PCWSTR((file_name).as_ptr()),
+                creation_disposition.0,
+                share_mode,
+                security_attributes,
+                OPEN_EXISTING,
+                desired_access,
+                None,
+            );
+
+            if GetLastError() == windows::Win32::Foundation::WIN32_ERROR(0) {
+                self.device_handle = handle.unwrap();
+                println!("{:#?}", self.device_handle);
+                Ok(0)
+            } else {
+                println!("{:#?}", GetLastError());
+                Err(1)
+            }
+        }
+    }
+
+    pub(crate) fn get_pipe_number(&mut self, direction: u8) {
+        let mut e_buffer = [0; 0];
+        let mut endpoint = e_buffer.as_mut_ptr() as *const core::ffi::c_void;
+        let endpoint_numbers = 15;
+
+        let mut buffer: [u8; 30] = [0; 30];
+        let mut output_buffer = buffer.as_mut_ptr() as *mut core::ffi::c_void;
+        let mut bytes_returned: u32 = 0;
+        let overlapped: Option<*mut OVERLAPPED> = Default::default();
+
+        unsafe {
+            let result = DeviceIoControl(
+                self.device_handle,
+                IOCTL_USBCL_GET_ENDPOINT_NUMBER,
+                Option::from(endpoint),
+                0,
+                Option::from(output_buffer),
+                30,
+                Option::from(&mut bytes_returned as *mut u32),
+                overlapped,
+            );
+            println!("{:#?}", GetLastError());
+        }
+    }
+
+    pub(crate) fn get_endpoint_status(&mut self) {
+        let endpoint: Option<*const core::ffi::c_void> = Some(0x02 as *const core::ffi::c_void);
+        let endpoint_code = ((0x00000022) << 16) | ((0) << 14) | ((0x4000 + 0x07) << 2) | (0);
+        let status: Option<*mut core::ffi::c_void> = Default::default();
+        let ret: Option<*mut u32> = Default::default();
+        let overlapped: Option<*mut OVERLAPPED> = Default::default();
+        let mut buffer: [u8; 2] = Default::default();
+        let mut output_buffer = buffer.as_mut_ptr() as *mut core::ffi::c_void;
+        let mut bytes_returned: u32 = 0;
+
+        unsafe {
+            let result = DeviceIoControl(
+                self.device_handle,
+                endpoint_code,
+                endpoint,
+                0,
+                Option::from(output_buffer),
+                size_of::<i32>() as u32,
+                Option::from(&mut bytes_returned as *mut u32),
+                overlapped,
+            );
+
+            println!("{:#?}", GetLastError());
+        }
+    }
+
+    //
+    // pub(crate) fn get_associated_interface(&mut self){
+    //
+    //     let k: u8 = 0;
+    //     let m: *mut WINUSB_INTERFACE_HANDLE = Default::default();
+    //
+    //     unsafe {
+    //         let interface = WinUsb_GetAssociatedInterface(self.device_handle, k, m);
+    //     }
+    // }
+
+    pub(crate) fn get_guid(&mut self) {
+        const VID: &str = "04c5";
+        const PID: &str = "1623";
+
+        let h: HKEY = HKEY_LOCAL_MACHINE;
+        let subkey: PCWSTR = w!("SYSTEM\\CurrentControlSet\\Enum\\USB\\VID_04C5&PID_1623");
+
+        let mut val: HKEY = HKEY(std::ptr::null_mut());
+        let val_ptr = &mut val as *mut HKEY;
+
+        // Creates HKEY
+
+        unsafe {
+            let ret = RegOpenKeyExW(
+                h,
+                subkey,
+                Some(0),
+                KEY_READ | KEY_QUERY_VALUE | KEY_ENUMERATE_SUB_KEYS,
+                val_ptr,
+            );
+            println!("{:#?}", GetLastError());
+        }
+
+        let lpClass: PWSTR = Default::default();
+        let mut sub: u32 = 0;
+        let sub_ptr = &mut sub as *mut u32;
+
+        //Checks how many items under registry key
+
+        unsafe {
+            let ret = RegQueryInfoKeyW(
+                val,
+                Some(lpClass),
+                Some(null_mut()),
+                Some(null_mut()),
+                Some(sub_ptr),
+                Some(null_mut()),
+                Some(null_mut()),
+                Some(null_mut()),
+                Some(null_mut()),
+                Some(null_mut()),
+                Some(null_mut()),
+                Some(null_mut()),
+            );
+            println!("{:#?}", ret);
+        }
+
+        for i in 0..sub {
+            let mut name: [u16; 14] = [0; 14];
+            let pname = PWSTR(name.as_mut_ptr());
+            let mut sz: u32 = 14;
+            let sz_ptr = &mut sz as *mut u32;
+
+            // enumerate keys
+            unsafe {
+                let ret = RegEnumKeyExW(
+                    val,
+                    i,
+                    Some(pname),
+                    sz_ptr,
+                    Some(null_mut()),
+                    Some(PWSTR::default()),
+                    Some(null_mut()),
+                    Some(null_mut()),
+                );
+                println!("{:#?}", GetLastError());
+
+                // let subkey1: PCWSTR = PCWSTR(HSTRING::from("SYSTEM\\CurrentControlSet\\Enum\\USB\\VID_04C5&PID_1623\\5&2ec1d53&0&1").as_ptr());
+                let keyval: PCWSTR = PCWSTR(HSTRING::from("ConfigFlags").as_ptr());
+
+                let reg_key = "SYSTEM\\CurrentControlSet\\Enum\\USB\\VID_04C5&PID_1623\\"
+                    .to_owned()
+                    + String::from_utf16(name.as_ref())
+                        .unwrap()
+                        .trim_matches(char::from(0))
+                        .to_string()
+                        .as_str();
+                let r: PCWSTR = PCWSTR(HSTRING::from(reg_key).as_ptr());
+
+                let mut vsz: u32 = 13;
+                let vsz_ptr = &mut sz as *mut u32;
+
+                let mut buffer: [u8; 4] = [0; 4];
+                let mut output_buffer = buffer.as_mut_ptr() as *mut core::ffi::c_void;
+
+                let ret = RegGetValueW(
+                    HKEY_LOCAL_MACHINE,
+                    r,
+                    keyval,
+                    RRF_RT_ANY,
+                    Some(null_mut()),
+                    Option::from(output_buffer),
+                    Option::from(vsz_ptr),
+                );
+                println!("{:#?}", ret);
+
+                if buffer[0] == 0 {
+                    // Found Connected Device
+                    // Extract Device GUID & Class GUID
+
+                    let mut class_guid: [u16; 64] = [0; 64];
+                    let class_guid_buffer = class_guid.as_mut_ptr() as *mut c_void;
+
+                    let mut vsz: u32 = 128;
+                    let vsz_ptr = &mut vsz as *mut u32;
+
+                    let ret = RegGetValueW(
+                        HKEY_LOCAL_MACHINE,
+                        r,
+                        PCWSTR(HSTRING::from("ClassGUID").as_ptr()),
+                        RRF_RT_ANY,
+                        Some(null_mut()),
+                        Option::from(class_guid_buffer),
+                        Option::from(vsz_ptr),
+                    );
+                    println!("{:#?}", ret);
+
+                    println!("{:#?}", class_guid);
+
+
+
+                    let data1 = String::from_utf16(&class_guid[1..9]).unwrap();
+                    let data2 = String::from_utf16(&class_guid[10..14]).unwrap();
+                    let data3 = String::from_utf16(&class_guid[15..19]).unwrap();
+                    let data4 = String::from_utf16(&class_guid[20..37]).unwrap().replace('-', "");
+
+
+                    let y= u32::from_str_radix(&*data1, 16);
+                    // let g: u32 = y.parse().unwrap();
+
+
+                    self.class_guid.data1 = u32::from_str_radix(&*data1, 16).expect("REASON");
+                    self.class_guid.data2 = u16::from_str_radix(&*data2, 16).expect("REASON");
+                    self.class_guid.data3 = u16::from_str_radix(&*data3, 16).expect("REASON");
+
+                    let w = from_utf8(data4.as_ref()).unwrap();
+                    println!("{:#?}", w);
+
+                    self.class_guid.data4 = <[u8; 8]>::try_from(w.as_bytes()).unwrap();
+
+                    // self.class_guid.data4 = <[u8; 8]>::try_from(data4.into_bytes());
+
+
+                    // println!("{:#?}", &data1);
+                    println!("{:#?}", &data2);
+                    println!("{:#?}", &data3);
+                    // println!("{:#?}", &data4);
+
+                    // println!("temp1: {:?}", String::from_utf8(Vec::from(data4)));
+
+                    // println!("{:#?}", temp2.parse::<u32>().unwrap());
+                    // let y: &str = (&temp1[1..8]);
+                    // temp_class_guid.data1 = (&temp1[1..8]).parse().unwrap();
+                    // temp_class_guid.data2 = (&temp1[8..17]).parse().unwrap();
+
+
+                    // let mut temp3 = &temp1[19..24];
+                    // temp_class_guid.data2 = temp3.parse().unwrap();
+
+                    //
+                    // println!("{:X?}", &temp2);
+                    //temp_class_guid.data1 = from_utf8(&*class_guid);
+
+                    let mut device_guid: [u8; 64] = [0; 64];
+                    let device_guid_buffer = device_guid.as_mut_ptr() as *mut c_void;
+
+                    let mut vsz: u32 = 64;
+                    let vsz_ptr = &mut vsz as *mut u32;
+
+                    let device_guid_key_path = r.to_string().unwrap() + "\\Device Parameters";
+                    let r: PCWSTR = PCWSTR(HSTRING::from(device_guid_key_path).as_ptr());
+
+                    let ret = RegGetValueW(
+                        HKEY_LOCAL_MACHINE,
+                        r,
+                        PCWSTR(HSTRING::from("DeviceInterfaceGUIDs").as_ptr()),
+                        RRF_RT_ANY,
+                        Some(null_mut()),
+                        Option::from(device_guid_buffer),
+                        Option::from(vsz_ptr),
+                    );
+                    println!("{:#?}", ret);
+
+                    break;
+                }
+            }
+        }
+    }
+
+    pub fn initialize(&mut self) -> Result<u32, u32>{
+        let mut interface_handle: WINUSB_INTERFACE_HANDLE = Default::default();
+        let inter = &mut interface_handle as *mut WINUSB_INTERFACE_HANDLE;
+
+        unsafe {
+            let ret = WinUsb_Initialize(self.device_handle, inter);
+            if ret.is_err() {
+                println!("{:#?}", GetLastError());
+                panic!("{:#?}", GetLastError());
+            }
+            else {
+                Ok(0)
+            }
+
+        }
+    }
+
+    pub fn query_interface_settings(&mut self) {
+        let inter = self.initialize();
+
+        let mut descriptor: USB_INTERFACE_DESCRIPTOR = Default::default();
+        let desc = &mut descriptor as *mut USB_INTERFACE_DESCRIPTOR;
+
+        unsafe {
+            let ret = WinUsb_QueryInterfaceSettings(self.winusb_handle, 0, desc);
+            println!("{:#?}", GetLastError());
+        }
+    }
+
+    pub fn get_pipe_endpoint(&mut self, direction: u8) {
+        let mut pipe = &mut Default::default() as *mut WINUSB_PIPE_INFORMATION;
+
+        unsafe {
+            let ret = WinUsb_QueryPipe(self.winusb_handle, 0, direction, pipe);
+            println!("{:#?}", GetLastError());
+        }
+    }
+
+    pub(crate) fn query_device_information(&mut self) {
+        self.initialize();
+        let info_type: u32 = 0x01;
+        let buffer_length: *mut u32 = Default::default();
+
+        let mut buffer = vec![];
+        let output_buffer = buffer.as_mut_ptr() as *mut core::ffi::c_void;
+
+        unsafe {
+            let ret = WinUsb_QueryDeviceInformation(
+                self.winusb_handle,
+                info_type,
+                buffer_length,
+                output_buffer,
+            );
+
+            println!("{:#?}", GetLastError());
+        }
+    }
+
+    pub fn reset_endpoint(&mut self) {
+        unsafe {
+            let ret = WinUsb_ResetPipe(self.winusb_handle, 0x02);
+
+            println!("{:#?}", GetLastError());
+        }
+    }
+
+    pub fn write_data(&mut self, data: &[u8]) {
+        let mut d: [u8; 1120] = [
+            0, 0, 0, 1, 65, 53, 4, 88, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        ];
+        // let d = vec! [0, 0, 0, 1, 73, 50, 0, 14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+        // let d_buf:*mut [u8] = &mut d as *mut [u8];
+        let buffer_length: u32 = 22;
+        // let blen: *mut u32 = buffer_length;
+        // let mut buffer: [u8; buffer_length] = [data];
+        let mut l: u32 = data.len() as u32;
+        let pl: *mut u32 = &mut l;
+
+        let overlapped: Option<*const OVERLAPPED> = Some(null());
+
+        unsafe {
+            let ret = WinUsb_WritePipe(
+                self.winusb_handle,
+                0x02,
+                &data,
+                Option::from(pl),
+                overlapped,
+            );
+            println!("{:#?}", GetLastError());
+        }
+    }
+
+    pub(crate) unsafe fn read_data(&mut self) {
+        loop {
+            let mut buffer: [u8; 64] = [0; 64];
+            let buf: &mut [u8; 64] = &mut buffer;
+
+            let mut l: u32 = 64;
+            let pl: *mut u32 = &mut l;
+
+            // let overlapped: Option<*const OVERLAPPED> = Default::default();
+
+            unsafe {
+                let overlapped: Option<*const OVERLAPPED> = Default::default();
+                let ret = WinUsb_ReadPipe(
+                    self.winusb_handle,
+                    0x81,
+                    Some(buf),
+                    Option::from(pl),
+                    overlapped,
+                );
+
+                if GetLastError().0 != 0 {
+                    println!("{:#?}", GetLastError());
+                } else {
+                    println!("{:#?}", buffer);
+                }
+            }
+            let delay = time::Duration::from_secs(2);
+            thread::sleep(delay);
+        }
+    }
+
+    pub fn get_overlapped_result(&mut self){
+
+
+        let overlapped = OVERLAPPED { Internal: Default::default(), InternalHigh: Default::default(), Anonymous: Default::default(), hEvent: Default::default() };
+        let mut num_bytes_transferred: *mut u32 = Default::default();
+
+
+        unsafe {
+            let ret = WinUsb_GetOverlappedResult(self.winusb_handle, &overlapped, num_bytes_transferred, bool::from(FALSE));
+        }
+
+    }
+
+}
+
+//     pub fn get_power_policy(&mut self) {
+//
+//         unsafe {
+//             let ret = WinUsb_GetPowerPolicy(self.winusb_handle, );
+//         }
+//     }
+// }