1
//
2
// Copyright (c) 2011-2019 Canonical Ltd
3
//
4
// Licensed under the Apache License, Version 2.0 (the "License");
5
// you may not use this file except in compliance with the License.
6
// You may obtain a copy of the License at
7
//
8
//     http://www.apache.org/licenses/LICENSE-2.0
9
//
10
// Unless required by applicable law or agreed to in writing, software
11
// distributed under the License is distributed on an "AS IS" BASIS,
12
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13
// See the License for the specific language governing permissions and
14
// limitations under the License.
15

16
package yaml
17

18
import (
19
	"encoding/base64"
20
	"math"
21
	"regexp"
22
	"strconv"
23
	"strings"
24
	"time"
25
)
26

27
type resolveMapItem struct {
28
	value interface{}
29
	tag   string
30
}
31

32
var resolveTable = make([]byte, 256)
33
var resolveMap = make(map[string]resolveMapItem)
34

35
func init() {
36
	t := resolveTable
37
	t[int('+')] = 'S' // Sign
38
	t[int('-')] = 'S'
39
	for _, c := range "0123456789" {
40
		t[int(c)] = 'D' // Digit
41
	}
42
	for _, c := range "yYnNtTfFoO~" {
43
		t[int(c)] = 'M' // In map
44
	}
45
	t[int('.')] = '.' // Float (potentially in map)
46

47
	var resolveMapList = []struct {
48
		v   interface{}
49
		tag string
50
		l   []string
51
	}{
52
		{true, boolTag, []string{"true", "True", "TRUE"}},
53
		{false, boolTag, []string{"false", "False", "FALSE"}},
54
		{nil, nullTag, []string{"", "~", "null", "Null", "NULL"}},
55
		{math.NaN(), floatTag, []string{".nan", ".NaN", ".NAN"}},
56
		{math.Inf(+1), floatTag, []string{".inf", ".Inf", ".INF"}},
57
		{math.Inf(+1), floatTag, []string{"+.inf", "+.Inf", "+.INF"}},
58
		{math.Inf(-1), floatTag, []string{"-.inf", "-.Inf", "-.INF"}},
59
		{"<<", mergeTag, []string{"<<"}},
60
	}
61

62
	m := resolveMap
63
	for _, item := range resolveMapList {
64
		for _, s := range item.l {
65
			m[s] = resolveMapItem{item.v, item.tag}
66
		}
67
	}
68
}
69

70
const (
71
	nullTag      = "!!null"
72
	boolTag      = "!!bool"
73
	strTag       = "!!str"
74
	intTag       = "!!int"
75
	floatTag     = "!!float"
76
	timestampTag = "!!timestamp"
77
	seqTag       = "!!seq"
78
	mapTag       = "!!map"
79
	binaryTag    = "!!binary"
80
	mergeTag     = "!!merge"
81
)
82

83
var longTags = make(map[string]string)
84
var shortTags = make(map[string]string)
85

86
func init() {
87
	for _, stag := range []string{nullTag, boolTag, strTag, intTag, floatTag, timestampTag, seqTag, mapTag, binaryTag, mergeTag} {
88
		ltag := longTag(stag)
89
		longTags[stag] = ltag
90
		shortTags[ltag] = stag
91
	}
92
}
93

94
const longTagPrefix = "tag:yaml.org,2002:"
95

96
func shortTag(tag string) string {
97
	if strings.HasPrefix(tag, longTagPrefix) {
98
		if stag, ok := shortTags[tag]; ok {
99
			return stag
100
		}
101
		return "!!" + tag[len(longTagPrefix):]
102
	}
103
	return tag
104
}
105

106
func longTag(tag string) string {
107
	if strings.HasPrefix(tag, "!!") {
108
		if ltag, ok := longTags[tag]; ok {
109
			return ltag
110
		}
111
		return longTagPrefix + tag[2:]
112
	}
113
	return tag
114
}
115

116
func resolvableTag(tag string) bool {
117
	switch tag {
118
	case "", strTag, boolTag, intTag, floatTag, nullTag, timestampTag:
119
		return true
120
	}
121
	return false
122
}
123

124
var yamlStyleFloat = regexp.MustCompile(`^[-+]?(\.[0-9]+|[0-9]+(\.[0-9]*)?)([eE][-+]?[0-9]+)?$`)
125

126
func resolve(tag string, in string) (rtag string, out interface{}) {
127
	tag = shortTag(tag)
128
	if !resolvableTag(tag) {
129
		return tag, in
130
	}
131

132
	defer func() {
133
		switch tag {
134
		case "", rtag, strTag, binaryTag:
135
			return
136
		case floatTag:
137
			if rtag == intTag {
138
				switch v := out.(type) {
139
				case int64:
140
					rtag = floatTag
141
					out = float64(v)
142
					return
143
				case int:
144
					rtag = floatTag
145
					out = float64(v)
146
					return
147
				}
148
			}
149
		}
150
		failf("cannot decode %s `%s` as a %s", shortTag(rtag), in, shortTag(tag))
151
	}()
152

153
	// Any data is accepted as a !!str or !!binary.
154
	// Otherwise, the prefix is enough of a hint about what it might be.
155
	hint := byte('N')
156
	if in != "" {
157
		hint = resolveTable[in[0]]
158
	}
159
	if hint != 0 && tag != strTag && tag != binaryTag {
160
		// Handle things we can lookup in a map.
161
		if item, ok := resolveMap[in]; ok {
162
			return item.tag, item.value
163
		}
164

165
		// Base 60 floats are a bad idea, were dropped in YAML 1.2, and
166
		// are purposefully unsupported here. They're still quoted on
167
		// the way out for compatibility with other parser, though.
168

169
		switch hint {
170
		case 'M':
171
			// We've already checked the map above.
172

173
		case '.':
174
			// Not in the map, so maybe a normal float.
175
			floatv, err := strconv.ParseFloat(in, 64)
176
			if err == nil {
177
				return floatTag, floatv
178
			}
179

180
		case 'D', 'S':
181
			// Int, float, or timestamp.
182
			// Only try values as a timestamp if the value is unquoted or there's an explicit
183
			// !!timestamp tag.
184
			if tag == "" || tag == timestampTag {
185
				t, ok := parseTimestamp(in)
186
				if ok {
187
					return timestampTag, t
188
				}
189
			}
190

191
			plain := strings.Replace(in, "_", "", -1)
192
			intv, err := strconv.ParseInt(plain, 0, 64)
193
			if err == nil {
194
				if intv == int64(int(intv)) {
195
					return intTag, int(intv)
196
				} else {
197
					return intTag, intv
198
				}
199
			}
200
			uintv, err := strconv.ParseUint(plain, 0, 64)
201
			if err == nil {
202
				return intTag, uintv
203
			}
204
			if yamlStyleFloat.MatchString(plain) {
205
				floatv, err := strconv.ParseFloat(plain, 64)
206
				if err == nil {
207
					return floatTag, floatv
208
				}
209
			}
210
			if strings.HasPrefix(plain, "0b") {
211
				intv, err := strconv.ParseInt(plain[2:], 2, 64)
212
				if err == nil {
213
					if intv == int64(int(intv)) {
214
						return intTag, int(intv)
215
					} else {
216
						return intTag, intv
217
					}
218
				}
219
				uintv, err := strconv.ParseUint(plain[2:], 2, 64)
220
				if err == nil {
221
					return intTag, uintv
222
				}
223
			} else if strings.HasPrefix(plain, "-0b") {
224
				intv, err := strconv.ParseInt("-"+plain[3:], 2, 64)
225
				if err == nil {
226
					if true || intv == int64(int(intv)) {
227
						return intTag, int(intv)
228
					} else {
229
						return intTag, intv
230
					}
231
				}
232
			}
233
			// Octals as introduced in version 1.2 of the spec.
234
			// Octals from the 1.1 spec, spelled as 0777, are still
235
			// decoded by default in v3 as well for compatibility.
236
			// May be dropped in v4 depending on how usage evolves.
237
			if strings.HasPrefix(plain, "0o") {
238
				intv, err := strconv.ParseInt(plain[2:], 8, 64)
239
				if err == nil {
240
					if intv == int64(int(intv)) {
241
						return intTag, int(intv)
242
					} else {
243
						return intTag, intv
244
					}
245
				}
246
				uintv, err := strconv.ParseUint(plain[2:], 8, 64)
247
				if err == nil {
248
					return intTag, uintv
249
				}
250
			} else if strings.HasPrefix(plain, "-0o") {
251
				intv, err := strconv.ParseInt("-"+plain[3:], 8, 64)
252
				if err == nil {
253
					if true || intv == int64(int(intv)) {
254
						return intTag, int(intv)
255
					} else {
256
						return intTag, intv
257
					}
258
				}
259
			}
260
		default:
261
			panic("internal error: missing handler for resolver table: " + string(rune(hint)) + " (with " + in + ")")
262
		}
263
	}
264
	return strTag, in
265
}
266

267
// encodeBase64 encodes s as base64 that is broken up into multiple lines
268
// as appropriate for the resulting length.
269
func encodeBase64(s string) string {
270
	const lineLen = 70
271
	encLen := base64.StdEncoding.EncodedLen(len(s))
272
	lines := encLen/lineLen + 1
273
	buf := make([]byte, encLen*2+lines)
274
	in := buf[0:encLen]
275
	out := buf[encLen:]
276
	base64.StdEncoding.Encode(in, []byte(s))
277
	k := 0
278
	for i := 0; i < len(in); i += lineLen {
279
		j := i + lineLen
280
		if j > len(in) {
281
			j = len(in)
282
		}
283
		k += copy(out[k:], in[i:j])
284
		if lines > 1 {
285
			out[k] = '\n'
286
			k++
287
		}
288
	}
289
	return string(out[:k])
290
}
291

292
// This is a subset of the formats allowed by the regular expression
293
// defined at http://yaml.org/type/timestamp.html.
294
var allowedTimestampFormats = []string{
295
	"2006-1-2T15:4:5.999999999Z07:00", // RCF3339Nano with short date fields.
296
	"2006-1-2t15:4:5.999999999Z07:00", // RFC3339Nano with short date fields and lower-case "t".
297
	"2006-1-2 15:4:5.999999999",       // space separated with no time zone
298
	"2006-1-2",                        // date only
299
	// Notable exception: time.Parse cannot handle: "2001-12-14 21:59:43.10 -5"
300
	// from the set of examples.
301
}
302

303
// parseTimestamp parses s as a timestamp string and
304
// returns the timestamp and reports whether it succeeded.
305
// Timestamp formats are defined at http://yaml.org/type/timestamp.html
306
func parseTimestamp(s string) (time.Time, bool) {
307
	// TODO write code to check all the formats supported by
308
	// http://yaml.org/type/timestamp.html instead of using time.Parse.
309

310
	// Quick check: all date formats start with YYYY-.
311
	i := 0
312
	for ; i < len(s); i++ {
313
		if c := s[i]; c < '0' || c > '9' {
314
			break
315
		}
316
	}
317
	if i != 4 || i == len(s) || s[i] != '-' {
318
		return time.Time{}, false
319
	}
320
	for _, format := range allowedTimestampFormats {
321
		if t, err := time.Parse(format, s); err == nil {
322
			return t, true
323
		}
324
	}
325
	return time.Time{}, false
326
}
327

328