@@ -3,17 +3,17 @@ use std::os::windows::prelude::*;
3
3
use std:: time:: Duration ;
4
4
use std:: { io, ptr} ;
5
5
6
- use winapi:: shared:: minwindef:: * ;
7
- use winapi:: um:: commapi:: * ;
8
- use winapi:: um:: fileapi:: * ;
9
- use winapi:: um:: handleapi:: * ;
10
- use winapi:: um:: processthreadsapi:: GetCurrentProcess ;
11
- use winapi:: um:: winbase:: * ;
12
- use winapi:: um:: winnt:: {
13
- DUPLICATE_SAME_ACCESS , FILE_ATTRIBUTE_NORMAL , GENERIC_READ , GENERIC_WRITE , HANDLE , MAXDWORD ,
6
+ use windows_sys:: Win32 :: Devices :: Communication :: * ;
7
+ use windows_sys:: Win32 :: Foundation :: {
8
+ CloseHandle , DuplicateHandle , DUPLICATE_SAME_ACCESS , GENERIC_READ , GENERIC_WRITE , HANDLE ,
9
+ INVALID_HANDLE_VALUE , TRUE ,
14
10
} ;
11
+ use windows_sys:: Win32 :: Storage :: FileSystem :: {
12
+ CreateFileW , FlushFileBuffers , ReadFile , WriteFile , FILE_ATTRIBUTE_NORMAL , OPEN_EXISTING ,
13
+ } ;
14
+ use windows_sys:: Win32 :: System :: Threading :: GetCurrentProcess ;
15
15
16
- use crate :: windows:: dcb;
16
+ use crate :: windows:: dcb:: { self , DCBBitField } ;
17
17
use crate :: {
18
18
ClearBuffer , DataBits , Error , ErrorKind , FlowControl , Parity , Result , SerialPort ,
19
19
SerialPortBuilder , StopBits ,
@@ -137,15 +137,15 @@ impl COMPort {
137
137
}
138
138
}
139
139
140
- fn escape_comm_function ( & mut self , function : DWORD ) -> Result < ( ) > {
140
+ fn escape_comm_function ( & mut self , function : u32 ) -> Result < ( ) > {
141
141
match unsafe { EscapeCommFunction ( self . handle , function) } {
142
142
0 => Err ( super :: error:: last_os_error ( ) ) ,
143
143
_ => Ok ( ( ) ) ,
144
144
}
145
145
}
146
146
147
- fn read_pin ( & mut self , pin : DWORD ) -> Result < bool > {
148
- let mut status: DWORD = 0 ;
147
+ fn read_pin ( & mut self , pin : u32 ) -> Result < bool > {
148
+ let mut status: u32 = 0 ;
149
149
150
150
match unsafe { GetCommModemStatus ( self . handle , & mut status) } {
151
151
0 => Err ( super :: error:: last_os_error ( ) ) ,
@@ -163,16 +163,16 @@ impl COMPort {
163
163
}
164
164
}
165
165
166
- fn timeout_constant ( duration : Duration ) -> DWORD {
166
+ fn timeout_constant ( duration : Duration ) -> u32 {
167
167
let milliseconds = duration. as_millis ( ) ;
168
- // In the way we are setting up COMMTIMEOUTS, a timeout_constant of MAXDWORD gets rejected.
169
- // Let's clamp the timeout constant for values of MAXDWORD and above. See remarks at
168
+ // In the way we are setting up COMMTIMEOUTS, a timeout_constant of u32::MAX gets rejected.
169
+ // Let's clamp the timeout constant for values of u32::MAX and above. See remarks at
170
170
// https://learn.microsoft.com/en-us/windows/win32/api/winbase/ns-winbase-commtimeouts.
171
171
//
172
172
// This effectively throws away accuracy for really long timeouts but at least preserves a
173
173
// long-ish timeout. But just casting to DWORD would result in presumably unexpected short
174
174
// and non-monotonic timeouts from cutting off the higher bits.
175
- u128:: min ( milliseconds, MAXDWORD as u128 - 1 ) as DWORD
175
+ u128:: min ( milliseconds, u32 :: MAX as u128 - 1 ) as u32
176
176
}
177
177
}
178
178
@@ -206,13 +206,13 @@ impl IntoRawHandle for COMPort {
206
206
207
207
impl io:: Read for COMPort {
208
208
fn read ( & mut self , buf : & mut [ u8 ] ) -> io:: Result < usize > {
209
- let mut len: DWORD = 0 ;
209
+ let mut len: u32 = 0 ;
210
210
211
211
match unsafe {
212
212
ReadFile (
213
213
self . handle ,
214
- buf. as_mut_ptr ( ) as LPVOID ,
215
- buf. len ( ) as DWORD ,
214
+ buf. as_mut_ptr ( ) ,
215
+ buf. len ( ) as u32 ,
216
216
& mut len,
217
217
ptr:: null_mut ( ) ,
218
218
)
@@ -234,13 +234,13 @@ impl io::Read for COMPort {
234
234
235
235
impl io:: Write for COMPort {
236
236
fn write ( & mut self , buf : & [ u8 ] ) -> io:: Result < usize > {
237
- let mut len: DWORD = 0 ;
237
+ let mut len: u32 = 0 ;
238
238
239
239
match unsafe {
240
240
WriteFile (
241
241
self . handle ,
242
- buf. as_ptr ( ) as LPVOID ,
243
- buf. len ( ) as DWORD ,
242
+ buf. as_ptr ( ) ,
243
+ buf. len ( ) as u32 ,
244
244
& mut len,
245
245
ptr:: null_mut ( ) ,
246
246
)
@@ -270,15 +270,15 @@ impl SerialPort for COMPort {
270
270
fn set_timeout ( & mut self , timeout : Duration ) -> Result < ( ) > {
271
271
let timeout_constant = Self :: timeout_constant ( timeout) ;
272
272
273
- let mut timeouts = COMMTIMEOUTS {
274
- ReadIntervalTimeout : MAXDWORD ,
275
- ReadTotalTimeoutMultiplier : MAXDWORD ,
273
+ let timeouts = COMMTIMEOUTS {
274
+ ReadIntervalTimeout : u32 :: MAX ,
275
+ ReadTotalTimeoutMultiplier : u32 :: MAX ,
276
276
ReadTotalTimeoutConstant : timeout_constant,
277
277
WriteTotalTimeoutMultiplier : 0 ,
278
278
WriteTotalTimeoutConstant : timeout_constant,
279
279
} ;
280
280
281
- if unsafe { SetCommTimeouts ( self . handle , & mut timeouts) } == 0 {
281
+ if unsafe { SetCommTimeouts ( self . handle , & timeouts) } == 0 {
282
282
return Err ( super :: error:: last_os_error ( ) ) ;
283
283
}
284
284
@@ -320,7 +320,7 @@ impl SerialPort for COMPort {
320
320
321
321
fn baud_rate ( & self ) -> Result < u32 > {
322
322
let dcb = dcb:: get_dcb ( self . handle ) ?;
323
- Ok ( dcb. BaudRate as u32 )
323
+ Ok ( dcb. BaudRate )
324
324
}
325
325
326
326
fn data_bits ( & self ) -> Result < DataBits > {
@@ -364,9 +364,9 @@ impl SerialPort for COMPort {
364
364
365
365
fn flow_control ( & self ) -> Result < FlowControl > {
366
366
let dcb = dcb:: get_dcb ( self . handle ) ?;
367
- if dcb. fOutxCtsFlow ( ) != 0 || dcb. fRtsControl ( ) != 0 {
367
+ if dcb. fOutxCtsFlow ( ) || dcb. fRtsControl ( ) != dcb :: RtsControl :: Disable {
368
368
Ok ( FlowControl :: Hardware )
369
- } else if dcb. fOutX ( ) != 0 || dcb. fInX ( ) != 0 {
369
+ } else if dcb. fOutX ( ) || dcb. fInX ( ) {
370
370
Ok ( FlowControl :: Software )
371
371
} else {
372
372
Ok ( FlowControl :: None )
@@ -404,7 +404,7 @@ impl SerialPort for COMPort {
404
404
}
405
405
406
406
fn bytes_to_read ( & self ) -> Result < u32 > {
407
- let mut errors: DWORD = 0 ;
407
+ let mut errors: u32 = 0 ;
408
408
let mut comstat = MaybeUninit :: uninit ( ) ;
409
409
410
410
if unsafe { ClearCommError ( self . handle , & mut errors, comstat. as_mut_ptr ( ) ) != 0 } {
@@ -415,7 +415,7 @@ impl SerialPort for COMPort {
415
415
}
416
416
417
417
fn bytes_to_write ( & self ) -> Result < u32 > {
418
- let mut errors: DWORD = 0 ;
418
+ let mut errors: u32 = 0 ;
419
419
let mut comstat = MaybeUninit :: uninit ( ) ;
420
420
421
421
if unsafe { ClearCommError ( self . handle , & mut errors, comstat. as_mut_ptr ( ) ) != 0 } {
0 commit comments