Wie konvertiere ich in Bash 8 Bytes in ein vorzeichenloses Int (64-Bit-LE)?

Wie kann ich 8 Bytes als vorzeichenloses int (Little Endian) 'lesen / interpretieren' ?
Vielleicht gibt es dafür eine magische Bash-Fu-Konvertierung?

UPDATE:
Es scheint, dass bei der Interpretation meiner Frage etwas überkreuzt wurde. Hier ist ein breiteres Beispiel dafür, was ich versuche zu tun.

Ich möchte die ersten (und letzten) 64 KB einer Datei lesen. Jedes 8-Byte-Wort ist als vorzeichenlose 64-Bit-Little-Endian-Ganzzahl zu interpretieren. Diese Ganzzahlen sollen in einer Hashing-Berechnung verwendet werden, die die Datei eindeutig identifiziert. Es müssen also viele Berechnungen durchgeführt werden. ∴ Geschwindigkeit wird bevorzugt, ist aber nicht kritisch. (Warum mache ich das? Weil smplayerdie Namen der INI-Dateien für abgespielte Medien gehasht werden und ich auf diese Dateien zugreifen und sie ändern möchte, ahme ich den C ++ - Code des Smplayers in Bash nach.)

Eine Lösung, die das Akzeptieren einer Piped-Eingabe ermöglicht, wäre optimal und wahrscheinlich aufgrund der Art und Weise, wie Bash-Variablen \ x00 nicht verarbeiten können, von wesentlicher Bedeutung.

Mir ist klar, dass so etwas wahrscheinlich besser für Python, Perl und C / C ++ geeignet ist, aber ich kenne Python und Perl nicht, und obwohl ich es in C ++ tun könnte, ist es Jahre her, seit ich es verwendet habe Ich versuche mich auf Bash zu konzentrieren.

Kurze Perl- und Python-Schnipsel sind gut. Bash wird bevorzugt (aber nicht unter Geschwindigkeitseinbußen).

Bash ist das falsche Werkzeug. Muscheln können gut Teile zusammenkleben; Textverarbeitung und Arithmetik werden nebenbei bereitgestellt, und die Datenverarbeitung liegt überhaupt nicht in ihrem Zuständigkeitsbereich.

Ich würde Python über Perl wählen, weil Python auf Anhieb Bignums hat. Verwenden Sie struct.unpackdiese Option, um die Daten zu entpacken.

#!/usr/bin/env python
import os, struct, sys
fmt = "<" + "Q" * 8192
header_bytes = sys.stdin.read(65536)
header_ints = list(struct.unpack(fmt, header_bytes))
sys.stdin.seek(-65536, 2)
footer_bytes = sys.stdin.read(65536)
footer_ints = list(struct.unpack(fmt, header_bytes))
# your calculations here

Hier ist meine Antwort auf die ursprüngliche Frage. Die überarbeitete Frage hat nicht viel mit dem Original zu tun, bei dem es darum ging, eine 8-Byte-Sequenz in die 64-Bit-Ganzzahl umzuwandeln, die sie in Little-Endian-Reihenfolge darstellt.

Ich glaube nicht, dass bash eine eingebaute Funktion dafür hat. Das folgende Snippet wird aauf eine Zeichenfolge gesetzt, die die hexadezimale Darstellung der Zahl ist, die den Bytes in der angegebenen Zeichenfolge in Big-Endian- Reihenfolge entspricht.

a=0x$(printf "%s" "$string" |
      od -t x1 -An |
      tr -dc '[:alnum:]')

Kehren Sie für die Little-Endian-Reihenfolge die Reihenfolge der Bytes in der ursprünglichen Zeichenfolge um. In Bash und für eine Zeichenfolge bekannter Länge können Sie dies tun

a=0x$(printf "%s" "${string:7:1}${string:6:1}${string:5:1}${string:4:1}${string:3:1}${string:2:1}${string:1:1}${string:0:1}" |
      od -t x1 -An |
      tr -dc '[:alnum:]')

Sie können auch die bevorzugte Endianität Ihrer Plattform ermitteln, wenn Sie od8-Byte-Typen unterstützen.

a=0x$(printf "%s" "$string" |
      od -t x8 -An |
      tr -dc '[:alnum:]')

Ob Sie rechnen $akönnen, hängt davon ab, ob Ihre Bash 8-Byte-Arithmetik unterstützt. Selbst wenn dies der Fall ist, wird es als signierter Wert behandelt.

Alternativ können Sie Perl verwenden:

a=0x$(perl -e 'print unpack "Q<", $ARGV[0]' "$string")

Wenn Ihr Perl ohne 64-Bit-Integer-Unterstützung kompiliert wird, müssen Sie die Bytes aufteilen.

a=0x$(perl -e 'printf "%x%08x\n", reverse unpack "L<L<", $ARGV[0]' "$string")

(Ersetzen Sie es <durch >Big-Endian oder entfernen Sie es, um die Plattform-Endianness zu erhalten.)

Gilles 'Python-Methode ist definitiv schneller, aber ich dachte, ich würde diese * Bash *** + *** Standard-Single-Purpose-Tools * einfach als allgemeines Mahlgut in die Mühle werfen. Es geht wahrscheinlich genauso um' bc ' wie alles andere ... Es gibt eine Menge Initialisierungsmaterial, um Eingabedateien mit weniger als 64 KB zu berücksichtigen ... Der Hash wird auf die Länge der Datei initialisiert, und dann wird jede der 64-Bit-Ganzzahlen nacheinander hinzugefügt es; verursacht (erwarteten) Integer-Überlauf .. hat es bcgeschafft, den Trick zu machen ...

# This script reads 8196 8-byte blocks (64 KiB) from the head and tail of a file
# Each 8-bytes block is interpreted as an unsigned 64-bit Little-Endian integer.
# The head integers and tail integers ar printed to stdout; one integer per line.
#
# INIT: If the file is smaller than 64k, calculate the number of unsigned ints to read 
# ====
  file="$1"
  flen=($(du -b "$file"))           # file length
  qlen=8                            # ui64 length in bytes
    ((flen<qlen)) && exit 1         # file is too short -- exit 
  bmax=$((64*1024))                 # byte end of read (== byte max to read)
    ((flen<bmax)) && ((bmax=flen))  # reduce byte max to file length
  qmax=$((bmax/qlen))               # ui64 end of read (== ui64 max to read)
    (((qmax*qlen)<bmax)) && ((bmax=(qmax*qlen))) # round down byte max (/8)
  hash=$(echo $flen |xxd -p -u)
# 
# MAIN
# ====
  for skip in 0  $((flen-bmax)) ;do
    hash=$(dd if="$file" bs=1 count=$bmax skip=$skip 2>/dev/null |
             xxd -p -u -c 8 |
             { echo -e " ibase=16 \n obase=10 \n scale=0 \n hash=$hash \n ouint=10000000000000000 "; \
               sed -re "s/(..)(..)(..)(..)(..)(..)(..)(..)/hash=(hash+\8\7\6\5\4\3\2\1)%ouint/"; \
               echo "hash"; } |bc)
  done
  echo $hash
#

# Output:
16A6528E803325FF

Dies akzeptiert stdin und druckt die letzten 64 KB der Datei als vorzeichenlose 8-Byte-Hexadezimalzahlen in der Endianess des Computers (Little-Endian auf x86). Um die ersten 64 KB zu drucken, ersetzen Sie "Schwanz" durch "Kopf".

tail -c $(( 1024*64 )) | xxd -ps |tr -d '\n' | while read -N16 i ; do echo 0x$i ; done

EINSCHRÄNKUNGEN: Der Versuch, die Ausgabe mit printf in eine Dezimalzahl umzuwandeln, führt zu Fehlern außerhalb des Bereichs