1pub const LIRC_INET_PORT: u32 = 8765;
4pub const LIRC_DRIVER_DEVICE: &[u8; 12usize] = b"/dev/lirc/0\0";
5pub const LIRCDOLDCFGFILE: &[u8; 16usize] = b"/etc/lircd.conf\0";
6pub const LIRCMDOLDCFGFILE: &[u8; 17usize] = b"/etc/lircmd.conf\0";
7pub const LIRCRC_USER_FILE: &[u8; 8usize] = b".lircrc\0";
8pub const LIRCRC_OLD_ROOT_FILE: &[u8; 12usize] = b"/etc/lircrc\0";
9pub const LIRC_RELEASE_SUFFIX: &[u8; 6usize] = b"_EVUP\0";
10pub const LIRC_OPTIONS_PATH: &[u8; 28usize] = b"/etc/lirc/lirc_options.conf\0";
11pub const LIRC_OPTIONS_VAR: &[u8; 18usize] = b"LIRC_OPTIONS_PATH\0";
12pub const LIRC_EOF: u32 = 134217728;
13pub const LIRC_RET_SUCCESS: u32 = 0;
14pub const LIRC_RET_ERROR: i32 = -1;
15pub type size_t = ::std::os::raw::c_uint;
16
17#[repr(C)]
18#[derive(Debug, Copy, Clone)]
19pub struct lirc_list {
20 pub string: *mut ::std::os::raw::c_char,
21 pub next: *mut lirc_list,
22}
23
24#[test]
25fn bindgen_test_layout_lirc_list() {
26 assert_eq!(
27 ::std::mem::size_of::<lirc_list>(),
28 16usize,
29 concat!("Size of: ", stringify!(lirc_list))
30 );
31 assert_eq!(
32 ::std::mem::align_of::<lirc_list>(),
33 8usize,
34 concat!("Alignment of ", stringify!(lirc_list))
35 );
36 fn test_field_string() {
37 assert_eq!(
38 unsafe {
39 let uninit = ::std::mem::MaybeUninit::<lirc_list>::uninit();
40 let ptr = uninit.as_ptr();
41 ::std::ptr::addr_of!((*ptr).string) as usize - ptr as usize
42 },
43 0usize,
44 concat!(
45 "Offset of field: ",
46 stringify!(lirc_list),
47 "::",
48 stringify!(string)
49 )
50 );
51 }
52 test_field_string();
53 fn test_field_next() {
54 assert_eq!(
55 unsafe {
56 let uninit = ::std::mem::MaybeUninit::<lirc_list>::uninit();
57 let ptr = uninit.as_ptr();
58 ::std::ptr::addr_of!((*ptr).next) as usize - ptr as usize
59 },
60 8usize,
61 concat!(
62 "Offset of field: ",
63 stringify!(lirc_list),
64 "::",
65 stringify!(next)
66 )
67 );
68 }
69 test_field_next();
70}
71
72#[repr(C)]
73#[derive(Debug, Copy, Clone)]
74pub struct lirc_code {
75 pub remote: *mut ::std::os::raw::c_char,
76 pub button: *mut ::std::os::raw::c_char,
77 pub next: *mut lirc_code,
78}
79
80#[test]
81fn bindgen_test_layout_lirc_code() {
82 assert_eq!(
83 ::std::mem::size_of::<lirc_code>(),
84 24usize,
85 concat!("Size of: ", stringify!(lirc_code))
86 );
87 assert_eq!(
88 ::std::mem::align_of::<lirc_code>(),
89 8usize,
90 concat!("Alignment of ", stringify!(lirc_code))
91 );
92 fn test_field_remote() {
93 assert_eq!(
94 unsafe {
95 let uninit = ::std::mem::MaybeUninit::<lirc_code>::uninit();
96 let ptr = uninit.as_ptr();
97 ::std::ptr::addr_of!((*ptr).remote) as usize - ptr as usize
98 },
99 0usize,
100 concat!(
101 "Offset of field: ",
102 stringify!(lirc_code),
103 "::",
104 stringify!(remote)
105 )
106 );
107 }
108 test_field_remote();
109 fn test_field_button() {
110 assert_eq!(
111 unsafe {
112 let uninit = ::std::mem::MaybeUninit::<lirc_code>::uninit();
113 let ptr = uninit.as_ptr();
114 ::std::ptr::addr_of!((*ptr).button) as usize - ptr as usize
115 },
116 8usize,
117 concat!(
118 "Offset of field: ",
119 stringify!(lirc_code),
120 "::",
121 stringify!(button)
122 )
123 );
124 }
125 test_field_button();
126 fn test_field_next() {
127 assert_eq!(
128 unsafe {
129 let uninit = ::std::mem::MaybeUninit::<lirc_code>::uninit();
130 let ptr = uninit.as_ptr();
131 ::std::ptr::addr_of!((*ptr).next) as usize - ptr as usize
132 },
133 16usize,
134 concat!(
135 "Offset of field: ",
136 stringify!(lirc_code),
137 "::",
138 stringify!(next)
139 )
140 );
141 }
142 test_field_next();
143}
144
145#[repr(C)]
146#[derive(Debug, Copy, Clone)]
147pub struct lirc_config {
148 pub lircrc_class: *mut ::std::os::raw::c_char,
149 pub current_mode: *mut ::std::os::raw::c_char,
150 pub next: *mut lirc_config_entry,
151 pub first: *mut lirc_config_entry,
152 pub sockfd: ::std::os::raw::c_int,
153}
154
155#[test]
156fn bindgen_test_layout_lirc_config() {
157 assert_eq!(
158 ::std::mem::size_of::<lirc_config>(),
159 40usize,
160 concat!("Size of: ", stringify!(lirc_config))
161 );
162 assert_eq!(
163 ::std::mem::align_of::<lirc_config>(),
164 8usize,
165 concat!("Alignment of ", stringify!(lirc_config))
166 );
167 fn test_field_lircrc_class() {
168 assert_eq!(
169 unsafe {
170 let uninit = ::std::mem::MaybeUninit::<lirc_config>::uninit();
171 let ptr = uninit.as_ptr();
172 ::std::ptr::addr_of!((*ptr).lircrc_class) as usize - ptr as usize
173 },
174 0usize,
175 concat!(
176 "Offset of field: ",
177 stringify!(lirc_config),
178 "::",
179 stringify!(lircrc_class)
180 )
181 );
182 }
183 test_field_lircrc_class();
184 fn test_field_current_mode() {
185 assert_eq!(
186 unsafe {
187 let uninit = ::std::mem::MaybeUninit::<lirc_config>::uninit();
188 let ptr = uninit.as_ptr();
189 ::std::ptr::addr_of!((*ptr).current_mode) as usize - ptr as usize
190 },
191 8usize,
192 concat!(
193 "Offset of field: ",
194 stringify!(lirc_config),
195 "::",
196 stringify!(current_mode)
197 )
198 );
199 }
200 test_field_current_mode();
201 fn test_field_next() {
202 assert_eq!(
203 unsafe {
204 let uninit = ::std::mem::MaybeUninit::<lirc_config>::uninit();
205 let ptr = uninit.as_ptr();
206 ::std::ptr::addr_of!((*ptr).next) as usize - ptr as usize
207 },
208 16usize,
209 concat!(
210 "Offset of field: ",
211 stringify!(lirc_config),
212 "::",
213 stringify!(next)
214 )
215 );
216 }
217 test_field_next();
218 fn test_field_first() {
219 assert_eq!(
220 unsafe {
221 let uninit = ::std::mem::MaybeUninit::<lirc_config>::uninit();
222 let ptr = uninit.as_ptr();
223 ::std::ptr::addr_of!((*ptr).first) as usize - ptr as usize
224 },
225 24usize,
226 concat!(
227 "Offset of field: ",
228 stringify!(lirc_config),
229 "::",
230 stringify!(first)
231 )
232 );
233 }
234 test_field_first();
235 fn test_field_sockfd() {
236 assert_eq!(
237 unsafe {
238 let uninit = ::std::mem::MaybeUninit::<lirc_config>::uninit();
239 let ptr = uninit.as_ptr();
240 ::std::ptr::addr_of!((*ptr).sockfd) as usize - ptr as usize
241 },
242 32usize,
243 concat!(
244 "Offset of field: ",
245 stringify!(lirc_config),
246 "::",
247 stringify!(sockfd)
248 )
249 );
250 }
251 test_field_sockfd();
252}
253#[repr(C)]
254#[derive(Debug, Copy, Clone)]
255pub struct lirc_config_entry {
256 pub prog: *mut ::std::os::raw::c_char,
257 pub code: *mut lirc_code,
258 pub rep_delay: ::std::os::raw::c_uint,
259 pub ign_first_events: ::std::os::raw::c_uint,
260 pub rep: ::std::os::raw::c_uint,
261 pub config: *mut lirc_list,
262 pub change_mode: *mut ::std::os::raw::c_char,
263 pub flags: ::std::os::raw::c_uint,
264 pub mode: *mut ::std::os::raw::c_char,
265 pub next_config: *mut lirc_list,
266 pub next_code: *mut lirc_code,
267 pub next: *mut lirc_config_entry,
268}
269
270#[test]
271fn bindgen_test_layout_lirc_config_entry() {
272 assert_eq!(
273 ::std::mem::size_of::<lirc_config_entry>(),
274 88usize,
275 concat!("Size of: ", stringify!(lirc_config_entry))
276 );
277 assert_eq!(
278 ::std::mem::align_of::<lirc_config_entry>(),
279 8usize,
280 concat!("Alignment of ", stringify!(lirc_config_entry))
281 );
282 fn test_field_prog() {
283 assert_eq!(
284 unsafe {
285 let uninit = ::std::mem::MaybeUninit::<lirc_config_entry>::uninit();
286 let ptr = uninit.as_ptr();
287 ::std::ptr::addr_of!((*ptr).prog) as usize - ptr as usize
288 },
289 0usize,
290 concat!(
291 "Offset of field: ",
292 stringify!(lirc_config_entry),
293 "::",
294 stringify!(prog)
295 )
296 );
297 }
298 test_field_prog();
299 fn test_field_code() {
300 assert_eq!(
301 unsafe {
302 let uninit = ::std::mem::MaybeUninit::<lirc_config_entry>::uninit();
303 let ptr = uninit.as_ptr();
304 ::std::ptr::addr_of!((*ptr).code) as usize - ptr as usize
305 },
306 8usize,
307 concat!(
308 "Offset of field: ",
309 stringify!(lirc_config_entry),
310 "::",
311 stringify!(code)
312 )
313 );
314 }
315 test_field_code();
316 fn test_field_rep_delay() {
317 assert_eq!(
318 unsafe {
319 let uninit = ::std::mem::MaybeUninit::<lirc_config_entry>::uninit();
320 let ptr = uninit.as_ptr();
321 ::std::ptr::addr_of!((*ptr).rep_delay) as usize - ptr as usize
322 },
323 16usize,
324 concat!(
325 "Offset of field: ",
326 stringify!(lirc_config_entry),
327 "::",
328 stringify!(rep_delay)
329 )
330 );
331 }
332 test_field_rep_delay();
333 fn test_field_ign_first_events() {
334 assert_eq!(
335 unsafe {
336 let uninit = ::std::mem::MaybeUninit::<lirc_config_entry>::uninit();
337 let ptr = uninit.as_ptr();
338 ::std::ptr::addr_of!((*ptr).ign_first_events) as usize - ptr as usize
339 },
340 20usize,
341 concat!(
342 "Offset of field: ",
343 stringify!(lirc_config_entry),
344 "::",
345 stringify!(ign_first_events)
346 )
347 );
348 }
349 test_field_ign_first_events();
350 fn test_field_rep() {
351 assert_eq!(
352 unsafe {
353 let uninit = ::std::mem::MaybeUninit::<lirc_config_entry>::uninit();
354 let ptr = uninit.as_ptr();
355 ::std::ptr::addr_of!((*ptr).rep) as usize - ptr as usize
356 },
357 24usize,
358 concat!(
359 "Offset of field: ",
360 stringify!(lirc_config_entry),
361 "::",
362 stringify!(rep)
363 )
364 );
365 }
366 test_field_rep();
367 fn test_field_config() {
368 assert_eq!(
369 unsafe {
370 let uninit = ::std::mem::MaybeUninit::<lirc_config_entry>::uninit();
371 let ptr = uninit.as_ptr();
372 ::std::ptr::addr_of!((*ptr).config) as usize - ptr as usize
373 },
374 32usize,
375 concat!(
376 "Offset of field: ",
377 stringify!(lirc_config_entry),
378 "::",
379 stringify!(config)
380 )
381 );
382 }
383 test_field_config();
384 fn test_field_change_mode() {
385 assert_eq!(
386 unsafe {
387 let uninit = ::std::mem::MaybeUninit::<lirc_config_entry>::uninit();
388 let ptr = uninit.as_ptr();
389 ::std::ptr::addr_of!((*ptr).change_mode) as usize - ptr as usize
390 },
391 40usize,
392 concat!(
393 "Offset of field: ",
394 stringify!(lirc_config_entry),
395 "::",
396 stringify!(change_mode)
397 )
398 );
399 }
400 test_field_change_mode();
401 fn test_field_flags() {
402 assert_eq!(
403 unsafe {
404 let uninit = ::std::mem::MaybeUninit::<lirc_config_entry>::uninit();
405 let ptr = uninit.as_ptr();
406 ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize
407 },
408 48usize,
409 concat!(
410 "Offset of field: ",
411 stringify!(lirc_config_entry),
412 "::",
413 stringify!(flags)
414 )
415 );
416 }
417 test_field_flags();
418 fn test_field_mode() {
419 assert_eq!(
420 unsafe {
421 let uninit = ::std::mem::MaybeUninit::<lirc_config_entry>::uninit();
422 let ptr = uninit.as_ptr();
423 ::std::ptr::addr_of!((*ptr).mode) as usize - ptr as usize
424 },
425 56usize,
426 concat!(
427 "Offset of field: ",
428 stringify!(lirc_config_entry),
429 "::",
430 stringify!(mode)
431 )
432 );
433 }
434 test_field_mode();
435 fn test_field_next_config() {
436 assert_eq!(
437 unsafe {
438 let uninit = ::std::mem::MaybeUninit::<lirc_config_entry>::uninit();
439 let ptr = uninit.as_ptr();
440 ::std::ptr::addr_of!((*ptr).next_config) as usize - ptr as usize
441 },
442 64usize,
443 concat!(
444 "Offset of field: ",
445 stringify!(lirc_config_entry),
446 "::",
447 stringify!(next_config)
448 )
449 );
450 }
451 test_field_next_config();
452 fn test_field_next_code() {
453 assert_eq!(
454 unsafe {
455 let uninit = ::std::mem::MaybeUninit::<lirc_config_entry>::uninit();
456 let ptr = uninit.as_ptr();
457 ::std::ptr::addr_of!((*ptr).next_code) as usize - ptr as usize
458 },
459 72usize,
460 concat!(
461 "Offset of field: ",
462 stringify!(lirc_config_entry),
463 "::",
464 stringify!(next_code)
465 )
466 );
467 }
468 test_field_next_code();
469 fn test_field_next() {
470 assert_eq!(
471 unsafe {
472 let uninit = ::std::mem::MaybeUninit::<lirc_config_entry>::uninit();
473 let ptr = uninit.as_ptr();
474 ::std::ptr::addr_of!((*ptr).next) as usize - ptr as usize
475 },
476 80usize,
477 concat!(
478 "Offset of field: ",
479 stringify!(lirc_config_entry),
480 "::",
481 stringify!(next)
482 )
483 );
484 }
485 test_field_next();
486}
487
488#[repr(C)]
489#[derive(Debug, Copy, Clone)]
490pub struct lirc_cmd_ctx {
491 pub packet: [::std::os::raw::c_char; 257usize],
492 pub buffer: [::std::os::raw::c_char; 257usize],
493 pub reply: [::std::os::raw::c_char; 257usize],
494 pub head: ::std::os::raw::c_int,
495 pub reply_to_stdout: ::std::os::raw::c_int,
496 pub next: *mut ::std::os::raw::c_char,
497}
498
499#[test]
500fn bindgen_test_layout_lirc_cmd_ctx() {
501 assert_eq!(
502 ::std::mem::size_of::<lirc_cmd_ctx>(),
503 792usize,
504 concat!("Size of: ", stringify!(lirc_cmd_ctx))
505 );
506 assert_eq!(
507 ::std::mem::align_of::<lirc_cmd_ctx>(),
508 8usize,
509 concat!("Alignment of ", stringify!(lirc_cmd_ctx))
510 );
511 fn test_field_packet() {
512 assert_eq!(
513 unsafe {
514 let uninit = ::std::mem::MaybeUninit::<lirc_cmd_ctx>::uninit();
515 let ptr = uninit.as_ptr();
516 ::std::ptr::addr_of!((*ptr).packet) as usize - ptr as usize
517 },
518 0usize,
519 concat!(
520 "Offset of field: ",
521 stringify!(lirc_cmd_ctx),
522 "::",
523 stringify!(packet)
524 )
525 );
526 }
527 test_field_packet();
528 fn test_field_buffer() {
529 assert_eq!(
530 unsafe {
531 let uninit = ::std::mem::MaybeUninit::<lirc_cmd_ctx>::uninit();
532 let ptr = uninit.as_ptr();
533 ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize
534 },
535 257usize,
536 concat!(
537 "Offset of field: ",
538 stringify!(lirc_cmd_ctx),
539 "::",
540 stringify!(buffer)
541 )
542 );
543 }
544 test_field_buffer();
545 fn test_field_reply() {
546 assert_eq!(
547 unsafe {
548 let uninit = ::std::mem::MaybeUninit::<lirc_cmd_ctx>::uninit();
549 let ptr = uninit.as_ptr();
550 ::std::ptr::addr_of!((*ptr).reply) as usize - ptr as usize
551 },
552 514usize,
553 concat!(
554 "Offset of field: ",
555 stringify!(lirc_cmd_ctx),
556 "::",
557 stringify!(reply)
558 )
559 );
560 }
561 test_field_reply();
562 fn test_field_head() {
563 assert_eq!(
564 unsafe {
565 let uninit = ::std::mem::MaybeUninit::<lirc_cmd_ctx>::uninit();
566 let ptr = uninit.as_ptr();
567 ::std::ptr::addr_of!((*ptr).head) as usize - ptr as usize
568 },
569 772usize,
570 concat!(
571 "Offset of field: ",
572 stringify!(lirc_cmd_ctx),
573 "::",
574 stringify!(head)
575 )
576 );
577 }
578 test_field_head();
579 fn test_field_reply_to_stdout() {
580 assert_eq!(
581 unsafe {
582 let uninit = ::std::mem::MaybeUninit::<lirc_cmd_ctx>::uninit();
583 let ptr = uninit.as_ptr();
584 ::std::ptr::addr_of!((*ptr).reply_to_stdout) as usize - ptr as usize
585 },
586 776usize,
587 concat!(
588 "Offset of field: ",
589 stringify!(lirc_cmd_ctx),
590 "::",
591 stringify!(reply_to_stdout)
592 )
593 );
594 }
595 test_field_reply_to_stdout();
596 fn test_field_next() {
597 assert_eq!(
598 unsafe {
599 let uninit = ::std::mem::MaybeUninit::<lirc_cmd_ctx>::uninit();
600 let ptr = uninit.as_ptr();
601 ::std::ptr::addr_of!((*ptr).next) as usize - ptr as usize
602 },
603 784usize,
604 concat!(
605 "Offset of field: ",
606 stringify!(lirc_cmd_ctx),
607 "::",
608 stringify!(next)
609 )
610 );
611 }
612 test_field_next();
613}
614
615extern "C" {
616 pub fn lirc_init(prog: *const ::std::os::raw::c_char, verbose: u32) -> i32;
617
618 pub fn lirc_deinit() -> ::std::os::raw::c_int;
619
620 pub fn lirc_readconfig(
621 path: *const std::os::raw::c_char,
622 config: *mut *mut lirc_config,
623 check: ::std::option::Option<
624 unsafe extern "C" fn(s: *mut ::std::os::raw::c_char) -> ::std::os::raw::c_int,
625 >,
626 ) -> ::std::os::raw::c_int;
627
628 pub fn lirc_freeconfig(config: *mut lirc_config);
629
630 pub fn lirc_nextcode(code: *mut *mut ::std::os::raw::c_char) -> ::std::os::raw::c_int;
631
632 pub fn lirc_code2char(
633 config: *mut lirc_config,
634 code: *mut u8,
635 string: *mut *mut u8,
636 ) -> ::std::os::raw::c_int;
637
638 pub fn lirc_get_local_socket(
639 path: *const ::std::os::raw::c_char,
640 quiet: ::std::os::raw::c_int,
641 ) -> ::std::os::raw::c_int;
642
643 #[deprecated]
644 pub fn lirc_nextir() -> *mut ::std::os::raw::c_char;
645
646 #[deprecated]
647 pub fn lirc_ir2char(
648 config: *mut lirc_config,
649 code: *mut ::std::os::raw::c_char,
650 ) -> *mut ::std::os::raw::c_char;
651
652 pub fn lirc_readconfig_only(
653 file: *const ::std::os::raw::c_char,
654 config: *mut *mut lirc_config,
655 check: ::std::option::Option<
656 unsafe extern "C" fn(s: *mut ::std::os::raw::c_char) -> ::std::os::raw::c_int,
657 >,
658 ) -> ::std::os::raw::c_int;
659
660 pub fn lirc_code2charprog(
661 config: *mut lirc_config,
662 code: *mut ::std::os::raw::c_char,
663 string: *mut *mut ::std::os::raw::c_char,
664 prog: *mut *mut ::std::os::raw::c_char,
665 ) -> ::std::os::raw::c_int;
666
667 pub fn lirc_getsocketname(
668 id: *const ::std::os::raw::c_char,
669 buf: *mut ::std::os::raw::c_char,
670 size: size_t,
671 ) -> size_t;
672
673 pub fn lirc_getmode(config: *mut lirc_config) -> *const ::std::os::raw::c_char;
674
675 pub fn lirc_setmode(
676 config: *mut lirc_config,
677 mode: *const ::std::os::raw::c_char,
678 ) -> *const ::std::os::raw::c_char;
679 pub fn lirc_command_init(
680 ctx: *mut lirc_cmd_ctx,
681 fmt: *const ::std::os::raw::c_char,
682 ...
683 ) -> ::std::os::raw::c_int;
684
685 pub fn lirc_command_run(
686 ctx: *mut lirc_cmd_ctx,
687 fd: ::std::os::raw::c_int,
688 ) -> ::std::os::raw::c_int;
689
690 pub fn lirc_command_reply_to_stdout(ctx: *mut lirc_cmd_ctx);
691
692 pub fn lirc_send_one(
693 fd: ::std::os::raw::c_int,
694 remote: *const ::std::os::raw::c_char,
695 keysym: *const ::std::os::raw::c_char,
696 ) -> ::std::os::raw::c_int;
697
698 pub fn lirc_simulate(
699 fd: ::std::os::raw::c_int,
700 remote: *const ::std::os::raw::c_char,
701 keysym: *const ::std::os::raw::c_char,
702 scancode: ::std::os::raw::c_int,
703 repeat: ::std::os::raw::c_int,
704 ) -> ::std::os::raw::c_int;
705
706 pub fn lirc_get_remote_socket(
707 address: *const ::std::os::raw::c_char,
708 port: ::std::os::raw::c_int,
709 quiet: ::std::os::raw::c_int,
710 ) -> ::std::os::raw::c_int;
711}