code review 6348074: encoding/asn1: promote untyped strings to UTF8 as needed.

src/pkg/encoding/asn1/marshal.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.
 
 package asn1
 
 import (
         "bytes"
+        "errors"
         "fmt"
         "io"
         "math/big"
         "reflect"
         "time"
+        "unicode/utf8"
 )
 
 // A forkableWriter is an in-memory buffer that can be
 // 'forked' to create new forkableWriters that bracket the
 // original.  After
 //    pre, post := w.fork();
 // the overall sequence of bytes represented is logically w+pre+post.
 type forkableWriter struct {
         *bytes.Buffer
         pre, post *forkableWriter
@@ skipping 249 matching lines @@
         for _, c := range b {
                 if c > 127 {
                         return StructuralError{"IA5String contains invalid character"}
                 }
         }
 
         _, err = out.Write(b)
         return
 }
 
+func marshalUTF8String(out *forkableWriter, s string) (err error) {
+        _, err = out.Write([]byte(s))
+        return
+}
+
 func marshalTwoDigits(out *forkableWriter, v int) (err error) {
         err = out.WriteByte(byte('0' + (v/10)%10))
         if err != nil {
                 return
         }
         return out.WriteByte(byte('0' + v%10))
 }
 
 func marshalUTCTime(out *forkableWriter, t time.Time) (err error) {
         utc := t.UTC()
@@ skipping 146 matching lines @@
                 for i := 0; i < v.Len(); i++ {
                         var pre *forkableWriter
                         pre, out = out.fork()
                         err = marshalField(pre, v.Index(i), params)
                         if err != nil {
                                 return
                         }
                 }
                 return
         case reflect.String:
-                if params.stringType == tagIA5String {
+                switch params.stringType {
+                case tagIA5String:
                         return marshalIA5String(out, v.String())
-                } else {
+                case tagPrintableString:
                         return marshalPrintableString(out, v.String())
+                default:
+                        return marshalUTF8String(out, v.String())
                 }
                 return
         }
 
         return StructuralError{"unknown Go type"}
 }
 
 func marshalField(out *forkableWriter, v reflect.Value, params fieldParameters) (err error) {
         // If the field is an interface{} then recurse into it.
         if v.Kind() == reflect.Interface && v.Type().NumMethod() == 0 {
@@ skipping 22 matching lines @@
                 return
         }
 
         tag, isCompound, ok := getUniversalType(v.Type())
         if !ok {
                 err = StructuralError{fmt.Sprintf("unknown Go type: %v", v.Type())}
                 return
         }
         class := classUniversal
 
-        if params.stringType != 0 {
-                if tag != tagPrintableString {
-                        return StructuralError{"Explicit string type given to non-string member"}
+        if params.stringType != 0 && tag != tagPrintableString {
+                return StructuralError{"Explicit string type given to non-string member"}
+        }
+
+        if tag == tagPrintableString {
+                if params.stringType == 0 {
+                        // This is a string without an explicit string type. We'll use
+                        // a PrintableString if the character set in the string is
+                        // sufficiently limited, otherwise we'll use a UTF8String.
+                        for _, r := range v.String() {
+                                if r >= utf8.RuneSelf || !isPrintable(byte(r)) {
+                                        if !utf8.ValidString(v.String()) {
+                                                return errors.New("asn1: string not valid UTF-8")
+                                        }
+                                        tag = tagUTF8String
+                                        break
+                                }
+                        }
+                } else {
+                        tag = params.stringType
                 }
-                tag = params.stringType
         }
 
         if params.set {
                 if tag != tagSequence {
                         return StructuralError{"Non sequence tagged as set"}
                 }
                 tag = tagSet
         }
 
         tags, body := out.fork()
@@ skipping 38 matching lines @@
         var out bytes.Buffer
         v := reflect.ValueOf(val)
         f := newForkableWriter()
         err := marshalField(f, v, fieldParameters{})
         if err != nil {
                 return nil, err
         }
         _, err = f.writeTo(&out)
         return out.Bytes(), nil
 }