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
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
|
use libc;
use std::error;
use std::ffi::NulError;
use std::fmt;
use std::io;
use std::ptr::null_mut;
use std::str;
use {raw, Session};
/// Representation of an error that can occur within libssh2
#[derive(Debug)]
#[allow(missing_copy_implementations)]
pub struct Error {
code: libc::c_int,
msg: &'static str,
}
impl Error {
#[doc(hidden)]
pub fn last_error_raw(raw: *mut raw::LIBSSH2_SESSION) -> Option<Error> {
static STATIC: () = ();
unsafe {
let mut msg = 0 as *mut _;
let rc = raw::libssh2_session_last_error(raw, &mut msg, 0 as *mut _, 0);
if rc == 0 {
return None;
}
let s = ::opt_bytes(&STATIC, msg).unwrap();
Some(Error::new(rc, str::from_utf8(s).unwrap()))
}
}
/// Given a libssh2 error return code, generate an Error object that
/// encapsulates that error code and the error reason.
/// The error reason is extracted from the Session and is used if the
/// session contains the same error code as that provided.
/// If the error code doesn't match then an approximation of the error
/// reason is used instead of the error message stored in the Session.
pub fn from_session_error(sess: &Session, rc: libc::c_int) -> Error {
Self::from_session_error_raw(sess.raw(), rc)
}
#[doc(hidden)]
pub fn from_session_error_raw(raw: *mut raw::LIBSSH2_SESSION, rc: libc::c_int) -> Error {
static STATIC: () = ();
unsafe {
let mut msg = null_mut();
let res = raw::libssh2_session_last_error(raw, &mut msg, null_mut(), 0);
if res != rc {
return Self::from_errno(rc);
}
let s = ::opt_bytes(&STATIC, msg).unwrap();
Error::new(rc, str::from_utf8(s).unwrap())
}
}
/// Generate the last error that occurred for a `Session`.
///
/// Returns `None` if there was no last error.
pub fn last_error(sess: &Session) -> Option<Error> {
Self::last_error_raw(sess.raw())
}
/// Create a new error for the given code and message
pub fn new(code: libc::c_int, msg: &'static str) -> Error {
Error {
code: code,
msg: msg,
}
}
/// Generate an error that represents EOF
pub fn eof() -> Error {
Error::new(raw::LIBSSH2_ERROR_CHANNEL_EOF_SENT, "end of file")
}
/// Generate an error for unknown failure
pub fn unknown() -> Error {
Error::new(libc::c_int::min_value(), "no other error listed")
}
/// Construct an error from an error code from libssh2
pub fn from_errno(code: libc::c_int) -> Error {
let msg = match code {
raw::LIBSSH2_ERROR_BANNER_RECV => "banner recv failure",
raw::LIBSSH2_ERROR_BANNER_SEND => "banner send failure",
raw::LIBSSH2_ERROR_INVALID_MAC => "invalid mac",
raw::LIBSSH2_ERROR_KEX_FAILURE => "kex failure",
raw::LIBSSH2_ERROR_ALLOC => "alloc failure",
raw::LIBSSH2_ERROR_SOCKET_SEND => "socket send faiulre",
raw::LIBSSH2_ERROR_KEY_EXCHANGE_FAILURE => "key exchange failure",
raw::LIBSSH2_ERROR_TIMEOUT => "timed out",
raw::LIBSSH2_ERROR_HOSTKEY_INIT => "hostkey init error",
raw::LIBSSH2_ERROR_HOSTKEY_SIGN => "hostkey sign error",
raw::LIBSSH2_ERROR_DECRYPT => "decrypt error",
raw::LIBSSH2_ERROR_SOCKET_DISCONNECT => "socket disconnected",
raw::LIBSSH2_ERROR_PROTO => "protocol error",
raw::LIBSSH2_ERROR_PASSWORD_EXPIRED => "password expired",
raw::LIBSSH2_ERROR_FILE => "file error",
raw::LIBSSH2_ERROR_METHOD_NONE => "bad method name",
raw::LIBSSH2_ERROR_AUTHENTICATION_FAILED => "authentication failed",
raw::LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED => "public key unverified",
raw::LIBSSH2_ERROR_CHANNEL_OUTOFORDER => "channel out of order",
raw::LIBSSH2_ERROR_CHANNEL_FAILURE => "channel failure",
raw::LIBSSH2_ERROR_CHANNEL_REQUEST_DENIED => "request denied",
raw::LIBSSH2_ERROR_CHANNEL_UNKNOWN => "unknown channel error",
raw::LIBSSH2_ERROR_CHANNEL_WINDOW_EXCEEDED => "window exceeded",
raw::LIBSSH2_ERROR_CHANNEL_PACKET_EXCEEDED => "packet exceeded",
raw::LIBSSH2_ERROR_CHANNEL_CLOSED => "closed channel",
raw::LIBSSH2_ERROR_CHANNEL_EOF_SENT => "eof sent",
raw::LIBSSH2_ERROR_SCP_PROTOCOL => "scp protocol error",
raw::LIBSSH2_ERROR_ZLIB => "zlib error",
raw::LIBSSH2_ERROR_SOCKET_TIMEOUT => "socket timeout",
raw::LIBSSH2_ERROR_SFTP_PROTOCOL => "sftp protocol error",
raw::LIBSSH2_ERROR_REQUEST_DENIED => "request denied",
raw::LIBSSH2_ERROR_METHOD_NOT_SUPPORTED => "method not supported",
raw::LIBSSH2_ERROR_INVAL => "invalid",
raw::LIBSSH2_ERROR_INVALID_POLL_TYPE => "invalid poll type",
raw::LIBSSH2_ERROR_PUBLICKEY_PROTOCOL => "public key protocol error",
raw::LIBSSH2_ERROR_EAGAIN => "operation would block",
raw::LIBSSH2_ERROR_BUFFER_TOO_SMALL => "buffer too small",
raw::LIBSSH2_ERROR_BAD_USE => "bad use error",
raw::LIBSSH2_ERROR_COMPRESS => "compression error",
raw::LIBSSH2_ERROR_OUT_OF_BOUNDARY => "out of bounds",
raw::LIBSSH2_ERROR_AGENT_PROTOCOL => "invalid agent protocol",
raw::LIBSSH2_ERROR_SOCKET_RECV => "error receiving on socket",
raw::LIBSSH2_ERROR_ENCRYPT => "bad encrypt",
raw::LIBSSH2_ERROR_BAD_SOCKET => "bad socket",
raw::LIBSSH2_ERROR_KNOWN_HOSTS => "known hosts error",
raw::LIBSSH2_FX_EOF => "end of file",
raw::LIBSSH2_FX_NO_SUCH_FILE => "no such file",
raw::LIBSSH2_FX_PERMISSION_DENIED => "permission denied",
raw::LIBSSH2_FX_FAILURE => "failure",
raw::LIBSSH2_FX_BAD_MESSAGE => "bad message",
raw::LIBSSH2_FX_NO_CONNECTION => "no connection",
raw::LIBSSH2_FX_CONNECTION_LOST => "connection lost",
raw::LIBSSH2_FX_OP_UNSUPPORTED => "operation unsupported",
raw::LIBSSH2_FX_INVALID_HANDLE => "invalid handle",
raw::LIBSSH2_FX_NO_SUCH_PATH => "no such path",
raw::LIBSSH2_FX_FILE_ALREADY_EXISTS => "file already exists",
raw::LIBSSH2_FX_WRITE_PROTECT => "file is write protected",
raw::LIBSSH2_FX_NO_MEDIA => "no media available",
raw::LIBSSH2_FX_NO_SPACE_ON_FILESYSTEM => "no space on filesystem",
raw::LIBSSH2_FX_QUOTA_EXCEEDED => "quota exceeded",
raw::LIBSSH2_FX_UNKNOWN_PRINCIPAL => "unknown principal",
raw::LIBSSH2_FX_LOCK_CONFLICT => "lock conflict",
raw::LIBSSH2_FX_DIR_NOT_EMPTY => "directory not empty",
raw::LIBSSH2_FX_NOT_A_DIRECTORY => "not a directory",
raw::LIBSSH2_FX_INVALID_FILENAME => "invalid filename",
raw::LIBSSH2_FX_LINK_LOOP => "link loop",
_ => "unknown error",
};
Error::new(code, msg)
}
/// Get the message corresponding to this error
pub fn message(&self) -> &str {
self.msg
}
/// Return the code for this error
pub fn code(&self) -> libc::c_int {
self.code
}
}
impl From<Error> for io::Error {
fn from(err: Error) -> io::Error {
let kind = match err.code {
raw::LIBSSH2_ERROR_EAGAIN => io::ErrorKind::WouldBlock,
raw::LIBSSH2_ERROR_TIMEOUT => io::ErrorKind::TimedOut,
_ => io::ErrorKind::Other,
};
io::Error::new(kind, err.msg)
}
}
impl fmt::Display for Error {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "[{}] {}", self.code, self.msg)
}
}
impl error::Error for Error {
fn description(&self) -> &str {
self.message()
}
}
impl From<NulError> for Error {
fn from(_: NulError) -> Error {
Error::new(
raw::LIBSSH2_ERROR_INVAL,
"provided data contained a nul byte and could not be used \
as as string",
)
}
}
|
