--- CBOR-XS/XS.pm 2013/10/26 11:08:34 1.3 +++ CBOR-XS/XS.pm 2013/11/22 16:00:30 1.23 @@ -14,16 +14,55 @@ # OO-interface $coder = CBOR::XS->new; - #TODO + $binary_cbor_data = $coder->encode ($perl_value); + $perl_value = $coder->decode ($binary_cbor_data); + + # prefix decoding + + my $many_cbor_strings = ...; + while (length $many_cbor_strings) { + my ($data, $length) = $cbor->decode_prefix ($many_cbor_strings); + # data was decoded + substr $many_cbor_strings, 0, $length, ""; # remove decoded cbor string + } =head1 DESCRIPTION -WARNING! THIS IS A PRE-ALPHA RELEASE! IT WILL CRASH, CORRUPT YOUR DATA AND -EAT YOUR CHILDREN! +WARNING! This module is very new, and not very well tested (that's up +to you to do). Furthermore, details of the implementation might change +freely before version 1.0. And lastly, most extensions depend on an IANA +assignment, and until that assignment is official, this implementation is +not interoperable with other implementations (even future versions of this +module) until the assignment is done. + +You are still invited to try out CBOR, and this module. + +This module converts Perl data structures to the Concise Binary Object +Representation (CBOR) and vice versa. CBOR is a fast binary serialisation +format that aims to use a superset of the JSON data model, i.e. when you +can represent something in JSON, you should be able to represent it in +CBOR. + +In short, CBOR is a faster and very compact binary alternative to JSON, +with the added ability of supporting serialisation of Perl objects. (JSON +often compresses better than CBOR though, so if you plan to compress the +data later you might want to compare both formats first). + +To give you a general idea about speed, with texts in the megabyte range, +C usually encodes roughly twice as fast as L or +L and decodes about 15%-30% faster than those. The shorter the +data, the worse L performs in comparison. + +As for compactness, C encoded data structures are usually about +20% smaller than the same data encoded as (compact) JSON or L. + +In addition to the core CBOR data format, this module implements a number +of extensions, to support cyclic and self-referencing data structures +(see C), string deduplication (see C) and +scalar references (always enabled). -This module converts Perl data structures to CBOR and vice versa. Its -primary goal is to be I and its secondary goal is to be -I. To reach the latter goal it was written in C. +The primary goal of this module is to be I and the secondary goal +is to be I. To reach the latter goal it was written in C. See MAPPING, below, on how CBOR::XS maps perl values to CBOR values and vice versa. @@ -34,7 +73,7 @@ use common::sense; -our $VERSION = 0.02; +our $VERSION = 0.08; our @ISA = qw(Exporter); our @EXPORT = qw(encode_cbor decode_cbor); @@ -42,6 +81,8 @@ use Exporter; use XSLoader; +use Types::Serialiser; + our $MAGIC = "\xd9\xd9\xf7"; =head1 FUNCTIONAL INTERFACE @@ -79,7 +120,6 @@ The mutators for flags all return the CBOR object again and thus calls can be chained: -#TODO my $cbor = CBOR::XS->new->encode ({a => [1,2]}); =item $cbor = $cbor->max_depth ([$maximum_nesting_depth]) @@ -123,6 +163,80 @@ See SECURITY CONSIDERATIONS, below, for more info on why this is useful. +=item $cbor = $cbor->allow_unknown ([$enable]) + +=item $enabled = $cbor->get_allow_unknown + +If C<$enable> is true (or missing), then C will I throw an +exception when it encounters values it cannot represent in CBOR (for +example, filehandles) but instead will encode a CBOR C value. + +If C<$enable> is false (the default), then C will throw an +exception when it encounters anything it cannot encode as CBOR. + +This option does not affect C in any way, and it is recommended to +leave it off unless you know your communications partner. + +=item $cbor = $cbor->allow_sharing ([$enable]) + +=item $enabled = $cbor->get_allow_sharing + +If C<$enable> is true (or missing), then C will not double-encode +values that have been referenced before (e.g. when the same object, such +as an array, is referenced multiple times), but instead will emit a +reference to the earlier value. + +This means that such values will only be encoded once, and will not result +in a deep cloning of the value on decode, in decoders supporting the value +sharing extension. + +It is recommended to leave it off unless you know your +communication partner supports the value sharing extensions to CBOR +(http://cbor.schmorp.de/value-sharing). + +Detecting shared values incurs a runtime overhead when values are encoded +that have a reference counter large than one, and might unnecessarily +increase the encoded size, as potentially shared values are encode as +sharable whether or not they are actually shared. + +At the moment, only targets of references can be shared (e.g. scalars, +arrays or hashes pointed to by a reference). Weirder constructs, such as +an array with multiple "copies" of the I string, which are hard but +not impossible to create in Perl, are not supported (this is the same as +for L). + +If C<$enable> is false (the default), then C will encode +exception when it encounters anything it cannot encode as CBOR. + +This option does not affect C in any way - shared values and +references will always be decoded properly if present. + +=item $cbor = $cbor->allow_stringref ([$enable]) + +=item $enabled = $cbor->get_allow_stringref + +If C<$enable> is true (or missing), then C will try not to encode +the same string twice, but will instead encode a reference to the string +instead. Depending on your data format. this can save a lot of space, but +also results in a very large runtime overhead (expect encoding times to be +2-4 times as high as without). + +It is recommended to leave it off unless you know your +communications partner supports the stringref extension to CBOR +(http://cbor.schmorp.de/stringref). + +If C<$enable> is false (the default), then C will encode +exception when it encounters anything it cannot encode as CBOR. + +This option does not affect C in any way - string references will +always be decoded properly if present. + +=item $cbor = $cbor->filter ([$cb->($tag, $value)]) + +=item $cb_or_undef = $cbor->get_filter + +TODO + =item $cbor_data = $cbor->encode ($perl_scalar) Converts the given Perl data structure (a scalar value) to its CBOR @@ -165,17 +279,52 @@ =over 4 -=item True, False +=item integers + +CBOR integers become (numeric) perl scalars. On perls without 64 bit +support, 64 bit integers will be truncated or otherwise corrupted. + +=item byte strings + +Byte strings will become octet strings in Perl (the byte values 0..255 +will simply become characters of the same value in Perl). -These CBOR values become C and C, +=item UTF-8 strings + +UTF-8 strings in CBOR will be decoded, i.e. the UTF-8 octets will be +decoded into proper Unicode code points. At the moment, the validity of +the UTF-8 octets will not be validated - corrupt input will result in +corrupted Perl strings. + +=item arrays, maps + +CBOR arrays and CBOR maps will be converted into references to a Perl +array or hash, respectively. The keys of the map will be stringified +during this process. + +=item null + +CBOR null becomes C in Perl. + +=item true, false, undefined + +These CBOR values become C, +C and C, respectively. They are overloaded to act almost exactly like the numbers -C<1> and C<0>. You can check whether a scalar is a CBOR boolean by using -the C function. +C<1> and C<0> (for true and false) or to throw an exception on access (for +error). See the L manpage for details. + +=item tagged values -=item Null, Undefined +Tagged items consists of a numeric tag and another CBOR value. -CBOR Null and Undefined values becomes C in Perl (in the future, -Undefined may raise an exception). +See L and the description of C<< ->filter >> +for details. + +=item anything else + +Anything else (e.g. unsupported simple values) will raise a decoding +error. =back @@ -190,40 +339,47 @@ =item hash references -Perl hash references become CBOR maps. As there is no inherent ordering -in hash keys (or CBOR maps), they will usually be encoded in a -pseudo-random order. +Perl hash references become CBOR maps. As there is no inherent ordering in +hash keys (or CBOR maps), they will usually be encoded in a pseudo-random +order. + +Currently, tied hashes will use the indefinite-length format, while normal +hashes will use the fixed-length format. =item array references -Perl array references become CBOR arrays. +Perl array references become fixed-length CBOR arrays. =item other references Other unblessed references are generally not allowed and will cause an exception to be thrown, except for references to the integers C<0> and -C<1>, which get turned into C and C in CBOR. +C<1>, which get turned into false and true in CBOR. + +=item CBOR::XS::Tagged objects -=item CBOR::XS::true, CBOR::XS::false +Objects of this type must be arrays consisting of a single C<[tag, value]> +pair. The (numerical) tag will be encoded as a CBOR tag, the value will +be encoded as appropriate for the value. You cna use C to +create such objects. -These special values become CBOR True and CBOR False values, -respectively. You can also use C<\1> and C<\0> directly if you want. +=item Types::Serialiser::true, Types::Serialiser::false, Types::Serialiser::error -=item blessed objects +These special values become CBOR true, CBOR false and CBOR undefined +values, respectively. You can also use C<\1>, C<\0> and C<\undef> directly +if you want. -Blessed objects are not directly representable in CBOR. TODO -See the -C and C methods on various options on -how to deal with this: basically, you can choose between throwing an -exception, encoding the reference as if it weren't blessed, or provide -your own serialiser method. +=item other blessed objects + +Other blessed objects are serialised via C or C. See +L for specific classes handled by this +module, and L for generic object serialisation. =item simple scalars -TODO Simple Perl scalars (any scalar that is not a reference) are the most difficult objects to encode: CBOR::XS will encode undefined scalars as -CBOR C values, scalars that have last been used in a string context +CBOR null values, scalars that have last been used in a string context before encoding as CBOR strings, and anything else as number value: # dump as number @@ -255,32 +411,369 @@ if you need this capability (but don't forget to explain why it's needed :). -Note that numerical precision has the same meaning as under Perl (so -binary to decimal conversion follows the same rules as in Perl, which -can differ to other languages). Also, your perl interpreter might expose -extensions to the floating point numbers of your platform, such as -infinities or NaN's - these cannot be represented in CBOR, and it is an -error to pass those in. +Perl values that seem to be integers generally use the shortest possible +representation. Floating-point values will use either the IEEE single +format if possible without loss of precision, otherwise the IEEE double +format will be used. Perls that use formats other than IEEE double to +represent numerical values are supported, but might suffer loss of +precision. =back +=head2 OBJECT SERIALISATION + +This module knows two way to serialise a Perl object: The CBOR-specific +way, and the generic way. + +Whenever the encoder encounters a Perl object that it cnanot serialise +directly (most of them), it will first look up the C method on +it. + +If it has a C method, it will call it with the object as only +argument, and expects exactly one return value, which it will then +substitute and encode it in the place of the object. + +Otherwise, it will look up the C method. If it exists, it will +call it with the object as first argument, and the constant string C +as the second argument, to distinguish it from other serialisers. + +The C method can return any number of values (i.e. zero or +more). These will be encoded as CBOR perl object, together with the +classname. + +If an object supports neither C nor C, encoding will fail +with an error. + +Objects encoded via C cannot be automatically decoded, but +objects encoded via C can be decoded using the following protocol: + +When an encoded CBOR perl object is encountered by the decoder, it will +look up the C method, by using the stored classname, and will fail +if the method cannot be found. + +After the lookup it will call the C method with the stored classname +as first argument, the constant string C as second argument, and all +values returned by C as remaining arguments. + +=head4 EXAMPLES + +Here is an example C method: + + sub My::Object::TO_CBOR { + my ($obj) = @_; + + ["this is a serialised My::Object object", $obj->{id}] + } + +When a C is encoded to CBOR, it will instead encode a simple +array with two members: a string, and the "object id". Decoding this CBOR +string will yield a normal perl array reference in place of the object. + +A more useful and practical example would be a serialisation method for +the URI module. CBOR has a custom tag value for URIs, namely 32: -=head2 MAGIC HEADER + sub URI::TO_CBOR { + my ($self) = @_; + my $uri = "$self"; # stringify uri + utf8::upgrade $uri; # make sure it will be encoded as UTF-8 string + CBOR::XS::tagged 32, "$_[0]" + } + +This will encode URIs as a UTF-8 string with tag 32, which indicates an +URI. + +Decoding such an URI will not (currently) give you an URI object, but +instead a CBOR::XS::Tagged object with tag number 32 and the string - +exactly what was returned by C. + +To serialise an object so it can automatically be deserialised, you need +to use C and C. To take the URI module as example, this +would be a possible implementation: + + sub URI::FREEZE { + my ($self, $serialiser) = @_; + "$self" # encode url string + } + + sub URI::THAW { + my ($class, $serialiser, $uri) = @_; + + $class->new ($uri) + } + +Unlike C, multiple values can be returned by C. For +example, a C method that returns "type", "id" and "variant" values +would cause an invocation of C with 5 arguments: + + sub My::Object::FREEZE { + my ($self, $serialiser) = @_; + + ($self->{type}, $self->{id}, $self->{variant}) + } + + sub My::Object::THAW { + my ($class, $serialiser, $type, $id, $variant) = @_; + + $class- $type, id => $id, variant => $variant) + } + + +=head1 MAGIC HEADER There is no way to distinguish CBOR from other formats programmatically. To make it easier to distinguish CBOR from other formats, the CBOR specification has a special "magic string" that can be -prepended to any CBOR string without changing it's meaning. +prepended to any CBOR string without changing its meaning. This string is available as C<$CBOR::XS::MAGIC>. This module does not -prepend this string tot he CBOR data it generates, but it will ignroe it +prepend this string to the CBOR data it generates, but it will ignore it if present, so users can prepend this string as a "file type" indicator as required. -=head2 CBOR and JSON +=head1 THE CBOR::XS::Tagged CLASS -TODO +CBOR has the concept of tagged values - any CBOR value can be tagged with +a numeric 64 bit number, which are centrally administered. + +C handles a few tags internally when en- or decoding. You can +also create tags yourself by encoding C objects, and the +decoder will create C objects itself when it hits an +unknown tag. + +These objects are simply blessed array references - the first member of +the array being the numerical tag, the second being the value. + +You can interact with C objects in the following ways: + +=over 4 + +=item $tagged = CBOR::XS::tag $tag, $value + +This function(!) creates a new C object using the given +C<$tag> (0..2**64-1) to tag the given C<$value> (which can be any Perl +value that can be encoded in CBOR, including serialisable Perl objects and +C objects). + +=item $tagged->[0] + +=item $tagged->[0] = $new_tag + +=item $tag = $tagged->tag + +=item $new_tag = $tagged->tag ($new_tag) + +Access/mutate the tag. + +=item $tagged->[1] + +=item $tagged->[1] = $new_value + +=item $value = $tagged->value + +=item $new_value = $tagged->value ($new_value) + +Access/mutate the tagged value. + +=back + +=cut + +sub tag($$) { + bless [@_], CBOR::XS::Tagged::; +} + +sub CBOR::XS::Tagged::tag { + $_[0][0] = $_[1] if $#_; + $_[0][0] +} + +sub CBOR::XS::Tagged::value { + $_[0][1] = $_[1] if $#_; + $_[0][1] +} + +=head2 EXAMPLES + +Here are some examples of C uses to tag objects. + +You can look up CBOR tag value and emanings in the IANA registry at +L. + +Prepend a magic header (C<$CBOR::XS::MAGIC>): + + my $cbor = encode_cbor CBOR::XS::tag 55799, $value; + # same as: + my $cbor = $CBOR::XS::MAGIC . encode_cbor $value; + +Serialise some URIs and a regex in an array: + + my $cbor = encode_cbor [ + (CBOR::XS::tag 32, "http://www.nethype.de/"), + (CBOR::XS::tag 32, "http://software.schmorp.de/"), + (CBOR::XS::tag 35, "^[Pp][Ee][Rr][lL]\$"), + ]; + +Wrap CBOR data in CBOR: + + my $cbor_cbor = encode_cbor + CBOR::XS::tag 24, + encode_cbor [1, 2, 3]; + +=head1 TAG HANDLING AND EXTENSIONS + +This section describes how this module handles specific tagged values +and extensions. If a tag is not mentioned here and no additional filters +are provided for it, then the default handling applies (creating a +CBOR::XS::Tagged object on decoding, and only encoding the tag when +explicitly requested). + +Tags not handled specifically are currently converted into a +L object, which is simply a blessed array reference +consisting of the numeric tag value followed by the (decoded) CBOR value. + +Future versions of this module reserve the right to special case +additional tags (such as base64url). + +=head2 ENFORCED TAGS + +These tags are always handled when decoding, and their handling cannot be +overriden by the user. + +=over 4 + +=item (perl-object, L) + +These tags are automatically created (and decoded) for serialisable +objects using the C methods (the L object +serialisation protocol). See L for details. + +=item , (sharable, sharedref, L ) + +These tags are automatically decoded when encountered, resulting in +shared values in the decoded object. They are only encoded, however, when +C is enabled. + +=item , (stringref-namespace, stringref, L ) + +These tags are automatically decoded when encountered. They are only +encoded, however, when C is enabled. + +=item 22098 (indirection, L) + +This tag is automatically generated when a reference are encountered (with +the exception of hash and array refernces). It is converted to a reference +when decoding. + +=item 55799 (self-describe CBOR, RFC 7049) + +This value is not generated on encoding (unless explicitly requested by +the user), and is simply ignored when decoding. + +=back + +=head2 OPTIONAL TAGS + +These tags have default filters provided when decoding. Their handling can +be overriden by changing the C<%CBOR::XS::FILTER> entry for the tag, or by +providing a custom C function when decoding. + +When they result in decoding into a specific Perl class, the module +usually provides a corresponding C method as well. + +When any of these need to load additional modules that are not part of the +perl core distribution (e.g. L), it is (currently) up to the user to +provide these modules. The decoding usually fails with an exception if the +required module cannot be loaded. + +=over 4 + +=item 2, 3 (positive/negative bignum) + +These tags are decoded into L objects. The corresponding +C method encodes "small" bigints into normal CBOR +integers, and others into positive/negative CBOR bignums. + +=item 4, 5 (decimal fraction/bigfloat) + +Both decimal fractions and bigfloats are decoded into L +objects. The corresponding C method I +encodes into a decimal fraction. + +CBOR cannot represent bigfloats with I large exponents - conversion +of such big float objects is undefined. + +Also, NaN and infinities are not encoded properly. + +=item 21, 22, 23 (expected later JSON conversion) + +CBOR::XS is not a CBOR-to-JSON converter, and will simply ignore these +tags. + +=item 32 (URI) + +These objects decode into L objects. The corresponding +C method again results in a CBOR URI value. + +=back + +=cut + +our %FILTER = ( + # 0 # rfc4287 datetime, utf-8 + # 1 # unix timestamp, any + + 2 => sub { # pos bigint + require Math::BigInt; + Math::BigInt->new ("0x" . unpack "H*", pop) + }, + + 3 => sub { # neg bigint + require Math::BigInt; + -Math::BigInt->new ("0x" . unpack "H*", pop) + }, + + 4 => sub { # decimal fraction, array + require Math::BigFloat; + Math::BigFloat->new ($_[1][1] . "E" . $_[1][0]) + }, + + 5 => sub { # bigfloat, array + require Math::BigFloat; + scalar Math::BigFloat->new ($_[1][1])->blsft ($_[1][0], 2) + }, + + 21 => sub { pop }, # expected conversion to base64url encoding + 22 => sub { pop }, # expected conversion to base64 encoding + 23 => sub { pop }, # expected conversion to base16 encoding + + # 24 # embedded cbor, byte string + + 32 => sub { + require URI; + URI->new (pop) + }, + + # 33 # base64url rfc4648, utf-8 + # 34 # base64 rfc46484, utf-8 + # 35 # regex pcre/ecma262, utf-8 + # 36 # mime message rfc2045, utf-8 +); + + +=head1 CBOR and JSON + +CBOR is supposed to implement a superset of the JSON data model, and is, +with some coercion, able to represent all JSON texts (something that other +"binary JSON" formats such as BSON generally do not support). + +CBOR implements some extra hints and support for JSON interoperability, +and the spec offers further guidance for conversion between CBOR and +JSON. None of this is currently implemented in CBOR, and the guidelines +in the spec do not result in correct round-tripping of data. If JSON +interoperability is improved in the future, then the goal will be to +ensure that decoded JSON data will round-trip encoding and decoding to +CBOR intact. =head1 SECURITY CONSIDERATIONS @@ -358,34 +851,82 @@ =cut -our $true = do { bless \(my $dummy = 1), "CBOR::XS::Boolean" }; -our $false = do { bless \(my $dummy = 0), "CBOR::XS::Boolean" }; - -sub true() { $true } -sub false() { $false } +our %FILTER = ( + # 0 # rfc4287 datetime, utf-8 + # 1 # unix timestamp, any + + 2 => sub { # pos bigint + require Math::BigInt; + Math::BigInt->new ("0x" . unpack "H*", pop) + }, + + 3 => sub { # neg bigint + require Math::BigInt; + -Math::BigInt->new ("0x" . unpack "H*", pop) + }, + + 4 => sub { # decimal fraction, array + require Math::BigFloat; + Math::BigFloat->new ($_[1][1] . "E" . $_[1][0]) + }, + + 5 => sub { # bigfloat, array + require Math::BigFloat; + scalar Math::BigFloat->new ($_[1][1])->blsft ($_[1][0], 2) + }, + + 21 => sub { pop }, # expected conversion to base64url encoding + 22 => sub { pop }, # expected conversion to base64 encoding + 23 => sub { pop }, # expected conversion to base16 encoding + + # 24 # embedded cbor, byte string + + 32 => sub { + require URI; + URI->new (pop) + }, + + # 33 # base64url rfc4648, utf-8 + # 34 # base64 rfc46484, utf-8 + # 35 # regex pcre/ecma262, utf-8 + # 36 # mime message rfc2045, utf-8 +); -sub is_bool($) { - UNIVERSAL::isa $_[0], "CBOR::XS::Boolean" -# or UNIVERSAL::isa $_[0], "CBOR::Literal" +sub CBOR::XS::default_filter { + &{ $FILTER{$_[0]} or return } } -XSLoader::load "CBOR::XS", $VERSION; +sub URI::TO_CBOR { + my $uri = $_[0]->as_string; + utf8::upgrade $uri; + CBOR::XS::tag 32, $uri +} -package CBOR::XS::Boolean; +sub Math::BigInt::TO_CBOR { + if ($_[0] >= -2147483648 && $_[0] <= 2147483647) { + $_[0]->numify + } else { + my $hex = substr $_[0]->as_hex, 2; + $hex = "0$hex" if 1 & length $hex; # sigh + CBOR::XS::tag $_[0] >= 0 ? 2 : 3, pack "H*", $hex + } +} -use overload - "0+" => sub { ${$_[0]} }, - "++" => sub { $_[0] = ${$_[0]} + 1 }, - "--" => sub { $_[0] = ${$_[0]} - 1 }, - fallback => 1; +sub Math::BigFloat::TO_CBOR { + my ($m, $e) = $_[0]->parts; + CBOR::XS::tag 4, [$e->numify, $m] +} -1; +XSLoader::load "CBOR::XS", $VERSION; =head1 SEE ALSO The L and L modules that do similar, but human-readable, serialisation. +The L module provides the data model for true, false +and error values. + =head1 AUTHOR Marc Lehmann @@ -393,3 +934,5 @@ =cut +1 +