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
extern crate libc;
use std::str;
use error::Error;
pub mod sys {
#[repr(C)]
pub struct virStream {}
pub type virStreamPtr = *mut virStream;
}
#[link(name = "virt")]
extern "C" {
fn virStreamSend(c: sys::virStreamPtr,
data: *const libc::c_char,
nbytes: libc::c_uint)
-> libc::c_int;
fn virStreamRecv(c: sys::virStreamPtr,
data: *mut libc::c_char,
nbytes: libc::c_uint)
-> libc::c_int;
fn virStreamFree(c: sys::virStreamPtr) -> libc::c_int;
fn virStreamAbort(c: sys::virStreamPtr) -> libc::c_int;
fn virStreamFinish(c: sys::virStreamPtr) -> libc::c_int;
}
pub type StreamEventType = self::libc::c_uint;
pub const VIR_STREAM_EVENT_READABLE: StreamEventType = (1 << 0);
pub const VIR_STREAM_EVENT_WRITABLE: StreamEventType = (1 << 1);
pub const VIR_STREAM_EVENT_ERROR: StreamEventType = (1 << 2);
pub const VIR_STREAM_EVENT_HANGUP: StreamEventType = (1 << 3);
#[derive(Debug)]
pub struct Stream {
ptr: Option<sys::virStreamPtr>,
}
impl Drop for Stream {
fn drop(&mut self) {
if self.ptr.is_some() {
if let Err(e) = self.free() {
panic!("Unable to drop memory for Stream, code {}, message: {}",
e.code,
e.message)
}
}
}
}
impl Stream {
pub fn new(ptr: sys::virStreamPtr) -> Stream {
Stream { ptr: Some(ptr) }
}
pub fn as_ptr(&self) -> sys::virStreamPtr {
self.ptr.unwrap()
}
pub fn free(&mut self) -> Result<(), Error> {
unsafe {
if virStreamFree(self.as_ptr()) == -1 {
return Err(Error::new());
}
self.ptr = None;
return Ok(());
}
}
pub fn finish(self) -> Result<(), Error> {
unsafe {
if virStreamFinish(self.as_ptr()) == -1 {
return Err(Error::new());
}
return Ok(());
}
}
pub fn abort(self) -> Result<(), Error> {
unsafe {
if virStreamAbort(self.as_ptr()) == -1 {
return Err(Error::new());
}
return Ok(());
}
}
pub fn send(&self, data: &str) -> Result<u32, Error> {
unsafe {
let ret = virStreamSend(self.as_ptr(),
string_to_c_chars!(data),
data.len() as libc::c_uint);
if ret == -1 {
return Err(Error::new());
}
return Ok(ret as u32);
}
}
pub fn recv(&self, size: u32) -> Result<String, Error> {
unsafe {
let mut data: [libc::c_char; 2048] = ['\0' as i8; 2048];
let ret = virStreamRecv(self.as_ptr(), data.as_mut_ptr(), size as libc::c_uint);
if ret == -1 {
return Err(Error::new());
}
return Ok(c_chars_to_string!(data.as_ptr()));
}
}
}