Come trovare i file con il 100% di caratteri NUL nei loro contenuti?

Qual è il comando da riga di comando di Linux che può identificare tali file?

AFAIK il findcomando (o grep) può corrispondere solo a una stringa specifica all'interno del file di testo. Ma voglio abbinare l'intero contenuto, cioè voglio vedere quali file corrispondono all'espressione regolare \0+, ignorando i caratteri di fine riga . Forse il find . cat | greplinguaggio potrebbe funzionare, ma non so come fare in modo che grep ignori le righe (e tratti il ​​file come binario).

Background: ogni pochi giorni, quando il mio laptop si blocca, la mia partizione btrfs perde informazioni: i file aperti per la scrittura vengono sostituiti con zero (la dimensione del file rimane più o meno intatta). Uso la sincronizzazione e non desidero propagare questi file falsi: ho bisogno di un modo per identificarli in modo da poterli catturare dal backup.

Puoi grepper ␀ personaggi usando la modalità 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

Quindi puoi usare questo:

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

Sono d'accordo con ciò che dice D_Bye sulla ricerca della radice del problema.

In ogni caso per verificare se un file contiene solo \0e / o \nè possibile utilizzare tr:

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

Che restituisce 0 per null / newline e file vuoti.

Ho il sospetto che quei file siano sparsi, cioè che non abbiano spazio su disco assegnato a loro, semplicemente specificano una dimensione del file ( dusegnalerebbe 0 per loro).

Nel qual caso, con GNU find, potresti farlo (supponendo che nessun percorso di file contenga caratteri di nuova riga):

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

Ecco un piccolo programma Python che può farlo:

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))

E in azione:

$ 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

È possibile selezionare più file utilizzando find delle -exec, xargs, GNU parallel, e programmi simili. In alternativa, verranno stampati i nomi dei file che devono essere trattati:

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

Tieni presente che se hai intenzione di passare l'output di questo ad un altro programma, i nomi dei file possono contenere nuove righe, quindi dovresti delimitarli in modo diverso (opportunamente, con \0).

Se hai molti file, sarebbe meglio usare un'opzione per l'elaborazione parallela, poiché questa legge solo un file alla volta.

Trova i file che contengono solo caratteri null '\ 0' e caratteri newline '\ n'.
L' qin sed cause ogni file cerca di smettere immediatamente su di trovare qualsiasi carattere non nullo in una linea.

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

Crea file di 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

produzione

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

Questa one-liner è il modo più efficace per trovare i file nul 100% utilizzando GNU find, xargse grep(supponendo che quest'ultimo è costruito con il supporto PCRE):

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

I vantaggi di questo metodo rispetto ad altre risposte fornite sono:

• i file non sparsi sono inclusi nella ricerca.
• i file non leggibili non vengono passati a grep, evitando Permission deniedavvisi.
• grepinterromperà la lettura dei dati dai file dopo aver trovato un byte diverso da zero ( LC_ALL=Cviene utilizzato per assicurarsi che ogni byte sia interpretato come un carattere ).
• i file vuoti (zero byte) non sono inclusi nei risultati.
• meno grepprocessi controllano in modo efficiente più file.
• i percorsi che contengono newline o che iniziano con -sono gestiti correttamente.
• funziona sulla maggior parte dei sistemi embedded privi di Python / Perl.

Passare l' -Zopzione ae greputilizzare xargs -r0 ...consente di eseguire ulteriori azioni sui file nul al 100% (ad esempio: cleanup):

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

Consiglio inoltre di utilizzare le findopzioni -Pper evitare i seguenti collegamenti simbolici ed -xdevevitare di attraversare i filesystem (ad es. Montaggi remoti, alberi dei dispositivi, montaggi di bind, ecc.).

Per ignorare i caratteri di fine riga , la seguente variante dovrebbe funzionare (anche se non penso che sia una buona idea):

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

Mettendo tutto insieme, inclusa la rimozione dei file indesiderati (100% caratteri nul / newline) per impedire il backup:

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

Non consiglio di includere file vuoti (zero byte), spesso esistono per scopi molto specifici .

Per usare GNU sed puoi usare l' -zopzione, che definisce una linea come stringhe con terminazione zero e cerca ed elimina le righe vuote in questo modo:

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

Il comando head in mezzo è solo un'ottimizzazione.

Pitone

File singolo

Definisci l'alias:

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

Provalo:

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

Più file

Trova ricorsivamente tutti i file binari:

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 {}" \;

Per trovare tutti i file non binari, cambia &&con ||.