clamav-async 0.2.0

Async ClamAV bindings for Rust
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

// Copyright (C) 2020-2023 Cisco Systems, Inc. and/or its affiliates. All rights reserved.
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License version 2 as
// published by the Free Software Foundation.
//
// This program 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 this program; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
// MA 02110-1301, USA.

use std::io;
use std::mem;
use std::os::raw;

#[cfg(windows)]
use bindings::Windows::{
    Win32::System::SystemServices::{HANDLE, INVALID_HANDLE_VALUE},
    Win32::System::Threading::GetCurrentProcess,
    Win32::System::WindowsProgramming::DuplicateHandle,
    Win32::System::WindowsProgramming::DUPLICATE_SAME_ACCESS,
};

extern "C" {
    // https://docs.microsoft.com/en-us/cpp/c-runtime-library/reference/open-osfhandle?view=msvc-160
    fn _open_osfhandle(osfhandle: isize, flags: raw::c_int) -> raw::c_int;

    // https://docs.microsoft.com/en-us/cpp/c-runtime-library/reference/close?view=msvc-160
    fn _close(fd: raw::c_int) -> raw::c_int;
}

pub const _O_RDONLY: raw::c_int = 0;

pub struct WindowsFd(i32);

impl WindowsFd {
    pub fn new(handle: std::os::windows::io::RawHandle) -> io::Result<WindowsFd> {
        let mut owned_handle = INVALID_HANDLE_VALUE;
        unsafe {
            if DuplicateHandle(
                GetCurrentProcess(),
                std::mem::transmute::<_, HANDLE>(handle),
                GetCurrentProcess(),
                &mut owned_handle,
                0,
                false,
                DUPLICATE_SAME_ACCESS,
            )
            .as_bool()
                == false
            {
                return Err(io::Error::last_os_error());
            }

            let fd = _open_osfhandle(mem::transmute(owned_handle), _O_RDONLY);
            if fd == -1 {
                Err(io::Error::new(
                    io::ErrorKind::InvalidInput,
                    "Error converting Windows HANDLE to file descriptor",
                ))
            } else {
                Ok(WindowsFd(fd))
            }
        }
    }

    pub fn raw(&self) -> i32 {
        self.0
    }
}

impl Drop for WindowsFd {
    fn drop(&mut self) {
        unsafe {
            let _ = _close(self.0);
        }
    }
}