Wala shell

Advanced PHP File Manager

Server IP: 127.0.0.1 | PHP Version: 8.3.30 | Domains Hosted: 54

Name	Size	Last Modified	Actions
📁 ..	-	2025-05-25 12:27
📄 build.go // Package jsonutil provides JSON serialization of AWS requests and responses. package jsonutil import ( "bytes" "encoding/base64" "fmt" "math" "reflect" "sort" "strconv" "time" "github.com/aws/aws-sdk-go/aws" "github.com/aws/aws-sdk-go/private/protocol" ) const ( floatNaN = "NaN" floatInf = "Infinity" floatNegInf = "-Infinity" ) var timeType = reflect.ValueOf(time.Time{}).Type() var byteSliceType = reflect.ValueOf([]byte{}).Type() // BuildJSON builds a JSON string for a given object v. func BuildJSON(v interface{}) ([]byte, error) { var buf bytes.Buffer err := buildAny(reflect.ValueOf(v), &buf, "") return buf.Bytes(), err } func buildAny(value reflect.Value, buf bytes.Buffer, tag reflect.StructTag) error { origVal := value value = reflect.Indirect(value) if !value.IsValid() { return nil } vtype := value.Type() t := tag.Get("type") if t == "" { switch vtype.Kind() { case reflect.Struct: // also it can't be a time object if value.Type() != timeType { t = "structure" } case reflect.Slice: // also it can't be a byte slice if _, ok := value.Interface().([]byte); !ok { t = "list" } case reflect.Map: // cannot be a JSONValue map if _, ok := value.Interface().(aws.JSONValue); !ok { t = "map" } } } switch t { case "structure": if field, ok := vtype.FieldByName("_"); ok { tag = field.Tag } return buildStruct(value, buf, tag) case "list": return buildList(value, buf, tag) case "map": return buildMap(value, buf, tag) default: return buildScalar(origVal, buf, tag) } } func buildStruct(value reflect.Value, buf bytes.Buffer, tag reflect.StructTag) error { if !value.IsValid() { return nil } // unwrap payloads if payload := tag.Get("payload"); payload != "" { field, _ := value.Type().FieldByName(payload) tag = field.Tag value = elemOf(value.FieldByName(payload)) if !value.IsValid() && tag.Get("type") != "structure" { return nil } } buf.WriteByte('{') defer buf.WriteString("}") if !value.IsValid() { return nil } t := value.Type() first := true for i := 0; i < t.NumField(); i++ { member := value.Field(i) // This allocates the most memory. // Additionally, we cannot skip nil fields due to // idempotency auto filling. field := t.Field(i) if field.PkgPath != "" { continue // ignore unexported fields } if field.Tag.Get("json") == "-" { continue } if field.Tag.Get("location") != "" { continue // ignore non-body elements } if field.Tag.Get("ignore") != "" { continue } if protocol.CanSetIdempotencyToken(member, field) { token := protocol.GetIdempotencyToken() member = reflect.ValueOf(&token) } if (member.Kind() == reflect.Ptr \|\| member.Kind() == reflect.Slice \|\| member.Kind() == reflect.Map) && member.IsNil() { continue // ignore unset fields } if first { first = false } else { buf.WriteByte(',') } // figure out what this field is called name := field.Name if locName := field.Tag.Get("locationName"); locName != "" { name = locName } writeString(name, buf) buf.WriteString(`:`) err := buildAny(member, buf, field.Tag) if err != nil { return err } } return nil } func buildList(value reflect.Value, buf bytes.Buffer, tag reflect.StructTag) error { buf.WriteString("[") for i := 0; i < value.Len(); i++ { buildAny(value.Index(i), buf, "") if i < value.Len()-1 { buf.WriteString(",") } } buf.WriteString("]") return nil } type sortedValues []reflect.Value func (sv sortedValues) Len() int { return len(sv) } func (sv sortedValues) Swap(i, j int) { sv[i], sv[j] = sv[j], sv[i] } func (sv sortedValues) Less(i, j int) bool { return sv[i].String() < sv[j].String() } func buildMap(value reflect.Value, buf bytes.Buffer, tag reflect.StructTag) error { buf.WriteString("{") sv := sortedValues(value.MapKeys()) sort.Sort(sv) for i, k := range sv { if i > 0 { buf.WriteByte(',') } writeString(k.String(), buf) buf.WriteString(`:`) buildAny(value.MapIndex(k), buf, "") } buf.WriteString("}") return nil } func buildScalar(v reflect.Value, buf bytes.Buffer, tag reflect.StructTag) error { // prevents allocation on the heap. scratch := [64]byte{} switch value := reflect.Indirect(v); value.Kind() { case reflect.String: writeString(value.String(), buf) case reflect.Bool: if value.Bool() { buf.WriteString("true") } else { buf.WriteString("false") } case reflect.Int64: buf.Write(strconv.AppendInt(scratch[:0], value.Int(), 10)) case reflect.Float64: f := value.Float() switch { case math.IsNaN(f): writeString(floatNaN, buf) case math.IsInf(f, 1): writeString(floatInf, buf) case math.IsInf(f, -1): writeString(floatNegInf, buf) default: buf.Write(strconv.AppendFloat(scratch[:0], f, 'f', -1, 64)) } default: switch converted := value.Interface().(type) { case time.Time: format := tag.Get("timestampFormat") if len(format) == 0 { format = protocol.UnixTimeFormatName } ts := protocol.FormatTime(format, converted) if format != protocol.UnixTimeFormatName { ts = `"` + ts + `"` } buf.WriteString(ts) case []byte: if !value.IsNil() { buf.WriteByte('"') if len(converted) < 1024 { // for small buffers, using Encode directly is much faster. dst := make([]byte, base64.StdEncoding.EncodedLen(len(converted))) base64.StdEncoding.Encode(dst, converted) buf.Write(dst) } else { // for large buffers, avoid unnecessary extra temporary // buffer space. enc := base64.NewEncoder(base64.StdEncoding, buf) enc.Write(converted) enc.Close() } buf.WriteByte('"') } case aws.JSONValue: str, err := protocol.EncodeJSONValue(converted, protocol.QuotedEscape) if err != nil { return fmt.Errorf("unable to encode JSONValue, %v", err) } buf.WriteString(str) default: return fmt.Errorf("unsupported JSON value %v (%s)", value.Interface(), value.Type()) } } return nil } var hex = "0123456789abcdef" func writeString(s string, buf bytes.Buffer) { buf.WriteByte('"') for i := 0; i < len(s); i++ { if s[i] == '"' { buf.WriteString(`\"`) } else if s[i] == '\\' { buf.WriteString(`\\`) } else if s[i] == '\b' { buf.WriteString(`\b`) } else if s[i] == '\f' { buf.WriteString(`\f`) } else if s[i] == '\r' { buf.WriteString(`\r`) } else if s[i] == '\t' { buf.WriteString(`\t`) } else if s[i] == '\n' { buf.WriteString(`\n`) } else if s[i] < 32 { buf.WriteString("\\u00") buf.WriteByte(hex[s[i]>>4]) buf.WriteByte(hex[s[i]&0xF]) } else { buf.WriteByte(s[i]) } } buf.WriteByte('"') } // Returns the reflection element of a value, if it is a pointer. func elemOf(value reflect.Value) reflect.Value { for value.Kind() == reflect.Ptr { value = value.Elem() } return value }	6.76 KB	2025-05-25 12:27
📄 build_test.go package jsonutil_test import ( "encoding/json" "math" "strings" "testing" "time" "github.com/aws/aws-sdk-go/private/protocol/json/jsonutil" ) func S(s string) string { return &s } func D(s int64) int64 { return &s } func F(s float64) float64 { return &s } func T(s time.Time) time.Time { return &s } type J struct { S string SS []string D int64 F float64 T time.Time } var zero = 0.0 var jsonTests = []struct { in interface{} out string err string }{ { in: J{}, out: `{}`, }, { in: J{ S: S("str"), SS: []string{"A", "B", "C"}, D: D(123), F: F(4.56), T: T(time.Unix(987, 0)), }, out: `{"S":"str","SS":["A","B","C"],"D":123,"F":4.56,"T":987}`, }, { in: J{ S: S(`"''"`), }, out: `{"S":"\"''\""}`, }, { in: J{ S: S("\x00føø\u00FF\n\\\"\r\t\b\f"), }, out: `{"S":"\u0000føøÿ\n\\\"\r\t\b\f"}`, }, { in: J{ F: F(math.NaN()), }, out: `{"F":"NaN"}`, }, { in: J{ F: F(math.Inf(1)), }, out: `{"F":"Infinity"}`, }, { in: J{ F: F(math.Inf(-1)), }, out: `{"F":"-Infinity"}`, }, } func TestBuildJSON(t testing.T) { for _, test := range jsonTests { out, err := jsonutil.BuildJSON(test.in) if test.err != "" { if err == nil { t.Errorf("expect error") } if e, a := test.err, err.Error(); !strings.Contains(a, e) { t.Errorf("expect %v, to contain %v", e, a) } } else { if err != nil { t.Errorf("expect nil, %v", err) } if e, a := string(out), test.out; e != a { t.Errorf("expect %v, got %v", e, a) } } } } func BenchmarkBuildJSON(b testing.B) { for i := 0; i < b.N; i++ { for _, test := range jsonTests { jsonutil.BuildJSON(test.in) } } } func BenchmarkStdlibJSON(b *testing.B) { for i := 0; i < b.N; i++ { for _, test := range jsonTests { json.Marshal(test.in) } } }	1.81 KB	2025-05-25 12:27
📄 unmarshal.go package jsonutil import ( "bytes" "encoding/base64" "encoding/json" "fmt" "io" "math" "math/big" "reflect" "strings" "time" "github.com/aws/aws-sdk-go/aws" "github.com/aws/aws-sdk-go/aws/awserr" "github.com/aws/aws-sdk-go/private/protocol" ) var millisecondsFloat = new(big.Float).SetInt64(1e3) // UnmarshalJSONError unmarshal's the reader's JSON document into the passed in // type. The value to unmarshal the json document into must be a pointer to the // type. func UnmarshalJSONError(v interface{}, stream io.Reader) error { var errBuf bytes.Buffer body := io.TeeReader(stream, &errBuf) err := json.NewDecoder(body).Decode(v) if err != nil { msg := "failed decoding error message" if err == io.EOF { msg = "error message missing" err = nil } return awserr.NewUnmarshalError(err, msg, errBuf.Bytes()) } return nil } // UnmarshalJSON reads a stream and unmarshals the results in object v. func UnmarshalJSON(v interface{}, stream io.Reader) error { var out interface{} decoder := json.NewDecoder(stream) decoder.UseNumber() err := decoder.Decode(&out) if err == io.EOF { return nil } else if err != nil { return err } return unmarshaler{}.unmarshalAny(reflect.ValueOf(v), out, "") } // UnmarshalJSONCaseInsensitive reads a stream and unmarshals the result into the // object v. Ignores casing for structure members. func UnmarshalJSONCaseInsensitive(v interface{}, stream io.Reader) error { var out interface{} decoder := json.NewDecoder(stream) decoder.UseNumber() err := decoder.Decode(&out) if err == io.EOF { return nil } else if err != nil { return err } return unmarshaler{ caseInsensitive: true, }.unmarshalAny(reflect.ValueOf(v), out, "") } type unmarshaler struct { caseInsensitive bool } func (u unmarshaler) unmarshalAny(value reflect.Value, data interface{}, tag reflect.StructTag) error { vtype := value.Type() if vtype.Kind() == reflect.Ptr { vtype = vtype.Elem() // check kind of actual element type } t := tag.Get("type") if t == "" { switch vtype.Kind() { case reflect.Struct: // also it can't be a time object if _, ok := value.Interface().(time.Time); !ok { t = "structure" } case reflect.Slice: // also it can't be a byte slice if _, ok := value.Interface().([]byte); !ok { t = "list" } case reflect.Map: // cannot be a JSONValue map if _, ok := value.Interface().(aws.JSONValue); !ok { t = "map" } } } switch t { case "structure": if field, ok := vtype.FieldByName("_"); ok { tag = field.Tag } return u.unmarshalStruct(value, data, tag) case "list": return u.unmarshalList(value, data, tag) case "map": return u.unmarshalMap(value, data, tag) default: return u.unmarshalScalar(value, data, tag) } } func (u unmarshaler) unmarshalStruct(value reflect.Value, data interface{}, tag reflect.StructTag) error { if data == nil { return nil } mapData, ok := data.(map[string]interface{}) if !ok { return fmt.Errorf("JSON value is not a structure (%#v)", data) } t := value.Type() if value.Kind() == reflect.Ptr { if value.IsNil() { // create the structure if it's nil s := reflect.New(value.Type().Elem()) value.Set(s) value = s } value = value.Elem() t = t.Elem() } // unwrap any payloads if payload := tag.Get("payload"); payload != "" { field, _ := t.FieldByName(payload) return u.unmarshalAny(value.FieldByName(payload), data, field.Tag) } for i := 0; i < t.NumField(); i++ { field := t.Field(i) if field.PkgPath != "" { continue // ignore unexported fields } // figure out what this field is called name := field.Name if locName := field.Tag.Get("locationName"); locName != "" { name = locName } if u.caseInsensitive { if _, ok := mapData[name]; !ok { // Fallback to uncased name search if the exact name didn't match. for kn, v := range mapData { if strings.EqualFold(kn, name) { mapData[name] = v } } } } member := value.FieldByIndex(field.Index) err := u.unmarshalAny(member, mapData[name], field.Tag) if err != nil { return err } } return nil } func (u unmarshaler) unmarshalList(value reflect.Value, data interface{}, tag reflect.StructTag) error { if data == nil { return nil } listData, ok := data.([]interface{}) if !ok { return fmt.Errorf("JSON value is not a list (%#v)", data) } if value.IsNil() { l := len(listData) value.Set(reflect.MakeSlice(value.Type(), l, l)) } for i, c := range listData { err := u.unmarshalAny(value.Index(i), c, "") if err != nil { return err } } return nil } func (u unmarshaler) unmarshalMap(value reflect.Value, data interface{}, tag reflect.StructTag) error { if data == nil { return nil } mapData, ok := data.(map[string]interface{}) if !ok { return fmt.Errorf("JSON value is not a map (%#v)", data) } if value.IsNil() { value.Set(reflect.MakeMap(value.Type())) } for k, v := range mapData { kvalue := reflect.ValueOf(k) vvalue := reflect.New(value.Type().Elem()).Elem() u.unmarshalAny(vvalue, v, "") value.SetMapIndex(kvalue, vvalue) } return nil } func (u unmarshaler) unmarshalScalar(value reflect.Value, data interface{}, tag reflect.StructTag) error { switch d := data.(type) { case nil: return nil // nothing to do here case string: switch value.Interface().(type) { case string: value.Set(reflect.ValueOf(&d)) case []byte: b, err := base64.StdEncoding.DecodeString(d) if err != nil { return err } value.Set(reflect.ValueOf(b)) case time.Time: format := tag.Get("timestampFormat") if len(format) == 0 { format = protocol.ISO8601TimeFormatName } t, err := protocol.ParseTime(format, d) if err != nil { return err } value.Set(reflect.ValueOf(&t)) case aws.JSONValue: // No need to use escaping as the value is a non-quoted string. v, err := protocol.DecodeJSONValue(d, protocol.NoEscape) if err != nil { return err } value.Set(reflect.ValueOf(v)) case float64: // These are regular strings when parsed by encoding/json's unmarshaler. switch { case strings.EqualFold(d, floatNaN): value.Set(reflect.ValueOf(aws.Float64(math.NaN()))) case strings.EqualFold(d, floatInf): value.Set(reflect.ValueOf(aws.Float64(math.Inf(1)))) case strings.EqualFold(d, floatNegInf): value.Set(reflect.ValueOf(aws.Float64(math.Inf(-1)))) default: return fmt.Errorf("unknown JSON number value: %s", d) } default: return fmt.Errorf("unsupported value: %v (%s)", value.Interface(), value.Type()) } case json.Number: switch value.Interface().(type) { case int64: // Retain the old behavior where we would just truncate the float64 // calling d.Int64() here could cause an invalid syntax error due to the usage of strconv.ParseInt f, err := d.Float64() if err != nil { return err } di := int64(f) value.Set(reflect.ValueOf(&di)) case float64: f, err := d.Float64() if err != nil { return err } value.Set(reflect.ValueOf(&f)) case time.Time: float, ok := new(big.Float).SetString(d.String()) if !ok { return fmt.Errorf("unsupported float time representation: %v", d.String()) } float = float.Mul(float, millisecondsFloat) ms, _ := float.Int64() t := time.Unix(0, ms1e6).UTC() value.Set(reflect.ValueOf(&t)) default: return fmt.Errorf("unsupported value: %v (%s)", value.Interface(), value.Type()) } case bool: switch value.Interface().(type) { case *bool: value.Set(reflect.ValueOf(&d)) default: return fmt.Errorf("unsupported value: %v (%s)", value.Interface(), value.Type()) } default: return fmt.Errorf("unsupported JSON value (%v)", data) } return nil }	7.59 KB	2025-05-25 12:27
📄 unmarshal_test.go //go:build go1.7 // +build go1.7 package jsonutil_test import ( "bytes" "math" "reflect" "testing" "time" "github.com/aws/aws-sdk-go/aws" "github.com/aws/aws-sdk-go/private/protocol/json/jsonutil" ) func TestUnmarshalJSON_JSONNumber(t testing.T) { type input struct { TimeField time.Time `locationName:"timeField"` IntField int64 `locationName:"intField"` FloatField float64 `locationName:"floatField"` } cases := map[string]struct { JSON string Value input Expected input ExpectedFn func(testing.T, input) }{ "seconds precision": { JSON: `{"timeField":1597094942}`, Expected: input{ TimeField: func() time.Time { dt := time.Date(2020, 8, 10, 21, 29, 02, 00, time.UTC) return &dt }(), }, }, "exact milliseconds precision": { JSON: `{"timeField":1597094942.123}`, Expected: input{ TimeField: func() time.Time { dt := time.Date(2020, 8, 10, 21, 29, 02, int(123time.Millisecond), time.UTC) return &dt }(), }, }, "microsecond precision truncated": { JSON: `{"timeField":1597094942.1235}`, Expected: input{ TimeField: func() time.Time { dt := time.Date(2020, 8, 10, 21, 29, 02, int(123time.Millisecond), time.UTC) return &dt }(), }, }, "nanosecond precision truncated": { JSON: `{"timeField":1597094942.123456789}`, Expected: input{ TimeField: func() time.Time { dt := time.Date(2020, 8, 10, 21, 29, 02, int(123time.Millisecond), time.UTC) return &dt }(), }, }, "milliseconds precision as small exponent": { JSON: `{"timeField":1.597094942123e9}`, Expected: input{ TimeField: func() time.Time { dt := time.Date(2020, 8, 10, 21, 29, 02, int(123time.Millisecond), time.UTC) return &dt }(), }, }, "milliseconds precision as large exponent": { JSON: `{"timeField":1.597094942123E9}`, Expected: input{ TimeField: func() time.Time { dt := time.Date(2020, 8, 10, 21, 29, 02, int(123time.Millisecond), time.UTC) return &dt }(), }, }, "milliseconds precision as exponent with sign": { JSON: `{"timeField":1.597094942123e+9}`, Expected: input{ TimeField: func() time.Time { dt := time.Date(2020, 8, 10, 21, 29, 02, int(123time.Millisecond), time.UTC) return &dt }(), }, }, "integer field": { JSON: `{"intField":123456789}`, Expected: input{ IntField: aws.Int64(123456789), }, }, "integer field truncated": { JSON: `{"intField":123456789.123}`, Expected: input{ IntField: aws.Int64(123456789), }, }, "float64 field": { JSON: `{"floatField":123456789.123}`, Expected: input{ FloatField: aws.Float64(123456789.123), }, }, "float64 field NaN": { JSON: `{"floatField":"NaN"}`, ExpectedFn: func(t testing.T, input input) { if input.FloatField == nil { t.Fatal("expect non nil float64") } if e, a := true, math.IsNaN(input.FloatField); e != a { t.Errorf("expect %v, got %v", e, a) } }, }, "float64 field Infinity": { JSON: `{"floatField":"Infinity"}`, Expected: input{ FloatField: aws.Float64(math.Inf(1)), }, }, "float64 field -Infinity": { JSON: `{"floatField":"-Infinity"}`, Expected: input{ FloatField: aws.Float64(math.Inf(-1)), }, }, } for name, tt := range cases { t.Run(name, func(t *testing.T) { err := jsonutil.UnmarshalJSON(&tt.Value, bytes.NewReader([]byte(tt.JSON))) if err != nil { t.Errorf("expect no error, got %v", err) } if tt.ExpectedFn != nil { tt.ExpectedFn(t, tt.Value) return } if e, a := tt.Expected, tt.Value; !reflect.DeepEqual(e, a) { t.Errorf("expect %v, got %v", e, a) } }) } }	3.66 KB	2025-05-25 12:27

Terminal