librpm 0.2.1

RPM Package Manager library binding with an idiomatic Rust API
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
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150

/*
 * Copyright (C) RustRPM Developers
 *
 * Licensed under the Mozilla Public License Version 2.0
 * Fedora-License-Identifier: MPLv2.0
 * SPDX-2.0-License-Identifier: MPL-2.0
 * SPDX-3.0-License-Identifier: MPL-2.0
 *
 * This is free software.
 * For more information on the license, see LICENSE.
 * For more information on free software, see <https://www.gnu.org/philosophy/free-sw.en.html>.
 *
 * 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/>.
 */

//! RPM macros are configuration parameters that have largely replaced the
//! previous rpmrc system.

use crate::error::{Error, ErrorKind};
use crate::internal::ConfigState;
use librpm_sys;
use std::ffi::{CStr, CString};

/// Scopes in which macros are defined
pub struct MacroContext(librpm_sys::rpmMacroContext);

/// Obtain the default global context
impl Default for MacroContext {
    fn default() -> MacroContext {
        // Safety: rpmGlobalMacroContext is a process-wide static pointer
        // provided by librpm. It is valid for the lifetime of the process.
        unsafe { MacroContext(librpm_sys::rpmGlobalMacroContext) }
    }
}

impl MacroContext {
    /// Define a macro in this context. Macros take the form:
    ///
    /// `<name>[(opts)] <body>`
    ///
    /// Level defines the macro recursion level (0 is the entry API)
    pub fn define(&self, macro_string: &str, level: isize) -> Result<(), Error> {
        let cstr =
            CString::new(macro_string).map_err(|e| format_err!(ErrorKind::InvalidArg, "{}", e))?;

        // Aggressively synchronize all macro operations through the global
        // lock. This serializes even non-global context operations, but these
        // are not hot paths and correctness is more important here.
        let _lock = ConfigState::lock();
        // Safety: cstr is a valid null-terminated C string, and self.0 is a
        // valid rpmMacroContext obtained from librpm. The global lock ensures
        // exclusive access to librpm's macro state.
        unsafe {
            librpm_sys::rpmDefineMacro(self.0, cstr.as_ptr(), level as i32);
        }

        Ok(())
    }

    /// Delete a macro from this context.
    pub fn pop(&self, name: &str) -> Result<(), Error> {
        let cstr = CString::new(name).map_err(|e| format_err!(ErrorKind::InvalidArg, "{}", e))?;

        let _lock = ConfigState::lock();
        // Safety: cstr is a valid null-terminated C string, and self.0 is a
        // valid rpmMacroContext. The global lock ensures exclusive access.
        unsafe {
            librpm_sys::rpmPopMacro(self.0, cstr.as_ptr());
        }

        Ok(())
    }

    /// Expand a macro expression and return the result as a string.
    ///
    /// The expression is expanded using this context's macro definitions.
    /// Macro references use `%{name}` syntax.
    ///
    /// ```no_run
    /// use librpm::MacroContext;
    ///
    /// librpm::init();
    /// let ctx = MacroContext::default();
    /// let arch = ctx.expand("%{_arch}").unwrap();
    /// println!("build arch: {arch}");
    /// ```
    pub fn expand(&self, expr: &str) -> Result<String, Error> {
        let cstr = CString::new(expr).map_err(|e| format_err!(ErrorKind::InvalidArg, "{}", e))?;

        let _lock = ConfigState::lock();
        let mut obuf: *mut std::os::raw::c_char = std::ptr::null_mut();
        let rc = unsafe { librpm_sys::rpmExpandMacros(self.0, cstr.as_ptr(), &mut obuf, 0) };

        if rc < 0 || obuf.is_null() {
            if !obuf.is_null() {
                unsafe { free(obuf.cast()) };
            }
            fail!(ErrorKind::Macro, "macro expansion failed: {}", expr);
        }

        let result = unsafe { CStr::from_ptr(obuf) }
            .to_string_lossy()
            .into_owned();
        unsafe { free(obuf.cast()) };
        Ok(result)
    }

    /// Test whether a macro is defined in this context.
    ///
    /// ```no_run
    /// use librpm::MacroContext;
    ///
    /// librpm::init();
    /// let ctx = MacroContext::default();
    /// assert!(ctx.is_defined("_arch"));
    /// ```
    pub fn is_defined(&self, name: &str) -> bool {
        let Ok(cstr) = CString::new(name) else {
            return false;
        };

        let _lock = ConfigState::lock();
        unsafe { librpm_sys::rpmMacroIsDefined(self.0, cstr.as_ptr()) != 0 }
    }
}

/// Expand a macro expression and return its numeric value.
///
/// Uses the global macro context. Boolean values (`Y`/`y` return 1,
/// `N`/`n` return 0) are accepted. An undefined or non-numeric macro
/// returns 0.
///
/// ```no_run
/// librpm::init();
/// let uid = librpm::macro_context::expand_numeric("%{_root_uid}");
/// ```
pub fn expand_numeric(expr: &str) -> i32 {
    let Ok(cstr) = CString::new(expr) else {
        return 0;
    };

    let _lock = ConfigState::lock();
    unsafe { librpm_sys::rpmExpandNumeric(cstr.as_ptr()) }
}

unsafe extern "C" {
    fn free(ptr: *mut std::ffi::c_void);
}