asn1: add support for RawContents

src/pkg/asn1/asn1.go

 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
 // The asn1 package implements parsing of DER-encoded ASN.1 data structures,
 // as defined in ITU-T Rec X.690.
 //
 // See also ``A Layman's Guide to a Subset of ASN.1, BER, and DER,''
 // http://luca.ntop.org/Teaching/Appunti/asn1.html.
 package asn1
@@ skipping 331 matching lines @@
         return;
 }
 
 // A RawValue represents an undecoded ASN.1 object.
 type RawValue struct {
         Class, Tag      int;
         IsCompound      bool;
         Bytes           []byte;
 }
 
+// RawContent is used to signal that the undecoded, DER data needs to be
+// preserved for a struct. To use it, the first field of the struct must have
+// this type. It's an error for any of the other fields to have this type.
+type RawContent []byte
+
 // Tagging
 
 // parseTagAndLength parses an ASN.1 tag and length pair from the given offset
 // into a byte array. It returns the parsed data and the new offset. SET and
 // SET OF (tag 17) are mapped to SEQUENCE and SEQUENCE OF (tag 16) since we
 // don't distinguish between ordered and unordered objects in this code.
 func parseTagAndLength(bytes []byte, initOffset int) (ret tagAndLength, offset int, err os.Error) {
         offset = initOffset;
         b := bytes[offset];
         offset++;
@@ skipping 91 matching lines @@
                 }
         }
         return;
 }
 
 var (
         bitStringType           = reflect.Typeof(BitString{});
         objectIdentifierType    = reflect.Typeof(ObjectIdentifier{});
         timeType                = reflect.Typeof(&time.Time{});
         rawValueType            = reflect.Typeof(RawValue{});
+        rawContentsType         = reflect.Typeof(RawContent(nil));
 )
 
 // invalidLength returns true iff offset + length > sliceLength, or if the
 // addition would overflow.
 func invalidLength(offset, length, sliceLength int) bool {
         return offset+length < offset || offset+length > sliceLength
 }
 
 // parseField is the main parsing function. Given a byte array and an offset
 // into the array, it will try to parse a suitable ASN.1 value out and store it
@@ skipping 114 matching lines @@
                 expectedTag = *params.tag;
         }
 
         // We have unwrapped any explicit tagging at this point.
         if t.class != expectedClass || t.tag != expectedTag || t.isCompound != compoundType {
                 // Tags don't match. Again, it could be an optional element.
                 ok := setDefaultValue(v, params);
                 if ok {
                         offset = initOffset
                 } else {
-                        err = StructuralError{fmt.Sprintf("tags don't match (%d vs %+v) %+v %s %#v", expectedTag, t, params, fieldType.Name(), bytes[offset:len(bytes)])}
+                        err = StructuralError{fmt.Sprintf("tags don't match (%d vs %+v) %+v %s @%d", expectedTag, t, params, fieldType.Name(), offset)}
                 }
                 return;
         }
         if invalidLength(offset, t.length, len(bytes)) {
                 err = SyntaxError{"data truncated"};
                 return;
         }
         innerBytes := bytes[offset : offset+t.length];
 
         // We deal with the structures defined in this package first.
@@ skipping 47 matching lines @@
         case *reflect.Int64Value:
                 parsedInt, err1 := parseInt64(innerBytes);
                 offset += t.length;
                 if err1 == nil {
                         val.Set(parsedInt)
                 }
                 err = err1;
                 return;
         case *reflect.StructValue:
                 structType := fieldType.(*reflect.StructType);
+
+                if structType.NumField() > 0 &&
+                        structType.Field(0).Type == rawContentsType {
+                        bytes := bytes[initOffset : offset+t.length];
+                        val.Field(0).SetValue(reflect.NewValue(RawContent(bytes)));
+                }
+
                 innerOffset := 0;
                 for i := 0; i < structType.NumField(); i++ {
                         field := structType.Field(i);
+                        if i == 0 && field.Type == rawContentsType {
+                                continue
+                        }
                         innerOffset, err = parseField(val.Field(i), innerBytes, innerOffset, parseFieldParameters(field.Tag));
                         if err != nil {
                                 return
                         }
                 }
                 offset += t.length;
                 // We allow extra bytes at the end of the SEQUENCE because
                 // adding elements to the end has been used in X.509 as the
                 // version numbers have increased.
                 return;
@@ skipping 78 matching lines @@
 // An ASN.1 SEQUENCE or SET can be written to a struct
 // if each of the elements in the sequence can be
 // written to the corresponding element in the struct.
 //
 // The following tags on struct fields have special meaning to Unmarshal:
 //
 //      optional                marks the field as ASN.1 OPTIONAL
 //      [explicit] tag:x        specifies the ASN.1 tag number; implies ASN.1 CONTEXT SPECIFIC
 //      default:x               sets the default value for optional integer fields
 //
+// If the type of the first field of a structure is RawContent then the raw
+// ASN1 contents of the struct will be stored in it.
+//
 // Other ASN.1 types are not supported; if it encounters them,
 // Unmarshal returns a parse error.
 func Unmarshal(val interface{}, b []byte) (rest []byte, err os.Error) {
         v := reflect.NewValue(val).(*reflect.PtrValue).Elem();
         offset, err := parseField(v, b, 0, fieldParameters{});
         if err != nil {
                 return nil, err
         }
         return b[offset:len(b)], nil;
 }