summaryrefslogtreecommitdiff
path: root/src/pkg/asn1/marshal.go
diff options
context:
space:
mode:
Diffstat (limited to 'src/pkg/asn1/marshal.go')
-rw-r--r--src/pkg/asn1/marshal.go194
1 files changed, 97 insertions, 97 deletions
diff --git a/src/pkg/asn1/marshal.go b/src/pkg/asn1/marshal.go
index 2e9aa1439..eec0ee849 100644
--- a/src/pkg/asn1/marshal.go
+++ b/src/pkg/asn1/marshal.go
@@ -5,13 +5,13 @@
package asn1
import (
- "bytes";
- "fmt";
- "io";
- "os";
- "reflect";
- "strings";
- "time";
+ "bytes"
+ "fmt"
+ "io"
+ "os"
+ "reflect"
+ "strings"
+ "time"
)
// A forkableWriter is an in-memory buffer that can be
@@ -20,8 +20,8 @@ import (
// pre, post := w.fork();
// the overall sequence of bytes represented is logically w+pre+post.
type forkableWriter struct {
- *bytes.Buffer;
- pre, post *forkableWriter;
+ *bytes.Buffer
+ pre, post *forkableWriter
}
func newForkableWriter() *forkableWriter {
@@ -29,65 +29,65 @@ func newForkableWriter() *forkableWriter {
}
func (f *forkableWriter) fork() (pre, post *forkableWriter) {
- f.pre = newForkableWriter();
- f.post = newForkableWriter();
- return f.pre, f.post;
+ f.pre = newForkableWriter()
+ f.post = newForkableWriter()
+ return f.pre, f.post
}
func (f *forkableWriter) Len() (l int) {
- l += f.Buffer.Len();
+ l += f.Buffer.Len()
if f.pre != nil {
l += f.pre.Len()
}
if f.post != nil {
l += f.post.Len()
}
- return;
+ return
}
func (f *forkableWriter) writeTo(out io.Writer) (n int, err os.Error) {
- n, err = out.Write(f.Bytes());
+ n, err = out.Write(f.Bytes())
if err != nil {
return
}
- var nn int;
+ var nn int
if f.pre != nil {
- nn, err = f.pre.writeTo(out);
- n += nn;
+ nn, err = f.pre.writeTo(out)
+ n += nn
if err != nil {
return
}
}
if f.pre != nil {
- nn, err = f.post.writeTo(out);
- n += nn;
+ nn, err = f.post.writeTo(out)
+ n += nn
}
- return;
+ return
}
func marshalBase128Int(out *forkableWriter, i int64) (err os.Error) {
if i == 0 {
- err = out.WriteByte(0);
- return;
+ err = out.WriteByte(0)
+ return
}
for i > 0 {
- next := i >> 7;
- o := byte(i & 0x7f);
+ next := i >> 7
+ o := byte(i & 0x7f)
if next > 0 {
o |= 0x80
}
- err = out.WriteByte(o);
+ err = out.WriteByte(o)
if err != nil {
return
}
- i = next;
+ i = next
}
- return nil;
+ return nil
}
func base128Length(i int) (numBytes int) {
@@ -96,63 +96,63 @@ func base128Length(i int) (numBytes int) {
}
for i > 0 {
- numBytes++;
- i >>= 7;
+ numBytes++
+ i >>= 7
}
- return;
+ return
}
func marshalTagAndLength(out *forkableWriter, t tagAndLength) (err os.Error) {
- b := uint8(t.class) << 6;
+ b := uint8(t.class) << 6
if t.isCompound {
b |= 0x20
}
if t.tag >= 31 {
- b |= 0x1f;
- err = out.WriteByte(b);
+ b |= 0x1f
+ err = out.WriteByte(b)
if err != nil {
return
}
- err = marshalBase128Int(out, int64(t.tag));
+ err = marshalBase128Int(out, int64(t.tag))
if err != nil {
return
}
} else {
- b |= uint8(t.tag);
- err = out.WriteByte(b);
+ b |= uint8(t.tag)
+ err = out.WriteByte(b)
if err != nil {
return
}
}
if t.length >= 128 {
- err = out.WriteByte(byte(base128Length(t.length)));
+ err = out.WriteByte(byte(base128Length(t.length)))
if err != nil {
return
}
- err = marshalBase128Int(out, int64(t.length));
+ err = marshalBase128Int(out, int64(t.length))
if err != nil {
return
}
} else {
- err = out.WriteByte(byte(t.length));
+ err = out.WriteByte(byte(t.length))
if err != nil {
return
}
}
- return nil;
+ return nil
}
func marshalBitString(out *forkableWriter, b BitString) (err os.Error) {
- paddingBits := byte((8 - b.BitLength%8) % 8);
- err = out.WriteByte(paddingBits);
+ paddingBits := byte((8 - b.BitLength%8) % 8)
+ err = out.WriteByte(paddingBits)
if err != nil {
return
}
- _, err = out.Write(b.Bytes);
- return;
+ _, err = out.Write(b.Bytes)
+ return
}
func marshalObjectIdentifier(out *forkableWriter, oid []int) (err os.Error) {
@@ -160,50 +160,50 @@ func marshalObjectIdentifier(out *forkableWriter, oid []int) (err os.Error) {
return StructuralError{"invalid object identifier"}
}
- err = out.WriteByte(byte(oid[0]*40 + oid[1]));
+ err = out.WriteByte(byte(oid[0]*40 + oid[1]))
if err != nil {
return
}
for i := 2; i < len(oid); i++ {
- err = marshalBase128Int(out, int64(oid[i]));
+ err = marshalBase128Int(out, int64(oid[i]))
if err != nil {
return
}
}
- return;
+ return
}
func marshalPrintableString(out *forkableWriter, s string) (err os.Error) {
- b := strings.Bytes(s);
+ b := strings.Bytes(s)
for _, c := range b {
if !isPrintable(c) {
return StructuralError{"PrintableString contains invalid character"}
}
}
- _, err = out.Write(b);
- return;
+ _, err = out.Write(b)
+ return
}
func marshalIA5String(out *forkableWriter, s string) (err os.Error) {
- b := strings.Bytes(s);
+ b := strings.Bytes(s)
for _, c := range b {
if c > 127 {
return StructuralError{"IA5String contains invalid character"}
}
}
- _, err = out.Write(b);
- return;
+ _, err = out.Write(b)
+ return
}
func marshalTwoDigits(out *forkableWriter, v int) (err os.Error) {
- err = out.WriteByte(byte('0' + (v/10)%10));
+ err = out.WriteByte(byte('0' + (v/10)%10))
if err != nil {
return
}
- return out.WriteByte(byte('0' + v%10));
+ return out.WriteByte(byte('0' + v%10))
}
func marshalUTCTime(out *forkableWriter, t *time.Time) (err os.Error) {
@@ -220,35 +220,35 @@ func marshalUTCTime(out *forkableWriter, t *time.Time) (err os.Error) {
return
}
- err = marshalTwoDigits(out, t.Month);
+ err = marshalTwoDigits(out, t.Month)
if err != nil {
return
}
- err = marshalTwoDigits(out, t.Day);
+ err = marshalTwoDigits(out, t.Day)
if err != nil {
return
}
- err = marshalTwoDigits(out, t.Hour);
+ err = marshalTwoDigits(out, t.Hour)
if err != nil {
return
}
- err = marshalTwoDigits(out, t.Minute);
+ err = marshalTwoDigits(out, t.Minute)
if err != nil {
return
}
- err = marshalTwoDigits(out, t.Second);
+ err = marshalTwoDigits(out, t.Second)
if err != nil {
return
}
switch {
case t.ZoneOffset/60 == 0:
- err = out.WriteByte('Z');
- return;
+ err = out.WriteByte('Z')
+ return
case t.ZoneOffset > 0:
err = out.WriteByte('+')
case t.ZoneOffset < 0:
@@ -259,18 +259,18 @@ func marshalUTCTime(out *forkableWriter, t *time.Time) (err os.Error) {
return
}
- offsetMinutes := t.ZoneOffset / 60;
+ offsetMinutes := t.ZoneOffset / 60
if offsetMinutes < 0 {
offsetMinutes = -offsetMinutes
}
- err = marshalTwoDigits(out, offsetMinutes/60);
+ err = marshalTwoDigits(out, offsetMinutes/60)
if err != nil {
return
}
- err = marshalTwoDigits(out, offsetMinutes%60);
- return;
+ err = marshalTwoDigits(out, offsetMinutes%60)
+ return
}
func marshalBody(out *forkableWriter, value reflect.Value, params fieldParameters) (err os.Error) {
@@ -295,81 +295,81 @@ func marshalBody(out *forkableWriter, value reflect.Value, params fieldParameter
case *reflect.Int64Value:
return marshalBase128Int(out, v.Get())
case *reflect.StructValue:
- t := v.Type().(*reflect.StructType);
+ t := v.Type().(*reflect.StructType)
for i := 0; i < t.NumField(); i++ {
- err = marshalField(out, v.Field(i), parseFieldParameters(t.Field(i).Tag));
+ err = marshalField(out, v.Field(i), parseFieldParameters(t.Field(i).Tag))
if err != nil {
return
}
}
- return;
+ return
case *reflect.SliceValue:
- sliceType := v.Type().(*reflect.SliceType);
+ sliceType := v.Type().(*reflect.SliceType)
if _, ok := sliceType.Elem().(*reflect.Uint8Type); ok {
- bytes := make([]byte, v.Len());
+ bytes := make([]byte, v.Len())
for i := 0; i < v.Len(); i++ {
bytes[i] = v.Elem(i).(*reflect.Uint8Value).Get()
}
- _, err = out.Write(bytes);
- return;
+ _, err = out.Write(bytes)
+ return
}
- var params fieldParameters;
+ var params fieldParameters
for i := 0; i < v.Len(); i++ {
- err = marshalField(out, v.Elem(i), params);
+ err = marshalField(out, v.Elem(i), params)
if err != nil {
return
}
}
- return;
+ return
case *reflect.StringValue:
if params.stringType == tagIA5String {
return marshalIA5String(out, v.Get())
} else {
return marshalPrintableString(out, v.Get())
}
- return;
+ return
}
- return StructuralError{"unknown Go type"};
+ return StructuralError{"unknown Go type"}
}
func marshalField(out *forkableWriter, v reflect.Value, params fieldParameters) (err os.Error) {
- tag, isCompound, ok := getUniversalType(v.Type());
+ tag, isCompound, ok := getUniversalType(v.Type())
if !ok {
- err = StructuralError{fmt.Sprintf("unknown Go type: %v", v.Type())};
- return;
+ err = StructuralError{fmt.Sprintf("unknown Go type: %v", v.Type())}
+ return
}
- class := classUniversal;
+ class := classUniversal
if params.stringType != 0 {
if tag != tagPrintableString {
return StructuralError{"Explicit string type given to non-string member"}
}
- tag = params.stringType;
+ tag = params.stringType
}
- tags, body := out.fork();
+ tags, body := out.fork()
- err = marshalBody(body, v, params);
+ err = marshalBody(body, v, params)
if err != nil {
return
}
- bodyLen := body.Len();
+ bodyLen := body.Len()
- var explicitTag *forkableWriter;
+ var explicitTag *forkableWriter
if params.explicit {
explicitTag, tags = tags.fork()
}
if !params.explicit && params.tag != nil {
// implicit tag.
- tag = *params.tag;
- class = classContextSpecific;
+ tag = *params.tag
+ class = classContextSpecific
}
- err = marshalTagAndLength(tags, tagAndLength{class, tag, bodyLen, isCompound});
+ err = marshalTagAndLength(tags, tagAndLength{class, tag, bodyLen, isCompound})
if err != nil {
return
}
@@ -383,18 +383,18 @@ func marshalField(out *forkableWriter, v reflect.Value, params fieldParameters)
})
}
- return nil;
+ return nil
}
// Marshal serialises val as an ASN.1 structure and writes the result to out.
// In the case of an error, no output is produced.
func Marshal(out io.Writer, val interface{}) os.Error {
- v := reflect.NewValue(val);
- f := newForkableWriter();
- err := marshalField(f, v, fieldParameters{});
+ v := reflect.NewValue(val)
+ f := newForkableWriter()
+ err := marshalField(f, v, fieldParameters{})
if err != nil {
return err
}
- _, err = f.writeTo(out);
- return err;
+ _, err = f.writeTo(out)
+ return err
}
generated by cgit v1.2.3 (git 2.39.1) at 2024-07-12 15:21:14 +0000