From fd117274e49729d64080ba4af5bb968615a60c94 Mon Sep 17 00:00:00 2001 From: trackers-love Date: Wed, 20 Dec 2023 17:15:49 +0800 Subject: [PATCH] fix utsudoedit error --- lib/util/src/arc4random.rs | 33 +- lib/util/src/closefrom.rs | 24 +- lib/util/src/common.rs | 1631 ++++++++++++++++++++++++++++++ lib/util/src/digest.rs | 51 +- lib/util/src/event.rs | 258 +---- lib/util/src/event_poll.rs | 163 +-- lib/util/src/fatal.rs | 21 +- lib/util/src/getgrouplist.rs | 9 +- lib/util/src/gethostname.rs | 8 +- lib/util/src/gettime.rs | 36 +- lib/util/src/gidlist.rs | 22 +- lib/util/src/key_val.rs | 7 +- lib/util/src/lbuf.rs | 20 +- lib/util/src/lib.rs | 5 +- lib/util/src/locking.rs | 18 +- lib/util/src/memset_s.rs | 7 +- lib/util/src/parseln.rs | 70 +- lib/util/src/progname.rs | 1 + lib/util/src/pw_dup.rs | 7 +- lib/util/src/secure_path.rs | 227 +---- lib/util/src/setgroups.rs | 17 +- lib/util/src/sha2.rs | 22 +- lib/util/src/sig2str.rs | 40 +- lib/util/src/str2sig.rs | 17 +- lib/util/src/strsplit.rs | 7 +- lib/util/src/strtobool.rs | 11 +- lib/util/src/strtoid.rs | 44 +- lib/util/src/strtomode.rs | 21 +- lib/util/src/strtonum.rs | 16 +- lib/util/src/sudo_conf.rs | 420 ++------ lib/util/src/sudo_debug.rs | 12 +- lib/util/src/sudo_debug_macro.rs | 4 + lib/util/src/sudo_dso.rs | 49 +- lib/util/src/term.rs | 265 +---- lib/util/src/ttyname_dev.rs | 327 ++---- lib/util/src/ttysize.rs | 44 +- 36 files changed, 2034 insertions(+), 1900 deletions(-) create mode 100644 lib/util/src/common.rs diff --git a/lib/util/src/arc4random.rs b/lib/util/src/arc4random.rs index ef5545c..bc1a40b 100644 --- a/lib/util/src/arc4random.rs +++ b/lib/util/src/arc4random.rs @@ -14,26 +14,21 @@ unused_assignments )] -//call libc_func -use libc::abort; +use crate::common::*; //define pub const RSBUFSZ: i32 = 1024; pub const __SIZEOF_PTHREAD_MUTEX_T: usize = 40; + +// #define KEYSZ 32 +// #define IVSZ 8 pub const KEYSZ: i32 = 32; pub const IVSZ: i32 = 8; //aliase of type -pub type pid_t = libc::c_int; -pub type uint32_t = libc::c_uint; -pub type size_t = libc::c_ulong; -pub type __off_t = libc::c_long; pub type __pthread_list_t = __pthread_internal_list; -pub type sig_atomic_t = __sig_atomic_t; -pub type __sig_atomic_t = libc::c_int; -pub type u8 = libc::c_uchar; -pub type u32 = libc::c_uint; +//line 75 #[derive(Copy, Clone)] #[repr(C)] pub struct _rs { @@ -116,6 +111,7 @@ static mut arc4random_mtx: pthread_mutex_t = pthread_mutex_t { }, }; +//line 108-126 #[no_mangle] unsafe fn _rs_stir() { let mut rnd: [libc::c_uchar; (KEYSZ + IVSZ) as usize] = [0; (KEYSZ + IVSZ) as usize]; @@ -157,6 +153,7 @@ unsafe fn _rs_stir() { (*rs).rs_count = 1600000; } +//line86 87 90... extern "C" { fn mmap( __addr: *mut libc::c_void, @@ -180,7 +177,6 @@ extern "C" { } //function _getentropy_fail -use libc::raise; pub const SIGKILL: libc::c_int = 9; pub unsafe fn _getentropy_fail() { raise(SIGKILL); @@ -188,7 +184,6 @@ pub unsafe fn _getentropy_fail() { //function _rs_forkdetect static mut wipeonfork: libc::c_int = 0; -use libc::getpid; static mut _rs_forked: __sig_atomic_t = 0; pub unsafe fn _rs_forkdetect() { if wipeonfork == 0 { @@ -212,11 +207,16 @@ pub unsafe fn _rs_forkdetect() { pub const PROT_READ: libc::c_short = 0x1; pub const PROT_WRITE: libc::c_short = 0x2; pub const MAP_ANON: libc::c_short = 0x20; + +// /* Return value of `mmap' in case of an error. */ +// #define MAP_FAILED ((void *) -1) pub const MAP_FAILED: libc::c_int = -1; + +//#define MAP_PRIVATE 0x02 /* Changes are private. */ pub const MAP_PRIVATE: libc::c_short = 0x02; + +//# define MADV_WIPEONFORK 18 /* Zero memory on fork, child only. */ pub const MADV_WIPEONFORK: libc::c_int = 18; -use libc::madvise; -use libc::pthread_atfork; pub unsafe extern "C" fn _rs_forkhandler() { _rs_forked = 1; } @@ -290,12 +290,10 @@ macro_rules! U8TO32_LITTLE { << 24 as libc::c_int }}; } - static mut sigma: [libc::c_char; 16] = unsafe { *::std::mem::transmute::<&[u8; 16], &[libc::c_char; 16]>(b"expand 32-byte k") }; static mut tau: [libc::c_char; 16] = unsafe { *::std::mem::transmute::<&[u8; 16], &[libc::c_char; 16]>(b"expand 16-byte k") }; - #[no_mangle] pub unsafe fn chacha_keysetup( mut x: *mut chacha_ctx, @@ -458,6 +456,7 @@ pub unsafe fn chacha_encrypt_bytes( x13 = j13; x14 = j14; x15 = j15; + i = 20; while i > 0 { QUARTERROUND!(x0, x4, x8, x12); @@ -486,6 +485,7 @@ pub unsafe fn chacha_encrypt_bytes( x13 = PLUS!(x13, j13); x14 = PLUS!(x14, j14); x15 = PLUS!(x15, j15); + //line 185-187 j12 = PLUS!(j12, 1); if j12 == 0 { @@ -508,6 +508,7 @@ pub unsafe fn chacha_encrypt_bytes( U32TO8_LITTLE!(c, x13, 52); U32TO8_LITTLE!(c, x14, 56); U32TO8_LITTLE!(c, x15, 60); + if bytes <= 64 { if bytes < 64 { i = 0; diff --git a/lib/util/src/closefrom.rs b/lib/util/src/closefrom.rs index 948b9a6..b7626a7 100644 --- a/lib/util/src/closefrom.rs +++ b/lib/util/src/closefrom.rs @@ -5,12 +5,8 @@ */ #![allow(unused_variables, unused_assignments, clashing_extern_declarations)] -use crate::arc4random::__off_t; -use crate::sudo_conf::__ino_t; -use crate::INT_MAX; -use libc::dirfd; -use libc::DIR; -pub const _SC_OPEN_MAX: i32 = 4; + +use crate::common::*; extern "C" { fn sysconf(__name: libc::c_int) -> libc::c_long; @@ -32,13 +28,6 @@ fn closefrom_fallback(lowfd: libc::c_int) { let mut _fd: libc::c_long = 0; let mut maxfd: libc::c_long; - #[macro_export] - macro_rules! _POSIX_OPEN_MAX { - () => { - 20 - }; - } - maxfd = unsafe { sysconf(_SC_OPEN_MAX) }; if maxfd < 0 { @@ -52,15 +41,6 @@ fn closefrom_fallback(lowfd: libc::c_int) { } } -#[repr(C)] -pub struct dirent { - pub d_ino: __ino_t, - pub d_off: __off_t, - pub d_reclen: libc::c_short, - pub d_type: libc::c_char, - pub d_name: [libc::c_char; 256], -} - #[no_mangle] fn sudo_closefrom(lowfd: libc::c_int) { let path: *const libc::c_char; diff --git a/lib/util/src/common.rs b/lib/util/src/common.rs new file mode 100644 index 0000000..7756029 --- /dev/null +++ b/lib/util/src/common.rs @@ -0,0 +1,1631 @@ +/* + * SPDX-FileCopyrightText: 2023 UnionTech Software Technology Co., Ltd. + * + * SPDX-License-Identifier: MulanPSL-2.0 + */ + +#![allow( + non_camel_case_types, + non_snake_case, + non_upper_case_globals, + unused_macros, + dead_code +)] + +//////////// 调用其它模块中接口 +pub use crate::sudo_debug::*; +pub use libc::abort; +pub use libc::dirfd; +pub use libc::free; +pub use libc::getpid; +pub use libc::madvise; +pub use libc::malloc; +pub use libc::pthread_atfork; +pub use libc::raise; +pub use libc::DIR; +pub use std::ffi::CStr; +pub use std::ffi::CString; +pub use std::string::String; + +//////////// 调用第三方库函数 + +//////////// 定义类型 +pub type nfds_t = libc::c_ulong; +pub type pid_t = __pid_t; +pub type size_t = libc::c_ulong; +pub type __off_t = libc::c_long; +pub type __ino_t = libc::c_ulong; +pub type __uint64_t = libc::c_ulong; +pub type uint64_t = __uint64_t; +pub type __uint32_t = libc::c_uint; +pub type uint32_t = __uint64_t; +pub type __uint8_t = libc::c_uchar; +pub type uint8_t = __uint8_t; +pub type __time_t = libc::c_long; +pub type __syscall_slong_t = libc::c_long; +pub type __dev_t = libc::c_ulong; +pub type dev_t = __dev_t; +pub type __uid_t = libc::c_uint; +pub type __gid_t = libc::c_uint; +pub type __mode_t = libc::c_uint; + +#[cfg(target_arch = "x86_64")] +pub type __nlink_t = libc::c_ulong; +#[cfg(not(target_arch = "x86_64"))] +pub type __nlink_t = libc::c_uint; + +#[cfg(target_arch = "x86_64")] +pub type __blksize_t = libc::c_long; +#[cfg(not(target_arch = "x86_64"))] +pub type __blksize_t = libc::c_int; + +pub type __off64_t = libc::c_long; +pub type __blkcnt_t = libc::c_long; +pub type __ssize_t = libc::c_long; +pub type gid_t = __gid_t; +pub type uid_t = __uid_t; +pub type ssize_t = __ssize_t; +pub type __pid_t = libc::c_int; +pub type __clock_t = libc::c_long; +pub type __suseconds_t = libc::c_long; +pub type __sig_atomic_t = libc::c_int; +pub type sig_atomic_t = __sig_atomic_t; +pub type time_t = __time_t; +pub type __id_t = libc::c_uint; +pub type id_t = __id_t; +pub type __clockid_t = libc::c_int; +pub type clockid_t = __clockid_t; +pub type off_t = __off_t; +pub type __int32_t = libc::c_int; +pub type FILE = _IO_FILE; +pub type u8 = libc::c_uchar; +pub type u32 = libc::c_uint; +pub type mode_t = __mode_t; +pub type in_addr_t = libc::c_uint; +pub type _IO_lock_t = (); + +pub type sudo_conv_callback_fn_t = + Option libc::c_int>; + +pub type sudo_conv_t = Option< + unsafe extern "C" fn( + libc::c_int, + *const sudo_conv_message, + *mut sudo_conv_reply, + *mut sudo_conv_callback, + ) -> libc::c_int, +>; + +pub type sudo_hook_fn_t = Option libc::c_int>; + +pub type sudo_printf_t = + Option libc::c_int>; + +pub type sudo_fatal_callback_t = Option; + +//////////// 定义静态变量值 +pub const EINVAL: libc::c_int = 22; +pub const SHA512_BLOCK_LENGTH: usize = 128; +pub const __SIGRTMIN: libc::c_uint = 64; +pub const NSIG: libc::c_uint = __SIGRTMIN + 1; +pub const _SC_NGROUPS_MAX: libc::c_uint = 3; +pub const _SC_OPEN_MAX: i32 = 4; +pub const SIZE_MAX: libc::c_ulong = 18446744073709551615; +pub const RSIZE_MAX: libc::c_ulong = SIZE_MAX >> 1; +pub const NGROUPS_MAX: libc::c_uint = 65536; +pub const SUDO_PATH_SECURE: libc::c_int = 0; +pub const SUDO_PATH_MISSING: libc::c_int = -1; +pub const SUDO_PATH_BAD_TYPE: libc::c_int = -2; +pub const SUDO_PATH_WRONG_OWNER: libc::c_int = -3; +pub const SUDO_PATH_WORLD_WRITABLE: libc::c_int = -4; +pub const SUDO_PATH_GROUP_WRITABLE: libc::c_int = -5; +pub const ENOENT: libc::c_int = 2; +pub const _SC_RTSIG_MAX: libc::c_int = 31; +pub const _ISdigit: libc::c_uint = 2048; +pub const ERANGE: libc::c_int = 34; +pub const _ISspace: libc::c_uint = 8192; +pub const SUDO_DEBUG_CRIT: libc::c_int = 1; +pub const SUDO_DEBUG_ERROR: libc::c_int = 2; +pub const SUDO_DEBUG_WARN: libc::c_int = 3; +pub const SUDO_DEBUG_NOTICE: libc::c_int = 4; +pub const SUDO_DEBUG_DIAG: libc::c_int = 5; +pub const SUDO_DEBUG_INFO: libc::c_int = 6; +pub const SUDO_DEBUG_TRACE: libc::c_int = 7; +pub const SUDO_DEBUG_DEBUG: libc::c_int = 8; +pub const SUDO_DEBUG_ERRNO: libc::c_int = 1 << 4; +pub const SUDO_DEBUG_LINENO: libc::c_int = 1 << 5; +pub const SUDO_DEBUG_ARGS: libc::c_int = 1 << 6; +pub const SUDO_DEBUG_CONV: libc::c_int = 2 << 6; +pub const SUDO_DEBUG_EDIT: libc::c_int = 3 << 6; +pub const SUDO_DEBUG_EVENT: libc::c_int = 4 << 6; +pub const SUDO_DEBUG_EXEC: libc::c_int = 5 << 6; +pub const SUDO_DEBUG_HOOKS: libc::c_int = 6 << 6; +pub const SUDO_DEBUG_MAIN: libc::c_int = 7 << 6; +pub const SUDO_DEBUG_NETIF: libc::c_int = 8 << 6; +pub const SUDO_DEBUG_PCOMM: libc::c_int = 9 << 6; +pub const SUDO_DEBUG_PLUGIN: libc::c_int = 10 << 6; +pub const SUDO_DEBUG_PTY: libc::c_int = 11 << 6; +pub const SUDO_DEBUG_SELINUX: libc::c_int = 12 << 6; +pub const SUDO_DEBUG_UTIL: libc::c_int = 13 << 6; +pub const SUDO_DEBUG_UTMP: libc::c_int = 14 << 6; +pub const SUDO_DEBUG_INSTANCE_ERROR: libc::c_int = -2; +pub const SUDO_DEBUG_INSTANCE_INITIALIZER: libc::c_int = -1; +pub const ROOT_UID: libc::c_int = 0 as libc::c_int; +pub const GROUP_API_VERSION_MAJOR: libc::c_int = 1 as libc::c_int; +pub const GROUP_API_VERSION_MINOR: libc::c_int = 0 as libc::c_int; +pub const SUDO_CONV_PROMPT_ECHO_OFF: libc::c_int = 0x0001; +pub const SUDO_CONV_PROMPT_ECHO_ON: libc::c_int = 0x0002; +pub const SUDO_CONV_ERROR_MSG: libc::c_int = 0x0003; +pub const SUDO_CONV_INFO_MSG: libc::c_int = 0x0004; +pub const SUDO_CONV_PROMPT_MASK: libc::c_int = 0x0005; +pub const SUDO_CONV_PROMPT_ECHO_OK: libc::c_int = 0x1000; +pub const SUDO_CONV_PREFER_TTY: libc::c_int = 0x2000; +pub const EOF: libc::c_int = -1; +pub const EPROTONOSUPPORT: libc::c_int = 93; +pub const EAFNOSUPPORT: libc::c_int = 97; +pub const AUDIT_NOT_CONFIGURED: libc::c_int = -2; +pub const AUDIT_USER_CMD: libc::c_int = 1123; +pub const ECONNREFUSED: libc::c_int = 111; +pub const F_SETFD: libc::c_int = 2; +pub const FD_CLOEXEC: libc::c_int = 1; +pub const LC_ALL: libc::c_int = 6; + +pub static mut sudo_debug_subsys: libc::c_int = 0 as libc::c_int; + +pub const MODE_EDIT: libc::c_int = 0x00000002; // 2 +pub const MODE_LOGIN_SHELL: libc::c_int = 0x00040000; +pub const MODE_BACKGROUND: libc::c_int = 0x00010000; +pub const MODE_SHELL: libc::c_int = 0x00020000; +pub const MODE_IMPLIED_SHELL: libc::c_int = 0x00080000; +pub const MODE_RESET_HOME: libc::c_int = 0x00100000; +pub const MODE_PRESERVE_GROUPS: libc::c_int = 0x00200000; +pub const MODE_PRESERVE_ENV: libc::c_int = 0x00400000; +pub const MODE_NONINTERACTIVE: libc::c_int = 0x00800000; +pub const MODE_LONG_LIST: libc::c_int = 0x01000000; + +pub const SUDO_HOOK_VERSION_MAJOR: libc::c_uint = 1; +pub const SUDO_HOOK_VERSION_MINOR: libc::c_uint = 0; + +pub const SUDO_HOOK_SETENV: libc::c_uint = 1; +pub const SUDO_HOOK_UNSETENV: libc::c_uint = 2; +pub const SUDO_HOOK_PUTENV: libc::c_uint = 3; +pub const SUDO_HOOK_GETENV: libc::c_uint = 4; + +pub const SUDOERS_GRAMMAR_VERSION: libc::c_int = 5; +// #define SUDOERS_GRAMMAR_VERSION 46 + +pub const MODE_RUN: libc::c_int = 0x00000001; // 1 +pub const MODE_VALIDATE: libc::c_int = 0x00000004; // 4 +pub const MODE_INVALIDATE: libc::c_int = 0x00000008; // 8 +pub const MODE_KILL: libc::c_int = 0x00000010; // 16 +pub const MODE_VERSION: libc::c_int = 0x00000020; // 32 +pub const MODE_HELP: libc::c_int = 0x00000040; // 64 +pub const MODE_LIST: libc::c_int = 0x00000080; // 128 +pub const MODE_CHECK: libc::c_int = 0x00000100; // 256 +pub const MODE_MASK: libc::c_int = 0x0000ffff; // 65535 + +pub const MAX_UID_T_LEN: libc::c_int = 10; + +pub const SUDO_API_VERSION_MAJOR: libc::c_int = 1; +pub const SUDO_API_VERSION_MINOR: libc::c_int = 13; +pub const SUDO_DSO_DEFAULT: *mut libc::c_void = -(2 as libc::c_int) as *mut libc::c_void; + +pub const ELOOP: libc::c_int = 40; +pub const O_RDONLY: libc::c_int = 0o0; +pub const O_RDWR: libc::c_int = 0o2; +pub const O_CREAT: libc::c_int = 0o100; +pub const EAGAIN: libc::c_int = 11; +pub const EWOULDBLOCK: libc::c_int = 11; +pub const S_ISVTX: libc::c_int = 0o1000; +pub const S_ISGID: libc::c_int = 0o2000; +pub const S_ISUID: libc::c_int = 0o4000; + +//#define SEEK_SET 0 /* Seek from beginning of file. */ +//#define SEEK_END 2 /* Seek from end of file. */ +pub const SEEK_SET: libc::c_int = 0; +pub const SEEK_END: libc::c_int = 2; + +pub const __S_IREAD: libc::c_int = 0o400; +pub const __S_IWRITE: libc::c_int = 0o200; +pub const __S_IEXEC: libc::c_int = 0o100; +pub const S_IRWXU: libc::c_int = __S_IREAD | __S_IWRITE | __S_IEXEC; +pub const S_IXUSR: libc::c_int = 0o100; +pub const S_IXGRP: libc::c_int = S_IXUSR >> 3; +pub const S_IXOTH: libc::c_int = S_IXGRP >> 3; + +pub const S_IRWXG: libc::c_int = S_IRWXU >> 3; +pub const S_IRWXO: libc::c_int = S_IRWXG >> 3; +pub const S_IREAD: libc::c_int = 0o400; +pub const S_IWRITE: libc::c_int = 0o200; + +pub const SIG2STR_MAX: libc::c_int = 32; +pub const SIGALRM: libc::c_int = 14; +pub const SIGBUS: libc::c_int = 10; +pub const SIGCHLD: libc::c_int = 17; +pub const SIGCONT: libc::c_int = 18; +pub const SIGCONT_BG: libc::c_int = -3; +pub const SIGCONT_FG: libc::c_int = -2; +pub const SIGHUP: libc::c_int = 1; +pub const SIGINT: libc::c_int = 2; +pub const SIGKILL: libc::c_int = 9; +pub const SIGPIPE: libc::c_int = 13; +pub const SIGQUIT: libc::c_int = 3; +pub const SIGSTOP: libc::c_int = 19; +pub const SIGSYS: libc::c_int = 12; +pub const SIGTERM: libc::c_int = 15; +pub const SIGTRAP: libc::c_int = 5; +pub const SIGTSTP: libc::c_int = 18; +pub const SIGTTIN: libc::c_int = 21; +pub const SIGTTOU: libc::c_int = 22; +pub const SIGUSR1: libc::c_int = 10; +pub const SIGUSR2: libc::c_int = 12; +pub const SIGWINCH: libc::c_int = 28; +pub const SIG_BLOCK: libc::c_int = 0; +pub const SIG_SETMAS: libc::c_int = 2; +pub const SIG_SETMASK: libc::c_int = 2; +pub const SIG_UNBLOCK: libc::c_int = 1; +pub const SA_RESTART: libc::c_int = 0x10000000; +pub const EINTR: libc::c_int = 4; +pub const SUDO_CONF_DEBUG: libc::c_int = 0x01; +pub const SUDO_CONF_PLUGINS: libc::c_int = 0x04; + +// # define AT_FDCWD -100 +pub const AT_FDCWD: libc::c_int = -100; + +pub const EACCES: libc::c_int = 13; +pub const ENOTDIR: libc::c_int = 20; +pub const SUDO_LOCK: libc::c_int = 1; +pub const SUDO_TLOCK: libc::c_int = 2; +pub const SUDO_UNLOCK: libc::c_int = 4; +pub const SUDO_CONV_REPL_MAX: libc::c_int = 255; + +//#define __S_IFIFO 0010000 /* FIFO. */ +pub const __S_IFIFO: libc::c_int = 0o010000; +pub const _ISblank: libc::c_int = 1; + +//////////// 定义宏 +#[macro_export] +macro_rules! SUDO_API_VERSION { + () => { + SUDO_API_MKVERSION!(SUDO_API_VERSION_MAJOR, SUDO_API_VERSION_MINOR) + }; +} + +#[macro_export] +macro_rules! INT_MAX { + () => { + 0x7fffffff + }; +} + +#[macro_export] +macro_rules! _S_IFMT { + () => { + 0o170000 + }; +} + +#[macro_export] +macro_rules! S_IWUSR { + () => { + 0o200 + }; +} +// #define S_IWGRP (S_IWUSR >> 3) /* Write by group. */ +#[macro_export] +macro_rules! S_IWGRP { + () => { + S_IWUSR!() >> 3 + }; +} + +// #define S_IWOTH (S_IWGRP >> 3) /* Write by others. */ +#[macro_export] +macro_rules! S_IWOTH { + () => { + S_IWGRP!() >> 3 + }; +} + +// #define ISSET(t, f) ((t) & (f)) +#[macro_export] +macro_rules! ISSET { + ($_t:expr, $_f:expr) => { + (($_t) & ($_f)) + }; +} + +/* Extract subsystem number and convert to an index. */ +// #define SUDO_DEBUG_SUBSYS(n) (((n) >> 6) - 1) +#[macro_export] +macro_rules! SUDO_DEBUG_SUBSYS { + ($_n:expr) => { + ((($_n) >> 6) - 1) + }; +} + +/* Extract priority number and convert to an index. */ +// #define SUDO_DEBUG_PRI(n) (((n) & 0x0f) - 1) +#[macro_export] +macro_rules! SUDO_DEBUG_PRI { + ($_n:expr) => { + ((($_n) & 0x0f) - 1) + }; +} + +// #define TIOCGWINSZ 0x5413 +#[macro_export] +macro_rules! TIOCGWINSZ { + () => { + 0x5413 + }; +} + +#[macro_export] +macro_rules! _POSIX_OPEN_MAX { + () => { + 20 + }; +} + +// #define __S_IFREG 0100000 /* Regular file. */ +#[macro_export] +macro_rules! _S_IFREG { + () => { + 0o100000 + }; +} + +// #define __S_IFDIR 0040000 /* Directory. */ +#[macro_export] +macro_rules! _S_IFDIR { + () => { + 0o40000 + }; +} + +// #define INT_MIN (-__INT_MAX__ - 1) +#[macro_export] +macro_rules! INT_MIN { + () => { + (-(INT_MAX!()) - 1) + }; +} + +// #define UINT_MAX (__INT_MAX__ * 2U + 1U) +#[macro_export] +macro_rules! UINT_MAX { + () => { + ((INT_MAX!()) * (2 as libc::c_uint) + 1 as libc::c_uint) + }; +} + +// #define isblank(c) __isctype((c), _ISblank) +#[macro_export] +macro_rules! isblank { + ($c:expr) => { + __isctype!($c, _ISblank) + }; +} + +// # define __isctype(c, type) ((*__ctype_b_loc ())[(int) (c)] & (unsigned short int) type) +#[macro_export] +macro_rules! __isctype { + ($c:expr, $type:expr) => { + (*(*__ctype_b_loc()).offset($c as isize) as libc::c_int) + & ($type as libc::c_int as libc::c_ushort as libc::c_int) + }; +} + +// define _ISbit(bit) ((bit) < 8 ? ((1 << (bit)) << 8) : ((1 << (bit)) >> 8)) +// _ISblank = _ISbit (8), /* Blank (usually SPC and TAB). */ +#[macro_export] +macro_rules! _ISbit { + ($bit:expr) => { + if ($bit) < 8 { + ((1 << ($bit)) << 8) + } else { + ((1 << ($bit)) >> 8) + } + }; +} + +#[macro_export] +macro_rules! _ISblank { + () => { + _ISbit!(8) + }; +} + +macro_rules! SUDO_DEBUG_ALL { + /* all subsystems */ + () => { + 0xffff0000 + }; +} + +#[macro_export] +macro_rules! debug_decl_func { + ($funcname:expr) => {}; +} + +#[macro_export] +macro_rules! debug_decl_vars { + ($subsys:expr) => { + sudo_debug_subsys = $subsys + }; +} + +#[macro_export] +macro_rules! debug_decl { + ($subsys:expr) => { + debug_decl_vars!($subsys); + sudo_debug_enter_v1( + get_function_name!(), + get_file_name!(), + line!() as libc::c_int, + sudo_debug_subsys as libc::c_int, + ); + }; +} + +#[macro_export] +macro_rules! debug_return_int { + ($ret:expr) => {{ + let mut tmp_var: libc::c_int = $ret as libc::c_int; + sudo_debug_exit_int_v1( + get_function_name!(), + get_file_name!(), + line!() as libc::c_int, + sudo_debug_subsys as libc::c_int, + tmp_var, + ); + return tmp_var; + }}; +} + +#[macro_export] +macro_rules! debug_return_id_t { + ($ret:expr) => {{ + sudo_debug_exit_id_t_v1( + get_function_name!(), + get_file_name!(), + line!() as libc::c_int, + sudo_debug_subsys as libc::c_int, + $ret, + ); + return $ret; + }}; +} + +#[macro_export] +macro_rules! debug_return_size_t { + ($ret:expr) => { + sudo_debug_exit_size_t_v1( + get_function_name!(), + get_file_name!(), + line!() as libc::c_int, + sudo_debug_subsys as libc::c_int, + $ret, + ); + return $ret; + }; +} + +#[macro_export] +macro_rules! debug_return_ssize_t { + ($ret:expr) => {{ + sudo_debug_exit_ssize_t_v1( + get_function_name!(), + get_file_name!(), + line!() as libc::c_int, + sudo_debug_subsys as libc::c_int, + $ret, + ); + return $ret; + }}; +} + +#[macro_export] +macro_rules! debug_return_time_t { + ($ret:expr) => {{ + sudo_debug_exit_time_t_v1( + get_function_name!(), + get_file_name!(), + line!() as libc::c_int, + sudo_debug_subsys as libc::c_int, + $ret, + ); + return $ret; + }}; +} + +#[macro_export] +macro_rules! debug_return_long { + ($ret:expr) => { + sudo_debug_exit_long( + get_function_name!(), + get_file_name!(), + line!(), + sudo_debug_subsys, + $ret, + ); + return $ret; + }; +} + +#[macro_export] +macro_rules! debug_return_bool { + ($ret:expr) => {{ + let mut tmp_var: bool = $ret as bool; + sudo_debug_exit_bool_v1( + get_function_name!(), + get_file_name!(), + line!() as libc::c_int, + sudo_debug_subsys as libc::c_int, + tmp_var, + ); + return tmp_var; + }}; +} + +#[macro_export] +macro_rules! debug_return_str { + ($ret:expr) => {{ + sudo_debug_exit_str_v1( + get_function_name!(), + get_file_name!(), + line!() as libc::c_int, + sudo_debug_subsys as libc::c_int, + $ret, + ); + return $ret; + }}; +} + +#[macro_export] +macro_rules! debug_return_const_str { + ($ret:expr) => {{ + sudo_debug_exit_str_v1( + get_function_name!(), + get_file_name!(), + line!() as libc::c_int, + sudo_debug_subsys as libc::c_int, + $ret as *const libc::c_char, + ); + return $ret as *const libc::c_char; + }}; +} + +#[macro_export] +macro_rules! debug_return_str_masked { + ($ret:expr) => {{ + sudo_debug_exit_str_masked_v1( + get_function_name!(), + get_file_name!(), + line!() as libc::c_int, + sudo_debug_subsys as libc::c_int, + $ret, + ); + return $ret; + }}; +} + +#[macro_export] +macro_rules! debug_return_ptr { + ($ret:expr) => {{ + sudo_debug_exit_ptr_v1( + get_function_name!(), + get_file_name!(), + line!() as libc::c_int, + sudo_debug_subsys as libc::c_int, + $ret as *const libc::c_void, + ); + return $ret; + }}; +} + +macro_rules! debug_return_const_ptr { + ($ret:expr) => {{ + sudo_debug_exit_ptr_v1( + get_function_name!(), + get_file_name!(), + line!() as libc::c_int, + sudo_debug_subsys as libc::c_int, + $ret as *const libc::c_void, + ); + return $ret; + }}; +} + +#[macro_export] +macro_rules! sudo_debug_execve { + ($pri:expr, $path:expr, $argv:expr, $envp:expr) => {{ + sudo_debug_execve2_v1( + $pri | sudo_debug_subsys as libc::c_int, + $path as *const libc::c_char, + $argv as *const *mut libc::c_char, + $envp as *const *mut libc::c_char, + ); + }}; +} + +// #define sudo_debug_write(fd, str, len, errnum) \ +// sudo_debug_write2(fd, NULL, NULL, 0, (str), (len), (errnum)) + +macro_rules! sudo_debug_write { + ($fd:expr, $str:expr, $len:expr, $errnum:expr) => {{ + sudo_debug_write2_v1( + $fd as libc::c_int, + 0 as *const libc::c_char, + 0 as *const libc::c_char, + 0 as libc::c_int, + $str as *const libc::c_char, + $len as libc::c_int, + $errnum as libc::c_int, + ); + }}; +} + +// # define sudo_debug_printf(pri, ...) \ +// sudo_debug_printf2(__func__, __FILE__, __LINE__, (pri)|sudo_debug_subsys, \ +// __VA_ARGS__) +// #endif +#[macro_export] +macro_rules! sudo_debug_printf { + ($pri:expr, $($arg:tt)*) => {{ + sudo_debug_printf2_v1( + get_function_name!(), + get_file_name!(), + line!() as libc::c_int, + ($pri | sudo_debug_subsys) as libc::c_int, + $($arg)*, + ); + }}; +} + +#[macro_export] +macro_rules! debug_return { + () => {{ + sudo_debug_exit_v1( + get_function_name!(), + get_file_name!(), + line!() as libc::c_int, + sudo_debug_subsys as libc::c_int, + ); + return; + }}; +} + +// # define sudo_warn(fmt...) do { \ +// sudo_debug_printf2(__func__, __FILE__, __LINE__, \ +// SUDO_DEBUG_ERROR|SUDO_DEBUG_LINENO|SUDO_DEBUG_ERRNO|sudo_debug_subsys, \ +// fmt); \ +// sudo_warn_nodebug_v1(fmt); +// } while (0) +#[macro_export] +macro_rules! sudo_warn { + ($fmt:expr, $($arg:tt)*) => {{ + sudo_debug_printf2_v1( + get_function_name!(), + get_file_name!(), + line!() as libc::c_int, + SUDO_DEBUG_WARN|SUDO_DEBUG_LINENO|SUDO_DEBUG_ERRNO|sudo_debug_subsys, + $fmt, + $($arg)* + ); + sudo_warn_nodebug_v1($fmt, $($arg)*); + }}; +} + +// sudo_warnx(fmt...) do { \ +// sudo_debug_printf2(__func__, __FILE__, __LINE__, \ +// SUDO_DEBUG_ERROR|SUDO_DEBUG_LINENO|sudo_debug_subsys, fmt); \ +// sudo_warnx_nodebug_v1(fmt); +// } while (0) +#[macro_export] +macro_rules! sudo_warnx { + ($fmt:expr, $($arg:tt)*) => {{ + sudo_debug_printf2_v1( + get_function_name!(), + get_file_name!(), + line!() as libc::c_int, + SUDO_DEBUG_WARN|SUDO_DEBUG_LINENO|sudo_debug_subsys, + $fmt, + $($arg)* + ); + sudo_warnx_nodebug_v1( + $fmt, + $($arg)* + ); + }}; +} + +// # define sudo_fatalx(fmt...) do { \ +// sudo_debug_printf2(__func__, __FILE__, __LINE__, \ +// SUDO_DEBUG_ERROR|SUDO_DEBUG_LINENO|sudo_debug_subsys, fmt); \ +// sudo_fatalx_nodebug_v1(fmt); \ +// } while (0) +#[macro_export] +macro_rules! sudo_fatalx { + ($fmt:expr, $($arg:tt)*) => {{ + sudo_debug_printf2_v1( + get_function_name!(), + get_file_name!(), + line!() as libc::c_int, + SUDO_DEBUG_ERROR|SUDO_DEBUG_LINENO|sudo_debug_subsys, + $fmt, + $($arg)* + ); + sudo_fatalx_nodebug_v1( + $fmt, + $($arg)* + ); + }}; +} + +// # define sudo_fatal(fmt...) do { \ +// sudo_debug_printf2(__func__, __FILE__, __LINE__, \ +// SUDO_DEBUG_ERROR|SUDO_DEBUG_LINENO|SUDO_DEBUG_ERRNO|sudo_debug_subsys, \ +// fmt); \ +// sudo_fatal_nodebug_v1(fmt); +// } while (0) +#[macro_export] +macro_rules! sudo_fatal { + ($fmt:expr, $($arg:tt)*) => {{ + sudo_debug_printf2_v1( + get_function_name!(), + get_file_name!(), + line!() as libc::c_int, + SUDO_DEBUG_ERROR|SUDO_DEBUG_LINENO|SUDO_DEBUG_ERRNO|sudo_debug_subsys, + $fmt, + $($arg)* + ); + sudo_fatal_nodebug_v1($fmt, $($arg)*); + }}; +} + +// #define CLR(t, f) ((t) &= ~(f)) +#[macro_export] +macro_rules! CLR { + ($t:expr, $f:expr) => { + (($t) &= !($f)) + }; +} + +// #define SET(t, f) ((t) |= (f)) +#[macro_export] +macro_rules! SET { + ($t:expr, $f:expr) => { + (($t) |= ($f)) + }; +} + +/* Standard file descriptors. */ +// #define STDERR_FILENO 2 /* Standard error output. */ +#[macro_export] +macro_rules! STDERR_FILENO { + () => { + 2 + }; +} + +// #define SIGRTMIN (__libc_current_sigrtmin ()) +#[macro_export] +macro_rules! SIGRTMIN { + () => { + (__libc_current_sigrtmin()) + }; +} + +// #define SIGRTMAX (__libc_current_sigrtmax ()) +#[macro_export] +macro_rules! SIGRTMAX { + () => { + (__libc_current_sigrtmax()) + }; +} + +/* Values for sudo_dso_load() mode. */ +// #define SUDO_DSO_LAZY 0x1 +// #define SUDO_DSO_NOW 0x2 +// #define SUDO_DSO_GLOBAL 0x4 +// #define SUDO_DSO_LOCAL 0x8 +#[macro_export] +macro_rules! SUDO_DSO_LAZY { + () => { + 0x1 + }; +} + +#[macro_export] +macro_rules! SUDO_DSO_NOW { + () => { + 0x2 + }; +} + +#[macro_export] +macro_rules! SUDO_DSO_GLOBAL { + () => { + 0x4 + }; +} + +#[macro_export] +macro_rules! SUDO_DSO_LOCAL { + () => { + 0x8 + }; +} + +/* Getters and setters for plugin API versions */ +// #define SUDO_API_VERSION_GET_MAJOR(v) ((v) >> 16) +// #define SUDO_API_VERSION_GET_MINOR(v) ((v) & 0xffffU) +#[macro_export] +macro_rules! SUDO_API_VERSION_GET_MAJOR { + ($v:expr) => { + (($v) >> 16) + }; +} + +// #define SUDO_API_VERSION_GET_MINOR(v) ((v) & 0xffffU) +#[macro_export] +macro_rules! SUDO_API_VERSION_GET_MINOR { + ($v:expr) => { + (($v) & 0xffff) + }; +} + +#[macro_export] +macro_rules! SUDO_API_MKVERSION { + ($x: expr, $y: expr) => { + ((($x) << 16) | ($y)) + }; +} + +// #define GROUP_API_VERSION SUDO_API_MKVERSION(GROUP_API_VERSION_MAJOR, GROUP_API_VERSION_MINOR) +#[macro_export] +macro_rules! GROUP_API_VERSION { + () => { + (SUDO_API_MKVERSION!(GROUP_API_VERSION_MAJOR, GROUP_API_VERSION_MINOR)) + }; +} + +// #define _PATH_DEV "/dev/" +#[macro_export] +macro_rules! _PATH_DEV { + () => { + b"/dev/\0" as *const u8 as *const libc::c_char + }; +} + +#[macro_export] +macro_rules! SUDO_HOOK_VERSION { + () => { + SUDO_API_MKVERSION!(SUDO_HOOK_VERSION_MAJOR, SUDO_HOOK_VERSION_MINOR) + }; +} + +/* Define to the version of this package. */ +// #define PACKAGE_VERSION "0.0.5" +#[macro_export] +macro_rules! PACKAGE_VERSION { + () => { + (b"0.0.5\0" as *const u8 as *const libc::c_char) + }; +} + +// # define _PATH_NSSWITCH_CONF "/etc/nsswitch.conf" +#[macro_export] +macro_rules! _PATH_NSSWITCH_CONF { + () => { + (b"/etc/nsswitch.conf\0" as *const u8 as *const libc::c_char) + }; +} + +#[macro_export] +macro_rules! ACCESSPERMS { + () => { + (S_IRWXU | S_IRWXG | S_IRWXO) + }; +} + +#[macro_export] +macro_rules! ALLPERMS { + () => { + (S_ISUID as libc::c_int + | S_ISGID as libc::c_int + | S_ISVTX as libc::c_int + | S_IRWXU as libc::c_int + | S_IRWXG as libc::c_int + | S_IRWXO as libc::c_int) + }; +} + +#[macro_export] +macro_rules! USER_SIGNALED { + ($_info:expr) => { + (!($_info).is_null() && (*($_info)).si_code == SI_USER) + }; +} +#[macro_export] +macro_rules! WIFSTOPPED { + ($status:expr) => { + ($status & 0xff == 0x7f) + }; +} +#[macro_export] +macro_rules! WIFSIGNALED { + ($status:expr) => { + (((($status & 0x7f) + 1) >> 1) > 0) + }; +} +#[macro_export] +macro_rules! WEXITSTATUS { + ($status:expr) => { + ((($status) & 0xff00) >> 8) + }; +} +#[macro_export] +macro_rules! WSTOPSIG { + ($status:expr) => { + ((($status) & 0xff00) >> 8) + }; +} +#[macro_export] +macro_rules! WTERMSIG { + ($status:expr) => { + ($status & 0x7f) + }; +} +#[macro_export] +macro_rules! WIFEXITED { + ($status: expr) => { + (WTERMSIG!($status) == 0) + }; +} +// #define S_IFMT 00170000 +#[macro_export] +macro_rules! S_IFMT { + () => { + 0o0170000 + }; +} +// #define __S_ISTYPE(mode, mask) (((mode) & __S_IFMT) == (mask)) +#[macro_export] +macro_rules! __S_ISTYPE { + ($mode:expr, $mask:expr) => { + ((($mode) & S_IFMT!()) == ($mask)) + }; +} +#[macro_export] +macro_rules! S_ISFIFO { + ($mode: expr) => { + __S_ISTYPE!(($mode), __S_IFIFO as libc::c_uint) + }; +} + +#[macro_export] +macro_rules! S_IRUSR { + () => { + 0o400 + }; +} + +// # define S_IRGRP (S_IRUSR >> 3) /* Read by group. */ +#[macro_export] +macro_rules! S_IRGRP { + () => { + (S_IRUSR!() >> 3) + }; +} + +// #define _PATH_TTY "/dev/tty" +#[macro_export] +macro_rules! _PATH_TTY { + () => { + b"/dev/tty\0" as *const u8 as *const libc::c_char + }; +} +#[macro_export] +macro_rules! get_file_name { + () => { + CString::new(file!()).unwrap().as_bytes_with_nul().as_ptr() as *const libc::c_char + }; +} + +#[macro_export] +macro_rules! get_function_name { + () => { + CString::new(stdext::function_name!()) + .unwrap() + .as_bytes_with_nul() + .as_ptr() as *const libc::c_char + }; +} + +//////////// 定义结构体值 +#[derive(Copy, Clone)] +#[repr(C)] +pub struct pollfd { + pub fd: libc::c_int, + pub events: libc::c_short, + pub revents: libc::c_short, +} + +#[derive(Copy, Clone)] +#[repr(C)] +pub struct timespec { + pub tv_sec: __time_t, + pub tv_nsec: __syscall_slong_t, +} + +#[derive(Copy, Clone)] +#[repr(C)] +pub struct SHA2_CTX { + pub state: state, + pub count: [uint64_t; 2], + pub buffer: [uint8_t; SHA512_BLOCK_LENGTH], +} +#[derive(Copy, Clone)] +#[repr(C)] +pub union state { + pub st32: [uint32_t; 8], + pub st64: [uint64_t; 8], +} + +#[derive(Copy, Clone)] +#[repr(C)] +pub struct sudo_event { + pub entries: TAILQ_ENTRY_sudo_event, + pub active_entries: TAILQ_ENTRY_active_entries, + pub timeouts_entries: TAILQ_ENTRY_timeouts_entries, + pub base: *mut sudo_event_base, + pub fd: libc::c_int, + pub events: libc::c_short, + pub revents: libc::c_short, + pub flags: libc::c_short, + pub pfd_idx: libc::c_short, + pub callback: sudo_ev_callback_t, + pub timeout: timespec, + pub closure: *mut libc::c_void, +} +pub type sudo_ev_callback_t = + Option ()>; +#[derive(Copy, Clone)] +#[repr(C)] +pub struct TAILQ_ENTRY_sudo_event { + pub tqe_next: *mut sudo_event, + pub tqe_prev: *mut *mut sudo_event, +} +#[derive(Copy, Clone)] +#[repr(C)] +pub struct TAILQ_ENTRY_active_entries { + pub tqe_next: *mut sudo_event, + pub tqe_prev: *mut *mut sudo_event, +} +#[derive(Copy, Clone)] +#[repr(C)] +pub struct TAILQ_ENTRY_timeouts_entries { + pub tqe_next: *mut sudo_event, + pub tqe_prev: *mut *mut sudo_event, +} +#[derive(Copy, Clone)] +#[repr(C)] +pub struct sudo_event_base { + pub events: sudo_event_list, + pub active: sudo_event_list, + pub timeouts: sudo_event_list, + pub signal_event: sudo_event, + pub signals: [sudo_event_list; NSIG as usize], + pub orig_handlers: [*mut sigaction; NSIG as usize], + pub siginfo: [*mut siginfo_t; NSIG as usize], + pub signal_pending: [sig_atomic_t; NSIG as usize], + pub signal_caught: sig_atomic_t, + pub num_handlers: libc::c_int, + pub signal_pipe: [libc::c_int; 2], + pub pfds: *mut pollfd, + pub pfd_max: libc::c_int, + pub pfd_high: libc::c_int, + pub pfd_free: libc::c_int, + pub flags: libc::c_uint, +} +#[derive(Copy, Clone)] +#[repr(C)] +pub struct sudo_event_list { + pub tqh_first: *mut sudo_event, + pub tqh_last: *mut *mut sudo_event, +} +#[derive(Copy, Clone)] +#[repr(C)] +pub struct sigaction { + pub __sigaction_handler: Signal_handler, + pub sa_mask: __sigset_t, + pub sa_flags: libc::c_int, + pub sa_restorer: Option ()>, +} +#[derive(Copy, Clone)] +#[repr(C)] +pub struct __sigset_t { + pub __val: [libc::c_ulong; 16], +} +pub type sigset_t = __sigset_t; +#[derive(Copy, Clone)] +#[repr(C)] +pub union Signal_handler { + pub sa_handler: __sighandler_t, + pub sa_sigaction: + Option ()>, +} +pub type __sighandler_t = Option ()>; +#[derive(Copy, Clone)] +#[repr(C)] +pub struct siginfo_t { + pub si_signo: libc::c_int, + pub si_errno: libc::c_int, + pub si_code: libc::c_int, + pub __pad0: libc::c_int, + pub _sifields: siginfo_t_u, +} +#[derive(Copy, Clone)] +#[repr(C)] +pub union siginfo_t_u { + pub _pad: [libc::c_int; 28], + pub _kill: _kill_s, + pub _timer: _timer_s, + pub _rt: _rt_s, + pub _sigchld: _sigchld_s, + pub _sigfault: _sigfault_s, + pub _sigpoll: _sigpoll_s, + pub _sigsys: _sigsys_s, +} +#[derive(Copy, Clone)] +#[repr(C)] +pub struct _kill_s { + pub si_pid: __pid_t, + pub si_uid: __uid_t, +} +#[derive(Copy, Clone)] +#[repr(C)] +pub struct _timer_s { + pub si_tid: libc::c_int, + pub si_overrun: libc::c_int, + pub si_sigval: __sigval_t, +} +#[derive(Copy, Clone)] +#[repr(C)] +pub union sigval { + pub sival_int: libc::c_int, + pub sival_ptr: *mut libc::c_void, +} +pub type __sigval_t = sigval; +#[derive(Copy, Clone)] +#[repr(C)] +pub struct _rt_s { + pub si_pid: __pid_t, + pub si_uid: __uid_t, + pub si_sigval: __sigval_t, +} +#[derive(Copy, Clone)] +#[repr(C)] +pub struct _sigchld_s { + pub si_pid: __pid_t, + pub si_uid: __uid_t, + pub si_status: libc::c_int, + pub si_utime: __clock_t, + pub si_stime: __clock_t, +} +#[derive(Copy, Clone)] +#[repr(C)] +pub struct _sigfault_s { + pub si_addr: *mut libc::c_void, + pub si_addr_lsb: libc::c_short, + pub _bounds: _bounds_u, +} +#[derive(Copy, Clone)] +#[repr(C)] +pub union _bounds_u { + pub _addr_bnd: _addr_bnd_s, + pub _pkey: __uint32_t, +} +#[derive(Copy, Clone)] +#[repr(C)] +pub struct _addr_bnd_s { + pub _lower: *mut libc::c_void, + pub _upper: *mut libc::c_void, +} +#[derive(Copy, Clone)] +#[repr(C)] +pub struct _sigpoll_s { + pub si_band: libc::c_long, + pub si_fd: libc::c_int, +} +#[derive(Copy, Clone)] +#[repr(C)] +pub struct _sigsys_s { + pub _call_addr: *mut libc::c_void, + pub _syscall: libc::c_int, + pub _arch: libc::c_uint, +} + +#[derive(Copy, Clone)] +#[repr(C)] +pub struct timeval { + pub tv_sec: __time_t, + pub tv_usec: __suseconds_t, +} + +#[derive(Copy, Clone)] +#[repr(C)] +pub struct _IO_FILE { + pub _flags: libc::c_int, + pub _IO_read_ptr: *mut libc::c_char, + pub _IO_read_end: *mut libc::c_char, + pub _IO_read_base: *mut libc::c_char, + pub _IO_write_base: *mut libc::c_char, + pub _IO_write_ptr: *mut libc::c_char, + pub _IO_write_end: *mut libc::c_char, + pub _IO_buf_base: *mut libc::c_char, + pub _IO_buf_end: *mut libc::c_char, + pub _IO_save_base: *mut libc::c_char, + pub _IO_backup_base: *mut libc::c_char, + pub _IO_save_end: *mut libc::c_char, + pub _markers: *mut _IO_marker, + pub _chain: *mut _IO_FILE, + pub _fileno: libc::c_int, + pub _flags2: libc::c_int, + pub _old_offset: __off_t, + pub _cur_column: libc::c_ushort, + pub _vtable_offset: libc::c_schar, + pub _shortbuf: [libc::c_char; 1], + pub _lock: *mut libc::c_void, + pub _offset: __off64_t, + pub _codecvt: *mut _IO_codecvt, + pub _wide_data: *mut _IO_wide_data, + pub _freeres_list: *mut _IO_FILE, + pub _freeres_buf: *mut libc::c_void, + pub __pad5: size_t, + pub _mode: libc::c_int, + pub _unused2: [libc::c_char; 20], +} + +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _IO_marker { + _unused: [u8; 0], +} + +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _IO_codecvt { + _unused: [u8; 0], +} + +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _IO_wide_data { + _unused: [u8; 0], +} + +#[derive(Copy, Clone)] +#[repr(C)] +pub struct stat { + pub st_dev: __dev_t, + pub st_ino: __ino_t, + #[cfg(target_arch = "x86_64")] + pub st_nlink: __nlink_t, + pub st_mode: __mode_t, + #[cfg(not(target_arch = "x86_64"))] + pub st_nlink: __nlink_t, + pub st_uid: __uid_t, + pub st_gid: __gid_t, + #[cfg(target_arch = "x86_64")] + pub __pad0: libc::c_int, + pub st_rdev: __dev_t, + #[cfg(not(target_arch = "x86_64"))] + pub __pad1: __dev_t, + pub st_size: __off_t, + pub st_blksize: __blksize_t, + #[cfg(not(target_arch = "x86_64"))] + pub __pad2: libc::c_int, + pub st_blocks: __blkcnt_t, + pub st_atim: timespec, + pub st_mtim: timespec, + pub st_ctim: timespec, + #[cfg(target_arch = "x86_64")] + pub __glibc_reserved: [__syscall_slong_t; 3], + #[cfg(not(target_arch = "x86_64"))] + pub __glibc_reserved: [libc::c_int; 2], +} + +#[derive(Copy, Clone)] +#[repr(C)] +pub struct sudo_debug_file { + pub entries: sudo_debug_file_list, + pub debug_file: *mut libc::c_char, + pub debug_flags: *mut libc::c_char, +} + +#[derive(Copy, Clone)] +#[repr(C)] +pub struct sudo_debug_file_list { + pub tqe_next: *mut sudo_debug_file, + pub tqe_prev: *mut *mut sudo_debug_file, +} + +#[derive(Copy, Clone)] +#[repr(C)] +pub struct sudo_conf_debug_file_list { + pub tqh_first: *mut sudo_debug_file, + pub tqh_last: *mut *mut sudo_debug_file, +} + +#[derive(Copy, Clone)] +#[repr(C)] +pub struct winsize { + pub ws_row: libc::c_ushort, + pub ws_col: libc::c_ushort, + pub ws_xpixel: libc::c_ushort, + pub ws_ypixel: libc::c_ushort, +} + +#[derive(Copy, Clone)] +#[repr(C)] +pub struct dirent { + pub d_ino: __ino_t, + pub d_off: __off_t, + pub d_reclen: libc::c_ushort, + pub d_type: libc::c_uchar, + pub d_name: [libc::c_char; 256], +} + +#[derive(Copy, Clone)] +#[repr(C)] +pub union TMP_T { + pub __u6_addr8: [libc::c_uchar; 16], + pub __u6_addr16: [libc::c_ushort; 8], + pub __u6_addr32: [libc::c_uint; 4], +} + +#[derive(Copy, Clone)] +#[repr(C)] +pub struct in6_addr { + pub __in6_u: TMP_T, +} + +#[derive(Copy, Clone)] +#[repr(C)] +pub struct in_addr { + pub s_addr: in_addr_t, +} + +//add by bgz +//orig_c: DPRINTF1("STRING.....",base); +#[macro_export] +macro_rules! dprintf1 { + ($fmt:expr, $($arg:tt)*) => {{ + sudo_debug_printf2_v1( + get_function_name!(), + get_file_name!(), + line!() as libc::c_int, + (5) | sudo_debug_subsys, + $fmt, + $($arg)* + ); + if ldap_conf.debug >= 1 { + sudo_warnx_nodebug_v1( + $fmt, + $($arg)* + ); + } + }}; +} + +//orig_c: DPRINTF2("STRING.....",base); +#[macro_export] +macro_rules! dprintf2 { + ($fmt:expr, $($arg:tt)*) => {{ + sudo_debug_printf2_v1( + get_function_name!(), + get_file_name!(), + line!() as libc::c_int, + (6) | sudo_debug_subsys, + $fmt, + $($arg)* + ); + if ldap_conf.debug >= 2 { + sudo_warnx_nodebug_v1( + $fmt, + $($arg)* + ); + } + }}; +} +//end of bgz + +#[derive(Copy, Clone)] +#[repr(C)] +pub struct group { + pub gr_name: *mut libc::c_char, + pub gr_passwd: *mut libc::c_char, + pub gr_gid: __gid_t, + pub gr_mem: *mut *mut libc::c_char, +} + +#[derive(Copy, Clone)] +#[repr(C)] +pub struct sudo_conv_callback { + pub version: libc::c_uint, + pub closure: *mut libc::c_void, + pub on_suspend: sudo_conv_callback_fn_t, + pub on_resume: sudo_conv_callback_fn_t, +} + +#[derive(Copy, Clone)] +#[repr(C)] +pub struct policy_plugin { + pub type_0: libc::c_uint, + pub version: libc::c_uint, + pub open: Option< + unsafe extern "C" fn( + libc::c_uint, + sudo_conv_t, + sudo_printf_t, + *const *mut libc::c_char, + *const *mut libc::c_char, + *const *mut libc::c_char, + *const *mut libc::c_char, + ) -> libc::c_int, + >, + pub close: Option ()>, + pub show_version: Option libc::c_int>, + pub check_policy: Option< + unsafe extern "C" fn( + libc::c_int, + *const *mut libc::c_char, + *mut *mut libc::c_char, + *mut *mut *mut libc::c_char, + *mut *mut *mut libc::c_char, + *mut *mut *mut libc::c_char, + ) -> libc::c_int, + >, + pub list: Option< + unsafe extern "C" fn( + libc::c_int, + *const *mut libc::c_char, + libc::c_int, + *const libc::c_char, + ) -> libc::c_int, + >, + pub validate: Option libc::c_int>, + pub invalidate: Option ()>, + pub init_session: + Option libc::c_int>, + pub register_hooks: Option< + unsafe extern "C" fn( + libc::c_int, + Option libc::c_int>, + ) -> (), + >, + pub deregister_hooks: Option< + unsafe extern "C" fn( + libc::c_int, + Option libc::c_int>, + ) -> (), + >, +} + +#[derive(Copy, Clone)] +#[repr(C)] +pub struct sudo_conv_message { + pub msg_type: libc::c_int, + pub timeout: libc::c_int, + pub msg: *const libc::c_char, +} + +#[derive(Copy, Clone)] +#[repr(C)] +pub struct sudo_conv_reply { + pub reply: *mut libc::c_char, +} + +#[derive(Copy, Clone)] +#[repr(C)] +pub struct sudo_hook { + pub hook_version: libc::c_uint, + pub hook_type: libc::c_uint, + pub hook_fn: sudo_hook_fn_t, + pub closure: *mut libc::c_void, +} + +#[derive(Copy, Clone)] +#[repr(C)] +pub struct passwd { + pub pw_name: *mut libc::c_char, + pub pw_passwd: *mut libc::c_char, + pub pw_uid: __uid_t, + pub pw_gid: __gid_t, + pub pw_gecos: *mut libc::c_char, + pub pw_dir: *mut libc::c_char, + pub pw_shell: *mut libc::c_char, +} + +#[derive(Copy, Clone)] +#[repr(C)] +pub struct iovec { + pub iov_base: *mut libc::c_void, + pub iov_len: size_t, +} +#[derive(Copy, Clone)] +#[repr(C)] +pub struct plugin_info { + pub entries: C2RustUnnamed_1, + pub path: *mut libc::c_char, + pub symbol_name: *mut libc::c_char, + pub options: *mut *mut libc::c_char, + pub lineno: libc::c_uint, +} +#[derive(Copy, Clone)] +#[repr(C)] +pub struct C2RustUnnamed_1 { + pub tqe_next: *mut plugin_info, + pub tqe_prev: *mut *mut plugin_info, +} +#[derive(Copy, Clone)] +#[repr(C)] +pub struct plugin_info_list { + pub tqh_first: *mut plugin_info, + pub tqh_last: *mut *mut plugin_info, +} + +#[derive(Copy, Clone)] +#[repr(C)] +pub struct option { + pub name: *const libc::c_char, + pub has_arg: libc::c_int, + pub flag: *mut libc::c_int, + pub val: libc::c_int, +} + +//下面的三个值，只用于初始化变量时调用，不会修改值。 +pub const sb_all_arch: stat = stat { + st_dev: 0, + st_ino: 0, + st_nlink: 0, + st_mode: 0, + st_uid: 0, + st_gid: 0, + #[cfg(target_arch = "x86_64")] + __pad0: 0, + st_rdev: 0, + #[cfg(not(target_arch = "x86_64"))] + __pad1: 0, + st_size: 0, + st_blksize: 0, + #[cfg(not(target_arch = "x86_64"))] + __pad2: 0, + st_blocks: 0, + st_atim: timespec { + tv_sec: 0, + tv_nsec: 0, + }, + st_mtim: timespec { + tv_sec: 0, + tv_nsec: 0, + }, + st_ctim: timespec { + tv_sec: 0, + tv_nsec: 0, + }, + #[cfg(target_arch = "x86_64")] + __glibc_reserved: [0; 3], + #[cfg(not(target_arch = "x86_64"))] + __glibc_reserved: [0; 2], +}; + +#[cfg(target_arch = "x86_64")] +pub const xstat_flag: libc::c_int = 1; + +#[cfg(not(target_arch = "x86_64"))] +pub const xstat_flag: libc::c_int = 0; diff --git a/lib/util/src/digest.rs b/lib/util/src/digest.rs index 4c7edf3..762d88b 100644 --- a/lib/util/src/digest.rs +++ b/lib/util/src/digest.rs @@ -13,33 +13,14 @@ unused_assignments )] -//call other file's func -use crate::sha2::sudo_SHA224Final; -use crate::sha2::sudo_SHA224Init; -use crate::sha2::sudo_SHA224Update; -use crate::sha2::sudo_SHA256Final; -use crate::sha2::sudo_SHA256Init; -use crate::sha2::sudo_SHA256Update; -use crate::sha2::sudo_SHA384Final; -use crate::sha2::sudo_SHA384Init; -use crate::sha2::sudo_SHA384Update; -use crate::sha2::sudo_SHA512Final; -use crate::sha2::sudo_SHA512Init; -use crate::sha2::sudo_SHA512Update; -use crate::sha2::SHA2_CTX; -use crate::sudo_debug::sudo_debug_enter_v1; -use crate::sudo_debug::sudo_debug_exit_int_v1; -use crate::sudo_debug::sudo_debug_exit_ptr_v1; -use crate::sudo_debug::sudo_debug_exit_v1; -use crate::sudo_debug_macro::SUDO_DEBUG_UTIL; -use libc::free; -use libc::malloc; - -pub type size_t = libc::c_ulong; -pub type uint8_t = libc::c_uchar; +use crate::common::*; +use crate::sha2::*; //define -pub const EINVAL: libc::c_int = 22; +//#define SHA224_DIGEST_LENGTH 28 +//#define SHA256_DIGEST_LENGTH 32 +//#define SHA384_DIGEST_LENGTH 48 +//#define SHA512_DIGEST_LENGTH 64 pub const SHA224_DIGEST_LENGTH: libc::c_uint = 28; pub const SHA256_DIGEST_LENGTH: libc::c_uint = 32; pub const SHA384_DIGEST_LENGTH: libc::c_uint = 48; @@ -49,13 +30,14 @@ extern "C" { fn __errno_location() -> *mut libc::c_int; } +//line 55 pub struct digest_function { pub digest_len: libc::c_uint, pub init: Option ()>, pub update: Option ()>, pub final_0: Option ()>, } - +//line 65-89 static mut digest_functions: [digest_function; 5] = { [ { @@ -127,6 +109,7 @@ static mut digest_functions: [digest_function; 5] = { ] }; +//line91 pub struct sudo_digest { pub func: *mut digest_function, pub ctx: SHA2_CTX, @@ -135,7 +118,7 @@ pub struct sudo_digest { //line 97 #[no_mangle] unsafe extern "C" fn sudo_digest_alloc_v1(mut digest_type: libc::c_int) -> *mut sudo_digest { - debug_decl!(stdext::function_name!().as_ptr(), SUDO_DEBUG_UTIL); + debug_decl!(SUDO_DEBUG_UTIL); //line 100 let mut func: *mut digest_function = 0 as *mut digest_function; @@ -173,27 +156,30 @@ unsafe extern "C" fn sudo_digest_alloc_v1(mut digest_type: libc::c_int) -> *mut debug_return_ptr!(dig); } +//line124-130 #[no_mangle] unsafe fn sudo_digest_free_v1(mut dig: *mut sudo_digest) { - debug_decl!(stdext::function_name!().as_ptr(), SUDO_DEBUG_UTIL); + debug_decl!(SUDO_DEBUG_UTIL); free(dig as *mut libc::c_void); debug_return!() } +//line134-140 #[no_mangle] unsafe fn sudo_digest_reset_v1(mut dig: *mut sudo_digest) { - debug_decl!(stdext::function_name!().as_ptr(), SUDO_DEBUG_UTIL); + debug_decl!(SUDO_DEBUG_UTIL); ((*(*dig).func).init).expect("is not func pointer")(&mut (*dig).ctx); debug_return!() } +//line 144-155 #[no_mangle] unsafe fn sudo_digest_getlen_v1(mut digest_type: libc::c_int) -> libc::c_int { - debug_decl!(stdext::function_name!().as_ptr(), SUDO_DEBUG_UTIL); + debug_decl!(SUDO_DEBUG_UTIL); let mut i: libc::c_int = 0; @@ -209,13 +195,14 @@ unsafe fn sudo_digest_getlen_v1(mut digest_type: libc::c_int) -> libc::c_int { debug_return_int!(-1) } +//line 158 #[no_mangle] unsafe fn sudo_digest_update_v1( mut dig: *mut sudo_digest, mut data: *const libc::c_void, mut len: size_t, ) { - debug_decl!(stdext::function_name!().as_ptr(), SUDO_DEBUG_UTIL); + debug_decl!(SUDO_DEBUG_UTIL); //162 ((*(*dig).func).update).expect("is not null func point")( @@ -231,7 +218,7 @@ unsafe fn sudo_digest_update_v1( //line168 #[no_mangle] unsafe fn sudo_digest_final_v1(mut dig: *mut sudo_digest, mut md: *mut libc::c_uchar) { - debug_decl!(stdext::function_name!().as_ptr(), SUDO_DEBUG_UTIL); + debug_decl!(SUDO_DEBUG_UTIL); ((*(*dig).func).final_0).expect("is not func point")(md, &mut (*dig).ctx); diff --git a/lib/util/src/event.rs b/lib/util/src/event.rs index 09b50d5..7777a47 100644 --- a/lib/util/src/event.rs +++ b/lib/util/src/event.rs @@ -14,13 +14,7 @@ unused_mut )] -#[derive(Copy, Clone)] -#[repr(C)] -pub struct pollfd { - pub fd: libc::c_int, - pub events: libc::c_short, - pub revents: libc::c_short, -} +use crate::common::*; extern "C" { fn malloc(_: libc::c_ulong) -> *mut libc::c_void; @@ -93,148 +87,6 @@ extern "C" { fn sudo_gettime_mono_v1(ts: *mut timespec) -> libc::c_int; } -pub type __uint32_t = libc::c_uint; -pub type __uid_t = libc::c_uint; -pub type __pid_t = libc::c_int; -pub type __clock_t = libc::c_long; -pub type __time_t = libc::c_long; -pub type __suseconds_t = libc::c_long; -pub type __ssize_t = libc::c_long; -pub type __syscall_slong_t = libc::c_long; -pub type __sig_atomic_t = libc::c_int; -pub type ssize_t = __ssize_t; -pub type size_t = libc::c_ulong; - -#[derive(Copy, Clone)] -#[repr(C)] -pub struct __sigset_t { - pub __val: [libc::c_ulong; 16], -} -pub type sigset_t = __sigset_t; - -#[derive(Copy, Clone)] -#[repr(C)] -pub struct timeval { - pub tv_sec: __time_t, - pub tv_usec: __suseconds_t, -} -#[derive(Copy, Clone)] -#[repr(C)] -pub struct timespec { - pub tv_sec: __time_t, - pub tv_nsec: __syscall_slong_t, -} -pub type __sigval_t = sigval; -#[derive(Copy, Clone)] -#[repr(C)] -pub union sigval { - pub sival_int: libc::c_int, - pub sival_ptr: *mut libc::c_void, -} - -pub type sig_atomic_t = __sig_atomic_t; -#[derive(Copy, Clone)] -#[repr(C)] -pub struct siginfo_t { - pub si_signo: libc::c_int, - pub si_errno: libc::c_int, - pub si_code: libc::c_int, - pub __pad0: libc::c_int, - pub _sifields: C2RustUnnamed, -} -#[derive(Copy, Clone)] -#[repr(C)] -pub union C2RustUnnamed { - pub _pad: [libc::c_int; 28], - pub _kill: C2RustUnnamed_8, - pub _timer: C2RustUnnamed_7, - pub _rt: C2RustUnnamed_6, - pub _sigchld: C2RustUnnamed_5, - pub _sigfault: C2RustUnnamed_2, - pub _sigpoll: C2RustUnnamed_1, - pub _sigsys: C2RustUnnamed_0, -} -#[derive(Copy, Clone)] -#[repr(C)] -pub struct C2RustUnnamed_0 { - pub _call_addr: *mut libc::c_void, - pub _syscall: libc::c_int, - pub _arch: libc::c_uint, -} -#[derive(Copy, Clone)] -#[repr(C)] -pub struct C2RustUnnamed_1 { - pub si_band: libc::c_long, - pub si_fd: libc::c_int, -} -#[derive(Copy, Clone)] -#[repr(C)] -pub struct C2RustUnnamed_2 { - pub si_addr: *mut libc::c_void, - pub si_addr_lsb: libc::c_short, - pub _bounds: C2RustUnnamed_3, -} -#[derive(Copy, Clone)] -#[repr(C)] -pub union C2RustUnnamed_3 { - pub _addr_bnd: C2RustUnnamed_4, - pub _pkey: __uint32_t, -} -#[derive(Copy, Clone)] -#[repr(C)] -pub struct C2RustUnnamed_4 { - pub _lower: *mut libc::c_void, - pub _upper: *mut libc::c_void, -} -#[derive(Copy, Clone)] -#[repr(C)] -pub struct C2RustUnnamed_5 { - pub si_pid: __pid_t, - pub si_uid: __uid_t, - pub si_status: libc::c_int, - pub si_utime: __clock_t, - pub si_stime: __clock_t, -} -#[derive(Copy, Clone)] -#[repr(C)] -pub struct C2RustUnnamed_6 { - pub si_pid: __pid_t, - pub si_uid: __uid_t, - pub si_sigval: __sigval_t, -} -#[derive(Copy, Clone)] -#[repr(C)] -pub struct C2RustUnnamed_7 { - pub si_tid: libc::c_int, - pub si_overrun: libc::c_int, - pub si_sigval: __sigval_t, -} -#[derive(Copy, Clone)] -#[repr(C)] -pub struct C2RustUnnamed_8 { - pub si_pid: __pid_t, - pub si_uid: __uid_t, -} -pub type __sighandler_t = Option ()>; - -#[derive(Copy, Clone)] -#[repr(C)] -pub struct sigaction { - pub __sigaction_handler: C2RustUnnamed_9, - pub sa_mask: __sigset_t, - pub sa_flags: libc::c_int, - pub sa_restorer: Option ()>, -} -#[derive(Copy, Clone)] -#[repr(C)] -pub union C2RustUnnamed_9 { - pub sa_handler: __sighandler_t, - pub sa_sigaction: - Option ()>, -} -pub type sudo_ev_callback_t = - Option ()>; - #[derive(Copy, Clone)] #[repr(C)] pub struct sudo_ev_siginfo_container { @@ -242,69 +94,9 @@ pub struct sudo_ev_siginfo_container { pub siginfo: *mut siginfo_t, pub si_buf: [libc::c_char; 1], } -#[derive(Copy, Clone)] -#[repr(C)] -pub struct sudo_event { - pub entries: C2RustUnnamed_12, - pub active_entries: C2RustUnnamed_11, - pub timeouts_entries: C2RustUnnamed_10, - pub base: *mut sudo_event_base, - pub fd: libc::c_int, - pub events: libc::c_short, - pub revents: libc::c_short, - pub flags: libc::c_short, - pub pfd_idx: libc::c_short, - pub callback: sudo_ev_callback_t, - pub timeout: timespec, - pub closure: *mut libc::c_void, -} -#[derive(Copy, Clone)] -#[repr(C)] -pub struct sudo_event_base { - pub events: sudo_event_list, - pub active: sudo_event_list, - pub timeouts: sudo_event_list, - pub signal_event: sudo_event, - pub signals: [sudo_event_list; 65], - pub orig_handlers: [*mut sigaction; 65], - pub siginfo: [*mut siginfo_t; 65], - pub signal_pending: [sig_atomic_t; 65], - pub signal_caught: sig_atomic_t, - pub num_handlers: libc::c_int, - pub signal_pipe: [libc::c_int; 2], - pub pfds: *mut pollfd, - pub pfd_max: libc::c_int, - pub pfd_high: libc::c_int, - pub pfd_free: libc::c_int, - pub flags: libc::c_uint, -} -#[derive(Copy, Clone)] -#[repr(C)] -pub struct sudo_event_list { - pub tqh_first: *mut sudo_event, - pub tqh_last: *mut *mut sudo_event, -} -#[derive(Copy, Clone)] -#[repr(C)] -pub struct C2RustUnnamed_10 { - pub tqe_next: *mut sudo_event, - pub tqe_prev: *mut *mut sudo_event, -} -#[derive(Copy, Clone)] -#[repr(C)] -pub struct C2RustUnnamed_11 { - pub tqe_next: *mut sudo_event, - pub tqe_prev: *mut *mut sudo_event, -} -#[derive(Copy, Clone)] -#[repr(C)] -pub struct C2RustUnnamed_12 { - pub tqe_next: *mut sudo_event, - pub tqe_prev: *mut *mut sudo_event, -} + static mut default_base: *mut sudo_event_base = 0 as *const sudo_event_base as *mut sudo_event_base; static mut signal_base: *mut sudo_event_base = 0 as *const sudo_event_base as *mut sudo_event_base; - #[no_mangle] pub unsafe extern "C" fn sudo_ev_activate(mut base: *mut sudo_event_base, mut ev: *mut sudo_event) { (*ev).active_entries.tqe_next = 0 as *mut sudo_event; @@ -313,7 +105,6 @@ pub unsafe extern "C" fn sudo_ev_activate(mut base: *mut sudo_event_base, mut ev (*base).active.tqh_last = &mut (*ev).active_entries.tqe_next; (*ev).flags = ((*ev).flags as libc::c_int | 0x2 as libc::c_int) as libc::c_short; } - #[inline] unsafe extern "C" fn sudo_ev_deactivate(mut base: *mut sudo_event_base, mut ev: *mut sudo_event) { (*ev).flags = ((*ev).flags as libc::c_int & !(0x2 as libc::c_int)) as libc::c_short; @@ -324,10 +115,8 @@ unsafe extern "C" fn sudo_ev_deactivate(mut base: *mut sudo_event_base, mut ev: } *(*ev).active_entries.tqe_prev = (*ev).active_entries.tqe_next; } - unsafe extern "C" fn sudo_ev_deactivate_all(mut base: *mut sudo_event_base) { let mut ev: *mut sudo_event = 0 as *mut sudo_event; - let sudo_debug_subsys: libc::c_int = (4 as libc::c_int) << 6 as libc::c_int; sudo_debug_enter_v1( (*::core::mem::transmute::<&[u8; 23], &[libc::c_char; 23]>(b"sudo_ev_deactivate_all\0")) .as_ptr(), @@ -335,7 +124,6 @@ unsafe extern "C" fn sudo_ev_deactivate_all(mut base: *mut sudo_event_base) { 89 as libc::c_int, sudo_debug_subsys, ); - loop { ev = (*base).active.tqh_first; if ev.is_null() { @@ -351,13 +139,11 @@ unsafe extern "C" fn sudo_ev_deactivate_all(mut base: *mut sudo_event_base) { sudo_debug_subsys, ); } - unsafe extern "C" fn sudo_ev_activate_sigevents(mut base: *mut sudo_event_base) { let mut ev: *mut sudo_event = 0 as *mut sudo_event; let mut set: sigset_t = sigset_t { __val: [0; 16] }; let mut oset: sigset_t = sigset_t { __val: [0; 16] }; let mut i: libc::c_int = 0; - let sudo_debug_subsys: libc::c_int = (4 as libc::c_int) << 6 as libc::c_int; sudo_debug_enter_v1( (*::core::mem::transmute::<&[u8; 27], &[libc::c_char; 27]>( b"sudo_ev_activate_sigevents\0", @@ -367,7 +153,6 @@ unsafe extern "C" fn sudo_ev_activate_sigevents(mut base: *mut sudo_event_base) 107 as libc::c_int, sudo_debug_subsys, ); - sigfillset(&mut set); sigprocmask(0 as libc::c_int, &mut set, &mut oset); (*base).signal_caught = 0 as libc::c_int; @@ -415,7 +200,6 @@ unsafe extern "C" fn sudo_ev_activate_sigevents(mut base: *mut sudo_event_base) sudo_debug_subsys, ); } - unsafe extern "C" fn signal_pipe_cb( mut fd: libc::c_int, mut _what: libc::c_int, @@ -424,14 +208,12 @@ unsafe extern "C" fn signal_pipe_cb( let mut base: *mut sudo_event_base = v as *mut sudo_event_base; let mut ch: libc::c_uchar = 0; let mut nread: ssize_t = 0; - let sudo_debug_subsys: libc::c_int = (4 as libc::c_int) << 6 as libc::c_int; sudo_debug_enter_v1( (*::core::mem::transmute::<&[u8; 15], &[libc::c_char; 15]>(b"signal_pipe_cb\0")).as_ptr(), b"event.c\0" as *const u8 as *const libc::c_char, 151 as libc::c_int, sudo_debug_subsys, ); - loop { nread = read( fd, @@ -453,7 +235,6 @@ unsafe extern "C" fn signal_pipe_cb( ch as libc::c_int, ); } - if nread == -(1 as libc::c_int) as libc::c_long && *__errno_location() != 11 as libc::c_int { sudo_debug_printf2_v1( (*::core::mem::transmute::<&[u8; 15], &[libc::c_char; 15]>(b"signal_pipe_cb\0")) @@ -478,10 +259,8 @@ unsafe extern "C" fn signal_pipe_cb( sudo_debug_subsys, ); } - unsafe extern "C" fn sudo_ev_base_init(mut base: *mut sudo_event_base) -> libc::c_int { let mut i: libc::c_int = 0; - let sudo_debug_subsys: libc::c_int = (4 as libc::c_int) << 6 as libc::c_int; sudo_debug_enter_v1( (*::core::mem::transmute::<&[u8; 18], &[libc::c_char; 18]>(b"sudo_ev_base_init\0")) .as_ptr(), @@ -560,11 +339,9 @@ unsafe extern "C" fn sudo_ev_base_init(mut base: *mut sudo_event_base) -> libc:: ); return sudo_debug_ret_0; } - #[no_mangle] pub unsafe extern "C" fn sudo_ev_base_alloc_v1() -> *mut sudo_event_base { let mut base: *mut sudo_event_base = 0 as *mut sudo_event_base; - let sudo_debug_subsys: libc::c_int = (4 as libc::c_int) << 6 as libc::c_int; sudo_debug_enter_v1( (*::core::mem::transmute::<&[u8; 22], &[libc::c_char; 22]>(b"sudo_ev_base_alloc_v1\0")) .as_ptr(), @@ -598,7 +375,6 @@ pub unsafe extern "C" fn sudo_ev_base_alloc_v1() -> *mut sudo_event_base { ); return sudo_debug_ret as *mut sudo_event_base; } - if sudo_ev_base_init(base) != 0 as libc::c_int { free(base as *mut libc::c_void); let mut sudo_debug_ret_0: *mut libc::c_void = 0 as *mut libc::c_void; @@ -623,13 +399,11 @@ pub unsafe extern "C" fn sudo_ev_base_alloc_v1() -> *mut sudo_event_base { ); return sudo_debug_ret_1 as *mut sudo_event_base; } - #[no_mangle] pub unsafe extern "C" fn sudo_ev_base_free_v1(mut base: *mut sudo_event_base) { let mut ev: *mut sudo_event = 0 as *mut sudo_event; let mut next: *mut sudo_event = 0 as *mut sudo_event; let mut i: libc::c_int = 0; - let sudo_debug_subsys: libc::c_int = (4 as libc::c_int) << 6 as libc::c_int; sudo_debug_enter_v1( (*::core::mem::transmute::<&[u8; 21], &[libc::c_char; 21]>(b"sudo_ev_base_free_v1\0")) .as_ptr(), @@ -684,10 +458,8 @@ pub unsafe extern "C" fn sudo_ev_base_free_v1(mut base: *mut sudo_event_base) { sudo_debug_subsys, ); } - #[no_mangle] pub unsafe extern "C" fn sudo_ev_base_setdef_v1(mut base: *mut sudo_event_base) { - let sudo_debug_subsys: libc::c_int = (4 as libc::c_int) << 6 as libc::c_int; sudo_debug_enter_v1( (*::core::mem::transmute::<&[u8; 23], &[libc::c_char; 23]>(b"sudo_ev_base_setdef_v1\0")) .as_ptr(), @@ -704,7 +476,6 @@ pub unsafe extern "C" fn sudo_ev_base_setdef_v1(mut base: *mut sudo_event_base) sudo_debug_subsys, ); } - unsafe extern "C" fn sudo_ev_init( mut ev: *mut sudo_event, mut fd: libc::c_int, @@ -712,7 +483,6 @@ unsafe extern "C" fn sudo_ev_init( mut callback: sudo_ev_callback_t, mut closure: *mut libc::c_void, ) { - let sudo_debug_subsys: libc::c_int = (4 as libc::c_int) << 6 as libc::c_int; sudo_debug_enter_v1( (*::core::mem::transmute::<&[u8; 13], &[libc::c_char; 13]>(b"sudo_ev_init\0")).as_ptr(), b"event.c\0" as *const u8 as *const libc::c_char, @@ -744,7 +514,6 @@ pub unsafe extern "C" fn sudo_ev_alloc_v1( mut closure: *mut libc::c_void, ) -> *mut sudo_event { let mut ev: *mut sudo_event = 0 as *mut sudo_event; - let sudo_debug_subsys: libc::c_int = (4 as libc::c_int) << 6 as libc::c_int; sudo_debug_enter_v1( (*::core::mem::transmute::<&[u8; 17], &[libc::c_char; 17]>(b"sudo_ev_alloc_v1\0")).as_ptr(), b"event.c\0" as *const u8 as *const libc::c_char, @@ -820,7 +589,6 @@ pub unsafe extern "C" fn sudo_ev_alloc_v1( } #[no_mangle] pub unsafe extern "C" fn sudo_ev_free_v1(mut ev: *mut sudo_event) { - let sudo_debug_subsys: libc::c_int = (4 as libc::c_int) << 6 as libc::c_int; sudo_debug_enter_v1( (*::core::mem::transmute::<&[u8; 16], &[libc::c_char; 16]>(b"sudo_ev_free_v1\0")).as_ptr(), b"event.c\0" as *const u8 as *const libc::c_char, @@ -886,7 +654,6 @@ unsafe extern "C" fn sudo_ev_add_signal( mut tohead: bool, ) -> libc::c_int { let signo: libc::c_int = (*ev).fd; - let sudo_debug_subsys: libc::c_int = (4 as libc::c_int) << 6 as libc::c_int; sudo_debug_enter_v1( (*::core::mem::transmute::<&[u8; 19], &[libc::c_char; 19]>(b"sudo_ev_add_signal\0")) .as_ptr(), @@ -1029,7 +796,7 @@ unsafe extern "C" fn sudo_ev_add_signal( } if ((*base).signals[signo as usize].tqh_first).is_null() { let mut sa: sigaction = sigaction { - __sigaction_handler: C2RustUnnamed_9 { sa_handler: None }, + __sigaction_handler: Signal_handler { sa_handler: None }, sa_mask: sigset_t { __val: [0; 16] }, sa_flags: 0, sa_restorer: None, @@ -1117,7 +884,6 @@ unsafe extern "C" fn sudo_ev_add_signal( ); return sudo_debug_ret_4; } - #[no_mangle] pub unsafe extern "C" fn sudo_ev_add_v1( mut base: *mut sudo_event_base, @@ -1137,7 +903,6 @@ pub unsafe extern "C" fn sudo_ev_add_v1( } return sudo_ev_add_v2(base, ev, ts, tohead); } - #[no_mangle] pub unsafe extern "C" fn sudo_ev_add_v2( mut base: *mut sudo_event_base, @@ -1145,7 +910,6 @@ pub unsafe extern "C" fn sudo_ev_add_v2( mut timo: *mut timespec, mut tohead: bool, ) -> libc::c_int { - let sudo_debug_subsys: libc::c_int = (4 as libc::c_int) << 6 as libc::c_int; sudo_debug_enter_v1( (*::core::mem::transmute::<&[u8; 15], &[libc::c_char; 15]>(b"sudo_ev_add_v2\0")).as_ptr(), b"event.c\0" as *const u8 as *const libc::c_char, @@ -1317,13 +1081,11 @@ pub unsafe extern "C" fn sudo_ev_add_v2( ); return sudo_debug_ret_2; } - #[no_mangle] pub unsafe extern "C" fn sudo_ev_del_v1( mut base: *mut sudo_event_base, mut ev: *mut sudo_event, ) -> libc::c_int { - let sudo_debug_subsys: libc::c_int = (4 as libc::c_int) << 6 as libc::c_int; sudo_debug_enter_v1( (*::core::mem::transmute::<&[u8; 15], &[libc::c_char; 15]>(b"sudo_ev_del_v1\0")).as_ptr(), b"event.c\0" as *const u8 as *const libc::c_char, @@ -1534,12 +1296,10 @@ pub unsafe extern "C" fn sudo_ev_del_v1( ); return sudo_debug_ret_4; } - #[no_mangle] pub unsafe extern "C" fn sudo_ev_dispatch_v1(mut base: *mut sudo_event_base) -> libc::c_int { return sudo_ev_loop_v1(base, 0 as libc::c_int); } - #[no_mangle] pub unsafe extern "C" fn sudo_ev_loop_v1( mut base: *mut sudo_event_base, @@ -1552,7 +1312,6 @@ pub unsafe extern "C" fn sudo_ev_loop_v1( let mut ev: *mut sudo_event = 0 as *mut sudo_event; let mut nready: libc::c_int = 0; let mut rc: libc::c_int = 0 as libc::c_int; - let sudo_debug_subsys: libc::c_int = (4 as libc::c_int) << 6 as libc::c_int; sudo_debug_enter_v1( (*::core::mem::transmute::<&[u8; 16], &[libc::c_char; 16]>(b"sudo_ev_loop_v1\0")).as_ptr(), b"event.c\0" as *const u8 as *const libc::c_char, @@ -1680,10 +1439,8 @@ pub unsafe extern "C" fn sudo_ev_loop_v1( ); return sudo_debug_ret; } - #[no_mangle] pub unsafe extern "C" fn sudo_ev_loopexit_v1(mut base: *mut sudo_event_base) { - let sudo_debug_subsys: libc::c_int = (4 as libc::c_int) << 6 as libc::c_int; sudo_debug_enter_v1( (*::core::mem::transmute::<&[u8; 20], &[libc::c_char; 20]>(b"sudo_ev_loopexit_v1\0")) .as_ptr(), @@ -1718,10 +1475,8 @@ pub unsafe extern "C" fn sudo_ev_loopexit_v1(mut base: *mut sudo_event_base) { sudo_debug_subsys, ); } - #[no_mangle] pub unsafe extern "C" fn sudo_ev_loopbreak_v1(mut base: *mut sudo_event_base) { - let sudo_debug_subsys: libc::c_int = (4 as libc::c_int) << 6 as libc::c_int; sudo_debug_enter_v1( (*::core::mem::transmute::<&[u8; 21], &[libc::c_char; 21]>(b"sudo_ev_loopbreak_v1\0")) .as_ptr(), @@ -1755,10 +1510,8 @@ pub unsafe extern "C" fn sudo_ev_loopbreak_v1(mut base: *mut sudo_event_base) { sudo_debug_subsys, ); } - #[no_mangle] pub unsafe extern "C" fn sudo_ev_loopcontinue_v1(mut base: *mut sudo_event_base) { - let sudo_debug_subsys: libc::c_int = (4 as libc::c_int) << 6 as libc::c_int; sudo_debug_enter_v1( (*::core::mem::transmute::<&[u8; 24], &[libc::c_char; 24]>(b"sudo_ev_loopcontinue_v1\0")) .as_ptr(), @@ -1792,10 +1545,8 @@ pub unsafe extern "C" fn sudo_ev_loopcontinue_v1(mut base: *mut sudo_event_base) sudo_debug_subsys, ); } - #[no_mangle] pub unsafe extern "C" fn sudo_ev_got_exit_v1(mut base: *mut sudo_event_base) -> bool { - let sudo_debug_subsys: libc::c_int = (4 as libc::c_int) << 6 as libc::c_int; sudo_debug_enter_v1( (*::core::mem::transmute::<&[u8; 20], &[libc::c_char; 20]>(b"sudo_ev_got_exit_v1\0")) .as_ptr(), @@ -1831,10 +1582,8 @@ pub unsafe extern "C" fn sudo_ev_got_exit_v1(mut base: *mut sudo_event_base) -> ); return sudo_debug_ret_0; } - #[no_mangle] pub unsafe extern "C" fn sudo_ev_got_break_v1(mut base: *mut sudo_event_base) -> bool { - let sudo_debug_subsys: libc::c_int = (4 as libc::c_int) << 6 as libc::c_int; sudo_debug_enter_v1( (*::core::mem::transmute::<&[u8; 21], &[libc::c_char; 21]>(b"sudo_ev_got_break_v1\0")) .as_ptr(), @@ -1894,7 +1643,6 @@ pub unsafe extern "C" fn sudo_ev_get_timeleft_v2( tv_sec: 0, tv_nsec: 0, }; - let sudo_debug_subsys: libc::c_int = (4 as libc::c_int) << 6 as libc::c_int; sudo_debug_enter_v1( (*::core::mem::transmute::<&[u8; 24], &[libc::c_char; 24]>(b"sudo_ev_get_timeleft_v2\0")) .as_ptr(), diff --git a/lib/util/src/event_poll.rs b/lib/util/src/event_poll.rs index 8db9300..96b2ed2 100644 --- a/lib/util/src/event_poll.rs +++ b/lib/util/src/event_poll.rs @@ -3,6 +3,7 @@ * * SPDX-License-Identifier: MulanPSL-2.0 */ + #![allow( non_camel_case_types, dead_code, @@ -14,43 +15,24 @@ unused_parens )] -use crate::event::sudo_ev_callback_t; -use crate::sudo_debug::sudo_debug_exit_v1; -// use crate::sudo_debug::sudo_debug_printf2_v1; -use crate::term::__sighandler_t; -use crate::term::__sigset_t; -use crate::term::sig_atomic_t; -use crate::term::siginfo_t; -use libc::free; - -use crate::sudo_debug::sudo_debug_enter_v1; -use crate::sudo_debug::sudo_debug_exit_int_v1; -use crate::sudo_debug_macro::SUDO_DEBUG_DEBUG; -use crate::sudo_debug_macro::SUDO_DEBUG_ERROR; -use crate::sudo_debug_macro::SUDO_DEBUG_EVENT; -use crate::sudo_debug_macro::SUDO_DEBUG_INFO; -use crate::sudo_debug_macro::SUDO_DEBUG_LINENO; - -pub type __time_t = libc::c_long; -pub type __syscall_slong_t = libc::c_long; -pub type size_t = libc::c_ulong; -pub type nfds_t = libc::c_ulong; - -pub const __SIGRTMIN: libc::c_uint = 64; -pub const NSIG: libc::c_uint = __SIGRTMIN + 1; +use crate::common::*; + +//#define SUDO_EV_READ 0x02 /* fire when readable */ +//#define SUDO_EV_WRITE 0x04 /* fire when writable */ pub const SUDO_EV_READ: libc::c_short = 0x02; -pub const POLLIN: libc::c_short = 0x001; -pub const POLLHUP: libc::c_short = 0x010; -pub const POLLNVAL: libc::c_short = 0x020; -pub const POLLERR: libc::c_short = 0x008; pub const SUDO_EV_WRITE: libc::c_short = 0x04; + +// #define POLLIN 0x001 /* There is data to read. */ +// #define POLLOUT 0x004 /* Writing now will not block. */ +pub const POLLIN: libc::c_short = 0x001; pub const POLLOUT: libc::c_short = 0x004; -#[derive(Copy, Clone)] -#[repr(C)] -pub struct sigset_t { - pub __val: [libc::c_ulong; 16], -} +// #define POLLERR 0x008 /* Error condition. */ +// #define POLLHUP 0x010 /* Hung up. */ +// #define POLLNVAL 0x020 /* Invalid polling request. */ +pub const POLLERR: libc::c_short = 0x008; +pub const POLLHUP: libc::c_short = 0x010; +pub const POLLNVAL: libc::c_short = 0x020; extern "C" { fn reallocarray(__ptr: *mut libc::c_void, __nmemb: size_t, __size: size_t) @@ -72,107 +54,11 @@ extern "C" { _: ... ); } -#[derive(Copy, Clone)] -#[repr(C)] -pub struct pollfd { - pub fd: libc::c_int, - pub events: libc::c_short, - pub revents: libc::c_short, -} - -#[derive(Copy, Clone)] -#[repr(C)] -pub struct timespec { - pub tv_sec: __time_t, - pub tv_nsec: __syscall_slong_t, -} - -#[derive(Copy, Clone)] -#[repr(C)] -pub struct mid_struct_1 { - pub tqe_next: *mut sudo_event, - pub tqe_prev: *mut *mut sudo_event, -} - -#[derive(Copy, Clone)] -#[repr(C)] -pub struct mid_struct_2 { - pub tqe_next: *mut sudo_event, - pub tqe_prev: *mut *mut sudo_event, -} - -#[derive(Copy, Clone)] -#[repr(C)] -pub struct mid_struct_3 { - pub tqe_next: *mut sudo_event, - pub tqe_prev: *mut *mut sudo_event, -} - -#[derive(Copy, Clone)] -#[repr(C)] -pub struct sudo_event { - pub entries: mid_struct_1, - pub active_entries: mid_struct_2, - pub timeouts_entries: mid_struct_3, - pub base: *mut sudo_event_base, - pub fd: libc::c_int, - pub events: libc::c_short, - pub revents: libc::c_short, - pub flags: libc::c_short, - pub pfd_idx: libc::c_short, - pub callback: sudo_ev_callback_t, - pub timeout: timespec, - pub closure: *mut libc::c_void, -} - -#[derive(Copy, Clone)] -#[repr(C)] -pub struct sudo_event_list { - pub tqh_first: *mut sudo_event, - pub tqh_last: *mut *mut sudo_event, -} - -#[derive(Copy, Clone)] -#[repr(C)] -pub union mid_union_1 { - pub sa_handler: __sighandler_t, - pub sa_sigaction: Option, -} - -#[derive(Copy, Clone)] -#[repr(C)] -pub struct sigaction { - pub __sigaction_handler: mid_union_1, - pub sa_mask: __sigset_t, - pub sa_flags: libc::c_int, - pub sa_restorer: Option, -} - -#[derive(Copy, Clone)] -#[repr(C)] -pub struct sudo_event_base { - pub events: sudo_event_list, - pub active: sudo_event_list, - pub timeouts: sudo_event_list, - pub signal_event: sudo_event, - pub signals: [sudo_event_list; NSIG as usize], - pub orig_handlers: [*mut sigaction; NSIG as usize], - pub siginfo: [*mut siginfo_t; NSIG as usize], - pub signal_pending: [sig_atomic_t; NSIG as usize], - pub signal_caught: sig_atomic_t, - pub num_handlers: libc::c_int, - pub signal_pipe: [libc::c_int; 2], - pub pfds: *mut pollfd, - pub pfd_max: libc::c_int, - pub pfd_high: libc::c_int, - pub pfd_free: libc::c_int, - pub flags: libc::c_uint, -} #[no_mangle] unsafe fn sudo_ev_base_alloc_impl(mut base: *mut sudo_event_base) -> libc::c_int { let mut i: libc::c_int = 0; - debug_decl!(stdext::function_name!().as_ptr(), SUDO_DEBUG_EVENT); + debug_decl!(SUDO_DEBUG_EVENT); (*base).pfd_high = -1; (*base).pfd_max = 32; @@ -186,7 +72,7 @@ unsafe fn sudo_ev_base_alloc_impl(mut base: *mut sudo_event_base) -> libc::c_int sudo_debug_printf!( SUDO_DEBUG_ERROR | SUDO_DEBUG_LINENO, b"%s: unable to allocate %d pollfds\0" as *const u8 as *const libc::c_char, - stdext::function_name!().as_ptr(), + get_function_name!(), (*base).pfd_max ); (*base).pfd_max = 0; @@ -201,7 +87,7 @@ unsafe fn sudo_ev_base_alloc_impl(mut base: *mut sudo_event_base) -> libc::c_int #[no_mangle] unsafe fn sudo_ev_base_free_impl(mut base: *mut sudo_event_base) { - debug_decl!(stdext::function_name!().as_ptr(), SUDO_DEBUG_EVENT); + debug_decl!(SUDO_DEBUG_EVENT); free((*base).pfds as *mut libc::c_void); debug_return!() @@ -210,7 +96,7 @@ unsafe fn sudo_ev_base_free_impl(mut base: *mut sudo_event_base) { #[no_mangle] unsafe fn sudo_ev_add_impl(mut base: *mut sudo_event_base, mut ev: *mut sudo_event) -> libc::c_int { let mut pfd: *mut pollfd = 0 as *mut pollfd; - debug_decl!(stdext::function_name!().as_ptr(), SUDO_DEBUG_EVENT); + debug_decl!(SUDO_DEBUG_EVENT); /* If out of space in pfds array, realloc. */ if (*base).pfd_free == (*base).pfd_max { @@ -228,7 +114,7 @@ unsafe fn sudo_ev_add_impl(mut base: *mut sudo_event_base, mut ev: *mut sudo_eve sudo_debug_printf!( SUDO_DEBUG_ERROR | SUDO_DEBUG_LINENO, b"%s: unable to allocate %d pollfds\0" as *const u8 as *const libc::c_char, - stdext::function_name!().as_ptr(), + get_function_name!(), ((*base).pfd_max) * 2 ); @@ -274,7 +160,7 @@ unsafe fn sudo_ev_add_impl(mut base: *mut sudo_event_base, mut ev: *mut sudo_eve #[no_mangle] unsafe fn sudo_ev_del_impl(mut base: *mut sudo_event_base, mut ev: *mut sudo_event) -> libc::c_int { - debug_decl!(stdext::function_name!().as_ptr(), SUDO_DEBUG_EVENT); + debug_decl!(SUDO_DEBUG_EVENT); /* Mark pfd entry unused, add to free list and adjust high slot. */ (*((*base).pfds).offset((*ev).pfd_idx as isize)).fd = -1; @@ -310,7 +196,7 @@ unsafe fn sudo_ev_scan_impl(mut base: *mut sudo_event_base, mut flags: libc::c_i let mut ev: *mut sudo_event = 0 as *mut sudo_event; let mut nready: libc::c_int; - debug_decl!(stdext::function_name!().as_ptr(), SUDO_DEBUG_EVENT); + debug_decl!(SUDO_DEBUG_EVENT); ev = (*base).timeouts.tqh_first; if !ev.is_null() { @@ -335,6 +221,7 @@ unsafe fn sudo_ev_scan_impl(mut base: *mut sudo_event_base, mut flags: libc::c_i timeout = 0 as *mut timespec; } } + nready = sudo_ev_poll( (*base).pfds, ((*base).pfd_high + 1) as libc::c_int as nfds_t, @@ -344,7 +231,7 @@ unsafe fn sudo_ev_scan_impl(mut base: *mut sudo_event_base, mut flags: libc::c_i sudo_debug_printf!( SUDO_DEBUG_INFO, b"%s: %d fds ready\0" as *const u8 as *const libc::c_char, - stdext::function_name!().as_ptr(), + get_function_name!(), nready ); @@ -377,7 +264,7 @@ unsafe fn sudo_ev_scan_impl(mut base: *mut sudo_event_base, mut flags: libc::c_i SUDO_DEBUG_DEBUG, b"%s: polled fd %d, events %d, activating %p\0" as *const u8 as *const libc::c_char, - stdext::function_name!().as_ptr(), + get_function_name!(), (*ev).fd, what, ev diff --git a/lib/util/src/fatal.rs b/lib/util/src/fatal.rs index 3e46279..14e0fbb 100644 --- a/lib/util/src/fatal.rs +++ b/lib/util/src/fatal.rs @@ -13,7 +13,7 @@ non_upper_case_globals, dead_code )] -use crate::__LC_MESSAGES; + use libc::FILE; #[macro_export] @@ -39,9 +39,9 @@ extern "C" { __msgid: *const libc::c_char, __category: libc::c_int, ) -> *mut libc::c_char; + fn do_cleanup(); } -pub type ssize_t = libc::c_long; pub type sudo_fatal_callback_t = Option; static mut sudo_warn_conversation: sudo_conv_t = None; static mut sudo_warn_setlocale: Option bool> = None; @@ -74,14 +74,6 @@ static mut callbacks: sudo_fatal_callback_list = { init }; -pub const SUDO_CONV_PROMPT_ECHO_OFF: libc::c_int = 1; -pub const SUDO_CONV_PROMPT_ECHO_ON: libc::c_int = 2; -pub const SUDO_CONV_ERROR_MSG: libc::c_int = 3; -pub const SUDO_CONV_INFO_MSG: libc::c_int = 4; -pub const SUDO_CONV_PROMPT_MASK: libc::c_int = 5; -pub const SUDO_CONV_PROMPT_ECHO_OK: libc::c_int = 4096; -pub const SUDO_CONV_PREFER_TTY: libc::c_int = 8192; - #[derive(Copy, Clone)] pub struct sudo_conv_message { pub msg_type: libc::c_int, @@ -112,6 +104,7 @@ pub type sudo_conv_t = Option< ) -> libc::c_int, >; +/* #[no_mangle] pub fn do_cleanup() { let mut cb: *mut sudo_fatal_callback = 0 as *mut sudo_fatal_callback; @@ -128,6 +121,7 @@ pub fn do_cleanup() { }; } } +*/ #[no_mangle] unsafe fn sudo_fatal_callback_register_v1(mut func: sudo_fatal_callback_t) -> libc::c_int { @@ -145,9 +139,10 @@ unsafe fn sudo_fatal_callback_register_v1(mut func: sudo_fatal_callback_t) -> li if cb.is_null() { return -1; } - (*cb).func = func; - (*cb).entries.sle_next = cb; - callbacks.slh_first = cb; + let ref mut fresh6 = (*cb).func; + *fresh6 = func; + let ref mut fresh7 = (*cb).entries.sle_next; + *fresh7 = callbacks.slh_first; return 0; } diff --git a/lib/util/src/getgrouplist.rs b/lib/util/src/getgrouplist.rs index a4ee40d..8c48df8 100644 --- a/lib/util/src/getgrouplist.rs +++ b/lib/util/src/getgrouplist.rs @@ -6,10 +6,7 @@ #![allow(non_camel_case_types, unused_mut, unused_variables, unused_assignments)] -//line72-2(arg), -pub type gid_t = libc::c_uint; -pub type __gid_t = libc::c_uint; -pub type size_t = libc::c_ulong; +use crate::common::*; extern "C" { fn getgrouplist( @@ -24,10 +21,6 @@ extern "C" { -> *mut libc::c_void; } -// define -pub const _SC_NGROUPS_MAX: libc::c_uint = 3; -pub const NGROUPS_MAX: libc::c_uint = 65536; - //line_72 #[no_mangle] pub unsafe extern "C" fn sudo_getgrouplist2_v1( diff --git a/lib/util/src/gethostname.rs b/lib/util/src/gethostname.rs index 258cd21..27aac53 100644 --- a/lib/util/src/gethostname.rs +++ b/lib/util/src/gethostname.rs @@ -5,8 +5,8 @@ */ #![allow(unused_imports, unused_assignments, non_camel_case_types)] -use std::ffi::CStr; -use std::string::String; + +use crate::common::*; extern "C" { fn malloc(_: libc::c_ulong) -> *mut libc::c_void; @@ -15,9 +15,7 @@ extern "C" { fn gethostname(__name: *mut libc::c_char, __len: size_t) -> libc::c_int; } -pub type size_t = libc::c_ulong; -pub type C2RustUnnamed = libc::c_uint; -pub const _SC_HOST_NAME_MAX: C2RustUnnamed = 180; +pub const _SC_HOST_NAME_MAX: libc::c_uint = 180; #[no_mangle] pub unsafe extern "C" fn sudo_gethostname_v1() -> *mut libc::c_char { diff --git a/lib/util/src/gettime.rs b/lib/util/src/gettime.rs index 65f1bb1..df474e9 100644 --- a/lib/util/src/gettime.rs +++ b/lib/util/src/gettime.rs @@ -14,13 +14,7 @@ unused_mut )] -use crate::sudo_debug::sudo_debug_enter_v1; -use crate::sudo_debug::sudo_debug_exit_int_v1; -// use crate::sudo_debug::sudo_debug_printf2_v1; -use crate::sudo_debug_macro::SUDO_DEBUG_ERRNO; -use crate::sudo_debug_macro::SUDO_DEBUG_LINENO; -use crate::sudo_debug_macro::SUDO_DEBUG_UTIL; -use crate::sudo_debug_macro::SUDO_DEBUG_WARN; +use crate::common::*; extern "C" { fn clock_gettime(__clock_id: clockid_t, __tp: *mut timespec) -> libc::c_int; @@ -36,26 +30,6 @@ extern "C" { ); } -pub type __time_t = libc::c_long; -pub type __suseconds_t = libc::c_long; -pub type __clockid_t = libc::c_int; -pub type __syscall_slong_t = libc::c_long; -pub type clockid_t = __clockid_t; - -#[derive(Copy, Clone)] -#[repr(C)] -pub struct timespec { - pub tv_sec: __time_t, - pub tv_nsec: __syscall_slong_t, -} - -#[derive(Copy, Clone)] -#[repr(C)] -pub struct timeval { - pub tv_sec: __time_t, - pub tv_usec: __suseconds_t, -} - #[derive(Copy, Clone)] #[repr(C)] pub struct timezone { @@ -65,14 +39,16 @@ pub struct timezone { pub type __timezone_ptr_t = *mut timezone; +//#define CLOCK_REALTIME 0 pub const CLOCK_REALTIME: libc::c_int = 0; + pub const SUDO_CLOCK_BOOTTIME: libc::c_int = 7; pub const SUDO_CLOCK_UPTIME: libc::c_int = 1; pub const _SC_MONOTONIC_CLOCK: libc::c_int = 149; #[no_mangle] pub unsafe extern "C" fn sudo_gettime_real_v1(mut ts: *mut timespec) -> libc::c_int { - debug_decl!(stdext::function_name!().as_ptr(), SUDO_DEBUG_UTIL); + debug_decl!(SUDO_DEBUG_UTIL); if clock_gettime(CLOCK_REALTIME, ts) == -1 { let mut tv: timeval = timeval { @@ -99,7 +75,7 @@ pub unsafe extern "C" fn sudo_gettime_real_v1(mut ts: *mut timespec) -> libc::c_ pub unsafe extern "C" fn sudo_gettime_mono_v1(ts: *mut timespec) -> i32 { static mut has_monoclock: libc::c_int = -1; - debug_decl!(stdext::function_name!().as_ptr(), SUDO_DEBUG_UTIL); + debug_decl!(SUDO_DEBUG_UTIL); if has_monoclock == -1 { has_monoclock = (sysconf(_SC_MONOTONIC_CLOCK) != -1) as libc::c_int; @@ -125,7 +101,7 @@ pub unsafe extern "C" fn sudo_gettime_mono_v1(ts: *mut timespec) -> i32 { #[no_mangle] pub unsafe extern "C" fn sudo_gettime_awake_v1(ts: *mut timespec) -> libc::c_int { static mut has_monoclock: libc::c_int = -1; - debug_decl!(stdext::function_name!().as_ptr(), SUDO_DEBUG_UTIL); + debug_decl!(SUDO_DEBUG_UTIL); if has_monoclock == -1 { has_monoclock = (sysconf(_SC_MONOTONIC_CLOCK) != -1) as libc::c_int; diff --git a/lib/util/src/gidlist.rs b/lib/util/src/gidlist.rs index 95dfa03..1f06725 100644 --- a/lib/util/src/gidlist.rs +++ b/lib/util/src/gidlist.rs @@ -11,11 +11,17 @@ unused_mut )] -use crate::sudo_debug::sudo_debug_enter_v1; -use crate::sudo_debug::sudo_debug_exit_int_v1; -use crate::sudo_debug_macro::SUDO_DEBUG_UTIL; +use crate::common::*; extern "C" { + fn sudo_debug_printf2_v1( + func: *const libc::c_char, + file: *const libc::c_char, + lineno: libc::c_int, + level: libc::c_int, + fmt: *const libc::c_char, + _: ... + ); fn reallocarray(__ptr: *mut libc::c_void, __nmemb: size_t, __size: size_t) -> *mut libc::c_void; fn sudo_strtoidx_v1( @@ -28,11 +34,7 @@ extern "C" { fn sudo_warnx_nodebug_v1(fmt: *const libc::c_char, _: ...); } -pub type __gid_t = libc::c_uint; //typedef __gid_t gid_t; -pub type gid_t = __gid_t; pub type GETGROUPS_T = gid_t; //#define GETGROUPS_T gid_t -pub type size_t = libc::c_ulong; -pub type id_t = libc::c_uint; #[no_mangle] pub unsafe extern "C" fn sudo_parse_gids_v1( @@ -46,7 +48,7 @@ pub unsafe extern "C" fn sudo_parse_gids_v1( let mut errstr: *const libc::c_char = 0 as *const libc::c_char; let mut ep: *mut libc::c_char = 0 as *mut libc::c_char; - debug_decl!(stdext::function_name!().as_ptr(), SUDO_DEBUG_UTIL); + debug_decl!(SUDO_DEBUG_UTIL); if *cp as libc::c_int != '\0' as i32 { ngids += 1; //ngids++ @@ -56,7 +58,7 @@ pub unsafe extern "C" fn sudo_parse_gids_v1( } cp = cp.offset(1); - if *cp as libc::c_int != '\0' as i32 { + if !(*cp as libc::c_int != '\0' as i32) { break; } } @@ -73,7 +75,7 @@ pub unsafe extern "C" fn sudo_parse_gids_v1( if gids.is_null() { sudo_warnx!( b"%s: %s\0" as *const u8 as *const libc::c_char, - stdext::function_name!().as_ptr(), + get_function_name!(), b"unable to allocate memor0" as *const u8 as *const libc::c_char ); debug_return_int!(-1); diff --git a/lib/util/src/key_val.rs b/lib/util/src/key_val.rs index a41be2f..5af519b 100644 --- a/lib/util/src/key_val.rs +++ b/lib/util/src/key_val.rs @@ -6,16 +6,13 @@ #![allow(unused_assignments, non_camel_case_types)] -use crate::sudo_debug::sudo_debug_enter_v1; -use crate::sudo_debug::sudo_debug_exit_str_v1; -use crate::sudo_debug_macro::SUDO_DEBUG_UTIL; +use crate::common::*; extern "C" { fn malloc(_: libc::c_ulong) -> *mut libc::c_void; fn memcpy(_: *mut libc::c_void, _: *const libc::c_void, _: libc::c_ulong) -> *mut libc::c_void; fn strlen(_: *const libc::c_char) -> libc::c_ulong; } -pub type size_t = libc::c_ulong; #[no_mangle] pub unsafe extern "C" fn sudo_new_key_val_v1( @@ -27,7 +24,7 @@ pub unsafe extern "C" fn sudo_new_key_val_v1( let mut cp: *mut libc::c_char = 0 as *mut libc::c_char; let mut str: *mut libc::c_char = 0 as *mut libc::c_char; - debug_decl!(stdext::function_name!().as_ptr(), SUDO_DEBUG_UTIL); + debug_decl!(SUDO_DEBUG_UTIL); str = malloc( key_len diff --git a/lib/util/src/lbuf.rs b/lib/util/src/lbuf.rs index 29d73ca..e09e093 100644 --- a/lib/util/src/lbuf.rs +++ b/lib/util/src/lbuf.rs @@ -12,12 +12,7 @@ dead_code )] -use crate::sudo_debug::sudo_debug_enter_v1; -use crate::sudo_debug::sudo_debug_exit_bool_v1; -use crate::sudo_debug::sudo_debug_exit_v1; -use crate::sudo_debug_macro::SUDO_DEBUG_ERROR; -use crate::sudo_debug_macro::SUDO_DEBUG_LINENO; -use crate::sudo_debug_macro::SUDO_DEBUG_UTIL; +use crate::common::*; extern "C" { fn free(__ptr: *mut libc::c_void); @@ -48,7 +43,6 @@ pub struct sudo_lbuf { pub cols: libc::c_short, pub error: libc::c_short, } - pub type sudo_lbuf_output_t = Option libc::c_int>; pub type size_t = libc::c_ulong; @@ -60,7 +54,7 @@ pub unsafe extern "C" fn sudo_lbuf_init_v1( mut continuation: *const libc::c_char, mut cols: libc::c_int, ) { - debug_decl!(stdext::function_name!().as_ptr(), SUDO_DEBUG_UTIL); + debug_decl!(SUDO_DEBUG_UTIL); (*lbuf).output = output; (*lbuf).continuation = continuation; @@ -76,7 +70,7 @@ pub unsafe extern "C" fn sudo_lbuf_init_v1( #[no_mangle] pub unsafe extern "C" fn sudo_lbuf_destroy_v1(mut lbuf: *mut sudo_lbuf) { - debug_decl!(stdext::function_name!().as_ptr(), SUDO_DEBUG_UTIL); + debug_decl!(SUDO_DEBUG_UTIL); free((*lbuf).buf as *mut libc::c_void); (*lbuf).buf = 0 as *mut libc::c_char; @@ -86,7 +80,7 @@ pub unsafe extern "C" fn sudo_lbuf_destroy_v1(mut lbuf: *mut sudo_lbuf) { //static unsafe extern "C" fn sudo_lbuf_expand(mut lbuf: *mut sudo_lbuf, mut extra: libc::c_int) -> bool { - debug_decl!(stdext::function_name!().as_ptr(), SUDO_DEBUG_UTIL); + debug_decl!(SUDO_DEBUG_UTIL); if (*lbuf).len + extra + 1 >= (*lbuf).size { let mut new_buf: *mut libc::c_char; @@ -131,7 +125,7 @@ unsafe extern "C" fn sudo_lbuf_println( let mut indent: libc::c_int = (*lbuf).indent; let mut is_comment: bool = false; - debug_decl!(stdext::function_name!().as_ptr(), SUDO_DEBUG_UTIL); + debug_decl!(SUDO_DEBUG_UTIL); if *line.offset(0 as isize) as libc::c_int == '#' as i32 && *(*__ctype_b_loc()) @@ -143,7 +137,6 @@ unsafe extern "C" fn sudo_lbuf_println( is_comment = true; indent = 2; } - if !((*lbuf).continuation).is_null() && !is_comment { contlen = strlen((*lbuf).continuation) as libc::c_int; } @@ -223,7 +216,7 @@ pub unsafe extern "C" fn sudo_lbuf_print_v1(mut lbuf: *mut sudo_lbuf) { let mut ep: *mut libc::c_char = 0 as *mut libc::c_char; let mut len: libc::c_int = 0; - debug_decl!(stdext::function_name!().as_ptr(), SUDO_DEBUG_UTIL); + debug_decl!(SUDO_DEBUG_UTIL); if !(((*lbuf).buf).is_null() || (*lbuf).len == 0 as libc::c_int) { //len = lbuf->continuation ? strlen(lbuf->continuation) : 0; @@ -289,7 +282,6 @@ pub unsafe extern "C" fn sudo_lbuf_error_v1(mut lbuf: *mut sudo_lbuf) -> bool { } return false; } - #[no_mangle] pub unsafe extern "C" fn sudo_lbuf_clearerr_v1(mut lbuf: *mut sudo_lbuf) { if !lbuf.is_null() { diff --git a/lib/util/src/lib.rs b/lib/util/src/lib.rs index ff0cdf9..9dd4a4e 100644 --- a/lib/util/src/lib.rs +++ b/lib/util/src/lib.rs @@ -4,9 +4,10 @@ * SPDX-License-Identifier: MulanPSL-2.0 */ +//#![feature(c_variadic)] #[warn(unused_unsafe)] #[macro_use] -mod sudo_debug_macro; +pub mod common; mod arc4random; mod arc4random_uniform; mod closefrom; @@ -38,7 +39,7 @@ mod strtoid; mod strtomode; mod strtonum; mod sudo_conf; -mod sudo_debug; +pub mod sudo_debug; mod sudo_dso; mod term; mod ttyname_dev; diff --git a/lib/util/src/locking.rs b/lib/util/src/locking.rs index 5f99ed8..f367d69 100644 --- a/lib/util/src/locking.rs +++ b/lib/util/src/locking.rs @@ -4,11 +4,9 @@ * SPDX-License-Identifier: MulanPSL-2.0 */ -#![allow(dead_code, non_camel_case_types, unused_mut)] +#![allow(dead_code, non_camel_case_types, unused_mut, unused_assignments)] -use crate::sudo_debug::sudo_debug_enter_v1; -use crate::sudo_debug::sudo_debug_exit_bool_v1; -use crate::sudo_debug_macro::SUDO_DEBUG_UTIL; +use crate::common::*; extern "C" { fn lockf(__fd: libc::c_int, __cmd: libc::c_int, __len: off_t) -> libc::c_int; @@ -16,16 +14,12 @@ extern "C" { } -pub type __off_t = libc::c_long; -pub type off_t = __off_t; - -pub const SUDO_LOCK: libc::c_int = 1; -pub const SUDO_TLOCK: libc::c_int = 2; -pub const SUDO_UNLOCK: libc::c_int = 4; +// # define F_ULOCK 0 /* Unlock a previously locked region. */ +// # define F_LOCK 1 /* Lock a region for exclusive use. */ +// # define F_TLOCK 2 /* Test and lock a region for exclusive use. */ pub const F_ULOCK: libc::c_int = 0; pub const F_LOCK: libc::c_int = 1; pub const F_TLOCK: libc::c_int = 2; -pub const EINVAL: libc::c_int = 22; #[no_mangle] unsafe extern "C" fn sudo_lock_file_v1(mut fd: libc::c_int, mut type_0: libc::c_int) -> bool { @@ -39,7 +33,7 @@ unsafe extern "C" fn sudo_lock_region_v1( mut len: off_t, ) -> bool { let mut op: libc::c_int = 0; - debug_decl!(stdext::function_name!().as_ptr(), SUDO_DEBUG_UTIL); + debug_decl!(SUDO_DEBUG_UTIL); match type_0 { SUDO_LOCK => { diff --git a/lib/util/src/memset_s.rs b/lib/util/src/memset_s.rs index f56b10b..62b13b3 100644 --- a/lib/util/src/memset_s.rs +++ b/lib/util/src/memset_s.rs @@ -6,15 +6,12 @@ #![allow(dead_code, non_camel_case_types, unused_mut)] +use crate::common::*; + extern "C" { fn __errno_location() -> *mut libc::c_int; } -pub type size_t = libc::c_ulong; -pub const SIZE_MAX: libc::c_ulong = 18446744073709551615; -pub const RSIZE_MAX: libc::c_ulong = SIZE_MAX >> 1; -pub const EINVAL: libc::c_int = 22; - #[no_mangle] pub fn sudo_memset_s( mut v: *mut libc::c_void, diff --git a/lib/util/src/parseln.rs b/lib/util/src/parseln.rs index 05ca7b7..646caa9 100644 --- a/lib/util/src/parseln.rs +++ b/lib/util/src/parseln.rs @@ -15,28 +15,7 @@ improper_ctypes )] -use crate::sudo_debug::sudo_debug_enter_v1; -use crate::sudo_debug::sudo_debug_exit_ssize_t_v1; -// use crate::sudo_debug::sudo_debug_printf2_v1; -use crate::sudo_debug_macro::SUDO_DEBUG_ERROR; -use crate::sudo_debug_macro::SUDO_DEBUG_LINENO; -use crate::sudo_debug_macro::SUDO_DEBUG_UTIL; - -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _IO_marker { - _unused: [u8; 0], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _IO_codecvt { - _unused: [u8; 0], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _IO_wide_data { - _unused: [u8; 0], -} +use crate::common::*; extern "C" { fn getdelim( @@ -60,49 +39,12 @@ extern "C" { ); } -pub type __ssize_t = libc::c_long; -pub type ssize_t = __ssize_t; -pub type __SIZE_TYPE__ = libc::c_ulong; -pub type size_t = __SIZE_TYPE__; -pub type FILE = _IO_FILE; -pub type __off_t = libc::c_long; -pub type __off64_t = libc::c_long; - -pub struct _IO_FILE { - pub _flags: libc::c_int, - pub _IO_read_ptr: *mut libc::c_char, - pub _IO_read_end: *mut libc::c_char, - pub _IO_read_base: *mut libc::c_char, - pub _IO_write_base: *mut libc::c_char, - pub _IO_write_ptr: *mut libc::c_char, - pub _IO_write_end: *mut libc::c_char, - pub _IO_buf_base: *mut libc::c_char, - pub _IO_buf_end: *mut libc::c_char, - pub _IO_save_base: *mut libc::c_char, - pub _IO_backup_base: *mut libc::c_char, - pub _IO_save_end: *mut libc::c_char, - pub _markers: *mut _IO_marker, - pub _chain: *mut _IO_FILE, - pub _fileno: libc::c_int, - pub _flags2: libc::c_int, - pub _old_offset: __off_t, - pub _cur_column: libc::c_ushort, - pub _vtable_offset: libc::c_schar, - - pub _shortbuf: [libc::c_char; 1], - pub _lock: *mut libc::c_void, - pub _offset: __off64_t, - pub _codecvt: *mut _IO_codecvt, - pub _wide_data: *mut _IO_wide_data, - pub _freeres_list: *mut _IO_FILE, - pub _freeres_buf: *mut libc::c_void, - pub __pad5: size_t, - pub _mode: libc::c_int, - pub _unused2: [libc::c_char; 20], -} - +/* sudo_parseln() flags */ +// #define PARSELN_COMM_BOL 0x01 /* comments only at begining of line */ +// #define PARSELN_CONT_IGN 0x02 /* ignore line continuation char */ pub const PARSELN_COMM_BOL: libc::c_int = 0x01; pub const PARSELN_CONT_IGN: libc::c_int = 0x02; + pub const _ISblank: libc::c_int = 1; #[no_mangle] @@ -121,7 +63,7 @@ pub unsafe extern "C" fn sudo_parseln_v2( let mut continued: bool = false; let mut comment: bool = false; - debug_decl!(stdext::function_name!().as_ptr(), SUDO_DEBUG_UTIL); + debug_decl!(SUDO_DEBUG_UTIL); loop { comment = false; diff --git a/lib/util/src/progname.rs b/lib/util/src/progname.rs index d2d602f..f8f0659 100644 --- a/lib/util/src/progname.rs +++ b/lib/util/src/progname.rs @@ -10,6 +10,7 @@ extern "C" { fn strrchr(_: *const libc::c_char, _: libc::c_int) -> *mut libc::c_char; static mut __progname: *const libc::c_char; } + static mut progname: *const libc::c_char = b"\0" as *const u8 as *const libc::c_char; //*progname = "" #[no_mangle] pub unsafe extern "C" fn initprogname(mut name: *const libc::c_char) { diff --git a/lib/util/src/pw_dup.rs b/lib/util/src/pw_dup.rs index 160d201..f6eb5ad 100644 --- a/lib/util/src/pw_dup.rs +++ b/lib/util/src/pw_dup.rs @@ -15,16 +15,14 @@ unused_macros )] +use crate::common::*; + extern "C" { fn malloc(_: libc::c_ulong) -> *mut libc::c_void; fn memcpy(_: *mut libc::c_void, _: *const libc::c_void, _: libc::c_ulong) -> *mut libc::c_void; fn strlen(_: *const libc::c_char) -> libc::c_ulong; } -pub type __uid_t = libc::c_uint; -pub type __gid_t = libc::c_uint; -pub type size_t = libc::c_ulong; - #[derive(Copy, Clone)] #[repr(C)] pub struct passwd { @@ -36,7 +34,6 @@ pub struct passwd { pub pw_dir: *mut libc::c_char, pub pw_shell: *mut libc::c_char, } - #[no_mangle] pub unsafe extern "C" fn sudo_pw_dup(mut pw: *const passwd) -> *mut passwd { let mut nsize: size_t = 0 as libc::c_int as size_t; diff --git a/lib/util/src/secure_path.rs b/lib/util/src/secure_path.rs index b09b57f..189acb1 100644 --- a/lib/util/src/secure_path.rs +++ b/lib/util/src/secure_path.rs @@ -3,6 +3,7 @@ * * SPDX-License-Identifier: MulanPSL-2.0 */ + #![allow( dead_code, mutable_transmutes, @@ -14,6 +15,8 @@ unused_variables )] +use crate::common::*; + extern "C" { fn __xstat( __ver: libc::c_int, @@ -23,181 +26,12 @@ extern "C" { fn memcpy(_: *mut libc::c_void, _: *const libc::c_void, _: libc::c_ulong) -> *mut libc::c_void; } -pub type __dev_t = libc::c_ulong; -pub type __uid_t = libc::c_uint; -pub type __gid_t = libc::c_uint; -pub type __ino_t = libc::c_ulong; -pub type __mode_t = libc::c_uint; -#[cfg(target_arch = "x86_64")] -pub type __nlink_t = libc::c_ulong; -#[cfg(not(target_arch = "x86_64"))] -pub type __nlink_t = libc::c_uint; -pub type __off_t = libc::c_long; -pub type __time_t = libc::c_long; -#[cfg(target_arch = "x86_64")] -pub type __blksize_t = libc::c_long; -#[cfg(not(target_arch = "x86_64"))] -pub type __blksize_t = libc::c_int; -pub type __blkcnt_t = libc::c_long; -pub type __syscall_slong_t = libc::c_long; -pub type gid_t = __gid_t; -pub type uid_t = __uid_t; - -use crate::sudo_debug::sudo_debug_enter_v1; -use crate::sudo_debug::sudo_debug_exit_int_v1; -use crate::sudo_debug_macro::SUDO_DEBUG_UTIL; - -// #define __S_IFREG 0100000 /* Regular file. */ -#[macro_export] -macro_rules! _S_IFREG { - () => { - 0o100000 - }; -} - -// #define __S_IFDIR 0040000 /* Directory. */ -#[macro_export] -macro_rules! _S_IFDIR { - () => { - 0o40000 - }; -} - -// #define SUDO_PATH_MISSING -1 -#[macro_export] -macro_rules! SUDO_PATH_MISSING { - () => { - -1 - }; -} - -// #define __S_IFMT 0170000 /* These bits determine file type. */ -#[macro_export] -macro_rules! _S_IFMT { - () => { - 0o170000 - }; -} - -// #define SUDO_PATH_BAD_TYPE -2 -#[macro_export] -macro_rules! SUDO_PATH_BAD_TYPE { - () => { - -2 - }; -} - -// #define SUDO_PATH_WRONG_OWNER -3 -#[macro_export] -macro_rules! SUDO_PATH_WRONG_OWNER { - () => { - -3 - }; -} - -// #define SUDO_PATH_WORLD_WRITABLE -4 -#[macro_export] -macro_rules! SUDO_PATH_WORLD_WRITABLE { - () => { - -4 - }; -} - -// #define SUDO_PATH_GROUP_WRITABLE -5 -#[macro_export] -macro_rules! SUDO_PATH_GROUP_WRITABLE { - () => { - -5 - }; -} - -// #define __S_IWRITE 0200 /* Write by owner. */ -// #define S_IWUSR __S_IWRITE /* Write by owner. */ -#[macro_export] -macro_rules! S_IWUSR { - () => { - 0200 - }; -} - -// #define S_IWGRP (S_IWUSR >> 3) /* Write by group. */ -#[macro_export] -macro_rules! S_IWGRP { - () => { - S_IWUSR!() >> 3 - }; -} - -// #define S_IWOTH (S_IWGRP >> 3) /* Write by others. */ -#[macro_export] -macro_rules! S_IWOTH { - () => { - S_IWGRP!() >> 3 - }; -} - -// #define SUDO_PATH_SECURE 0 -macro_rules! SUDO_PATH_SECURE { - () => { - 0 - }; -} - -// #define ISSET(t, f) ((t) & (f)) -#[macro_export] -macro_rules! ISSET { - ($_t:expr, $_f:expr) => { - (($_t) & ($_f)) - }; -} - -#[derive(Copy, Clone)] -#[repr(C)] -pub struct timespec { - pub tv_sec: __time_t, - pub tv_nsec: __syscall_slong_t, -} - -#[derive(Copy, Clone)] -#[repr(C)] -pub struct stat { - pub st_dev: __dev_t, - pub st_ino: __ino_t, - #[cfg(target_arch = "x86_64")] - pub st_nlink: __nlink_t, - pub st_mode: __mode_t, - #[cfg(not(target_arch = "x86_64"))] - pub st_nlink: __nlink_t, - pub st_uid: __uid_t, - pub st_gid: __gid_t, - #[cfg(target_arch = "x86_64")] - pub __pad0: libc::c_int, - pub st_rdev: __dev_t, - #[cfg(not(target_arch = "x86_64"))] - pub __pad1: __dev_t, - pub st_size: __off_t, - pub st_blksize: __blksize_t, - #[cfg(not(target_arch = "x86_64"))] - pub __pad2: libc::c_int, - pub st_blocks: __blkcnt_t, - pub st_atim: timespec, - pub st_mtim: timespec, - pub st_ctim: timespec, - #[cfg(target_arch = "x86_64")] - pub __glibc_reserved: [__syscall_slong_t; 3], - #[cfg(not(target_arch = "x86_64"))] - pub __glibc_reserved: [libc::c_int; 2], -} - #[inline] unsafe extern "C" fn stat( mut __path: *const libc::c_char, mut __statbuf: *mut stat, ) -> libc::c_int { - #[cfg(target_arch = "x86_64")] - return __xstat(1 as libc::c_int, __path, __statbuf); - #[cfg(not(target_arch = "x86_64"))] - return __xstat(0 as libc::c_int, __path, __statbuf); + return __xstat(xstat_flag as libc::c_int, __path, __statbuf); } /* @@ -211,60 +45,23 @@ pub unsafe extern "C" fn sudo_secure_path( mut gid: gid_t, mut sbp: *mut stat, ) -> libc::c_int { - let mut sb: stat = stat { - st_dev: 0, - st_ino: 0, - #[cfg(target_arch = "x86_64")] - st_nlink: 0, - st_mode: 0, - #[cfg(not(target_arch = "x86_64"))] - st_nlink: 0, - st_uid: 0, - st_gid: 0, - #[cfg(target_arch = "x86_64")] - __pad0: 0, - st_rdev: 0, - #[cfg(not(target_arch = "x86_64"))] - __pad1: 0, - st_size: 0, - st_blksize: 0, - #[cfg(not(target_arch = "x86_64"))] - __pad2: 0, - st_blocks: 0, - st_atim: timespec { - tv_sec: 0, - tv_nsec: 0, - }, - st_mtim: timespec { - tv_sec: 0, - tv_nsec: 0, - }, - st_ctim: timespec { - tv_sec: 0, - tv_nsec: 0, - }, - #[cfg(target_arch = "x86_64")] - __glibc_reserved: [0; 3], - #[cfg(not(target_arch = "x86_64"))] - __glibc_reserved: [0; 2], - }; - - let mut ret: libc::c_int = SUDO_PATH_MISSING!(); - debug_decl!(stdext::function_name!().as_ptr(), SUDO_DEBUG_UTIL); + let mut sb: stat = sb_all_arch; + let mut ret: libc::c_int = SUDO_PATH_MISSING; + debug_decl!(SUDO_DEBUG_UTIL); if (!path.is_null()) && (stat(path, &mut sb) == 0) { if (sb.st_mode & _S_IFMT!()) != c_type { - ret = SUDO_PATH_BAD_TYPE!(); + ret = SUDO_PATH_BAD_TYPE; } else if uid != -(1 as libc::c_int) as uid_t && sb.st_uid != uid { - ret = SUDO_PATH_WRONG_OWNER!(); + ret = SUDO_PATH_WRONG_OWNER; } else if (sb.st_mode & S_IWOTH!()) != 0 { - ret = SUDO_PATH_WORLD_WRITABLE!(); + ret = SUDO_PATH_WORLD_WRITABLE; } else if ISSET!(sb.st_mode, S_IWGRP!()) != 0 && (gid == -(1 as libc::c_int) as gid_t || sb.st_gid != gid) { - ret = SUDO_PATH_GROUP_WRITABLE!(); + ret = SUDO_PATH_GROUP_WRITABLE; } else { - ret = SUDO_PATH_SECURE!(); + ret = SUDO_PATH_SECURE; } if !sbp.is_null() { memcpy( diff --git a/lib/util/src/setgroups.rs b/lib/util/src/setgroups.rs index 3508e2d..4853148 100644 --- a/lib/util/src/setgroups.rs +++ b/lib/util/src/setgroups.rs @@ -12,25 +12,14 @@ unused_mut )] +use crate::common::*; + extern "C" { fn sysconf(__name: libc::c_int) -> libc::c_long; fn __errno_location() -> *mut libc::c_int; fn setgroups(__n: size_t, __groups: *const gid_t) -> libc::c_int; } -//func be included -use crate::sudo_debug::sudo_debug_enter_v1; -use crate::sudo_debug::sudo_debug_exit_int_v1; -use crate::sudo_debug_macro::SUDO_DEBUG_UTIL; - -pub type gid_t = libc::c_uint; -pub type size_t = libc::c_ulong; - -//define -pub const EINVAL: libc::c_int = 22; -pub const _SC_NGROUPS_MAX: libc::c_int = 3; -pub const NGROUPS_MAX: libc::c_int = 65536; - //func sudo_setgroups_v1 #[no_mangle] unsafe extern "C" fn sudo_setgroups_v1( @@ -40,7 +29,7 @@ unsafe extern "C" fn sudo_setgroups_v1( let mut maxgids: libc::c_int = 0; let mut ret: libc::c_int = 0; - debug_decl!(stdext::function_name!().as_ptr(), SUDO_DEBUG_UTIL); + debug_decl!(SUDO_DEBUG_UTIL); //line43 ret = setgroups(ngids as size_t, gids as *mut gid_t); diff --git a/lib/util/src/sha2.rs b/lib/util/src/sha2.rs index 99e54d9..7eb6c51 100644 --- a/lib/util/src/sha2.rs +++ b/lib/util/src/sha2.rs @@ -13,30 +13,18 @@ unused_mut, unused_must_use )] + +use crate::common::*; + extern "C" { fn memset(__dest: *mut libc::c_void, __ch: libc::c_int, __len: size_t) -> *mut libc::c_void; fn memcpy(_: *mut libc::c_void, _: *const libc::c_void, _: libc::c_ulong) -> *mut libc::c_void; fn sudo_memset_s(v: *mut libc::c_void, smax: size_t, c: libc::c_int, n: size_t) -> libc::c_int; } -pub type __uint64_t = libc::c_ulong; -pub type uint64_t = __uint64_t; -pub type __uint32_t = libc::c_uint; -pub type uint32_t = __uint64_t; -pub type __uint8_t = libc::c_uchar; -pub type uint8_t = __uint8_t; -pub type size_t = libc::c_ulong; -pub const SHA512_BLOCK_LENGTH: usize = 128; +//#define SHA256_BLOCK_LENGTH 64 pub const SHA256_BLOCK_LENGTH: libc::c_int = 64; -pub struct SHA2_CTX { - pub state: state, - pub count: [uint64_t; 2], - pub buffer: [uint8_t; SHA512_BLOCK_LENGTH], -} -pub union state { - pub st32: [uint32_t; 8], - pub st64: [uint64_t; 8], -} + macro_rules! BE8TO32 { ($x:expr,$y:expr) => { $x = ((*$y.offset(0 as isize) & 255) as uint32_t) << 24 diff --git a/lib/util/src/sig2str.rs b/lib/util/src/sig2str.rs index be45208..4249ddf 100644 --- a/lib/util/src/sig2str.rs +++ b/lib/util/src/sig2str.rs @@ -14,23 +14,7 @@ unused_mut )] -use crate::EINVAL; - -// #define SIGRTMIN (__libc_current_sigrtmin ()) -#[macro_export] -macro_rules! SIGRTMIN { - () => { - (__libc_current_sigrtmin()) - }; -} - -// #define SIGRTMAX (__libc_current_sigrtmax ()) -#[macro_export] -macro_rules! SIGRTMAX { - () => { - (__libc_current_sigrtmax()) - }; -} +use crate::common::*; // # define SIG2STR_MAX 32 #[macro_export] @@ -39,19 +23,16 @@ macro_rules! SIG2STR_MAX { 32 }; } - -/* Biggest signal number + 1 (including real-time signals). */ -// #define _NSIG (__SIGRTMAX + 1) +/* +/* sys_sigabbrev is not declared by glibc */ +// # define sudo_sys_signame sys_sigabbrev #[macro_export] -macro_rules! NSIG { +macro_rules! sudo_sys_signame { () => { - (SIGRTMAX!() + 1) + sys_sigabbrev }; } - -pub type size_t = libc::c_ulong; -pub const _SC_RTSIG_MAX: libc::c_uint = 31; -pub type __int32_t = libc::c_int; +*/ pub const _ISlower: libc::c_uint = 512; extern "C" { @@ -66,6 +47,7 @@ extern "C" { _: ... ) -> libc::c_int; fn sudo_strlcpy(dst: *mut libc::c_char, src: *const libc::c_char, siz: size_t) -> size_t; + //static sys_sigabbrev: [*const libc::c_char; 65]; fn __ctype_toupper_loc() -> *mut *const __int32_t; fn __ctype_b_loc() -> *mut *const libc::c_ushort; } @@ -132,6 +114,8 @@ pub unsafe extern "C" fn sudo_sig2str( sudo_sys_signame[7 as libc::c_int as usize] = b"BUS\0" as *const u8 as *const libc::c_char as *mut libc::c_char; } + + if (sudo_sys_signame[11 as libc::c_int as usize]).is_null() { sudo_sys_signame[11 as libc::c_int as usize] = b"SEGV\0" as *const u8 as *const libc::c_char as *mut libc::c_char; @@ -265,7 +249,7 @@ pub unsafe extern "C" fn sudo_sig2str( return 0; } - if signo > 0 && signo < NSIG!() && !(sudo_sys_signame[signo as usize]).is_null() { + if signo > 0 && signo < NSIG as libc::c_int && !(sudo_sys_signame[signo as usize]).is_null() { sudo_strlcpy(signame, sudo_sys_signame[signo as usize], SIG2STR_MAX!()); /* Make sure we always return an upper case signame. */ @@ -282,6 +266,6 @@ pub unsafe extern "C" fn sudo_sig2str( } return 0 as libc::c_int; } - *__errno_location() = EINVAL!(); + *__errno_location() = EINVAL; return -(1 as libc::c_int); } diff --git a/lib/util/src/str2sig.rs b/lib/util/src/str2sig.rs index 00989e8..575a6d2 100644 --- a/lib/util/src/str2sig.rs +++ b/lib/util/src/str2sig.rs @@ -11,9 +11,7 @@ unused_mut )] -use crate::EINVAL; -use crate::SIGRTMAX; -use crate::SIGRTMIN; +use crate::common::*; extern "C" { fn __ctype_b_loc() -> *mut *const libc::c_ushort; @@ -33,6 +31,7 @@ extern "C" { fn strcmp(_: *const libc::c_char, _: *const libc::c_char) -> libc::c_int; fn sysconf(__name: libc::c_int) -> libc::c_long; fn strcasecmp(_: *const libc::c_char, _: *const libc::c_char) -> libc::c_int; +// static sys_sigabbrev: [*const libc::c_char; 65]; fn __errno_location() -> *mut libc::c_int; } @@ -85,15 +84,12 @@ static mut sigaliases: [sigalias; 6] = [ }, ]; +//#define SIGABRT 6 /* Abnormal termination. */ pub const SIGABRT: libc::c_int = 6; pub const SIGCLD: libc::c_int = 17; pub const SIGIO: libc::c_int = 29; pub const SIGIOT: libc::c_int = 6; pub const SIGPOLL: libc::c_int = 29; -pub const _ISdigit: libc::c_uint = 2048; -pub const __SIGRTMIN: libc::c_uint = 64; -pub const NSIG: libc::c_uint = __SIGRTMIN + 1; -pub const _SC_RTSIG_MAX: libc::c_int = 31; #[no_mangle] pub unsafe extern "C" fn sudo_str2sig( @@ -103,7 +99,6 @@ pub unsafe extern "C" fn sudo_str2sig( let mut alias: *mut sigalias = 0 as *mut sigalias; let mut errstr: *const libc::c_char = 0 as *const libc::c_char; let mut signo: libc::c_int = 0; - static mut sudo_sys_signame: [*mut libc::c_char; 65] = [0 as *const libc::c_char as *mut libc::c_char; 65]; let mut i: libc::c_int = 0; @@ -245,7 +240,6 @@ pub unsafe extern "C" fn sudo_str2sig( sudo_sys_signame[23 as libc::c_int as usize] = b"URG\0" as *const u8 as *const libc::c_char as *mut libc::c_char; } - if (*(*__ctype_b_loc()).offset(*signame.offset(0 as isize) as libc::c_uchar as isize) as libc::c_int & _ISdigit as libc::c_ushort as libc::c_int) @@ -263,6 +257,7 @@ pub unsafe extern "C" fn sudo_str2sig( *result = signo; return 0; } + if strncmp( signame, b"RTMIN\0" as *const u8 as *const libc::c_char, @@ -290,6 +285,7 @@ pub unsafe extern "C" fn sudo_str2sig( } } } + if strncmp( signame, b"RTMAX\0" as *const u8 as *const libc::c_char, @@ -325,7 +321,6 @@ pub unsafe extern "C" fn sudo_str2sig( } alias = alias.offset(1); } - signo = 1; while signo < NSIG as libc::c_int { if !(sudo_sys_signame[signo as usize]).is_null() { @@ -336,6 +331,6 @@ pub unsafe extern "C" fn sudo_str2sig( } signo += 1; } - *__errno_location() = EINVAL!(); + *__errno_location() = EINVAL; return -1; } diff --git a/lib/util/src/strsplit.rs b/lib/util/src/strsplit.rs index 63871a0..e6ce346 100644 --- a/lib/util/src/strsplit.rs +++ b/lib/util/src/strsplit.rs @@ -6,10 +6,7 @@ #![allow(unused_variables, unused_mut, unused_assignments)] -//use other file's func -use crate::sudo_debug::sudo_debug_enter_v1; -use crate::sudo_debug::sudo_debug_exit_ptr_v1; -use crate::sudo_debug_macro::SUDO_DEBUG_UTIL; +use crate::common::*; //line42 #[no_mangle] @@ -24,7 +21,7 @@ unsafe fn sudo_strsplit_v1( let mut s: *const libc::c_char = 0 as *const libc::c_char; //line45 - debug_decl!(stdext::function_name!().as_ptr(), SUDO_DEBUG_UTIL); + debug_decl!(SUDO_DEBUG_UTIL); //line 48 if str.is_null() { diff --git a/lib/util/src/strtobool.rs b/lib/util/src/strtobool.rs index 30efdf4..53b39bb 100644 --- a/lib/util/src/strtobool.rs +++ b/lib/util/src/strtobool.rs @@ -11,12 +11,7 @@ unused_mut )] -use crate::sudo_debug::sudo_debug_enter_v1; -use crate::sudo_debug::sudo_debug_exit_int_v1; -// use crate::sudo_debug::sudo_debug_printf2_v1; -use crate::sudo_debug_macro::SUDO_DEBUG_ERROR; -use crate::sudo_debug_macro::SUDO_DEBUG_LINENO; -use crate::sudo_debug_macro::SUDO_DEBUG_UTIL; +use crate::common::*; extern "C" { fn strcasecmp(__s1: *const libc::c_char, __s2: *const libc::c_char) -> libc::c_int; @@ -32,7 +27,8 @@ extern "C" { #[no_mangle] pub unsafe extern "C" fn sudo_strtobool_v1(mut str: *const libc::c_char) -> libc::c_int { - debug_decl!(stdext::function_name!().as_ptr(), SUDO_DEBUG_UTIL); + debug_decl!(SUDO_DEBUG_UTIL); + match *str as u8 as char { '0' | '1' => { if *str.offset(1 as isize) as libc::c_int == '\u{0}' as i32 { @@ -75,5 +71,6 @@ pub unsafe extern "C" fn sudo_strtobool_v1(mut str: *const libc::c_char) -> libc b"invalid boolean value \"%s\"\0" as *const u8 as *const libc::c_char, str ); + debug_return_int!(-1); } diff --git a/lib/util/src/strtoid.rs b/lib/util/src/strtoid.rs index 02bfbb1..a768b08 100644 --- a/lib/util/src/strtoid.rs +++ b/lib/util/src/strtoid.rs @@ -3,6 +3,7 @@ * * SPDX-License-Identifier: MulanPSL-2.0 */ + #![allow( dead_code, mutable_transmutes, @@ -13,35 +14,7 @@ unused_mut )] -type id_t = u32; -use crate::sudo_debug::sudo_debug_enter_v1; -use crate::sudo_debug::sudo_debug_exit_id_t_v1; -use crate::sudo_debug_macro::SUDO_DEBUG_UTIL; -use crate::INT_MAX; - -// #define INT_MIN (-__INT_MAX__ - 1) -#[macro_export] -macro_rules! INT_MIN { - () => { - (-(INT_MAX!()) - 1) - }; -} - -// #define UINT_MAX (__INT_MAX__ * 2U + 1U) -#[macro_export] -macro_rules! UINT_MAX { - () => { - ((INT_MAX!()) * (2 as libc::c_uint) + 1 as libc::c_uint) - }; -} - -// #define EINVAL 22 /* Invalid argument */ -#[macro_export] -macro_rules! EINVAL { - () => { - 22 - }; -} +use crate::common::*; extern "C" { fn sudo_strtonumx( @@ -51,6 +24,7 @@ extern "C" { endp: *mut *mut libc::c_char, errstrp: *mut *const libc::c_char, ) -> libc::c_longlong; + fn __errno_location() -> *mut libc::c_int; } @@ -63,6 +37,7 @@ unsafe extern "C" fn valid_separator( mut sep: *const libc::c_char, ) -> bool { let mut valid: bool = false; + if ep != p { /* check for valid separator (including '\0') */ if sep.is_null() { @@ -72,6 +47,7 @@ unsafe extern "C" fn valid_separator( if *ep == *sep { valid = true; } + if !(*sep as libc::c_int != '\u{0}' as i32) { break; } @@ -98,7 +74,9 @@ pub unsafe extern "C" fn sudo_strtoidx_v1( let mut errstr: *const libc::c_char = 0 as *const libc::c_char; let mut ep: *mut libc::c_char = 0 as *mut libc::c_char; let mut ret: id_t = 0; - debug_decl!(stdext::function_name!().as_ptr(), SUDO_DEBUG_UTIL); + + debug_decl!(SUDO_DEBUG_UTIL); + ret = sudo_strtonumx( p, INT_MIN!() as libc::c_longlong, @@ -115,17 +93,21 @@ pub unsafe extern "C" fn sudo_strtoidx_v1( || ret == UINT_MAX!() as id_t || !valid_separator(p, ep, sep) { + // 暂时不处理国际化问题 errstr = b"invalid value\0" as *const u8 as *const libc::c_char; - *__errno_location() = EINVAL!() as libc::c_int; + *__errno_location() = EINVAL; ret = 0; } } + if !errstrp.is_null() { *errstrp = errstr; } + if !endp.is_null() { *endp = ep; } + debug_return_id_t!(ret) } diff --git a/lib/util/src/strtomode.rs b/lib/util/src/strtomode.rs index feec9ff..6684faf 100644 --- a/lib/util/src/strtomode.rs +++ b/lib/util/src/strtomode.rs @@ -14,21 +14,7 @@ unused_mut )] -use crate::sudo_debug::sudo_debug_enter_v1; -use crate::sudo_debug::sudo_debug_exit_int_v1; -use crate::sudo_debug_macro::SUDO_DEBUG_UTIL; - -type mode_t = i64; -pub const S_IRWXU: mode_t = 448; -pub const S_IRWXG: mode_t = 56; -pub const S_IRWXO: mode_t = 7; - -// # define ACCESSPERMS (S_IRWXU|S_IRWXG|S_IRWXO) -macro_rules! ACCESSPERMS { - () => { - (S_IRWXU | S_IRWXG | S_IRWXO) - }; -} +use crate::common::*; extern "C" { fn strtol(_: *const libc::c_char, _: *mut *mut libc::c_char, _: libc::c_int) -> libc::c_long; @@ -42,7 +28,7 @@ pub unsafe extern "C" fn sudo_strtomode_v1( let mut ep: *mut libc::c_char = 0 as *mut libc::c_char; let mut lval: libc::c_long = 0; - debug_decl!(stdext::function_name!().as_ptr(), SUDO_DEBUG_UTIL); + debug_decl!(SUDO_DEBUG_UTIL); *__errno_location() = 0 as libc::c_int; lval = strtol(cp, &mut ep, 8 as libc::c_int); @@ -54,7 +40,7 @@ pub unsafe extern "C" fn sudo_strtomode_v1( debug_return_int!(0); } - if lval < 0 || lval > ACCESSPERMS!() { + if lval < 0 || lval > (ACCESSPERMS!() as libc::c_long) { if !errstr.is_null() { *errstr = if lval < 0 { b"value too small\0" as *const u8 as *const libc::c_char @@ -65,6 +51,7 @@ pub unsafe extern "C" fn sudo_strtomode_v1( *__errno_location() = libc::ERANGE as libc::c_int; debug_return_int!(0); } + if !errstr.is_null() { *errstr = 0 as *const libc::c_char; } diff --git a/lib/util/src/strtonum.rs b/lib/util/src/strtonum.rs index f8fc4ff..19b5c48 100644 --- a/lib/util/src/strtonum.rs +++ b/lib/util/src/strtonum.rs @@ -12,16 +12,13 @@ unused_mut )] +use crate::common::*; + extern "C" { - fn __errno_location() -> *mut libc::c_int; fn __ctype_b_loc() -> *mut *const libc::c_ushort; + fn __errno_location() -> *mut libc::c_int; } -pub const _ISspace: libc::c_uint = 8192; -pub const _ISdigit: libc::c_uint = 2048; -pub const EINVAL: libc::c_int = 22; -pub const ERANGE: libc::c_int = 34; - #[derive(Eq, PartialEq)] enum strtonum_err { STN_INITIAL = 0, @@ -46,7 +43,6 @@ pub unsafe extern "C" fn sudo_strtonumx( let mut ch: libc::c_uchar = 0; let mut remainder: libc::c_int = 0; let mut sign: libc::c_char = 0; - if minval > maxval { errval = strtonum_err::STN_INVALID; } else { @@ -61,7 +57,6 @@ pub unsafe extern "C" fn sudo_strtonumx( break; } } - match ch as u8 as char { '-' => { sign = '-' as i32 as libc::c_char; @@ -154,7 +149,6 @@ pub unsafe extern "C" fn sudo_strtonumx( } } } - match errval { strtonum_err::STN_INITIAL | strtonum_err::STN_VALID => { if !errstrp.is_null() { @@ -183,7 +177,6 @@ pub unsafe extern "C" fn sudo_strtonumx( } } } - if !endp.is_null() { if errval == strtonum_err::STN_INITIAL || errval == strtonum_err::STN_INVALID { *endp = str as *mut libc::c_char; @@ -193,7 +186,6 @@ pub unsafe extern "C" fn sudo_strtonumx( } return result; } - #[no_mangle] pub unsafe extern "C" fn sudo_strtonum( mut str: *const libc::c_char, @@ -205,13 +197,11 @@ pub unsafe extern "C" fn sudo_strtonum( let mut ep: *mut libc::c_char = 0 as *mut libc::c_char; let mut ret: libc::c_longlong = 0; ret = sudo_strtonumx(str, minval, maxval, &mut ep, &mut errstr); - if str == ep || *ep as libc::c_int != '\u{0}' as i32 { *__errno_location() = EINVAL; errstr = b"invalid value\0" as *const u8 as *const libc::c_char; ret = 0 as libc::c_longlong; } - if !errstrp.is_null() { *errstrp = errstr; } diff --git a/lib/util/src/sudo_conf.rs b/lib/util/src/sudo_conf.rs index 5fead52..499ea8d 100644 --- a/lib/util/src/sudo_conf.rs +++ b/lib/util/src/sudo_conf.rs @@ -14,122 +14,15 @@ unused_mut, unreachable_code )] -use crate::INT_MAX; -use crate::ISSET; - -// use crate::fatal::sudo_warnx_nodebug_v1; -use crate::sudo_debug::sudo_debug_enter_v1; -use crate::sudo_debug::sudo_debug_exit_bool_v1; -use crate::sudo_debug::sudo_debug_exit_int_v1; -use crate::sudo_debug::sudo_debug_exit_ptr_v1; -use crate::sudo_debug_macro::SUDO_DEBUG_ERROR; -use crate::sudo_debug_macro::SUDO_DEBUG_INFO; -use crate::sudo_debug_macro::SUDO_DEBUG_UTIL; -use crate::sudo_debug_macro::SUDO_DEBUG_WARN; - -pub type __dev_t = libc::c_ulong; -pub type __uid_t = libc::c_uint; -pub type __gid_t = libc::c_uint; -pub type __ino_t = libc::c_ulong; -pub type __mode_t = libc::c_uint; -#[cfg(target_arch = "x86_64")] -pub type __nlink_t = libc::c_ulong; -#[cfg(not(target_arch = "x86_64"))] -pub type __nlink_t = libc::c_uint; -pub type __off_t = libc::c_long; -pub type __off64_t = libc::c_long; -pub type __time_t = libc::c_long; -#[cfg(target_arch = "x86_64")] -pub type __blksize_t = libc::c_long; -#[cfg(not(target_arch = "x86_64"))] -pub type __blksize_t = libc::c_int; -pub type __blkcnt_t = libc::c_long; -pub type __ssize_t = libc::c_long; -pub type __syscall_slong_t = libc::c_long; -pub type gid_t = __gid_t; -pub type uid_t = __uid_t; -pub type ssize_t = __ssize_t; -pub type size_t = libc::c_ulong; -#[derive(Copy, Clone)] -#[repr(C)] -pub struct timespec { - pub tv_sec: __time_t, - pub tv_nsec: __syscall_slong_t, -} - -#[derive(Copy, Clone)] -#[repr(C)] -pub struct stat { - pub st_dev: __dev_t, - pub st_ino: __ino_t, - #[cfg(target_arch = "x86_64")] - pub st_nlink: __nlink_t, - pub st_mode: __mode_t, - #[cfg(not(target_arch = "x86_64"))] - pub st_nlink: __nlink_t, - pub st_uid: __uid_t, - pub st_gid: __gid_t, - #[cfg(target_arch = "x86_64")] - pub __pad0: libc::c_int, - pub st_rdev: __dev_t, - #[cfg(not(target_arch = "x86_64"))] - pub __pad1: __dev_t, - pub st_size: __off_t, - pub st_blksize: __blksize_t, - #[cfg(not(target_arch = "x86_64"))] - pub __pad2: libc::c_int, - pub st_blocks: __blkcnt_t, - pub st_atim: timespec, - pub st_mtim: timespec, - pub st_ctim: timespec, - #[cfg(target_arch = "x86_64")] - pub __glibc_reserved: [__syscall_slong_t; 3], - #[cfg(not(target_arch = "x86_64"))] - pub __glibc_reserved: [libc::c_int; 2], -} - -#[derive(Copy, Clone)] -#[repr(C)] -pub struct _IO_FILE { - pub _flags: libc::c_int, - pub _IO_read_ptr: *mut libc::c_char, - pub _IO_read_end: *mut libc::c_char, - pub _IO_read_base: *mut libc::c_char, - pub _IO_write_base: *mut libc::c_char, - pub _IO_write_ptr: *mut libc::c_char, - pub _IO_write_end: *mut libc::c_char, - pub _IO_buf_base: *mut libc::c_char, - pub _IO_buf_end: *mut libc::c_char, - pub _IO_save_base: *mut libc::c_char, - pub _IO_backup_base: *mut libc::c_char, - pub _IO_save_end: *mut libc::c_char, - pub _markers: *mut _IO_marker, - pub _chain: *mut _IO_FILE, - pub _fileno: libc::c_int, - pub _flags2: libc::c_int, - pub _old_offset: __off_t, - pub _cur_column: libc::c_ushort, - pub _vtable_offset: libc::c_schar, - pub _shortbuf: [libc::c_char; 1], - pub _lock: *mut libc::c_void, - pub _offset: __off64_t, - pub _codecvt: *mut _IO_codecvt, - pub _wide_data: *mut _IO_wide_data, - pub _freeres_list: *mut _IO_FILE, - pub _freeres_buf: *mut libc::c_void, - pub __pad5: size_t, - pub _mode: libc::c_int, - pub _unused2: [libc::c_char; 20], -} -pub type FILE = _IO_FILE; +use crate::common::*; /* Indexes into path_table[] below (order is important). */ // #define SUDO_CONF_PATH_ASKPASS 0 // #define SUDO_CONF_PATH_SESH 1 // #define SUDO_CONF_PATH_NOEXEC 2 // #define SUDO_CONF_PATH_PLUGIN_DIR 3 -// #define SUDO_CONF_PATH_DEVSEARCH 4 +// #define SUDO_CONF_PATH_DEVSEARCH 4 pub const SUDO_CONF_PATH_ASKPASS: libc::c_int = 0; pub const SUDO_CONF_PATH_SESH: libc::c_int = 1; pub const SUDO_CONF_PATH_NOEXEC: libc::c_int = 2; @@ -138,52 +31,15 @@ pub const SUDO_CONF_PATH_DEVSEARCH: libc::c_int = 4; pub const __LC_ALL: libc::c_int = 6; pub const LC_ALL: libc::c_int = __LC_ALL; -// # define ROOT_UID 0 -pub const ROOT_UID: libc::c_int = 0 as libc::c_int; - -/* secure_path.c */ -// #define SUDO_PATH_SECURE 0 -// #define SUDO_PATH_MISSING -1 -// #define SUDO_PATH_BAD_TYPE -2 -// #define SUDO_PATH_WRONG_OWNER -3 -// #define SUDO_PATH_WORLD_WRITABLE -4 -// #define SUDO_PATH_GROUP_WRITABLE -5 -pub const SUDO_PATH_SECURE: libc::c_int = 0; -pub const SUDO_PATH_MISSING: libc::c_int = -1; -pub const SUDO_PATH_BAD_TYPE: libc::c_int = -2; -pub const SUDO_PATH_WRONG_OWNER: libc::c_int = -3; -pub const SUDO_PATH_WORLD_WRITABLE: libc::c_int = -4; -pub const SUDO_PATH_GROUP_WRITABLE: libc::c_int = -5; - -// #define ENOENT 2 /* No such file or directory */ -pub const ENOENT: libc::c_int = 2; /* Values of sudo_conf_group_source() */ // #define GROUP_SOURCE_ADAPTIVE 0 -// #define GROUP_SOURCE_STATIC 1 +// #define GROUP_SOURCE_STATIC 1 // #define GROUP_SOURCE_DYNAMIC 2 pub const GROUP_SOURCE_ADAPTIVE: libc::c_int = 0; pub const GROUP_SOURCE_STATIC: libc::c_int = 1; pub const GROUP_SOURCE_DYNAMIC: libc::c_int = 2; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _IO_marker { - _unused: [u8; 0], -} - -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _IO_codecvt { - _unused: [u8; 0], -} - -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct _IO_wide_data { - _unused: [u8; 0], -} - extern "C" { fn fclose(__stream: *mut FILE) -> libc::c_int; fn fopen(_: *const libc::c_char, _: *const libc::c_char) -> *mut FILE; @@ -210,6 +66,7 @@ extern "C" { msgid: *const libc::c_char, ) -> *mut libc::c_char; fn sudo_warn_nodebug_v1(fmt: *const libc::c_char, _: ...); + // fn sudo_warnx_nodebug_v1(fmt: *const libc::c_char, _: ...); fn sudo_secure_file_v1( path: *const libc::c_char, uid: uid_t, @@ -246,40 +103,6 @@ extern "C" { ); fn sudo_warnx_nodebug_v1(fmt: *const libc::c_char, _: ...); } -// #define isblank(c) __isctype((c), _ISblank) -macro_rules! isblank { - ($c:expr) => { - __isctype!($c, _ISblank!()) - }; -} - -// # define __isctype(c, type) ((*__ctype_b_loc ())[(int) (c)] & (unsigned short int) type) -macro_rules! __isctype { - ($c:expr, $type:expr) => { - ((*__ctype_b_loc()).offset($c as isize) as libc::c_int) - & ($type as libc::c_int as libc::c_ushort as libc::c_int) - }; -} - -// define _ISbit(bit) ((bit) < 8 ? ((1 << (bit)) << 8) : ((1 << (bit)) >> 8)) -// _ISblank = _ISbit (8), /* Blank (usually SPC and TAB). */ -#[macro_export] -macro_rules! _ISbit { - ($bit:expr) => { - if ($bit) < 8 { - ((1 << ($bit)) << 8) - } else { - ((1 << ($bit)) >> 8) - } - }; -} - -#[macro_export] -macro_rules! _ISblank { - () => { - _ISbit!(8) - }; -} // # define _PATH_SUDO_ASKPASS NULL macro_rules! _PATH_SUDO_ASKPASS { @@ -291,14 +114,14 @@ macro_rules! _PATH_SUDO_ASKPASS { // # define _PATH_SUDO_SESH "/usr/libexec/utsudo/sesh" macro_rules! _PATH_SUDO_SESH { () => { - (b"/usr/libexec/utsudo/sesh\0" as *const u8 as *const libc::c_char as *mut libc::c_char) + (b"/usr/libexec/utsudo/utsesh\0" as *const u8 as *const libc::c_char as *mut libc::c_char) }; } -// # define _PATH_SUDO_NOEXEC "/usr/libexec/utsudo/sudo_noexec.so" +// # define _PATH_SUDO_NOEXEC "/usr/libexec/utsudo/utsudo_noexec.so" macro_rules! _PATH_SUDO_NOEXEC { () => { - (b"/usr/libexec/utsudo/sudo_noexec.so\0" as *const u8 as *const libc::c_char + (b"/usr/libexec/utsudo/utsudo_noexec.so\0" as *const u8 as *const libc::c_char as *mut libc::c_char) }; } @@ -317,59 +140,13 @@ macro_rules! _PATH_SUDO_DEVSEARCH { }; } -// # define _PATH_SUDO_CONF "/etc/sudo.conf" +// # define _PATH_SUDO_CONF "/etc/utsudo.conf" macro_rules! _PATH_SUDO_CONF { () => { - (b"/etc/sudo.conf\0" as *const u8 as *const libc::c_char) + (b"/etc/utsudo.conf\0" as *const u8 as *const libc::c_char) }; } -#[derive(Copy, Clone)] -#[repr(C)] -pub struct sudo_debug_file { - pub entries: C2RustUnnamed_0, - pub debug_file: *mut libc::c_char, - pub debug_flags: *mut libc::c_char, -} - -#[derive(Copy, Clone)] -#[repr(C)] -pub struct C2RustUnnamed_0 { - pub tqe_next: *mut sudo_debug_file, - pub tqe_prev: *mut *mut sudo_debug_file, -} - -#[derive(Copy, Clone)] -#[repr(C)] -pub struct sudo_conf_debug_file_list { - pub tqh_first: *mut sudo_debug_file, - pub tqh_last: *mut *mut sudo_debug_file, -} - -#[derive(Copy, Clone)] -#[repr(C)] -pub struct plugin_info { - pub entries: C2RustUnnamed_1, - pub path: *mut libc::c_char, - pub symbol_name: *mut libc::c_char, - pub options: *mut *mut libc::c_char, - pub lineno: libc::c_uint, -} - -#[derive(Copy, Clone)] -#[repr(C)] -pub struct C2RustUnnamed_1 { - pub tqe_next: *mut plugin_info, - pub tqe_prev: *mut *mut plugin_info, -} - -#[derive(Copy, Clone)] -#[repr(C)] -pub struct plugin_info_list { - pub tqh_first: *mut plugin_info, - pub tqh_last: *mut *mut plugin_info, -} - #[derive(Copy, Clone)] #[repr(C)] pub struct sudo_conf_debug { @@ -377,7 +154,6 @@ pub struct sudo_conf_debug { pub debug_files: sudo_conf_debug_file_list, pub progname: *mut libc::c_char, } - #[derive(Copy, Clone)] #[repr(C)] pub struct C2RustUnnamed_2 { @@ -390,7 +166,6 @@ pub struct sudo_conf_debug_list { pub tqh_first: *mut sudo_conf_debug, pub tqh_last: *mut *mut sudo_conf_debug, } - #[derive(Copy, Clone)] #[repr(C)] pub struct sudo_conf_table { @@ -411,7 +186,6 @@ pub struct sudo_conf_data { pub plugins: plugin_info_list, pub path_table: [sudo_conf_path_table; 6], } - #[derive(Copy, Clone)] #[repr(C)] pub struct sudo_conf_path_table { @@ -466,12 +240,12 @@ pub unsafe extern "C" fn parse_variable( let mut var: *mut sudo_conf_table = 0 as *mut sudo_conf_table; let mut ret: libc::c_int = 0; - debug_decl!(stdext::function_name!().as_ptr(), SUDO_DEBUG_UTIL); + debug_decl!(SUDO_DEBUG_UTIL); var = sudo_conf_var_table.as_mut_ptr(); while !((*var).name).is_null() { if strncmp(entry, (*var).name, (*var).namelen as libc::c_ulong) == 0 - && isblank!(entry.offset((*var).namelen as isize)) != 0 + && isblank!(*entry.offset((*var).namelen as isize)) != 0 { entry = entry.offset(((*var).namelen + 1) as isize); @@ -489,7 +263,7 @@ pub unsafe extern "C" fn parse_variable( sudo_debug_printf!( ret, b"%s: %s:%u: Set %s %s\0" as *const u8 as *const libc::c_char, - stdext::function_name!().as_ptr(), + get_function_name!(), conf_file, lineno, (*var).name, @@ -499,14 +273,16 @@ pub unsafe extern "C" fn parse_variable( } var = var.offset(1); } // while !((*var).name).is_null() + sudo_debug_printf!( SUDO_DEBUG_WARN, b"%s: %s:%u: unknown setting %s\0" as *const u8 as *const libc::c_char, - stdext::function_name!().as_ptr(), + get_function_name!(), conf_file, lineno, entry ); + debug_return_int!(false as libc::c_int); } @@ -527,7 +303,7 @@ unsafe extern "C" fn parse_path( let mut cur: *mut sudo_conf_path_table = 0 as *mut sudo_conf_path_table; let mut namelen: size_t = 0 as size_t; - debug_decl!(stdext::function_name!().as_ptr(), SUDO_DEBUG_UTIL); + debug_decl!(SUDO_DEBUG_UTIL); 'bad: loop { name = sudo_strsplit_v1( @@ -539,6 +315,7 @@ unsafe extern "C" fn parse_path( if name.is_null() { break 'bad; } + namelen = ep.offset_from(name) as libc::c_long as size_t; /* Parse path (if present). */ @@ -558,10 +335,10 @@ unsafe extern "C" fn parse_path( let mut pval: *mut libc::c_char = 0 as *mut libc::c_char; if !path.is_null() { pval = strdup(path); - if !pval.is_null() { + if pval.is_null() { sudo_warnx!( b"%s: %s\0" as *const u8 as *const libc::c_char, - stdext::function_name!().as_ptr(), + get_function_name!(), b"unable to allocate memory\0" as *const u8 as *const libc::c_char ); debug_return_int!(-1); @@ -573,10 +350,11 @@ unsafe extern "C" fn parse_path( } (*cur).pval = pval; (*cur).dynamic = true; + sudo_debug_printf!( SUDO_DEBUG_INFO, b"%s: %s:%u: Path %s %s\0" as *const u8 as *const libc::c_char, - stdext::function_name!().as_ptr(), + get_function_name!(), conf_file, lineno, (*cur).pname, @@ -591,14 +369,16 @@ unsafe extern "C" fn parse_path( cur = cur.offset(1 as isize); } // !(*cur).pname.is_null() + sudo_debug_printf!( SUDO_DEBUG_WARN, b"%s: %s:%u: unknown path %s\0" as *const u8 as *const libc::c_char, - stdext::function_name!().as_ptr(), + get_function_name!(), conf_file, lineno, entry ); + debug_return_int!(false as libc::c_int); break 'bad; @@ -611,6 +391,7 @@ unsafe extern "C" fn parse_path( conf_file, lineno ); + debug_return_int!(false as libc::c_int); } @@ -633,7 +414,7 @@ unsafe extern "C" fn parse_debug( let mut pathlen: size_t = 0 as size_t; let mut prognamelen: size_t = 0 as size_t; - debug_decl!(stdext::function_name!().as_ptr(), SUDO_DEBUG_UTIL); + debug_decl!(SUDO_DEBUG_UTIL); /* Parse progname. */ progname = sudo_strsplit_v1( @@ -667,7 +448,7 @@ unsafe extern "C" fn parse_debug( &mut ep, ); - if !flags.is_null() { + if flags.is_null() { debug_return_int!(false as libc::c_int); /* not enough fields */ } @@ -675,12 +456,13 @@ unsafe extern "C" fn parse_debug( debug_spec = sudo_conf_data.debugging.tqh_first; while !debug_spec.is_null() { if strncmp((*debug_spec).progname, progname, prognamelen) == 0 - && (*debug_spec).progname.offset(prognamelen as isize) as libc::c_int == '\u{0}' as i32 + && *((*debug_spec).progname).offset(prognamelen as isize) as libc::c_int == '\0' as i32 { break; } debug_spec = (*debug_spec).entries.tqe_next; } + 'oom: loop { if debug_spec.is_null() { debug_spec = malloc(::std::mem::size_of::() as libc::c_ulong) @@ -690,7 +472,7 @@ unsafe extern "C" fn parse_debug( break 'oom; } (*debug_spec).progname = strndup(progname, prognamelen); - if !(*debug_spec).progname.is_null() { + if (*debug_spec).progname.is_null() { free(debug_spec as *mut libc::c_void); debug_spec = 0 as *mut sudo_conf_debug; break 'oom; @@ -708,7 +490,7 @@ unsafe extern "C" fn parse_debug( debug_file = calloc(1, ::std::mem::size_of::() as libc::c_ulong) as *mut sudo_debug_file; - if !debug_file.is_null() { + if debug_file.is_null() { break 'oom; } @@ -734,7 +516,7 @@ unsafe extern "C" fn parse_debug( sudo_warnx!( b"%s: %s\0" as *const u8 as *const libc::c_char, - stdext::function_name!().as_ptr(), + get_function_name!(), b"unable to allocate memory\0" ); @@ -765,7 +547,7 @@ unsafe extern "C" fn parse_plugin( let mut symlen: size_t = 0 as size_t; let mut nopts: libc::c_uint = 0 as libc::c_uint; - debug_decl!(stdext::function_name!().as_ptr(), SUDO_DEBUG_UTIL); + debug_decl!(SUDO_DEBUG_UTIL); /* Parse symbol. */ symbol = sudo_strsplit_v1( @@ -799,7 +581,7 @@ unsafe extern "C" fn parse_plugin( } 'oom: loop { - if *ep as libc::c_int != '\u{0}' as i32 { + if *ep as libc::c_int != '\0' as i32 { /* Count number of options and allocate array. */ let mut cp: *const libc::c_char = 0 as *const libc::c_char; let mut opt: *const libc::c_char = ep; @@ -839,27 +621,36 @@ unsafe extern "C" fn parse_plugin( b" \t\0" as *const u8 as *const libc::c_char, &mut ep, ); - while !cp.is_null() { - *options.offset(nopts as isize) = strndup(cp, ep.offset_from(cp) as size_t); - if ((*options).offset(nopts as isize)).is_null() { + + loop { + if cp.is_null() { + break; + } + let ref mut fresh0 = *options.offset(nopts as isize); + *fresh0 = strndup(cp, ep.offset_from(cp) as libc::c_long as size_t); + if (*options.offset(nopts as isize)).is_null() { + let ref mut fresh1 = *options.offset(nopts as isize); + *fresh1 = 0 as *mut libc::c_char; break 'oom; } - nopts += 1; + nopts = nopts.wrapping_add(1); + cp = sudo_strsplit_v1( 0 as *const libc::c_char, entry_end, b" \t\0" as *const u8 as *const libc::c_char, &mut ep, ); - } // while !cp.is_null() + } *options.offset(nopts as isize) = 0 as *mut libc::c_char; - } // if *ep as libc::c_int != '\u{0}' as i32 + } // if *ep as libc::c_int != '\0' as i32 info = calloc( - ::std::mem::size_of::<*const plugin_info>() as libc::c_ulong, - 1, + ::core::mem::size_of::() as libc::c_ulong, + 1 as libc::c_int as libc::c_ulong, ) as *mut plugin_info; + if info.is_null() { break 'oom; } @@ -874,7 +665,7 @@ unsafe extern "C" fn parse_plugin( (*info).options = options; (*info).lineno = lineno; - // TAILQ_INSERT_TAIL(&sudo_conf_data.plugins, info, entries); + // TAILQ_INSERT_TAIL(&sudo_conf_data.plugins, info, entries); (*info).entries.tqe_next = 0 as *mut plugin_info; (*info).entries.tqe_prev = sudo_conf_data.plugins.tqh_last; *sudo_conf_data.plugins.tqh_last = info; @@ -884,20 +675,23 @@ unsafe extern "C" fn parse_plugin( break 'oom; } // oom loop + sudo_warnx!( b"%s: %s\0" as *const u8 as *const libc::c_char, - stdext::function_name!().as_ptr(), + get_function_name!(), b"unable to allocate memory\0" as *const u8 as *const libc::c_char ); if !options.is_null() { loop { - nopts -= 1; - if !(nopts != 0) { + let fresh2 = nopts; + nopts = nopts.wrapping_sub(1); + if !(fresh2 != 0) { break; } free(*options.offset(nopts as isize) as *mut libc::c_void); } + free(options as *mut libc::c_void); } if !info.is_null() { @@ -918,7 +712,7 @@ unsafe extern "C" fn set_var_disable_coredump( // int val = sudo_strtobool(strval); let mut val: libc::c_int = sudo_strtobool_v1(strval); - debug_decl!(stdext::function_name!().as_ptr(), SUDO_DEBUG_UTIL); + debug_decl!(SUDO_DEBUG_UTIL); if val == -1 { sudo_warnx!( @@ -934,7 +728,7 @@ unsafe extern "C" fn set_var_disable_coredump( sudo_conf_data.disable_coredump = val as libc::c_int != 0; - debug_return_int!(true as libc::c_int); + debug_return_int!(true as libc::c_int) } #[no_mangle] @@ -943,7 +737,7 @@ unsafe extern "C" fn set_var_group_source( mut conf_file: *const libc::c_char, mut lineno: libc::c_uint, ) -> libc::c_int { - debug_decl!(stdext::function_name!().as_ptr(), SUDO_DEBUG_UTIL); + debug_decl!(SUDO_DEBUG_UTIL); if strcasecmp(strval, b"adaptive\0" as *const u8 as *const libc::c_char) == 0 { sudo_conf_data.group_source = GROUP_SOURCE_ADAPTIVE; @@ -960,8 +754,9 @@ unsafe extern "C" fn set_var_group_source( ); debug_return_int!(false as libc::c_int); } - debug_return_int!(true as libc::c_int); + debug_return_int!(true as libc::c_int) } + #[no_mangle] unsafe extern "C" fn set_var_max_groups( mut strval: *const libc::c_char, @@ -969,7 +764,7 @@ unsafe extern "C" fn set_var_max_groups( mut lineno: libc::c_uint, ) -> libc::c_int { let mut max_groups: libc::c_int = 0 as libc::c_int; - debug_decl!(stdext::function_name!().as_ptr(), SUDO_DEBUG_UTIL); + debug_decl!(SUDO_DEBUG_UTIL); max_groups = sudo_strtonum(strval, 1, INT_MAX!(), 0 as *mut *const libc::c_char) as libc::c_int; if max_groups <= 0 { @@ -982,7 +777,7 @@ unsafe extern "C" fn set_var_max_groups( debug_return_int!(false as libc::c_int); } sudo_conf_data.max_groups = max_groups; - debug_return_int!(true as libc::c_int); + debug_return_int!(true as libc::c_int) } #[no_mangle] @@ -992,7 +787,7 @@ unsafe extern "C" fn set_var_probe_interfaces( mut lineno: libc::c_uint, ) -> libc::c_int { let mut val: libc::c_int = sudo_strtobool_v1(strval); - debug_decl!(stdext::function_name!().as_ptr(), SUDO_DEBUG_UTIL); + debug_decl!(SUDO_DEBUG_UTIL); if val == -1 { sudo_warnx!( @@ -1006,7 +801,7 @@ unsafe extern "C" fn set_var_probe_interfaces( } sudo_conf_data.probe_interfaces = val as libc::c_int != 0; - debug_return_int!(true as libc::c_int); + debug_return_int!(true as libc::c_int) } #[no_mangle] @@ -1064,25 +859,25 @@ pub unsafe extern "C" fn sudo_conf_debug_files_v1( let mut progbaselen: size_t = 0 as size_t; let mut progbase: *const libc::c_char = progname; - debug_decl!(stdext::function_name!().as_ptr(), SUDO_DEBUG_UTIL); + debug_decl!(SUDO_DEBUG_UTIL); /* Determine basename if program is fully qualified (like for plugins). */ prognamelen = strlen(progname) as size_t; - progbaselen = strlen(progname) as size_t; + progbaselen = prognamelen; if *progname as libc::c_int == '/' as i32 { progbase = strrchr(progname, '/' as i32); progbase = progbase.offset(1 as isize); progbaselen = strlen(progbase); } - /* Convert sudoedit -> sudo. */ - if progbaselen > 4 + /* Convert utsudoedit -> utsudo. */ + if progbaselen > 6 && strcmp( - progbase.offset(4 as isize), + progbase.offset(6 as isize), b"edit\0" as *const u8 as *const libc::c_char, ) == 0 { - progbaselen = progbaselen - 4; + progbaselen = progbaselen - 6; } debug_spec = sudo_conf_data.debugging.tqh_first; @@ -1090,14 +885,13 @@ pub unsafe extern "C" fn sudo_conf_debug_files_v1( let mut prog: *const libc::c_char = progbase; let mut len: size_t = progbaselen; - if ((*debug_spec).progname).offset(0 as isize) as libc::c_int == '/' as i32 { + if *((*debug_spec).progname).offset(0 as isize) as libc::c_int == '/' as i32 { /* Match fully-qualified name, if possible. */ prog = progname; len = prognamelen; } - if strncasecmp((*debug_spec).progname, prog, len) == 0 - && ((*debug_spec).progname).offset(len as isize) as libc::c_int == '\u{0}' as i32 + && *((*debug_spec).progname).offset(len as isize) as libc::c_int == '\u{0}' as i32 { debug_return_ptr!(&mut ((*debug_spec).debug_files) as *mut sudo_conf_debug_file_list); } @@ -1118,51 +912,14 @@ pub unsafe extern "C" fn sudo_conf_probe_interfaces_v1() -> bool { } /* - * Reads in /etc/sudo.conf and populates sudo_conf_data. + * Reads in /etc/utsudo.conf and populates sudo_conf_data. */ #[no_mangle] pub unsafe extern "C" fn sudo_conf_read_v1( mut conf_file: *const libc::c_char, mut conf_types: libc::c_int, ) -> libc::c_int { - let mut sb: stat = stat { - st_dev: 0, - st_ino: 0, - #[cfg(target_arch = "x86_64")] - st_nlink: 0, - st_mode: 0, - #[cfg(not(target_arch = "x86_64"))] - st_nlink: 0, - st_uid: 0, - st_gid: 0, - #[cfg(target_arch = "x86_64")] - __pad0: 0, - st_rdev: 0, - #[cfg(not(target_arch = "x86_64"))] - __pad1: 0, - st_size: 0, - st_blksize: 0, - #[cfg(not(target_arch = "x86_64"))] - __pad2: 0, - st_blocks: 0, - st_atim: timespec { - tv_sec: 0, - tv_nsec: 0, - }, - st_mtim: timespec { - tv_sec: 0, - tv_nsec: 0, - }, - st_ctim: timespec { - tv_sec: 0, - tv_nsec: 0, - }, - #[cfg(target_arch = "x86_64")] - __glibc_reserved: [0; 3], - #[cfg(not(target_arch = "x86_64"))] - __glibc_reserved: [0; 2], - }; - + let mut sb: stat = sb_all_arch; let mut fp: *mut FILE = 0 as *mut FILE; let mut ret: libc::c_int = false as libc::c_int; @@ -1171,7 +928,7 @@ pub unsafe extern "C" fn sudo_conf_read_v1( let mut conf_lineno: libc::c_uint = 0 as libc::c_uint; let mut linesize: size_t = 0 as size_t; - debug_decl!(stdext::function_name!().as_ptr(), SUDO_DEBUG_UTIL); + debug_decl!(SUDO_DEBUG_UTIL); prev_locale = setlocale(LC_ALL, 0 as *const libc::c_char); if prev_locale.is_null() { @@ -1183,7 +940,7 @@ pub unsafe extern "C" fn sudo_conf_read_v1( if prev_locale.is_null() { sudo_warnx!( b"%s: %s\0" as *const u8 as *const libc::c_char, - stdext::function_name!().as_ptr(), + get_function_name!(), b"unable to allocate memory\0" as *const u8 as *const libc::c_char ); debug_return_int!(-(1 as libc::c_int)); @@ -1195,6 +952,7 @@ pub unsafe extern "C" fn sudo_conf_read_v1( { setlocale(LC_ALL, b"C\0" as *const u8 as *mut libc::c_char); } + 'done: loop { if conf_file.is_null() { conf_file = _PATH_SUDO_CONF!(); @@ -1205,7 +963,7 @@ pub unsafe extern "C" fn sudo_conf_read_v1( &mut sb, ) { SUDO_PATH_SECURE => { - break 'done; + // break 'done; } SUDO_PATH_MISSING => { /* Root should always be able to read sudo.conf. */ @@ -1285,7 +1043,7 @@ pub unsafe extern "C" fn sudo_conf_read_v1( } cur = sudo_conf_table.as_mut_ptr(); - while (*cur).name.is_null() { + while !(*cur).name.is_null() { if strncasecmp(cp, (*cur).name, (*cur).namelen as libc::c_ulong) == 0 && isblank!(*cp.offset((*cur).namelen as isize) as isize) != 0 { @@ -1306,13 +1064,15 @@ pub unsafe extern "C" fn sudo_conf_read_v1( } // ISSET break; } // if strncasecmp + i = i.wrapping_add(1); + cur = cur.offset(1); } // while (*cur).name.is_null() - if (*cur).name.is_null() { + if ((*cur).name).is_null() { sudo_debug_printf!( SUDO_DEBUG_WARN, b"%s: %s:%u: unsupported entry: %s\0" as *const u8 as *const libc::c_char, - stdext::function_name!().as_ptr(), + get_function_name!(), conf_file, conf_lineno, line @@ -1330,8 +1090,8 @@ pub unsafe extern "C" fn sudo_conf_read_v1( free(line as *mut libc::c_void); /* Restore locale if needed. */ - if prev_locale.offset(0 as isize) as libc::c_int != 'C' as i32 - || prev_locale.offset(1 as isize) as libc::c_int != '\u{0}' as i32 + if *prev_locale.offset(0 as isize) as libc::c_int != 'C' as i32 + || *prev_locale.offset(1 as isize) as libc::c_int != '\u{0}' as i32 { setlocale(LC_ALL, prev_locale); } @@ -1346,7 +1106,7 @@ pub unsafe extern "C" fn sudo_conf_read_v1( #[no_mangle] pub unsafe extern "C" fn sudo_conf_clear_paths_v1() { let mut cur: *mut sudo_conf_path_table = 0 as *mut sudo_conf_path_table; - debug_decl!(stdext::function_name!().as_ptr(), SUDO_DEBUG_UTIL); + debug_decl!(SUDO_DEBUG_UTIL); cur = (sudo_conf_data.path_table).as_mut_ptr(); while !((*cur).pname).is_null() { @@ -1594,7 +1354,7 @@ unsafe extern "C" fn run_static_initializers() { pname: 0 as *const libc::c_char, pnamelen: 0 as libc::c_uint, dynamic: false, - pval: _PATH_SUDO_SESH!(), + pval: 0 as *mut libc::c_char, }; null }, diff --git a/lib/util/src/sudo_debug.rs b/lib/util/src/sudo_debug.rs index 706325d..ef7ec99 100644 --- a/lib/util/src/sudo_debug.rs +++ b/lib/util/src/sudo_debug.rs @@ -88,12 +88,12 @@ macro_rules! O_CREAT { }; } -#[macro_export] +/*#[macro_export] macro_rules! S_IRUSR { () => { 0400 }; -} +}*/ #[macro_export] macro_rules! IGNORE_RESULT { @@ -157,21 +157,21 @@ macro_rules! sudo_setbit { /* Extract subsystem number and convert to an index. */ // #define SUDO_DEBUG_SUBSYS(n) (((n) >> 6) - 1) -#[macro_export] +/*#[macro_export] macro_rules! SUDO_DEBUG_SUBSYS { ($_n:expr) => { ((($_n) >> 6) - 1) }; -} +}*/ /* Extract priority number and convert to an index. */ // #define SUDO_DEBUG_PRI(n) (((n) & 0x0f) - 1) -#[macro_export] +/*#[macro_export] macro_rules! SUDO_DEBUG_PRI { ($_n:expr) => { ((($_n) & 0x0f) - 1) }; -} +}*/ /* Flag to include string version of errno in debug info. */ // #define SUDO_DEBUG_ERRNO (1<<4) diff --git a/lib/util/src/sudo_debug_macro.rs b/lib/util/src/sudo_debug_macro.rs index bb448c9..4822b7a 100644 --- a/lib/util/src/sudo_debug_macro.rs +++ b/lib/util/src/sudo_debug_macro.rs @@ -22,6 +22,7 @@ use crate::sudo_debug::*; pub static mut sudo_debug_subsys: libc::c_int = 0 as libc::c_int; + // extern "C" { // fn sudo_debug_printf2_v1( // func: *const libc::c_char, @@ -133,6 +134,7 @@ macro_rules! debug_decl { }; } + macro_rules! debug_return_int { ($ret:expr) => {{ sudo_debug_exit_int_v1( @@ -233,6 +235,7 @@ macro_rules! debug_return_bool { }}; } + macro_rules! debug_return_str { ($ret:expr) => {{ sudo_debug_exit_str_v1( @@ -246,6 +249,7 @@ macro_rules! debug_return_str { }}; } + macro_rules! debug_return_const_str { ($ret:expr) => { let mut sudo_debug_ret: *mut libc::c_char = ($ret); diff --git a/lib/util/src/sudo_dso.rs b/lib/util/src/sudo_dso.rs index 625cf52..510d2b8 100644 --- a/lib/util/src/sudo_dso.rs +++ b/lib/util/src/sudo_dso.rs @@ -14,46 +14,11 @@ unused_mut )] -//secure_path.rs -use crate::ISSET; - -/* Values for sudo_dso_load() mode. */ -// #define SUDO_DSO_LAZY 0x1 -// #define SUDO_DSO_NOW 0x2 -// #define SUDO_DSO_GLOBAL 0x4 -// #define SUDO_DSO_LOCAL 0x8 - -#[macro_export] -macro_rules! SUDO_DSO_LAZY { - () => { - 0x1 - }; -} - -#[macro_export] -macro_rules! SUDO_DSO_NOW { - () => { - 0x2 - }; -} - -#[macro_export] -macro_rules! SUDO_DSO_GLOBAL { - () => { - 0x3 - }; -} - -#[macro_export] -macro_rules! SUDO_DSO_LOCAL { - () => { - 0x4 - }; -} +use crate::common::*; /* The MODE argument to `dlopen' contains one of the following: */ -// #define RTLD_LAZY 0x00001 /* Lazy function call binding. */ -// #define RTLD_NOW 0x00002 /* Immediate function call binding. */ +// #define RTLD_LAZY 0x00001 /* Lazy function call binding. */ +// #define RTLD_NOW 0x00002 /* Immediate function call binding. */ #[macro_export] macro_rules! RTLD_LAZY { () => { @@ -68,7 +33,7 @@ macro_rules! RTLD_NOW { }; } -// #define RTLD_GLOBAL 0x00100 +// #define RTLD_GLOBAL 0x00100 #[macro_export] macro_rules! RTLD_GLOBAL { () => { @@ -76,7 +41,7 @@ macro_rules! RTLD_GLOBAL { }; } -// #define RTLD_LOCAL 0 +// #define RTLD_LOCAL 0 #[macro_export] macro_rules! RTLD_LOCAL { () => { @@ -89,7 +54,6 @@ macro_rules! RTLD_LOCAL { // #define SUDO_DSO_DEFAULT ((void *)-2) /* Use default search algorithm. */ // #define SUDO_DSO_SELF ((void *)-3) /* Search the caller itself. */ pub const SUDO_DSO_NEXT: *mut libc::c_void = -(1 as libc::c_int) as *mut libc::c_void; -pub const SUDO_DSO_DEFAULT: *mut libc::c_void = -(2 as libc::c_int) as *mut libc::c_void; pub const SUDO_DSO_SELF: *mut libc::c_void = -(3 as libc::c_int) as *mut libc::c_void; // # define RTLD_NEXT ((void *) -1l) @@ -98,9 +62,6 @@ pub const RTLD_NEXT: *mut libc::c_void = -(1 as libc::c_long) as *mut libc::c_vo // # define RTLD_DEFAULT ((void *) 0) pub const RTLD_DEFAULT: *mut libc::c_void = 0 as *mut libc::c_void; -// #define ENOENT 2 -pub const ENOENT: libc::c_int = 2; - extern "C" { fn dlerror() -> *mut libc::c_char; fn dlclose(__handle: *mut libc::c_void) -> libc::c_int; diff --git a/lib/util/src/term.rs b/lib/util/src/term.rs index 00352ae..bf015fa 100644 --- a/lib/util/src/term.rs +++ b/lib/util/src/term.rs @@ -15,20 +15,11 @@ clashing_extern_declarations )] -//ttysize.rs文件中定义 -use crate::TIOCGWINSZ; - -use crate::sudo_debug::sudo_debug_enter_v1; -use crate::sudo_debug::sudo_debug_exit_bool_v1; -use crate::sudo_debug_macro::SUDO_DEBUG_UTIL; +use crate::common::*; /* Type of a signal handler. */ // typedef void (*__sighandler_t) (int); -pub type __sighandler_t = Option ()>; -pub type __pid_t = libc::c_int; -pub type __uid_t = libc::c_uint; -pub type __clock_t = libc::c_long; -pub type __uint32_t = libc::c_uint; + pub type tcflag_t = libc::c_uint; pub type cc_t = libc::c_uchar; pub const NCCS: libc::c_int = 32; @@ -48,141 +39,6 @@ pub static mut sudo_term_erase: libc::c_int = 0; #[no_mangle] pub static mut sudo_term_kill: libc::c_int = 0; -#[derive(Copy, Clone)] -#[repr(C)] -pub union sigval { - pub sival_int: libc::c_int, - pub sival_ptr: *mut libc::c_void, -} -pub type __sigval_t = sigval; - -#[derive(Copy, Clone)] -#[repr(C)] -pub struct siginfo_t { - pub si_signo: libc::c_int, - pub si_errno: libc::c_int, - pub si_code: libc::c_int, - pub __pad0: libc::c_int, - pub _sifields: sifields_union, -} - -#[derive(Copy, Clone)] -#[repr(C)] -pub struct kill_struct { - pub si_pid: __pid_t, - pub si_uid: __uid_t, -} - -#[derive(Copy, Clone)] -#[repr(C)] -pub struct timer_struct { - pub si_tid: libc::c_int, - pub si_overrun: libc::c_int, - pub si_sigval: __sigval_t, -} - -#[derive(Copy, Clone)] -#[repr(C)] -pub struct rt_struct { - pub si_pid: __pid_t, - pub si_uid: __uid_t, - pub si_sigval: __sigval_t, -} - -#[derive(Copy, Clone)] -#[repr(C)] -pub struct sigchld_struct { - pub si_pid: __pid_t, - pub si_uid: __uid_t, - pub si_status: libc::c_int, - pub si_utime: __clock_t, - pub si_stime: __clock_t, -} - -#[derive(Copy, Clone)] -#[repr(C)] -pub struct sigfault_struct { - pub si_addr: *mut libc::c_void, - pub si_addr_lsb: libc::c_short, - pub _bounds: bounds_struct, -} - -#[derive(Copy, Clone)] -#[repr(C)] -pub struct sigpoll_struct { - pub si_band: libc::c_long, - pub si_fd: libc::c_int, -} - -#[derive(Copy, Clone)] -#[repr(C)] -pub struct sigsys_struct { - pub _call_addr: *mut libc::c_void, - pub _syscall: libc::c_int, - pub _arch: libc::c_uint, -} - -#[derive(Copy, Clone)] -#[repr(C)] -pub union sifields_union { - pub _pad: [libc::c_int; 28], - pub _kill: kill_struct, - pub _timer: timer_struct, - pub _rt: rt_struct, - pub _sigchld: sigchld_struct, - pub _sigfault: sigfault_struct, - pub _sigpoll: sigpoll_struct, - pub _sigsys: sigsys_struct, -} - -#[derive(Copy, Clone)] -#[repr(C)] -pub struct bounds_struct { - pub _addr_bnd: addr_bnd_struct, - pub _key: __uint32_t, -} - -#[derive(Copy, Clone)] -#[repr(C)] -pub struct addr_bnd_struct { - pub _lower: *mut libc::c_void, - pub _upper: *mut libc::c_void, -} - -#[derive(Copy, Clone)] -#[repr(C)] -pub struct __sigset_t { - pub __val: [libc::c_ulong; 16], -} -pub type sigset_t = __sigset_t; - -#[derive(Copy, Clone)] -#[repr(C)] -pub union __sigaction_handler_union { - /* Used if SA_SIGINFO is not set. */ - sa_handler: __sighandler_t, - - /* Used if SA_SIGINFO is set. */ - sa_sigaction: - Option ()>, -} - -#[derive(Copy, Clone)] -#[repr(C)] -pub struct sigaction { - pub __sigaction_handler: __sigaction_handler_union, - - /* Additional set of signals to be blocked. */ - pub sa_mask: sigset_t, - - /* Special flags. */ - pub sa_flags: libc::c_int, - - /* Restore handler. */ - // void (*sa_restorer) (void); - pub sa_restorer: Option ()>, -} - /* An integral type that can be modified atomically, without the possibility of a signal arriving in the middle of the operation. */ // typedef __sig_atomic_t sig_atomic_t; @@ -230,15 +86,6 @@ pub struct termios { c_ospeed: speed_t, /* output speed */ } -#[derive(Copy, Clone)] -#[repr(C)] -pub struct winsize { - ws_row: libc::c_ushort, - ws_col: libc::c_ushort, - ws_xpixel: libc::c_ushort, - ws_ypixel: libc::c_ushort, -} - extern "C" { fn memset(_: *mut libc::c_void, _: libc::c_int, _: libc::c_ulong) -> *mut libc::c_void; fn sigemptyset(__set: *mut sigset_t) -> libc::c_int; @@ -289,27 +136,11 @@ pub const VTIME: libc::c_int = 5 as libc::c_int; // #define VMIN 6 pub const VMIN: libc::c_int = 6 as libc::c_int; -// #define CLR(t, f) ((t) &= ~(f)) -#[macro_export] -macro_rules! CLR { - ($t:expr, $f:expr) => { - (($t) &= !($f)) - }; -} - -// #define SET(t, f) ((t) |= (f)) -#[macro_export] -macro_rules! SET { - ($t:expr, $f:expr) => { - (($t) |= ($f)) - }; -} - // #define ECHO 0000010 #[macro_export] macro_rules! ECHO { () => { - 0000010 + 0o000010 }; } @@ -317,7 +148,7 @@ macro_rules! ECHO { #[macro_export] macro_rules! ECHONL { () => { - 0000100 + 0o000100 }; } @@ -325,7 +156,7 @@ macro_rules! ECHONL { #[macro_export] macro_rules! ICRNL { () => { - 0000400 + 0o000400 }; } @@ -333,7 +164,7 @@ macro_rules! ICRNL { #[macro_export] macro_rules! IGNCR { () => { - 0000200 + 0o000200 }; } @@ -341,7 +172,7 @@ macro_rules! IGNCR { #[macro_export] macro_rules! INLCR { () => { - 0000100 + 0o000100 }; } @@ -349,7 +180,7 @@ macro_rules! INLCR { #[macro_export] macro_rules! IUCLC { () => { - 0001000 + 0o001000 }; } @@ -357,7 +188,7 @@ macro_rules! IUCLC { #[macro_export] macro_rules! IXON { () => { - 0002000 + 0o002000 }; } @@ -365,7 +196,7 @@ macro_rules! IXON { #[macro_export] macro_rules! OPOST { () => { - 0000001 + 0o000001 }; } @@ -373,7 +204,7 @@ macro_rules! OPOST { #[macro_export] macro_rules! ICANON { () => { - 0000002 + 0o000002 }; } @@ -381,7 +212,7 @@ macro_rules! ICANON { #[macro_export] macro_rules! ISIG { () => { - 0000001 + 0o000001 }; } @@ -389,7 +220,7 @@ macro_rules! ISIG { #[macro_export] macro_rules! IEXTEN { () => { - 0100000 + 0o100000 }; } @@ -397,7 +228,7 @@ macro_rules! IEXTEN { #[macro_export] macro_rules! IGNPAR { () => { - 0000004 + 0o000004 }; } @@ -405,49 +236,49 @@ macro_rules! IGNPAR { #[macro_export] macro_rules! PARMRK { () => { - 0000010 + 0o000010 }; } // #define INPCK 0000020 #[macro_export] macro_rules! INPCK { () => { - 0000020 + 0o000020 }; } // #define ISTRIP 0000040 #[macro_export] macro_rules! ISTRIP { () => { - 0000040 + 0o000040 }; } // #define IXANY 0004000 #[macro_export] macro_rules! IXANY { () => { - 0004000 + 0o004000 }; } // #define IXOFF 0010000 #[macro_export] macro_rules! IXOFF { () => { - 0010000 + 0o010000 }; } // #define IMAXBEL 0020000 #[macro_export] macro_rules! IMAXBEL { () => { - 0020000 + 0o020000 }; } // #define IUTF8 0040000 #[macro_export] macro_rules! IUTF8 { () => { - 0040000 + 0o040000 }; } @@ -456,35 +287,35 @@ macro_rules! IUTF8 { #[macro_export] macro_rules! OLCUC { () => { - 0000002 + 0o000002 }; } // #define ONLCR 0000004 #[macro_export] macro_rules! ONLCR { () => { - 0000004 + 0o000004 }; } // #define OCRNL 0000010 #[macro_export] macro_rules! OCRNL { () => { - 0000010 + 0o000010 }; } // #define ONOCR 0000020 #[macro_export] macro_rules! ONOCR { () => { - 0000020 + 0o000020 }; } // #define ONLRET 0000040 #[macro_export] macro_rules! ONLRET { () => { - 0000040 + 0o000040 }; } @@ -492,28 +323,28 @@ macro_rules! ONLRET { #[macro_export] macro_rules! CS7 { () => { - 0000040 + 0o000040 }; } // #define CS8 0000060 #[macro_export] macro_rules! CS8 { () => { - 0000060 + 0o000060 }; } // #define PARENB 0000400 #[macro_export] macro_rules! PARENB { () => { - 0000400 + 0o000400 }; } // #define PARODD 0001000 #[macro_export] macro_rules! PARODD { () => { - 0001000 + 0o001000 }; } @@ -521,7 +352,7 @@ macro_rules! PARODD { #[macro_export] macro_rules! XCASE { () => { - 0000004 + 0o000004 }; } @@ -529,7 +360,7 @@ macro_rules! XCASE { #[macro_export] macro_rules! ECHOE { () => { - 0000020 + 0o000020 }; } @@ -537,7 +368,7 @@ macro_rules! ECHOE { #[macro_export] macro_rules! ECHOK { () => { - 0000040 + 0o000040 }; } @@ -545,7 +376,7 @@ macro_rules! ECHOK { #[macro_export] macro_rules! NOFLSH { () => { - 0000200 + 0o000200 }; } @@ -553,7 +384,7 @@ macro_rules! NOFLSH { #[macro_export] macro_rules! TOSTOP { () => { - 0000400 + 0o000400 }; } @@ -561,7 +392,7 @@ macro_rules! TOSTOP { #[macro_export] macro_rules! ECHOCTL { () => { - 0001000 + 0o001000 }; } @@ -569,7 +400,7 @@ macro_rules! ECHOCTL { #[macro_export] macro_rules! ECHOKE { () => { - 0004000 + 0o004000 }; } @@ -577,7 +408,7 @@ macro_rules! ECHOKE { #[macro_export] macro_rules! PENDIN { () => { - 0040000 + 0o040000 }; } @@ -593,7 +424,7 @@ macro_rules! B0 { #[macro_export] macro_rules! B38400 { () => { - 0000017 + 0o000017 }; } @@ -682,14 +513,14 @@ unsafe extern "C" fn tcsetattr_nobg( tp: *mut termios, ) -> libc::c_int { let mut sa: sigaction = sigaction { - __sigaction_handler: __sigaction_handler_union { sa_handler: None }, + __sigaction_handler: Signal_handler { sa_handler: None }, sa_mask: sigset_t { __val: [0; 16] }, sa_flags: 0, sa_restorer: None, }; let mut osa: sigaction = sigaction { - __sigaction_handler: __sigaction_handler_union { sa_handler: None }, + __sigaction_handler: Signal_handler { sa_handler: None }, sa_mask: sigset_t { __val: [0; 16] }, sa_flags: 0, sa_restorer: None, @@ -736,7 +567,7 @@ unsafe extern "C" fn tcsetattr_nobg( // #[named] #[no_mangle] unsafe extern "C" fn sudo_term_restore_v1(fd: libc::c_int, flush: bool) -> bool { - debug_decl!(stdext::function_name!().as_ptr(), SUDO_DEBUG_UTIL); + debug_decl!(SUDO_DEBUG_UTIL); if changed != 0 { let mut flags: libc::c_int = { @@ -761,7 +592,7 @@ unsafe extern "C" fn sudo_term_restore_v1(fd: libc::c_int, flush: bool) -> bool */ #[no_mangle] unsafe extern "C" fn sudo_term_noecho_v1(fd: libc::c_int) -> bool { - debug_decl!(stdext::function_name!().as_ptr(), SUDO_DEBUG_UTIL); + debug_decl!(SUDO_DEBUG_UTIL); if changed == 0 && tcgetattr(fd, &mut oterm) != 0 { debug_return_bool!(false); @@ -795,9 +626,9 @@ unsafe extern "C" fn sudo_term_raw_v1(fd: libc::c_int, isig: libc::c_int) -> boo c_ispeed: 0, c_ospeed: 0, }; - debug_decl!(stdext::function_name!().as_ptr(), SUDO_DEBUG_UTIL); + debug_decl!(SUDO_DEBUG_UTIL); - if changed != 0 && tcgetattr(fd, &mut oterm) != 0 { + if changed == 0 && tcgetattr(fd, &mut oterm) != 0 { debug_return_bool!(false); } memcpy( @@ -831,9 +662,9 @@ unsafe extern "C" fn sudo_term_raw_v1(fd: libc::c_int, isig: libc::c_int) -> boo */ #[no_mangle] unsafe extern "C" fn sudo_term_cbreak_v1(fd: libc::c_int) -> bool { - debug_decl!(stdext::function_name!().as_ptr(), SUDO_DEBUG_UTIL); + debug_decl!(SUDO_DEBUG_UTIL); - if changed != 0 && tcgetattr(fd, &mut oterm) != 0 { + if changed == 0 && tcgetattr(fd, &mut oterm) != 0 { debug_return_bool!(false); } @@ -897,7 +728,7 @@ unsafe extern "C" fn sudo_term_copy_v1(src: libc::c_int, dst: libc::c_int) -> bo ws_ypixel: 0, }; let mut speed: speed_t = 0 as speed_t; - debug_decl!(stdext::function_name!().as_ptr(), SUDO_DEBUG_UTIL); + debug_decl!(SUDO_DEBUG_UTIL); if tcgetattr(src, &mut tt_src) != 0 || tcgetattr(dst, &mut tt_dst) != 0 { debug_return_bool!(false); diff --git a/lib/util/src/ttyname_dev.rs b/lib/util/src/ttyname_dev.rs index da85da5..c7b767b 100644 --- a/lib/util/src/ttyname_dev.rs +++ b/lib/util/src/ttyname_dev.rs @@ -16,35 +16,18 @@ unused_variables )] -use crate::sudo_debug::sudo_debug_enter_v1; -use crate::sudo_debug::sudo_debug_exit_str_v1; -// use crate::sudo_debug::sudo_debug_printf2_v1; -use crate::sudo_debug_macro::SUDO_DEBUG_DEBUG; -use crate::sudo_debug_macro::SUDO_DEBUG_ERRNO; -use crate::sudo_debug_macro::SUDO_DEBUG_ERROR; -use crate::sudo_debug_macro::SUDO_DEBUG_INFO; -use crate::sudo_debug_macro::SUDO_DEBUG_LINENO; -use crate::sudo_debug_macro::SUDO_DEBUG_UTIL; - -pub type __dev_t = libc::c_ulong; -pub type __uid_t = libc::c_uint; -pub type __gid_t = libc::c_uint; -pub type __ino_t = libc::c_ulong; -pub type __mode_t = libc::c_uint; -#[cfg(target_arch = "x86_64")] -pub type __nlink_t = libc::c_ulong; -#[cfg(not(target_arch = "x86_64"))] -pub type __nlink_t = libc::c_uint; -pub type __off_t = libc::c_long; -pub type __time_t = libc::c_long; -#[cfg(target_arch = "x86_64")] -pub type __blksize_t = libc::c_long; -#[cfg(not(target_arch = "x86_64"))] -pub type __blksize_t = libc::c_int; -pub type __blkcnt_t = libc::c_long; -pub type __syscall_slong_t = libc::c_long; -pub type dev_t = __dev_t; -pub type size_t = libc::c_ulong; +use crate::common::*; + +extern "C" { + fn sudo_debug_printf2_v1( + func: *const libc::c_char, + file: *const libc::c_char, + line: libc::c_int, + level: libc::c_int, + fmt: *const libc::c_char, + _: ... + ); +} // #define PATH_MAX 4096 /* # chars in a path name including nul */ pub const PATH_MAX: usize = 4096; @@ -52,23 +35,10 @@ pub const PATH_MAX: usize = 4096; // #define ENOMEM 12 /* Out of memory */ pub const ENOMEM: libc::c_int = 12; -// #define ERANGE 34 /* Math result not representable */ -pub const ERANGE: libc::c_int = 34; - -// #define ENOENT 2 /* No such file or directory */ -pub const ENOENT: libc::c_int = 2; - pub const DT_CHR: libc::c_int = 2; pub const DT_LNK: libc::c_int = 10; pub const DT_UNKNOWN: libc::c_int = 0; -// #define _PATH_DEV "/dev/" -macro_rules! _PATH_DEV { - () => { - b"/dev/\0" as *const u8 as *const libc::c_char - }; -} - // console macro_rules! _PATH_DEV_CONSOLE { () => { @@ -104,16 +74,6 @@ macro_rules! _PATH_DEV_STDERR { }; } -// #define S_ISCHR(mode) __S_ISTYPE((mode), __S_IFCHR) -// #define __S_ISTYPE(mode, mask) (((mode) & __S_IFMT) == (mask)) -// #define __S_IFMT 0170000 /* These bits determine file type. */ -// #define __S_IFCHR 0020000 /* Character device. */ -macro_rules! __S_IFMT { - () => { - 0o170000 - }; -} - macro_rules! __S_IFCHR { () => { 0o020000 @@ -122,7 +82,7 @@ macro_rules! __S_IFCHR { macro_rules! __S_ISTYPE { ($mode:expr, $mask:expr) => { - ((($mode) & __S_IFMT!()) == ($mask)) + ((($mode) & _S_IFMT!()) == ($mask)) }; } @@ -132,39 +92,12 @@ macro_rules! S_ISCHR { }; } -// # define S_IWOTH (S_IWGRP >> 3) /* Write by others. */ -// # define S_IWGRP (S_IWUSR >> 3) /* Write by group. */ -// # define S_IWUSR __S_IWRITE /* Write by owner. */ -// #define __S_IWRITE 0200 /* Write by owner. */ -macro_rules! __S_IWRITE { - () => { - 0200 - }; -} - -macro_rules! S_IWUSR { - () => { - __S_IWRITE!() - }; -} - -macro_rules! S_IWGRP { - () => { - (S_IWUSR!() >> 3) - }; -} - -macro_rules! S_IWOTH { - () => { - (S_IWGRP!() >> 3) - }; -} - #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct __dirstream { _unused: [u8; 0], } +pub type DIR = __dirstream; extern "C" { fn sudo_conf_devsearch_path_v1() -> *const libc::c_char; @@ -196,66 +129,18 @@ extern "C" { fn opendir(__name: *const libc::c_char) -> *mut DIR; fn dirfd(__dirp: *mut DIR) -> libc::c_int; fn readdir(__dirp: *mut DIR) -> *mut dirent; + /* fn sudo_debug_printf2_v1( - func: *const libc::c_char, - file: *const libc::c_char, - lineno: libc::c_int, - level: libc::c_int, - fmt: *const libc::c_char, - _: ... - ); -} - -#[derive(Copy, Clone)] -#[repr(C)] -pub struct timespec { - pub tv_sec: __time_t, - pub tv_nsec: __syscall_slong_t, -} - -#[derive(Copy, Clone)] -#[repr(C)] -pub struct stat { - pub st_dev: __dev_t, - pub st_ino: __ino_t, - #[cfg(target_arch = "x86_64")] - pub st_nlink: __nlink_t, - pub st_mode: __mode_t, - #[cfg(not(target_arch = "x86_64"))] - pub st_nlink: __nlink_t, - pub st_uid: __uid_t, - pub st_gid: __gid_t, - #[cfg(target_arch = "x86_64")] - pub __pad0: libc::c_int, - pub st_rdev: __dev_t, - #[cfg(not(target_arch = "x86_64"))] - pub __pad1: __dev_t, - pub st_size: __off_t, - pub st_blksize: __blksize_t, - #[cfg(not(target_arch = "x86_64"))] - pub __pad2: libc::c_int, - pub st_blocks: __blkcnt_t, - pub st_atim: timespec, - pub st_mtim: timespec, - pub st_ctim: timespec, - #[cfg(target_arch = "x86_64")] - pub __glibc_reserved: [__syscall_slong_t; 3], - #[cfg(not(target_arch = "x86_64"))] - pub __glibc_reserved: [libc::c_int; 2], -} - -#[derive(Copy, Clone)] -#[repr(C)] -pub struct dirent { - pub d_ino: __ino_t, - pub d_off: __off_t, - pub d_reclen: libc::c_ushort, - pub d_type: libc::c_uchar, - pub d_name: [libc::c_char; 256], + func: *const libc::c_char, + file: *const libc::c_char, + lineno: libc::c_int, + level: libc::c_int, + fmt: *const libc::c_char, + _: ... + ); + */ } -pub type DIR = __dirstream; - /* * Device nodes to ignore. */ @@ -268,21 +153,14 @@ static mut ignore_devs: [*const libc::c_char; 4] = [ #[inline] unsafe extern "C" fn fstat(mut __fd: libc::c_int, mut __statbuf: *mut stat) -> libc::c_int { - #[cfg(target_arch = "x86_64")] - return __fxstat(1 as libc::c_int, __fd, __statbuf); - #[cfg(not(target_arch = "x86_64"))] - return __fxstat(0 as libc::c_int, __fd, __statbuf); + return __fxstat(xstat_flag as libc::c_int, __fd, __statbuf); } - #[inline] unsafe extern "C" fn stat( mut __path: *const libc::c_char, mut __statbuf: *mut stat, ) -> libc::c_int { - #[cfg(target_arch = "x86_64")] - return __xstat(1 as libc::c_int, __path, __statbuf); - #[cfg(not(target_arch = "x86_64"))] - return __xstat(0 as libc::c_int, __path, __statbuf); + return __xstat(xstat_flag as libc::c_int, __path, __statbuf); } #[inline] @@ -313,58 +191,23 @@ unsafe extern "C" fn sudo_ttyname_scan( let mut pathbuf: [libc::c_char; PATH_MAX] = [0; PATH_MAX]; let mut ret: *mut libc::c_char = 0 as *mut libc::c_char; let mut dp: *mut dirent = 0 as *mut dirent; - - let mut sb: stat = stat { - st_dev: 0, - st_ino: 0, - #[cfg(target_arch = "x86_64")] - st_nlink: 0, - st_mode: 0, - #[cfg(not(target_arch = "x86_64"))] - st_nlink: 0, - st_uid: 0, - st_gid: 0, - #[cfg(target_arch = "x86_64")] - __pad0: 0, - st_rdev: 0, - #[cfg(not(target_arch = "x86_64"))] - __pad1: 0, - st_size: 0, - st_blksize: 0, - #[cfg(not(target_arch = "x86_64"))] - __pad2: 0, - st_blocks: 0, - st_atim: timespec { - tv_sec: 0, - tv_nsec: 0, - }, - st_mtim: timespec { - tv_sec: 0, - tv_nsec: 0, - }, - st_ctim: timespec { - tv_sec: 0, - tv_nsec: 0, - }, - #[cfg(target_arch = "x86_64")] - __glibc_reserved: [0; 3], - #[cfg(not(target_arch = "x86_64"))] - __glibc_reserved: [0; 2], - }; - + let mut sb: stat = sb_all_arch; let mut i: libc::c_int = 0 as libc::c_int; let mut d: *mut DIR = 0 as *mut DIR; - debug_decl!(stdext::function_name!().as_ptr(), SUDO_DEBUG_UTIL); + + debug_decl!(SUDO_DEBUG_UTIL); 'done: loop { if *dir.offset(0 as isize) as libc::c_int == '\u{0}' as i32 { *__errno_location() = ENOENT; break 'done; } + d = opendir(dir); if d.is_null() { break 'done; } + if fstat(dirfd(d), &mut sb) == -1 { sudo_debug_printf!( SUDO_DEBUG_ERROR | SUDO_DEBUG_LINENO, @@ -382,71 +225,45 @@ unsafe extern "C" fn sudo_ttyname_scan( *__errno_location() = ENOENT; break 'done; } + sudo_debug_printf!( SUDO_DEBUG_INFO | SUDO_DEBUG_LINENO, b"scanning for dev %u in %s\0" as *const u8 as *const libc::c_char, rdev as libc::c_uint, dir ); + sdlen = strlen(dir); while sdlen > 0 && dir.offset((sdlen - 1) as isize) as libc::c_int == '/' as i32 { sdlen -= 1; } + if (sdlen + 1) >= ::std::mem::size_of::<[libc::c_char; PATH_MAX]>() as libc::c_ulong { *__errno_location() = ERANGE; break 'done; } + memcpy( pathbuf.as_mut_ptr() as *mut libc::c_void, dir as *const libc::c_void, sdlen, ); - sdlen += 1; - pathbuf[sdlen as usize] = '/' as i32 as libc::c_char; - dp = readdir(d); - while !dp.is_null() { - let mut sb: stat = stat { - st_dev: 0, - st_ino: 0, - #[cfg(target_arch = "x86_64")] - st_nlink: 0, - st_mode: 0, - #[cfg(not(target_arch = "x86_64"))] - st_nlink: 0, - st_uid: 0, - st_gid: 0, - #[cfg(target_arch = "x86_64")] - __pad0: 0, - st_rdev: 0, - #[cfg(not(target_arch = "x86_64"))] - __pad1: 0, - st_size: 0, - st_blksize: 0, - #[cfg(not(target_arch = "x86_64"))] - __pad2: 0, - st_blocks: 0, - st_atim: timespec { - tv_sec: 0, - tv_nsec: 0, - }, - st_mtim: timespec { - tv_sec: 0, - tv_nsec: 0, - }, - st_ctim: timespec { - tv_sec: 0, - tv_nsec: 0, - }, - #[cfg(target_arch = "x86_64")] - __glibc_reserved: [0; 3], - #[cfg(not(target_arch = "x86_64"))] - __glibc_reserved: [0; 2], - }; + let fresh0 = sdlen; + sdlen = sdlen.wrapping_add(1); + pathbuf[fresh0 as usize] = '/' as i32 as libc::c_char; + + loop { + dp = readdir(d); + if dp.is_null() { + break; + } + let mut sb: stat = sb_all_arch; /* Skip anything starting with "." */ if (*dp).d_name[0 as usize] as libc::c_int == '.' as i32 { continue; } + pathbuf[sdlen as usize] = '\u{0}' as i32 as libc::c_char; if sudo_strlcat( pathbuf.as_mut_ptr(), @@ -462,6 +279,7 @@ unsafe extern "C" fn sudo_ttyname_scan( ); continue; } + /* Ignore device nodes listed in ignore_devs[]. */ i = 0; while !ignore_devs[i as usize].is_null() { @@ -493,6 +311,7 @@ unsafe extern "C" fn sudo_ttyname_scan( continue; } } + if stat(pathbuf.as_mut_ptr(), &mut sb) == -1 { sudo_debug_printf!( SUDO_DEBUG_ERROR | SUDO_DEBUG_LINENO | SUDO_DEBUG_ERRNO, @@ -501,6 +320,7 @@ unsafe extern "C" fn sudo_ttyname_scan( ); continue; } + if S_ISCHR!(sb.st_mode) && sb.st_rdev == rdev { sudo_debug_printf!( SUDO_DEBUG_INFO | SUDO_DEBUG_LINENO, @@ -540,44 +360,9 @@ unsafe extern "C" fn sudo_dev_check( mut buf: *mut libc::c_char, mut buflen: size_t, ) -> *mut libc::c_char { - let mut sb: stat = stat { - st_dev: 0, - st_ino: 0, - #[cfg(target_arch = "x86_64")] - st_nlink: 0, - st_mode: 0, - #[cfg(not(target_arch = "x86_64"))] - st_nlink: 0, - st_uid: 0, - st_gid: 0, - #[cfg(target_arch = "x86_64")] - __pad0: 0, - st_rdev: 0, - #[cfg(not(target_arch = "x86_64"))] - __pad1: 0, - st_size: 0, - st_blksize: 0, - #[cfg(not(target_arch = "x86_64"))] - __pad2: 0, - st_blocks: 0, - st_atim: timespec { - tv_sec: 0, - tv_nsec: 0, - }, - st_mtim: timespec { - tv_sec: 0, - tv_nsec: 0, - }, - st_ctim: timespec { - tv_sec: 0, - tv_nsec: 0, - }, - #[cfg(target_arch = "x86_64")] - __glibc_reserved: [0; 3], - #[cfg(not(target_arch = "x86_64"))] - __glibc_reserved: [0; 2], - }; - debug_decl!(stdext::function_name!().as_ptr(), SUDO_DEBUG_UTIL); + let mut sb: stat = sb_all_arch; + debug_decl!(SUDO_DEBUG_UTIL); + if stat(devname, &mut sb) == 0 { if S_ISCHR!(sb.st_mode) && sb.st_rdev == rdev { sudo_debug_printf!( @@ -586,6 +371,7 @@ unsafe extern "C" fn sudo_dev_check( rdev, devname ); + if sudo_strlcpy(buf, devname, buflen) < buflen { debug_return_str!(buf); } @@ -599,6 +385,7 @@ unsafe extern "C" fn sudo_dev_check( *__errno_location() = ERANGE; } // if S_ISCHR( } //if stat(devname + sudo_debug_printf!( SUDO_DEBUG_INFO | SUDO_DEBUG_LINENO, b"comparing dev %u to %s: no\0" as *const u8 as *const libc::c_char, @@ -627,7 +414,7 @@ pub unsafe extern "C" fn sudo_ttyname_dev_v1( let mut ep: *const libc::c_char = 0 as *const libc::c_char; let mut len: size_t = 0 as size_t; - debug_decl!(stdext::function_name!().as_ptr(), SUDO_DEBUG_UTIL); + debug_decl!(SUDO_DEBUG_UTIL); /* * First, check /dev/console. @@ -639,6 +426,7 @@ pub unsafe extern "C" fn sudo_ttyname_dev_v1( */ devsearch = sudo_conf_devsearch_path_v1(); devsearch_end = devsearch.offset(strlen(devsearch) as isize); + cp = sudo_strsplit_v1( devsearch, devsearch_end, @@ -662,12 +450,14 @@ pub unsafe extern "C" fn sudo_ttyname_dev_v1( ); continue; } // if len >= + memcpy( path.as_mut_ptr() as *mut libc::c_void, cp as *const libc::c_void, len, ); path[len as usize] = '\u{0}' as i32 as libc::c_char; + if strcmp(path.as_mut_ptr(), _PATH_DEV_PTS!()) == 0 { /* Special case /dev/pts */ len = snprintf( @@ -677,6 +467,7 @@ pub unsafe extern "C" fn sudo_ttyname_dev_v1( _PATH_DEV!(), gnu_dev_minor(rdev), ) as size_t; + if len > ::std::mem::size_of::<[libc::c_char; PATH_MAX]>() as libc::c_ulong { sudo_debug_printf!( SUDO_DEBUG_ERROR | SUDO_DEBUG_LINENO, @@ -705,6 +496,7 @@ pub unsafe extern "C" fn sudo_ttyname_dev_v1( break; } } + cp = sudo_strsplit_v1( 0 as *const libc::c_char, devsearch_end, @@ -713,6 +505,5 @@ pub unsafe extern "C" fn sudo_ttyname_dev_v1( ); } // while !cp.is_null() } // ret.is_null() - debug_return_str!(ret as *mut libc::c_char) } diff --git a/lib/util/src/ttysize.rs b/lib/util/src/ttysize.rs index 0e13004..359f7a9 100644 --- a/lib/util/src/ttysize.rs +++ b/lib/util/src/ttysize.rs @@ -14,36 +14,7 @@ unused_mut )] -use crate::sudo_debug::sudo_debug_enter_v1; -use crate::sudo_debug::sudo_debug_exit_int_v1; -use crate::sudo_debug::sudo_debug_exit_v1; -use crate::sudo_debug_macro::SUDO_DEBUG_UTIL; - -/* Standard file descriptors. */ -// #define STDERR_FILENO 2 /* Standard error output. */ -#[macro_export] -macro_rules! STDERR_FILENO { - () => { - 2 - }; -} - -// #define TIOCGWINSZ 0x5413 -#[macro_export] -macro_rules! TIOCGWINSZ { - () => { - 0x5413 - }; -} - -// #define __INT_MAX__ 2147483647 -// #define INT_MAX __INT_MAX__ -#[macro_export] -macro_rules! INT_MAX { - () => { - 2147483647 - }; -} +use crate::common::*; extern "C" { fn ioctl(fd: libc::c_int, __request: libc::c_ulong, ...) -> libc::c_int; @@ -57,15 +28,6 @@ extern "C" { } -#[derive(Copy, Clone)] -#[repr(C)] -pub struct winsize { - pub ws_row: libc::c_ushort, - pub ws_col: libc::c_ushort, - pub ws_xpixel: libc::c_ushort, - pub ws_ypixel: libc::c_ushort, -} - #[no_mangle] pub unsafe extern "C" fn get_ttysize_ioctl( rowp: *mut libc::c_int, @@ -78,7 +40,7 @@ pub unsafe extern "C" fn get_ttysize_ioctl( ws_ypixel: 0, }; - debug_decl!(stdext::function_name!().as_ptr(), SUDO_DEBUG_UTIL); + debug_decl!(SUDO_DEBUG_UTIL); if (ioctl(STDERR_FILENO!(), TIOCGWINSZ!(), &wsize) == 0) && wsize.ws_row != 0 @@ -96,7 +58,7 @@ pub unsafe extern "C" fn sudo_get_ttysize_v1( mut rowp: *mut libc::c_int, mut colp: *mut libc::c_int, ) { - debug_decl!(stdext::function_name!().as_ptr(), SUDO_DEBUG_UTIL); + debug_decl!(SUDO_DEBUG_UTIL); if get_ttysize_ioctl(rowp, colp) == -(1 as libc::c_int) { let mut p: *mut libc::c_char = 0 as *mut libc::c_char; -- 2.33.0