Bash: créer un fifo anonyme

Nous le savons tous mkfifoet les pipelines. Le premier crée un canal nommé , il faut donc sélectionner un nom, très probablement avec mktempet plus tard, n'oubliez pas de dissocier. L'autre crée un canal anonyme, sans tracas avec les noms et la suppression, mais les extrémités du canal sont liées aux commandes dans le pipeline, il n'est pas vraiment pratique de saisir les descripteurs de fichiers et de les utiliser dans le reste du script. Dans un programme compilé, je ferais juste ret=pipe(filedes); dans Bash, il y a exec 5<>filedonc quelque chose à attendre "exec 5<> -"ou "pipe <5 >6"quelque chose comme ça dans Bash?

Vous pouvez dissocier un canal nommé immédiatement après l'avoir attaché au processus en cours, ce qui entraîne pratiquement un canal anonyme:

# create a temporary named pipe
PIPE=$(mktemp -u)
mkfifo $PIPE
# attach it to file descriptor 3
exec 3<>$PIPE
# unlink the named pipe
rm $PIPE
...
# anything we write to fd 3 can be read back from it
echo 'Hello world!' >&3
head -n1 <&3
...
# close the file descriptor when we are finished (optional)
exec 3>&-

Si vous voulez vraiment éviter les canaux nommés (par exemple, le système de fichiers est en lecture seule), votre idée de "saisir les descripteurs de fichiers" fonctionne également. Notez que ceci est spécifique à Linux en raison de l'utilisation de procfs.

# start a background pipeline with two processes running forever
tail -f /dev/null | tail -f /dev/null &
# save the process ids
PID2=$!
PID1=$(jobs -p %+)
# hijack the pipe's file descriptors using procfs
exec 3>/proc/$PID1/fd/1 4</proc/$PID2/fd/0
# kill the background processes we no longer need
# (using disown suppresses the 'Terminated' message)
disown $PID2
kill $PID1 $PID2
...
# anything we write to fd 3 can be read back from fd 4
echo 'Hello world!' >&3
head -n1 <&4
...
# close the file descriptors when we are finished (optional)
exec 3>&- 4<&-

Bien qu'aucun des obus que je connaisse ne puisse fabriquer des tuyaux sans bifurquer, certains ont mieux que le pipeline de base.

En bash, ksh et zsh, en supposant que votre système prend en charge /dev/fd(la plupart le font de nos jours), vous pouvez lier l'entrée ou la sortie d'une commande à un nom de fichier: se <(command)développe en un nom de fichier qui désigne un tuyau connecté à la sortie de command, et se >(command)développe à un nom de fichier qui désigne un tuyau connecté à l'entrée de command. Cette fonctionnalité est appelée substitution de processus . Son objectif principal est de diriger plusieurs commandes vers une autre ou vers une autre, par exemple,

diff <(transform <file1) <(transform <file2)
tee >(transform1 >out1) >(transform2 >out2)

Ceci est également utile pour lutter contre certaines des lacunes des tuyaux shell de base. Par exemple, command2 < <(command1)est équivalent à command1 | command2, sauf que son statut est celui de command2. Un autre cas d'utilisation est exec > >(postprocessing), ce qui équivaut à, mais plus lisible que, de mettre tout le reste du script à l'intérieur { ... } | postprocessing.

Bash 4 a des coprocessus .

Un coprocessus est exécuté de manière asynchrone dans un sous-shell, comme si la commande avait été terminée avec l'opérateur de contrôle «&», avec un canal bidirectionnel établi entre le shell d'exécution et le coprocessus.

Le format d'un coprocessus est:

coproc [NAME] command [redirections] 

Depuis octobre 2012, cette fonctionnalité ne semble toujours pas exister dans Bash, mais coproc peut être utilisé si tout ce dont vous avez besoin pour des canaux sans nom / anonymes est de parler à un processus enfant. Le problème avec coproc à ce stade est que, apparemment, un seul est pris en charge à la fois. Je ne peux pas comprendre pourquoi coproc a cette limitation. Ils auraient dû être une amélioration du code d'arrière-plan de tâche existant (le & op), mais c'est une question pour les auteurs de bash.

Alors que la réponse de @ DavidAnderson couvre toutes les bases et offre de belles garanties, la chose la plus importante qu'elle révèle est qu'il est aussi facile de mettre la main sur un canal anonyme <(:), tant que vous restez sur Linux.

La réponse la plus courte et la plus simple à votre question est donc:

exec 5<> <(:)

Sur macOS, cela ne fonctionnera pas, alors vous devrez créer un répertoire temporaire pour héberger le fifo nommé jusqu'à ce que vous y soyez redirigé. Je ne connais pas les autres BSD.

La fonction suivante a été testée en utilisant GNU bash, version 4.4.19(1)-release (x86_64-pc-linux-gnu). Le système d'exploitation était Ubuntu 18. Cette fonction prend un seul paramètre qui est le descripteur de fichier souhaité pour le FIFO anonyme.

MakeFIFO() {
    local "MakeFIFO_upper=$(ulimit -n)" 
    if [[ $# -ne 1 || ${#1} -gt ${#MakeFIFO_upper} || -n ${1%%[0-9]*} || 10#$1 -le 2
        || 10#$1 -ge MakeFIFO_upper ]] || eval ! exec "$1<> " <(:) 2>"/dev/null"; then
        echo "$FUNCNAME: $1: Could not create FIFO" >&2
        return "1"
    fi
}

La fonction suivante a été testée en utilisant GNU bash, version 3.2.57(1)-release (x86_64-apple-darwin17). Le système d'exploitation était macOS High Sierra. Cette fonction démarre en créant un FIFO nommé dans un répertoire temporaire connu uniquement du processus qui l'a créé . Ensuite, le descripteur de fichier est redirigé vers le FIFO. Enfin, le FIFO est dissocié du nom de fichier en supprimant le répertoire temporaire. Cela rend le FIFO anonyme.

MakeFIFO() {
    MakeFIFO.SetStatus() {
        return "${1:-$?}"
    }
    MakeFIFO.CleanUp() {
        local "MakeFIFO_status=$?"
        rm -rf "${MakeFIFO_directory:-}"    
        unset "MakeFIFO_directory"
        MakeFIFO.SetStatus "$MakeFIFO_status" && true
        eval eval "${MakeFIFO_handler:-:}'; true'" 
    }
    local "MakeFIFO_success=false" "MakeFIFO_upper=$(ulimit -n)" "MakeFIFO_file=" 
    MakeFIFO_handler="$(trap -p EXIT)"
    MakeFIFO_handler="${MakeFIFO_handler#trap -- }"
    MakeFIFO_handler="${MakeFIFO_handler% *}"
    trap -- 'MakeFIFO.CleanUp' EXIT
    until "$MakeFIFO_success"; do
        [[ $# -eq 1 && ${#1} -le ${#MakeFIFO_upper} && -z ${1%%[0-9]*}
        && 10#$1 -gt 2 && 10#$1 -lt MakeFIFO_upper ]] || break
        MakeFIFO_directory=$(mktemp -d) 2>"/dev/null" || break
        MakeFIFO_file="$MakeFIFO_directory/pipe"
        mkfifo -m 600 $MakeFIFO_file 2>"/dev/null" || break
        ! eval ! exec "$1<> $MakeFIFO_file" 2>"/dev/null" || break
        MakeFIFO_success="true"
    done
    rm -rf "${MakeFIFO_directory:-}"
    unset  "MakeFIFO_directory"
    eval trap -- "$MakeFIFO_handler" EXIT
    unset  "MakeFIFO_handler"
    "$MakeFIFO_success" || { echo "$FUNCNAME: $1: Could not create FIFO" >&2; return "1"; }
}

Les fonctions ci-dessus peuvent être combinées en une seule fonction qui fonctionnera sur les deux systèmes d'exploitation. Voici un exemple d'une telle fonction. Ici, une tentative est faite pour créer un FIFO vraiment anonyme. En cas d'échec, un FIFO nommé est créé et converti en FIFO anonyme.

MakeFIFO() {
    MakeFIFO.SetStatus() {
        return "${1:-$?}"
    }
    MakeFIFO.CleanUp() {
        local "MakeFIFO_status=$?"
        rm -rf "${MakeFIFO_directory:-}"    
        unset "MakeFIFO_directory"
        MakeFIFO.SetStatus "$MakeFIFO_status" && true
        eval eval "${MakeFIFO_handler:-:}'; true'" 
    }
    local "MakeFIFO_success=false" "MakeFIFO_upper=$(ulimit -n)" "MakeFIFO_file=" 
    MakeFIFO_handler="$(trap -p EXIT)"
    MakeFIFO_handler="${MakeFIFO_handler#trap -- }"
    MakeFIFO_handler="${MakeFIFO_handler% *}"
    trap -- 'MakeFIFO.CleanUp' EXIT
    until "$MakeFIFO_success"; do
        [[ $# -eq 1 && ${#1} -le ${#MakeFIFO_upper} && -z ${1%%[0-9]*}
        && 10#$1 -gt 2 && 10#$1 -lt MakeFIFO_upper ]] || break
        if eval ! exec "$1<> " <(:) 2>"/dev/null"; then
            MakeFIFO_directory=$(mktemp -d) 2>"/dev/null" || break
            MakeFIFO_file="$MakeFIFO_directory/pipe"
            mkfifo -m 600 $MakeFIFO_file 2>"/dev/null" || break
            ! eval ! exec "$1<> $MakeFIFO_file" 2>"/dev/null" || break
        fi
        MakeFIFO_success="true"
    done
    rm -rf "${MakeFIFO_directory:-}"
    unset  "MakeFIFO_directory"
    eval trap -- "$MakeFIFO_handler" EXIT
    unset  "MakeFIFO_handler"
    "$MakeFIFO_success" || { echo "$FUNCNAME: $1: Could not create FIFO" >&2; return "1"; }
}

Voici un exemple de création d'un FIFO anonyme, puis d'écriture de texte dans le même FIFO.

fd="6"
MakeFIFO "$fd"
echo "Now is the" >&"$fd"
echo "time for all" >&"$fd"
echo "good men" >&"$fd"

Vous trouverez ci-dessous un exemple de lecture de l'intégralité du contenu de la FIFO anonyme.

echo "EOF" >&"$fd"
while read -u "$fd" message; do
    [[ $message != *EOF ]] || break
    echo "$message"
done

Cela produit la sortie suivante.

Now is the
time for all
good men

La commande ci-dessous ferme le FIFO anonyme.

eval exec "$fd>&-"

Références: la
création d'un canal anonyme pour une utilisation ultérieure Les
fichiers dans les répertoires accessibles en écriture sont une sécurité de script shell dangereuse

En utilisant la bonne et brillante réponse de htamas, je l'ai un peu modifiée pour l'utiliser dans une doublure, la voici:

# create a temporary named pipe
PIPE=(`(exec 0</dev/null 1</dev/null; (( read -d \  e < /proc/self/stat ; echo $e >&2 ; exec tail -f /dev/null 2> /dev/null ) | ( read -d \  e < /proc/self/stat ; echo $e  >&2 ; exec tail -f /dev/null 2> /dev/null )) &) 2>&1 | for ((i=0; i<2; i++)); do read e; printf "$e "; done`)
# attach it to file descriptors 3 and 4
exec 3>/proc/${PIPE[0]}/fd/1 4</proc/${PIPE[1]}/fd/0
...
# kill the temporary pids
kill ${PIPE[@]}
...
# anything we write to fd 3 can be read back from fd 4
echo 'Hello world!' >&3
head -n1 <&4
...
# close the file descriptor when we are finished (optional)
exec 3>&- 4<&-