Movatterモバイル変換

[0]ホーム
URL:

Skip to content

Navigation Menu

Sign in
Appearance settings

Search code, repositories, users, issues, pull requests...

Provide feedback

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly

 Sign up
Appearance settings

Commite3db920

Browse files
committed
#74 CanFDFrames with ExtendedID are not correctly parsed by socketcan::dump::Reader. Also added TryFrom to extract specific frames from wrapper enums
1 parentf9fa149 commite3db920

File tree

3 files changed

+195
-119
lines changed

3 files changed

+195
-119
lines changed

‎CHANGELOG.md

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -17,6 +17,7 @@ The change log for the Rust [socketcan](https://crates.io/crates/socketcan) libr
1717
-[#68](https://github.com/socketcan-rs/socketcan-rs/pull/68) remove unnecessary qualifications
1818
-[#73](https://github.com/socketcan-rs/socketcan-rs/pull/73) Update some dependencies
1919
-`itertools` to v0.13,`nix` to v0.29,`bitflags` to v2.6,`mio` to v1
20+
-[#74](https://github.com/socketcan-rs/socketcan-rs/pull/74) CanFDFrames with ExtendedID are not correctly parsed by socketcan::dump::Reader
2021
-[#75](https://github.com/socketcan-rs/socketcan-rs/pull/75) Fix DLC and add padding for CANFD frames
2122
-[#76](https://github.com/socketcan-rs/socketcan-rs/pull/76) Add CanCtrlModes::has_mode(mode: CanCtrlMode)
2223
-[#80](https://github.com/socketcan-rs/socketcan-rs/pull/80) Friendly non-Linux compilation error

‎src/dump.rs

Lines changed: 117 additions & 119 deletions
Original file line numberDiff line numberDiff line change
@@ -25,16 +25,16 @@
2525
2626
usecrate::{
2727
id::{FdFlags,IdFlags},
28-
CanDataFrame,CanFdFrame,
28+
CanAnyFrame,CanDataFrame,CanFdFrame,CanFrame,ConstructionError,
2929
};
3030
use embedded_can::StandardId;
3131
use hex::FromHex;
3232
use libc::canid_t;
33-
use std::{fs, io, path};
33+
use std::{fs, io, path, str};
3434

3535
// cannot be generic, because from_str_radix is not part of any Trait
3636
fnparse_raw(bytes:&[u8],radix:u32) ->Option<u64>{
37-
::std::str::from_utf8(bytes)
37+
str::from_utf8(bytes)
3838
.ok()
3939
.and_then(|s| u64::from_str_radix(s, radix).ok())
4040
}
@@ -80,7 +80,7 @@ pub struct CanDumpRecord<'a> {
8080
/// The name of the device
8181
pubdevice:&'astr,
8282
/// The parsed frame
83-
pubframe:super::CanAnyFrame,
83+
pubframe:CanAnyFrame,
8484
}
8585

8686
#[derive(Debug)]
@@ -97,7 +97,7 @@ pub enum ParseError {
9797
/// Invalid CAN frame
9898
InvalidCanFrame,
9999
/// Error creating the frame
100-
ConstructionError(super::ConstructionError),
100+
ConstructionError(ConstructionError),
101101
}
102102

103103
implFrom<io::Error>forParseError{
@@ -106,8 +106,8 @@ impl From<io::Error> for ParseError {
106106
}
107107
}
108108

109-
implFrom<super::ConstructionError>forParseError{
110-
fnfrom(e:super::ConstructionError) ->ParseError{
109+
implFrom<ConstructionError>forParseError{
110+
fnfrom(e:ConstructionError) ->ParseError{
111111
ParseError::ConstructionError(e)
112112
}
113113
}
@@ -155,7 +155,7 @@ impl<R: io::BufRead> Reader<R> {
155155
let f = field_iter.next().ok_or(ParseError::UnexpectedEndOfLine)?;
156156

157157
// device name
158-
let device =::std::str::from_utf8(f).map_err(|_|ParseError::InvalidDeviceName)?;
158+
let device = str::from_utf8(f).map_err(|_|ParseError::InvalidDeviceName)?;
159159

160160
// parse packet
161161
let can_raw = field_iter.next().ok_or(ParseError::UnexpectedEndOfLine)?;
@@ -164,7 +164,7 @@ impl<R: io::BufRead> Reader<R> {
164164
.iter()
165165
.position(|&c| c ==b'#')
166166
.ok_or(ParseError::InvalidCanFrame)?;
167-
let(can_id,mut can_data) = can_raw.split_at(sep_idx);
167+
let(can_id_str,mut can_data) = can_raw.split_at(sep_idx);
168168

169169
// determine frame type (FD or classical) and skip separator(s)
170170
letmut fd_flags =FdFlags::empty();
@@ -186,32 +186,26 @@ impl<R: io::BufRead> Reader<R> {
186186
can_data =&can_data[..can_data.len() -1];
187187
};
188188

189-
letmut flags =IdFlags::empty();
190-
flags.set(IdFlags::RTR,b"R" == can_data);
189+
letmut can_id =(parse_raw(can_id_str,16).ok_or(ParseError::InvalidCanFrame)?)ascanid_t;
190+
letmut id_flags =IdFlags::empty();
191+
id_flags.set(IdFlags::RTR,b"R" == can_data);
192+
id_flags.set(IdFlags::EFF, can_id >=StandardId::MAX.as_raw()ascanid_t);
191193
// TODO: How are error frames saved?
194+
can_id |= id_flags.bits();
192195

193-
let data =ifflags.contains(IdFlags::RTR){
194-
Vec::new()
196+
let data =ifid_flags.contains(IdFlags::RTR){
197+
vec![]
195198
}else{
196199
Vec::from_hex(can_data).map_err(|_|ParseError::InvalidCanFrame)?
197200
};
198-
let frame:super::CanAnyFrame =if is_fd_frame{
199-
CanFdFrame::init(
200-
parse_raw(can_id,16).ok_or(ParseError::InvalidCanFrame)?ascanid_t | flags.bits(),
201-
&data,
202-
fd_flags,
203-
)
204-
.map(super::CanAnyFrame::Fd)
201+
202+
let frame:CanAnyFrame =if is_fd_frame{
203+
CanFdFrame::init(can_id,&data, fd_flags)
204+
.map(CanAnyFrame::Fd)
205205
}else{
206-
// TODO: Check for other frame types?
207-
// is extended?
208-
let can_id =parse_raw(can_id,16).ok_or(ParseError::InvalidCanFrame)?;
209-
if can_id >=StandardId::MAX.as_raw()asu64{
210-
flags.set(IdFlags::EFF,true);
211-
}
212-
CanDataFrame::init(can_idascanid_t | flags.bits(),&data)
213-
.map(super::CanFrame::Data)
214-
.map(|f| f.into())
206+
CanDataFrame::init(can_id,&data)
207+
.map(CanFrame::Data)
208+
.map(CanAnyFrame::from)
215209
}?;
216210

217211
Ok(Some(CanDumpRecord{
@@ -223,7 +217,7 @@ impl<R: io::BufRead> Reader<R> {
223217
}
224218

225219
impl<R: io::Read>IteratorforCanDumpRecords<'_, io::BufReader<R>>{
226-
typeItem =Result<(u64,super::CanAnyFrame),ParseError>;
220+
typeItem =Result<(u64,CanAnyFrame),ParseError>;
227221

228222
fnnext(&mutself) ->Option<Self::Item>{
229223
// lift Option:
@@ -235,6 +229,8 @@ impl<R: io::Read> Iterator for CanDumpRecords<'_, io::BufReader<R>> {
235229
}
236230
}
237231

232+
/////////////////////////////////////////////////////////////////////////////
233+
238234
#[cfg(test)]
239235
mod test{
240236
usesuper::*;
@@ -248,37 +244,33 @@ mod test {
248244

249245
letmut reader =Reader::from_reader(input);
250246

251-
{
252-
let rec1 = reader.next_record().unwrap().unwrap();
253-
254-
assert_eq!(rec1.t_us,1469439874299591);
255-
assert_eq!(rec1.device,"can1");
256-
257-
ifletCanAnyFrame::Normal(frame) = rec1.frame{
258-
assert_eq!(frame.raw_id(),0x080);
259-
assert!(!frame.is_remote_frame());
260-
assert!(!frame.is_error_frame());
261-
assert!(!frame.is_extended());
262-
assert_eq!(frame.data(),&[]);
263-
}else{
264-
panic!("Expected Normal frame, got FD");
265-
}
247+
let rec1 = reader.next_record().unwrap().unwrap();
248+
249+
assert_eq!(rec1.t_us,1469439874299591);
250+
assert_eq!(rec1.device,"can1");
251+
252+
ifletCanAnyFrame::Normal(frame) = rec1.frame{
253+
assert_eq!(frame.raw_id(),0x080);
254+
assert!(!frame.is_remote_frame());
255+
assert!(!frame.is_error_frame());
256+
assert!(!frame.is_extended());
257+
assert_eq!(frame.data(),&[]);
258+
}else{
259+
panic!("Expected Normal frame, got FD");
266260
}
267261

268-
{
269-
let rec2 = reader.next_record().unwrap().unwrap();
270-
assert_eq!(rec2.t_us,1469439874299654);
271-
assert_eq!(rec2.device,"can1");
272-
273-
ifletCanAnyFrame::Normal(frame) = rec2.frame{
274-
assert_eq!(frame.raw_id(),0x701);
275-
assert!(!frame.is_remote_frame());
276-
assert!(!frame.is_error_frame());
277-
assert!(!frame.is_extended());
278-
assert_eq!(frame.data(),&[0x7F]);
279-
}else{
280-
panic!("Expected Normal frame, got FD");
281-
}
262+
let rec2 = reader.next_record().unwrap().unwrap();
263+
assert_eq!(rec2.t_us,1469439874299654);
264+
assert_eq!(rec2.device,"can1");
265+
266+
ifletCanAnyFrame::Normal(frame) = rec2.frame{
267+
assert_eq!(frame.raw_id(),0x701);
268+
assert!(!frame.is_remote_frame());
269+
assert!(!frame.is_error_frame());
270+
assert!(!frame.is_extended());
271+
assert_eq!(frame.data(),&[0x7F]);
272+
}else{
273+
panic!("Expected Normal frame, got FD");
282274
}
283275

284276
assert!(reader.next_record().unwrap().is_none());
@@ -291,82 +283,88 @@ mod test {
291283

292284
letmut reader =Reader::from_reader(input);
293285

294-
{
295-
let rec1 = reader.next_record().unwrap().unwrap();
296-
297-
assert_eq!(rec1.t_us,1469439874299591);
298-
assert_eq!(rec1.device,"can1");
299-
300-
ifletCanAnyFrame::Normal(frame) = rec1.frame{
301-
assert_eq!(frame.raw_id(),0x080080);
302-
assert_eq!(frame.is_remote_frame(),false);
303-
assert_eq!(frame.is_error_frame(),false);
304-
assert_eq!(frame.is_extended(),true);
305-
assert_eq!(frame.data(),&[]);
306-
}else{
307-
panic!("Expected Normal frame, got FD");
308-
}
286+
let rec1 = reader.next_record().unwrap().unwrap();
287+
288+
assert_eq!(rec1.t_us,1469439874299591);
289+
assert_eq!(rec1.device,"can1");
290+
291+
ifletCanAnyFrame::Normal(frame) = rec1.frame{
292+
assert_eq!(frame.raw_id(),0x080080);
293+
assert_eq!(frame.is_remote_frame(),false);
294+
assert_eq!(frame.is_error_frame(),false);
295+
assert_eq!(frame.is_extended(),true);
296+
assert_eq!(frame.data(),&[]);
297+
}else{
298+
panic!("Expected Normal frame, got FD");
309299
}
310300

311-
{
312-
let rec2 = reader.next_record().unwrap().unwrap();
313-
assert_eq!(rec2.t_us,1469439874299654);
314-
assert_eq!(rec2.device,"can1");
315-
316-
ifletCanAnyFrame::Normal(frame) = rec2.frame{
317-
assert_eq!(frame.raw_id(),0x053701);
318-
assert_eq!(frame.is_remote_frame(),false);
319-
assert_eq!(frame.is_error_frame(),false);
320-
assert_eq!(frame.is_extended(),true);
321-
assert_eq!(frame.data(),&[0x7F]);
322-
}else{
323-
panic!("Expected Normal frame, got FD");
324-
}
301+
let rec2 = reader.next_record().unwrap().unwrap();
302+
assert_eq!(rec2.t_us,1469439874299654);
303+
assert_eq!(rec2.device,"can1");
304+
305+
ifletCanAnyFrame::Normal(frame) = rec2.frame{
306+
assert_eq!(frame.raw_id(),0x053701);
307+
assert_eq!(frame.is_remote_frame(),false);
308+
assert_eq!(frame.is_error_frame(),false);
309+
assert_eq!(frame.is_extended(),true);
310+
assert_eq!(frame.data(),&[0x7F]);
311+
}else{
312+
panic!("Expected Normal frame, got FD");
325313
}
326314

327315
assert!(reader.next_record().unwrap().is_none());
328316
}
329317

318+
// Issue #74
319+
#[test]
320+
fntest_extended_id_fd(){
321+
let input:&[u8] =
322+
b"(1234.567890) can0 12345678##500112233445566778899AABBCCDDEEFF";
323+
324+
letmut reader =Reader::from_reader(input);
325+
let rec = reader.next_record().unwrap().unwrap();
326+
let frame =CanFdFrame::try_from(rec.frame).unwrap();
327+
328+
assert!(frame.is_extended());
329+
assert_eq!(0x12345678, frame.raw_id());
330+
}
331+
330332
#[test]
331333
fntest_fd(){
332334
let input:&[u8] =b"(1469439874.299591) can1 080##0\n\
333335
(1469439874.299654) can1 701##17F";
334336

335337
letmut reader =Reader::from_reader(input);
336338

337-
{
338-
let rec1 = reader.next_record().unwrap().unwrap();
339-
340-
assert_eq!(rec1.t_us,1469439874299591);
341-
assert_eq!(rec1.device,"can1");
342-
ifletCanAnyFrame::Fd(frame) = rec1.frame{
343-
assert_eq!(frame.raw_id(),0x080);
344-
assert!(!frame.is_remote_frame());
345-
assert!(!frame.is_error_frame());
346-
assert!(!frame.is_extended());
347-
assert!(!frame.is_brs());
348-
assert!(!frame.is_esi());
349-
assert_eq!(frame.data(),&[]);
350-
}else{
351-
panic!("Expected FD frame, got Normal");
352-
}
339+
let rec1 = reader.next_record().unwrap().unwrap();
340+
341+
assert_eq!(rec1.t_us,1469439874299591);
342+
assert_eq!(rec1.device,"can1");
343+
ifletCanAnyFrame::Fd(frame) = rec1.frame{
344+
assert_eq!(frame.raw_id(),0x080);
345+
assert!(!frame.is_remote_frame());
346+
assert!(!frame.is_error_frame());
347+
assert!(!frame.is_extended());
348+
assert!(!frame.is_brs());
349+
assert!(!frame.is_esi());
350+
assert_eq!(frame.data(),&[]);
351+
}else{
352+
panic!("Expected FD frame, got Normal");
353353
}
354354

355-
{
356-
let rec2 = reader.next_record().unwrap().unwrap();
357-
assert_eq!(rec2.t_us,1469439874299654);
358-
assert_eq!(rec2.device,"can1");
359-
ifletCanAnyFrame::Fd(frame) = rec2.frame{
360-
assert_eq!(frame.raw_id(),0x701);
361-
assert!(!frame.is_remote_frame());
362-
assert!(!frame.is_error_frame());
363-
assert!(!frame.is_extended());
364-
assert!(frame.is_brs());
365-
assert!(!frame.is_esi());
366-
assert_eq!(frame.data(),&[0x7F]);
367-
}else{
368-
panic!("Expected FD frame, got Normal");
369-
}
355+
let rec2 = reader.next_record().unwrap().unwrap();
356+
assert_eq!(rec2.t_us,1469439874299654);
357+
assert_eq!(rec2.device,"can1");
358+
ifletCanAnyFrame::Fd(frame) = rec2.frame{
359+
assert_eq!(frame.raw_id(),0x701);
360+
assert!(!frame.is_remote_frame());
361+
assert!(!frame.is_error_frame());
362+
assert!(!frame.is_extended());
363+
assert!(frame.is_brs());
364+
assert!(!frame.is_esi());
365+
assert_eq!(frame.data(),&[0x7F]);
366+
}else{
367+
panic!("Expected FD frame, got Normal");
370368
}
371369

372370
assert!(reader.next_record().unwrap().is_none());

0 commit comments

Comments
 (0)
[8]ページ先頭
©2009-2025 Movatter.jp