From 3be31e79a87b15872a222d11714e1dc4046fad4d Mon Sep 17 00:00:00 2001 From: "Richard W.M. Jones" Date: Tue, 1 Apr 2008 19:10:45 +0000 Subject: [PATCH] Fixed byte swaps so that now ext3 superblock can be parsed. --- bitmatch.ml | 120 ++++++++++++++++++++++++++++++++++++++++++++++++++-- bitmatch.mli | 6 ++- pa_bitmatch.ml | 4 +- tests/.cvsignore | 1 + tests/70_ext3_sb.ml | 76 +++++++++++++++++++++++++++++++++ tests/ext3_sb | Bin 0 -> 1024 bytes 6 files changed, 202 insertions(+), 5 deletions(-) create mode 100644 tests/70_ext3_sb.ml create mode 100644 tests/ext3_sb diff --git a/bitmatch.ml b/bitmatch.ml index 0c9edc0..2cba403 100644 --- a/bitmatch.ml +++ b/bitmatch.ml @@ -1,5 +1,5 @@ (* Bitmatch library. - * $Id: bitmatch.ml,v 1.5 2008-04-01 17:05:37 rjones Exp $ + * $Id: bitmatch.ml,v 1.6 2008-04-01 19:10:45 rjones Exp $ *) open Printf @@ -44,6 +44,101 @@ let bitstring_of_file fname = let bitstring_length (_, _, len) = len (*----------------------------------------------------------------------*) +(* Bitwise functions. + * + * We try to isolate all bitwise functions within these modules. + *) + +module I = struct + (* Bitwise operations on ints. Note that we assume int <= 31 bits. *) + let (<<) = (lsl) + let (>>) = (lsr) + let one = 1 + let minus_one = -1 + let ff = 0xff + + (* Create a mask so many bits wide. *) + let mask bits = + if bits < 30 then + pred (one << bits) + else if bits = 30 then + max_int + else + minus_one + + (* Byte swap an int of a given size. *) + let byteswap v bits = + if bits <= 8 then v + else if bits <= 16 then ( + let shift = bits-8 in + let v1 = v >> shift in + let v2 = (v land (mask shift)) << 8 in + v2 lor v1 + ) else if bits <= 24 then ( + let shift = bits - 16 in + let v1 = v >> (8+shift) in + let v2 = ((v >> shift) land ff) << 8 in + let v3 = (v land (mask shift)) << 16 in + v3 lor v2 lor v1 + ) else ( + let shift = bits - 24 in + let v1 = v >> (16+shift) in + let v2 = ((v >> (8+shift)) land ff) << 8 in + let v3 = ((v >> shift) land ff) << 16 in + let v4 = (v land (mask shift)) << 24 in + v4 lor v3 lor v2 lor v1 + ) +end + +module I32 = struct + (* Bitwise operations on int32s. Note we try to keep it as similar + * as possible to the I module above, to make it easier to track + * down bugs. + *) + let (<<) = Int32.shift_left + let (>>) = Int32.shift_right_logical + let (land) = Int32.logand + let (lor) = Int32.logor + let pred = Int32.pred + let max_int = Int32.max_int + let one = Int32.one + let minus_one = Int32.minus_one + let ff = 0xff_l + + (* Create a mask so many bits wide. *) + let mask bits = + if bits < 31 then + pred (one << bits) + else if bits = 31 then + max_int + else + minus_one + + (* Byte swap an int of a given size. *) + let byteswap v bits = + if bits <= 8 then v + else if bits <= 16 then ( + let shift = bits-8 in + let v1 = v >> shift in + let v2 = (v land (mask shift)) << 8 in + v2 lor v1 + ) else if bits <= 24 then ( + let shift = bits - 16 in + let v1 = v >> (8+shift) in + let v2 = ((v >> shift) land ff) << 8 in + let v3 = (v land (mask shift)) << 16 in + v3 lor v2 lor v1 + ) else ( + let shift = bits - 24 in + let v1 = v >> (16+shift) in + let v2 = ((v >> (8+shift)) land ff) << 8 in + let v3 = ((v >> shift) land ff) << 16 in + let v4 = (v land (mask shift)) << 24 in + v4 lor v3 lor v2 lor v1 + ) +end + +(*----------------------------------------------------------------------*) (* Extraction functions. * * NB: internal functions, called from the generated macros, and @@ -146,6 +241,11 @@ let extract_int_be_unsigned data off len flen = ) in word, off+flen, len-flen +let extract_int_le_unsigned data off len flen = + let v, off, len = extract_int_be_unsigned data off len flen in + let v = I.byteswap v flen in + v, off, len + let _make_int32_be c0 c1 c2 c3 = Int32.logor (Int32.logor @@ -155,6 +255,15 @@ let _make_int32_be c0 c1 c2 c3 = (Int32.shift_left c2 8)) c3 +let _make_int32_le c0 c1 c2 c3 = + Int32.logor + (Int32.logor + (Int32.logor + (Int32.shift_left c3 24) + (Int32.shift_left c2 16)) + (Int32.shift_left c1 8)) + c0 + (* Extract exactly 32 bits. We have to consider endianness and signedness. *) let extract_int32_be_unsigned data off len flen = let byteoff = off lsr 3 in @@ -187,6 +296,11 @@ let extract_int32_be_unsigned data off len flen = ) in word, off+flen, len-flen +let extract_int32_le_unsigned data off len flen = + let v, off, len = extract_int32_be_unsigned data off len flen in + let v = I32.byteswap v flen in + v, off, len + let _make_int64_be c0 c1 c2 c3 c4 c5 c6 c7 = Int64.logor (Int64.logor @@ -426,6 +540,6 @@ let hexdump_bitstring chan (data, off, len) = if !linelen > 0 then ( let skip = (16 - !linelen) * 3 + if !linelen < 8 then 1 else 0 in for i = 0 to skip-1 do fprintf chan " " done; - fprintf chan " |%s|\n" linechars + fprintf chan " |%s|\n%!" linechars ) else - fprintf chan "\n" + fprintf chan "\n%!" diff --git a/bitmatch.mli b/bitmatch.mli index d2afc30..7ed9e63 100644 --- a/bitmatch.mli +++ b/bitmatch.mli @@ -1,5 +1,5 @@ (* Bitmatch library. - * $Id: bitmatch.mli,v 1.5 2008-04-01 17:05:37 rjones Exp $ + * $Id: bitmatch.mli,v 1.6 2008-04-01 19:10:45 rjones Exp $ *) exception Construct_failure of string * string * int * int @@ -46,8 +46,12 @@ val extract_char_unsigned : string -> int -> int -> int -> int * int * int val extract_int_be_unsigned : string -> int -> int -> int -> int * int * int +val extract_int_le_unsigned : string -> int -> int -> int -> int * int * int + val extract_int32_be_unsigned : string -> int -> int -> int -> int32 * int * int +val extract_int32_le_unsigned : string -> int -> int -> int -> int32 * int * int + val extract_int64_be_unsigned : string -> int -> int -> int -> int64 * int * int val construct_bit : Buffer.t -> bool -> int -> unit diff --git a/pa_bitmatch.ml b/pa_bitmatch.ml index f25a49d..6673a21 100644 --- a/pa_bitmatch.ml +++ b/pa_bitmatch.ml @@ -1,5 +1,5 @@ (* Bitmatch syntax extension. - * $Id: pa_bitmatch.ml,v 1.4 2008-04-01 17:05:37 rjones Exp $ + * $Id: pa_bitmatch.ml,v 1.5 2008-04-01 19:10:45 rjones Exp $ *) open Printf @@ -551,6 +551,8 @@ let output_bitmatch _loc bs cases = Printf.eprintf "PA_BITMATCH: TEST:\n"; Printf.eprintf " %s\n" $str:field$; Printf.eprintf " off %d len %d\n%!" $lid:off$ $lid:len$; + (*Bitmatch.hexdump_bitstring stderr + ($lid:data$,$lid:off$,$lid:len$);*) ); $expr$ >> diff --git a/tests/.cvsignore b/tests/.cvsignore index b4fbc01..8ca81f0 100644 --- a/tests/.cvsignore +++ b/tests/.cvsignore @@ -12,3 +12,4 @@ 10_constr1 20_varsize 60_ping +70_ext3_sb diff --git a/tests/70_ext3_sb.ml b/tests/70_ext3_sb.ml new file mode 100644 index 0000000..e8cebb4 --- /dev/null +++ b/tests/70_ext3_sb.ml @@ -0,0 +1,76 @@ +(* Parse an ext3 superblock. + * $Id: 70_ext3_sb.ml,v 1.1 2008-04-01 19:10:45 rjones Exp $ + *) + +open Printf + +(*let () = Bitmatch.debug := true*) + +let bits = Bitmatch.bitstring_of_file "tests/ext3_sb" + +(* The structure is straight from /usr/include/linux/ext3_fs.h *) + +let () = + bitmatch bits with + | s_inodes_count : 32 : littleendian; (* Inodes count *) + s_blocks_count : 32 : littleendian; (* Blocks count *) + s_r_blocks_count : 32 : littleendian; (* Reserved blocks count *) + s_free_blocks_count : 32 : littleendian; (* Free blocks count *) + s_free_inodes_count : 32 : littleendian; (* Free inodes count *) + s_first_data_block : 32 : littleendian; (* First Data Block *) + s_log_block_size : 32 : littleendian; (* Block size *) + s_log_frag_size : 32 : littleendian; (* Fragment size *) + s_blocks_per_group : 32 : littleendian; (* # Blocks per group *) + s_frags_per_group : 32 : littleendian; (* # Fragments per group *) + s_inodes_per_group : 32 : littleendian; (* # Inodes per group *) + s_mtime : 32 : littleendian; (* Mount time *) + s_wtime : 32 : littleendian; (* Write time *) + s_mnt_count : 16 : littleendian; (* Mount count *) + s_max_mnt_count : 16 : littleendian; (* Maximal mount count *) + 0xef53 : 16 : littleendian; (* Magic signature *) + s_state : 16 : littleendian; (* File system state *) + s_errors : 16 : littleendian; (* Behaviour when detecting errors *) + s_minor_rev_level : 16 : littleendian; (* minor revision level *) + s_lastcheck : 32 : littleendian; (* time of last check *) + s_checkinterval : 32 : littleendian; (* max. time between checks *) + s_creator_os : 32 : littleendian; (* OS *) + s_rev_level : 32 : littleendian; (* Revision level *) + s_def_resuid : 16 : littleendian; (* Default uid for reserved blocks *) + s_def_resgid : 16 : littleendian; (* Default gid for reserved blocks *) + s_first_ino : 32 : littleendian; (* First non-reserved inode *) + s_inode_size : 16 : littleendian; (* size of inode structure *) + s_block_group_nr : 16 : littleendian; (* block group # of this superblock *) + s_feature_compat : 32 : littleendian; (* compatible feature set *) + s_feature_incompat : 32 : littleendian; (* incompatible feature set *) + s_feature_ro_compat : 32 : littleendian; (* readonly-compatible feature set *) + s_uuid : 128 : bitstring; (* 128-bit uuid for volume *) + s_volume_name : 128 : bitstring; (* volume name XXX string *) + s_last_mounted : 512 : bitstring; (* directory where last mounted XXX string *) + s_algorithm_usage_bitmap : 32 : littleendian; (* For compression *) + s_prealloc_blocks : 8; (* Nr of blocks to try to preallocate*) + s_prealloc_dir_blocks : 8; (* Nr to preallocate for dirs *) + s_reserved_gdt_blocks : 16 : littleendian; (* Per group desc for online growth *) + s_journal_uuid : 128 : bitstring; (* uuid of journal superblock *) + s_journal_inum : 32 : littleendian; (* inode number of journal file *) + s_journal_dev : 32 : littleendian; (* device number of journal file *) + s_last_orphan : 32 : littleendian; (* start of list of inodes to delete *) + s_hash_seed0 : 32 : littleendian; (* HTREE hash seed *) + s_hash_seed1 : 32 : littleendian; + s_hash_seed2 : 32 : littleendian; + s_hash_seed3 : 32 : littleendian; + s_def_hash_version : 8; (* Default hash version to use *) + s_reserved_char_pad : 8; + s_reserved_word_pad : 16 : littleendian; + s_default_mount_opts : 32 : littleendian; + s_first_meta_bg : 32 : littleendian; (* First metablock block group *) + s_reserved : 6080 : bitstring -> (* Padding to the end of the block *) + + printf "ext3 superblock:\n"; + printf " s_inodes_count = %ld\n" s_inodes_count; + printf " s_blocks_count = %ld\n" s_blocks_count; + printf " s_free_inodes_count = %ld\n" s_free_inodes_count; + printf " s_free_blocks_count = %ld\n" s_free_blocks_count + + | _ -> + eprintf "not an ext3 superblock!\n%!"; + exit 2 diff --git a/tests/ext3_sb b/tests/ext3_sb new file mode 100644 index 0000000000000000000000000000000000000000..3cbc044f516868c3d878176e3bc53ac189566b88 GIT binary patch literal 1024 zcmb0*!oc7oz|3H-&cJXqj)~#fVFm_91|*;WWCQUHb_Rx*7v8voFdxJJ|H1DW!RijK ziFJpmhUw!53N!$*4G^;dF-Y8_BIMSA9vAPaQ>2?2HoO+mPs-0P0g6)@z?=X#mIKaW zU|12Dw1WATm&&YDzL5#lrR_{W)jUvnkU#jC7#R40SOACxfmjHLg@ITEh(&=|42Z>n iSOSP8fmjNNrJ0c|U~oX@fY}%h!cZ|PFd6~_7XkoJRV9Z2 literal 0 HcmV?d00001 -- 1.8.3.1