Comment trouver des fichiers avec des caractères 100% NUL dans leur contenu?

Quelle est la commande de ligne de commande Linux qui peut identifier de tels fichiers?

AFAIK la findcommande (ou grep) ne peut correspondre qu'à une chaîne spécifique à l'intérieur du fichier texte. Mais je veux faire correspondre le contenu entier, c'est-à-dire que je veux voir quels fichiers correspondent à l'expression régulière \0+, en ignorant les caractères de fin de ligne . Peut-être que l' find . cat | grepidiome pourrait fonctionner, mais je ne sais pas comment faire grep en ignorant les lignes (et traiter le fichier comme binaire).

Contexte: Tous les quelques jours, lorsque mon ordinateur portable se bloque, ma partition btrfs perd des informations: les fichiers ouverts en écriture voient leur contenu remplacé par des zéros (la taille du fichier reste plus ou moins intacte). J'utilise la synchronisation et je ne veux pas que ces faux fichiers se propagent: j'ai besoin d'un moyen de les identifier afin de pouvoir les récupérer depuis la sauvegarde.

Vous pouvez greppour ␀ caractères en utilisant le mode regex Perl:

$ echo -ne "\0\0" > nul.bin
$ echo -ne "\0x\0" > non-nul.bin
$ grep -P "[^\0]" *.bin
Binary file non-nul.bin matches

Vous pouvez donc utiliser ceci:

for path in *.foo
do
    grep -P "[^\0]" "$path" || echo "$path"
done

Je suis d'accord avec ce que D_Bye dit sur la recherche de la racine du problème.

Quoi qu'il en soit pour vérifier si un fichier contient uniquement \0et / ou \nvous pouvez utiliser tr:

<file tr -d '\0\n' | wc -c

Qui renvoie 0 pour les fichiers null / newline et vides.

Je soupçonne que ces fichiers sont rares, c'est-à-dire qu'ils n'ont pas d'espace disque alloué, ils spécifient simplement une taille de fichier ( durapporterait 0 pour eux).

Dans ce cas, avec GNU find, vous pouvez faire (en supposant qu'aucun chemin de fichier ne contient de caractères de nouvelle ligne):

find . -type f -size +0 -printf '%b:%p\n' | grep '^0:' | cut -d: -f2-

Voici un petit programme python qui peut le faire:

import sys

def only_contains_nulls(fobj, chunk_size=1024):
    first = True
    while True:
        data = fobj.read(chunk_size)
        if not data:
            if first:
                return 1  # No data
            else:
                return 0
        if data.strip("\0"):
            return 1
        first = False

if __name__ == '__main__':
    with open(sys.argv[1]) as f:
        sys.exit(only_contains_nulls(f))

Et en action:

$ printf '\0\0\0' > file
$ ./onlynulls file && echo "Only nulls" || echo "Non-null characters"
Only nulls
$ printf a >> file
$ ./onlynulls file && echo "Only nulls" || echo "Non-null characters"
Non-null characters

Vous pouvez vérifier plusieurs fichiers en utilisant FIND -exec, xargs, GNU parallel, et des programmes similaires. Alternativement, cela imprimera les noms de fichiers qui doivent être traités:

files=( file1 file2 )
for file in "${files[@]}"; do
    ./onlynulls "$file" || printf '%s\n' "$file"
done

Gardez à l'esprit que si vous allez transmettre la sortie de ceci à un autre programme, les noms de fichiers peuvent contenir des sauts de ligne, vous devez donc les délimiter différemment (convenablement, avec \0).

Si vous avez beaucoup de fichiers, il serait préférable d'utiliser une option pour le traitement parallèle, car elle ne lit qu'un fichier à la fois.

Recherchez les fichiers qui contiennent uniquement des caractères nuls '\ 0' et des caractères de nouvelle ligne '\ n'.
Le qdans sed fait que chaque fichier recherche de quitter immédiatement à trouver un caractère non nul en ligne.

find -type f -name 'file-*' |
  while IFS= read -r file ;do 
      out=$(sed -n '1=; /^\x00\+$/d; i non-null
                      ; q' "$file")
      [[ $out == "1" ]] &&  echo "$file"
  done

Créer des fichiers de test

> file-empty
printf '%s\n' 'line1' 'line2' 'line3'      > file-with-text           
printf '%4s\n' '' '' xx | sed 's/ /\x00/g' > file-with-text-and-nulls
printf '%4s\n' '' '' '' | sed 's/ /\x00/g' > file-with-nulls-and-newlines
printf '%4s'   '' '' '' | sed 's/ /\x00/g' > file-with-nulls-only

production

./file-with-nulls-and-newlines
./file-with-nulls-only

Cette ligne unique est le moyen le plus efficace de trouver 100% des fichiers NUL en utilisant GNU find, xargset grep( en supposant que ce dernier est construit avec le soutien PCRE):

find . -type f -size +0 -readable -print0 |
  LC_ALL=C xargs -r0 grep -LP "[^\x00]" --

Les avantages de cette méthode par rapport aux autres réponses fournies sont:

• les fichiers non clairsemés sont inclus dans la recherche.
• les fichiers non lisibles ne sont pas transmis à grep, ce qui évite les Permission deniedavertissements.
• greparrêtera la lecture des données des fichiers après avoir trouvé un octet non nul ( LC_ALL=Cest utilisé pour s'assurer que chaque octet est interprété comme un caractère ).
• les fichiers vides (zéro octet) ne sont pas inclus dans les résultats.
• moins de grepprocessus vérifient efficacement plusieurs fichiers.
• les chemins contenant des sauts de ligne ou commençant par -sont traités correctement.
• fonctionne sur la plupart des systèmes embarqués qui manquent de Python / Perl.

Passer l' -Zoption grepet l'utiliser xargs -r0 ...permet d'effectuer d'autres actions sur les fichiers 100% nul (ex: nettoyage):

find . -type f -size +0 -readable -print0 |
  LC_ALL=C xargs -0 grep -ZLP "[^\x00]" -- |
  xargs -r0 rm --

Je recommande également d'utiliser les findoptions -Ppour éviter de suivre les liens symboliques et -xdevpour éviter de traverser les systèmes de fichiers (par exemple: montages distants, arborescences de périphériques, montages de liaison, etc.).

Pour ignorer les caractères de fin de ligne , la variante suivante devrait fonctionner (bien que je ne pense pas que ce soit une si bonne idée):

find . -type f -size +0 -readable -print0 |
  LC_ALL=C xargs -r0 grep -LP "[^\x00\r\n]" --

Tout rassembler, y compris la suppression des fichiers indésirables (caractères 100% nul / newline) pour les empêcher d'être sauvegardés:

find -P . -xdev -type f -size +0 -readable -print0 |
  LC_ALL=C xargs -0 grep -ZLP "[^\x00\r\n]" -- |
  xargs -0 rm --

Je ne recommande pas d'inclure des fichiers vides (zéro octet), ils existent souvent à des fins très spécifiques .

Pour utiliser GNU sed, vous pouvez utiliser l' -zoption, qui définit une ligne comme des chaînes terminées par zéro et correspond et supprime les lignes vides comme suit:

if [ "$( sed -z '/^$/d' "$file" | head -c 1 | wc -c )" -eq 0 ]; then
    echo "$file contains only NULL!"
fi

La commande head entre les deux n'est qu'une optimisation.

Python

Un seul fichier

Définissez l'alias:

alias is_binary="python -c 'import sys; sys.exit(not b\"\x00\" in open(sys.argv[1], \"rb\").read())'"

Essaye-le:

$ is_binary /etc/hosts; echo $?
1
$ is_binary `which which`; echo $?
0

Fichiers multiples

Recherchez tous les fichiers binaires de manière récursive:

IS_BINARY='import sys; sys.exit(not b"\x00" in open(sys.argv[1], "rb").read())'
find . -type f -exec bash -c "python -c '$IS_BINARY' {} && echo {}" \;

Pour rechercher tous les fichiers non binaires, modifiez &&avec ||.