Ricaricare le assegnazioni di gruppo di un utente Linux senza disconnettersi

Dall'interno di una shell, è possibile emettere il seguente comando

su - $USER

id ora elencherà il nuovo gruppo:

id

Orribilmente hacky, ma si potrebbero usare due strati di newgrp per ottenere questo risultato per un particolare gruppo:

id -g
``` ```
newgrp <new group name>

…vi darà l'attuale ID del gruppo primario. Chiameremo questo orig_group ai fini di questo esempio. Poi:

newgrp <orig_group>
``` &001 


...vi passerà a quel gruppo come primario e lo aggiungerà alla lista dei gruppi restituiti da `groups` o `id -G`. Ora, un altro: 


&001 &001 


...vi farà avere una shell in cui potete vedere il nuovo gruppo e il primario è quello originale. 


Questo è orribile e vi farà aggiungere un solo gruppo alla volta, ma mi ha aiutato un paio di volte a far aggiungere gruppi senza fare il log-out/in tutta la mia X sessione (e. per ottenere l'aggiunta di fuse come gruppo ad un utente in modo che sshfs funzioni). 

_Modifica : Non richiede nemmeno che tu digiti la tua password, che `su` will._

Questo ingegnoso trucco di questo link funziona alla grande!

exec su -l $USER

Ho pensato di pubblicarlo qui perché ogni volta che mi dimentico come si fa, questo è il primo link che compare su google.

1. Ottenere una shell con il nuovo gruppo senza disconnettersi ed entrare di nuovo

Se si aggiunge un solo gruppo, ho usato il seguente:

exec sg <new group name> newgrp `id -gn`
``` ```
screen -S <session_name> -X at \# stuff "exec sg <new_group_name> newgrp ### 1. Ottenere una shell con il nuovo gruppo senza disconnettersi ed entrare di nuovo 


Se si aggiunge un solo gruppo, ho usato il seguente: 

exec sg newgrp id -gn “` id -gn### 1. Ottenere una shell con il nuovo gruppo senza disconnettersi ed entrare di nuovo

Se si aggiunge un solo gruppo, ho usato il seguente:

exec sg <new group name> newgrp `id -gn`
``` ^M"

Questa è una variante del trucco newgrp a due strati di Legooolas, ma è in una riga e non richiede l'inserimento manuale del gruppo primario.

sg è newgrp ma accetta un comando da eseguire con il nuovo ID del gruppo. Il exec significa che la nuova shell sostituisce la shell esistente, quindi non è necessario "fare il logout” due volte.

A differenza di su, non è necessario digitare la password. Inoltre non aggiorna il vostro ambiente (a parte l'aggiunta del gruppo), in modo da mantenere l'attuale directory di lavoro ecc.

2. Esecuzione del comando in tutte le finestre dello schermo in una sessione

Il comando at in Screen esegue un comando in qualsiasi finestra si specifichi (si noti che si tratta di un comando Screen, non di una shell).

Si può usare il seguente comando per inviare il comando a tutte le sessioni di Screen esistenti:

screen -S <session_name> -p 0 -X stuff "exec sg <new_group_name> newgrp ### 1. Ottenere una shell con il nuovo gruppo senza disconnettersi ed entrare di nuovo 


Se si aggiunge un solo gruppo, ho usato il seguente: 

exec sg newgrp id -gn screen -S -X at # stuff “exec sg newgrp ### 1. Ottenere una shell con il nuovo gruppo senza disconnettersi ed entrare di nuovo

Se si aggiunge un solo gruppo, ho usato il seguente:

exec sg <new group name> newgrp `id -gn`
``` id -gn### 1. Ottenere una shell con il nuovo gruppo senza disconnettersi ed entrare di nuovo 


Se si aggiunge un solo gruppo, ho usato il seguente: 

exec sg newgrp id -gn ^M"

Questa è una variante del trucco newgrp a due strati di Legooolas, ma è in una riga e non richiede l'inserimento manuale del gruppo primario.

id è newgrp ma accetta un comando da eseguire con il nuovo ID del gruppo. Il stuff significa che la nuova shell sostituisce la shell esistente, quindi non è necessario "fare il logout” due volte.

A differenza di su, non è necessario digitare la password. Inoltre non aggiorna il vostro ambiente (a parte l'aggiunta del gruppo), in modo da mantenere l'attuale directory di lavoro ecc.

2. Esecuzione del comando in tutte le finestre dello schermo in una sessione

Il comando &007 in Screen esegue un comando in qualsiasi finestra si specifichi (si noti che si tratta di un comando Screen, non di una shell).

Si può usare il seguente comando per inviare il comando a tutte le sessioni di Screen esistenti:

id -gn### 1. Ottenere una shell con il nuovo gruppo senza disconnettersi ed entrare di nuovo

Se si aggiunge un solo gruppo, ho usato il seguente:

exec sg <new group name> newgrp `id -gn`
``` ```
screen -S <session_name> -X at \# stuff "exec sg <new_group_name> newgrp ### 1. Ottenere una shell con il nuovo gruppo senza disconnettersi ed entrare di nuovo 


Se si aggiunge un solo gruppo, ho usato il seguente: 

exec sg newgrp id -gn “` id -gn### 1. Ottenere una shell con il nuovo gruppo senza disconnettersi ed entrare di nuovo

Se si aggiunge un solo gruppo, ho usato il seguente:

exec sg <new group name> newgrp `id -gn`
``` ^M"

Questa è una variante del trucco newgrp a due strati di Legooolas, ma è in una riga e non richiede l'inserimento manuale del gruppo primario.

&007 è newgrp ma accetta un comando da eseguire con il nuovo ID del gruppo. Il &007 significa che la nuova shell sostituisce la shell esistente, quindi non è necessario "fare il logout” due volte.

A differenza di su, non è necessario digitare la password. Inoltre non aggiorna il vostro ambiente (a parte l'aggiunta del gruppo), in modo da mantenere l'attuale directory di lavoro ecc.

2. Esecuzione del comando in tutte le finestre dello schermo in una sessione

Il comando [ &007 ]&003 in Screen esegue un comando in qualsiasi finestra si specifichi (si noti che si tratta di un comando Screen, non di una shell).

Si può usare il seguente comando per inviare il comando a tutte le sessioni di Screen esistenti:

^M" “`

Si noti la necessità di uscire dai back stick per far sì che &007 venga eseguito nella sessione Screen, e la ^M per far sì che Screen prema ‘enter’ alla fine del comando.

Si noti anche che il comando [ &007 ]&003 di Screen digita semplicemente il testo del comando a nome dell'utente. Quindi può accadere qualcosa di strano se una delle finestre dello schermo ha un comando scritto a metà su un prompt di comando o sta eseguendo un'applicazione diversa da una shell (per esempio emacs, in alto). Se questo è un problema, ho alcune idee:

• Per eliminare qualsiasi comando mezzo scritto, potete aggiungere ”^C" all'inizio del comando.
• Per evitare di eseguire il comando in una finestra emacs, ecc., si potrebbe chiedere `at’ di filtrare sul titolo della finestra, ecc. (nell'esempio sopra, io uso “#”, che corrisponde a tutte le finestre, ma si può filtrare per titolo della finestra, utente, ecc.

Per eseguire il comando in una finestra specifica (identificata dal numero della finestra), usare quanto segue:

&001

Utilizzando il comando newgrp il problema risolto per me:

newgrp <GroupName>

Questo post del blog ha una spiegazione dettagliata.

Potete farlo.

Aggiungete tutti i gruppi che volete utilizzando usermod -G. Poi, come utente con una sessione in esecuzione, eseguire newgrp - con il solo argomento ‘-’.

Questo reinizializza l'id del gruppo al default, ma imposterà anche i gruppi secondari. È possibile verificarlo eseguendo groups dalla sessione corrente, prima e dopo usermod e newgrp.

Questo deve essere eseguito da ogni sessione aperta - non so molto di schermo. Tuttavia, se è possibile iterare su tutte le sessioni aperte ed eseguire newgrp, si dovrebbe essere bravi. Non dovrete preoccuparvi di conoscere i gruppi o gli ID dei gruppi.

Buona fortuna.

I gruppi sono di solito enumerati al momento del login, non c'è modo che io sappia di forzarlo a rifare l'enumerazione dei gruppi senza effettuare il logout e tornare indietro.

Molte risposte votate qui sembrano usare un workaround che invoca una nuova shell con un nuovo ambiente (come per il login). la shell madre e tutti gli altri programmi in esecuzione continua non riceveranno generalmente la nuova appartenenza al gruppo fino a quando non saranno ri-votati da una nuova shell di solito dopo il logout pulito e il login.

Per riassumere:

exec newgrp <newlyaddedgroupname1>
exec newgrp <newlyaddedgroupname2>
...
exec newgrp -
``` &001 


Usare 'exec' significa sostituire la shell esistente con la nuova shell avviata dal comando newgrp (quindi uscire dalla nuova shell vi fa uscire). 


L'ultimo `newgrp -` è necessario per ripristinare il vostro normale gruppo primario, quindi i file creati successivamente avranno quello come proprietario del gruppo. 


Nota: La domanda del poster originale era come rendere visibili i gruppi aggiunti di recente nei processi esistenti. I comandi `gpasswd` e `usermod` non influiscono sui processi esistenti; i gruppi appena aggiunti (o cancellati!) appaiono (scompaiono) nel vostro account, cioè nei file /etc/group e /etc/gshadow, ma le autorizzazioni per i processi esistenti non vengono modificate. Per _rimuovere_ i permessi devi eliminare tutti i processi in esecuzione; `newgrp -` non rileggerà /etc/group e non resetterà la lista dei gruppi; invece, sembra usare solo i gruppi precedentemente associati al processo.

Non sono riuscito a far funzionare il comando del newgrp. Non sono sicuro se questo dipenda da /etc/sudoers, ma normalmente devo digitare la mia password per sudo, e questo ha funzionato senza richiedere la mia password:

[leo60228@leonix:~]$ groups
users wheel

[leo60228@leonix:~]$ sudo echo hi
[sudo] password for leo60228:
hi

[leo60228@leonix:~]$ sudo -k # reset sudo timeout

[leo60228@leonix:~]$ exec sudo -i -u $(whoami) # no password necessary

[leo60228@leonix:~]$ groups
users wheel docker

Questo fa il trucco se avete sudo e può salvarvi dall'inserire la vostra password un'altra volta in alcuni casi:

sudo su $USER

Avevo bisogno di farlo in uno script di shell (lo script aggiunge l'utente corrente a un gruppo, esegue comandi successivi che richiedono l'appartenenza a quel gruppo). Il comando newgrp è fragile in quanto può eseguire solo una nuova shell piuttosto che un comando arbitrario (voglio rieseguire lo script di shell corrente con args originali a linea di comando).

Ecco la mia soluzione, che utilizza molti bash-ismi: (si noti che lo script circostante ha bisogno di un qualche tipo di ramo per eseguire questa funzione solo se il gruppo richiesto non è attualmente attivo):

(nota: lo script implica che ha eseguito sudo adduser $user docker, il che significa che potrebbe anche solo eseguire sudo docker ovunque invece di docker, ma questo non era auspicabile in questo caso)

# save these for later
ORIGINAL_ARGS=("$@")

# This function is a little insane. The problem is this: user running
# this script is not a member of docker group, but used 'sudo' to add
# themselves to group. Without logging out and back in, the only way
# to gain access to that group is via the 'newgrp' command, which
# unfortunately starts a new shell rather than an arbitrary command...
#
# Also, we're going to newgrp twice: first to add the new group and
# again to restore the original group (but the new group remains in
# the 'groups' output).
#
# So this horrendous hack dups stdin to fd3 for later. Then runs
# 'newgrp' piping in a script that runs 'newgrp' a second time, piping
# in another script that restores stdin from fd3 and execs the
# original command...
restart-newgrp-newgrp() {
  # dup original stdin to fd3
  exec 3<&0

  local group="$1"
  local command="$0"
  local arg
  for arg in "${ORIGINAL_ARGS[@]}"; do
    printf -v command "%s %q" "$command" "$arg"
  done

  # restore original stdin from fd3; also replace any single-quote in
  # command with '"'"' to embed it in a single-quoted string
  local script
  printf -v script "exec newgrp %q <<<'exec <&3-; exec %s'" "$(id -gn)" "${command///\"\"}"

  exec newgrp "$group" <<<"$script"
}

Ho avuto un problema simile, ma anche per gli utenti non registrati. Il riavvio di nscd non ha aiutato, ma l'esecuzione di questo comando sì: nscd -i group. Questo dovrebbe istruire nscd (demone della cache) a ricaricare il file dei gruppi.