14 // Codec defines the interface for encoding and decoding of 9p types.
15 // Unsupported types will throw an error.
16 type Codec interface {
17 // Unmarshal from data into the value pointed to by v.
18 Unmarshal(data []byte, v interface{}) error
20 // Marshal the value v into a byte slice.
21 Marshal(v interface{}) ([]byte, error)
23 // Size returns the encoded size for the target of v.
24 Size(v interface{}) int
27 func NewCodec() Codec {
33 func (c codec9p) Unmarshal(data []byte, v interface{}) error {
34 dec := &decoder{bytes.NewReader(data)}
38 func (c codec9p) Marshal(v interface{}) ([]byte, error) {
42 if err := enc.encode(v); err != nil {
49 func (c codec9p) Size(v interface{}) int {
53 // DecodeDir decodes a directory entry from rd using the provided codec.
54 func DecodeDir(codec Codec, rd io.Reader, d *Dir) error {
57 // pull the size off the wire
58 if err := binary.Read(rd, binary.LittleEndian, &ll); err != nil {
62 p := make([]byte, ll+2)
63 binary.LittleEndian.PutUint16(p, ll) // must have size at start
65 // read out the rest of the record
66 if _, err := io.ReadFull(rd, p[2:]); err != nil {
70 return codec.Unmarshal(p, d)
73 // EncodeDir writes the directory to wr.
74 func EncodeDir(codec Codec, wr io.Writer, d *Dir) error {
75 p, err := codec.Marshal(d)
88 func (e *encoder) encode(vs ...interface{}) error {
89 for _, v := range vs {
90 switch v := v.(type) {
91 case uint8, uint16, uint32, uint64, FcallType, Tag, QType, Fid, Flag,
92 *uint8, *uint16, *uint32, *uint64, *FcallType, *Tag, *QType, *Fid, *Flag:
93 if err := binary.Write(e.wr, binary.LittleEndian, v); err != nil {
97 if err := e.encode(uint32(len(v))); err != nil {
101 if err := binary.Write(e.wr, binary.LittleEndian, v); err != nil {
106 if err := e.encode(*v); err != nil {
110 if err := binary.Write(e.wr, binary.LittleEndian, uint16(len(v))); err != nil {
114 _, err := io.WriteString(e.wr, v)
119 if err := e.encode(*v); err != nil {
124 if err := e.encode(uint16(len(v))); err != nil {
128 for _, m := range v {
129 if err := e.encode(m); err != nil {
134 if err := e.encode(*v); err != nil {
138 if err := e.encode(uint32(v.Unix())); err != nil {
142 if err := e.encode(*v); err != nil {
146 if err := e.encode(v.Type, v.Version, v.Path); err != nil {
150 if err := e.encode(*v); err != nil {
154 if err := e.encode(uint16(len(v))); err != nil {
158 elements := make([]interface{}, len(v))
163 if err := e.encode(elements...); err != nil {
167 if err := e.encode(*v); err != nil {
171 elements, err := fields9p(v)
176 if err := e.encode(uint16(size9p(elements...))); err != nil {
180 if err := e.encode(elements...); err != nil {
184 if err := e.encode(*v); err != nil {
188 elements := make([]interface{}, len(v))
193 if err := e.encode(elements...); err != nil {
197 if err := e.encode(*v); err != nil {
201 if err := e.encode(v.Type, v.Tag, v.Message); err != nil {
205 if err := e.encode(*v); err != nil {
209 elements, err := fields9p(v)
215 case MessageRstat, *MessageRstat:
216 // NOTE(stevvooe): Prepend size preceeding Dir. See bugs in
217 // http://man.cat-v.org/plan_9/5/stat to make sense of this.
218 // The field has been included here but we need to make sure
219 // to double emit it for Rstat.
220 if err := e.encode(uint16(size9p(elements...))); err != nil {
225 if err := e.encode(elements...); err != nil {
234 type decoder struct {
238 // read9p extracts values from rd and unmarshals them to the targets of vs.
239 func (d *decoder) decode(vs ...interface{}) error {
240 for _, v := range vs {
241 switch v := v.(type) {
242 case *uint8, *uint16, *uint32, *uint64, *FcallType, *Tag, *QType, *Fid, *Flag:
243 if err := binary.Read(d.rd, binary.LittleEndian, v); err != nil {
249 if err := d.decode(&ll); err != nil {
253 *v = make([]byte, int(ll))
255 if err := binary.Read(d.rd, binary.LittleEndian, v); err != nil {
261 // implement string[s] encoding
262 if err := d.decode(&ll); err != nil {
266 b := make([]byte, ll)
268 n, err := io.ReadFull(d.rd, b)
274 return fmt.Errorf("unexpected string length")
281 if err := d.decode(&ll); err != nil {
285 elements := make([]interface{}, int(ll))
286 *v = make([]string, int(ll))
287 for i := range elements {
288 elements[i] = &(*v)[i]
291 if err := d.decode(elements...); err != nil {
296 if err := d.decode(&epoch); err != nil {
300 *v = time.Unix(int64(epoch), 0).UTC()
302 if err := d.decode(&v.Type, &v.Version, &v.Path); err != nil {
308 if err := d.decode(&ll); err != nil {
312 elements := make([]interface{}, int(ll))
313 *v = make([]Qid, int(ll))
314 for i := range elements {
315 elements[i] = &(*v)[i]
318 if err := d.decode(elements...); err != nil {
324 if err := d.decode(&ll); err != nil {
328 b := make([]byte, ll)
329 // must consume entire dir entry.
330 n, err := io.ReadFull(d.rd, b)
332 log.Println("dir readfull failed:", err, ll, n)
336 elements, err := fields9p(v)
341 dec := &decoder{bytes.NewReader(b)}
343 if err := dec.decode(elements...); err != nil {
350 if err := d.decode(&element); err != nil {
356 *v = append(*v, element)
359 if err := d.decode(&v.Type, &v.Tag); err != nil {
363 message, err := newMessage(v.Type)
368 // NOTE(stevvooe): We do a little pointer dance to allocate the
369 // new type, write to it, then assign it back to the interface as
370 // a concrete type, avoiding a pointer (the interface) to a
372 rv := reflect.New(reflect.TypeOf(message))
373 if err := d.decode(rv.Interface()); err != nil {
377 v.Message = rv.Elem().Interface().(Message)
379 elements, err := fields9p(v)
385 case *MessageRstat, MessageRstat:
386 // NOTE(stevvooe): Consume extra size preceeding Dir. See bugs
387 // in http://man.cat-v.org/plan_9/5/stat to make sense of
388 // this. The field has been included here but we need to make
389 // sure to double emit it for Rstat. decode extra size header
390 // for stat structure.
392 if err := d.decode(&ll); err != nil {
397 if err := d.decode(elements...); err != nil {
406 // size9p calculates the projected size of the values in vs when encoded into
407 // 9p binary protocol. If an element or elements are not valid for 9p encoded,
408 // the value 0 will be used for the size. The error will be detected when
410 func size9p(vs ...interface{}) uint32 {
412 for _, v := range vs {
417 switch v := v.(type) {
418 case uint8, uint16, uint32, uint64, FcallType, Tag, QType, Fid, Flag,
419 *uint8, *uint16, *uint32, *uint64, *FcallType, *Tag, *QType, *Fid, *Flag:
420 s += uint32(binary.Size(v))
422 s += uint32(binary.Size(uint32(0)) + len(v))
424 s += size9p(uint32(0), *v)
426 s += uint32(binary.Size(uint16(0)) + len(v))
430 s += size9p(uint16(0))
432 for _, sv := range v {
437 case time.Time, *time.Time:
438 // BUG(stevvooe): Y2038 is coming.
439 s += size9p(uint32(0))
441 s += size9p(v.Type, v.Version, v.Path)
445 s += size9p(uint16(0))
446 elements := make([]interface{}, len(v))
447 for i := range elements {
450 s += size9p(elements...)
455 // walk the fields of the message to get the total size. we just
456 // use the field order from the message struct. We may add tag
457 // ignoring if needed.
458 elements, err := fields9p(v)
460 // BUG(stevvooe): The options here are to return 0, panic or
461 // make this return an error. Ideally, we make it safe to
462 // return 0 and have the rest of the package do the right
463 // thing. For now, we do this, but may want to panic until
464 // things are stable.
468 s += size9p(elements...) + size9p(uint16(0))
472 elements := make([]interface{}, len(v))
473 for i := range elements {
476 s += size9p(elements...)
480 s += size9p(v.Type, v.Tag, v.Message)
484 // special case twstat and rstat for size fields. See bugs in
485 // http://man.cat-v.org/plan_9/5/stat to make sense of this.
487 case *MessageRstat, MessageRstat:
488 s += size9p(uint16(0)) // for extra size field before dir
491 // walk the fields of the message to get the total size. we just
492 // use the field order from the message struct. We may add tag
493 // ignoring if needed.
494 elements, err := fields9p(v)
496 // BUG(stevvooe): The options here are to return 0, panic or
497 // make this return an error. Ideally, we make it safe to
498 // return 0 and have the rest of the package do the right
499 // thing. For now, we do this, but may want to panic until
500 // things are stable.
504 s += size9p(elements...)
511 // fields9p lists the settable fields from a struct type for reading and
512 // writing. We are using a lot of reflection here for fairly static
513 // serialization but we can replace this in the future with generated code if
514 // performance is an issue.
515 func fields9p(v interface{}) ([]interface{}, error) {
516 rv := reflect.Indirect(reflect.ValueOf(v))
518 if rv.Kind() != reflect.Struct {
519 return nil, fmt.Errorf("cannot extract fields from non-struct: %v", rv)
522 var elements []interface{}
523 for i := 0; i < rv.NumField(); i++ {
526 if !f.CanInterface() {
527 // unexported field, skip it.
535 elements = append(elements, f.Interface())
541 func string9p(v interface{}) string {
546 rv := reflect.Indirect(reflect.ValueOf(v))
548 if rv.Kind() != reflect.Struct {
549 panic("not a struct")
554 for i := 0; i < rv.NumField(); i++ {
557 s += fmt.Sprintf(" %v=%v", strings.ToLower(rv.Type().Field(i).Name), f.Interface())