1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
#![allow(non_upper_case_globals)]
#![allow(non_camel_case_types)]
#![allow(non_snake_case)]
use std::{ffi::{CString}, mem::MaybeUninit};
include!("./bindings.rs");
pub fn readconfig(_path: Option<&str>) -> Result<lirc_config, i32> {
unsafe {
let mut raw = MaybeUninit::uninit();
let ret = lirc_readconfig(std::ptr::null(), raw.as_mut_ptr(), None);
if ret != 0 {
return Err(ret);
}
Ok(std::ptr::read(raw.assume_init()))
}
}
pub fn readconfig_only(_file: Option<&str>) -> Result<lirc_config, i32> {
unsafe {
let mut raw = MaybeUninit::uninit();
let ret = lirc_readconfig_only(std::ptr::null(), raw.as_mut_ptr(), None);
if ret == -1 {
return Err(-ret);
}
Ok(std::ptr::read(raw.assume_init()))
}
}
pub fn freeconfig(mut conf: lirc_config) {
unsafe {
lirc_freeconfig(&mut conf);
}
}
#[must_use]
pub fn init(prog: &str, verbose: u32) -> i32{
unsafe {
let prog_str = CString::new(prog).unwrap();
lirc_init(prog_str.as_ptr(), verbose)
}
}
#[must_use]
pub fn deinit() -> i32{
unsafe {
lirc_deinit()
}
}
pub fn send_one(fd: i32, remote: &str, key: &str) -> i32 {
unsafe {
let r = std::ffi::CString::new(remote).unwrap();
let k = std::ffi::CString::new(key).unwrap();
lirc_send_one(fd, r.as_ptr(), k.as_ptr())
}
}
pub fn nextcode() -> Result<String, i32> {
unsafe {
let mut str_buf = MaybeUninit::uninit();
let ret = lirc_nextcode(str_buf.as_mut_ptr());
if ret != 0 {
return Err(ret);
}
let r = std::ffi::CStr::from_ptr(str_buf.assume_init()).to_str();
Ok(String::from(r.unwrap()))
}
}
pub fn code2char(mut conf: lirc_config, code: &mut str) -> Result<String, i32> {
unsafe {
let mut c = MaybeUninit::uninit();
let ret = lirc_code2char(&mut conf, code.as_mut_ptr(), c.as_mut_ptr());
if ret != 0 {
return Err(ret);
}
let a = std::ffi::CStr::from_ptr(c.assume_init() as *mut ::std::os::raw::c_char).to_str();
Ok(String::from(a.unwrap()))
}
}
pub fn get_local_socket(path: &str, quiet: bool) -> Result<i32, i32> {
unsafe {
let q = if quiet { 1 } else { 0 };
let p = std::ffi::CString::new(path).unwrap();
let r = lirc_get_local_socket(p.as_ptr(), q);
if r < 0 {
return Err(r);
}
Ok(r)
}
}
pub fn get_remote_socket(host: &str, port: i32, quiet: bool) -> Result<i32, i32> {
unsafe {
let q: i32 = if quiet { 1 } else { 0 };
let h = std::ffi::CString::new(host).unwrap();
let r = lirc_get_remote_socket(h.as_ptr(), port, q);
if r < 0 {
return Err(r);
}
Ok(r)
}
}
pub fn set_mode(conf: &mut lirc_config, mode: &str) -> String {
unsafe {
let m = std::ffi::CString::new(mode).unwrap();
let ret = lirc_setmode(conf, m.as_ptr());
let ret_str = std::ffi::CStr::from_ptr(ret);
ret_str.to_str().unwrap().to_string()
}
}
