podman

1
// Copyright 2012 The Go Authors. All rights reserved.
2
// Use of this source code is governed by a BSD-style
3
// license that can be found in the LICENSE file.
4

5
// Plan 9 directory marshalling. See intro(5).
6

7
package plan9
8

9
import "errors"
10

11
var (
12
	ErrShortStat = errors.New("stat buffer too short")
13
	ErrBadStat   = errors.New("malformed stat buffer")
14
	ErrBadName   = errors.New("bad character in file name")
15
)
16

17
// A Qid represents a 9P server's unique identification for a file.
18
type Qid struct {
19
	Path uint64 // the file server's unique identification for the file
20
	Vers uint32 // version number for given Path
21
	Type uint8  // the type of the file (plan9.QTDIR for example)
22
}
23

24
// A Dir contains the metadata for a file.
25
type Dir struct {
26
	// system-modified data
27
	Type uint16 // server type
28
	Dev  uint32 // server subtype
29

30
	// file data
31
	Qid    Qid    // unique id from server
32
	Mode   uint32 // permissions
33
	Atime  uint32 // last read time
34
	Mtime  uint32 // last write time
35
	Length int64  // file length
36
	Name   string // last element of path
37
	Uid    string // owner name
38
	Gid    string // group name
39
	Muid   string // last modifier name
40
}
41

42
var nullDir = Dir{
43
	Type: ^uint16(0),
44
	Dev:  ^uint32(0),
45
	Qid: Qid{
46
		Path: ^uint64(0),
47
		Vers: ^uint32(0),
48
		Type: ^uint8(0),
49
	},
50
	Mode:   ^uint32(0),
51
	Atime:  ^uint32(0),
52
	Mtime:  ^uint32(0),
53
	Length: ^int64(0),
54
}
55

56
// Null assigns special "don't touch" values to members of d to
57
// avoid modifying them during plan9.Wstat.
58
func (d *Dir) Null() { *d = nullDir }
59

60
// Marshal encodes a 9P stat message corresponding to d into b
61
//
62
// If there isn't enough space in b for a stat message, ErrShortStat is returned.
63
func (d *Dir) Marshal(b []byte) (n int, err error) {
64
	n = STATFIXLEN + len(d.Name) + len(d.Uid) + len(d.Gid) + len(d.Muid)
65
	if n > len(b) {
66
		return n, ErrShortStat
67
	}
68

69
	for _, c := range d.Name {
70
		if c == '/' {
71
			return n, ErrBadName
72
		}
73
	}
74

75
	b = pbit16(b, uint16(n)-2)
76
	b = pbit16(b, d.Type)
77
	b = pbit32(b, d.Dev)
78
	b = pbit8(b, d.Qid.Type)
79
	b = pbit32(b, d.Qid.Vers)
80
	b = pbit64(b, d.Qid.Path)
81
	b = pbit32(b, d.Mode)
82
	b = pbit32(b, d.Atime)
83
	b = pbit32(b, d.Mtime)
84
	b = pbit64(b, uint64(d.Length))
85
	b = pstring(b, d.Name)
86
	b = pstring(b, d.Uid)
87
	b = pstring(b, d.Gid)
88
	b = pstring(b, d.Muid)
89

90
	return n, nil
91
}
92

93
// UnmarshalDir decodes a single 9P stat message from b and returns the resulting Dir.
94
//
95
// If b is too small to hold a valid stat message, ErrShortStat is returned.
96
//
97
// If the stat message itself is invalid, ErrBadStat is returned.
98
func UnmarshalDir(b []byte) (*Dir, error) {
99
	if len(b) < STATFIXLEN {
100
		return nil, ErrShortStat
101
	}
102
	size, buf := gbit16(b)
103
	if len(b) != int(size)+2 {
104
		return nil, ErrBadStat
105
	}
106
	b = buf
107

108
	var d Dir
109
	d.Type, b = gbit16(b)
110
	d.Dev, b = gbit32(b)
111
	d.Qid.Type, b = gbit8(b)
112
	d.Qid.Vers, b = gbit32(b)
113
	d.Qid.Path, b = gbit64(b)
114
	d.Mode, b = gbit32(b)
115
	d.Atime, b = gbit32(b)
116
	d.Mtime, b = gbit32(b)
117

118
	n, b := gbit64(b)
119
	d.Length = int64(n)
120

121
	var ok bool
122
	if d.Name, b, ok = gstring(b); !ok {
123
		return nil, ErrBadStat
124
	}
125
	if d.Uid, b, ok = gstring(b); !ok {
126
		return nil, ErrBadStat
127
	}
128
	if d.Gid, b, ok = gstring(b); !ok {
129
		return nil, ErrBadStat
130
	}
131
	if d.Muid, b, ok = gstring(b); !ok {
132
		return nil, ErrBadStat
133
	}
134

135
	return &d, nil
136
}
137

138
// pbit8 copies the 8-bit number v to b and returns the remaining slice of b.
139
func pbit8(b []byte, v uint8) []byte {
140
	b[0] = byte(v)
141
	return b[1:]
142
}
143

144
// pbit16 copies the 16-bit number v to b in little-endian order and returns the remaining slice of b.
145
func pbit16(b []byte, v uint16) []byte {
146
	b[0] = byte(v)
147
	b[1] = byte(v >> 8)
148
	return b[2:]
149
}
150

151
// pbit32 copies the 32-bit number v to b in little-endian order and returns the remaining slice of b.
152
func pbit32(b []byte, v uint32) []byte {
153
	b[0] = byte(v)
154
	b[1] = byte(v >> 8)
155
	b[2] = byte(v >> 16)
156
	b[3] = byte(v >> 24)
157
	return b[4:]
158
}
159

160
// pbit64 copies the 64-bit number v to b in little-endian order and returns the remaining slice of b.
161
func pbit64(b []byte, v uint64) []byte {
162
	b[0] = byte(v)
163
	b[1] = byte(v >> 8)
164
	b[2] = byte(v >> 16)
165
	b[3] = byte(v >> 24)
166
	b[4] = byte(v >> 32)
167
	b[5] = byte(v >> 40)
168
	b[6] = byte(v >> 48)
169
	b[7] = byte(v >> 56)
170
	return b[8:]
171
}
172

173
// pstring copies the string s to b, prepending it with a 16-bit length in little-endian order, and
174
// returning the remaining slice of b..
175
func pstring(b []byte, s string) []byte {
176
	b = pbit16(b, uint16(len(s)))
177
	n := copy(b, s)
178
	return b[n:]
179
}
180

181
// gbit8 reads an 8-bit number from b and returns it with the remaining slice of b.
182
func gbit8(b []byte) (uint8, []byte) {
183
	return uint8(b[0]), b[1:]
184
}
185

186
// gbit16 reads a 16-bit number in little-endian order from b and returns it with the remaining slice of b.
187
func gbit16(b []byte) (uint16, []byte) {
188
	return uint16(b[0]) | uint16(b[1])<<8, b[2:]
189
}
190

191
// gbit32 reads a 32-bit number in little-endian order from b and returns it with the remaining slice of b.
192
func gbit32(b []byte) (uint32, []byte) {
193
	return uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24, b[4:]
194
}
195

196
// gbit64 reads a 64-bit number in little-endian order from b and returns it with the remaining slice of b.
197
func gbit64(b []byte) (uint64, []byte) {
198
	lo := uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24
199
	hi := uint32(b[4]) | uint32(b[5])<<8 | uint32(b[6])<<16 | uint32(b[7])<<24
200
	return uint64(lo) | uint64(hi)<<32, b[8:]
201
}
202

203
// gstring reads a string from b, prefixed with a 16-bit length in little-endian order.
204
// It returns the string with the remaining slice of b and a boolean. If the length is
205
// greater than the number of bytes in b, the boolean will be false.
206
func gstring(b []byte) (string, []byte, bool) {
207
	n, b := gbit16(b)
208
	if int(n) > len(b) {
209
		return "", b, false
210
	}
211
	return string(b[:n]), b[n:], true
212
}
213