Trong bash, làm thế nào để chuyển đổi 8 byte thành int không dấu (64 bit LE)?

Làm cách nào tôi có thể 'đọc / giải thích' 8 byte dưới dạng int không dấu (Little Endian) ?
Có lẽ có một chuyển đổi ma thuật Bash-fu cho điều này?

CẬP NHẬT:
Có vẻ như một cái gì đó có dây chéo trong việc giải thích câu hỏi của tôi. Đây là một ví dụ rộng hơn về những gì tôi đang cố gắng làm.

Tôi muốn đọc 64k đầu tiên (và cuối cùng) của một tệp. Mỗi từ 8 byte sẽ được hiểu là một số nguyên không dấu Little-Endian 64 bit. Các số nguyên này sẽ được sử dụng trong tính toán băm xác định duy nhất tệp. Vì vậy, có rất nhiều tính toán để thực hiện, ∴ tốc độ được ưa thích, nhưng không quan trọng. (Tại sao tôi lại làm việc đó? Bởi vì smplayerbăm tên các file của mình chơi phương tiện truyền thông .ini, và tôi muốn truy cập và sửa đổi những tập tin này, vì vậy tôi đang bắt chước C ++ của SMPlayer trong Bash.)

Một giải pháp phục vụ cho việc chấp nhận đầu vào có đường ống sẽ là tối ưu và có lẽ là điều cần thiết vì cách các biến Bash không thể xử lý \ x00 ..

Tôi nhận ra rằng một cái gì đó như thế này có lẽ phù hợp hơn với những thứ như Python, Perl và C / C ++, nhưng tôi không biết Python và Perl, và mặc dù tôi có thể làm điều đó trong C ++, đã nhiều năm kể từ khi tôi sử dụng nó và tôi đang cố tập trung vào Bash.

Đoạn ngắn Perl và Python là tốt. Bash được ưa thích (nhưng không phải hy sinh tốc độ).

Bash là công cụ sai hoàn toàn. Vỏ rất tốt trong việc dán các mảnh và mảnh lại với nhau; xử lý văn bản và số học được cung cấp ở bên cạnh, và xử lý dữ liệu hoàn toàn không nằm trong tầm nhìn của họ.

Tôi sẽ tìm Python trên Perl, bởi vì Python có bignums ngay lập tức. Sử dụng struct.unpackđể giải nén dữ liệu.

#!/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

Đây là câu trả lời của tôi cho câu hỏi ban đầu. Câu hỏi sửa đổi không liên quan nhiều đến bản gốc, đó là về việc chuyển đổi một chuỗi 8 byte thành số nguyên 64 bit mà nó đại diện theo thứ tự cuối nhỏ.

Tôi không nghĩ bash có bất kỳ tính năng tích hợp nào cho việc này. Đoạn mã sau đặt athành một chuỗi là biểu diễn thập lục phân của số tương ứng với các byte trong chuỗi đã chỉ định theo thứ tự cuối lớn .

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

Đối với thứ tự endian nhỏ, đảo ngược thứ tự của các byte trong chuỗi gốc. Trong bash, và với một chuỗi có độ dài đã biết, bạn có thể làm

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:]')

Bạn cũng có thể nhận được tính xác thực ưa thích của nền tảng nếu odhỗ trợ các loại 8 byte.

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

Việc bạn có thể thực hiện số học hay không $asẽ tùy thuộc vào việc bash của bạn có hỗ trợ số học 8 byte hay không. Ngay cả nếu có, nó sẽ coi nó như một giá trị đã ký.

Ngoài ra, sử dụng Perl:

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

Nếu perl của bạn được biên dịch mà không có hỗ trợ số nguyên 64 bit, bạn sẽ cần phải chia nhỏ các byte.

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

(Thay thế <bằng >endian lớn hoặc loại bỏ nó để có được endianness nền tảng.)

Phương pháp python của Gilles chắc chắn là nhanh hơn, nhưng tôi nghĩ rằng tôi chỉ cần ném vào * bash *** + *** std-single-aim-tools * này như là một công cụ chuyên nghiệp cho nhà máy .. Có lẽ nhiều về 'bc ' như mọi thứ khác ... Nó có rất nhiều công cụ Khởi tạo, để phục vụ cho các tệp đầu vào có giá trị dưới 64k ... Hàm băm được khởi tạo theo chiều dài của tệp và sau đó từng số nguyên 64 bit được thêm vào nó; gây ra tràn số nguyên (dự kiến) .. bcđược quản lý để thực hiện thủ thuật ...

# 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

Điều này chấp nhận stdin và in 64kB cuối cùng của tệp dưới dạng số nguyên thập lục phân 8 byte không dấu trong phần cuối của máy (endian trên x86). Để in 64kB đầu tiên, thay thế 'đuôi' bằng 'đầu'

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

GIỚI HẠN: cố gắng chuyển đổi đầu ra thành số thập phân bằng printf sẽ dẫn đến các lỗi ngoài phạm vi