cloudfox-coreshift-core 2.5.0

Low-level Linux and Android systems primitives for CoreShift (CloudFox)
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

// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at https://mozilla.org/MPL/2.0/

//! Generic binder client for any named Android service.

use crate::CoreError;
use super::sys::*;
use std::os::raw::c_char;

// ── RawBinderService ──────────────────────────────────────────────────────

/// Generic binder client for any named Android service.
///
/// Handles its own `dlopen` on `libbinder_ndk.so`. Callers provide raw
/// transaction codes (resolved via [`crate::android::dex::find_transaction_code`])
/// and use [`RawBinderService::transact_bool`] /
/// [`RawBinderService::transact_i32`] for typed round-trips.
pub struct RawBinderService {
    _lib: DlHandle,
    vt: Vtable,
    service: OwnedBinder,
}
unsafe impl Send for RawBinderService {}

impl RawBinderService {
    /// Open a connection to the named service (e.g. `"power"`, `"batterystats"`).
    pub fn open(service_name: &str) -> Result<Self, CoreError> {
        use std::ffi::CString;
        let handle = unsafe {
            libc::dlopen(
                LIBBINDER_PATH.as_ptr() as *const c_char,
                libc::RTLD_NOW | libc::RTLD_LOCAL,
            )
        };
        if handle.is_null() {
            return Err(CoreError::binder(-1, "dlopen:libbinder_ndk.so"));
        }
        let lib = DlHandle;
        let vt = load_vtable(handle)?;
        let cs = CString::new(service_name)
            .map_err(|_| CoreError::binder(-1, "service_name:nul_byte"))?;
        let raw = unsafe { (vt.get_service)(cs.as_ptr()) };
        if raw.is_null() {
            return Err(CoreError::binder(-1, "AServiceManager_getService:null"));
        }
        let service = OwnedBinder {
            ptr: raw,
            dec_strong: vt.dec_strong,
        };
        Ok(Self {
            _lib: lib,
            vt,
            service,
        })
    }

    /// Send a no-argument transaction; read exception header then bool reply.
    pub fn transact_bool(&self, code: u32) -> Result<bool, CoreError> {
        let out = self.raw_noarg(code)?;
        let r = ParcelReader {
            vt: &self.vt,
            parcel: &out,
        };
        let ex = r.read_i32()?;
        if ex != EX_NONE {
            return Err(CoreError::binder(ex, "transact_bool:exception"));
        }
        if let Some(rb) = self.vt.read_bool {
            let mut v = false;
            let s = unsafe { rb(out.ptr as *const AParcel, &mut v) };
            if s != STATUS_OK {
                return Err(CoreError::binder(s, "AParcel_readBool"));
            }
            Ok(v)
        } else {
            Ok(r.read_i32()? != 0)
        }
    }

    /// Send a transaction with one i32 argument; discard reply.
    pub fn transact_i32(&self, code: u32, arg: i32) -> Result<(), CoreError> {
        let _ = transact_write(&self.vt, self.service.ptr, code, |w| w.write_i32(arg))?;
        Ok(())
    }

    fn raw_noarg(&self, code: u32) -> Result<OwnedParcel, CoreError> {
        transact_write(&self.vt, self.service.ptr, code, |_| Ok(()))
    }
}