Ian Lance Taylor | 3d5f356 | 2012-12-12 15:06:45 -0800 | [diff] [blame] | 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 | |
Ian Lance Taylor | 0ba4563 | 2017-01-13 11:17:23 -0800 | [diff] [blame] | 5 | // Plan 9 directory marshaling. See intro(5). |
Ian Lance Taylor | 3d5f356 | 2012-12-12 15:06:45 -0800 | [diff] [blame] | 6 | |
| 7 | package syscall |
| 8 | |
| 9 | import "errors" |
| 10 | |
| 11 | var ( |
| 12 | ErrShortStat = errors.New("stat buffer too short") |
| 13 | ErrBadStat = errors.New("malformed stat buffer") |
Ian Lance Taylor | a398986 | 2014-06-04 16:11:41 -0700 | [diff] [blame] | 14 | ErrBadName = errors.New("bad character in file name") |
Ian Lance Taylor | 3d5f356 | 2012-12-12 15:06:45 -0800 | [diff] [blame] | 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 (syscall.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 |
Ian Lance Taylor | b95c633 | 2014-07-19 01:26:37 -0700 | [diff] [blame] | 57 | // avoid modifying them during syscall.Wstat. |
Ian Lance Taylor | 3d5f356 | 2012-12-12 15:06:45 -0800 | [diff] [blame] | 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 | |
Ian Lance Taylor | a398986 | 2014-06-04 16:11:41 -0700 | [diff] [blame] | 69 | for _, c := range d.Name { |
| 70 | if c == '/' { |
| 71 | return n, ErrBadName |
| 72 | } |
| 73 | } |
| 74 | |
Ian Lance Taylor | 3d5f356 | 2012-12-12 15:06:45 -0800 | [diff] [blame] | 75 | b = pbit16(b, uint16(n)-2) |
| 76 | b = pbit16(b, d.Type) |
| 77 | b = pbit32(b, d.Dev) |
Ian Lance Taylor | 3d5f356 | 2012-12-12 15:06:45 -0800 | [diff] [blame] | 78 | b = pbit8(b, d.Qid.Type) |
Ian Lance Taylor | 093f55b | 2013-07-15 23:35:05 -0700 | [diff] [blame] | 79 | b = pbit32(b, d.Qid.Vers) |
| 80 | b = pbit64(b, d.Qid.Path) |
Ian Lance Taylor | 3d5f356 | 2012-12-12 15:06:45 -0800 | [diff] [blame] | 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) |
Ian Lance Taylor | 3d5f356 | 2012-12-12 15:06:45 -0800 | [diff] [blame] | 111 | d.Qid.Type, b = gbit8(b) |
Ian Lance Taylor | 093f55b | 2013-07-15 23:35:05 -0700 | [diff] [blame] | 112 | d.Qid.Vers, b = gbit32(b) |
| 113 | d.Qid.Path, b = gbit64(b) |
Ian Lance Taylor | 3d5f356 | 2012-12-12 15:06:45 -0800 | [diff] [blame] | 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. |
Ian Lance Taylor | b156d71 | 2016-07-22 07:41:34 -0700 | [diff] [blame] | 187 | //go:nosplit |
Ian Lance Taylor | 3d5f356 | 2012-12-12 15:06:45 -0800 | [diff] [blame] | 188 | func gbit16(b []byte) (uint16, []byte) { |
| 189 | return uint16(b[0]) | uint16(b[1])<<8, b[2:] |
| 190 | } |
| 191 | |
| 192 | // gbit32 reads a 32-bit number in little-endian order from b and returns it with the remaining slice of b. |
| 193 | func gbit32(b []byte) (uint32, []byte) { |
| 194 | return uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24, b[4:] |
| 195 | } |
| 196 | |
| 197 | // gbit64 reads a 64-bit number in little-endian order from b and returns it with the remaining slice of b. |
| 198 | func gbit64(b []byte) (uint64, []byte) { |
| 199 | lo := uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24 |
| 200 | hi := uint32(b[4]) | uint32(b[5])<<8 | uint32(b[6])<<16 | uint32(b[7])<<24 |
| 201 | return uint64(lo) | uint64(hi)<<32, b[8:] |
| 202 | } |
| 203 | |
| 204 | // gstring reads a string from b, prefixed with a 16-bit length in little-endian order. |
| 205 | // It returns the string with the remaining slice of b and a boolean. If the length is |
| 206 | // greater than the number of bytes in b, the boolean will be false. |
| 207 | func gstring(b []byte) (string, []byte, bool) { |
| 208 | n, b := gbit16(b) |
| 209 | if int(n) > len(b) { |
| 210 | return "", b, false |
| 211 | } |
| 212 | return string(b[:n]), b[n:], true |
| 213 | } |