1. 1
2. 2
3. 3
4. 4
5. 5
6. 6
7. 7
8. 8
9. 9
10. 10
11. 11
12. 12
13. 13
14. 14
15. 15
16. 16
17. 17
18. 18
19. 19
20. 20
21. 21
22. 22
23. 23
24. 24
25. 25
26. 26
27. 27
28. 28
29. 29
30. 30
31. 31
32. 32
33. 33
34. 34
35. 35
36. 36
37. 37
38. 38
39. 39
40. 40
41. 41
42. 42
43. 43
44. 44
45. 45
46. 46
47. 47
48. 48
49. 49
50. 50
51. 51
52. 52
53. 53
54. 54
55. 55
56. 56
57. 57
58. 58
59. 59
60. 60
61. 61
62. 62
63. 63
64. 64
65. 65
66. 66
67. 67
68. 68
69. 69
70. 70
71. 71
72. 72
73. 73
74. 74
75. 75
76. 76
77. 77
78. 78
79. 79
80. 80
81. 81
82. 82
83. 83
84. 84
85. 85
86. 86
87. 87
88. 88

// Copyright 2017 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 encoding

import (
	"io"

	"github.com/ProtonMail/go-crypto/openpgp/errors"
)

// OID is used to store a variable-length field with a one-octet size
// prefix. See https://tools.ietf.org/html/rfc6637#section-9.
type OID struct {
	bytes []byte
}

const (
	// maxOID is the maximum number of bytes in a OID.
	maxOID = 254
	// reservedOIDLength1 and reservedOIDLength2 are OID lengths that the RFC
	// specifies are reserved.
	reservedOIDLength1 = 0
	reservedOIDLength2 = 0xff
)

// NewOID returns a OID initialized with bytes.
func NewOID(bytes []byte) *OID {
	switch len(bytes) {
	case reservedOIDLength1, reservedOIDLength2:
		panic("encoding: NewOID argument length is reserved")
	default:
		if len(bytes) > maxOID {
			panic("encoding: NewOID argment too large")
		}
	}

	return &OID{
		bytes: bytes,
	}
}

// Bytes returns the decoded data.
func (o *OID) Bytes() []byte {
	return o.bytes
}

// BitLength is the size in bits of the decoded data.
func (o *OID) BitLength() uint16 {
	return uint16(len(o.bytes) * 8)
}

// EncodedBytes returns the encoded data.
func (o *OID) EncodedBytes() []byte {
	return append([]byte{byte(len(o.bytes))}, o.bytes...)
}

// EncodedLength is the size in bytes of the encoded data.
func (o *OID) EncodedLength() uint16 {
	return uint16(1 + len(o.bytes))
}

// ReadFrom reads into b the next OID from r.
func (o *OID) ReadFrom(r io.Reader) (int64, error) {
	var buf [1]byte
	n, err := io.ReadFull(r, buf[:])
	if err != nil {
		if err == io.EOF {
			err = io.ErrUnexpectedEOF
		}
		return int64(n), err
	}

	switch buf[0] {
	case reservedOIDLength1, reservedOIDLength2:
		return int64(n), errors.UnsupportedError("reserved for future extensions")
	}

	o.bytes = make([]byte, buf[0])

	nn, err := io.ReadFull(r, o.bytes)
	if err == io.EOF {
		err = io.ErrUnexpectedEOF
	}

	return int64(n) + int64(nn), err
}