codex-rs/linux-sandbox/src/linux_run_main.rs (43 lines):
	- line 203: let result = unsafe {
	- line 243: let command_pid = unsafe { libc::fork() };
	- line 259: let reaped_pid = unsafe { libc::waitpid(-1, &mut status, 0) };
	- line 576: let parent_pid = unsafe { libc::getpid() };
	- line 577: let pid = unsafe { libc::fork() };
	- line 586: let setpgid_res = unsafe { libc::setpgid(0, 0) };
	- line 661: let fd = unsafe { libc::inotify_init1(libc::IN_NONBLOCK | libc::IN_CLOEXEC) };
	- line 681: let watch = unsafe { libc::inotify_add_watch(fd, parent_cstr.as_ptr(), mask) };
	- line 688: unsafe {
	- line 707: let res = unsafe { libc::poll(&mut poll_fd, 1, 10) };
	- line 726: let read = unsafe { libc::read(self.fd, buf.as_mut_ptr().cast(), buf.len()) };
	- line 744: unsafe {
	- line 755: if unsafe { libc::pipe2(pipe.as_mut_ptr(), libc::O_CLOEXEC) } < 0 {
	- line 764: unsafe {
	- line 774: let read = unsafe { libc::read(read_fd, byte.as_mut_ptr().cast(), byte.len()) };
	- line 783: unsafe {
	- line 790: unsafe {
	- line 801: unsafe {
	- line 817: let mut blocked: libc::sigset_t = unsafe { std::mem::zeroed() };
	- line 818: let mut previous: libc::sigset_t = unsafe { std::mem::zeroed() };
	- line 819: unsafe {
	- line 834: unsafe {
	- line 847: let res = unsafe { libc::prctl(libc::PR_SET_PDEATHSIG, libc::SIGTERM) };
	- line 852: if unsafe { libc::getppid() } != parent_pid {
	- line 853: unsafe {
	- line 864: unsafe {
	- line 878: let mut action: libc::sigaction = unsafe { std::mem::zeroed() };
	- line 879: let mut previous_action: libc::sigaction = unsafe { std::mem::zeroed() };
	- line 881: unsafe {
	- line 910: unsafe {
	- line 918: unsafe {
	- line 930: let wait_res = unsafe { libc::waitpid(pid, &mut status as *mut libc::c_int, 0) };
	- line 1282: let result = unsafe { libc::kill(pid, 0) };
	- line 1311: if unsafe { libc::flock(lock_file.as_raw_fd(), libc::LOCK_EX) } < 0 {
	- line 1319: if unsafe { libc::flock(lock_file.as_raw_fd(), libc::LOCK_UN) } < 0 {
	- line 1338: let effective_uid = unsafe { libc::geteuid() };
	- line 1377: unsafe {
	- line 1423: let pipe_res = unsafe { libc::pipe2(pipe_fds.as_mut_ptr(), libc::O_CLOEXEC) };
	- line 1431: let pid = unsafe { libc::fork() };
	- line 1441: unsafe {
	- line 1459: let mut read_file = unsafe { File::from_raw_fd(read_fd) };
	- line 1486: let close_res = unsafe { libc::close(fd) };
	- line 1569: unsafe {


codex-rs/http-client/src/outbound_proxy/macos.rs (37 lines):
	- line 47: retain: Option<unsafe extern "C" fn(*mut c_void) -> *mut c_void>,
	- line 48: release: Option<unsafe extern "C" fn(*mut c_void)>,
	- line 49: copy_description: Option<unsafe extern "C" fn(*mut c_void) -> CFStringRef>,
	- line 53: unsafe extern "C" fn(*mut c_void, CFArrayRef, CFErrorRef);
	- line 56: unsafe extern "C" {
	- line 120: let proxy_type = cf_string_value(&proxy, unsafe { kCFProxyTypeKey })?;
	- line 121: if cf_string_equals(&proxy_type, unsafe { kCFProxyTypeAutoConfigurationURL })
	- line 122: || cf_string_equals(&proxy_type, unsafe {
	- line 127: } else if cf_string_equals(&proxy_type, unsafe { kCFProxyTypeHTTP })
	- line 128: || cf_string_equals(&proxy_type, unsafe { kCFProxyTypeHTTPS })
	- line 132: cf_string_equals(&proxy_type, unsafe { kCFProxyTypeNone })
	- line 148: let proxies = unsafe {
	- line 157: Some(unsafe { ProxyArray::wrap_under_create_rule(proxies) })
	- line 199: let Some(proxy_type) = cf_string_value(proxy, unsafe { kCFProxyTypeKey }) else {
	- line 203: if cf_string_equals(&proxy_type, unsafe { kCFProxyTypeNone }) {
	- line 207: if cf_string_equals(&proxy_type, unsafe { kCFProxyTypeHTTP }) {
	- line 211: if cf_string_equals(&proxy_type, unsafe { kCFProxyTypeHTTPS }) {
	- line 217: if cf_string_equals(&proxy_type, unsafe { kCFProxyTypeSOCKS }) {
	- line 221: if cf_string_equals(&proxy_type, unsafe { kCFProxyTypeAutoConfigurationURL }) {
	- line 222: let Some(pac_url) = cf_url_value(proxy, unsafe { kCFProxyAutoConfigurationURLKey }) else {
	- line 228: if cf_string_equals(&proxy_type, unsafe {
	- line 232: cf_string_value(proxy, unsafe { kCFProxyAutoConfigurationJavaScriptKey })
	- line 237: execute_pac(|callback, context| unsafe {
	- line 277: execute_pac(|callback, context| unsafe {
	- line 307: let source = unsafe { CFRunLoopSource::wrap_under_create_rule(source) };
	- line 309: let mode = unsafe { kCFRunLoopDefaultMode };
	- line 318: unsafe { CFRunLoopSourceInvalidate(source.as_concrete_TypeRef()) };
	- line 326: unsafe extern "C" fn pac_result_callback(
	- line 331: let state = unsafe { &mut *client.cast::<PacRunLoopState>() };
	- line 335: Some(Ok(unsafe { ProxyArray::wrap_under_get_rule(proxies) }))
	- line 345: let Some(host) = cf_string_value(proxy, unsafe { kCFProxyHostNameKey })
	- line 353: let url = match cf_i32_value(proxy, unsafe { kCFProxyPortNumberKey }) {
	- line 383: if unsafe { CFGetTypeID(value.as_CFTypeRef()) == CFURLGetTypeID() } {
	- line 384: Some(unsafe { CFURL::wrap_under_get_rule(value.as_CFTypeRef() as CFURLRef) })
	- line 394: unsafe { CFEqual(value.as_CFTypeRef(), expected as CFTypeRef) != 0 }
	- line 399: let url = unsafe {
	- line 409: Some(unsafe { CFURL::wrap_under_create_rule(url) })


codex-rs/windows-sandbox-rs/src/token.rs (23 lines):
	- line 56: unsafe fn set_default_dacl(h_token: HANDLE, sids: &[*mut c_void]) -> Result<()> {
	- line 109: pub unsafe fn world_sid() -> Result<Vec<u8>> {
	- line 132: pub unsafe fn convert_string_sid_to_sid(s: &str) -> Option<*mut c_void> {
	- line 134: unsafe extern "system" {
	- line 138: let ok = unsafe { ConvertStringSidToSidW(to_wide(s).as_ptr(), &mut psid) };
	- line 149: let psid = unsafe { convert_string_sid_to_sid(sid) }
	- line 162: unsafe {
	- line 171: pub unsafe fn get_current_token_for_restriction() -> Result<HANDLE> {
	- line 180: unsafe extern "system" {
	- line 187: let ok = unsafe { OpenProcessToken(GetCurrentProcess(), desired, &mut h) };
	- line 194: pub unsafe fn get_logon_sid_bytes(h_token: HANDLE) -> Result<Vec<u8>> {
	- line 195: unsafe fn scan_token_groups_for_logon(h: HANDLE) -> Option<Vec<u8>> {
	- line 215: let after_count = unsafe { buf.as_ptr().add(std::mem::size_of::<u32>()) } as usize;
	- line 279: pub(crate) unsafe fn get_user_sid_bytes(h_token: HANDLE) -> Result<Vec<u8>> {
	- line 319: unsafe fn enable_single_privilege(h_token: HANDLE, name: &str) -> Result<()> {
	- line 352: pub unsafe fn create_readonly_token_with_cap(
	- line 365: pub unsafe fn create_readonly_token_with_cap_from(
	- line 377: pub unsafe fn create_workspace_write_token_with_caps_from(
	- line 392: pub unsafe fn create_workspace_write_token_with_caps_and_user_from(
	- line 408: pub unsafe fn create_readonly_token_with_caps_from(
	- line 423: pub unsafe fn create_readonly_token_with_caps_and_user_from(
	- line 435: unsafe fn create_token_with_caps_user_and_additional_restrictions_from(
	- line 448: unsafe fn create_token_with_caps_from(


codex-rs/windows-sandbox-rs/src/elevated/runner_client.rs (22 lines):
	- line 185: let thread_wait = unsafe { WaitForSingleObject(thread_handle, 0) };
	- line 213: let current_process = unsafe { GetCurrentProcess() };
	- line 215: let duplicate_ok = unsafe {
	- line 229: unsafe { GetLastError() }
	- line 264: let cancel_ok = unsafe { CancelSynchronousIo(thread_handle) };
	- line 266: let err = unsafe { GetLastError() };
	- line 305: unsafe {
	- line 346: let mut si: STARTUPINFOW = unsafe { std::mem::zeroed() };
	- line 348: let mut pi: PROCESS_INFORMATION = unsafe { std::mem::zeroed() };
	- line 351: let previous_error_mode = unsafe { SetErrorMode(RUNNER_ERROR_MODE_FLAGS) };
	- line 353: let spawn_res = unsafe {
	- line 372: unsafe {
	- line 376: let err = unsafe { GetLastError() };
	- line 377: unsafe {
	- line 391: unsafe {
	- line 398: unsafe {
	- line 415: pipe_write: unsafe { File::from_raw_handle(h_pipe_in as _) },
	- line 416: pipe_read: unsafe { File::from_raw_handle(h_pipe_out as _) },
	- line 427: unsafe {
	- line 437: unsafe {
	- line 457: let ok = unsafe {
	- line 468: let err = unsafe { GetLastError() } as i32;


codex-rs/utils/pty/src/tests.rs (21 lines):
	- line 268: let result = unsafe { libc::kill(pid, 0) };
	- line 447: let parent_sid = unsafe { libc::getsid(0) };
	- line 467: let child_sid = unsafe { libc::getsid(child_pid) };
	- line 958: let _ = unsafe { libc::kill(child_pid, libc::SIGKILL) };
	- line 1252: unsafe { libc::waitpid(child_pid, std::ptr::null_mut(), libc::WNOHANG) };
	- line 1313: let _ = unsafe { libc::kill(bg_pid, libc::SIGKILL) };
	- line 1332: let result = unsafe { libc::pipe(fds.as_mut_ptr()) };
	- line 1337: let mut read_end = unsafe { std::fs::File::from_raw_fd(fds[0]) };
	- line 1338: let write_end = unsafe { std::fs::File::from_raw_fd(fds[1]) };
	- line 1385: let result = unsafe { libc::pipe(fds.as_mut_ptr()) };
	- line 1390: let read_end = unsafe { std::fs::File::from_raw_fd(fds[0]) };
	- line 1391: let preserved_fd = unsafe { std::fs::File::from_raw_fd(fds[1]) };
	- line 1456: let result = unsafe { libc::pipe(fds.as_mut_ptr()) };
	- line 1461: let read_end = unsafe { std::fs::File::from_raw_fd(fds[0]) };
	- line 1462: let write_end = unsafe { std::fs::File::from_raw_fd(fds[1]) };
	- line 1504: let result = unsafe { libc::pipe(fds.as_mut_ptr()) };
	- line 1509: let read_end = unsafe { std::fs::File::from_raw_fd(fds[0]) };
	- line 1510: let write_end = unsafe { std::fs::File::from_raw_fd(fds[1]) };
	- line 1570: let result = unsafe { libc::pipe(fds.as_mut_ptr()) };
	- line 1575: let mut read_end = unsafe { std::fs::File::from_raw_fd(fds[0]) };
	- line 1576: let write_end = unsafe { std::fs::File::from_raw_fd(fds[1]) };


codex-rs/windows-sandbox-rs/src/acl.rs (20 lines):
	- line 71: pub unsafe fn fetch_dacl_handle(path: &Path) -> Result<(*mut ACL, *mut c_void)> {
	- line 110: pub unsafe fn dacl_mask_allows(
	- line 131: unsafe fn dacl_mask_allows_with_scope(
	- line 222: unsafe {
	- line 232: pub unsafe fn dacl_has_write_allow_for_sid(p_dacl: *mut ACL, psid: *mut c_void) -> bool {
	- line 273: pub unsafe fn dacl_has_write_deny_for_sid(p_dacl: *mut ACL, psid: *mut c_void) -> bool {
	- line 318: pub unsafe fn dacl_has_read_deny_for_sid(p_dacl: *mut ACL, psid: *mut c_void) -> bool {
	- line 362: unsafe fn dacl_allow_mask_needs_refresh(
	- line 380: unsafe {
	- line 392: unsafe fn ensure_allow_mask_aces_with_inheritance_impl(
	- line 469: pub unsafe fn ensure_allow_mask_aces_with_inheritance(
	- line 489: pub unsafe fn ensure_allow_mask_aces(
	- line 507: pub unsafe fn ensure_allow_write_aces(path: &Path, sids: &[*mut c_void]) -> Result<bool> {
	- line 521: pub unsafe fn add_allow_ace(path: &Path, psid: *mut c_void) -> Result<bool> {
	- line 587: pub unsafe fn add_deny_write_ace(path: &Path, psid: *mut c_void) -> Result<bool> {
	- line 614: unsafe fn already_present(self, p_dacl: *mut ACL, psid: *mut c_void) -> bool {
	- line 622: unsafe fn add_deny_ace(path: &Path, psid: *mut c_void, kind: DenyAceKind) -> Result<bool> {
	- line 695: pub unsafe fn add_deny_read_ace(path: &Path, psid: *mut c_void) -> Result<bool> {
	- line 703: pub unsafe fn revoke_ace(path: &Path, psid: *mut c_void) {
	- line 759: pub unsafe fn allow_null_device(psid: *mut c_void) {


codex-rs/tui/src/ide_context/windows_pipe.rs (19 lines):
	- line 65: let handle = unsafe {
	- line 102: let result = unsafe {
	- line 124: let result = unsafe {
	- line 149: let event = unsafe { CreateEventW(ptr::null(), TRUE, FALSE, ptr::null()) };
	- line 154: let mut overlapped = unsafe { std::mem::zeroed::<OVERLAPPED>() };
	- line 180: match unsafe { WaitForSingleObject(self.event.raw(), remaining_timeout_ms(deadline)) } {
	- line 193: let result = unsafe {
	- line 204: let cancel_result = unsafe { CancelIoEx(handle, self.as_mut_ptr()) };
	- line 214: unsafe {
	- line 221: unsafe {
	- line 239: unsafe {
	- line 263: unsafe { std::ptr::read_unaligned(self.buffer.as_ptr() as *const TOKEN_USER) };
	- line 270: let result = unsafe { GetNamedPipeServerProcessId(pipe_handle, &mut server_process_id) };
	- line 276: unsafe { OpenProcess(PROCESS_QUERY_LIMITED_INFORMATION, FALSE, server_process_id) };
	- line 282: let current_token = open_process_token(unsafe { GetCurrentProcess() })?;
	- line 286: if unsafe { EqualSid(server_user.sid()?, current_user.sid()?) } == 0 {
	- line 298: let result = unsafe { OpenProcessToken(process, TOKEN_QUERY, &mut token) };
	- line 308: unsafe {
	- line 316: let result = unsafe {


codex-rs/shell-escalation/src/unix/socket.rs (18 lines):
	- line 27: unsafe { std::slice::from_raw_parts(buf.as_ptr().cast(), buf.len()) }
	- line 31: unsafe { &*(buf as *const [MaybeUninit<T>; N] as *const [T; N]) }
	- line 35: unsafe {
	- line 45: unsafe { libc::CMSG_SPACE((count * size_of::<RawFd>()) as _) as usize }
	- line 51: let mut hdr: libc::msghdr = unsafe { std::mem::zeroed() };
	- line 56: let mut cmsg = unsafe { libc::CMSG_FIRSTHDR(&hdr) as *const libc::cmsghdr };
	- line 58: let level = unsafe { (*cmsg).cmsg_level };
	- line 59: let ty = unsafe { (*cmsg).cmsg_type };
	- line 61: let data_ptr = unsafe { libc::CMSG_DATA(cmsg).cast::<RawFd>() };
	- line 66: let cmsg_data_len = usize::try_from(unsafe { (*cmsg).cmsg_len })
	- line 68: - unsafe { libc::CMSG_LEN(0) as usize };
	- line 72: let fd = unsafe { data_ptr.add(i).read() };
	- line 73: fds.push(unsafe { OwnedFd::from_raw_fd(fd) });
	- line 76: cmsg = unsafe { libc::CMSG_NXTHDR(&hdr, cmsg) };
	- line 220: unsafe {
	- line 378: pub unsafe fn from_raw_fd(fd: RawFd) -> std::io::Result<Self> {
	- line 379: Self::new(unsafe { Socket::from_raw_fd(fd) })
	- line 454: let fd_status = unsafe { libc::fcntl(received_fds[0].as_raw_fd(), libc::F_GETFD) };


codex-rs/tui/src/ide_context/ipc.rs (17 lines):
	- line 148: let uid = unsafe { libc::getuid() };
	- line 289: let fd = unsafe { libc::socket(libc::AF_UNIX, libc::SOCK_STREAM, 0) };
	- line 293: let fd = unsafe { OwnedFd::from_raw_fd(fd) };
	- line 297: let result = unsafe {
	- line 317: Ok(unsafe { std::os::unix::net::UnixStream::from_raw_fd(fd.into_raw_fd()) })
	- line 332: let mut addr = unsafe { std::mem::zeroed::<libc::sockaddr_un>() };
	- line 374: let flags = unsafe { libc::fcntl(fd, libc::F_GETFD) };
	- line 378: let result = unsafe { libc::fcntl(fd, libc::F_SETFD, flags | libc::FD_CLOEXEC) };
	- line 388: let flags = unsafe { libc::fcntl(fd, libc::F_GETFL) };
	- line 392: let result = unsafe { libc::fcntl(fd, libc::F_SETFL, flags | libc::O_NONBLOCK) };
	- line 422: let result = unsafe {
	- line 466: let result = unsafe { libc::poll(&mut poll_fd, 1, remaining_timeout_ms(deadline)?) };
	- line 536: let uid = unsafe { libc::getuid() };
	- line 569: let mut credentials = unsafe { std::mem::zeroed::<libc::ucred>() };
	- line 577: let result = unsafe {
	- line 605: let result = unsafe { libc::getpeereid(stream.as_raw_fd(), &mut peer_uid, &mut peer_gid) };
	- line 631: if peer_uid != unsafe { libc::getuid() } {


codex-rs/linux-sandbox/src/proxy_routing.rs (17 lines):
	- line 79: unsafe {
	- line 154: let flags = unsafe { libc::fcntl(route.control_fd, libc::F_GETFD) };
	- line 161: let mut control = unsafe { UnixStream::from_raw_fd(route.control_fd) };
	- line 164: if unsafe { libc::fcntl(control.as_raw_fd(), libc::F_SETFD, flags | libc::FD_CLOEXEC) } < 0
	- line 200: unsafe {
	- line 326: let parent_pid = unsafe { libc::getpid() };
	- line 327: let pid = unsafe { libc::fork() };
	- line 339: unsafe { libc::_exit(1) };
	- line 341: unsafe { libc::_exit(0) };
	- line 410: let fd = unsafe { libc::socket(libc::AF_INET, libc::SOCK_DGRAM | libc::SOCK_CLOEXEC, 0) };
	- line 415: let mut ifreq = unsafe { std::mem::zeroed::<libc::ifreq>() };
	- line 421: unsafe { libc::ioctl(fd, libc::SIOCGIFFLAGS as libc::Ioctl, &mut ifreq) };
	- line 428: let current_flags = unsafe { ifreq.ifr_ifru.ifru_flags };
	- line 433: unsafe { libc::ioctl(fd, libc::SIOCSIFFLAGS as libc::Ioctl, &ifreq) };
	- line 441: let mut addr_req = unsafe { std::mem::zeroed::<libc::ifreq>() };
	- line 453: unsafe {
	- line 457: let set_addr_result = unsafe { libc::ioctl(fd, libc::SIOCSIFADDR as libc::Ioctl, &addr_req) };


codex-rs/shell-escalation/src/unix/escalate_server.rs (16 lines):
	- line 346: unsafe {
	- line 566: let rc = unsafe { libc::kill(pid, 0) };
	- line 587: assert_ne!(unsafe { libc::fcntl(socket_fd, libc::F_GETFD) }, -1);
	- line 674: assert_ne!(unsafe { libc::fcntl(socket_fd, libc::F_GETFD) }, -1);
	- line 867: let original_fd = unsafe { libc::dup(target_fd) };
	- line 871: if unsafe { libc::close(target_fd) } == -1 {
	- line 873: unsafe {
	- line 880: original_fd: unsafe { std::os::fd::OwnedFd::from_raw_fd(original_fd) },
	- line 891: unsafe {
	- line 902: if unsafe { libc::pipe(pipe_fds.as_mut_ptr()) } == -1 {
	- line 905: let read_end = unsafe { std::os::fd::OwnedFd::from_raw_fd(pipe_fds[0]) };
	- line 906: let mut write_end = unsafe { std::fs::File::from_raw_fd(pipe_fds[1]) };
	- line 1055: let dup_socket_fd = unsafe { libc::dup(socket_fd) };
	- line 1057: let handshake_client = unsafe { AsyncDatagramSocket::from_raw_fd(dup_socket_fd) }?;
	- line 1063: let dup_server_stream_fd = unsafe { libc::dup(server_stream_guard.as_raw_fd()) };
	- line 1068: let server_stream_fd = unsafe { std::os::fd::OwnedFd::from_raw_fd(dup_server_stream_fd) };


codex-rs/windows-sandbox-rs/src/wfp.rs (15 lines):
	- line 105: let mut session: FWPM_SESSION0 = unsafe { zeroed() };
	- line 113: let result = unsafe {
	- line 127: let result = unsafe { FwpmTransactionBegin0(self.handle, 0) };
	- line 138: unsafe {
	- line 152: let result = unsafe { FwpmTransactionCommit0(self.engine.handle) };
	- line 162: unsafe {
	- line 178: let mut access: EXPLICIT_ACCESS_W = unsafe { zeroed() };
	- line 179: unsafe {
	- line 191: let result = unsafe {
	- line 219: unsafe {
	- line 241: let result = unsafe { FwpmProviderAdd0(engine, &provider, null_mut()) };
	- line 262: let result = unsafe { FwpmSubLayerAdd0(engine, &sublayer, null_mut()) };
	- line 303: let result = unsafe { FwpmFilterAdd0(engine, &filter, null_mut(), &mut filter_id) };
	- line 347: let result = unsafe { FwpmFilterDeleteByKey0(engine, key) };
	- line 384: Anonymous: unsafe { zeroed() },


codex-rs/network-proxy/src/windows_tcp_attribution.rs (15 lines):
	- line 62: let result = unsafe {
	- line 78: let result = unsafe {
	- line 108: let row_count = unsafe { std::ptr::read_unaligned(buffer.as_ptr().cast::<u32>()) } as usize;
	- line 125: let rows = unsafe {
	- line 180: let process_handle = unsafe { OpenProcess(PROCESS_QUERY_LIMITED_INFORMATION, 0, process_id) };
	- line 184: let opened = unsafe {
	- line 197: let queried = unsafe {
	- line 206: if queried != 0 || unsafe { GetLastError() } != ERROR_INSUFFICIENT_BUFFER {
	- line 211: let queried = unsafe {
	- line 239: let group_count = unsafe { std::ptr::read_unaligned(buffer.as_ptr().cast::<u32>()) } as usize;
	- line 256: let groups = unsafe {
	- line 269: if unsafe { ConvertSidToStringSidW(sid, &mut string_sid) } == 0 {
	- line 273: let value = unsafe {
	- line 280: unsafe {
	- line 300: Ok(unsafe { OwnedHandle::from_raw_handle(handle as RawHandle) })


codex-rs/utils/pty/src/win/job.rs (15 lines):
	- line 28: unsafe extern "system" {
	- line 44: let handle = unsafe { CreateJobObjectW(std::ptr::null_mut(), std::ptr::null()) };
	- line 48: let handle = unsafe { OwnedHandle::from_raw_handle(handle.cast()) };
	- line 70: let handle = unsafe {
	- line 77: Ok(unsafe { std::os::windows::io::OwnedHandle::from_raw_handle(handle.cast()) })
	- line 82: let terminated = unsafe {
	- line 93: let mut limits: JOBOBJECT_EXTENDED_LIMIT_INFORMATION = unsafe { std::mem::zeroed() };
	- line 95: let configured = unsafe {
	- line 114: let assigned = unsafe {
	- line 134: let process = unsafe {
	- line 144: let process = unsafe { OwnedHandle::from_raw_handle(process.cast()) };
	- line 147: let status = unsafe { NtResumeProcess(process.as_raw_handle().cast()) };
	- line 149: unsafe {
	- line 177: let status = unsafe { NtResumeProcess(process_handle.cast()) };
	- line 217: let terminated = unsafe {


codex-rs/windows-sandbox-rs/src/desktop.rs (14 lines):
	- line 163: let sandbox_sid = unsafe { get_user_sid_bytes(security.h_token)? };
	- line 228: let handle = unsafe {
	- line 237: anyhow::bail!("OpenDesktopW failed: {}", unsafe { GetLastError() });
	- line 270: let owner_user_sid = unsafe {
	- line 284: if unsafe {
	- line 295: unsafe { GetLastError() }
	- line 307: let handle = unsafe {
	- line 317: let error = unsafe { GetLastError() };
	- line 318: unsafe {
	- line 351: let handle = unsafe {
	- line 362: let err = unsafe { GetLastError() } as i32;
	- line 374: unsafe {
	- line 385: unsafe fn grant_desktop_access(handle: isize, logs_base_dir: Option<&Path>) -> Result<()> {
	- line 447: unsafe {


codex-rs/windows-sandbox-rs/src/lib.rs (13 lines):
	- line 414: let res = unsafe { WaitForSingleObject(process, timeout) };
	- line 437: let res = unsafe { WaitForSingleObject(process, wait_ms) };
	- line 445: unsafe fn setup_stdio_pipes() -> io::Result<PipeHandles> {
	- line 577: let (stdin_pair, stdout_pair, stderr_pair) = unsafe { setup_stdio_pipes()? };
	- line 588: .and_then(|desktop| unsafe {
	- line 603: unsafe {
	- line 619: unsafe {
	- line 634: let ok = unsafe {
	- line 655: let ok = unsafe {
	- line 677: unsafe {
	- line 687: let root_result = unsafe {
	- line 692: &format!("capture failed to terminate root process: {}", unsafe {
	- line 706: unsafe {


codex-rs/tui/src/terminal_probe/windows.rs (12 lines):
	- line 95: let key = unsafe { record.Event.KeyEvent };
	- line 101: let character = unsafe { key.uChar.UnicodeChar };
	- line 163: match unsafe {
	- line 177: if unsafe { GetNumberOfConsoleInputEvents(self.handle, &mut pending) } == 0 {
	- line 185: [unsafe { std::mem::zeroed::<INPUT_RECORD>() }; WINDOWS_PROBE_READ_RECORDS];
	- line 194: let result = unsafe {
	- line 220: if unsafe { GetNumberOfConsoleInputEvents(self.handle, &mut pending) } == 0 {
	- line 238: let result = unsafe {
	- line 274: let result = unsafe {
	- line 295: let mut info = unsafe { std::mem::zeroed::<CONSOLE_SCREEN_BUFFER_INFOEX>() };
	- line 297: if unsafe { GetConsoleScreenBufferInfoEx(output, &mut info) } == 0 {
	- line 326: let handle = unsafe { GetStdHandle(kind) };


codex-rs/utils/pty/src/win/psuedocon.rs (12 lines):
	- line 100: let mut info: OSVERSIONINFOW = unsafe { mem::zeroed() };
	- line 102: let status = unsafe { (ntdll.RtlGetVersion)(&mut info) };
	- line 118: unsafe impl Send for PsuedoCon {}
	- line 119: unsafe impl Sync for PsuedoCon {}
	- line 123: unsafe { (CONPTY.ClosePseudoConsole)(self.con) };
	- line 134: let result = unsafe {
	- line 155: let result = unsafe { (CONPTY.ResizePseudoConsole)(self.con, size) };
	- line 168: let mut si: STARTUPINFOEXW = unsafe { mem::zeroed() };
	- line 180: let mut pi: PROCESS_INFORMATION = unsafe { mem::zeroed() };
	- line 188: let res = unsafe {
	- line 214: let _main_thread = unsafe { OwnedHandle::from_raw_handle(pi.hThread as _) };
	- line 215: let proc = unsafe { OwnedHandle::from_raw_handle(pi.hProcess as _) };


codex-rs/cli/src/debug_sandbox/pid_tracker.rs (11 lines):
	- line 18: let kq = unsafe { libc::kqueue() };
	- line 30: unsafe extern "C" {
	- line 40: unsafe {
	- line 66: let res = unsafe { libc::kill(pid as libc::pid_t, 0) };
	- line 97: let res = unsafe { libc::kevent(kq, &kev, 1, std::ptr::null_mut(), 0, std::ptr::null()) };
	- line 163: let res = unsafe { libc::kevent(kq, &kev, 1, std::ptr::null_mut(), 0, std::ptr::null()) };
	- line 181: let _ = unsafe { libc::kevent(kq, &kev, 1, std::ptr::null_mut(), 0, std::ptr::null()) };
	- line 195: let _ = unsafe { libc::close(kq) };
	- line 206: unsafe { std::mem::MaybeUninit::zeroed().assume_init() };
	- line 220: let nev = unsafe {
	- line 272: let _ = unsafe { libc::close(kq) };


codex-rs/windows-sandbox-rs/src/unified_exec/backends/legacy.rs (11 lines):
	- line 189: unsafe {
	- line 208: && unsafe { TerminateProcess(*handle, 1) } == 0
	- line 213: unsafe { GetLastError() }
	- line 224: let ok = unsafe {
	- line 234: let err = unsafe { GetLastError() } as i32;
	- line 259: unsafe {
	- line 270: unsafe {
	- line 296: let result = unsafe {
	- line 416: unsafe {
	- line 433: let wait_res = unsafe { WaitForSingleObject(pi.hProcess, timeout) };
	- line 448: unsafe {


codex-rs/utils/pty/src/pty.rs (11 lines):
	- line 323: unsafe {
	- line 431: let result = unsafe {
	- line 447: Ok(unsafe { (File::from_raw_fd(master), File::from_raw_fd(slave)) })
	- line 452: let flags = unsafe { libc::fcntl(fd, libc::F_GETFD) };
	- line 456: let result = unsafe { libc::fcntl(fd, libc::F_SETFD, flags | libc::FD_CLOEXEC) };
	- line 471: let bytes = unsafe {
	- line 486: unsafe {
	- line 502: let descriptor_table_bytes = unsafe {
	- line 525: if unsafe { libc::getrlimit(libc::RLIMIT_NOFILE, &raw mut limit) } == 0 {
	- line 550: let flags = unsafe { libc::fcntl(num, libc::F_GETFD) };
	- line 558: unsafe {


codex-rs/windows-sandbox-rs/src/proc_thread_attr.rs (11 lines):
	- line 23: unsafe {
	- line 27: return Err(io::Error::from_raw_os_error(unsafe {
	- line 33: let ok = unsafe { InitializeProcThreadAttributeList(list, attr_count, 0, &mut size) };
	- line 35: return Err(io::Error::from_raw_os_error(unsafe {
	- line 52: unsafe {
	- line 67: unsafe { self.update(PROC_THREAD_ATTRIBUTE_HANDLE_LIST, value, size) }
	- line 80: unsafe { self.update(PROC_THREAD_ATTRIBUTE_JOB_LIST, value, size) }
	- line 83: unsafe fn update(
	- line 89: let ok = unsafe {
	- line 101: return Err(io::Error::from_raw_os_error(unsafe {
	- line 111: unsafe {


codex-rs/utils/pty/src/process_group.rs (11 lines):
	- line 28: if unsafe { libc::prctl(libc::PR_SET_PDEATHSIG, libc::SIGTERM) } == -1 {
	- line 32: if unsafe { libc::getppid() } != parent_pid {
	- line 33: unsafe {
	- line 50: let result = unsafe { libc::setsid() };
	- line 72: let result = unsafe { libc::setpgid(0, 0) };
	- line 94: let pgid = unsafe { libc::getpgid(pid) };
	- line 103: let result = unsafe { libc::killpg(pgid, libc::SIGKILL) };
	- line 124: let result = unsafe { libc::killpg(pgid, signal) };
	- line 138: if unsafe { libc::kill(pid, signal) } == -1 {
	- line 172: let count = unsafe {
	- line 200: let current_group_id = unsafe { libc::getpgid(process_id) };


codex-rs/linux-sandbox/src/proxy_lifecycle.rs (11 lines):
	- line 123: let res = unsafe { libc::prctl(libc::PR_SET_PDEATHSIG, libc::SIGTERM) };
	- line 126: } else if unsafe { libc::getppid() } != expected_parent_pid {
	- line 134: let null_read_fd = unsafe { libc::open(c"/dev/null".as_ptr(), libc::O_RDONLY) };
	- line 137: if unsafe { libc::fcntl(libc::STDIN_FILENO, libc::F_GETFD) } < 0 {
	- line 143: let null_write_fd = unsafe { libc::open(c"/dev/null".as_ptr(), libc::O_WRONLY) };
	- line 145: if unsafe { libc::dup2(null_read_fd, libc::STDIN_FILENO) } < 0 {
	- line 164: if unsafe { libc::dup2(source_fd, stream_fd) } < 0 {
	- line 188: if unsafe { libc::dup2(source_fd, stream_fd) } < 0 {
	- line 202: let relocated_fd = unsafe {
	- line 214: Ok(unsafe { OwnedFd::from_raw_fd(relocated_fd) })
	- line 218: let res = unsafe { libc::close(fd) };


codex-rs/windows-sandbox-rs/src/winutil.rs (10 lines):
	- line 78: unsafe {
	- line 106: unsafe {
	- line 143: let ok = unsafe {
	- line 158: let err = unsafe { GetLastError() };
	- line 184: if unsafe { ConvertStringSidToSidW(sid_w.as_ptr(), &mut psid) } == 0 {
	- line 187: unsafe { GetLastError() }
	- line 190: let sid_len = unsafe { GetLengthSid(psid) };
	- line 192: unsafe {
	- line 198: let ok = unsafe { CopySid(sid_len, out.as_mut_ptr() as *mut std::ffi::c_void, psid) };
	- line 199: unsafe {


codex-rs/http-client/src/outbound_proxy/windows.rs (10 lines):
	- line 141: let ok = unsafe {
	- line 192: let ok = unsafe { WinHttpGetIEProxyConfigForCurrentUser(&mut raw) };
	- line 252: let string = unsafe { wide_ptr_to_string(self.0) };
	- line 264: unsafe {
	- line 276: let handle = unsafe {
	- line 296: unsafe {
	- line 325: unsafe fn wide_ptr_to_string(ptr: PWSTR) -> String {
	- line 327: while unsafe { *ptr.add(len) } != 0 {
	- line 330: let slice = unsafe { std::slice::from_raw_parts(ptr, len) };
	- line 335: unsafe { GetLastError() }


codex-rs/tui/src/tui/terminal_stderr.rs (10 lines):
	- line 154: if unsafe {
	- line 162: unsafe { (stdout_stat.assume_init(), stderr_stat.assume_init()) };
	- line 173: let saved_stderr = unsafe { libc::dup(libc::STDERR_FILENO) };
	- line 178: let saved_stderr = unsafe { OwnedFd::from_raw_fd(saved_stderr) };
	- line 181: if unsafe { libc::dup2(devnull.as_raw_fd(), libc::STDERR_FILENO) } == -1 {
	- line 195: if unsafe { libc::dup2(saved_stderr.as_raw_fd(), libc::STDERR_FILENO) } == -1 {
	- line 227: let saved_stderr = unsafe { libc::dup(libc::STDERR_FILENO) };
	- line 232: let saved_stderr = unsafe { OwnedFd::from_raw_fd(saved_stderr) };
	- line 234: if unsafe { libc::dup2(file.as_raw_fd(), libc::STDERR_FILENO) } == -1 {
	- line 244: let _ = unsafe { libc::dup2(self.saved_stderr.as_raw_fd(), libc::STDERR_FILENO) };


codex-rs/tui/src/terminal_probe.rs (9 lines):
	- line 136: let original_flags = unsafe { libc::fcntl(fd, libc::F_GETFL) };
	- line 140: if unsafe { libc::fcntl(fd, libc::F_SETFL, original_flags | libc::O_NONBLOCK) } == -1 {
	- line 168: let count = unsafe {
	- line 209: let result = unsafe {
	- line 229: unsafe { libc::fcntl(self.reader.as_raw_fd(), libc::F_SETFL, self.original_flags) };
	- line 235: let duplicated = unsafe { libc::dup(fd) };
	- line 239: Ok(unsafe { File::from_raw_fd(duplicated) })
	- line 555: let count = unsafe {
	- line 582: let count = unsafe {


codex-rs/windows-sandbox-rs/src/elevated/runner_pipe.rs (9 lines):
	- line 63: let ok = unsafe {
	- line 72: return Err(io::Error::from_raw_os_error(unsafe {
	- line 82: let h = unsafe {
	- line 94: unsafe {
	- line 98: return Err(io::Error::from_raw_os_error(unsafe {
	- line 111: let ok = unsafe { ConnectNamedPipe(h, ptr::null_mut()) };
	- line 113: let err = unsafe { GetLastError() };
	- line 120: let ok = unsafe { GetNamedPipeClientProcessId(h, &mut client_pid) };
	- line 122: return Err(io::Error::from_raw_os_error(unsafe {


codex-rs/tui/src/tui.rs (9 lines):
	- line 387: let result = unsafe { libc::tcflush(libc::STDIN_FILENO, libc::TCIFLUSH) };
	- line 404: let handle = unsafe { GetStdHandle(STD_INPUT_HANDLE) };
	- line 406: let err = unsafe { GetLastError() };
	- line 411: let result = unsafe { FlushConsoleInputBuffer(handle) };
	- line 413: let err = unsafe { GetLastError() };
	- line 1215: if unsafe { GetConsoleMode(handle, &mut mode) } == 0 {
	- line 1224: if unsafe { SetConsoleMode(handle, mode | requested) } == 0 {
	- line 1231: let stdout_handle = unsafe { GetStdHandle(STD_OUTPUT_HANDLE) };
	- line 1234: let stderr_handle = unsafe { GetStdHandle(STD_ERROR_HANDLE) };


codex-rs/windows-sandbox-rs/src/process.rs (8 lines):
	- line 70: unsafe fn ensure_inheritable_stdio(si: &mut STARTUPINFOW) -> Result<()> {
	- line 92: pub unsafe fn create_process_as_user(
	- line 240: unsafe {
	- line 266: let spawn_result = unsafe {
	- line 281: unsafe {
	- line 301: unsafe {
	- line 337: let ok = unsafe {
	- line 351: unsafe {


codex-rs/utils/pty/src/win/procthreadattr.rs (8 lines):
	- line 43: unsafe {
	- line 52: unsafe { data.set_len(bytes_required) };
	- line 55: let res = unsafe {
	- line 75: unsafe {
	- line 94: unsafe { self.update(PROC_THREAD_ATTRIBUTE_JOB_LIST, value, size) }
	- line 97: unsafe fn update(
	- line 103: let res = unsafe {
	- line 125: unsafe { DeleteProcThreadAttributeList(self.as_mut_ptr()) };


codex-rs/windows-sandbox-rs/src/dpapi.rs (8 lines):
	- line 26: let ok = unsafe {
	- line 39: return Err(anyhow!("CryptProtectData failed: {}", unsafe {
	- line 44: unsafe { std::slice::from_raw_parts(out_blob.pbData, out_blob.cbData as usize) }.to_vec();
	- line 45: unsafe {
	- line 60: let ok = unsafe {
	- line 73: return Err(anyhow!("CryptUnprotectData failed: {}", unsafe {
	- line 78: unsafe { std::slice::from_raw_parts(out_blob.pbData, out_blob.cbData as usize) }.to_vec();
	- line 79: unsafe {


codex-rs/cli/src/doctor/desktop/platform.rs (7 lines):
	- line 88: unsafe { libc::proc_pidpath(pid, buffer.as_mut_ptr().cast(), buffer.len() as u32) };
	- line 103: let handle = unsafe { OpenProcess(PROCESS_QUERY_LIMITED_INFORMATION, 0, pid) };
	- line 107: let process = unsafe { OwnedHandle::from_raw_handle(handle as _) };
	- line 110: let result = unsafe {
	- line 122: let result = unsafe {
	- line 160: let result = unsafe {
	- line 180: let result = unsafe {


codex-rs/windows-sandbox-rs/src/hide_users.rs (7 lines):
	- line 81: let status = unsafe {
	- line 101: unsafe {
	- line 110: let status = unsafe {
	- line 135: let attrs = unsafe { GetFileAttributesW(wide.as_ptr()) };
	- line 137: let err = unsafe { GetLastError() } as i32;
	- line 148: let ok = unsafe { SetFileAttributesW(wide.as_ptr(), new_attrs) };
	- line 150: let err = unsafe { GetLastError() } as i32;


codex-rs/app-server-daemon/src/backend/pid.rs (7 lines):
	- line 175: unsafe {
	- line 263: unsafe { libc::waitpid(raw_pid, std::ptr::null_mut(), libc::WNOHANG) };
	- line 512: let result = unsafe { libc::kill(pid, 0) };
	- line 520: let result = unsafe { libc::kill(raw_pid, libc::SIGTERM) };
	- line 535: let result = unsafe { libc::kill(raw_pid, libc::SIGKILL) };
	- line 550: let result = unsafe { libc::kill(-raw_pid, libc::SIGKILL) };
	- line 606: let result = unsafe { libc::flock(file.as_raw_fd(), libc::LOCK_EX | libc::LOCK_NB) };


codex-rs/utils/sleep-inhibitor/src/windows_inhibitor.rs (5 lines):
	- line 72: let handle = unsafe { PowerCreateRequest(&context) };
	- line 83: if unsafe { PowerSetRequest(handle, request_type) } == 0 {
	- line 87: let _ = unsafe { CloseHandle(handle) };
	- line 102: if unsafe { PowerClearRequest(self.handle, self.request_type) } == 0 {
	- line 111: if unsafe { CloseHandle(self.handle) } == 0 {


codex-rs/windows-sandbox-rs/src/setup.rs (5 lines):
	- line 488: unsafe {
	- line 975: let mut sei: SHELLEXECUTEINFOW = unsafe { std::mem::zeroed() };
	- line 985: let ok = unsafe { ShellExecuteExW(&mut sei) };
	- line 987: let last_error = unsafe { GetLastError() };
	- line 998: unsafe {


codex-rs/exec-server/src/no_follow/windows.rs (5 lines):
	- line 62: unsafe extern "system" {
	- line 159: let status = unsafe {
	- line 181: let code = unsafe { RtlNtStatusToDosError(status) };
	- line 190: Ok(unsafe { OwnedHandle::from_raw_handle(handle as RawHandle) })
	- line 310: let result = unsafe {


codex-rs/cli/src/doctor.rs (5 lines):
	- line 1788: details.push(format!("console input code page: {}", unsafe {
	- line 1791: details.push(format!("console output code page: {}", unsafe {
	- line 1794: details.push(console_mode_detail("stdout console mode", unsafe {
	- line 1797: details.push(console_mode_detail("stderr console mode", unsafe {
	- line 1806: if unsafe { GetConsoleMode(handle, &mut mode) } == 0 {


codex-rs/windows-sandbox-rs/src/conpty/mod.rs (5 lines):
	- line 49: unsafe {
	- line 118: let mut si: STARTUPINFOEXW = unsafe { std::mem::zeroed() };
	- line 142: let mut pi: PROCESS_INFORMATION = unsafe { std::mem::zeroed() };
	- line 143: let ok = unsafe {
	- line 159: let err = unsafe { GetLastError() } as i32;


codex-rs/process-hardening/src/lib.rs (5 lines):
	- line 46: let ret_code = unsafe { libc::prctl(libc::PR_SET_DUMPABLE, 0, 0, 0, 0) };
	- line 66: let ret_code = unsafe { libc::prctl(libc::PR_SET_DUMPABLE, 0, 0, 0, 0) };
	- line 85: let ret_code = unsafe { libc::ptrace(libc::PT_DENY_ATTACH, 0, std::ptr::null_mut(), 0) };
	- line 109: let ret_code = unsafe { libc::setrlimit(libc::RLIMIT_CORE, &rlim) };
	- line 127: unsafe {


codex-rs/tui/src/tui/windows_console.rs (5 lines):
	- line 31: let handle = unsafe { GetStdHandle(STD_INPUT_HANDLE) };
	- line 37: if unsafe { GetConsoleMode(handle, &mut mode) } == 0 {
	- line 52: if requested_mode != mode && unsafe { SetConsoleMode(handle, requested_mode) } == 0 {
	- line 76: if requested_mode != mode && unsafe { SetConsoleMode(handle, requested_mode) } == 0 {
	- line 98: if requested_mode != mode && unsafe { SetConsoleMode(handle, requested_mode) } == 0 {


codex-rs/utils/pty/src/win/mod.rs (5 lines):
	- line 71: let res = unsafe { GetExitCodeProcess(proc.as_raw_handle() as _, &mut status) };
	- line 137: unsafe {
	- line 141: let res = unsafe { GetExitCodeProcess(proc.as_raw_handle() as _, &mut status) };
	- line 151: let res = unsafe { GetProcessId(self.proc.lock().unwrap().as_raw_handle() as _) };
	- line 172: unsafe {


codex-rs/utils/pty/src/unix_io.rs (5 lines):
	- line 27: let fd = unsafe { BorrowedFd::borrow_raw(master_fd) }.try_clone_to_owned()?;
	- line 28: let flags = unsafe { libc::fcntl(fd.as_raw_fd(), libc::F_GETFL) };
	- line 30: || unsafe { libc::fcntl(fd.as_raw_fd(), libc::F_SETFL, flags | libc::O_NONBLOCK) } == -1
	- line 80: if unsafe { libc::tcgetattr(fd.get_ref().as_raw_fd(), termios.as_mut_ptr()) }
	- line 83: let eof = unsafe { termios.assume_init() }.c_cc[libc::VEOF];


codex-rs/shell-command/src/shell_detect.rs (5 lines):
	- line 63: let uid = unsafe { libc::getuid() };
	- line 74: let suggested_buffer_len = unsafe { libc::sysconf(libc::_SC_GETPW_R_SIZE_MAX) };
	- line 83: let status = unsafe {
	- line 98: let passwd = unsafe { passwd.assume_init_ref() };
	- line 103: let shell_path = unsafe { CStr::from_ptr(passwd.pw_shell) }


codex-rs/exec-server/src/sandboxed_file_open.rs (4 lines):
	- line 188: let process = unsafe { OpenProcess(PROCESS_DUP_HANDLE, 0, process_id) };
	- line 193: let process = unsafe { OwnedHandle::from_raw_handle(process as _) };
	- line 196: if unsafe {
	- line 211: Ok(unsafe { std::fs::File::from_raw_handle(duplicated as _) })


codex-rs/windows-sandbox-rs/src/spawn_prep.rs (4 lines):
	- line 154: let (h_token, readonly_sid, readonly_sid_str, write_root_sids) = unsafe {
	- line 255: unsafe {
	- line 279: unsafe {
	- line 436: unsafe {


codex-rs/tui/src/external_editor.rs (4 lines):
	- line 262: Some(val) => unsafe { env::set_var(key, val) },
	- line 263: None => unsafe { env::remove_var(key) },
	- line 271: unsafe {
	- line 283: unsafe {


codex-rs/uds/src/lib.rs (4 lines):
	- line 251: unsafe { BorrowedSocket::borrow_raw(self.as_raw_socket()) }
	- line 273: unsafe { BorrowedSocket::borrow_raw(self.as_raw_socket()) }
	- line 326: unsafe impl async_io::IoSafe for WindowsUnixListener {}
	- line 327: unsafe impl async_io::IoSafe for WindowsUnixStream {}


codex-rs/linux-sandbox/src/exec_util.rs (4 lines):
	- line 24: let flags = unsafe { libc::fcntl(fd, libc::F_GETFD) };
	- line 35: let result = unsafe { libc::fcntl(fd, libc::F_SETFD, cleared_flags) };
	- line 61: let result = unsafe { libc::fcntl(fd, libc::F_SETFD, flags | libc::FD_CLOEXEC) };
	- line 70: let flags = unsafe { libc::fcntl(fd, libc::F_GETFD) };


codex-rs/diagnostics/src/lib.rs (4 lines):
	- line 110: let usage = unsafe {
	- line 134: let page_size = u64::try_from(unsafe { libc::sysconf(libc::_SC_PAGESIZE) })
	- line 167: unsafe extern "system" {
	- line 176: let counters = unsafe {


codex-rs/tui/src/pets/image_protocol.rs (4 lines):
	- line 327: Some(value) => unsafe { env::set_var(name, value) },
	- line 328: None => unsafe { env::remove_var(name) },
	- line 337: Some(value) => unsafe { env::set_var(self.name, value) },
	- line 338: None => unsafe { env::remove_var(self.name) },


codex-rs/shell-escalation/src/unix/escalate_client.rs (3 lines):
	- line 27: Ok(unsafe { AsyncDatagramSocket::from_raw_fd(client_fd) }?)
	- line 109: let err = unsafe {
	- line 142: assert_ne!(unsafe { libc::fcntl(original_fd, libc::F_GETFD) }, -1);


codex-rs/test-binary-support/lib.rs (3 lines):
	- line 53: unsafe {
	- line 62: Some(value) => unsafe {
	- line 65: None => unsafe {


codex-rs/windows-sandbox-rs/src/workspace_acl.rs (3 lines):
	- line 13: pub unsafe fn protect_workspace_codex_dir(cwd: &Path, psid: *mut c_void) -> Result<bool> {
	- line 19: pub unsafe fn protect_workspace_agents_dir(cwd: &Path, psid: *mut c_void) -> Result<bool> {
	- line 23: unsafe fn protect_workspace_subdir(cwd: &Path, psid: *mut c_void, subdir: &str) -> Result<bool> {


codex-rs/tui/src/app/tests.rs (3 lines):
	- line 344: Some(value) => unsafe { std::env::set_var("VISUAL", value) },
	- line 345: None => unsafe { std::env::remove_var("VISUAL") },
	- line 369: unsafe { std::env::set_var("VISUAL", "editor") };


codex-rs/cli/src/doctor/windows_dev_drive.rs (3 lines):
	- line 101: if unsafe { GetVolumePathNameW(path.as_ptr(), volume.as_mut_ptr(), volume.len() as u32) } == 0 {
	- line 104: match unsafe { GetDriveTypeW(volume.as_ptr()) } {
	- line 134: if unsafe {


codex-rs/windows-sandbox-rs/src/unified_exec/tests.rs (3 lines):
	- line 137: let handle = unsafe { OpenProcess(PROCESS_SYNCHRONIZE, 0, pid) };
	- line 141: Ok(unsafe { OwnedHandle::from_raw_handle(handle as _) })
	- line 147: let result = unsafe { WaitForSingleObject(process.as_raw_handle() as _, timeout_ms) };


codex-rs/cli/src/doctor/sandbox.rs (3 lines):
	- line 159: let status = unsafe {
	- line 168: Some(unsafe { (*(buffer as *const USER_INFO_23)).usri23_flags })
	- line 173: unsafe { NetApiBufferFree(buffer.cast()) };


codex-rs/rmcp-client/src/auth_status.rs (3 lines):
	- line 453: unsafe {
	- line 466: unsafe {
	- line 470: unsafe {


codex-rs/rmcp-client/src/utils.rs (3 lines):
	- line 197: unsafe {
	- line 210: unsafe {
	- line 214: unsafe {


codex-rs/windows-sandbox-rs/src/audit.rs (3 lines):
	- line 84: unsafe fn path_has_world_write_allow(path: &Path) -> Result<bool> {
	- line 106: match unsafe { path_has_world_write_allow(path) } {
	- line 293: |path, sid| unsafe { add_deny_write_ace(path, sid) },


codex-rs/linux-sandbox/src/fd_mount.rs (3 lines):
	- line 43: let flags = unsafe { libc::fcntl(descriptor, libc::F_GETFD) };
	- line 49: let file = unsafe { File::from_raw_fd(descriptor) };
	- line 51: unsafe { libc::fcntl(file.as_raw_fd(), libc::F_SETFD, flags | libc::FD_CLOEXEC) };


codex-rs/cli/src/doctor/disk.rs (3 lines):
	- line 131: if unsafe { libc::statvfs(path.as_ptr(), stats.as_mut_ptr()) } != 0 {
	- line 134: let stats = unsafe { stats.assume_init() };
	- line 153: if unsafe {


codex-rs/config/src/loader/macos.rs (3 lines):
	- line 125: unsafe extern "C" {
	- line 129: let value_ref = unsafe {
	- line 143: let value = unsafe { CFString::wrap_under_create_rule(value_ref as _) }.to_string();


codex-rs/responses-api-proxy/src/read_api_key.rs (3 lines):
	- line 48: let result = unsafe {
	- line 175: let page_size = unsafe { sysconf(_SC_PAGESIZE) };
	- line 200: let _ = unsafe { mlock(start as *const c_void, size) };


codex-rs/tui/src/tui/input_boundary.rs (3 lines):
	- line 84: let result = unsafe {
	- line 107: let handle = unsafe { GetStdHandle(STD_INPUT_HANDLE) };
	- line 113: if unsafe { GetNumberOfConsoleInputEvents(handle, &mut pending) } == 0 {


codex-rs/utils/pty/src/pipe.rs (3 lines):
	- line 92: unsafe {
	- line 155: let parent_pid = unsafe { libc::getpid() };
	- line 159: unsafe {


codex-rs/utils/sleep-inhibitor/src/macos.rs (3 lines):
	- line 14: unsafe extern "C" {}
	- line 75: let result = unsafe {
	- line 95: let result = unsafe {


codex-rs/bwrap/src/main.rs (2 lines):
	- line 8: unsafe extern "C" {
	- line 27: let exit_code = unsafe { bwrap_main(cstrings.len() as libc::c_int, argv_ptrs.as_ptr()) };


codex-rs/utils/sleep-inhibitor/src/iokit_bindings.rs (2 lines):
	- line 17: unsafe extern "C" {
	- line 20: unsafe extern "C" {


codex-rs/code-mode-runtime/src/runtime/mod.rs (2 lines):
	- line 359: unsafe extern "C" {
	- line 365: unsafe { v8__V8__IsSandboxEnabled() },


codex-rs/tui/src/clipboard_copy.rs (2 lines):
	- line 410: unsafe {
	- line 439: unsafe {


codex-rs/config/src/loader/mod.rs (2 lines):
	- line 862: let hr = unsafe {
	- line 878: let path = unsafe {


codex-rs/sandboxing/src/bwrap.rs (2 lines):
	- line 98: let flags = unsafe { libc::fcntl(fd, libc::F_GETFL) };
	- line 100: || unsafe { libc::fcntl(fd, libc::F_SETFL, flags | libc::O_NONBLOCK) } < 0


codex-rs/v8-poc/src/lib.rs (2 lines):
	- line 18: unsafe extern "C" {
	- line 23: unsafe { v8__V8__IsSandboxEnabled() }


codex-rs/windows-sandbox-rs/src/deny_read_state.rs (2 lines):
	- line 32: pub unsafe fn sync_persistent_deny_read_acls(
	- line 46: let applied_paths = unsafe { apply_deny_read_acls(desired_paths, psid) }?;


codex-rs/utils/sleep-inhibitor/src/linux_inhibitor.rs (2 lines):
	- line 175: let parent_pid = unsafe { libc::getpid() };
	- line 213: unsafe {


codex-rs/arg0/src/lib.rs (2 lines):
	- line 169: unsafe {
	- line 320: unsafe { std::env::set_var(&key, &value) };


codex-rs/exec-server/src/regular_file.rs (1 line):
	- line 72: unsafe { GetFileType(file.as_raw_handle() as HANDLE) == FILE_TYPE_DISK }


codex-rs/utils/pty/src/win/conpty.rs (1 line):
	- line 87: unsafe {


codex-rs/secrets/src/local.rs (1 line):
	- line 373: unsafe { std::ptr::write_volatile(byte, 0) };


codex-rs/app-server-daemon/src/lib.rs (1 line):
	- line 833: let result = unsafe { libc::flock(file.as_raw_fd(), libc::LOCK_EX | libc::LOCK_NB) };


codex-rs/app-server-transport/src/transport/remote_control/mod.rs (1 line):
	- line 95: unsafe { std::env::remove_var(REMOTE_CONTROL_DISABLED_ENV_VAR) };


codex-rs/core/src/shell_snapshot.rs (1 line):
	- line 293: unsafe {


codex-rs/protocol/src/permissions.rs (1 line):
	- line 3628: unsafe {


codex-rs/core/src/spawn.rs (1 line):
	- line 95: unsafe {


codex-rs/linux-sandbox/src/launcher.rs (1 line):
	- line 228: unsafe {


codex-rs/tui/src/tui/job_control.rs (1 line):
	- line 203: unsafe {


codex-rs/utils/pty/src/process.rs (1 line):
	- line 312: let result = unsafe { libc::ioctl(raw_fd, libc::TIOCSWINSZ, &mut winsize) };


codex-rs/linux-sandbox/src/landlock.rs (1 line):
	- line 121: let result = unsafe { libc::prctl(libc::PR_SET_NO_NEW_PRIVS, 1, 0, 0, 0) };


codex-rs/cli/src/desktop_app/mac.rs (1 line):
	- line 51: let result = unsafe {


codex-rs/exec-server/src/fs_sandbox.rs (1 line):
	- line 478: unsafe {


codex-rs/linux-sandbox/src/bundled_bwrap.rs (1 line):
	- line 63: unsafe {


codex-rs/windows-sandbox-rs/src/elevated_impl.rs (1 line):
	- line 184: unsafe {


codex-rs/windows-sandbox-rs/src/deny_read_acl.rs (1 line):
	- line 51: pub unsafe fn apply_deny_read_acls(paths: &[PathBuf], psid: *mut c_void) -> Result<Vec<PathBuf>> {
