89 lines
2.9 KiB
Rust
89 lines
2.9 KiB
Rust
// smbc is library wrapping libsmbclient from Samba project
|
|
// Copyright (c) 2016 Konstantin Gribov
|
|
//
|
|
// This file is part of smbc.
|
|
//
|
|
// smbc is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU General Public License as published by
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
// (at your option) any later version.
|
|
//
|
|
// smbc is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU General Public License for more details.
|
|
//
|
|
// 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 std::borrow::Cow;
|
|
use std::ffi::{CStr, CString};
|
|
use std::io::{self, Write};
|
|
use std::slice;
|
|
|
|
use result::*;
|
|
|
|
/// try! get smbc function or return io::Error(EINVAL)
|
|
macro_rules! try_ufn {
|
|
($e:ident <- $s:expr) => (unsafe {
|
|
$e($s.ctx).ok_or($crate::std::io::Error::from_raw_os_error(libc::EINVAL as i32))
|
|
}?)
|
|
}
|
|
|
|
#[inline(always)]
|
|
/// Ok(ptr) for non-null ptr or Err(last_os_error) otherwise
|
|
pub fn result_from_ptr_mut<T>(ptr: *mut T) -> io::Result<*mut T> {
|
|
if ptr.is_null() { Err(io::Error::last_os_error()) } else { Ok(ptr) }
|
|
}
|
|
|
|
#[inline(always)]
|
|
/// Ok(ptr) for non-null ptr or Err(last_os_error) otherwise
|
|
pub fn result_from_ptr<T>(ptr: *const T) -> io::Result<*const T> {
|
|
if ptr.is_null() { Err(io::Error::last_os_error()) } else { Ok(ptr) }
|
|
}
|
|
|
|
pub unsafe fn cstr<'a, T>(p: *const T) -> Cow<'a, str> {
|
|
CStr::from_ptr(p as *const c_char).to_string_lossy()
|
|
}
|
|
|
|
pub fn cstring<P: AsRef<str>>(p: P) -> Result<CString> {
|
|
Ok(CString::new(p.as_ref())?)
|
|
}
|
|
|
|
pub unsafe fn write_to_cstr(dest: *mut u8, len: usize, src: &str) {
|
|
// just to ensure that it can be interpreted as c string
|
|
*(dest.offset((len - 1) as isize)) = 0u8;
|
|
trace!(target: "smbc", "orig: {:?}", cstr(dest));
|
|
|
|
let mut buf = slice::from_raw_parts_mut(dest, len);
|
|
let mut idx = buf.write(src.as_bytes()).unwrap();
|
|
|
|
if idx == len {
|
|
idx -= 1;
|
|
}
|
|
buf = slice::from_raw_parts_mut(dest, len);
|
|
buf[idx] = 0u8;
|
|
|
|
trace!(target: "smbc", "write to [{:p};{}] from [{:p},{}]: {:?}", dest, len, src.as_ptr(), src.len(), cstr(dest));
|
|
}
|
|
|
|
#[inline(always)]
|
|
/// to io::Result with Err(last_os_error) if t == -1
|
|
pub fn to_result_with_le<T: Eq + From<i8>>(t: T) -> io::Result<T> {
|
|
to_result_with_error(t, io::Error::last_os_error())
|
|
}
|
|
|
|
#[inline(always)]
|
|
/// to io::Result with Err(from_raw_os_error(errno)) if t == -1
|
|
pub fn to_result_with_errno<T: Eq + From<i8>>(t: T, errno: c_int) -> io::Result<T> {
|
|
to_result_with_error(t, io::Error::from_raw_os_error(errno as i32))
|
|
}
|
|
|
|
#[inline(always)]
|
|
fn to_result_with_error<T: Eq + From<i8>>(t: T, err: io::Error) -> io::Result<T> {
|
|
if t == T::from(-1) { Err(err) } else { Ok(t) }
|
|
}
|
|
|