index : openssh	IBS PRIVSEP V_2_5_2 V_2_9_9 V_2_9_P1 V_3_0_2 V_3_2_3 V_3_3 V_3_5 V_3_6 V_3_6_1 V_3_7 V_3_8 V_3_8_1 V_3_9 V_4_0 V_4_1 V_4_2 V_4_3 V_4_4 V_4_5 V_4_6 V_4_7 V_4_9 V_5_3 V_5_4 V_5_6 V_5_8 V_5_9 V_6_0 V_6_2 V_6_3 V_6_4 V_6_5 V_6_6 V_6_7 V_6_8 V_6_9 V_7_0 V_7_1 V_7_2 V_7_3 V_7_4 V_7_5 V_7_6 V_7_7 V_7_8 V_7_9 V_8_0 V_8_1 V_8_2 V_8_3 V_8_4 V_8_5 V_8_6 V_8_7 V_8_8 V_8_9 V_9_0 V_9_1 V_9_2 V_9_3 V_9_4 V_9_5 V_9_6 V_9_7 V_9_8 master
	Mirror of https://anongit.mindrot.org/openssh.git	matthias

summaryrefslogtreecommitdiffstats

log msg author committer range

path: root/mpaux.c

Age	Commit message (Expand)	Author
2005-05-26	- (djm) [mpaux.c mpaux.h Makefile.in] Remove old mpaux.[ch] code, it has not	Damien Miller
2001-02-09	- itojun@cvs.openbsd.org 2001/02/08 19:30:52	Ben Lindstrom
2000-12-22	One way to massive patch. <sigh> It compiles and works under Linux..	Ben Lindstrom
2000-09-16	- (djm) Merge OpenBSD changes:	Damien Miller
2000-06-22	- OpenBSD CVS Updates:	Damien Miller
2000-04-16	- Reduce diff against OpenBSD source	Damien Miller
2000-04-16	- OpenBSD CVS updates.	Damien Miller
2000-04-13	- Merged OpenBSD updates to include paths.	Damien Miller
2000-04-01	- Big OpenBSD CVS update (mainly beginnings of SSH2 infrastructure)	Damien Miller
1999-12-14	- OpenBSD CVS Changes	Damien Miller
1999-11-25	- Merged very large OpenBSD source code reformat	Damien Miller
1999-11-16	- Merged OpenBSD CVS changes:	Damien Miller
1999-11-13	Remove redundant inclusion of config.h	Damien Miller
1999-11-12	- Merged yet more changes from OpenBSD CVS	Damien Miller
1999-10-28	Merged latest OpenBSD changes.	Damien Miller
1999-10-28	- Integrated patch from Dan Brosemer <odin@linuxfreak.com>	Damien Miller
1999-10-27	Initial revision	Damien Miller

generated by cgit v1.2.3 (git 2.25.1) at 2024-09-13 06:27:06 +0000

use crate::abort_on_panic;
use libc::{c_char, c_ulong};
use libnewsboat::utils;
use libnewsboat::{
    log,
    logger::{self, Level},
};
use std::ffi::{CStr, CString};
use std::path;
use std::ptr;

#[repr(C)]
pub struct FilterUrl {
    filter: *mut char,
    url: *mut char,
}

#[no_mangle]
pub unsafe extern "C" fn rs_replace_all(
    input: *const c_char,
    from: *const c_char,
    to: *const c_char,
) -> *mut c_char {
    abort_on_panic(|| {
        let rs_input = CStr::from_ptr(input);
        let rs_input = rs_input.to_string_lossy().into_owned();

        let rs_from = CStr::from_ptr(from);
        // This won't panic because all strings in Newsboat are in UTF-8
        let rs_from = rs_from.to_str().expect("rs_from contained invalid UTF-8");

        let rs_to = CStr::from_ptr(to);
        // This won't panic because all strings in Newsboat are in UTF-8
        let rs_to = rs_to.to_str().expect("rs_to contained invalid UTF-8");

        let result = utils::replace_all(rs_input, rs_from, rs_to);
        // Panic here can't happen because:
        // 1. panic can only happen if `result` contains null bytes;
        // 2. `result` contains what `input` contained, plus maybe what `to` contains (if there were
        //    replacements);
        // 3. neither `input` nor `to` could contain null bytes because they're null-terminated
        //    strings we got from C.
        let result = CString::new(result).unwrap();
        result.into_raw()
    })
}

#[no_mangle]
pub unsafe extern "C" fn rs_consolidate_whitespace(input: *const c_char) -> *mut c_char {
    abort_on_panic(|| {
        let rs_input = CStr::from_ptr(input);
        let rs_input = rs_input.to_string_lossy().into_owned();

        let result = utils::consolidate_whitespace(rs_input);
        // Panic here can't happen because:
        // 1. panic can only happen if `result` contains null bytes;
        // 2. `result` contains what `input` contained, and input is a
        // null-terminated string from C.
        let result = CString::new(result).unwrap();
        result.into_raw()
    })
}

#[no_mangle]
pub unsafe extern "C" fn rs_resolve_tilde(path: *const c_char) -> *mut c_char {
    abort_on_panic(|| {
        let rs_path = CStr::from_ptr(path);
        // We simply assume that all the paths are in UTF-8 -- hence to_string_lossy().
        let rs_path = rs_path.to_string_lossy().into_owned();

        let result = utils::resolve_tilde(path::PathBuf::from(rs_path));
        // We simply assume that all the paths are in UTF-8 -- hence to_string_lossy().
        let result = result.to_string_lossy().into_owned();

        // `result` consists of:
        // 1. a path to the home dir, which can't contain NUL bytes, since it has to be handled by
        //    C APIs;
        // 2. a path delimiter, which is a slash and not a NUL byte;
        // 3. the original input, `path`, which came here as a C string, so doesn't contain NUL
        //    bytes.
        //
        // Thus, `unwrap` won't panic.
        let result = CString::new(result).unwrap();
        result.into_raw()
    })
}

#[no_mangle]
pub unsafe extern "C" fn rs_resolve_relative(
    reference: *const c_char,
    path: *const c_char,
) -> *mut c_char {
    use std::path::Path;
    abort_on_panic(|| {
        let rs_reference = CStr::from_ptr(reference);
        let rs_reference = rs_reference.to_string_lossy().into_owned();

        let rs_path = CStr::from_ptr(path);
        let rs_path = rs_path.to_string_lossy().into_owned();

        let result = utils::resolve_relative(Path::new(&rs_reference), Path::new(&rs_path));

        // result.to_str().unwrap()' won't panic because it is either
        // - rs_path
        // - combination of reference and rs_path
        //   which are both valid strings
        //
        // CString::new(...).unwrap() won't panic for the above reasons, the strings that went into
        // it are valid strings
        let result = CString::new(result.to_str().unwrap()).unwrap();
        result.into_raw()
    })
}

#[no_mangle]
pub unsafe extern "C" fn rs_to_u(in_str: *const c_char, default_value: u32) -> u32 {
    abort_on_panic(|| {
        let rs_str = CStr::from_ptr(in_str);
        let rs_str = rs_str.to_string_lossy().into_owned();

        utils::to_u(rs_str, default_value)
    })
}

#[no_mangle]
pub unsafe extern "C" fn rs_absolute_url(
    base_url: *const c_char,
    link: *const c_char,
) -> *mut c_char {
    abort_on_panic(|| {
        let rs_base_url = CStr::from_ptr(base_url);
        let rs_base_url = rs_base_url.to_string_lossy();
        let rs_link = CStr::from_ptr(link);
        let rs_link = rs_link.to_string_lossy();

        let ret = utils::absolute_url(&rs_base_url, &rs_link);
        // `ret` is either the same as `rs_link`, or a combination of `rs_base_url`, `rs_link`, and
        // a slash. `rs_base_url` and `rs_link` came here as C strings, so they are guaranteed not
        // to contain NUL. The slash is obviously not a NUL. Thus, `unwrap` won't panic.
        CString::new(ret).unwrap().into_raw()
    })
}

#[no_mangle]
pub unsafe extern "C" fn rs_is_special_url(in_str: *const c_char) -> bool {
    abort_on_panic(|| {
        let rs_str = CStr::from_ptr(in_str);
        let rs_str = rs_str.to_string_lossy();
        utils::is_special_url(&rs_str)
    })
}

#[no_mangle]
pub unsafe extern "C" fn rs_is_http_url(in_str: *const c_char) -> bool {
    abort_on_panic(|| {
        let rs_str = CStr::from_ptr(in_str);
        let rs_str = rs_str.to_string_lossy();
        utils::is_http_url(&rs_str)
    })
}

#[no_mangle]
pub unsafe extern "C" fn rs_is_query_url(in_str: *const c_char) -> bool {
    abort_on_panic(|| {
        let rs_str = CStr::from_ptr(in_str);
        let rs_str = rs_str.to_string_lossy();
        utils::is_query_url(&rs_str)
    })
}

#[no_mangle]
pub unsafe extern "C" fn rs_is_filter_url(in_str: *const c_char) -> bool {
    abort_on_panic(|| {
        let rs_str = CStr::from_ptr(in_str);
        let rs_str = rs_str.to_string_lossy();
        utils::is_filter_url(&rs_str)
    })
}

#[no_mangle]
pub unsafe extern "C" fn rs_is_exec_url(in_str: *const c_char) -> bool {
    abort_on_panic(|| {
        let rs_str = CStr::from_ptr(in_str);
        let rs_str = rs_str.to_string_lossy();
        utils::is_exec_url(&rs_str)
    })
}

#[no_mangle]
pub unsafe extern "C" fn rs_censor_url(url: *const