Debian Codegraph @

src/protocol.rs

raw
1 //! Pure SFTP wire-protocol codec: types, request builders, response parsers.
2 //!
3 //! No I/O. No transport. Bytes in, bytes out. Shared by the sync and async
4 //! client implementations.
5
6 #![allow(dead_code)]
7
8 use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt};
9 use std::io::{Cursor, Read, Seek, SeekFrom, Write};
10
11 #[derive(Debug)]
12 pub enum Error {
13 Io(std::io::Error),
14 Utf8(std::str::Utf8Error),
15 Other(u32, String, String),
16 Eof(String, String),
17 NoSuchFile(String, String),
18 PermissionDenied(String, String),
19 Failure(String, String),
20 BadMessage(String, String),
21 NoConnection(String, String),
22 ConnectionLost(String, String),
23 OpUnsupported(String, String),
24 InvalidHandle(String, String),
25 NoSuchPath(String, String),
26 FileAlreadyExists(String, String),
27 WriteProtect(String, String),
28 NoMedia(String, String),
29 NoSpaceOnFilesystem(String, String),
30 QuotaExceeded(String, String),
31 UnknownPrincipal(String, String),
32 LockConflict(String, String),
33 DirNotEmpty(String, String),
34 NotADirectory(String, String),
35 InvalidFilename(String, String),
36 LinkLoop(String, String),
37 CannotDelete(String, String),
38 InvalidParameter(String, String),
39 FileIsADirectory(String, String),
40 ByteRangeLockConflict(String, String),
41 ByteRangeLockRefused(String, String),
42 DeletePending(String, String),
43 FileCorrupt(String, String),
44 OwnerInvalid(String, String),
45 GroupInvalid(String, String),
46 NoMatchingByteRangeLock(String, String),
47 }
48
49 impl From<std::io::Error> for Error {
50 fn from(err: std::io::Error) -> Self {
51 Error::Io(err)
52 }
53 }
54
55 impl From<std::str::Utf8Error> for Error {
56 fn from(err: std::str::Utf8Error) -> Self {
57 Error::Utf8(err)
58 }
59 }
60
61 impl From<Error> for std::io::Error {
62 fn from(err: Error) -> Self {
63 match err {
64 Error::Io(err) => err,
65 Error::Eof(_, _) => std::io::Error::new(std::io::ErrorKind::UnexpectedEof, ""),
66 Error::NoSuchFile(_, m) => std::io::Error::new(std::io::ErrorKind::NotFound, m),
67 Error::PermissionDenied(_, m) => {
68 std::io::Error::new(std::io::ErrorKind::PermissionDenied, m)
69 }
70 Error::NoConnection(_, m) => std::io::Error::new(std::io::ErrorKind::NotConnected, m),
71 Error::ConnectionLost(_, m) => {
72 std::io::Error::new(std::io::ErrorKind::ConnectionReset, m)
73 }
74 Error::InvalidHandle(_, m) => std::io::Error::new(std::io::ErrorKind::InvalidInput, m),
75 Error::NoSuchPath(_, m) => std::io::Error::new(std::io::ErrorKind::NotFound, m),
76 Error::FileAlreadyExists(_, m) => {
77 std::io::Error::new(std::io::ErrorKind::AlreadyExists, m)
78 }
79 Error::WriteProtect(_, m) => {
80 std::io::Error::new(std::io::ErrorKind::PermissionDenied, m)
81 }
82 Error::NoMedia(_, m) => std::io::Error::new(std::io::ErrorKind::NotFound, m),
83 Error::QuotaExceeded(_, m) => {
84 std::io::Error::new(std::io::ErrorKind::PermissionDenied, m)
85 }
86 Error::LockConflict(_, m) => {
87 std::io::Error::new(std::io::ErrorKind::PermissionDenied, m)
88 }
89 Error::InvalidFilename(_, m) => {
90 std::io::Error::new(std::io::ErrorKind::InvalidInput, m)
91 }
92 _ => std::io::Error::other(format!("{:?}", err)),
93 }
94 }
95 }
96
97 pub type Result<R> = std::result::Result<R, Error>;
98
99 pub const SSH_FILEXFER_ATTR_SIZE: u32 = 0x00000001;
100 pub const SSH_FILEXFER_ATTR_UIDGID: u32 = 0x00000002;
101 pub const SSH_FILEXFER_ATTR_PERMISSIONS: u32 = 0x00000004;
102 pub const SSH_FILEXFER_ATTR_ACCESSTIME: u32 = 0x00000008;
103 pub const SSH_FILEXFER_ATTR_CREATETIME: u32 = 0x00000010;
104 pub const SSH_FILEXFER_ATTR_MODIFYTIME: u32 = 0x00000020;
105 pub const SSH_FILEXFER_ATTR_ACL: u32 = 0x00000040;
106 pub const SSH_FILEXFER_ATTR_OWNERGROUP: u32 = 0x00000080;
107 pub const SSH_FILEXFER_ATTR_SUBSECOND_TIMES: u32 = 0x00000100;
108 pub const SSH_FILEXFER_ATTR_BITS: u32 = 0x00000200;
109 pub const SSH_FILEXFER_ATTR_ALLOCATION_SIZE: u32 = 0x00000400;
110 pub const SSH_FILEXFER_ATTR_TEXT_HINT: u32 = 0x00000800;
111 pub const SSH_FILEXFER_ATTR_MIME_TYPE: u32 = 0x00001000;
112 pub const SSH_FILEXFER_ATTR_LINK_COUNT: u32 = 0x00002000;
113 pub const SSH_FILEXFER_ATTR_UNTRANSLATED_NAME: u32 = 0x00004000;
114 pub const SSH_FILEXFER_ATTR_CTIME: u32 = 0x00008000;
115 pub const SSH_FILEXFER_ATTR_EXTENDED: u32 = 0x80000000;
116
117 const SSH_FILEXFER_ATTR_KNOWN_TEXT: u8 = 0x00;
118 const SSH_FILEXFER_ATTR_GUESSED_TEXT: u8 = 0x01;
119 const SSH_FILEXFER_ATTR_KNOWN_BINARY: u8 = 0x02;
120 const SSH_FILEXFER_ATTR_GUESSED_BINARY: u8 = 0x03;
121
122 #[derive(Clone, Copy, PartialEq, Eq, Debug)]
123 pub enum TextHint {
124 KnownText,
125 GuessedText,
126 KnownBinary,
127 GuessedBinary,
128 }
129
130 impl From<TextHint> for u8 {
131 fn from(hint: TextHint) -> Self {
132 match hint {
133 TextHint::KnownText => SSH_FILEXFER_ATTR_KNOWN_TEXT,
134 TextHint::GuessedText => SSH_FILEXFER_ATTR_GUESSED_TEXT,
135 TextHint::KnownBinary => SSH_FILEXFER_ATTR_KNOWN_BINARY,
136 TextHint::GuessedBinary => SSH_FILEXFER_ATTR_GUESSED_BINARY,
137 }
138 }
139 }
140
141 impl From<u8> for TextHint {
142 fn from(hint: u8) -> Self {
143 match hint {
144 SSH_FILEXFER_ATTR_KNOWN_TEXT => TextHint::KnownText,
145 SSH_FILEXFER_ATTR_GUESSED_TEXT => TextHint::GuessedText,
146 SSH_FILEXFER_ATTR_KNOWN_BINARY => TextHint::KnownBinary,
147 SSH_FILEXFER_ATTR_GUESSED_BINARY => TextHint::GuessedBinary,
148 _ => panic!("Invalid text hint"),
149 }
150 }
151 }
152
153 pub const SSH_FILEXFER_ATTR_FLAGS_READONLY: u32 = 0x00000001;
154 pub const SSH_FILEXFER_ATTR_FLAGS_SYSTEM: u32 = 0x00000002;
155 pub const SSH_FILEXFER_ATTR_FLAGS_HIDDEN: u32 = 0x00000004;
156 pub const SSH_FILEXFER_ATTR_FLAGS_CASE_INSENSITIVE: u32 = 0x00000008;
157 pub const SSH_FILEXFER_ATTR_FLAGS_ARCHIVE: u32 = 0x00000010;
158 pub const SSH_FILEXFER_ATTR_FLAGS_ENCRYPTED: u32 = 0x00000020;
159 pub const SSH_FILEXFER_ATTR_FLAGS_COMPRESSED: u32 = 0x00000040;
160 pub const SSH_FILEXFER_ATTR_FLAGS_SPARSE: u32 = 0x00000080;
161 pub const SSH_FILEXFER_ATTR_FLAGS_APPEND_ONLY: u32 = 0x00000100;
162 pub const SSH_FILEXFER_ATTR_FLAGS_IMMUTABLE: u32 = 0x00000200;
163 pub const SSH_FILEXFER_ATTR_FLAGS_SYNC: u32 = 0x00000400;
164 pub const SSH_FILEXFER_ATTR_FLAGS_TRANSLATION_ERR: u32 = 0x00000800;
165
166 const SSH_FILEXFER_TYPE_REGULAR: u8 = 1;
167 const SSH_FILEXFER_TYPE_DIRECTORY: u8 = 2;
168 const SSH_FILEXFER_TYPE_SYMLINK: u8 = 3;
169 const SSH_FILEXFER_TYPE_SPECIAL: u8 = 4;
170 const SSH_FILEXFER_TYPE_UNKNOWN: u8 = 5;
171 const SSH_FILEXFER_TYPE_SOCKET: u8 = 6;
172 const SSH_FILEXFER_TYPE_CHAR_DEVICE: u8 = 7;
173 const SSH_FILEXFER_TYPE_BLOCK_DEVICE: u8 = 8;
174 const SSH_FILEXFER_TYPE_FIFO: u8 = 9;
175
176 #[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
177 pub enum Kind {
178 Regular,
179 Directory,
180 Symlink,
181 Special,
182 #[default]
183 Unknown,
184 Socket,
185 CharDevice,
186 BlockDevice,
187 Fifo,
188 }
189
190 impl From<Kind> for u8 {
191 fn from(val: Kind) -> Self {
192 match val {
193 Kind::Regular => SSH_FILEXFER_TYPE_REGULAR,
194 Kind::Directory => SSH_FILEXFER_TYPE_DIRECTORY,
195 Kind::Symlink => SSH_FILEXFER_TYPE_SYMLINK,
196 Kind::Special => SSH_FILEXFER_TYPE_SPECIAL,
197 Kind::Unknown => SSH_FILEXFER_TYPE_UNKNOWN,
198 Kind::Socket => SSH_FILEXFER_TYPE_SOCKET,
199 Kind::CharDevice => SSH_FILEXFER_TYPE_CHAR_DEVICE,
200 Kind::BlockDevice => SSH_FILEXFER_TYPE_BLOCK_DEVICE,
201 Kind::Fifo => SSH_FILEXFER_TYPE_FIFO,
202 }
203 }
204 }
205
206 impl From<u8> for Kind {
207 fn from(kind: u8) -> Self {
208 match kind {
209 SSH_FILEXFER_TYPE_REGULAR => Kind::Regular,
210 SSH_FILEXFER_TYPE_DIRECTORY => Kind::Directory,
211 SSH_FILEXFER_TYPE_SYMLINK => Kind::Symlink,
212 SSH_FILEXFER_TYPE_SPECIAL => Kind::Special,
213 SSH_FILEXFER_TYPE_UNKNOWN => Kind::Unknown,
214 SSH_FILEXFER_TYPE_SOCKET => Kind::Socket,
215 SSH_FILEXFER_TYPE_CHAR_DEVICE => Kind::CharDevice,
216 SSH_FILEXFER_TYPE_BLOCK_DEVICE => Kind::BlockDevice,
217 SSH_FILEXFER_TYPE_FIFO => Kind::Fifo,
218 f => panic!("Unknown file type {}", f),
219 }
220 }
221 }
222
223 pub const SSH_FXP_INIT: u8 = 1;
224 pub const SSH_FXP_VERSION: u8 = 2;
225 pub const SSH_FXP_OPEN: u8 = 3;
226 pub const SSH_FXP_CLOSE: u8 = 4;
227 pub const SSH_FXP_READ: u8 = 5;
228 pub const SSH_FXP_WRITE: u8 = 6;
229 pub const SSH_FXP_LSTAT: u8 = 7;
230 pub const SSH_FXP_FSTAT: u8 = 8;
231 pub const SSH_FXP_SETSTAT: u8 = 9;
232 pub const SSH_FXP_FSETSTAT: u8 = 10;
233 pub const SSH_FXP_OPENDIR: u8 = 11;
234 pub const SSH_FXP_READDIR: u8 = 12;
235 pub const SSH_FXP_REMOVE: u8 = 13;
236 pub const SSH_FXP_MKDIR: u8 = 14;
237 pub const SSH_FXP_RMDIR: u8 = 15;
238 pub const SSH_FXP_REALPATH: u8 = 16;
239 pub const SSH_FXP_STAT: u8 = 17;
240 pub const SSH_FXP_RENAME: u8 = 18;
241 pub const SSH_FXP_READLINK: u8 = 19;
242 pub const SSH_FXP_SYMLINK: u8 = 20;
243 pub const SSH_FXP_LINK: u8 = 21;
244 pub const SSH_FXP_BLOCK: u8 = 22;
245 pub const SSH_FXP_UNBLOCK: u8 = 23;
246 pub const SSH_FXP_STATUS: u8 = 101;
247 pub const SSH_FXP_HANDLE: u8 = 102;
248 pub const SSH_FXP_DATA: u8 = 103;
249 pub const SSH_FXP_NAME: u8 = 104;
250 pub const SSH_FXP_ATTRS: u8 = 105;
251 pub const SSH_FXP_EXTENDED: u8 = 200;
252 pub const SSH_FXP_EXTENDED_REPLY: u8 = 201;
253
254 pub const SSH_FX_OK: u32 = 0;
255 pub const SSH_FX_EOF: u32 = 1;
256 pub const SSH_FX_NO_SUCH_FILE: u32 = 2;
257 pub const SSH_FX_PERMISSION_DENIED: u32 = 3;
258 pub const SSH_FX_FAILURE: u32 = 4;
259 pub const SSH_FX_BAD_MESSAGE: u32 = 5;
260 pub const SSH_FX_NO_CONNECTION: u32 = 6;
261 pub const SSH_FX_CONNECTION_LOST: u32 = 7;
262 pub const SSH_FX_OP_UNSUPPORTED: u32 = 8;
263 pub const SSH_FX_INVALID_HANDLE: u32 = 9;
264 pub const SSH_FX_NO_SUCH_PATH: u32 = 10;
265 pub const SSH_FX_FILE_ALREADY_EXISTS: u32 = 11;
266 pub const SSH_FX_WRITE_PROTECT: u32 = 12;
267 pub const SSH_FX_NO_MEDIA: u32 = 13;
268 pub const SSH_FX_NO_SPACE_ON_FILESYSTEM: u32 = 14;
269 pub const SSH_FX_QUOTA_EXCEEDED: u32 = 15;
270 pub const SSH_FX_UNKNOWN_PRINCIPAL: u32 = 16;
271 pub const SSH_FX_LOCK_CONFLICT: u32 = 17;
272 pub const SSH_FX_DIR_NOT_EMPTY: u32 = 18;
273 pub const SSH_FX_NOT_A_DIRECTORY: u32 = 19;
274 pub const SSH_FX_INVALID_FILENAME: u32 = 20;
275 pub const SSH_FX_LINK_LOOP: u32 = 21;
276 pub const SSH_FX_CANNOT_DELETE: u32 = 22;
277 pub const SSH_FX_INVALID_PARAMETER: u32 = 23;
278 pub const SSH_FX_FILE_IS_A_DIRECTORY: u32 = 24;
279 pub const SSH_FX_BYTE_RANGE_LOCK_CONFLICT: u32 = 25;
280 pub const SSH_FX_BYTE_RANGE_LOCK_REFUSED: u32 = 26;
281 pub const SSH_FX_DELETE_PENDING: u32 = 27;
282 pub const SSH_FX_FILE_CORRUPT: u32 = 28;
283 pub const SSH_FX_OWNER_INVALID: u32 = 29;
284 pub const SSH_FX_GROUP_INVALID: u32 = 30;
285 pub const SSH_FX_NO_MATCHING_BYTE_RANGE_LOCK: u32 = 31;
286
287 pub const SFTP_FLAG_READ: u32 = 0x00000001;
288 pub const SFTP_FLAG_WRITE: u32 = 0x00000002;
289 pub const SFTP_FLAG_APPEND: u32 = 0x00000004;
290 pub const SFTP_FLAG_CREAT: u32 = 0x00000008;
291 pub const SFTP_FLAG_TRUNC: u32 = 0x00000010;
292 pub const SFTP_FLAG_EXCL: u32 = 0x00000020;
293
294 #[derive(Debug, PartialEq, Eq, Clone, Copy, Default)]
295 pub struct OpenOptions(u32);
296
297 impl OpenOptions {
298 pub fn new() -> OpenOptions {
299 OpenOptions(0)
300 }
301
302 pub fn read(mut self, read: bool) -> OpenOptions {
303 if read {
304 self.0 |= SFTP_FLAG_READ;
305 } else {
306 self.0 &= !SFTP_FLAG_READ;
307 }
308 self
309 }
310
311 pub fn write(mut self, write: bool) -> OpenOptions {
312 if write {
313 self.0 |= SFTP_FLAG_WRITE;
314 } else {
315 self.0 &= !SFTP_FLAG_WRITE;
316 }
317 self
318 }
319
320 pub fn append(mut self, append: bool) -> OpenOptions {
321 if append {
322 self.0 |= SFTP_FLAG_APPEND;
323 } else {
324 self.0 &= !SFTP_FLAG_APPEND;
325 }
326 self
327 }
328
329 pub fn create(mut self, create: bool) -> OpenOptions {
330 if create {
331 self.0 |= SFTP_FLAG_CREAT;
332 } else {
333 self.0 &= !SFTP_FLAG_CREAT;
334 }
335 self
336 }
337
338 pub fn truncate(mut self, truncate: bool) -> OpenOptions {
339 if truncate {
340 self.0 |= SFTP_FLAG_TRUNC;
341 } else {
342 self.0 &= !SFTP_FLAG_TRUNC;
343 }
344 self
345 }
346
347 pub fn excl(mut self, excl: bool) -> OpenOptions {
348 if excl {
349 self.0 |= SFTP_FLAG_EXCL;
350 } else {
351 self.0 &= !SFTP_FLAG_EXCL;
352 }
353 self
354 }
355
356 pub fn mode(&mut self, mode: u32) -> &mut OpenOptions {
357 self.0 |= mode;
358 self
359 }
360
361 pub fn get(&self) -> u32 {
362 self.0
363 }
364 }
365
366 pub const SSH_FXF_RENAME_OVERWRITE: u32 = 0x00000001;
367 pub const SSH_FXF_RENAME_ATOMIC: u32 = 0x00000002;
368 pub const SSH_FXF_RENAME_NATIVE: u32 = 0x00000004;
369
370 pub const SSH_FXF_ACCESS_DISPOSITION: u32 = 0x00000007;
371 pub const SSH_FXF_CREATE_NEW: u32 = 0x00000000;
372 pub const SSH_FXF_CREATE_TRUNCATE: u32 = 0x00000001;
373 pub const SSH_FXF_OPEN_EXISTING: u32 = 0x00000002;
374 pub const SSH_FXF_OPEN_OR_CREATE: u32 = 0x00000003;
375 pub const SSH_FXF_TRUNCATE_EXISTING: u32 = 0x00000004;
376 pub const SSH_FXF_APPEND_DATA: u32 = 0x00000008;
377 pub const SSH_FXF_APPEND_DATA_ATOMIC: u32 = 0x00000010;
378 pub const SSH_FXF_TEXT_MODE: u32 = 0x00000020;
379 pub const SSH_FXF_BLOCK_READ: u32 = 0x00000040;
380 pub const SSH_FXF_BLOCK_WRITE: u32 = 0x00000080;
381 pub const SSH_FXF_BLOCK_DELETE: u32 = 0x00000100;
382 pub const SSH_FXF_BLOCK_ADVISORY: u32 = 0x00000200;
383 pub const SSH_FXF_NOFOLLOW: u32 = 0x00000400;
384 pub const SSH_FXF_DELETE_ON_CLOSE: u32 = 0x00000800;
385 pub const SSH_FXF_ACCESS_AUDIT_ALARM_INFO: u32 = 0x00001000;
386 pub const SSH_FXF_ACCESS_BACKUP: u32 = 0x00002000;
387 pub const SSH_FXF_BACKUP_STREAM: u32 = 0x00004000;
388 pub const SSH_FXF_OVERRIDE_OWNER: u32 = 0x00008000;
389
390 #[derive(Debug, PartialEq, Eq, Clone, Default)]
391 pub struct Attributes {
392 pub size: Option<u64>,
393 pub uid: Option<u32>,
394 pub gid: Option<u32>,
395 pub allocation_size: Option<u64>,
396 pub owner: Option<String>,
397 pub group: Option<String>,
398 pub permissions: Option<u32>,
399 pub access_time: Option<(u64, Option<u32>)>,
400 pub create_time: Option<(u64, Option<u32>)>,
401 pub modify_time: Option<(u64, Option<u32>)>,
402 pub ctime: Option<(u64, Option<u32>)>,
403 pub acl: Option<Vec<u8>>,
404 pub attrib_bits: Option<u32>,
405 pub attrib_bits_valid: Option<u32>,
406 pub text_hint: Option<TextHint>,
407 pub mime_type: Option<String>,
408 pub link_count: Option<u32>,
409 pub untranslated_name: Option<Vec<u8>>,
410 pub extended: Option<Vec<(String, String)>>,
411 }
412
413 impl Attributes {
414 pub fn new() -> Self {
415 Self::default()
416 }
417
418 pub fn serialize(&self) -> std::io::Result<Vec<u8>> {
419 let mut valid_attribute_flags: u32 = 0;
420 let buf = Vec::new();
421 let mut writer = Cursor::new(buf);
422 writer.write_u32::<BigEndian>(valid_attribute_flags)?;
423
424 if let Some(size) = self.size {
425 writer.write_u64::<BigEndian>(size)?;
426 valid_attribute_flags |= SSH_FILEXFER_ATTR_SIZE;
427 }
428 if let Some(uid) = self.uid {
429 writer.write_u32::<BigEndian>(uid)?;
430 valid_attribute_flags |= SSH_FILEXFER_ATTR_UIDGID;
431 }
432 if let Some(gid) = self.gid {
433 writer.write_u32::<BigEndian>(gid)?;
434 assert!(valid_attribute_flags & SSH_FILEXFER_ATTR_UIDGID != 0);
435 } else {
436 assert!(valid_attribute_flags & SSH_FILEXFER_ATTR_UIDGID == 0);
437 }
438 if let Some(allocation_size) = self.allocation_size {
439 writer.write_u64::<BigEndian>(allocation_size)?;
440 valid_attribute_flags |= SSH_FILEXFER_ATTR_ALLOCATION_SIZE;
441 }
442 if let Some(owner) = self.owner.as_ref() {
443 writer.write_u32::<BigEndian>(owner.len() as u32)?;
444 writer.write_all(owner.as_bytes())?;
445 valid_attribute_flags |= SSH_FILEXFER_ATTR_OWNERGROUP;
446 }
447 if let Some(group) = self.group.as_ref() {
448 writer.write_u32::<BigEndian>(group.len() as u32)?;
449 writer.write_all(group.as_bytes())?;
450 valid_attribute_flags |= SSH_FILEXFER_ATTR_OWNERGROUP;
451 }
452 if let Some(permissions) = self.permissions {
453 writer.write_u32::<BigEndian>(permissions)?;
454 valid_attribute_flags |= SSH_FILEXFER_ATTR_PERMISSIONS;
455 }
456 if let Some(access_time) = self.access_time {
457 writer.write_u64::<BigEndian>(access_time.0)?;
458 if let Some(ns) = access_time.1 {
459 writer.write_u32::<BigEndian>(ns)?;
460 valid_attribute_flags |= SSH_FILEXFER_ATTR_SUBSECOND_TIMES;
461 }
462 valid_attribute_flags |= SSH_FILEXFER_ATTR_ACCESSTIME;
463 }
464 if let Some(create_time) = self.create_time {
465 writer.write_u64::<BigEndian>(create_time.0)?;
466 if let Some(ns) = create_time.1 {
467 assert!(valid_attribute_flags & SSH_FILEXFER_ATTR_SUBSECOND_TIMES != 0);
468 writer.write_u32::<BigEndian>(ns)?;
469 } else {
470 assert!(valid_attribute_flags & SSH_FILEXFER_ATTR_SUBSECOND_TIMES == 0);
471 }
472 valid_attribute_flags |= SSH_FILEXFER_ATTR_CREATETIME;
473 }
474 if let Some(modify_time) = self.modify_time {
475 writer.write_u64::<BigEndian>(modify_time.0)?;
476 if let Some(ns) = modify_time.1 {
477 assert!(valid_attribute_flags & SSH_FILEXFER_ATTR_SUBSECOND_TIMES != 0);
478 writer.write_u32::<BigEndian>(ns)?;
479 } else {
480 assert!(valid_attribute_flags & SSH_FILEXFER_ATTR_SUBSECOND_TIMES == 0);
481 }
482 valid_attribute_flags |= SSH_FILEXFER_ATTR_MODIFYTIME;
483 }
484 if let Some(ctime) = self.ctime {
485 writer.write_u64::<BigEndian>(ctime.0)?;
486 if let Some(ns) = ctime.1 {
487 assert!(valid_attribute_flags & SSH_FILEXFER_ATTR_SUBSECOND_TIMES != 0);
488 writer.write_u32::<BigEndian>(ns)?;
489 } else {
490 assert!(valid_attribute_flags & SSH_FILEXFER_ATTR_SUBSECOND_TIMES == 0);
491 }
492 valid_attribute_flags |= SSH_FILEXFER_ATTR_CTIME;
493 }
494 if let Some(acl) = self.acl.as_ref() {
495 writer.write_u32::<BigEndian>(acl.len() as u32)?;
496 writer.write_all(acl.as_slice())?;
497 valid_attribute_flags |= SSH_FILEXFER_ATTR_ACL;
498 }
499 if let Some(attrib_bits) = self.attrib_bits {
500 writer.write_u32::<BigEndian>(attrib_bits)?;
501 valid_attribute_flags |= SSH_FILEXFER_ATTR_BITS;
502 }
503 if let Some(attrib_bits_valid) = self.attrib_bits_valid {
504 writer.write_u32::<BigEndian>(attrib_bits_valid)?;
505 valid_attribute_flags |= SSH_FILEXFER_ATTR_BITS;
506 }
507 if let Some(text_hint) = self.text_hint {
508 writer.write_u8(text_hint.into())?;
509 valid_attribute_flags |= SSH_FILEXFER_ATTR_TEXT_HINT;
510 }
511 if let Some(mime_type) = self.mime_type.as_ref() {
512 writer.write_u32::<BigEndian>(mime_type.len() as u32)?;
513 writer.write_all(mime_type.as_bytes())?;
514 valid_attribute_flags |= SSH_FILEXFER_ATTR_MIME_TYPE;
515 }
516 if let Some(link_count) = self.link_count {
517 writer.write_u32::<BigEndian>(link_count)?;
518 valid_attribute_flags |= SSH_FILEXFER_ATTR_LINK_COUNT;
519 }
520 if let Some(untranslated_name) = self.untranslated_name.as_ref() {
521 writer.write_u32::<BigEndian>(untranslated_name.len() as u32)?;
522 writer.write_all(untranslated_name.as_slice())?;
523 valid_attribute_flags |= SSH_FILEXFER_ATTR_UNTRANSLATED_NAME;
524 }
525 if let Some(extended) = self.extended.as_ref() {
526 writer.write_u32::<BigEndian>(extended.len() as u32)?;
527 for (key, value) in extended.iter() {
528 writer.write_u32::<BigEndian>(key.len() as u32)?;
529 writer.write_all(key.as_bytes())?;
530 writer.write_u32::<BigEndian>(value.len() as u32)?;
531 writer.write_all(value.as_bytes())?;
532 }
533 valid_attribute_flags |= SSH_FILEXFER_ATTR_EXTENDED;
534 }
535
536 writer.seek(SeekFrom::Start(0))?;
537 writer.write_u32::<BigEndian>(valid_attribute_flags)?;
538 Ok(writer.into_inner())
539 }
540
541 pub fn deserialize(reader: &mut Cursor<&[u8]>) -> std::io::Result<Self> {
542 let valid = reader.read_u32::<BigEndian>()?;
543
544 let size = if valid & SSH_FILEXFER_ATTR_SIZE != 0 {
545 Some(reader.read_u64::<BigEndian>()?)
546 } else {
547 None
548 };
549 let (uid, gid) = if valid & SSH_FILEXFER_ATTR_UIDGID != 0 {
550 (
551 Some(reader.read_u32::<BigEndian>()?),
552 Some(reader.read_u32::<BigEndian>()?),
553 )
554 } else {
555 (None, None)
556 };
557 let allocation_size = if valid & SSH_FILEXFER_ATTR_ALLOCATION_SIZE != 0 {
558 Some(reader.read_u64::<BigEndian>()?)
559 } else {
560 None
561 };
562 let owner = if valid & SSH_FILEXFER_ATTR_OWNERGROUP != 0 {
563 Some(read_string(reader, "owner")?)
564 } else {
565 None
566 };
567 let group = if valid & SSH_FILEXFER_ATTR_OWNERGROUP != 0 {
568 Some(read_string(reader, "group")?)
569 } else {
570 None
571 };
572 let permissions = if valid & SSH_FILEXFER_ATTR_PERMISSIONS != 0 {
573 Some(reader.read_u32::<BigEndian>()?)
574 } else {
575 None
576 };
577 let access_time = if valid & SSH_FILEXFER_ATTR_ACCESSTIME != 0 {
578 let secs = reader.read_u64::<BigEndian>()?;
579 let ns = if valid & SSH_FILEXFER_ATTR_SUBSECOND_TIMES != 0 {
580 Some(reader.read_u32::<BigEndian>()?)
581 } else {
582 None
583 };
584 Some((secs, ns))
585 } else {
586 None
587 };
588 let create_time = if valid & SSH_FILEXFER_ATTR_CREATETIME != 0 {
589 let secs = reader.read_u64::<BigEndian>()?;
590 let ns = if valid & SSH_FILEXFER_ATTR_SUBSECOND_TIMES != 0 {
591 Some(reader.read_u32::<BigEndian>()?)
592 } else {
593 None
594 };
595 Some((secs, ns))
596 } else {
597 None
598 };
599 let modify_time = if valid & SSH_FILEXFER_ATTR_MODIFYTIME != 0 {
600 let secs = reader.read_u64::<BigEndian>()?;
601 let ns = if valid & SSH_FILEXFER_ATTR_SUBSECOND_TIMES != 0 {
602 Some(reader.read_u32::<BigEndian>()?)
603 } else {
604 None
605 };
606 Some((secs, ns))
607 } else {
608 None
609 };
610 let ctime = if valid & SSH_FILEXFER_ATTR_CTIME != 0 {
611 let secs = reader.read_u64::<BigEndian>()?;
612 let ns = if valid & SSH_FILEXFER_ATTR_SUBSECOND_TIMES != 0 {
613 Some(reader.read_u32::<BigEndian>()?)
614 } else {
615 None
616 };
617 Some((secs, ns))
618 } else {
619 None
620 };
621 let acl = if valid & SSH_FILEXFER_ATTR_ACL != 0 {
622 let len = reader.read_u32::<BigEndian>()?;
623 let mut buf = vec![0; len as usize];
624 reader.read_exact(&mut buf)?;
625 Some(buf)
626 } else {
627 None
628 };
629 let attrib_bits = if valid & SSH_FILEXFER_ATTR_BITS != 0 {
630 Some(reader.read_u32::<BigEndian>()?)
631 } else {
632 None
633 };
634 let attrib_bits_valid = if valid & SSH_FILEXFER_ATTR_BITS != 0 {
635 Some(reader.read_u32::<BigEndian>()?)
636 } else {
637 None
638 };
639 let text_hint = if valid & SSH_FILEXFER_ATTR_TEXT_HINT != 0 {
640 Some(reader.read_u8()?)
641 } else {
642 None
643 };
644 let mime_type = if valid & SSH_FILEXFER_ATTR_MIME_TYPE != 0 {
645 Some(read_string(reader, "mime type")?)
646 } else {
647 None
648 };
649 let link_count = if valid & SSH_FILEXFER_ATTR_LINK_COUNT != 0 {
650 Some(reader.read_u32::<BigEndian>()?)
651 } else {
652 None
653 };
654 let untranslated_name = if valid & SSH_FILEXFER_ATTR_UNTRANSLATED_NAME != 0 {
655 let len = reader.read_u32::<BigEndian>()?;
656 let mut buf = vec![0; len as usize];
657 reader.read_exact(&mut buf)?;
658 Some(buf)
659 } else {
660 None
661 };
662 let extended = if valid & SSH_FILEXFER_ATTR_EXTENDED != 0 {
663 let len = reader.read_u32::<BigEndian>()?;
664 let mut ext = Vec::with_capacity(len as usize);
665 for _ in 0..len {
666 let k = read_string(reader, "extended key")?;
667 let v = read_string(reader, "extended value")?;
668 ext.push((k, v));
669 }
670 Some(ext)
671 } else {
672 None
673 };
674
675 Ok(Self {
676 size,
677 uid,
678 gid,
679 allocation_size,
680 owner,
681 group,
682 permissions,
683 access_time,
684 create_time,
685 modify_time,
686 ctime,
687 acl,
688 attrib_bits,
689 attrib_bits_valid,
690 text_hint: text_hint.map(|h| h.into()),
691 mime_type,
692 link_count,
693 untranslated_name,
694 extended,
695 })
696 }
697 }
698
699 fn read_string(reader: &mut Cursor<&[u8]>, what: &str) -> std::io::Result<String> {
700 let len = reader.read_u32::<BigEndian>()?;
701 let mut buf = vec![0; len as usize];
702 reader.read_exact(&mut buf)?;
703 String::from_utf8(buf).map_err(|e| {
704 std::io::Error::new(
705 std::io::ErrorKind::InvalidData,
706 format!("Invalid {}: {}", what, e),
707 )
708 })
709 }
710
711 #[derive(Debug, Clone)]
712 pub struct File(pub Vec<u8>);
713
714 #[derive(Debug, Clone)]
715 pub struct Directory(pub Vec<u8>);
716
717 pub fn build_init() -> Vec<u8> {
718 let mut buf = Vec::with_capacity(4);
719 buf.write_u32::<BigEndian>(3).unwrap();
720 buf
721 }
722
723 pub fn parse_version(body: &[u8]) -> std::io::Result<(u32, Vec<(String, String)>)> {
724 let mut reader = Cursor::new(body);
725 let version = reader.read_u32::<BigEndian>()?;
726 if version != 3 {
727 return Err(std::io::Error::other(format!(
728 "SFTP version mismatch (expected 3, got: {})",
729 version
730 )));
731 }
732 let mut extensions = Vec::new();
733 while reader.position() < reader.get_ref().len() as u64 {
734 let key = read_string(&mut reader, "extension key")?;
735 let value = read_string(&mut reader, "extension value")?;
736 extensions.push((key, value));
737 }
738 Ok((version, extensions))
739 }
740
741 fn put_str(buf: &mut Vec<u8>, s: &str) {
742 buf.write_u32::<BigEndian>(s.len() as u32).unwrap();
743 buf.extend_from_slice(s.as_bytes());
744 }
745
746 fn put_bytes(buf: &mut Vec<u8>, b: &[u8]) {
747 buf.write_u32::<BigEndian>(b.len() as u32).unwrap();
748 buf.extend_from_slice(b);
749 }
750
751 /// Build a request body containing only a single path field.
752 pub fn build_path_only(path: &str) -> Vec<u8> {
753 let mut buf = Vec::with_capacity(4 + path.len());
754 put_str(&mut buf, path);
755 buf
756 }
757
758 pub fn build_handle_only(handle: &[u8]) -> Vec<u8> {
759 let mut buf = Vec::with_capacity(4 + handle.len());
760 put_bytes(&mut buf, handle);
761 buf
762 }
763
764 pub fn build_path_and_attrs(path: &str, attr: &Attributes) -> std::io::Result<Vec<u8>> {
765 let attrs = attr.serialize()?;
766 let mut buf = Vec::with_capacity(4 + path.len() + attrs.len());
767 put_str(&mut buf, path);
768 buf.extend_from_slice(&attrs);
769 Ok(buf)
770 }
771
772 pub fn build_handle_and_attrs(handle: &[u8], attr: &Attributes) -> std::io::Result<Vec<u8>> {
773 let attrs = attr.serialize()?;
774 let mut buf = Vec::with_capacity(4 + handle.len() + attrs.len());
775 put_bytes(&mut buf, handle);
776 buf.extend_from_slice(&attrs);
777 Ok(buf)
778 }
779
780 pub fn build_path_and_flags(path: &str, flags: u32) -> Vec<u8> {
781 let mut buf = Vec::with_capacity(8 + path.len());
782 put_str(&mut buf, path);
783 buf.write_u32::<BigEndian>(flags).unwrap();
784 buf
785 }
786
787 pub fn build_handle_and_flags(handle: &[u8], flags: u32) -> Vec<u8> {
788 let mut buf = Vec::with_capacity(8 + handle.len());
789 put_bytes(&mut buf, handle);
790 buf.write_u32::<BigEndian>(flags).unwrap();
791 buf
792 }
793
794 pub fn build_two_paths(a: &str, b: &str) -> Vec<u8> {
795 let mut buf = Vec::with_capacity(8 + a.len() + b.len());
796 put_str(&mut buf, a);
797 put_str(&mut buf, b);
798 buf
799 }
800
801 pub fn build_link(path: &str, target: &str, symlink: bool) -> Vec<u8> {
802 let mut buf = build_two_paths(path, target);
803 buf.push(if symlink { 1 } else { 0 });
804 buf
805 }
806
807 pub fn build_open(path: &str, options: u32, attr: &Attributes) -> std::io::Result<Vec<u8>> {
808 let attrs = attr.serialize()?;
809 let mut buf = Vec::with_capacity(8 + path.len() + attrs.len());
810 put_str(&mut buf, path);
811 buf.write_u32::<BigEndian>(options).unwrap();
812 buf.extend_from_slice(&attrs);
813 Ok(buf)
814 }
815
816 pub fn build_realpath(path: &str, control_byte: Option<u8>, compose: Option<&str>) -> Vec<u8> {
817 let mut buf = build_path_only(path);
818 if let Some(b) = control_byte {
819 buf.push(b);
820 }
821 if let Some(c) = compose {
822 put_str(&mut buf, c);
823 }
824 buf
825 }
826
827 pub fn build_rename(oldpath: &str, newpath: &str, flags: Option<u32>) -> Vec<u8> {
828 let mut buf = build_two_paths(oldpath, newpath);
829 buf.write_u32::<BigEndian>(
830 flags.unwrap_or(SSH_FXF_RENAME_ATOMIC | SSH_FXF_RENAME_NATIVE | SSH_FXF_RENAME_OVERWRITE),
831 )
832 .unwrap();
833 buf
834 }
835
836 pub fn build_extended(request: &str, data: &[u8]) -> Vec<u8> {
837 let mut buf = Vec::with_capacity(4 + request.len() + data.len());
838 put_str(&mut buf, request);
839 buf.extend_from_slice(data);
840 buf
841 }
842
843 pub fn build_block(handle: &[u8], offset: u64, length: u64, lockmask: u32) -> Vec<u8> {
844 let mut buf = Vec::with_capacity(4 + handle.len() + 8 + 8 + 4);
845 put_bytes(&mut buf, handle);
846 buf.write_u64::<BigEndian>(offset).unwrap();
847 buf.write_u64::<BigEndian>(length).unwrap();
848 buf.write_u32::<BigEndian>(lockmask).unwrap();
849 buf
850 }
851
852 pub fn build_unblock(handle: &[u8], offset: u64, length: u64) -> Vec<u8> {
853 let mut buf = Vec::with_capacity(4 + handle.len() + 8 + 8);
854 put_bytes(&mut buf, handle);
855 buf.write_u64::<BigEndian>(offset).unwrap();
856 buf.write_u64::<BigEndian>(length).unwrap();
857 buf
858 }
859
860 pub fn build_pwrite(handle: &[u8], offset: u64, data: &[u8]) -> Vec<u8> {
861 let mut buf = Vec::with_capacity(4 + handle.len() + 8 + 4 + data.len());
862 put_bytes(&mut buf, handle);
863 buf.write_u64::<BigEndian>(offset).unwrap();
864 buf.write_u32::<BigEndian>(data.len() as u32).unwrap();
865 buf.extend_from_slice(data);
866 buf
867 }
868
869 pub fn build_pread(handle: &[u8], offset: u64, length: u32) -> Vec<u8> {
870 let mut buf = Vec::with_capacity(4 + handle.len() + 8 + 4);
871 put_bytes(&mut buf, handle);
872 buf.write_u64::<BigEndian>(offset).unwrap();
873 buf.write_u32::<BigEndian>(length).unwrap();
874 buf
875 }
876
877 pub fn parse_status(respdata: &[u8]) -> Result<()> {
878 let mut reader = Cursor::new(respdata);
879 let status = reader.read_u32::<BigEndian>()?;
880 let err_msg = read_string(&mut reader, "error message")?;
881 let lang_tag = read_string(&mut reader, "lang tag")?;
882 match status {
883 SSH_FX_OK => Ok(()),
884 SSH_FX_EOF => Err(Error::Eof(err_msg, lang_tag)),
885 SSH_FX_NO_SUCH_FILE => Err(Error::NoSuchFile(err_msg, lang_tag)),
886 SSH_FX_PERMISSION_DENIED => Err(Error::PermissionDenied(err_msg, lang_tag)),
887 SSH_FX_FAILURE => Err(Error::Failure(err_msg, lang_tag)),
888 SSH_FX_BAD_MESSAGE => Err(Error::BadMessage(err_msg, lang_tag)),
889 SSH_FX_NO_CONNECTION => Err(Error::NoConnection(err_msg, lang_tag)),
890 SSH_FX_CONNECTION_LOST => Err(Error::ConnectionLost(err_msg, lang_tag)),
891 SSH_FX_OP_UNSUPPORTED => Err(Error::OpUnsupported(err_msg, lang_tag)),
892 SSH_FX_INVALID_HANDLE => Err(Error::InvalidHandle(err_msg, lang_tag)),
893 SSH_FX_NO_SUCH_PATH => Err(Error::NoSuchPath(err_msg, lang_tag)),
894 SSH_FX_FILE_ALREADY_EXISTS => Err(Error::FileAlreadyExists(err_msg, lang_tag)),
895 SSH_FX_WRITE_PROTECT => Err(Error::WriteProtect(err_msg, lang_tag)),
896 SSH_FX_NO_MEDIA => Err(Error::NoMedia(err_msg, lang_tag)),
897 SSH_FX_NO_SPACE_ON_FILESYSTEM => Err(Error::NoSpaceOnFilesystem(err_msg, lang_tag)),
898 SSH_FX_QUOTA_EXCEEDED => Err(Error::QuotaExceeded(err_msg, lang_tag)),
899 SSH_FX_UNKNOWN_PRINCIPAL => Err(Error::UnknownPrincipal(err_msg, lang_tag)),
900 SSH_FX_LOCK_CONFLICT => Err(Error::LockConflict(err_msg, lang_tag)),
901 SSH_FX_DIR_NOT_EMPTY => Err(Error::DirNotEmpty(err_msg, lang_tag)),
902 SSH_FX_NOT_A_DIRECTORY => Err(Error::NotADirectory(err_msg, lang_tag)),
903 SSH_FX_INVALID_FILENAME => Err(Error::InvalidFilename(err_msg, lang_tag)),
904 SSH_FX_LINK_LOOP => Err(Error::LinkLoop(err_msg, lang_tag)),
905 SSH_FX_CANNOT_DELETE => Err(Error::CannotDelete(err_msg, lang_tag)),
906 SSH_FX_INVALID_PARAMETER => Err(Error::InvalidParameter(err_msg, lang_tag)),
907 SSH_FX_FILE_IS_A_DIRECTORY => Err(Error::FileIsADirectory(err_msg, lang_tag)),
908 SSH_FX_BYTE_RANGE_LOCK_CONFLICT => Err(Error::ByteRangeLockConflict(err_msg, lang_tag)),
909 SSH_FX_BYTE_RANGE_LOCK_REFUSED => Err(Error::ByteRangeLockRefused(err_msg, lang_tag)),
910 SSH_FX_DELETE_PENDING => Err(Error::DeletePending(err_msg, lang_tag)),
911 SSH_FX_FILE_CORRUPT => Err(Error::FileCorrupt(err_msg, lang_tag)),
912 SSH_FX_OWNER_INVALID => Err(Error::OwnerInvalid(err_msg, lang_tag)),
913 SSH_FX_GROUP_INVALID => Err(Error::GroupInvalid(err_msg, lang_tag)),
914 SSH_FX_NO_MATCHING_BYTE_RANGE_LOCK => {
915 Err(Error::NoMatchingByteRangeLock(err_msg, lang_tag))
916 }
917 _ => Err(Error::Other(status, err_msg, lang_tag)),
918 }
919 }
920
921 pub fn parse_handle(respdata: &[u8]) -> Result<Vec<u8>> {
922 let mut reader = Cursor::new(respdata);
923 let handle_len = reader.read_u32::<BigEndian>()?;
924 let mut handle = vec![0u8; handle_len as usize];
925 reader.read_exact(&mut handle)?;
926 Ok(handle)
927 }
928
929 pub fn parse_data(respdata: &[u8]) -> Result<Vec<u8>> {
930 let mut reader = Cursor::new(respdata);
931 let len = reader.read_u32::<BigEndian>()?;
932 let mut data = vec![0; len as usize];
933 reader.read_exact(&mut data)?;
934 Ok(data)
935 }
936
937 pub fn parse_attrs(respdata: &[u8]) -> Result<Attributes> {
938 let mut reader = Cursor::new(respdata);
939 Attributes::deserialize(&mut reader).map_err(Error::Io)
940 }
941
942 pub fn parse_name(respdata: &[u8]) -> Result<Vec<(String, Attributes)>> {
943 let mut reader = Cursor::new(respdata);
944 let count = reader.read_u32::<BigEndian>()?;
945 let mut files = Vec::with_capacity(count as usize);
946 for _ in 0..count {
947 let filename = read_string(&mut reader, "filename")?;
948 let attrs = Attributes::deserialize(&mut reader)?;
949 files.push((filename, attrs));
950 }
951 Ok(files)
952 }
953
954 pub fn parse_readdir(respdata: &[u8]) -> Result<Vec<(String, String, Attributes)>> {
955 let mut reader = Cursor::new(respdata);
956 let count = reader.read_u32::<BigEndian>()?;
957 let mut files = Vec::with_capacity(count as usize);
958 for _ in 0..count {
959 let filename = read_string(&mut reader, "filename")?;
960 let longname = read_string(&mut reader, "longname")?;
961 let attrs = Attributes::deserialize(&mut reader)?;
962 files.push((filename, longname, attrs));
963 }
964 Ok(files)
965 }
966
967 fn unexpected(cmd: u8) -> Error {
968 Error::Io(std::io::Error::other(format!(
969 "Unexpected response: {}",
970 cmd
971 )))
972 }
973
974 /// Interpret an SSH_FXP_STATUS reply received in place of a data-bearing response.
975 /// Any non-OK status becomes its matching Error; SSH_FX_OK is itself a protocol
976 /// violation (the server should have sent the requested handle/attrs/data/name).
977 fn status_as_error(data: &[u8]) -> Error {
978 match parse_status(data) {
979 Ok(()) => Error::Io(std::io::Error::other(
980 "Server returned SSH_FX_OK where a data-bearing response was expected",
981 )),
982 Err(e) => e,
983 }
984 }
985
986 pub fn expect_status(cmd: u8, data: &[u8]) -> Result<()> {
987 match cmd {
988 SSH_FXP_STATUS => parse_status(data),
989 _ => Err(unexpected(cmd)),
990 }
991 }
992
993 pub fn expect_handle(cmd: u8, data: &[u8]) -> Result<Vec<u8>> {
994 match cmd {
995 SSH_FXP_HANDLE => parse_handle(data),
996 SSH_FXP_STATUS => Err(status_as_error(data)),
997 _ => Err(unexpected(cmd)),
998 }
999 }
1000
1001 pub fn expect_attrs(cmd: u8, data: &[u8]) -> Result<Attributes> {
1002 match cmd {
1003 SSH_FXP_ATTRS => parse_attrs(data),
1004 SSH_FXP_STATUS => Err(status_as_error(data)),
1005 _ => Err(unexpected(cmd)),
1006 }
1007 }
1008
1009 pub fn expect_data(cmd: u8, data: &[u8]) -> Result<Vec<u8>> {
1010 match cmd {
1011 SSH_FXP_DATA => parse_data(data),
1012 SSH_FXP_STATUS => Err(status_as_error(data)),
1013 _ => Err(unexpected(cmd)),
1014 }
1015 }
1016
1017 pub fn expect_name(cmd: u8, data: &[u8]) -> Result<Vec<(String, Attributes)>> {
1018 match cmd {
1019 SSH_FXP_NAME => parse_name(data),
1020 SSH_FXP_STATUS => Err(status_as_error(data)),
1021 _ => Err(unexpected(cmd)),
1022 }
1023 }
1024
1025 pub fn expect_readdir(cmd: u8, data: &[u8]) -> Result<Vec<(String, String, Attributes)>> {
1026 match cmd {
1027 SSH_FXP_NAME => parse_readdir(data),
1028 SSH_FXP_STATUS => Err(status_as_error(data)),
1029 _ => Err(unexpected(cmd)),
1030 }
1031 }
1032
1033 pub fn expect_extended(cmd: u8, data: Vec<u8>) -> Result<Option<Vec<u8>>> {
1034 match cmd {
1035 SSH_FXP_EXTENDED_REPLY => Ok(Some(data)),
1036 SSH_FXP_STATUS => parse_status(&data).map(|_| None),
1037 _ => Err(unexpected(cmd)),
1038 }
1039 }
1040
1041 pub fn read_raw_packet<C: Read>(channel: &mut C) -> std::io::Result<(u8, Vec<u8>)> {
1042 let mut buf = [0u8; 4];
1043 channel.read_exact(&mut buf)?;
1044 let len = i32::from_be_bytes(buf);
1045 let mut buf = vec![0u8; len as usize];
1046 channel.read_exact(&mut buf)?;
1047 let kind = buf[0];
1048 Ok((kind, buf[1..].to_vec()))
1049 }
1050
1051 pub fn write_raw_packet<C: Write>(channel: &mut C, kind: u8, buf: &[u8]) -> std::io::Result<()> {
1052 let mut channel = std::io::BufWriter::new(channel);
1053 channel.write_u32::<BigEndian>(buf.len() as u32 + 1)?;
1054 channel.write_u8(kind)?;
1055 channel.write_all(buf)?;
1056 channel.flush()?;
1057 Ok(())
1058 }
1059
1060 /// Wrap a request body with the request-id prefix used by all numbered requests.
1061 pub fn with_request_id(request_id: u32, body: &[u8]) -> Vec<u8> {
1062 let mut buf = Vec::with_capacity(4 + body.len());
1063 buf.write_u32::<BigEndian>(request_id).unwrap();
1064 buf.extend_from_slice(body);
1065 buf
1066 }
1067
1068 /// Strip the request-id prefix from a response body. Returns (request_id, payload).
1069 pub fn split_request_id(buf: &[u8]) -> std::io::Result<(u32, &[u8])> {
1070 if buf.len() < 4 {
1071 return Err(std::io::Error::other(
1072 "response too short to contain request id",
1073 ));
1074 }
1075 let request_id = u32::from_be_bytes([buf[0], buf[1], buf[2], buf[3]]);
1076 Ok((request_id, &buf[4..]))
1077 }
1078
1079 #[cfg(test)]
1080 mod tests {
1081 use super::*;
1082
1083 #[test]
1084 fn attributes_roundtrip_size_perms() {
1085 let mut a = Attributes::new();
1086 a.size = Some(12345);
1087 a.permissions = Some(0o100644);
1088 let bytes = a.serialize().unwrap();
1089 let mut cursor = Cursor::new(bytes.as_slice());
1090 let b = Attributes::deserialize(&mut cursor).unwrap();
1091 assert_eq!(a, b);
1092 }
1093
1094 #[test]
1095 fn attributes_roundtrip_uidgid() {
1096 let mut a = Attributes::new();
1097 a.uid = Some(1000);
1098 a.gid = Some(1000);
1099 let bytes = a.serialize().unwrap();
1100 let mut cursor = Cursor::new(bytes.as_slice());
1101 let b = Attributes::deserialize(&mut cursor).unwrap();
1102 assert_eq!(a, b);
1103 }
1104
1105 #[test]
1106 fn build_path_only_layout() {
1107 let body = build_path_only("hello");
1108 assert_eq!(body, b"\x00\x00\x00\x05hello".to_vec());
1109 }
1110
1111 #[test]
1112 fn build_two_paths_layout() {
1113 let body = build_two_paths("a", "bc");
1114 assert_eq!(body, b"\x00\x00\x00\x01a\x00\x00\x00\x02bc".to_vec());
1115 }
1116
1117 #[test]
1118 fn request_id_roundtrip() {
1119 let body = b"hello".to_vec();
1120 let wrapped = with_request_id(0x12345678, &body);
1121 let (id, rest) = split_request_id(&wrapped).unwrap();
1122 assert_eq!(id, 0x12345678);
1123 assert_eq!(rest, body.as_slice());
1124 }
1125
1126 #[test]
1127 fn parse_status_ok() {
1128 let mut buf = Vec::new();
1129 buf.extend_from_slice(&SSH_FX_OK.to_be_bytes());
1130 buf.extend_from_slice(&0u32.to_be_bytes());
1131 buf.extend_from_slice(&0u32.to_be_bytes());
1132 parse_status(&buf).unwrap();
1133 }
1134
1135 #[test]
1136 fn parse_status_eof() {
1137 let mut buf = Vec::new();
1138 buf.extend_from_slice(&SSH_FX_EOF.to_be_bytes());
1139 let msg = b"end";
1140 buf.extend_from_slice(&(msg.len() as u32).to_be_bytes());
1141 buf.extend_from_slice(msg);
1142 buf.extend_from_slice(&0u32.to_be_bytes());
1143 match parse_status(&buf) {
1144 Err(Error::Eof(m, _)) => assert_eq!(m, "end"),
1145 other => panic!("expected Eof, got {:?}", other),
1146 }
1147 }
1148
1149 fn status_payload(code: u32) -> Vec<u8> {
1150 let mut buf = Vec::new();
1151 buf.extend_from_slice(&code.to_be_bytes());
1152 buf.extend_from_slice(&0u32.to_be_bytes());
1153 buf.extend_from_slice(&0u32.to_be_bytes());
1154 buf
1155 }
1156
1157 #[test]
1158 fn expect_handle_passes_through_status_error() {
1159 let payload = status_payload(SSH_FX_NO_SUCH_FILE);
1160 match expect_handle(SSH_FXP_STATUS, &payload) {
1161 Err(Error::NoSuchFile(_, _)) => {}
1162 other => panic!("expected NoSuchFile, got {:?}", other),
1163 }
1164 }
1165
1166 #[test]
1167 fn expect_handle_rejects_ok_status_without_panic() {
1168 let payload = status_payload(SSH_FX_OK);
1169 match expect_handle(SSH_FXP_STATUS, &payload) {
1170 Err(Error::Io(e)) => {
1171 assert!(
1172 e.to_string().contains("SSH_FX_OK"),
1173 "unexpected message: {}",
1174 e
1175 );
1176 }
1177 other => panic!("expected Io error, got {:?}", other),
1178 }
1179 }
1180
1181 #[test]
1182 fn expect_attrs_rejects_ok_status_without_panic() {
1183 let payload = status_payload(SSH_FX_OK);
1184 assert!(matches!(
1185 expect_attrs(SSH_FXP_STATUS, &payload),
1186 Err(Error::Io(_))
1187 ));
1188 }
1189
1190 #[test]
1191 fn expect_data_rejects_ok_status_without_panic() {
1192 let payload = status_payload(SSH_FX_OK);
1193 assert!(matches!(
1194 expect_data(SSH_FXP_STATUS, &payload),
1195 Err(Error::Io(_))
1196 ));
1197 }
1198
1199 #[test]
1200 fn expect_name_rejects_ok_status_without_panic() {
1201 let payload = status_payload(SSH_FX_OK);
1202 assert!(matches!(
1203 expect_name(SSH_FXP_STATUS, &payload),
1204 Err(Error::Io(_))
1205 ));
1206 }
1207
1208 #[test]
1209 fn expect_readdir_rejects_ok_status_without_panic() {
1210 let payload = status_payload(SSH_FX_OK);
1211 assert!(matches!(
1212 expect_readdir(SSH_FXP_STATUS, &payload),
1213 Err(Error::Io(_))
1214 ));
1215 }
1216
1217 #[test]
1218 fn expect_handle_rejects_unexpected_cmd() {
1219 assert!(matches!(
1220 expect_handle(SSH_FXP_DATA, &[]),
1221 Err(Error::Io(_))
1222 ));
1223 }
1224
1225 fn roundtrip_attrs(a: &Attributes) {
1226 let bytes = a.serialize().unwrap();
1227 let mut cursor = Cursor::new(bytes.as_slice());
1228 let b = Attributes::deserialize(&mut cursor).unwrap();
1229 assert_eq!(*a, b);
1230 }
1231
1232 #[test]
1233 fn attributes_roundtrip_empty() {
1234 roundtrip_attrs(&Attributes::new());
1235 }
1236
1237 #[test]
1238 fn attributes_roundtrip_ownergroup() {
1239 let mut a = Attributes::new();
1240 a.owner = Some("alice".into());
1241 a.group = Some("staff".into());
1242 roundtrip_attrs(&a);
1243 }
1244
1245 #[test]
1246 fn attributes_roundtrip_allocation_size() {
1247 let mut a = Attributes::new();
1248 a.allocation_size = Some(4096);
1249 roundtrip_attrs(&a);
1250 }
1251
1252 #[test]
1253 fn attributes_roundtrip_times_seconds_only() {
1254 let mut a = Attributes::new();
1255 a.access_time = Some((1_700_000_000, None));
1256 a.modify_time = Some((1_700_000_001, None));
1257 a.ctime = Some((1_700_000_002, None));
1258 a.create_time = Some((1_700_000_003, None));
1259 roundtrip_attrs(&a);
1260 }
1261
1262 #[test]
1263 fn attributes_roundtrip_times_with_subseconds() {
1264 let mut a = Attributes::new();
1265 // Subseconds on access_time turns the SUBSECOND_TIMES flag on, so every
1266 // other timestamp in this message must also carry nanoseconds.
1267 a.access_time = Some((1_700_000_000, Some(100)));
1268 a.modify_time = Some((1_700_000_001, Some(200)));
1269 a.ctime = Some((1_700_000_002, Some(300)));
1270 a.create_time = Some((1_700_000_003, Some(400)));
1271 roundtrip_attrs(&a);
1272 }
1273
1274 #[test]
1275 fn attributes_roundtrip_bits() {
1276 let mut a = Attributes::new();
1277 a.attrib_bits = Some(SSH_FILEXFER_ATTR_FLAGS_READONLY);
1278 a.attrib_bits_valid = Some(SSH_FILEXFER_ATTR_FLAGS_READONLY);
1279 roundtrip_attrs(&a);
1280 }
1281
1282 #[test]
1283 fn attributes_roundtrip_text_and_mime() {
1284 let mut a = Attributes::new();
1285 a.text_hint = Some(TextHint::KnownBinary);
1286 a.mime_type = Some("application/octet-stream".into());
1287 roundtrip_attrs(&a);
1288 }
1289
1290 #[test]
1291 fn attributes_roundtrip_link_count_untranslated() {
1292 let mut a = Attributes::new();
1293 a.link_count = Some(3);
1294 a.untranslated_name = Some(vec![0xff, 0x00, 0x7f]);
1295 roundtrip_attrs(&a);
1296 }
1297
1298 #[test]
1299 fn attributes_roundtrip_acl() {
1300 let mut a = Attributes::new();
1301 a.acl = Some(vec![1, 2, 3, 4, 5]);
1302 roundtrip_attrs(&a);
1303 }
1304
1305 #[test]
1306 fn attributes_roundtrip_extended() {
1307 let mut a = Attributes::new();
1308 a.extended = Some(vec![
1309 ("vendor@example".into(), "value-1".into()),
1310 ("other".into(), "value-2".into()),
1311 ]);
1312 roundtrip_attrs(&a);
1313 }
1314
1315 #[test]
1316 fn attributes_roundtrip_all_fields() {
1317 let mut a = Attributes::new();
1318 a.size = Some(9_999_999);
1319 a.uid = Some(501);
1320 a.gid = Some(20);
1321 a.allocation_size = Some(12_288);
1322 a.owner = Some("alice".into());
1323 a.group = Some("staff".into());
1324 a.permissions = Some(0o100755);
1325 a.access_time = Some((1_700_000_000, Some(1)));
1326 a.modify_time = Some((1_700_000_001, Some(2)));
1327 a.ctime = Some((1_700_000_002, Some(3)));
1328 a.create_time = Some((1_700_000_003, Some(4)));
1329 a.acl = Some(vec![7, 8, 9]);
1330 a.attrib_bits = Some(SSH_FILEXFER_ATTR_FLAGS_ARCHIVE);
1331 a.attrib_bits_valid = Some(SSH_FILEXFER_ATTR_FLAGS_ARCHIVE);
1332 a.text_hint = Some(TextHint::GuessedText);
1333 a.mime_type = Some("text/plain".into());
1334 a.link_count = Some(1);
1335 a.untranslated_name = Some(b"raw-name".to_vec());
1336 a.extended = Some(vec![("x".into(), "y".into())]);
1337 roundtrip_attrs(&a);
1338 }
1339
1340 #[test]
1341 fn build_handle_only_layout() {
1342 let body = build_handle_only(&[0xaa, 0xbb]);
1343 assert_eq!(body, vec![0x00, 0x00, 0x00, 0x02, 0xaa, 0xbb]);
1344 }
1345
1346 #[test]
1347 fn build_path_and_flags_layout() {
1348 let body = build_path_and_flags("f", 0x11223344);
1349 assert_eq!(body, vec![0, 0, 0, 1, b'f', 0x11, 0x22, 0x33, 0x44]);
1350 }
1351
1352 #[test]
1353 fn build_handle_and_flags_layout() {
1354 let body = build_handle_and_flags(&[0xa], 0xdeadbeef);
1355 assert_eq!(body, vec![0, 0, 0, 1, 0xa, 0xde, 0xad, 0xbe, 0xef]);
1356 }
1357
1358 #[test]
1359 fn build_link_sets_flag_byte() {
1360 assert_eq!(build_link("a", "b", true).last().copied(), Some(1));
1361 assert_eq!(build_link("a", "b", false).last().copied(), Some(0));
1362 }
1363
1364 #[test]
1365 fn build_realpath_optional_fields() {
1366 let body = build_realpath("p", None, None);
1367 assert_eq!(body, vec![0, 0, 0, 1, b'p']);
1368
1369 let body = build_realpath("p", Some(0x5), None);
1370 assert_eq!(body, vec![0, 0, 0, 1, b'p', 0x5]);
1371
1372 let body = build_realpath("p", Some(0x5), Some("q"));
1373 assert_eq!(body, vec![0, 0, 0, 1, b'p', 0x5, 0, 0, 0, 1, b'q']);
1374 }
1375
1376 #[test]
1377 fn build_rename_default_flags() {
1378 let body = build_rename("a", "b", None);
1379 // Last 4 bytes are the flags: ATOMIC | NATIVE | OVERWRITE = 7.
1380 let tail = &body[body.len() - 4..];
1381 let flags = u32::from_be_bytes([tail[0], tail[1], tail[2], tail[3]]);
1382 assert_eq!(
1383 flags,
1384 SSH_FXF_RENAME_ATOMIC | SSH_FXF_RENAME_NATIVE | SSH_FXF_RENAME_OVERWRITE
1385 );
1386 }
1387
1388 #[test]
1389 fn build_rename_honours_explicit_flags() {
1390 let body = build_rename("a", "b", Some(SSH_FXF_RENAME_OVERWRITE));
1391 let tail = &body[body.len() - 4..];
1392 let flags = u32::from_be_bytes([tail[0], tail[1], tail[2], tail[3]]);
1393 assert_eq!(flags, SSH_FXF_RENAME_OVERWRITE);
1394 }
1395
1396 #[test]
1397 fn build_pread_layout() {
1398 let body = build_pread(b"h", 0x1122334455667788, 0x10);
1399 let expected: Vec<u8> = vec![
1400 0, 0, 0, 1, b'h', // handle
1401 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, // offset
1402 0x00, 0x00, 0x00, 0x10, // length
1403 ];
1404 assert_eq!(body, expected);
1405 }
1406
1407 #[test]
1408 fn build_pwrite_layout() {
1409 let body = build_pwrite(b"h", 1, b"abc");
1410 let expected: Vec<u8> = vec![
1411 0, 0, 0, 1, b'h', 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, b'a', b'b', b'c',
1412 ];
1413 assert_eq!(body, expected);
1414 }
1415
1416 #[test]
1417 fn build_block_unblock_layout() {
1418 let body = build_block(b"h", 1, 2, 0xff);
1419 assert_eq!(
1420 body,
1421 vec![0, 0, 0, 1, b'h', 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0xff,]
1422 );
1423
1424 let body = build_unblock(b"h", 3, 4);
1425 assert_eq!(
1426 body,
1427 vec![0, 0, 0, 1, b'h', 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 4]
1428 );
1429 }
1430
1431 #[test]
1432 fn build_extended_layout() {
1433 let body = build_extended("ext@ex", b"payload");
1434 assert_eq!(
1435 body,
1436 vec![
1437 0, 0, 0, 6, b'e', b'x', b't', b'@', b'e', b'x', b'p', b'a', b'y', b'l', b'o', b'a',
1438 b'd'
1439 ]
1440 );
1441 }
1442
1443 #[test]
1444 fn build_open_layout_includes_flags_and_attrs() {
1445 let body = build_open("p", 0x9, &Attributes::new()).unwrap();
1446 // path prefix
1447 assert_eq!(&body[..5], &[0, 0, 0, 1, b'p']);
1448 // flags
1449 assert_eq!(&body[5..9], &[0, 0, 0, 0x9]);
1450 // attrs: empty => valid=0
1451 assert_eq!(&body[9..], &[0, 0, 0, 0]);
1452 }
1453
1454 #[test]
1455 fn parse_name_roundtrip() {
1456 // Build a NAME body with two entries.
1457 let mut body = Vec::new();
1458 body.extend_from_slice(&2u32.to_be_bytes());
1459 for name in ["foo", "bar"] {
1460 body.extend_from_slice(&(name.len() as u32).to_be_bytes());
1461 body.extend_from_slice(name.as_bytes());
1462 // empty attrs
1463 body.extend_from_slice(&0u32.to_be_bytes());
1464 }
1465 let out = parse_name(&body).unwrap();
1466 assert_eq!(out.len(), 2);
1467 assert_eq!(out[0].0, "foo");
1468 assert_eq!(out[1].0, "bar");
1469 assert_eq!(out[0].1, Attributes::new());
1470 }
1471
1472 #[test]
1473 fn parse_readdir_roundtrip() {
1474 let mut body = Vec::new();
1475 body.extend_from_slice(&1u32.to_be_bytes());
1476 let name = "f.txt";
1477 let long = "-rw-r--r-- 1 u g 0 Jan 1 1970 f.txt";
1478 body.extend_from_slice(&(name.len() as u32).to_be_bytes());
1479 body.extend_from_slice(name.as_bytes());
1480 body.extend_from_slice(&(long.len() as u32).to_be_bytes());
1481 body.extend_from_slice(long.as_bytes());
1482 body.extend_from_slice(&0u32.to_be_bytes());
1483 let out = parse_readdir(&body).unwrap();
1484 assert_eq!(out.len(), 1);
1485 assert_eq!(out[0].0, name);
1486 assert_eq!(out[0].1, long);
1487 }
1488
1489 #[test]
1490 fn parse_handle_roundtrip() {
1491 let mut body = Vec::new();
1492 body.extend_from_slice(&4u32.to_be_bytes());
1493 body.extend_from_slice(b"abcd");
1494 assert_eq!(parse_handle(&body).unwrap(), b"abcd".to_vec());
1495 }
1496
1497 #[test]
1498 fn parse_data_roundtrip() {
1499 let mut body = Vec::new();
1500 body.extend_from_slice(&3u32.to_be_bytes());
1501 body.extend_from_slice(b"xyz");
1502 assert_eq!(parse_data(&body).unwrap(), b"xyz".to_vec());
1503 }
1504
1505 #[test]
1506 fn parse_version_reads_extensions() {
1507 let mut body = Vec::new();
1508 body.extend_from_slice(&3u32.to_be_bytes());
1509 for (k, v) in [
1510 ("[email protected]", "1"),
1511 ("[email protected]", "2"),
1512 ] {
1513 body.extend_from_slice(&(k.len() as u32).to_be_bytes());
1514 body.extend_from_slice(k.as_bytes());
1515 body.extend_from_slice(&(v.len() as u32).to_be_bytes());
1516 body.extend_from_slice(v.as_bytes());
1517 }
1518 let (version, exts) = parse_version(&body).unwrap();
1519 assert_eq!(version, 3);
1520 assert_eq!(exts.len(), 2);
1521 assert_eq!(exts[0].0, "[email protected]");
1522 assert_eq!(exts[1].1, "2");
1523 }
1524
1525 #[test]
1526 fn parse_version_rejects_non_3() {
1527 let body = 4u32.to_be_bytes().to_vec();
1528 assert!(parse_version(&body).is_err());
1529 }
1530
1531 #[test]
1532 fn split_request_id_rejects_short_buffer() {
1533 assert!(split_request_id(&[0, 0]).is_err());
1534 }
1535
1536 #[test]
1537 fn error_conversion_preserves_kind() {
1538 use std::io::ErrorKind::*;
1539 let cases: &[(Error, std::io::ErrorKind)] = &[
1540 (Error::NoSuchFile("m".into(), "".into()), NotFound),
1541 (Error::NoSuchPath("m".into(), "".into()), NotFound),
1542 (Error::NoMedia("m".into(), "".into()), NotFound),
1543 (
1544 Error::PermissionDenied("m".into(), "".into()),
1545 PermissionDenied,
1546 ),
1547 (Error::WriteProtect("m".into(), "".into()), PermissionDenied),
1548 (
1549 Error::QuotaExceeded("m".into(), "".into()),
1550 PermissionDenied,
1551 ),
1552 (Error::LockConflict("m".into(), "".into()), PermissionDenied),
1553 (Error::NoConnection("m".into(), "".into()), NotConnected),
1554 (
1555 Error::ConnectionLost("m".into(), "".into()),
1556 ConnectionReset,
1557 ),
1558 (Error::InvalidHandle("m".into(), "".into()), InvalidInput),
1559 (Error::InvalidFilename("m".into(), "".into()), InvalidInput),
1560 (
1561 Error::FileAlreadyExists("m".into(), "".into()),
1562 AlreadyExists,
1563 ),
1564 (Error::Eof("m".into(), "".into()), UnexpectedEof),
1565 ];
1566 for (err, expected) in cases {
1567 let io_err: std::io::Error = err.clone_for_test().into();
1568 assert_eq!(
1569 io_err.kind(),
1570 *expected,
1571 "wrong kind for {:?}: got {:?}",
1572 err,
1573 io_err.kind()
1574 );
1575 }
1576 }
1577
1578 impl Error {
1579 /// Test-only clone. The `Error` variant carrying `io::Error` cannot be
1580 /// cloned, but every variant used in `error_conversion_preserves_kind`
1581 /// is string-based and safe to duplicate.
1582 fn clone_for_test(&self) -> Error {
1583 match self {
1584 Error::NoSuchFile(a, b) => Error::NoSuchFile(a.clone(), b.clone()),
1585 Error::NoSuchPath(a, b) => Error::NoSuchPath(a.clone(), b.clone()),
1586 Error::NoMedia(a, b) => Error::NoMedia(a.clone(), b.clone()),
1587 Error::PermissionDenied(a, b) => Error::PermissionDenied(a.clone(), b.clone()),
1588 Error::WriteProtect(a, b) => Error::WriteProtect(a.clone(), b.clone()),
1589 Error::QuotaExceeded(a, b) => Error::QuotaExceeded(a.clone(), b.clone()),
1590 Error::LockConflict(a, b) => Error::LockConflict(a.clone(), b.clone()),
1591 Error::NoConnection(a, b) => Error::NoConnection(a.clone(), b.clone()),
1592 Error::ConnectionLost(a, b) => Error::ConnectionLost(a.clone(), b.clone()),
1593 Error::InvalidHandle(a, b) => Error::InvalidHandle(a.clone(), b.clone()),
1594 Error::InvalidFilename(a, b) => Error::InvalidFilename(a.clone(), b.clone()),
1595 Error::FileAlreadyExists(a, b) => Error::FileAlreadyExists(a.clone(), b.clone()),
1596 Error::Eof(a, b) => Error::Eof(a.clone(), b.clone()),
1597 _ => panic!("clone_for_test only handles string-based variants"),
1598 }
1599 }
1600 }
1601 }