Class: CFPropertyList::Binary
- Inherits:
-
Object
- Object
- CFPropertyList::Binary
- Defined in:
- lib/cfpropertylist/rbBinaryCFPropertyList.rb
Overview
Binary PList parser class
Class Method Summary collapse
- .ascii_string?(str) ⇒ Boolean
-
.bytes_needed(count) ⇒ Object
calculate how many bytes are needed to save
count
. -
.charset_convert(str, from, to = "UTF-8") ⇒ Object
Convert the given string from one charset to another.
-
.charset_strlen(str, charset = "UTF-8") ⇒ Object
Count characters considering character set.
- .pack_int_array_with_size(nbytes, array) ⇒ Object
-
.pack_it_with_size(nbytes, int) ⇒ Object
pack an
int
ofnbytes
with size. -
.type_bytes(type, length) ⇒ Object
Create a type byte for binary format as defined by apple.
Instance Method Summary collapse
-
#array_to_binary(val) ⇒ Object
Convert array to binary format and add it to the object table.
-
#bool_to_binary(val) ⇒ Object
Convert a bool value to binary and add it to the object table.
- #count_object_refs(object) ⇒ Object
-
#data_to_binary(val) ⇒ Object
Convert data value to binary format and add it to the object table.
-
#date_to_binary(val) ⇒ Object
Convert date value (apple format) to binary and adds it to the object table.
-
#dict_to_binary(val) ⇒ Object
Convert dictionary to binary format and add it to the object table.
-
#int_to_binary(value) ⇒ Object
Codes an integer to binary format.
-
#load(opts) ⇒ Object
Read a binary plist file.
-
#num_to_binary(value) ⇒ Object
Converts a numeric value to binary and adds it to the object table.
- #object_ref_size(object_refs) ⇒ Object
- #read_fd(fd, length) ⇒ Object
-
#real_to_binary(val) ⇒ Object
Codes a real value to binary format.
-
#string_to_binary(val) ⇒ Object
Uniques and transforms a string value to binary format and adds it to the object table.
-
#to_str(opts = {}) ⇒ Object
Convert CFPropertyList to binary format; since we have to count our objects we simply unique CFDictionary and CFArray.
- #uid_to_binary(value) ⇒ Object
- #unpack_with_size(nbytes, buff) ⇒ Object
Class Method Details
.ascii_string?(str) ⇒ Boolean
441 442 443 444 445 446 447 |
# File 'lib/cfpropertylist/rbBinaryCFPropertyList.rb', line 441 def Binary.ascii_string?(str) if str.respond_to?(:ascii_only?) str.ascii_only? else str !~ /[\x80-\xFF]/mn end end |
.bytes_needed(count) ⇒ Object
calculate how many bytes are needed to save count
387 388 389 390 391 392 393 394 395 396 |
# File 'lib/cfpropertylist/rbBinaryCFPropertyList.rb', line 387 def Binary.bytes_needed(count) case when count < 2**8 then 1 when count < 2**16 then 2 when count < 2**32 then 4 when count < 2**64 then 8 else raise CFFormatError.new("Data size too large: #{count}") end end |
.charset_convert(str, from, to = "UTF-8") ⇒ Object
Convert the given string from one charset to another
216 217 218 219 |
# File 'lib/cfpropertylist/rbBinaryCFPropertyList.rb', line 216 def Binary.charset_convert(str,from,to="UTF-8") return str.dup.force_encoding(from).encode(to) if str.respond_to?("encode") Iconv.conv(to,from,str) end |
.charset_strlen(str, charset = "UTF-8") ⇒ Object
Count characters considering character set
222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 |
# File 'lib/cfpropertylist/rbBinaryCFPropertyList.rb', line 222 def Binary.charset_strlen(str,charset="UTF-8") if str.respond_to?(:encode) size = str.length else utf8_str = Iconv.conv("UTF-8",charset,str) size = utf8_str.scan(/./mu).size end # UTF-16 code units in the range D800-DBFF are the beginning of # a surrogate pair, and count as one additional character for # length calculation. if charset =~ /^UTF-16/ if str.respond_to?(:encode) str.bytes.to_a.each_slice(2) { |pair| size += 1 if (0xd8..0xdb).include?(pair[0]) } else str.split('').each_slice(2) { |pair| size += 1 if ("\xd8".."\xdb").include?(pair[0]) } end end size end |
.pack_int_array_with_size(nbytes, array) ⇒ Object
374 375 376 377 378 379 380 381 382 383 384 |
# File 'lib/cfpropertylist/rbBinaryCFPropertyList.rb', line 374 def Binary.pack_int_array_with_size(nbytes, array) case nbytes when 1 then array.pack('C*') when 2 then array.pack('n*') when 4 then array.pack('N*') when 8 array.map { |int| [int >> 32, int & 0xFFFFFFFF].pack('NN') }.join else raise CFFormatError.new("Don't know how to pack #{nbytes} byte integer") end end |
.pack_it_with_size(nbytes, int) ⇒ Object
pack an int
of nbytes
with size
362 363 364 365 366 367 368 369 370 371 372 |
# File 'lib/cfpropertylist/rbBinaryCFPropertyList.rb', line 362 def Binary.pack_it_with_size(nbytes,int) case nbytes when 1 then [int].pack('c') when 2 then [int].pack('n') when 4 then [int].pack('N') when 8 [int >> 32, int & 0xFFFFFFFF].pack('NN') else raise CFFormatError.new("Don't know how to pack #{nbytes} byte integer") end end |
.type_bytes(type, length) ⇒ Object
Create a type byte for binary format as defined by apple
399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 |
# File 'lib/cfpropertylist/rbBinaryCFPropertyList.rb', line 399 def Binary.type_bytes(type, length) if length < 15 [(type << 4) | length].pack('C') else bytes = [(type << 4) | 0xF] if length <= 0xFF bytes.push(0x10, length).pack('CCC') # 1 byte length elsif length <= 0xFFFF bytes.push(0x11, length).pack('CCn') # 2 byte length elsif length <= 0xFFFFFFFF bytes.push(0x12, length).pack('CCN') # 4 byte length elsif length <= 0x7FFFFFFFFFFFFFFF bytes.push(0x13, length >> 32, length & 0xFFFFFFFF).pack('CCNN') # 8 byte length else raise CFFormatError.new("Integer too large: #{int}") end end end |
Instance Method Details
#array_to_binary(val) ⇒ Object
Convert array to binary format and add it to the object table
561 562 563 564 565 566 567 568 569 570 571 572 573 |
# File 'lib/cfpropertylist/rbBinaryCFPropertyList.rb', line 561 def array_to_binary(val) saved_object_count = @written_object_count @written_object_count += 1 #@object_refs += val.value.size values = val.value.map { |v| v.to_binary(self) } bdata = Binary.type_bytes(0b1010, val.value.size) << Binary.pack_int_array_with_size(object_ref_size(@object_refs), values) @object_table[saved_object_count] = bdata saved_object_count end |
#bool_to_binary(val) ⇒ Object
Convert a bool value to binary and add it to the object table
544 545 546 547 548 549 |
# File 'lib/cfpropertylist/rbBinaryCFPropertyList.rb', line 544 def bool_to_binary(val) @object_table[@written_object_count] = val ? "\x9" : "\x8" # 0x9 is 1001, type indicator for true; 0x8 is 1000, type indicator for false @written_object_count += 1 @written_object_count - 1 end |
#count_object_refs(object) ⇒ Object
418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 |
# File 'lib/cfpropertylist/rbBinaryCFPropertyList.rb', line 418 def count_object_refs(object) case object when CFArray contained_refs = 0 object.value.each do |element| if CFArray === element || CFDictionary === element contained_refs += count_object_refs(element) end end return object.value.size + contained_refs when CFDictionary contained_refs = 0 object.value.each_value do |value| if CFArray === value || CFDictionary === value contained_refs += count_object_refs(value) end end return object.value.keys.size * 2 + contained_refs else return 0 end end |
#data_to_binary(val) ⇒ Object
Convert data value to binary format and add it to the object table
552 553 554 555 556 557 558 |
# File 'lib/cfpropertylist/rbBinaryCFPropertyList.rb', line 552 def data_to_binary(val) @object_table[@written_object_count] = (Binary.type_bytes(0b0100, val.bytesize) << val) @written_object_count += 1 @written_object_count - 1 end |
#date_to_binary(val) ⇒ Object
Convert date value (apple format) to binary and adds it to the object table
533 534 535 536 537 538 539 540 541 |
# File 'lib/cfpropertylist/rbBinaryCFPropertyList.rb', line 533 def date_to_binary(val) val = val.getutc.to_f - CFDate::DATE_DIFF_APPLE_UNIX # CFDate is a real, number of seconds since 01/01/2001 00:00:00 GMT @object_table[@written_object_count] = (Binary.type_bytes(0b0011, 3) << [val].pack("E").reverse) @written_object_count += 1 @written_object_count - 1 end |
#dict_to_binary(val) ⇒ Object
Convert dictionary to binary format and add it to the object table
576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 |
# File 'lib/cfpropertylist/rbBinaryCFPropertyList.rb', line 576 def dict_to_binary(val) saved_object_count = @written_object_count @written_object_count += 1 #@object_refs += val.value.keys.size * 2 keys_and_values = val.value.keys.map { |k| CFString.new(k).to_binary(self) } keys_and_values.concat(val.value.values.map { |v| v.to_binary(self) }) bdata = Binary.type_bytes(0b1101,val.value.size) << Binary.pack_int_array_with_size(object_ref_size(@object_refs), keys_and_values) @object_table[saved_object_count] = bdata return saved_object_count end |
#int_to_binary(value) ⇒ Object
Codes an integer to binary format
471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 |
# File 'lib/cfpropertylist/rbBinaryCFPropertyList.rb', line 471 def int_to_binary(value) # Note: nbytes is actually an exponent. number of bytes = 2**nbytes. nbytes = 0 nbytes = 1 if value > 0xFF # 1 byte unsigned integer nbytes += 1 if value > 0xFFFF # 4 byte unsigned integer nbytes += 1 if value > 0xFFFFFFFF # 8 byte unsigned integer nbytes += 1 if value > 0x7FFFFFFFFFFFFFFF # 8 byte unsigned integer, stored in lower half of 16 bytes nbytes = 3 if value < 0 # signed integers always stored in 8 bytes Binary.type_bytes(0b0001, nbytes) << if nbytes < 4 [value].pack(["C", "n", "N", "q>"][nbytes]) else # nbytes == 4 [0,value].pack("Q>Q>") end end |
#load(opts) ⇒ Object
Read a binary plist file
9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 |
# File 'lib/cfpropertylist/rbBinaryCFPropertyList.rb', line 9 def load(opts) @unique_table = {} @count_objects = 0 @object_refs = 0 @written_object_count = 0 @object_table = [] @object_ref_size = 0 @offsets = [] fd = nil if(opts.has_key?(:file)) fd = File.open(opts[:file],"rb") file = opts[:file] else fd = StringIO.new(opts[:data],"rb") file = "<string>" end # first, we read the trailer: 32 byte from the end fd.seek(-32,IO::SEEK_END) buff = fd.read(32) offset_size, object_ref_size, number_of_objects, top_object, table_offset = buff.unpack "x6CCx4Nx4Nx4N" # after that, get the offset table fd.seek(table_offset, IO::SEEK_SET) coded_offset_table = fd.read(number_of_objects * offset_size) raise CFFormatError.new("#{file}: Format error!") unless coded_offset_table.bytesize == number_of_objects * offset_size @count_objects = number_of_objects # decode offset table if(offset_size != 3) formats = ["","C*","n*","","N*"] @offsets = coded_offset_table.unpack(formats[offset_size]) else @offsets = coded_offset_table.unpack("C*").each_slice(3).map { |x,y,z| (x << 16) | (y << 8) | z } end @object_ref_size = object_ref_size val = read_binary_object_at(file,fd,top_object) fd.close val end |
#num_to_binary(value) ⇒ Object
Converts a numeric value to binary and adds it to the object table
494 495 496 497 498 499 500 501 502 503 504 |
# File 'lib/cfpropertylist/rbBinaryCFPropertyList.rb', line 494 def num_to_binary(value) @object_table[@written_object_count] = if value.is_a?(CFInteger) int_to_binary(value.value) else real_to_binary(value.value) end @written_object_count += 1 @written_object_count - 1 end |
#object_ref_size(object_refs) ⇒ Object
107 108 109 |
# File 'lib/cfpropertylist/rbBinaryCFPropertyList.rb', line 107 def object_ref_size object_refs Binary.bytes_needed(object_refs) end |
#read_fd(fd, length) ⇒ Object
203 204 205 |
# File 'lib/cfpropertylist/rbBinaryCFPropertyList.rb', line 203 def read_fd fd, length length > 0 ? fd.read(length) : "" end |
#real_to_binary(val) ⇒ Object
Codes a real value to binary format
489 490 491 |
# File 'lib/cfpropertylist/rbBinaryCFPropertyList.rb', line 489 def real_to_binary(val) Binary.type_bytes(0b0010,3) << [val].pack("E").reverse end |
#string_to_binary(val) ⇒ Object
Uniques and transforms a string value to binary format and adds it to the object table
450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 |
# File 'lib/cfpropertylist/rbBinaryCFPropertyList.rb', line 450 def string_to_binary(val) val = val.to_s @unique_table[val] ||= begin if !Binary.ascii_string?(val) val = Binary.charset_convert(val,"UTF-8","UTF-16BE") bdata = Binary.type_bytes(0b0110, Binary.charset_strlen(val,"UTF-16BE")) val.force_encoding("ASCII-8BIT") if val.respond_to?("encode") @object_table[@written_object_count] = bdata << val else bdata = Binary.type_bytes(0b0101,val.bytesize) @object_table[@written_object_count] = bdata << val end @written_object_count += 1 @written_object_count - 1 end end |
#to_str(opts = {}) ⇒ Object
Convert CFPropertyList to binary format; since we have to count our objects we simply unique CFDictionary and CFArray
61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 |
# File 'lib/cfpropertylist/rbBinaryCFPropertyList.rb', line 61 def to_str(opts={}) @unique_table = {} @count_objects = 0 @object_refs = 0 @written_object_count = 0 @object_table = [] @offsets = [] binary_str = "bplist00" @object_refs = count_object_refs(opts[:root]) opts[:root].to_binary(self) next_offset = 8 offsets = @object_table.map do |object| offset = next_offset next_offset += object.bytesize offset end binary_str << @object_table.join table_offset = next_offset offset_size = Binary.bytes_needed(table_offset) if offset_size < 8 # Fast path: encode the entire offset array at once. binary_str << offsets.pack((%w(C n N N)[offset_size - 1]) + '*') else # Slow path: host may be little or big endian, must pack each offset # separately. offsets.each do |offset| binary_str << "#{Binary.pack_it_with_size(offset_size,offset)}" end end binary_str << [offset_size, object_ref_size(@object_refs)].pack("x6CC") binary_str << [@object_table.size].pack("x4N") binary_str << [0].pack("x4N") binary_str << [table_offset].pack("x4N") binary_str end |
#uid_to_binary(value) ⇒ Object
506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 |
# File 'lib/cfpropertylist/rbBinaryCFPropertyList.rb', line 506 def uid_to_binary(value) nbytes = 0 nbytes = 1 if value > 0xFF # 1 byte integer nbytes += 1 if value > 0xFFFF # 4 byte integer nbytes += 1 if value > 0xFFFFFFFF # 8 byte integer nbytes = 3 if value < 0 # 8 byte integer, since signed @object_table[@written_object_count] = Binary.type_bytes(0b1000, nbytes) << if nbytes < 3 [value].pack( if nbytes == 0 then "C" elsif nbytes == 1 then "n" else "N" end ) else # 64 bit signed integer; we need the higher and the lower 32 bit of the value high_word = value >> 32 low_word = value & 0xFFFFFFFF [high_word,low_word].pack("NN") end @written_object_count += 1 @written_object_count - 1 end |
#unpack_with_size(nbytes, buff) ⇒ Object
256 257 258 259 260 261 262 263 264 |
# File 'lib/cfpropertylist/rbBinaryCFPropertyList.rb', line 256 def unpack_with_size(nbytes, buff) format = ["C*", "n*", "N*", "N*"][nbytes - 1]; if nbytes == 3 buff = "\0" + buff.scan(/.{1,3}/).join("\0") end return buff.unpack(format) end |