renamore 0.3.2

More ways to rename files.
Documentation 
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

#![allow(non_camel_case_types)]

use std::path::Path;
use std::io::{Error, ErrorKind, Result};
use std::ffi::{c_char, c_int, c_uint, CString, c_ulong};
use std::os::unix::prelude::OsStrExt;

// Linking will fail on Darwin versions prior to 16 which corresponds to these:
//  - macOS 10.12
//  - iOS 10.0
//  - tvOS 10.0
//  - watchOS 3.0

extern "C" {
    fn renamex_np(from: *const c_char, to: *const c_char, flags: c_uint) -> c_int;
}

// const RENAME_SWAP: c_uint = 2;
const RENAME_EXCL: c_uint = 4;

pub fn rename_exclusive(from: &Path, to: &Path) -> Result<()> {
    let from_str = CString::new(from.as_os_str().as_bytes())?;
    let to_str = CString::new(to.as_os_str().as_bytes())?;
    let ret = unsafe {
        renamex_np(from_str.as_ptr(), to_str.as_ptr(), RENAME_EXCL)
    };

    if ret == -1 {
        let error = Error::last_os_error();
        // EINVAL is returned if `flags` is invalid.
        // ENOTSUP is returned if the file system doesn't support the operation.
        if error.kind() == ErrorKind::InvalidInput {
            Err(Error::from(ErrorKind::Unsupported))
        } else {
            Err(error)
        }
    } else {
        Ok(())
    }
}

#[repr(C)]
struct attrlist {
    bitmapcount: u16,
    reserved: u16,
    commonattr: u32,
    volattr: u32,
    dirattr: u32,
    fileattr: u32,
    forkattr: u32,
}

const ATTR_BIT_MAP_COUNT: u16 = 5;
const ATTR_VOL_CAPABILITIES: u32 = 0x00020000;

type vol_capabilities_set_t = [u32; 4];

const VOL_CAPABILITIES_INTERFACES: usize = 1;

#[repr(C)]
struct vol_capabilities_attr_t {
    capabilities: vol_capabilities_set_t,
    valid: vol_capabilities_set_t,
}

// const VOL_CAP_INT_RENAME_SWAP: u32 = 0x00040000;
const VOL_CAP_INT_RENAME_EXCL: u32 = 0x00080000;

#[repr(C)]
struct AttributeBuf {
    length: u32,
    volume: vol_capabilities_attr_t,
}

extern "C" {
    fn getattrlist(
        path: *const c_char,
        attrList: *mut attrlist,
        attrBuf: *mut AttributeBuf,
        attrBufSize: usize,
        options: c_ulong,
    ) -> c_int;
}

pub fn rename_exclusive_is_atomic(path: &Path) -> Result<bool> {
    let path_str = CString::new(path.as_os_str().as_bytes())?;
    let mut list = attrlist {
        bitmapcount: ATTR_BIT_MAP_COUNT,
        reserved: 0,
        commonattr: 0,
        volattr: ATTR_VOL_CAPABILITIES,
        dirattr: 0,
        fileattr: 0,
        forkattr: 0,
    };
    let mut buf = std::mem::MaybeUninit::<AttributeBuf>::uninit();

    let ret = unsafe {
        getattrlist(
            path_str.as_ptr(),
            std::ptr::addr_of_mut!(list),
            buf.as_mut_ptr(),
            std::mem::size_of::<AttributeBuf>(),
            0
        )
    };

    if ret == -1 {
        return Err(Error::last_os_error());
    }

    let attrs = unsafe { buf.assume_init_ref() };
    let capabilities = attrs.volume.capabilities[VOL_CAPABILITIES_INTERFACES];

    Ok(capabilities & VOL_CAP_INT_RENAME_EXCL != 0)
}