Elenca tutti i membri di un gruppo (Mac OS X)

Ho provato a cercare su Google ma non sono arrivato da nessuna parte. Come posso elencare tutti i membri di un gruppo chiamato mygroupdalla riga di comando in OS X?

$ dscl . list /groupsmi porterà tutti i gruppi ... ma come posso vedere i membri di ciascun gruppo?

Puoi usare:

dscacheutil -q group -a name admin

o:

dscacheutil -q group -a name staff

eccetera.

Non esiste un comando standard che elenca tutti i membri di un gruppo in OS X, quindi ecco una funzione shell che lo fa:

members () { dscl . -list /Users | while read user; do printf "$user "; dsmemberutil checkmembership -U "$user" -G "$*"; done | grep "is a member" | cut -d " " -f 1; }; 

Copia la riga di comando sopra nel Terminale, quindi digita (dove mygroup è il nome di un gruppo esistente).members mygroup

Qualche spiegazione per coloro che sono interessati:

Esistono cinque modi diversi (di cui sono a conoscenza) che un utente può essere membro di un gruppo in OS X. Il comando non è garantito per l'output di tutti, o anche di uno qualsiasi dei membri di mygroup , perché l'appartenenza proviene anche dagli utenti " ID gruppo principale , appartenenza tramite UUID dell'utente , eredità di appartenenza da un gruppo a un altro e appartenenze calcolate dal sistema, ad esempio il gruppo tutti .dscl . -read /Groups/mygroup GroupMembership

Quindi, piuttosto che cercare di tenere traccia di tutti questi, sembra un'idea migliore semplicemente controllare l'appartenenza di ogni utente al sistema (usando dsmemberutil ), ed è quello che fanno la funzione shell e lo script qui sotto.

Questo script di membri equivale alla funzione shell, ma ha una gestione migliore dell'input non valido:

#!/bin/bash

# members -- list all members of a group
#
# SYNOPSIS
#   members groupname
#
# http://superuser.com/questions/279891/list-all-members-of-a-group-mac-os-x
#  by Arne
# Expected to work on Mac OS 10.5 and newer, tested on 10.6 and 10.7.
# It could be rewritten to work on 10.4 by using "dseditgroup -o checkmember"
# instead of "dsmemberutil checkmembership".
# By using dseditgroup, the script could also be extended to handle
# other Directory Service nodes than the default local node.
#

the_group="$1"
# Input check and usage
  if [[ $# != 1 || $1 == -* || $1 =~ [[:space:]] ]]; then
    echo "Usage: ${0##*/} groupname" >&2
    echo "Lists all members of the group." >&2
    exit 64
  elif (dsmemberutil checkmembership -U root -G "$the_group" 2>&1 \
    | grep "group .* cannot be found") >&2; then
    exit 1
  fi

# Check every user
exec dscl . -list /Users \
  | while read each_username
  do
    printf "$each_username "
    dsmemberutil checkmembership -U "$each_username" -G "$the_group"
  done \
    | grep "is a member" | cut -d " " -f 1

# eof

Informazioni supplementari:

I cinque modi per essere un membro del gruppo sono:

1. ID gruppo primario dell'utente
2. Elencato nel GroupMembership del gruppo
3. UUID elencato nei GroupMembers del gruppo
4. Appartenenza ereditata al gruppo X in quanto membro del gruppo Y elencato nei gruppi nidificati del gruppo X.
5. Iscrizione calcolata dal sistema

Questi possono essere esplorati con comandi simili dscl . -read /Groups/somegroup

Esempio 4 : L'appartenenza al gruppo Operatore di stampa __lpoperator_ è ereditata dai membri del gruppo Amministratore di stampa __lpadmin_ e l'appartenenza a quel gruppo è ereditata dai membri del gruppo admin .

Esempio di 5 :

$ dscl . -read /Groups/netaccounts Comment
Comment:
 Group membership calculated by system
 Accounts from a remote directory server
$ 

VEDERE ANCHE
    id (1) , dscl (1) , dsmemberutil (1) , dseditgroup (8) , DirectoryServiceAttributes (7) , uuid (3)

Nota: questa è stata la mia risposta iniziale, scritta prima che mi rendessi conto che questa risposta dà ancora un risultato incompleto . (Per esempio, non trova nessun membro del ognuno gruppo!) Così ho scritto una risposta migliore, che include uno script che elenca tutti i membri di un gruppo in OS X .

La proprietà GroupMembership di mygroup può essere stampata con dscl in questo modo:

dscl . -read /Groups/mygroup GroupMembership

Ma questo non è garantito per produrre tutti (o anche qualsiasi) i membri del gruppo. Ciò che manca sono gli utenti che sono membri del gruppo solo avendo come ID gruppo principale .

Un esempio comune di ciò in OS X sono gli account di accesso regolari, che hanno il personale (gruppo 20) come gruppo principale, ma non sono elencati nella proprietà GroupMembership del gruppo personale .

Questi utenti possono essere trovati cercando l' ID numerico del gruppo primario (gid) come in questo esempio per il gruppo staff (gid 20):

dscl . -list /Users PrimaryGroupID | grep " 20$"

e il gid numerico (PrimaryGroupID) di mygroup viene trovato da:

dscl . -read /Groups/mygroup PrimaryGroupID

Per ottenere tutti i gruppi in cui si trova un utente , è possibile utilizzare quanto segue:

id -nG <username>

Esempio di output:

staff com.apple.sharepoint.group.1 everyone localaccounts _appserverusr admin _appserveradm _lpadmin _appstore _lpoperator _developer com.apple.access_ftp com.apple.access_screensharing com.apple.access_ssh

Utilizzando il comando sopra, è possibile ottenere tutti gli utenti che appartengono a un gruppo :

OSX :

group=staff;
for i in $(dscl . list /users);
do [[ $(id -nG $i | grep $group) ]] && echo $i;
done

Unix :

group=sudo;
# This only outputs lines that match a username (from the start of line to a colon must not be a hash indicating a comment) 
for i in $(grep -oE "^[^#:]+" /etc/passwd);
do [[ $(id -nG $i | grep $group) ]] && echo $i;
done

dscl . -read /Groups/[groupname] | grep GroupMembership

ATTENZIONE: il comando sopra non mostra sempre un elenco completo di TUTTI i membri del gruppo. Ad esempio per il "personale" del gruppo si ottiene "radice" solo come membro del gruppo che è incompleto. Per verificarlo, utilizzare uno dei seguenti comandi come utente predefinito (NON "root"): id -GnORgroups

Di conseguenza, vedrai tutti i gruppi a cui appartiene l'utente registrato predefinito. Uno di questi dovrebbe essere "personale". Pertanto, oltre a "root" ci sono più membri del gruppo "staff", che non sono elencati dal comando dscl . -read /Groups/[groupname] | grep GroupMembership. Lo stesso vale per il comando dscacheutil -q group -a name staffche suggerisce anche che solo "root" è un membro del gruppo "staff", che è ovviamente incompleto.

L'unico metodo affidabile per ottenere davvero TUTTI i membri di un gruppo nel terminale su OSX è già fornito qui da Arne Stenström. Questo sta usando la sua funzione shell resp. la sua sceneggiatura shell. Entrambi funzionano alla grande!

Comando

Simile alla risposta di @ duperuser, il seguente stamperà solo gli utenti del gruppo admincon spazi tra:

dscacheutil -q group -a name admin | grep -e '^users:' | sed 's/users: //'

Produzione

L'esecuzione del comando sopra produrrà qualcosa del genere:

root your_username someone_else

Abbattersi

Il dscacheutilcomando viene utilizzato per richiedere informazioni su varie categorie della cache del servizio di directory del sistema. L' -qopzione consente di specificare la categoria che si desidera interrogare. Le categorie disponibili sono group, host, mount, protocol, rpc, service e user. Eseguiamo inoltre una query su quella categoria specificando una coppia valore-chiave con l' -aopzione. In questo caso, vogliamo elencare il gruppo con la chiave nameuguale al valore admin. Il dscacheutilcomando sopra produce output in questo modo:

name: admin
password: *
gid: 80
users: root yourusername

Quindi reindirizziamo questo testo grepe scegliamo la riga contenente la stringa users:all'inizio. L' -eopzione consente a grep di riconoscere le espressioni regolari . Il ^personaggio specifica che vogliamo users:essere all'inizio della riga.

Questo ci dà

users: root yourusername

Infine, lo passiamo a sed e sostituiamo il testo users:con la stringa vuota. In sed , la prima lettera ssignifica sostituire. Il testo tra la prima coppia di barre ( /users: /) è ciò che vogliamo sostituire, e la coppia successiva di barre ( //) è ciò che vogliamo sostituire (in questo caso, nulla).

Ecco un'implementazione per questo problema che è stata derivata da un'implementazione in una discussione correlata . La routine è in qualche modo generica, con un hook di ricerca del servizio directory per qualsiasi piattaforma / architettura specifica, quindi può essere utilizzata senza modifiche su una rete eterogenea. Abbiamo installato un collegamento simbolico a questa utility denominata zed. Altre origini per questa implementazione sono menzionate nella sezione di attribuzione dello script. Questo strumento è progettato per essere eseguito su almeno OSX, HP-UX, Linux e SunOS, ma non è statotestato su SunOS e HP-UX. Lo script è stato testato il più possibile su Ubuntu Linux 12.04 e Mavericks OSX 10.9.1. L'output di questo script corrisponde all'output per la prima implementazione dello script shell per questo problema ed è quindi considerato corretto.

#!/usr/bin/perl
#
# Lists members of all groups, or optionally just the group
# specified on the command line
#
# Date:         12/30/2013
# Author:       William H. McCloskey, Jr.
# Changes:      Added logic to detect host type & tailor subset of getent (OSX)
# Attribution:
#   The logic for this script was directly lifted from Zed Pobre's work.
#     See below for Copyright notice.
#   The idea to use dscl to emulate a subset of the now defunct getent on OSX
#     came from
#       http://zzamboni.org/\
#         brt/2008/01/21/how-to-emulate-unix-getent-with-macosxs-dscl/
#     with an example implementation lifted from
#       https://github.com/petere/getent-osx/blob/master/getent
#
# Copyright © 2010-2013 by Zed Pobre (zed@debian.org or zed@resonant.org)
#
# Permission to use, copy, modify, and/or distribute this software for any
# purpose with or without fee is hereby granted, provided that the above
# copyright notice and this permission notice appear in all copies.
#

use strict; use warnings;

$ENV{"PATH"} = "/usr/bin:/bin";

# Only run on supported $os:
my $os;
($os)=(`uname -a` =~ /^([\w-]+)/);
unless ($os =~ /(HU-UX|SunOS|Linux|Darwin)/)
    {die "\$getent or equiv. does not exist:  Cannot run on $os\n";}

my $wantedgroup = shift;

my %groupmembers;

my @users;

# Acquire the list of @users based on what is available on this OS:
if ($os =~ /(SunOS|Linux|HP-UX)/) {
    #HP-UX & Solaris assumed to be like Linux; they have not been tested.
    my $usertext = `getent passwd`;
    @users = $usertext =~ /^([a-zA-Z0-9_-]+):/gm;
};
if ($os =~ /Darwin/) {
    @users = `dscl . -ls /Users`;
    chop @users;
}

# Now just do what Zed did - thanks Zed.
foreach my $userid (@users)
{
    my $usergrouptext = `id -Gn $userid`;
    my @grouplist = split(' ',$usergrouptext);

    foreach my $group (@grouplist)
    {
        $groupmembers{$group}->{$userid} = 1;
    }
}

if($wantedgroup)
{
    print_group_members($wantedgroup);
}
else
{
    foreach my $group (sort keys %groupmembers)
    {
        print "Group ",$group," has the following members:\n";
        print_group_members($group);
        print "\n";
    }
}

sub print_group_members
{
    my ($group) = @_;
    return unless $group;

    foreach my $member (sort keys %{$groupmembers{$group}})
    {
        print $member,"\n";
    }
}