1#[repr(C)]
4#[derive(Default)]
5pub struct __IncompleteArrayField<T>(::std::marker::PhantomData<T>, [T; 0]);
6impl<T> __IncompleteArrayField<T> {
7 #[inline]
8 pub const fn new() -> Self {
9 __IncompleteArrayField(::std::marker::PhantomData, [])
10 }
11 #[inline]
12 pub fn as_ptr(&self) -> *const T {
13 self as *const _ as *const T
14 }
15 #[inline]
16 pub fn as_mut_ptr(&mut self) -> *mut T {
17 self as *mut _ as *mut T
18 }
19 #[inline]
20 pub unsafe fn as_slice(&self, len: usize) -> &[T] {
21 ::std::slice::from_raw_parts(self.as_ptr(), len)
22 }
23 #[inline]
24 pub unsafe fn as_mut_slice(&mut self, len: usize) -> &mut [T] {
25 ::std::slice::from_raw_parts_mut(self.as_mut_ptr(), len)
26 }
27}
28impl<T> ::std::fmt::Debug for __IncompleteArrayField<T> {
29 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
30 fmt.write_str("__IncompleteArrayField")
31 }
32}
33#[repr(C)]
34pub struct __BindgenUnionField<T>(::std::marker::PhantomData<T>);
35impl<T> __BindgenUnionField<T> {
36 #[inline]
37 pub const fn new() -> Self {
38 __BindgenUnionField(::std::marker::PhantomData)
39 }
40 #[inline]
41 pub unsafe fn as_ref(&self) -> &T {
42 ::std::mem::transmute(self)
43 }
44 #[inline]
45 pub unsafe fn as_mut(&mut self) -> &mut T {
46 ::std::mem::transmute(self)
47 }
48}
49impl<T> ::std::default::Default for __BindgenUnionField<T> {
50 #[inline]
51 fn default() -> Self {
52 Self::new()
53 }
54}
55impl<T> ::std::clone::Clone for __BindgenUnionField<T> {
56 #[inline]
57 fn clone(&self) -> Self {
58 Self::new()
59 }
60}
61impl<T> ::std::marker::Copy for __BindgenUnionField<T> {}
62impl<T> ::std::fmt::Debug for __BindgenUnionField<T> {
63 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
64 fmt.write_str("__BindgenUnionField")
65 }
66}
67impl<T> ::std::hash::Hash for __BindgenUnionField<T> {
68 fn hash<H: ::std::hash::Hasher>(&self, _state: &mut H) {}
69}
70impl<T> ::std::cmp::PartialEq for __BindgenUnionField<T> {
71 fn eq(&self, _other: &__BindgenUnionField<T>) -> bool {
72 true
73 }
74}
75impl<T> ::std::cmp::Eq for __BindgenUnionField<T> {}
76pub const CAN_EFF_FLAG: u32 = 2147483648;
77pub const CAN_RTR_FLAG: u32 = 1073741824;
78pub const CAN_ERR_FLAG: u32 = 536870912;
79pub const CAN_SFF_MASK: u32 = 2047;
80pub const CAN_EFF_MASK: u32 = 536870911;
81pub const CAN_ERR_MASK: u32 = 536870911;
82pub const CAN_SFF_ID_BITS: u32 = 11;
83pub const CAN_EFF_ID_BITS: u32 = 29;
84pub const CAN_MAX_DLC: u32 = 8;
85pub const CAN_MAX_DLEN: u32 = 8;
86pub const CANFD_MAX_DLC: u32 = 15;
87pub const CANFD_MAX_DLEN: u32 = 64;
88pub const CANFD_BRS: u32 = 1;
89pub const CANFD_ESI: u32 = 2;
90pub const CAN_RAW: u32 = 1;
91pub const CAN_BCM: u32 = 2;
92pub const CAN_TP16: u32 = 3;
93pub const CAN_TP20: u32 = 4;
94pub const CAN_MCNET: u32 = 5;
95pub const CAN_ISOTP: u32 = 6;
96pub const CAN_J1939: u32 = 7;
97pub const CAN_NPROTO: u32 = 8;
98pub const SOL_CAN_BASE: u32 = 100;
99pub const CAN_INV_FILTER: u32 = 536870912;
100pub const CAN_RAW_FILTER_MAX: u32 = 512;
101pub const SETTIMER: u32 = 1;
102pub const STARTTIMER: u32 = 2;
103pub const TX_COUNTEVT: u32 = 4;
104pub const TX_ANNOUNCE: u32 = 8;
105pub const TX_CP_CAN_ID: u32 = 16;
106pub const RX_FILTER_ID: u32 = 32;
107pub const RX_CHECK_DLC: u32 = 64;
108pub const RX_NO_AUTOTIMER: u32 = 128;
109pub const RX_ANNOUNCE_RESUME: u32 = 256;
110pub const TX_RESET_MULTI_IDX: u32 = 512;
111pub const RX_RTR_FRAME: u32 = 1024;
112pub const CAN_FD_FRAME: u32 = 2048;
113pub const CAN_ERR_DLC: u32 = 8;
114pub const CAN_ERR_TX_TIMEOUT: u32 = 1;
115pub const CAN_ERR_LOSTARB: u32 = 2;
116pub const CAN_ERR_CRTL: u32 = 4;
117pub const CAN_ERR_PROT: u32 = 8;
118pub const CAN_ERR_TRX: u32 = 16;
119pub const CAN_ERR_ACK: u32 = 32;
120pub const CAN_ERR_BUSOFF: u32 = 64;
121pub const CAN_ERR_BUSERROR: u32 = 128;
122pub const CAN_ERR_RESTARTED: u32 = 256;
123pub const CAN_ERR_LOSTARB_UNSPEC: u32 = 0;
124pub const CAN_ERR_CRTL_UNSPEC: u32 = 0;
125pub const CAN_ERR_CRTL_RX_OVERFLOW: u32 = 1;
126pub const CAN_ERR_CRTL_TX_OVERFLOW: u32 = 2;
127pub const CAN_ERR_CRTL_RX_WARNING: u32 = 4;
128pub const CAN_ERR_CRTL_TX_WARNING: u32 = 8;
129pub const CAN_ERR_CRTL_RX_PASSIVE: u32 = 16;
130pub const CAN_ERR_CRTL_TX_PASSIVE: u32 = 32;
131pub const CAN_ERR_CRTL_ACTIVE: u32 = 64;
132pub const CAN_ERR_PROT_UNSPEC: u32 = 0;
133pub const CAN_ERR_PROT_BIT: u32 = 1;
134pub const CAN_ERR_PROT_FORM: u32 = 2;
135pub const CAN_ERR_PROT_STUFF: u32 = 4;
136pub const CAN_ERR_PROT_BIT0: u32 = 8;
137pub const CAN_ERR_PROT_BIT1: u32 = 16;
138pub const CAN_ERR_PROT_OVERLOAD: u32 = 32;
139pub const CAN_ERR_PROT_ACTIVE: u32 = 64;
140pub const CAN_ERR_PROT_TX: u32 = 128;
141pub const CAN_ERR_PROT_LOC_UNSPEC: u32 = 0;
142pub const CAN_ERR_PROT_LOC_SOF: u32 = 3;
143pub const CAN_ERR_PROT_LOC_ID28_21: u32 = 2;
144pub const CAN_ERR_PROT_LOC_ID20_18: u32 = 6;
145pub const CAN_ERR_PROT_LOC_SRTR: u32 = 4;
146pub const CAN_ERR_PROT_LOC_IDE: u32 = 5;
147pub const CAN_ERR_PROT_LOC_ID17_13: u32 = 7;
148pub const CAN_ERR_PROT_LOC_ID12_05: u32 = 15;
149pub const CAN_ERR_PROT_LOC_ID04_00: u32 = 14;
150pub const CAN_ERR_PROT_LOC_RTR: u32 = 12;
151pub const CAN_ERR_PROT_LOC_RES1: u32 = 13;
152pub const CAN_ERR_PROT_LOC_RES0: u32 = 9;
153pub const CAN_ERR_PROT_LOC_DLC: u32 = 11;
154pub const CAN_ERR_PROT_LOC_DATA: u32 = 10;
155pub const CAN_ERR_PROT_LOC_CRC_SEQ: u32 = 8;
156pub const CAN_ERR_PROT_LOC_CRC_DEL: u32 = 24;
157pub const CAN_ERR_PROT_LOC_ACK: u32 = 25;
158pub const CAN_ERR_PROT_LOC_ACK_DEL: u32 = 27;
159pub const CAN_ERR_PROT_LOC_EOF: u32 = 26;
160pub const CAN_ERR_PROT_LOC_INTERM: u32 = 18;
161pub const CAN_ERR_TRX_UNSPEC: u32 = 0;
162pub const CAN_ERR_TRX_CANH_NO_WIRE: u32 = 4;
163pub const CAN_ERR_TRX_CANH_SHORT_TO_BAT: u32 = 5;
164pub const CAN_ERR_TRX_CANH_SHORT_TO_VCC: u32 = 6;
165pub const CAN_ERR_TRX_CANH_SHORT_TO_GND: u32 = 7;
166pub const CAN_ERR_TRX_CANL_NO_WIRE: u32 = 64;
167pub const CAN_ERR_TRX_CANL_SHORT_TO_BAT: u32 = 80;
168pub const CAN_ERR_TRX_CANL_SHORT_TO_VCC: u32 = 96;
169pub const CAN_ERR_TRX_CANL_SHORT_TO_GND: u32 = 112;
170pub const CAN_ERR_TRX_CANL_SHORT_TO_CANH: u32 = 128;
171pub const J1939_MAX_UNICAST_ADDR: u32 = 253;
172pub const J1939_IDLE_ADDR: u32 = 254;
173pub const J1939_NO_ADDR: u32 = 255;
174pub const J1939_NO_NAME: u32 = 0;
175pub const J1939_PGN_REQUEST: u32 = 59904;
176pub const J1939_PGN_ADDRESS_CLAIMED: u32 = 60928;
177pub const J1939_PGN_ADDRESS_COMMANDED: u32 = 65240;
178pub const J1939_PGN_PDU1_MAX: u32 = 261888;
179pub const J1939_PGN_MAX: u32 = 262143;
180pub const J1939_NO_PGN: u32 = 262144;
181pub const SOL_CAN_J1939: u32 = 107;
182pub const J1939_FILTER_MAX: u32 = 512;
183pub const CAN_CTRLMODE_LOOPBACK: u32 = 1;
184pub const CAN_CTRLMODE_LISTENONLY: u32 = 2;
185pub const CAN_CTRLMODE_3_SAMPLES: u32 = 4;
186pub const CAN_CTRLMODE_ONE_SHOT: u32 = 8;
187pub const CAN_CTRLMODE_BERR_REPORTING: u32 = 16;
188pub const CAN_CTRLMODE_FD: u32 = 32;
189pub const CAN_CTRLMODE_PRESUME_ACK: u32 = 64;
190pub const CAN_CTRLMODE_FD_NON_ISO: u32 = 128;
191pub const CAN_TERMINATION_DISABLED: u32 = 0;
192pub const SOL_CAN_RAW: u32 = 101;
193pub type __kernel_sa_family_t = ::std::os::raw::c_ushort;
194pub type canid_t = __u32;
195pub type can_err_mask_t = __u32;
196#[repr(C)]
197#[repr(align(8))]
198pub struct can_frame {
199 pub can_id: canid_t,
200 pub can_dlc: __u8,
201 pub __pad: __u8,
202 pub __res0: __u8,
203 pub __res1: __u8,
204 pub data: [__u8; 8usize],
205}
206#[test]
207fn bindgen_test_layout_can_frame() {
208 assert_eq!(
209 ::std::mem::size_of::<can_frame>(),
210 16usize,
211 concat!("Size of: ", stringify!(can_frame))
212 );
213 assert_eq!(
214 ::std::mem::align_of::<can_frame>(),
215 8usize,
216 concat!("Alignment of ", stringify!(can_frame))
217 );
218 assert_eq!(
219 unsafe { &(*(::std::ptr::null::<can_frame>())).can_id as *const _ as usize },
220 0usize,
221 concat!(
222 "Offset of field: ",
223 stringify!(can_frame),
224 "::",
225 stringify!(can_id)
226 )
227 );
228 assert_eq!(
229 unsafe { &(*(::std::ptr::null::<can_frame>())).can_dlc as *const _ as usize },
230 4usize,
231 concat!(
232 "Offset of field: ",
233 stringify!(can_frame),
234 "::",
235 stringify!(can_dlc)
236 )
237 );
238 assert_eq!(
239 unsafe { &(*(::std::ptr::null::<can_frame>())).__pad as *const _ as usize },
240 5usize,
241 concat!(
242 "Offset of field: ",
243 stringify!(can_frame),
244 "::",
245 stringify!(__pad)
246 )
247 );
248 assert_eq!(
249 unsafe { &(*(::std::ptr::null::<can_frame>())).__res0 as *const _ as usize },
250 6usize,
251 concat!(
252 "Offset of field: ",
253 stringify!(can_frame),
254 "::",
255 stringify!(__res0)
256 )
257 );
258 assert_eq!(
259 unsafe { &(*(::std::ptr::null::<can_frame>())).__res1 as *const _ as usize },
260 7usize,
261 concat!(
262 "Offset of field: ",
263 stringify!(can_frame),
264 "::",
265 stringify!(__res1)
266 )
267 );
268 assert_eq!(
269 unsafe { &(*(::std::ptr::null::<can_frame>())).data as *const _ as usize },
270 8usize,
271 concat!(
272 "Offset of field: ",
273 stringify!(can_frame),
274 "::",
275 stringify!(data)
276 )
277 );
278}
279#[repr(C)]
280#[repr(align(8))]
281pub struct canfd_frame {
282 pub can_id: canid_t,
283 pub len: __u8,
284 pub flags: __u8,
285 pub __res0: __u8,
286 pub __res1: __u8,
287 pub data: [__u8; 64usize],
288}
289#[test]
290fn bindgen_test_layout_canfd_frame() {
291 assert_eq!(
292 ::std::mem::size_of::<canfd_frame>(),
293 72usize,
294 concat!("Size of: ", stringify!(canfd_frame))
295 );
296 assert_eq!(
297 ::std::mem::align_of::<canfd_frame>(),
298 8usize,
299 concat!("Alignment of ", stringify!(canfd_frame))
300 );
301 assert_eq!(
302 unsafe { &(*(::std::ptr::null::<canfd_frame>())).can_id as *const _ as usize },
303 0usize,
304 concat!(
305 "Offset of field: ",
306 stringify!(canfd_frame),
307 "::",
308 stringify!(can_id)
309 )
310 );
311 assert_eq!(
312 unsafe { &(*(::std::ptr::null::<canfd_frame>())).len as *const _ as usize },
313 4usize,
314 concat!(
315 "Offset of field: ",
316 stringify!(canfd_frame),
317 "::",
318 stringify!(len)
319 )
320 );
321 assert_eq!(
322 unsafe { &(*(::std::ptr::null::<canfd_frame>())).flags as *const _ as usize },
323 5usize,
324 concat!(
325 "Offset of field: ",
326 stringify!(canfd_frame),
327 "::",
328 stringify!(flags)
329 )
330 );
331 assert_eq!(
332 unsafe { &(*(::std::ptr::null::<canfd_frame>())).__res0 as *const _ as usize },
333 6usize,
334 concat!(
335 "Offset of field: ",
336 stringify!(canfd_frame),
337 "::",
338 stringify!(__res0)
339 )
340 );
341 assert_eq!(
342 unsafe { &(*(::std::ptr::null::<canfd_frame>())).__res1 as *const _ as usize },
343 7usize,
344 concat!(
345 "Offset of field: ",
346 stringify!(canfd_frame),
347 "::",
348 stringify!(__res1)
349 )
350 );
351 assert_eq!(
352 unsafe { &(*(::std::ptr::null::<canfd_frame>())).data as *const _ as usize },
353 8usize,
354 concat!(
355 "Offset of field: ",
356 stringify!(canfd_frame),
357 "::",
358 stringify!(data)
359 )
360 );
361}
362#[repr(C)]
363pub struct sockaddr_can {
364 pub can_family: __kernel_sa_family_t,
365 pub can_ifindex: ::std::os::raw::c_int,
366 pub can_addr: sockaddr_can__bindgen_ty_1,
367}
368#[repr(C)]
369pub struct sockaddr_can__bindgen_ty_1 {
370 pub tp: __BindgenUnionField<sockaddr_can__bindgen_ty_1__bindgen_ty_1>,
371 pub j1939: __BindgenUnionField<sockaddr_can__bindgen_ty_1__bindgen_ty_2>,
372 pub bindgen_union_field: [u64; 2usize],
373}
374#[repr(C)]
375pub struct sockaddr_can__bindgen_ty_1__bindgen_ty_1 {
376 pub rx_id: canid_t,
377 pub tx_id: canid_t,
378}
379#[test]
380fn bindgen_test_layout_sockaddr_can__bindgen_ty_1__bindgen_ty_1() {
381 assert_eq!(
382 ::std::mem::size_of::<sockaddr_can__bindgen_ty_1__bindgen_ty_1>(),
383 8usize,
384 concat!(
385 "Size of: ",
386 stringify!(sockaddr_can__bindgen_ty_1__bindgen_ty_1)
387 )
388 );
389 assert_eq!(
390 ::std::mem::align_of::<sockaddr_can__bindgen_ty_1__bindgen_ty_1>(),
391 4usize,
392 concat!(
393 "Alignment of ",
394 stringify!(sockaddr_can__bindgen_ty_1__bindgen_ty_1)
395 )
396 );
397 assert_eq!(
398 unsafe {
399 &(*(::std::ptr::null::<sockaddr_can__bindgen_ty_1__bindgen_ty_1>())).rx_id as *const _
400 as usize
401 },
402 0usize,
403 concat!(
404 "Offset of field: ",
405 stringify!(sockaddr_can__bindgen_ty_1__bindgen_ty_1),
406 "::",
407 stringify!(rx_id)
408 )
409 );
410 assert_eq!(
411 unsafe {
412 &(*(::std::ptr::null::<sockaddr_can__bindgen_ty_1__bindgen_ty_1>())).tx_id as *const _
413 as usize
414 },
415 4usize,
416 concat!(
417 "Offset of field: ",
418 stringify!(sockaddr_can__bindgen_ty_1__bindgen_ty_1),
419 "::",
420 stringify!(tx_id)
421 )
422 );
423}
424#[repr(C)]
425pub struct sockaddr_can__bindgen_ty_1__bindgen_ty_2 {
426 pub name: __u64,
427 pub pgn: __u32,
428 pub addr: __u8,
429}
430#[test]
431fn bindgen_test_layout_sockaddr_can__bindgen_ty_1__bindgen_ty_2() {
432 assert_eq!(
433 ::std::mem::size_of::<sockaddr_can__bindgen_ty_1__bindgen_ty_2>(),
434 16usize,
435 concat!(
436 "Size of: ",
437 stringify!(sockaddr_can__bindgen_ty_1__bindgen_ty_2)
438 )
439 );
440 assert_eq!(
441 ::std::mem::align_of::<sockaddr_can__bindgen_ty_1__bindgen_ty_2>(),
442 8usize,
443 concat!(
444 "Alignment of ",
445 stringify!(sockaddr_can__bindgen_ty_1__bindgen_ty_2)
446 )
447 );
448 assert_eq!(
449 unsafe {
450 &(*(::std::ptr::null::<sockaddr_can__bindgen_ty_1__bindgen_ty_2>())).name as *const _
451 as usize
452 },
453 0usize,
454 concat!(
455 "Offset of field: ",
456 stringify!(sockaddr_can__bindgen_ty_1__bindgen_ty_2),
457 "::",
458 stringify!(name)
459 )
460 );
461 assert_eq!(
462 unsafe {
463 &(*(::std::ptr::null::<sockaddr_can__bindgen_ty_1__bindgen_ty_2>())).pgn as *const _
464 as usize
465 },
466 8usize,
467 concat!(
468 "Offset of field: ",
469 stringify!(sockaddr_can__bindgen_ty_1__bindgen_ty_2),
470 "::",
471 stringify!(pgn)
472 )
473 );
474 assert_eq!(
475 unsafe {
476 &(*(::std::ptr::null::<sockaddr_can__bindgen_ty_1__bindgen_ty_2>())).addr as *const _
477 as usize
478 },
479 12usize,
480 concat!(
481 "Offset of field: ",
482 stringify!(sockaddr_can__bindgen_ty_1__bindgen_ty_2),
483 "::",
484 stringify!(addr)
485 )
486 );
487}
488#[test]
489fn bindgen_test_layout_sockaddr_can__bindgen_ty_1() {
490 assert_eq!(
491 ::std::mem::size_of::<sockaddr_can__bindgen_ty_1>(),
492 16usize,
493 concat!("Size of: ", stringify!(sockaddr_can__bindgen_ty_1))
494 );
495 assert_eq!(
496 ::std::mem::align_of::<sockaddr_can__bindgen_ty_1>(),
497 8usize,
498 concat!("Alignment of ", stringify!(sockaddr_can__bindgen_ty_1))
499 );
500 assert_eq!(
501 unsafe { &(*(::std::ptr::null::<sockaddr_can__bindgen_ty_1>())).tp as *const _ as usize },
502 0usize,
503 concat!(
504 "Offset of field: ",
505 stringify!(sockaddr_can__bindgen_ty_1),
506 "::",
507 stringify!(tp)
508 )
509 );
510 assert_eq!(
511 unsafe {
512 &(*(::std::ptr::null::<sockaddr_can__bindgen_ty_1>())).j1939 as *const _ as usize
513 },
514 0usize,
515 concat!(
516 "Offset of field: ",
517 stringify!(sockaddr_can__bindgen_ty_1),
518 "::",
519 stringify!(j1939)
520 )
521 );
522}
523#[test]
524fn bindgen_test_layout_sockaddr_can() {
525 assert_eq!(
526 ::std::mem::size_of::<sockaddr_can>(),
527 24usize,
528 concat!("Size of: ", stringify!(sockaddr_can))
529 );
530 assert_eq!(
531 ::std::mem::align_of::<sockaddr_can>(),
532 8usize,
533 concat!("Alignment of ", stringify!(sockaddr_can))
534 );
535 assert_eq!(
536 unsafe { &(*(::std::ptr::null::<sockaddr_can>())).can_family as *const _ as usize },
537 0usize,
538 concat!(
539 "Offset of field: ",
540 stringify!(sockaddr_can),
541 "::",
542 stringify!(can_family)
543 )
544 );
545 assert_eq!(
546 unsafe { &(*(::std::ptr::null::<sockaddr_can>())).can_ifindex as *const _ as usize },
547 4usize,
548 concat!(
549 "Offset of field: ",
550 stringify!(sockaddr_can),
551 "::",
552 stringify!(can_ifindex)
553 )
554 );
555 assert_eq!(
556 unsafe { &(*(::std::ptr::null::<sockaddr_can>())).can_addr as *const _ as usize },
557 8usize,
558 concat!(
559 "Offset of field: ",
560 stringify!(sockaddr_can),
561 "::",
562 stringify!(can_addr)
563 )
564 );
565}
566#[repr(C)]
567pub struct can_filter {
568 pub can_id: canid_t,
569 pub can_mask: canid_t,
570}
571#[test]
572fn bindgen_test_layout_can_filter() {
573 assert_eq!(
574 ::std::mem::size_of::<can_filter>(),
575 8usize,
576 concat!("Size of: ", stringify!(can_filter))
577 );
578 assert_eq!(
579 ::std::mem::align_of::<can_filter>(),
580 4usize,
581 concat!("Alignment of ", stringify!(can_filter))
582 );
583 assert_eq!(
584 unsafe { &(*(::std::ptr::null::<can_filter>())).can_id as *const _ as usize },
585 0usize,
586 concat!(
587 "Offset of field: ",
588 stringify!(can_filter),
589 "::",
590 stringify!(can_id)
591 )
592 );
593 assert_eq!(
594 unsafe { &(*(::std::ptr::null::<can_filter>())).can_mask as *const _ as usize },
595 4usize,
596 concat!(
597 "Offset of field: ",
598 stringify!(can_filter),
599 "::",
600 stringify!(can_mask)
601 )
602 );
603}
604#[repr(C)]
605#[derive(Debug, Copy, Clone)]
606pub struct bcm_timeval {
607 pub tv_sec: ::std::os::raw::c_long,
608 pub tv_usec: ::std::os::raw::c_long,
609}
610#[test]
611fn bindgen_test_layout_bcm_timeval() {
612 assert_eq!(
613 ::std::mem::size_of::<bcm_timeval>(),
614 16usize,
615 concat!("Size of: ", stringify!(bcm_timeval))
616 );
617 assert_eq!(
618 ::std::mem::align_of::<bcm_timeval>(),
619 8usize,
620 concat!("Alignment of ", stringify!(bcm_timeval))
621 );
622 assert_eq!(
623 unsafe { &(*(::std::ptr::null::<bcm_timeval>())).tv_sec as *const _ as usize },
624 0usize,
625 concat!(
626 "Offset of field: ",
627 stringify!(bcm_timeval),
628 "::",
629 stringify!(tv_sec)
630 )
631 );
632 assert_eq!(
633 unsafe { &(*(::std::ptr::null::<bcm_timeval>())).tv_usec as *const _ as usize },
634 8usize,
635 concat!(
636 "Offset of field: ",
637 stringify!(bcm_timeval),
638 "::",
639 stringify!(tv_usec)
640 )
641 );
642}
643#[repr(C)]
644pub struct bcm_msg_head {
645 pub opcode: __u32,
646 pub flags: __u32,
647 pub count: __u32,
648 pub ival1: bcm_timeval,
649 pub ival2: bcm_timeval,
650 pub can_id: canid_t,
651 pub nframes: __u32,
652 pub frames: __IncompleteArrayField<can_frame>,
653}
654#[test]
655fn bindgen_test_layout_bcm_msg_head() {
656 assert_eq!(
657 ::std::mem::size_of::<bcm_msg_head>(),
658 56usize,
659 concat!("Size of: ", stringify!(bcm_msg_head))
660 );
661 assert_eq!(
662 ::std::mem::align_of::<bcm_msg_head>(),
663 8usize,
664 concat!("Alignment of ", stringify!(bcm_msg_head))
665 );
666 assert_eq!(
667 unsafe { &(*(::std::ptr::null::<bcm_msg_head>())).opcode as *const _ as usize },
668 0usize,
669 concat!(
670 "Offset of field: ",
671 stringify!(bcm_msg_head),
672 "::",
673 stringify!(opcode)
674 )
675 );
676 assert_eq!(
677 unsafe { &(*(::std::ptr::null::<bcm_msg_head>())).flags as *const _ as usize },
678 4usize,
679 concat!(
680 "Offset of field: ",
681 stringify!(bcm_msg_head),
682 "::",
683 stringify!(flags)
684 )
685 );
686 assert_eq!(
687 unsafe { &(*(::std::ptr::null::<bcm_msg_head>())).count as *const _ as usize },
688 8usize,
689 concat!(
690 "Offset of field: ",
691 stringify!(bcm_msg_head),
692 "::",
693 stringify!(count)
694 )
695 );
696 assert_eq!(
697 unsafe { &(*(::std::ptr::null::<bcm_msg_head>())).ival1 as *const _ as usize },
698 16usize,
699 concat!(
700 "Offset of field: ",
701 stringify!(bcm_msg_head),
702 "::",
703 stringify!(ival1)
704 )
705 );
706 assert_eq!(
707 unsafe { &(*(::std::ptr::null::<bcm_msg_head>())).ival2 as *const _ as usize },
708 32usize,
709 concat!(
710 "Offset of field: ",
711 stringify!(bcm_msg_head),
712 "::",
713 stringify!(ival2)
714 )
715 );
716 assert_eq!(
717 unsafe { &(*(::std::ptr::null::<bcm_msg_head>())).can_id as *const _ as usize },
718 48usize,
719 concat!(
720 "Offset of field: ",
721 stringify!(bcm_msg_head),
722 "::",
723 stringify!(can_id)
724 )
725 );
726 assert_eq!(
727 unsafe { &(*(::std::ptr::null::<bcm_msg_head>())).nframes as *const _ as usize },
728 52usize,
729 concat!(
730 "Offset of field: ",
731 stringify!(bcm_msg_head),
732 "::",
733 stringify!(nframes)
734 )
735 );
736 assert_eq!(
737 unsafe { &(*(::std::ptr::null::<bcm_msg_head>())).frames as *const _ as usize },
738 56usize,
739 concat!(
740 "Offset of field: ",
741 stringify!(bcm_msg_head),
742 "::",
743 stringify!(frames)
744 )
745 );
746}
747pub const TX_SETUP: ::std::os::raw::c_uint = 1;
748pub const TX_DELETE: ::std::os::raw::c_uint = 2;
749pub const TX_READ: ::std::os::raw::c_uint = 3;
750pub const TX_SEND: ::std::os::raw::c_uint = 4;
751pub const RX_SETUP: ::std::os::raw::c_uint = 5;
752pub const RX_DELETE: ::std::os::raw::c_uint = 6;
753pub const RX_READ: ::std::os::raw::c_uint = 7;
754pub const TX_STATUS: ::std::os::raw::c_uint = 8;
755pub const TX_EXPIRED: ::std::os::raw::c_uint = 9;
756pub const RX_STATUS: ::std::os::raw::c_uint = 10;
757pub const RX_TIMEOUT: ::std::os::raw::c_uint = 11;
758pub const RX_CHANGED: ::std::os::raw::c_uint = 12;
759pub type _bindgen_ty_1 = ::std::os::raw::c_uint;
760pub type pgn_t = __u32;
761pub type priority_t = __u8;
762pub type name_t = __u64;
763pub const SO_J1939_FILTER: ::std::os::raw::c_uint = 1;
764pub const SO_J1939_PROMISC: ::std::os::raw::c_uint = 2;
765pub const SO_J1939_SEND_PRIO: ::std::os::raw::c_uint = 3;
766pub const SO_J1939_ERRQUEUE: ::std::os::raw::c_uint = 4;
767pub type _bindgen_ty_2 = ::std::os::raw::c_uint;
768pub const SCM_J1939_DEST_ADDR: ::std::os::raw::c_uint = 1;
769pub const SCM_J1939_DEST_NAME: ::std::os::raw::c_uint = 2;
770pub const SCM_J1939_PRIO: ::std::os::raw::c_uint = 3;
771pub const SCM_J1939_ERRQUEUE: ::std::os::raw::c_uint = 4;
772pub type _bindgen_ty_3 = ::std::os::raw::c_uint;
773pub const J1939_NLA_PAD: ::std::os::raw::c_uint = 0;
774pub const J1939_NLA_BYTES_ACKED: ::std::os::raw::c_uint = 1;
775pub type _bindgen_ty_4 = ::std::os::raw::c_uint;
776pub const J1939_EE_INFO_NONE: ::std::os::raw::c_uint = 0;
777pub const J1939_EE_INFO_TX_ABORT: ::std::os::raw::c_uint = 1;
778pub type _bindgen_ty_5 = ::std::os::raw::c_uint;
779#[repr(C)]
780pub struct j1939_filter {
781 pub name: name_t,
782 pub name_mask: name_t,
783 pub pgn: pgn_t,
784 pub pgn_mask: pgn_t,
785 pub addr: __u8,
786 pub addr_mask: __u8,
787}
788#[test]
789fn bindgen_test_layout_j1939_filter() {
790 assert_eq!(
791 ::std::mem::size_of::<j1939_filter>(),
792 32usize,
793 concat!("Size of: ", stringify!(j1939_filter))
794 );
795 assert_eq!(
796 ::std::mem::align_of::<j1939_filter>(),
797 8usize,
798 concat!("Alignment of ", stringify!(j1939_filter))
799 );
800 assert_eq!(
801 unsafe { &(*(::std::ptr::null::<j1939_filter>())).name as *const _ as usize },
802 0usize,
803 concat!(
804 "Offset of field: ",
805 stringify!(j1939_filter),
806 "::",
807 stringify!(name)
808 )
809 );
810 assert_eq!(
811 unsafe { &(*(::std::ptr::null::<j1939_filter>())).name_mask as *const _ as usize },
812 8usize,
813 concat!(
814 "Offset of field: ",
815 stringify!(j1939_filter),
816 "::",
817 stringify!(name_mask)
818 )
819 );
820 assert_eq!(
821 unsafe { &(*(::std::ptr::null::<j1939_filter>())).pgn as *const _ as usize },
822 16usize,
823 concat!(
824 "Offset of field: ",
825 stringify!(j1939_filter),
826 "::",
827 stringify!(pgn)
828 )
829 );
830 assert_eq!(
831 unsafe { &(*(::std::ptr::null::<j1939_filter>())).pgn_mask as *const _ as usize },
832 20usize,
833 concat!(
834 "Offset of field: ",
835 stringify!(j1939_filter),
836 "::",
837 stringify!(pgn_mask)
838 )
839 );
840 assert_eq!(
841 unsafe { &(*(::std::ptr::null::<j1939_filter>())).addr as *const _ as usize },
842 24usize,
843 concat!(
844 "Offset of field: ",
845 stringify!(j1939_filter),
846 "::",
847 stringify!(addr)
848 )
849 );
850 assert_eq!(
851 unsafe { &(*(::std::ptr::null::<j1939_filter>())).addr_mask as *const _ as usize },
852 25usize,
853 concat!(
854 "Offset of field: ",
855 stringify!(j1939_filter),
856 "::",
857 stringify!(addr_mask)
858 )
859 );
860}
861#[repr(C)]
862pub struct can_bittiming {
863 pub bitrate: __u32,
864 pub sample_point: __u32,
865 pub tq: __u32,
866 pub prop_seg: __u32,
867 pub phase_seg1: __u32,
868 pub phase_seg2: __u32,
869 pub sjw: __u32,
870 pub brp: __u32,
871}
872#[test]
873fn bindgen_test_layout_can_bittiming() {
874 assert_eq!(
875 ::std::mem::size_of::<can_bittiming>(),
876 32usize,
877 concat!("Size of: ", stringify!(can_bittiming))
878 );
879 assert_eq!(
880 ::std::mem::align_of::<can_bittiming>(),
881 4usize,
882 concat!("Alignment of ", stringify!(can_bittiming))
883 );
884 assert_eq!(
885 unsafe { &(*(::std::ptr::null::<can_bittiming>())).bitrate as *const _ as usize },
886 0usize,
887 concat!(
888 "Offset of field: ",
889 stringify!(can_bittiming),
890 "::",
891 stringify!(bitrate)
892 )
893 );
894 assert_eq!(
895 unsafe { &(*(::std::ptr::null::<can_bittiming>())).sample_point as *const _ as usize },
896 4usize,
897 concat!(
898 "Offset of field: ",
899 stringify!(can_bittiming),
900 "::",
901 stringify!(sample_point)
902 )
903 );
904 assert_eq!(
905 unsafe { &(*(::std::ptr::null::<can_bittiming>())).tq as *const _ as usize },
906 8usize,
907 concat!(
908 "Offset of field: ",
909 stringify!(can_bittiming),
910 "::",
911 stringify!(tq)
912 )
913 );
914 assert_eq!(
915 unsafe { &(*(::std::ptr::null::<can_bittiming>())).prop_seg as *const _ as usize },
916 12usize,
917 concat!(
918 "Offset of field: ",
919 stringify!(can_bittiming),
920 "::",
921 stringify!(prop_seg)
922 )
923 );
924 assert_eq!(
925 unsafe { &(*(::std::ptr::null::<can_bittiming>())).phase_seg1 as *const _ as usize },
926 16usize,
927 concat!(
928 "Offset of field: ",
929 stringify!(can_bittiming),
930 "::",
931 stringify!(phase_seg1)
932 )
933 );
934 assert_eq!(
935 unsafe { &(*(::std::ptr::null::<can_bittiming>())).phase_seg2 as *const _ as usize },
936 20usize,
937 concat!(
938 "Offset of field: ",
939 stringify!(can_bittiming),
940 "::",
941 stringify!(phase_seg2)
942 )
943 );
944 assert_eq!(
945 unsafe { &(*(::std::ptr::null::<can_bittiming>())).sjw as *const _ as usize },
946 24usize,
947 concat!(
948 "Offset of field: ",
949 stringify!(can_bittiming),
950 "::",
951 stringify!(sjw)
952 )
953 );
954 assert_eq!(
955 unsafe { &(*(::std::ptr::null::<can_bittiming>())).brp as *const _ as usize },
956 28usize,
957 concat!(
958 "Offset of field: ",
959 stringify!(can_bittiming),
960 "::",
961 stringify!(brp)
962 )
963 );
964}
965#[repr(C)]
966pub struct can_bittiming_const {
967 pub name: [::std::os::raw::c_char; 16usize],
968 pub tseg1_min: __u32,
969 pub tseg1_max: __u32,
970 pub tseg2_min: __u32,
971 pub tseg2_max: __u32,
972 pub sjw_max: __u32,
973 pub brp_min: __u32,
974 pub brp_max: __u32,
975 pub brp_inc: __u32,
976}
977#[test]
978fn bindgen_test_layout_can_bittiming_const() {
979 assert_eq!(
980 ::std::mem::size_of::<can_bittiming_const>(),
981 48usize,
982 concat!("Size of: ", stringify!(can_bittiming_const))
983 );
984 assert_eq!(
985 ::std::mem::align_of::<can_bittiming_const>(),
986 4usize,
987 concat!("Alignment of ", stringify!(can_bittiming_const))
988 );
989 assert_eq!(
990 unsafe { &(*(::std::ptr::null::<can_bittiming_const>())).name as *const _ as usize },
991 0usize,
992 concat!(
993 "Offset of field: ",
994 stringify!(can_bittiming_const),
995 "::",
996 stringify!(name)
997 )
998 );
999 assert_eq!(
1000 unsafe { &(*(::std::ptr::null::<can_bittiming_const>())).tseg1_min as *const _ as usize },
1001 16usize,
1002 concat!(
1003 "Offset of field: ",
1004 stringify!(can_bittiming_const),
1005 "::",
1006 stringify!(tseg1_min)
1007 )
1008 );
1009 assert_eq!(
1010 unsafe { &(*(::std::ptr::null::<can_bittiming_const>())).tseg1_max as *const _ as usize },
1011 20usize,
1012 concat!(
1013 "Offset of field: ",
1014 stringify!(can_bittiming_const),
1015 "::",
1016 stringify!(tseg1_max)
1017 )
1018 );
1019 assert_eq!(
1020 unsafe { &(*(::std::ptr::null::<can_bittiming_const>())).tseg2_min as *const _ as usize },
1021 24usize,
1022 concat!(
1023 "Offset of field: ",
1024 stringify!(can_bittiming_const),
1025 "::",
1026 stringify!(tseg2_min)
1027 )
1028 );
1029 assert_eq!(
1030 unsafe { &(*(::std::ptr::null::<can_bittiming_const>())).tseg2_max as *const _ as usize },
1031 28usize,
1032 concat!(
1033 "Offset of field: ",
1034 stringify!(can_bittiming_const),
1035 "::",
1036 stringify!(tseg2_max)
1037 )
1038 );
1039 assert_eq!(
1040 unsafe { &(*(::std::ptr::null::<can_bittiming_const>())).sjw_max as *const _ as usize },
1041 32usize,
1042 concat!(
1043 "Offset of field: ",
1044 stringify!(can_bittiming_const),
1045 "::",
1046 stringify!(sjw_max)
1047 )
1048 );
1049 assert_eq!(
1050 unsafe { &(*(::std::ptr::null::<can_bittiming_const>())).brp_min as *const _ as usize },
1051 36usize,
1052 concat!(
1053 "Offset of field: ",
1054 stringify!(can_bittiming_const),
1055 "::",
1056 stringify!(brp_min)
1057 )
1058 );
1059 assert_eq!(
1060 unsafe { &(*(::std::ptr::null::<can_bittiming_const>())).brp_max as *const _ as usize },
1061 40usize,
1062 concat!(
1063 "Offset of field: ",
1064 stringify!(can_bittiming_const),
1065 "::",
1066 stringify!(brp_max)
1067 )
1068 );
1069 assert_eq!(
1070 unsafe { &(*(::std::ptr::null::<can_bittiming_const>())).brp_inc as *const _ as usize },
1071 44usize,
1072 concat!(
1073 "Offset of field: ",
1074 stringify!(can_bittiming_const),
1075 "::",
1076 stringify!(brp_inc)
1077 )
1078 );
1079}
1080#[repr(C)]
1081pub struct can_clock {
1082 pub freq: __u32,
1083}
1084#[test]
1085fn bindgen_test_layout_can_clock() {
1086 assert_eq!(
1087 ::std::mem::size_of::<can_clock>(),
1088 4usize,
1089 concat!("Size of: ", stringify!(can_clock))
1090 );
1091 assert_eq!(
1092 ::std::mem::align_of::<can_clock>(),
1093 4usize,
1094 concat!("Alignment of ", stringify!(can_clock))
1095 );
1096 assert_eq!(
1097 unsafe { &(*(::std::ptr::null::<can_clock>())).freq as *const _ as usize },
1098 0usize,
1099 concat!(
1100 "Offset of field: ",
1101 stringify!(can_clock),
1102 "::",
1103 stringify!(freq)
1104 )
1105 );
1106}
1107pub const can_state_CAN_STATE_ERROR_ACTIVE: can_state = 0;
1108pub const can_state_CAN_STATE_ERROR_WARNING: can_state = 1;
1109pub const can_state_CAN_STATE_ERROR_PASSIVE: can_state = 2;
1110pub const can_state_CAN_STATE_BUS_OFF: can_state = 3;
1111pub const can_state_CAN_STATE_STOPPED: can_state = 4;
1112pub const can_state_CAN_STATE_SLEEPING: can_state = 5;
1113pub const can_state_CAN_STATE_MAX: can_state = 6;
1114pub type can_state = ::std::os::raw::c_uint;
1115#[repr(C)]
1116pub struct can_berr_counter {
1117 pub txerr: __u16,
1118 pub rxerr: __u16,
1119}
1120#[test]
1121fn bindgen_test_layout_can_berr_counter() {
1122 assert_eq!(
1123 ::std::mem::size_of::<can_berr_counter>(),
1124 4usize,
1125 concat!("Size of: ", stringify!(can_berr_counter))
1126 );
1127 assert_eq!(
1128 ::std::mem::align_of::<can_berr_counter>(),
1129 2usize,
1130 concat!("Alignment of ", stringify!(can_berr_counter))
1131 );
1132 assert_eq!(
1133 unsafe { &(*(::std::ptr::null::<can_berr_counter>())).txerr as *const _ as usize },
1134 0usize,
1135 concat!(
1136 "Offset of field: ",
1137 stringify!(can_berr_counter),
1138 "::",
1139 stringify!(txerr)
1140 )
1141 );
1142 assert_eq!(
1143 unsafe { &(*(::std::ptr::null::<can_berr_counter>())).rxerr as *const _ as usize },
1144 2usize,
1145 concat!(
1146 "Offset of field: ",
1147 stringify!(can_berr_counter),
1148 "::",
1149 stringify!(rxerr)
1150 )
1151 );
1152}
1153#[repr(C)]
1154pub struct can_ctrlmode {
1155 pub mask: __u32,
1156 pub flags: __u32,
1157}
1158#[test]
1159fn bindgen_test_layout_can_ctrlmode() {
1160 assert_eq!(
1161 ::std::mem::size_of::<can_ctrlmode>(),
1162 8usize,
1163 concat!("Size of: ", stringify!(can_ctrlmode))
1164 );
1165 assert_eq!(
1166 ::std::mem::align_of::<can_ctrlmode>(),
1167 4usize,
1168 concat!("Alignment of ", stringify!(can_ctrlmode))
1169 );
1170 assert_eq!(
1171 unsafe { &(*(::std::ptr::null::<can_ctrlmode>())).mask as *const _ as usize },
1172 0usize,
1173 concat!(
1174 "Offset of field: ",
1175 stringify!(can_ctrlmode),
1176 "::",
1177 stringify!(mask)
1178 )
1179 );
1180 assert_eq!(
1181 unsafe { &(*(::std::ptr::null::<can_ctrlmode>())).flags as *const _ as usize },
1182 4usize,
1183 concat!(
1184 "Offset of field: ",
1185 stringify!(can_ctrlmode),
1186 "::",
1187 stringify!(flags)
1188 )
1189 );
1190}
1191#[repr(C)]
1192pub struct can_device_stats {
1193 pub bus_error: __u32,
1194 pub error_warning: __u32,
1195 pub error_passive: __u32,
1196 pub bus_off: __u32,
1197 pub arbitration_lost: __u32,
1198 pub restarts: __u32,
1199}
1200#[test]
1201fn bindgen_test_layout_can_device_stats() {
1202 assert_eq!(
1203 ::std::mem::size_of::<can_device_stats>(),
1204 24usize,
1205 concat!("Size of: ", stringify!(can_device_stats))
1206 );
1207 assert_eq!(
1208 ::std::mem::align_of::<can_device_stats>(),
1209 4usize,
1210 concat!("Alignment of ", stringify!(can_device_stats))
1211 );
1212 assert_eq!(
1213 unsafe { &(*(::std::ptr::null::<can_device_stats>())).bus_error as *const _ as usize },
1214 0usize,
1215 concat!(
1216 "Offset of field: ",
1217 stringify!(can_device_stats),
1218 "::",
1219 stringify!(bus_error)
1220 )
1221 );
1222 assert_eq!(
1223 unsafe { &(*(::std::ptr::null::<can_device_stats>())).error_warning as *const _ as usize },
1224 4usize,
1225 concat!(
1226 "Offset of field: ",
1227 stringify!(can_device_stats),
1228 "::",
1229 stringify!(error_warning)
1230 )
1231 );
1232 assert_eq!(
1233 unsafe { &(*(::std::ptr::null::<can_device_stats>())).error_passive as *const _ as usize },
1234 8usize,
1235 concat!(
1236 "Offset of field: ",
1237 stringify!(can_device_stats),
1238 "::",
1239 stringify!(error_passive)
1240 )
1241 );
1242 assert_eq!(
1243 unsafe { &(*(::std::ptr::null::<can_device_stats>())).bus_off as *const _ as usize },
1244 12usize,
1245 concat!(
1246 "Offset of field: ",
1247 stringify!(can_device_stats),
1248 "::",
1249 stringify!(bus_off)
1250 )
1251 );
1252 assert_eq!(
1253 unsafe {
1254 &(*(::std::ptr::null::<can_device_stats>())).arbitration_lost as *const _ as usize
1255 },
1256 16usize,
1257 concat!(
1258 "Offset of field: ",
1259 stringify!(can_device_stats),
1260 "::",
1261 stringify!(arbitration_lost)
1262 )
1263 );
1264 assert_eq!(
1265 unsafe { &(*(::std::ptr::null::<can_device_stats>())).restarts as *const _ as usize },
1266 20usize,
1267 concat!(
1268 "Offset of field: ",
1269 stringify!(can_device_stats),
1270 "::",
1271 stringify!(restarts)
1272 )
1273 );
1274}
1275pub const IFLA_CAN_UNSPEC: ::std::os::raw::c_uint = 0;
1276pub const IFLA_CAN_BITTIMING: ::std::os::raw::c_uint = 1;
1277pub const IFLA_CAN_BITTIMING_CONST: ::std::os::raw::c_uint = 2;
1278pub const IFLA_CAN_CLOCK: ::std::os::raw::c_uint = 3;
1279pub const IFLA_CAN_STATE: ::std::os::raw::c_uint = 4;
1280pub const IFLA_CAN_CTRLMODE: ::std::os::raw::c_uint = 5;
1281pub const IFLA_CAN_RESTART_MS: ::std::os::raw::c_uint = 6;
1282pub const IFLA_CAN_RESTART: ::std::os::raw::c_uint = 7;
1283pub const IFLA_CAN_BERR_COUNTER: ::std::os::raw::c_uint = 8;
1284pub const IFLA_CAN_DATA_BITTIMING: ::std::os::raw::c_uint = 9;
1285pub const IFLA_CAN_DATA_BITTIMING_CONST: ::std::os::raw::c_uint = 10;
1286pub const IFLA_CAN_TERMINATION: ::std::os::raw::c_uint = 11;
1287pub const IFLA_CAN_TERMINATION_CONST: ::std::os::raw::c_uint = 12;
1288pub const IFLA_CAN_BITRATE_CONST: ::std::os::raw::c_uint = 13;
1289pub const IFLA_CAN_DATA_BITRATE_CONST: ::std::os::raw::c_uint = 14;
1290pub const IFLA_CAN_BITRATE_MAX: ::std::os::raw::c_uint = 15;
1291pub const __IFLA_CAN_MAX: ::std::os::raw::c_uint = 16;
1292pub type _bindgen_ty_6 = ::std::os::raw::c_uint;
1293pub const CAN_RAW_FILTER: ::std::os::raw::c_uint = 1;
1294pub const CAN_RAW_ERR_FILTER: ::std::os::raw::c_uint = 2;
1295pub const CAN_RAW_LOOPBACK: ::std::os::raw::c_uint = 3;
1296pub const CAN_RAW_RECV_OWN_MSGS: ::std::os::raw::c_uint = 4;
1297pub const CAN_RAW_FD_FRAMES: ::std::os::raw::c_uint = 5;
1298pub const CAN_RAW_JOIN_FILTERS: ::std::os::raw::c_uint = 6;
1299pub type _bindgen_ty_7 = ::std::os::raw::c_uint;
1300pub const VXCAN_INFO_UNSPEC: ::std::os::raw::c_uint = 0;
1301pub const VXCAN_INFO_PEER: ::std::os::raw::c_uint = 1;
1302pub const __VXCAN_INFO_MAX: ::std::os::raw::c_uint = 2;
1303pub type _bindgen_ty_8 = ::std::os::raw::c_uint;