tobimai/smbc
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Merge pull request #2 from purpleP/cleanup/2020-10-28

Browse Source 
Update for rust 1.42+ (std Error api change, ? operator,  unneeded `unsafe`s)
This commit is contained in:
Konstantin Gribov
2021-01-24 22:33:14 +03:00
committed by GitHub
parent 7bf7625d92 104431b0c4
commit 7c6bf2ce55
3 changed files with 30 additions and 45 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
src/result.rs
View File

@@ -28,7 +28,6 @@ pub type Result<T> = result::Result<T, Error>;
pub enum Error {
NewContext(io::Error),
InitContext(io::Error),
AuthCallbackPaniced(Box<error::Error>),
NulInPath(ffi::NulError),
Io(io::Error),
}
@@ -40,29 +39,18 @@ impl fmt::Display for Error {
Error::InitContext(ref err) => write!(f, "Init context error: {}", err),
Error::Io(ref err) => write!(f, "IO error: {}", err),
Error::NulInPath(ref err) => write!(f, "NUL in path: {}", err),
Error::AuthCallbackPaniced(ref err) => write!(f, "Auth callback paniced last time: {}", err)
}
}
}
impl error::Error for Error {
fn description(&self) -> &str {
match *self {
Error::NewContext(ref err) => err.description(),
Error::InitContext(ref err) => err.description(),
Error::Io(ref err) => err.description(),
Error::NulInPath(ref err) => err.description(),
Error::AuthCallbackPaniced(ref _err) => "panic in auth callback",
}
}
fn cause(&self) -> Option<&error::Error> {
fn source(&self) -> Option<&(dyn error::Error + 'static)> {
match *self {
Error::NewContext(ref err) => Some(err),
Error::InitContext(ref err) => Some(err),
Error::Io(ref err) => Some(err),
Error::NulInPath(ref err) => Some(err),
Error::AuthCallbackPaniced(ref err) => Some(err.as_ref()),
}
}
}

53
src/smbc.rs
View File

@@ -80,7 +80,7 @@ const SMBC_TRUE: smbc_bool = 1;
pub struct SmbClient<'a> {
ctx: *mut SMBCCTX,
#[allow(dead_code)]
auth_fn: &'a for<'b> Fn(&'b str, &'b str) -> (Cow<'a, str>, Cow<'a, str>, Cow<'a, str>),
auth_fn: &'a dyn for<'b> Fn(&'b str, &'b str) -> (Cow<'a, str>, Cow<'a, str>, Cow<'a, str>),
}
// {{{2
@@ -148,7 +148,7 @@ impl<'a> SmbClient<'a> {
};
unsafe {
let ctx = try!(result_from_ptr_mut(smbc_new_context()));
let ctx = result_from_ptr_mut(smbc_new_context())?;
smbc_setOptionUserData(ctx, auth_fn as *const _ as *mut c_void);
smbc_setFunctionAuthDataWithContext(ctx, Some(Self::auth_wrapper::<F>));
@@ -158,7 +158,7 @@ impl<'a> SmbClient<'a> {
smbc_setOptionDebugToStderr(ctx, SMBC_TRUE);
//smbc_setDebug(ctx, 10);
smbc.ctx = try!(result_from_ptr_mut(smbc_init_context(ctx)));
smbc.ctx = result_from_ptr_mut(smbc_init_context(ctx))?;
}
trace!(target: "smbc", "new smbclient");
@@ -208,22 +208,20 @@ impl<'a> SmbClient<'a> {
let open_fn = try_ufn!(smbc_getFunctionOpen <- self);
let path = try!(cstring(path));
let path = cstring(path)?;
trace!(target: "smbc", "opening {:?} with {:?}", path, open_fn);
unsafe {
let fd = try!(result_from_ptr_mut(open_fn(self.ctx,
path.as_ptr(),
try!(options.to_flags()),
options.mode)));
if (fd as i64) < 0 {
trace!(target: "smbc", "neg fd");
}
Ok(SmbFile {
smbc: &self,
fd: fd,
})
let fd = result_from_ptr_mut(open_fn(self.ctx,
path.as_ptr(),
options.to_flags()?,
options.mode))?;
if (fd as i64) < 0 {
trace!(target: "smbc", "neg fd");
}
Ok(SmbFile {
smbc: &self,
fd: fd,
})
}
/// Open read-only [`SmbFile`](struct.SmbFile.html) defined by SMB `path`.
@@ -272,17 +270,16 @@ impl<'a> SmbClient<'a> {
#[doc(hidden)]
/// Get metadata for file at `path`
pub fn metadata<P: AsRef<str>>(&self, path: P) -> Result<()> {
let stat_fn = try_ufn!(smbc_getFunctionStat <- self);
let path = try!(cstring(path));
let _stat_fn = try_ufn!(smbc_getFunctionStat <- self);
let _path = cstring(path)?;
unimplemented!();
}
/// Create new directory at SMB `path`
pub fn create_dir<P: AsRef<str>>(&self, path: P) -> Result<()> {
let mkdir_fn = try_ufn!(smbc_getFunctionMkdir <- self);
let path = try!(cstring(path));
try!(to_result_with_le(unsafe { mkdir_fn(self.ctx, path.as_ptr(), 0o755) }));
let path = cstring(path)?;
to_result_with_le(mkdir_fn(self.ctx, path.as_ptr(), 0o755))?;
Ok(())
}
@@ -295,8 +292,8 @@ impl<'a> SmbClient<'a> {
/// Directory should be empty to delete it.
pub fn remove_dir<P: AsRef<str>>(&self, path: P) -> Result<()> {
let rmdir_fn = try_ufn!(smbc_getFunctionRmdir <- self);
let path = try!(cstring(path));
try!(to_result_with_le(unsafe { rmdir_fn(self.ctx, path.as_ptr()) }));
let path = cstring(path)?;
to_result_with_le(rmdir_fn(self.ctx, path.as_ptr()))?;
Ok(())
}
} // 2}}}
@@ -426,12 +423,12 @@ impl<'a, 'b> Read for SmbFile<'a, 'b> {
fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
trace!(target: "smbc", "reading file to buf [{:?};{}]", buf.as_ptr(), buf.len());
let read_fn = try_ufn!(smbc_getFunctionRead <- self.smbc);
let bytes_read = try!(to_result_with_le(unsafe {
let bytes_read = to_result_with_le(
read_fn(self.smbc.ctx,
self.fd,
buf.as_mut_ptr() as *mut c_void,
buf.len() as _)
}));
)?;
Ok(bytes_read as usize)
}
} // }}}
@@ -441,12 +438,12 @@ impl<'a, 'b> Write for SmbFile<'a, 'b> {
fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
trace!(target: "smbc", "writing buf [{:?};{}] to file", buf.as_ptr(), buf.len());
let write_fn = try_ufn!(smbc_getFunctionWrite <- self.smbc);
let bytes_wrote = try!(to_result_with_le(unsafe {
let bytes_wrote = to_result_with_le(
write_fn(self.smbc.ctx,
self.fd,
buf.as_ptr() as *const c_void,
buf.len() as _)
}));
)?;
Ok(bytes_wrote as usize)
}
@@ -466,7 +463,7 @@ impl<'a, 'b> Seek for SmbFile<'a, 'b> {
SeekFrom::End(p) => (libc::SEEK_END, p as off_t),
SeekFrom::Current(p) => (libc::SEEK_CUR, p as off_t),
};
let res = try!(to_result_with_errno(unsafe { lseek_fn(self.smbc.ctx, self.fd, off, whence) }, libc::EINVAL));
let res = to_result_with_errno(lseek_fn(self.smbc.ctx, self.fd, off, whence), libc::EINVAL)?;
Ok(res as u64)
}
} // }}}

8
src/util.rs
View File

@@ -16,7 +16,7 @@
// You should have received a copy of the GNU General Public License
// along with smbc. If not, see <http://www.gnu.org/licenses/>.
use libc::{self, c_char, c_int};
use libc::{c_char, c_int};
use std::borrow::Cow;
use std::ffi::{CStr, CString};
@@ -27,9 +27,9 @@ use result::*;
/// try! get smbc function or return io::Error(EINVAL)
macro_rules! try_ufn {
($e:ident <- $s:expr) => (try!(unsafe {
($e:ident <- $s:expr) => (unsafe {
$e($s.ctx).ok_or($crate::std::io::Error::from_raw_os_error(libc::EINVAL as i32))
}))
}?)
}
#[inline(always)]
@@ -49,7 +49,7 @@ pub unsafe fn cstr<'a, T>(p: *const T) -> Cow<'a, str> {
}
pub fn cstring<P: AsRef<str>>(p: P) -> Result<CString> {
Ok(try!(CString::new(p.as_ref())))
Ok(CString::new(p.as_ref())?)
}
pub unsafe fn write_to_cstr(dest: *mut u8, len: usize, src: &str) {