Modo compatibile POSIX per ottenere il nome utente associato a un ID utente

Spesso desidero ottenere il nome di accesso associato a un ID utente e poiché è dimostrato che è un caso d'uso comune, ho deciso di scrivere una funzione di shell per farlo. Mentre utilizzo principalmente le distribuzioni GNU / Linux, provo a scrivere i miei script per essere il più portatile possibile e per verificare che ciò che sto facendo sia compatibile con POSIX.

Parse /etc/passwd

Il primo approccio che ho provato è stato di analizzare /etc/passwd(usando awk).

awk -v uid="$uid" -F: '$3 == uid {print $1}' /etc/passwd

Tuttavia, il problema con questo approccio è che gli accessi potrebbero non essere locali, ad esempio l'autenticazione dell'utente potrebbe avvenire tramite NIS o LDAP.

Usa il getentcomando

L'utilizzo getent passwdè più portatile dell'analisi in /etc/passwdquanto esegue anche query su database NIS o LDAP non locali.

• getent - Wikipedia
• getent (1) - Pagina man di Linux

getent passwd "$uid" | cut -d: -f1

Sfortunatamente, l' getentutilità non sembra essere specificata da POSIX.

Usa il idcomando

id è l'utility standardizzata POSIX per ottenere dati sull'identità di un utente.

Le implementazioni di BSD e GNU accettano un ID utente come operando:

• id (1) - Pagine del manuale di OpenBSD
• id (1) - Pagina man di FreeBSD
• GNU Coreutils: invocazione id

Ciò significa che può essere utilizzato per stampare il nome di accesso associato a un ID utente:

id -nu "$uid"

Tuttavia, fornire ID utente come operando non è specificato in POSIX; descrive solo l'uso di un nome di accesso come operando.

Combinando tutto quanto sopra

Ho considerato di combinare i tre approcci sopra in qualcosa di simile al seguente:

get_username(){
    uid="$1"
    # First try using getent
    getent passwd "$uid" | cut -d: -f1 ||
        # Next try using the UID as an operand to id.
        id -nu "$uid" ||
        # As a last resort, parse `/etc/passwd`.
        awk -v uid="$uid" -F: '$3 == uid {print $1}' /etc/passwd
}

Tuttavia, questo è goffo, inelegante e - soprattutto - non robusto; esce con uno stato diverso da zero se l'ID utente non è valido o non esiste. Prima di scrivere uno script di shell più lungo e clunkier che analizza e memorizza lo stato di uscita di ogni invocazione di comando, ho pensato di chiedere qui:

Esiste un modo più elegante e portatile (compatibile POSIX) per ottenere il nome di accesso associato a un ID utente?

Un modo comune per farlo è verificare se il programma che desideri esiste ed è disponibile dal tuo PATH. Per esempio:

get_username(){
  uid="$1"

  # First try using getent
  if command -v getent > /dev/null 2>&1; then 
    getent passwd "$uid" | cut -d: -f1

  # Next try using the UID as an operand to id.
  elif command -v id > /dev/null 2>&1 && \
       id -nu "$uid" > /dev/null 2>&1; then
    id -nu "$uid"

  # Next try perl - perl's getpwuid just calls the system's C library getpwuid
  elif command -v perl >/dev/null 2>&1; then
    perl -e '@u=getpwuid($ARGV[0]);
             if ($u[0]) {print $u[0]} else {exit 2}' "$uid"

  # As a last resort, parse `/etc/passwd`.
  else
      awk -v uid="$uid" -F: '
         BEGIN {ec=2};
         $3 == uid {print $1; ec=0; exit 0};
         END {exit ec}' /etc/passwd
  fi
}

Poiché POSIX idnon supporta gli argomenti UID, la elifclausola iddeve verificare non solo se si idtrova nel PERCORSO, ma anche se verrà eseguito senza errori. Ciò significa che potrebbe funzionare iddue volte, che fortunatamente non avrà un impatto evidente sulle prestazioni. E 'anche possibile che sia ide awkverrà eseguito, con lo stesso calo di prestazioni trascurabile.

A proposito, con questo metodo, non è necessario memorizzare l'output. Verrà eseguito solo uno di essi, quindi solo uno stamperà l'output per restituire la funzione.

In POSIX non c'è nulla che possa aiutare a parte id. Provare ide ricadere nell'analisi /etc/passwdè probabilmente portatile come nella pratica.

BusyBox idnon accetta gli ID utente, ma i sistemi con BusyBox sono in genere sistemi integrati autonomi in cui l'analisi /etc/passwdè sufficiente.

Nel caso in cui incontri un sistema non GNU in cui idnon accetta gli ID utente, puoi anche provare a chiamare getpwuidtramite Perl, nella possibilità che sia disponibile:

username=$(perl -e 'print((getpwuid($ARGV[0]))[0])) 2>/dev/null
if [ -n "$username" ]; then echo "$username"; return; fi

O Python:

if python -c 'import pwd, sys; print(pwd.getpwuid(int(sys.argv[1]))).pw_name' 2>/dev/null; then return; fi

POSIX specifica getpwuidcome funzione C standard per cercare nel database utenti un ID utente che consenta di tradurre l'ID in un nome di accesso. Ho scaricato il codice sorgente per i coreutils GNU e posso vedere questa funzione utilizzata nella loro implementazione di utility come ide ls.

Come esercizio di apprendimento, ho scritto questo programma C veloce e sporco per agire semplicemente come un wrapper per questa funzione. Ricorda che non ho programmato in C dal college (molti anni fa) e non ho intenzione di usarlo in produzione, ma ho pensato di pubblicarlo qui come prova di concetto (se qualcuno volesse modificarlo , sentiti libero):

#include <stdio.h>
#include <stdlib.h>  /* atoi */
#include <pwd.h>

int main( int argc, char *argv[] ) {
    uid_t uid;
    if ( argc >= 2 ) {
        /* NB: atoi returns 0 (super-user ID) if argument is not a number) */
        uid = atoi(argv[1]);
    }
    /* Ignore any other arguments after the first one. */
    else {
        fprintf(stderr, "One numeric argument must be supplied.\n");
        return 1;
    }

    struct passwd *pwd;
    pwd = getpwuid(uid);
    if (pwd) {
        printf("The login name for %d is: %s\n", uid, pwd->pw_name);
        return 0;
    }
    else {
        fprintf(stderr, "Invalid user ID: %d\n", uid);
        return 1;
    }
}

Non ho avuto la possibilità di testarlo con NIS / LDAP ma ho notato che se ci sono più voci per lo stesso utente /etc/passwd, ignora tutto tranne il primo.

Esempio di utilizzo:

$ ./get_user ""
The login name for 0 is: root

$ ./get_user 99
Invalid user ID: 99

In generale, consiglierei di non farlo. Il mapping da nomi utente a uid non è uno a uno e la codifica dei presupposti che è possibile riconvertire da un uid per ottenere un nome utente sta andando a rompere le cose. Ad esempio, eseguo spesso contenitori dello spazio dei nomi utente completamente senza root facendo in modo che i file passwde groupnel contenitore mappino tutti i nomi utente e gruppo su id 0; questo consente l'installazione dei pacchetti per funzionare senza chownerrori. Ma se qualcosa cerca di riconvertire 0 in un uid e non ottiene ciò che si aspetta, si romperà gratuitamente. Quindi, in questo esempio, invece di riconvertire e confrontare i nomi utente, è necessario convertire in uid e confrontare in quello spazio.

Se hai davvero bisogno di fare questa operazione, potrebbe essere possibile farlo in modo semi-portabile se sei root, creando un file temporaneo, inserendolo nell'UID chown, quindi usando lsper rileggere e analizzare il nome del proprietario. Ma userei solo un approccio ben noto che non è standardizzato ma "portatile in pratica", come uno di quelli che hai già trovato.

Ma ancora una volta, non farlo. A volte qualcosa di difficile da fare è inviarti un messaggio.