fix macos

crates/nu-command/src/filesystem/cd.rs

@@ -277,13 +277,9 @@ fn have_permission(dir: impl AsRef<Path>) -> PermissionResult<'static> {
 #[cfg(unix)]
 fn any_group(current_user_gid: gid_t, owner_group: u32) -> bool {
     use crate::filesystem::util::users;
-    use std::ffi::CString;
 
     users::get_current_username()
-        .and_then(|name| CString::new(name.as_bytes()).ok())
-        .and_then(|name| {
-            users::getgrouplist(name.as_c_str(), users::Gid::from_raw(current_user_gid)).ok()
-        })
+        .and_then(|name| users::get_user_groups(&name, current_user_gid))
         .unwrap_or_default()
         .into_iter()
         .any(|gid| gid.as_raw() == owner_group)

crates/nu-command/src/filesystem/util.rs

@@ -164,8 +164,62 @@ pub fn is_older(src: &Path, dst: &Path) -> bool {
 #[cfg(unix)]
 pub mod users {
     use libc::{gid_t, uid_t};
-    pub use nix::unistd::{getgrouplist, Gid};
-    use nix::unistd::{Group, Uid, User};
+    use nix::unistd::{Gid, Group, Uid, User};
+    use std::ffi::CString;
+
+    #[cfg(target_os = "macos")]
+    pub fn get_user_groups(user: &str, gid: git_t) -> Option<Vec<Gid>> {
+        use libc::{c_int, sysconf};
+        use std::cmp::min;
+
+        let Ok(user) = CString::new(user.as_bytes()) else {
+            return None;
+        };
+
+        let ngroups_max = match sysconf(SysconfVar::NGROUPS_MAX) {
+            Ok(Some(n)) => n as c_int,
+            Ok(None) | Err(_) => <c_int>::max_value(),
+        };
+        let mut groups = Vec::<Gid>::with_capacity(min(ngroups_max, 8) as usize);
+        loop {
+            let mut ngroups = groups.capacity() as i32;
+            let ret = unsafe {
+                libc::getgrouplist(
+                    user.c_str(),
+                    gid as c_int,
+                    groups.as_mut_ptr() as *mut c_int,
+                    &mut ngroups,
+                )
+            };
+
+            // BSD systems only return 0 or -1, Linux returns ngroups on success.
+            if ret >= 0 {
+                unsafe { groups.set_len(ngroups as usize) };
+                return Ok(groups);
+            } else if ret == -1 {
+                // Returns -1 if ngroups is too small, but does not set errno.
+                // BSD systems will still fill the groups buffer with as many
+                // groups as possible, but Linux manpages do not mention this
+                // behavior.
+                if groups.capacity() >= ngroups_max {
+                    return None;
+                }
+
+                let capacity = min(groups.capacity() * 2, ngroup_max);
+
+                groups.reserve(capacity);
+            }
+        }
+    }
+
+    #[cfg(not(target_os = "macos"))]
+    pub fn get_user_groups(user: &str, gid: gid_t) -> Option<Vec<Gid>> {
+        let Ok(user) = CString::new(user.as_bytes()) else {
+            return None;
+        };
+
+        nix::unistd::getgrouplist(user.as_c_str(), Gid::from_raw(gid)).ok()
+    }
 
     pub fn get_user_by_uid(uid: uid_t) -> Option<User> {
         User::from_uid(Uid::from_raw(uid)).ok().flatten()