diff --git a/aper.go b/aper.go index 3f2a18c..32885f5 100644 --- a/aper.go +++ b/aper.go @@ -173,7 +173,7 @@ func (pd *perBitData) parseConstraintValue(valueRange int64) (value uint64, err return } value, err = pd.getBitsValue(bytes * 8) - return + return value, err } func (pd *perBitData) parseLength(sizeRange int64, repeat *bool) (value uint64, err error) { @@ -207,10 +207,10 @@ func (pd *perBitData) parseLength(sizeRange int64, repeat *bool) (value uint64, } *repeat = true value = 16384 * firstByte - return + return value, err } -func (pd *perBitData) parseBitString(extensed bool, lowerBoundPtr *int64, upperBoundPtr *int64) (bitString BitString, err error) { +func (pd *perBitData) parseBitString(extensed bool, lowerBoundPtr *int64, upperBoundPtr *int64) (BitString, error) { var lb, ub, sizeRange int64 = 0, -1, -1 if !extensed { if lowerBoundPtr != nil { @@ -225,19 +225,19 @@ func (pd *perBitData) parseBitString(extensed bool, lowerBoundPtr *int64, upperB sizeRange = -1 } // initailization - bitString = BitString{[]byte{}, 0} + bitString := BitString{[]byte{}, 0} // lowerbound == upperbound if sizeRange == 1 { sizes := uint64(ub+7) >> 3 bitString.BitLength = uint64(ub) perTrace(2, fmt.Sprintf("Decoding BIT STRING size %d", ub)) if sizes > 2 { - if err = pd.parseAlignBits(); err != nil { - return + if err := pd.parseAlignBits(); err != nil { + return bitString, err } if (pd.byteOffset + sizes) > uint64(len(pd.bytes)) { - err = fmt.Errorf("PER data out of range") - return + err := fmt.Errorf("PER data out of range") + return bitString, err } bitString.Bytes = pd.bytes[pd.byteOffset : pd.byteOffset+sizes] pd.byteOffset += sizes @@ -247,31 +247,38 @@ func (pd *perBitData) parseBitString(extensed bool, lowerBoundPtr *int64, upperB } perTrace(1, perBitLog(uint64(ub), pd.byteOffset, pd.bitsOffset, bitString.Bytes)) } else { - bitString.Bytes, err = pd.getBitString(uint(ub)) + if byte, err := pd.getBitString(uint(ub)); err != nil { + logger.AperLog.Warnf("PD GetBitString error: %+v", err) + return bitString, err + } else { + bitString.Bytes = byte + } } perTrace(2, fmt.Sprintf("Decoded BIT STRING (length = %d): %0.8b", ub, bitString.Bytes)) - return + return bitString, nil } repeat := false for { var rawLength uint64 - if rawLength, err = pd.parseLength(sizeRange, &repeat); err != nil { - return + if length, err := pd.parseLength(sizeRange, &repeat); err != nil { + return bitString, err + } else { + rawLength = length } rawLength += uint64(lb) perTrace(2, fmt.Sprintf("Decoding BIT STRING size %d", rawLength)) if rawLength == 0 { - return + return bitString, nil } sizes := (rawLength + 7) >> 3 - if err = pd.parseAlignBits(); err != nil { - return + if err := pd.parseAlignBits(); err != nil { + return bitString, err } if (pd.byteOffset + sizes) > uint64(len(pd.bytes)) { - err = fmt.Errorf("PER data out of range") - return + err := fmt.Errorf("PER data out of range") + return bitString, err } bitString.Bytes = append(bitString.Bytes, pd.bytes[pd.byteOffset:pd.byteOffset+sizes]...) bitString.BitLength += rawLength @@ -290,9 +297,10 @@ func (pd *perBitData) parseBitString(extensed bool, lowerBoundPtr *int64, upperB break } } - return + return bitString, nil } -func (pd *perBitData) parseOctetString(extensed bool, lowerBoundPtr *int64, upperBoundPtr *int64) (octetString OctetString, err error) { +func (pd *perBitData) parseOctetString(extensed bool, lowerBoundPtr *int64, upperBoundPtr *int64) ( + OctetString, error) { var lb, ub, sizeRange int64 = 0, -1, -1 if !extensed { if lowerBoundPtr != nil { @@ -307,45 +315,51 @@ func (pd *perBitData) parseOctetString(extensed bool, lowerBoundPtr *int64, uppe sizeRange = -1 } // initailization - octetString = OctetString("") + octetString := OctetString("") // lowerbound == upperbound if sizeRange == 1 { perTrace(2, fmt.Sprintf("Decoding OCTET STRING size %d", ub)) if ub > 2 { unsignedUB := uint64(ub) - if err = pd.parseAlignBits(); err != nil { - return + if err := pd.parseAlignBits(); err != nil { + return octetString, err } if (int64(pd.byteOffset) + ub) > int64(len(pd.bytes)) { - err = fmt.Errorf("per data out of range") - return + err := fmt.Errorf("per data out of range") + return octetString, err } octetString = pd.bytes[pd.byteOffset : pd.byteOffset+unsignedUB] pd.byteOffset += uint64(ub) perTrace(1, perBitLog(8*unsignedUB, pd.byteOffset, pd.bitsOffset, octetString)) } else { - octetString, err = pd.getBitString(uint(ub * 8)) + if octet, err := pd.getBitString(uint(ub * 8)); err != nil { + return octetString, err + } else { + octetString = octet + } } perTrace(2, fmt.Sprintf("Decoded OCTET STRING (length = %d): 0x%0x", ub, octetString)) - return + return octetString, nil } repeat := false for { var rawLength uint64 - if rawLength, err = pd.parseLength(sizeRange, &repeat); err != nil { - return + if length, err := pd.parseLength(sizeRange, &repeat); err != nil { + return octetString, err + } else { + rawLength = length } rawLength += uint64(lb) perTrace(2, fmt.Sprintf("Decoding OCTET STRING size %d", rawLength)) if rawLength == 0 { - return - } else if err = pd.parseAlignBits(); err != nil { - return + return octetString, nil + } else if err := pd.parseAlignBits(); err != nil { + return octetString, err } if (rawLength + pd.byteOffset) > uint64(len(pd.bytes)) { - err = fmt.Errorf("per data out of range ") - return + err := fmt.Errorf("per data out of range ") + return octetString, err } octetString = append(octetString, pd.bytes[pd.byteOffset:pd.byteOffset+rawLength]...) pd.byteOffset += rawLength @@ -358,11 +372,11 @@ func (pd *perBitData) parseOctetString(extensed bool, lowerBoundPtr *int64, uppe break } } - return + return octetString, nil } func (pd *perBitData) parseBool() (value bool, err error) { - perTrace(3, fmt.Sprintf("Decoding BOOLEAN Value")) + perTrace(3, "Decoding BOOLEAN Value") bit, err1 := pd.getBitsValue(1) if err1 != nil { err = err1 @@ -370,19 +384,19 @@ func (pd *perBitData) parseBool() (value bool, err error) { } if bit == 1 { value = true - perTrace(2, fmt.Sprintf("Decoded BOOLEAN Value : ture")) + perTrace(2, "Decoded BOOLEAN Value : ture") } else { value = false - perTrace(2, fmt.Sprintf("Decoded BOOLEAN Value : false")) + perTrace(2, "Decoded BOOLEAN Value : false") } return } -func (pd *perBitData) parseInteger(extensed bool, lowerBoundPtr *int64, upperBoundPtr *int64) (value int64, err error) { +func (pd *perBitData) parseInteger(extensed bool, lowerBoundPtr *int64, upperBoundPtr *int64) (int64, error) { var lb, ub, valueRange int64 = 0, -1, 0 if !extensed { if lowerBoundPtr == nil { - perTrace(3, fmt.Sprintf("Decoding INTEGER with Unconstraint Value")) + perTrace(3, "Decoding INTEGER with Unconstraint Value") valueRange = -1 } else { lb = *lowerBoundPtr @@ -396,32 +410,29 @@ func (pd *perBitData) parseInteger(extensed bool, lowerBoundPtr *int64, upperBou } } else { valueRange = -1 - perTrace(3, fmt.Sprintf("Decoding INTEGER with Extensive Value")) + perTrace(3, "Decoding INTEGER with Extensive Value") } var rawLength uint if valueRange == 1 { - value = ub - return + return ub, nil } else if valueRange <= 0 { // semi-constraint or unconstraint - if err = pd.parseAlignBits(); err != nil { - return + if err := pd.parseAlignBits(); err != nil { + return int64(0), err } if pd.byteOffset >= uint64(len(pd.bytes)) { - err = fmt.Errorf("per data out of range") - return + return int64(0), fmt.Errorf("per data out of range") } rawLength = uint(pd.bytes[pd.byteOffset]) pd.byteOffset++ perTrace(1, perBitLog(8, pd.byteOffset, pd.bitsOffset, uint64(rawLength))) } else if valueRange <= 65536 { - rawValue, err1 := pd.parseConstraintValue(valueRange) - if err1 != nil { - err = err1 + rawValue, err := pd.parseConstraintValue(valueRange) + if err != nil { + return int64(0), err } else { - value = int64(rawValue) + lb + return int64(rawValue) + lb, nil } - return } else { // valueRange > 65536 var byteLen uint @@ -440,37 +451,36 @@ func (pd *perBitData) parseInteger(extensed bool, lowerBoundPtr *int64, upperBou break } } - if tempLength, err1 := pd.getBitsValue(i); err1 != nil { - err = err1 - return + if tempLength, err := pd.getBitsValue(i); err != nil { + return int64(0), err } else { rawLength = uint(tempLength) } rawLength++ - if err = pd.parseAlignBits(); err != nil { - return + if err := pd.parseAlignBits(); err != nil { + return int64(0), err } } perTrace(2, fmt.Sprintf("Decoding INTEGER Length with %d bytes", rawLength)) - var rawValue uint64 - if rawValue, err = pd.getBitsValue(rawLength * 8); err != nil { - return + + if rawValue, err := pd.getBitsValue(rawLength * 8); err != nil { + return int64(0), err } else if valueRange < 0 { signedBitMask := uint64(1 << (rawLength*8 - 1)) valueMask := signedBitMask - 1 // negative if rawValue&signedBitMask > 0 { - value = int64((^rawValue)&valueMask+1) * -1 - return + return int64((^rawValue)&valueMask+1) * -1, nil } + return int64(rawValue) + lb, nil + } else { + return int64(rawValue) + lb, nil } - value = int64(rawValue) + lb - return - } // parse ENUMERATED type but do not implement extensive value and different value with index -func (pd *perBitData) parseEnumerated(extensed bool, lowerBoundPtr *int64, upperBoundPtr *int64) (value uint64, err error) { +func (pd *perBitData) parseEnumerated(extensed bool, lowerBoundPtr *int64, upperBoundPtr *int64) (value uint64, + err error) { if extensed { err = fmt.Errorf("Unsupport the extensive value of ENUMERATED ") return @@ -489,7 +499,10 @@ func (pd *perBitData) parseEnumerated(extensed bool, lowerBoundPtr *int64, upper return } -func (pd *perBitData) parseSequenceOf(sizeExtensed bool, params fieldParameters, sliceType reflect.Type) (sliceContent reflect.Value, err error) { + +func (pd *perBitData) parseSequenceOf(sizeExtensed bool, params fieldParameters, sliceType reflect.Type) ( + reflect.Value, error) { + var sliceContent reflect.Value var lb int64 = 0 var sizeRange int64 if params.sizeLowerBound != nil && *params.sizeLowerBound < 65536 { @@ -506,17 +519,21 @@ func (pd *perBitData) parseSequenceOf(sizeExtensed bool, params fieldParameters, var numElements uint64 if sizeRange > 1 { - numElements, err = pd.parseConstraintValue(sizeRange) + if numElementsTmp, err := pd.parseConstraintValue(sizeRange); err != nil { + logger.AperLog.Warnf("Parse Constraint Value failed: %+v", err) + } else { + numElements = numElementsTmp + } numElements += uint64(lb) } else if sizeRange == 1 { numElements += uint64(lb) } else { - if err = pd.parseAlignBits(); err != nil { - return + if err := pd.parseAlignBits(); err != nil { + return sliceContent, err } if pd.byteOffset >= uint64(len(pd.bytes)) { - err = fmt.Errorf("per data out of range") - return + err := fmt.Errorf("per data out of range") + return sliceContent, err } numElements = uint64(pd.bytes[pd.byteOffset]) pd.byteOffset++ @@ -529,12 +546,12 @@ func (pd *perBitData) parseSequenceOf(sizeExtensed bool, params fieldParameters, intNumElements := int(numElements) sliceContent = reflect.MakeSlice(sliceType, intNumElements, intNumElements) for i := 0; i < intNumElements; i++ { - err = parseField(sliceContent.Index(i), pd, params) + err := parseField(sliceContent.Index(i), pd, params) if err != nil { - return + return sliceContent, err } } - return + return sliceContent, nil } func (pd *perBitData) getChoiceIndex(extensed bool, upperBoundPtr *int64) (present int, err error) { @@ -576,56 +593,55 @@ func getReferenceFieldValue(v reflect.Value) (value int64, err error) { return } -func (pd *perBitData) parseOpenType(v reflect.Value, params fieldParameters) (err error) { +func (pd *perBitData) parseOpenType(v reflect.Value, params fieldParameters) error { pdOpenType := &perBitData{[]byte(""), 0, 0} repeat := false for { var rawLength uint64 - if rawLength, err = pd.parseLength(-1, &repeat); err != nil { - return + if rawLengthTmp, err := pd.parseLength(-1, &repeat); err != nil { + return err + } else { + rawLength = rawLengthTmp } if rawLength == 0 { break - } else if err = pd.parseAlignBits(); err != nil { - return + } else if err := pd.parseAlignBits(); err != nil { + return err } if (rawLength + pd.byteOffset) > uint64(len(pd.bytes)) { - err = fmt.Errorf("per data out of range ") - return + return fmt.Errorf("per data out of range ") } pdOpenType.bytes = append(pdOpenType.bytes, pd.bytes[pd.byteOffset:pd.byteOffset+rawLength]...) pd.byteOffset += rawLength if !repeat { - if err = pd.parseAlignBits(); err != nil { - return + if err := pd.parseAlignBits(); err != nil { + return err } break } } perTrace(2, fmt.Sprintf("Decoding OpenType %s with (len = %d byte)", v.Type().String(), len(pdOpenType.bytes))) - err = parseField(v, pdOpenType, params) + err := parseField(v, pdOpenType, params) perTrace(2, fmt.Sprintf("Decoded OpenType %s", v.Type().String())) - return + return err } // parseField is the main parsing function. Given a byte slice and an offset // into the array, it will try to parse a suitable ASN.1 value out and store it // in the given Value. TODO : ObjectIdenfier, handle extension Field -func parseField(v reflect.Value, pd *perBitData, params fieldParameters) (err error) { +func parseField(v reflect.Value, pd *perBitData, params fieldParameters) error { fieldType := v.Type() // If we have run out of data return error. if pd.byteOffset == uint64(len(pd.bytes)) { - err = fmt.Errorf("sequence truncated") - return + return fmt.Errorf("sequence truncated") } if v.Kind() == reflect.Ptr { ptr := reflect.New(fieldType.Elem()) v.Set(ptr) - err = parseField(v.Elem(), pd, params) - return + return parseField(v.Elem(), pd, params) } sizeExtensible := false valueExtensible := false @@ -655,42 +671,41 @@ func parseField(v reflect.Value, pd *perBitData, params fieldParameters) (err er return err1 } v.Set(reflect.ValueOf(bitString)) - return + return nil case ObjectIdentifierType: - err = fmt.Errorf("Unsupport ObjectIdenfier type") - return + return fmt.Errorf("Unsupport ObjectIdenfier type") case OctetStringType: - octetString, err1 := pd.parseOctetString(sizeExtensible, params.sizeLowerBound, params.sizeUpperBound) - if err1 == nil { + if octetString, err := pd.parseOctetString(sizeExtensible, params.sizeLowerBound, params.sizeUpperBound); err != nil { + return err + } else { v.Set(reflect.ValueOf(octetString)) + return nil } - err = err1 - return case EnumeratedType: - parsedEnum, err1 := pd.parseEnumerated(valueExtensible, params.valueLowerBound, params.valueUpperBound) - if err1 == nil { + if parsedEnum, err := pd.parseEnumerated(valueExtensible, params.valueLowerBound, + params.valueUpperBound); err != nil { + return err + } else { v.SetUint(parsedEnum) + return nil } - err = err1 - return } switch val := v; val.Kind() { case reflect.Bool: - parsedBool, err1 := pd.parseBool() - if err1 == nil { + if parsedBool, err := pd.parseBool(); err != nil { + return err + } else { val.SetBool(parsedBool) + return nil } - err = err1 - return case reflect.Int, reflect.Int32, reflect.Int64: - parsedInt, err1 := pd.parseInteger(valueExtensible, params.valueLowerBound, params.valueUpperBound) - if err1 == nil { + if parsedInt, err := pd.parseInteger(valueExtensible, params.valueLowerBound, params.valueUpperBound); err != nil { + return err + } else { val.SetInt(parsedInt) - perTrace(2, fmt.Sprintf("Decoded INTEGER Value : %d", parsedInt)) + perTrace(2, fmt.Sprintf("Decoded INTEGER Value: %d", parsedInt)) + return nil } - err = err1 - return - case reflect.Struct: structType := fieldType @@ -701,8 +716,7 @@ func parseField(v reflect.Value, pd *perBitData, params fieldParameters) (err er // pass tag for optional for i := 0; i < structType.NumField(); i++ { if structType.Field(i).PkgPath != "" { - err = fmt.Errorf("struct contains unexported fields : " + structType.Field(i).PkgPath) - return + return fmt.Errorf("struct contains unexported fields : " + structType.Field(i).PkgPath) } tempParams := parseFieldParameters(structType.Field(i).Tag.Get("aper")) // for optional flag @@ -713,8 +727,10 @@ func parseField(v reflect.Value, pd *perBitData, params fieldParameters) (err er } if optionalCount > 0 { - if optionalPresents, err = pd.getBitsValue(optionalCount); err != nil { - return + if optionalPresentsTmp, err := pd.getBitsValue(optionalCount); err != nil { + return err + } else { + optionalPresents = optionalPresentsTmp } perTrace(2, fmt.Sprintf("optionalPresents is %0b", optionalPresents)) } @@ -724,8 +740,7 @@ func parseField(v reflect.Value, pd *perBitData, params fieldParameters) (err er var present int = 0 if params.openType { if params.referenceFieldValue == nil { - err = fmt.Errorf("OpenType reference value is empty") - return + return fmt.Errorf("OpenType reference value is empty") } refValue := *params.referenceFieldValue @@ -739,30 +754,29 @@ func parseField(v reflect.Value, pd *perBitData, params fieldParameters) (err er } } if present == 0 { - err = fmt.Errorf("OpenType reference value does not match any field") + return fmt.Errorf("OpenType reference value does not match any field") } else if present >= structType.NumField() { - err = fmt.Errorf("OpenType Present is bigger than number of struct field") + return fmt.Errorf("OpenType Present is bigger than number of struct field") } else { val.Field(0).SetInt(int64(present)) perTrace(2, fmt.Sprintf("Decoded Present index of OpenType is %d ", present)) - err = pd.parseOpenType(val.Field(present), structParams[present]) + return pd.parseOpenType(val.Field(present), structParams[present]) } } else { - present, err = pd.getChoiceIndex(valueExtensible, params.valueUpperBound) - if err != nil { + if presentTmp, err := pd.getChoiceIndex(valueExtensible, params.valueUpperBound); err != nil { logger.AperLog.Errorf("pd.getChoiceIndex Error") + } else { + present = presentTmp } val.Field(0).SetInt(int64(present)) if present == 0 { - err = fmt.Errorf("CHOICE present is 0(present's field number)") + return fmt.Errorf("CHOICE present is 0(present's field number)") } else if present >= structType.NumField() { - err = fmt.Errorf("CHOICE Present is bigger than number of struct field") + return fmt.Errorf("CHOICE Present is bigger than number of struct field") } else { - err = parseField(val.Field(present), pd, structParams[present]) + return parseField(val.Field(present), pd, structParams[present]) } } - return - } for i := 0; i < structType.NumField(); i++ { @@ -785,44 +799,42 @@ func parseField(v reflect.Value, pd *perBitData, params fieldParameters) (err er } } if index == i { - err = fmt.Errorf("Open type is not reference to the other field in the struct") - return + return fmt.Errorf("Open type is not reference to the other field in the struct") } structParams[i].referenceFieldValue = new(int64) - *structParams[i].referenceFieldValue, err = getReferenceFieldValue(val.Field(index)) - if err != nil { - return + if referenceFieldValue, err := getReferenceFieldValue(val.Field(index)); err != nil { + return err + } else { + *structParams[i].referenceFieldValue = referenceFieldValue } } - err = parseField(val.Field(i), pd, structParams[i]) - if err != nil { - return + if err := parseField(val.Field(i), pd, structParams[i]); err != nil { + return err } } - return + return nil case reflect.Slice: sliceType := fieldType - newSlice, err1 := pd.parseSequenceOf(sizeExtensible, params, sliceType) - if err1 == nil { + if newSlice, err := pd.parseSequenceOf(sizeExtensible, params, sliceType); err != nil { + return err + } else { val.Set(newSlice) + return nil } - err = err1 - return case reflect.String: - perTrace(2, fmt.Sprintf("Decoding PrintableString using Octet String decoding method")) + perTrace(2, "Decoding PrintableString using Octet String decoding method") - octetString, err1 := pd.parseOctetString(sizeExtensible, params.sizeLowerBound, params.sizeUpperBound) - err = err1 - if err1 == nil { + if octetString, err := pd.parseOctetString(sizeExtensible, params.sizeLowerBound, params.sizeUpperBound); err != nil { + return err + } else { printableString := string(octetString) val.SetString(printableString) perTrace(2, fmt.Sprintf("Decoded PrintableString : \"%s\"", printableString)) + return nil } - return } - err = fmt.Errorf("unsupported: " + v.Type().String()) - return + return fmt.Errorf("unsupported: " + v.Type().String()) } // Unmarshal parses the APER-encoded ASN.1 data structure b diff --git a/asn_type.go b/asn_type.go index d806f93..d267c23 100644 --- a/asn_type.go +++ b/asn_type.go @@ -28,8 +28,12 @@ type ObjectIdentifier []byte type Enumerated uint64 var ( - BitStringType = reflect.TypeOf(BitString{}) - OctetStringType = reflect.TypeOf(OctetString{}) + // BitStringType is the type of BitString + BitStringType = reflect.TypeOf(BitString{}) + // OctetStringType is the type of OctetString + OctetStringType = reflect.TypeOf(OctetString{}) + // ObjectIdentifierType is the type of ObjectIdentify ObjectIdentifierType = reflect.TypeOf(ObjectIdentifier{}) - EnumeratedType = reflect.TypeOf(Enumerated(0)) + // EnumeratedType is the type of Enumerated + EnumeratedType = reflect.TypeOf(Enumerated(0)) ) diff --git a/common.go b/common.go index cab67f9..74a9b52 100644 --- a/common.go +++ b/common.go @@ -74,5 +74,5 @@ func parseFieldParameters(str string) (params fieldParameters) { } } } - return + return params } diff --git a/logger/logger.go b/logger/logger.go index a6aa8ae..4441eac 100644 --- a/logger/logger.go +++ b/logger/logger.go @@ -1,41 +1,31 @@ package logger import ( - "fmt" - "github.com/sirupsen/logrus" "os" - "runtime" - "strings" + "time" + + formatter "github.com/antonfisher/nested-logrus-formatter" + "github.com/sirupsen/logrus" "free5gc/lib/logger_conf" "free5gc/lib/logger_util" ) var log *logrus.Logger + +// AperLog : Log entry of aper var AperLog *logrus.Entry func init() { log = logrus.New() - - log.Formatter = &logrus.TextFormatter{ - ForceColors: true, - DisableColors: false, - EnvironmentOverrideColors: false, - DisableTimestamp: false, - FullTimestamp: true, - TimestampFormat: "", - DisableSorting: false, - SortingFunc: nil, - DisableLevelTruncation: false, - QuoteEmptyFields: false, - FieldMap: nil, - CallerPrettyfier: func(f *runtime.Frame) (string, string) { - orgFilename, _ := os.Getwd() - repopath := orgFilename - repopath = strings.Replace(repopath, "/bin", "", 1) - filename := strings.Replace(f.File, repopath, "", -1) - return fmt.Sprintf("%s()", f.Function), fmt.Sprintf("%s:%d", filename, f.Line) - }, + log.SetReportCaller(false) + + log.Formatter = &formatter.Formatter{ + TimestampFormat: time.RFC3339, + TrimMessages: true, + NoFieldsSpace: true, + HideKeys: true, + FieldsOrder: []string{"component", "category"}, } free5gcLogHook, err := logger_util.NewFileHook(logger_conf.Free5gcLogFile, os.O_CREATE|os.O_APPEND|os.O_RDWR, 0666) @@ -48,14 +38,16 @@ func init() { log.Hooks.Add(selfLogHook) } - AperLog = log.WithFields(logrus.Fields{"aper": "aper"}) + AperLog = log.WithFields(logrus.Fields{"component": "LIB", "category": "Aper"}) } +// SetLogLevel : set the log level (panic|fatal|error|warn|info|debug|trace) func SetLogLevel(level logrus.Level) { AperLog.Infoln("set log level :", level) log.SetLevel(level) } +// SetReportCaller : Set whether shows the filePath and functionName on loggers func SetReportCaller(bool bool) { AperLog.Infoln("set report call :", bool) log.SetReportCaller(bool) diff --git a/marshal.go b/marshal.go index a1caed0..1312323 100644 --- a/marshal.go +++ b/marshal.go @@ -139,7 +139,8 @@ func (pd *perRawBitData) appendLength(sizeRange int64, value uint64) (err error) return } -func (pd *perRawBitData) appendBitString(bytes []byte, bitsLength uint64, extensive bool, lowerBoundPtr *int64, upperBoundPtr *int64) (err error) { +func (pd *perRawBitData) appendBitString(bytes []byte, bitsLength uint64, extensive bool, + lowerBoundPtr *int64, upperBoundPtr *int64) (err error) { var lb, ub, sizeRange int64 = 0, -1, -1 if lowerBoundPtr != nil { lb = *lowerBoundPtr @@ -152,15 +153,15 @@ func (pd *perRawBitData) appendBitString(bytes []byte, bitsLength uint64, extens return } if extensive { - perTrace(2, fmt.Sprintf("Putting size Extension Value")) + perTrace(2, "Putting size Extension Value") if sizeRange == -1 { - if err := pd.putBitsValue(1, 1); err != nil { - log.Printf("putBitsValue(1, 1) error: %v", err) + if errTmp := pd.putBitsValue(1, 1); errTmp != nil { + log.Printf("putBitsValue(1, 1) error: %v", errTmp) } lb = 0 } else { - if err := pd.putBitsValue(0, 1); err != nil { - log.Printf("putBitsValue(0, 1) error: %v", err) + if errTmp := pd.putBitsValue(0, 1); errTmp != nil { + log.Printf("putBitsValue(0, 1) error: %v", errTmp) } } } @@ -216,7 +217,8 @@ func (pd *perRawBitData) appendBitString(bytes []byte, bitsLength uint64, extens pd.appendAlignBits() pd.bytes = append(pd.bytes, bytes[byteOffset:byteOffset+sizes]...) perTrace(1, perRawBitLog(partOfRawLength, len(pd.bytes), pd.bitsOffset, bytes)) - perTrace(2, fmt.Sprintf("Encoded BIT STRING (length = %d): 0x%0x", partOfRawLength, bytes[byteOffset:byteOffset+sizes])) + perTrace(2, fmt.Sprintf("Encoded BIT STRING (length = %d): 0x%0x", partOfRawLength, + bytes[byteOffset:byteOffset+sizes])) rawLength -= (partOfRawLength - uint64(lb)) if rawLength > 0 { byteOffset += sizes @@ -226,11 +228,12 @@ func (pd *perRawBitData) appendBitString(bytes []byte, bitsLength uint64, extens break } } - return + return err } -func (pd *perRawBitData) appendOctetString(bytes []byte, extensive bool, lowerBoundPtr *int64, upperBoundPtr *int64) (err error) { +func (pd *perRawBitData) appendOctetString(bytes []byte, extensive bool, lowerBoundPtr *int64, + upperBoundPtr *int64) error { byteLen := uint64(len(bytes)) var lb, ub, sizeRange int64 = 0, -1, -1 if lowerBoundPtr != nil { @@ -240,19 +243,19 @@ func (pd *perRawBitData) appendOctetString(bytes []byte, extensive bool, lowerBo if byteLen <= uint64(ub) { sizeRange = ub - lb + 1 } else if !extensive { - err = fmt.Errorf("OctetString Length is over upperbound") - return + err := fmt.Errorf("OctetString Length is over upperbound") + return err } if extensive { - perTrace(2, fmt.Sprintf("Putting size Extension Value")) + perTrace(2, "Putting size Extension Value") if sizeRange == -1 { - if err := pd.putBitsValue(1, 1); err != nil { - log.Printf("putBitsValue(1, 1) err: %v", err) + if errTmp := pd.putBitsValue(1, 1); errTmp != nil { + log.Printf("putBitsValue(1, 1) err: %v", errTmp) } lb = 0 } else { - if err := pd.putBitsValue(0, 1); err != nil { - log.Printf("putBitsValue(0, 1) err: %v", err) + if errTmp := pd.putBitsValue(0, 1); errTmp != nil { + log.Printf("putBitsValue(0, 1) err: %v", errTmp) } } } @@ -266,7 +269,8 @@ func (pd *perRawBitData) appendOctetString(bytes []byte, extensive bool, lowerBo if sizeRange == 1 { if byteLen != uint64(ub) { - err = fmt.Errorf("OctetString Length(%d) is not match fix-sized : %d", byteLen, ub) + err := fmt.Errorf("OctetString Length(%d) is not match fix-sized : %d", byteLen, ub) + return err } perTrace(2, fmt.Sprintf("Encoding OCTET STRING size %d", ub)) if byteLen > 2 { @@ -274,10 +278,11 @@ func (pd *perRawBitData) appendOctetString(bytes []byte, extensive bool, lowerBo pd.bytes = append(pd.bytes, bytes...) perTrace(1, perRawBitLog(byteLen*8, len(pd.bytes), 0, bytes)) } else { - err = pd.putBitString(bytes, uint(byteLen*8)) + err := pd.putBitString(bytes, uint(byteLen*8)) + return err } perTrace(2, fmt.Sprintf("Encoded OCTET STRING (length = %d): 0x%0x", byteLen, bytes)) - return + return nil } rawLength := byteLen - uint64(lb) @@ -290,18 +295,19 @@ func (pd *perRawBitData) appendOctetString(bytes []byte, extensive bool, lowerBo } else { partOfRawLength = rawLength } - if err = pd.appendLength(sizeRange, partOfRawLength); err != nil { - return + if err := pd.appendLength(sizeRange, partOfRawLength); err != nil { + return err } partOfRawLength += uint64(lb) perTrace(2, fmt.Sprintf("Encoding OCTET STRING size %d", partOfRawLength)) if partOfRawLength == 0 { - return + return nil } pd.appendAlignBits() pd.bytes = append(pd.bytes, bytes[byteOffset:byteOffset+partOfRawLength]...) perTrace(1, perRawBitLog(partOfRawLength*8, len(pd.bytes), pd.bitsOffset, bytes)) - perTrace(2, fmt.Sprintf("Encoded OCTET STRING (length = %d): 0x%0x", partOfRawLength, bytes[byteOffset:byteOffset+partOfRawLength])) + perTrace(2, fmt.Sprintf("Encoded OCTET STRING (length = %d): 0x%0x", partOfRawLength, + bytes[byteOffset:byteOffset+partOfRawLength])) rawLength -= (partOfRawLength - uint64(lb)) if rawLength > 0 { byteOffset += partOfRawLength @@ -310,7 +316,7 @@ func (pd *perRawBitData) appendOctetString(bytes []byte, extensive bool, lowerBo break } } - return + return nil } @@ -318,42 +324,40 @@ func (pd *perRawBitData) appendBool(value bool) (err error) { perTrace(3, fmt.Sprintf("Encoding BOOLEAN Value %t", value)) if value { err = pd.putBitsValue(1, 1) - perTrace(2, fmt.Sprintf("Encoded BOOLEAN Value : 0x1")) + perTrace(2, "Encoded BOOLEAN Value : 0x1") } else { err = pd.putBitsValue(0, 1) - perTrace(2, fmt.Sprintf("Encoded BOOLEAN Value : 0x0")) + perTrace(2, "Encoded BOOLEAN Value : 0x0") } return } -func (pd *perRawBitData) appendInteger(value int64, extensive bool, lowerBoundPtr *int64, upperBoundPtr *int64) (err error) { +func (pd *perRawBitData) appendInteger(value int64, extensive bool, lowerBoundPtr *int64, upperBoundPtr *int64) error { var lb, valueRange int64 = 0, 0 if lowerBoundPtr != nil { lb = *lowerBoundPtr if value < lb { - err = fmt.Errorf("INTEGER value is smaller than lowerbound") - return + return fmt.Errorf("INTEGER value is smaller than lowerbound") } if upperBoundPtr != nil { ub := *upperBoundPtr if value <= ub { valueRange = ub - lb + 1 } else if !extensive { - err = fmt.Errorf("INTEGER value is larger than upperbound") - return + return fmt.Errorf("INTEGER value is larger than upperbound") } if extensive { - perTrace(2, fmt.Sprintf("Putting value Extension bit")) + perTrace(2, "Putting value Extension bit") if valueRange == 0 { - perTrace(3, fmt.Sprintf("Encoding INTEGER with Unconstraint Value")) + perTrace(3, "Encoding INTEGER with Unconstraint Value") valueRange = -1 - if err := pd.putBitsValue(1, 1); err != nil { - fmt.Printf("pd.putBitsValue(1, 1) error: %v", err) + if errTmp := pd.putBitsValue(1, 1); errTmp != nil { + fmt.Printf("pd.putBitsValue(1, 1) error: %v", errTmp) } } else { perTrace(3, fmt.Sprintf("Encoding INTEGER with Value Range(%d..%d)", lb, ub)) - if err := pd.putBitsValue(0, 1); err != nil { - fmt.Printf("pd.putBitsValue(0, 1) error: %v", err) + if errTmp := pd.putBitsValue(0, 1); errTmp != nil { + fmt.Printf("pd.putBitsValue(0, 1) error: %v", errTmp) } } } @@ -362,16 +366,16 @@ func (pd *perRawBitData) appendInteger(value int64, extensive bool, lowerBoundPt perTrace(3, fmt.Sprintf("Encoding INTEGER with Semi-Constraint Range(%d..)", lb)) } } else { - perTrace(3, fmt.Sprintf("Encoding INTEGER with Unconstraint Value")) + perTrace(3, "Encoding INTEGER with Unconstraint Value") valueRange = -1 } unsignedValue := uint64(value) var rawLength uint if valueRange == 1 { - perTrace(2, fmt.Sprintf("Value of INTEGER is fixed")) + perTrace(2, "Value of INTEGER is fixed") - return + return nil } if value < 0 { y := value >> 63 @@ -380,8 +384,7 @@ func (pd *perRawBitData) appendInteger(value int64, extensive bool, lowerBoundPt if valueRange <= 0 { unsignedValue >>= 7 } else if valueRange <= 65536 { - err = pd.appendConstraintValue(valueRange, uint64(value-lb)) - return + return pd.appendConstraintValue(valueRange, uint64(value-lb)) } else { unsignedValue >>= 8 } @@ -418,8 +421,8 @@ func (pd *perRawBitData) appendInteger(value int64, extensive bool, lowerBoundPt } } perTrace(2, fmt.Sprintf("Encoding INTEGER Length %d-1 in %d bits", rawLength, i)) - if err = pd.putBitsValue(uint64(rawLength-1), i); err != nil { - return + if err := pd.putBitsValue(uint64(rawLength-1), i); err != nil { + return err } } perTrace(2, fmt.Sprintf("Encoding INTEGER %d with %d bytes", value, rawLength)) @@ -429,49 +432,45 @@ func (pd *perRawBitData) appendInteger(value int64, extensive bool, lowerBoundPt if valueRange < 0 { mask := int64(1< ub { if extensive { - err = fmt.Errorf("Unsupport the extensive value of ENUMERATED ") + return fmt.Errorf("Unsupport the extensive value of ENUMERATED") } else { - err = fmt.Errorf("ENUMERATED value is larger than upperbound") + return fmt.Errorf("ENUMERATED value is larger than upperbound") } - return } else if signedValue < lb { - err = fmt.Errorf("ENUMERATED value is smaller than lowerbound") - return + return fmt.Errorf("ENUMERATED value is smaller than lowerbound") } if extensive { - if err = pd.putBitsValue(0, 1); err != nil { - return + if err := pd.putBitsValue(0, 1); err != nil { + return err } } valueRange := ub - lb + 1 perTrace(2, fmt.Sprintf("Encoding ENUMERATED Value : %d with Value Range(%d..%d)", value, lb, ub)) if valueRange > 1 { - err = pd.appendConstraintValue(valueRange, value) + return pd.appendConstraintValue(valueRange, value) } - return + return nil } -func (pd *perRawBitData) parseSequenceOf(v reflect.Value, params fieldParameters) (err error) { +func (pd *perRawBitData) parseSequenceOf(v reflect.Value, params fieldParameters) error { var lb, ub, sizeRange int64 = 0, -1, -1 numElements := int64(v.Len()) if params.sizeLowerBound != nil && *params.sizeLowerBound < 65536 { @@ -481,84 +480,82 @@ func (pd *perRawBitData) parseSequenceOf(v reflect.Value, params fieldParameters ub = *params.sizeUpperBound if params.sizeExtensible { if numElements > ub { - err = pd.putBitsValue(1, 1) + if err := pd.putBitsValue(1, 1); err != nil { + return err + } } else { - err = pd.putBitsValue(0, 1) + if err := pd.putBitsValue(0, 1); err != nil { + return err + } sizeRange = ub - lb + 1 } } else if numElements > ub { - err = fmt.Errorf("SEQUENCE OF Size is larger than upperbound") + return fmt.Errorf("SEQUENCE OF Size is larger than upperbound") } else { sizeRange = ub - lb + 1 } - if err != nil { - return - } - } else { sizeRange = -1 } if numElements < lb { - err = fmt.Errorf("SEQUENCE OF Size is lower than lowerbound") + return fmt.Errorf("SEQUENCE OF Size is lower than lowerbound") } else if sizeRange == 1 { perTrace(3, fmt.Sprintf("Encoding Length of \"SEQUENCE OF\" with fix-size %d", ub)) if numElements != ub { - err = fmt.Errorf("Encoding Length %d != fix-size %d", numElements, ub) + return fmt.Errorf("Encoding Length %d != fix-size %d", numElements, ub) } } else if sizeRange > 0 { perTrace(3, fmt.Sprintf("Encoding Length(%d) of \"SEQUENCE OF\" with Size Range(%d..%d)", numElements, lb, ub)) - err = pd.appendConstraintValue(sizeRange, uint64(numElements-lb)) + if err := pd.appendConstraintValue(sizeRange, uint64(numElements-lb)); err != nil { + return err + } } else { perTrace(3, fmt.Sprintf("Encoding Length(%d) of \"SEQUENCE OF\" with Semi-Constraint Range(%d..)", numElements, lb)) pd.appendAlignBits() pd.bytes = append(pd.bytes, byte(numElements&0xff)) perTrace(1, perRawBitLog(8, len(pd.bytes), pd.bitsOffset, uint64(numElements))) } - if err != nil { - return - } perTrace(2, fmt.Sprintf("Encoding \"SEQUENCE OF\" struct %s with len(%d)", v.Type().Elem().Name(), numElements)) params.sizeExtensible = false params.sizeUpperBound = nil params.sizeLowerBound = nil for i := 0; i < v.Len(); i++ { - err = pd.makeField(v.Index(i), params) - if err != nil { - return + if err := pd.makeField(v.Index(i), params); err != nil { + return err } } - return + return nil } -func (pd *perRawBitData) appendChoiceIndex(present int, extensive bool, upperBoundPtr *int64) (err error) { +func (pd *perRawBitData) appendChoiceIndex(present int, extensive bool, upperBoundPtr *int64) error { var ub int64 rawChoice := present - 1 if upperBoundPtr == nil { - err = fmt.Errorf("The upper bound of CHIOCE is missing") + return fmt.Errorf("The upper bound of CHIOCE is missing") } else if ub = *upperBoundPtr; ub < 0 { - err = fmt.Errorf("The upper bound of CHIOCE is negative") + return fmt.Errorf("The upper bound of CHIOCE is negative") } else if extensive && rawChoice > int(ub) { - err = fmt.Errorf("Unsupport value of CHOICE type is in Extensed") - } - if err != nil { - return + return fmt.Errorf("Unsupport value of CHOICE type is in Extensed") } perTrace(2, fmt.Sprintf("Encoding Present index of CHOICE %d - 1", present)) - err = pd.appendConstraintValue(ub+1, uint64(rawChoice)) - return + if err := pd.appendConstraintValue(ub+1, uint64(rawChoice)); err != nil { + return err + } + return nil } -func (pd *perRawBitData) appendOpenType(v reflect.Value, params fieldParameters) (err error) { +func (pd *perRawBitData) appendOpenType(v reflect.Value, params fieldParameters) error { pdOpenType := &perRawBitData{[]byte(""), 0} perTrace(2, fmt.Sprintf("Encoding OpenType %s to temp RawData", v.Type().String())) - if err = pdOpenType.makeField(v, params); err != nil { - return + if err := pdOpenType.makeField(v, params); err != nil { + return err } openTypeBytes := pdOpenType.bytes rawLength := uint64(len(pdOpenType.bytes)) - perTrace(2, fmt.Sprintf("Encoding OpenType %s RawData : 0x%0x(%d bytes)", v.Type().String(), pdOpenType.bytes, rawLength)) + perTrace(2, fmt.Sprintf("Encoding OpenType %s RawData : 0x%0x(%d bytes)", v.Type().String(), pdOpenType.bytes, + rawLength)) var byteOffset, partOfRawLength uint64 for { @@ -569,17 +566,18 @@ func (pd *perRawBitData) appendOpenType(v reflect.Value, params fieldParameters) } else { partOfRawLength = rawLength } - if err = pd.appendLength(-1, partOfRawLength); err != nil { - return + if err := pd.appendLength(-1, partOfRawLength); err != nil { + return err } perTrace(2, fmt.Sprintf("Encoding Part of OpenType RawData size %d", partOfRawLength)) if partOfRawLength == 0 { - return + return nil } pd.appendAlignBits() pd.bytes = append(pd.bytes, openTypeBytes[byteOffset:byteOffset+partOfRawLength]...) perTrace(1, perRawBitLog(partOfRawLength*8, len(pd.bytes), pd.bitsOffset, openTypeBytes)) - perTrace(2, fmt.Sprintf("Encoded OpenType RawData (length = %d): 0x%0x", partOfRawLength, openTypeBytes[byteOffset:byteOffset+partOfRawLength])) + perTrace(2, fmt.Sprintf("Encoded OpenType RawData (length = %d): 0x%0x", partOfRawLength, + openTypeBytes[byteOffset:byteOffset+partOfRawLength])) rawLength -= partOfRawLength if rawLength > 0 { byteOffset += partOfRawLength @@ -590,9 +588,9 @@ func (pd *perRawBitData) appendOpenType(v reflect.Value, params fieldParameters) } perTrace(2, fmt.Sprintf("Encoded OpenType %s", v.Type().String())) - return + return nil } -func (pd *perRawBitData) makeField(v reflect.Value, params fieldParameters) (err error) { +func (pd *perRawBitData) makeField(v reflect.Value, params fieldParameters) error { if !v.IsValid() { return fmt.Errorf("aper: cannot marshal nil value") } @@ -608,25 +606,26 @@ func (pd *perRawBitData) makeField(v reflect.Value, params fieldParameters) (err // We deal with the structures defined in this package first. switch fieldType { case BitStringType: - err = pd.appendBitString(v.Field(0).Bytes(), v.Field(1).Uint(), params.sizeExtensible, params.sizeLowerBound, params.sizeUpperBound) - return + err := pd.appendBitString(v.Field(0).Bytes(), v.Field(1).Uint(), params.sizeExtensible, params.sizeLowerBound, + params.sizeUpperBound) + return err case ObjectIdentifierType: - err = fmt.Errorf("Unsupport ObjectIdenfier type") - return + err := fmt.Errorf("Unsupport ObjectIdenfier type") + return err case OctetStringType: - err = pd.appendOctetString(v.Bytes(), params.sizeExtensible, params.sizeLowerBound, params.sizeUpperBound) - return + err := pd.appendOctetString(v.Bytes(), params.sizeExtensible, params.sizeLowerBound, params.sizeUpperBound) + return err case EnumeratedType: - err = pd.appendEnumerated(v.Uint(), params.valueExtensible, params.valueLowerBound, params.valueUpperBound) - return + err := pd.appendEnumerated(v.Uint(), params.valueExtensible, params.valueLowerBound, params.valueUpperBound) + return err } switch val := v; val.Kind() { case reflect.Bool: - err = pd.appendBool(v.Bool()) - return + err := pd.appendBool(v.Bool()) + return err case reflect.Int, reflect.Int32, reflect.Int64: - err = pd.appendInteger(v.Int(), params.valueExtensible, params.valueLowerBound, params.valueUpperBound) - return + err := pd.appendInteger(v.Int(), params.valueExtensible, params.valueLowerBound, params.valueUpperBound) + return err case reflect.Struct: @@ -638,16 +637,15 @@ func (pd *perRawBitData) makeField(v reflect.Value, params fieldParameters) (err // struct extensive TODO: support extensed type if params.valueExtensible { perTrace(2, fmt.Sprintf("Encoding Value Extensive Bit : %t", false)) - if err = pd.putBitsValue(0, 1); err != nil { - return + if err := pd.putBitsValue(0, 1); err != nil { + return err } } sequenceType = (structType.NumField() <= 0 || structType.Field(0).Name != "Present") // pass tag for optional for i := 0; i < structType.NumField(); i++ { if structType.Field(i).PkgPath != "" { - err = fmt.Errorf("struct contains unexported fields : " + structType.Field(i).PkgPath) - return + return fmt.Errorf("struct contains unexported fields : " + structType.Field(i).PkgPath) } tempParams := parseFieldParameters(structType.Field(i).Tag.Get("aper")) if sequenceType { @@ -660,7 +658,7 @@ func (pd *perRawBitData) makeField(v reflect.Value, params fieldParameters) (err optionalPresents++ } } else if v.Field(i).Type().Kind() == reflect.Ptr && v.Field(i).IsNil() { - err = fmt.Errorf("nil element in SEQUENCE type") + return fmt.Errorf("nil element in SEQUENCE type") } } @@ -668,8 +666,8 @@ func (pd *perRawBitData) makeField(v reflect.Value, params fieldParameters) (err } if optionalCount > 0 { perTrace(2, fmt.Sprintf("putting optional(%d), optionalPresents is %0b", optionalCount, optionalPresents)) - if err = pd.putBitsValue(optionalPresents, optionalCount); err != nil { - return + if err := pd.putBitsValue(optionalPresents, optionalCount); err != nil { + return err } } @@ -677,31 +675,31 @@ func (pd *perRawBitData) makeField(v reflect.Value, params fieldParameters) (err if !sequenceType { present := int(v.Field(0).Int()) if present == 0 { - err = fmt.Errorf("CHOICE or OpenType present is 0(present's field number)") + return fmt.Errorf("CHOICE or OpenType present is 0(present's field number)") } else if present >= structType.NumField() { - err = fmt.Errorf("Present is bigger than number of struct field") + return fmt.Errorf("Present is bigger than number of struct field") } else if params.openType { if params.referenceFieldValue == nil { - err = fmt.Errorf("OpenType reference value is empty") - return + return fmt.Errorf("OpenType reference value is empty") } refValue := *params.referenceFieldValue if structParams[present].referenceFieldValue == nil || *structParams[present].referenceFieldValue != refValue { - err = fmt.Errorf("reference value and present reference value is not match") - return + return fmt.Errorf("reference value and present reference value is not match") } perTrace(2, fmt.Sprintf("Encoding Present index of OpenType is %d ", present)) - err = pd.appendOpenType(val.Field(present), structParams[present]) + if err := pd.appendOpenType(val.Field(present), structParams[present]); err != nil { + return err + } } else { - err = pd.appendChoiceIndex(present, params.valueExtensible, params.valueUpperBound) - - if err != nil { - return + if err := pd.appendChoiceIndex(present, params.valueExtensible, params.valueUpperBound); err != nil { + return err + } + if err := pd.makeField(val.Field(present), structParams[present]); err != nil { + return err } - err = pd.makeField(val.Field(present), structParams[present]) } - return + return nil } @@ -726,33 +724,31 @@ func (pd *perRawBitData) makeField(v reflect.Value, params fieldParameters) (err } } if index == i { - err = fmt.Errorf("Open type is not reference to the other field in the struct") - return + return fmt.Errorf("Open type is not reference to the other field in the struct") } structParams[i].referenceFieldValue = new(int64) - *structParams[i].referenceFieldValue, err = getReferenceFieldValue(val.Field(index)) - if err != nil { - return + if value, err := getReferenceFieldValue(val.Field(index)); err != nil { + return err + } else { + *structParams[i].referenceFieldValue = value } } - err = pd.makeField(val.Field(i), structParams[i]) - if err != nil { - return + if err := pd.makeField(val.Field(i), structParams[i]); err != nil { + return err } } - return + return nil case reflect.Slice: - err = pd.parseSequenceOf(v, params) - return + err := pd.parseSequenceOf(v, params) + return err case reflect.String: printableString := v.String() perTrace(2, fmt.Sprintf("Encoding PrintableString : \"%s\" using Octet String decoding method", printableString)) - err = pd.appendOctetString([]byte(printableString), params.sizeExtensible, params.sizeLowerBound, params.sizeUpperBound) - return + err := pd.appendOctetString([]byte(printableString), params.sizeExtensible, params.sizeLowerBound, + params.sizeUpperBound) + return err } - err = fmt.Errorf("unsupported: " + v.Type().String()) - return - + return fmt.Errorf("unsupported: " + v.Type().String()) } // Marshal returns the ASN.1 encoding of val. diff --git a/version/version.go b/version/version.go index f89f034..934feed 100644 --- a/version/version.go +++ b/version/version.go @@ -1,7 +1,9 @@ package version +// VERSION : lastest version var VERSION = "2020-03-31-01" +// GetVersion : Get the latest version func GetVersion() (version string) { return VERSION } diff --git a/version/version_test.go b/version/version_test.go new file mode 100644 index 0000000..433b286 --- /dev/null +++ b/version/version_test.go @@ -0,0 +1,11 @@ +package version_test + +import ( + "free5gc/lib/aper/version" + "github.com/stretchr/testify/assert" + "testing" +) + +func TestVersion(t *testing.T) { + assert.Equal(t, "2020-03-31-01", version.GetVersion()) +}