| // Copyright 2017 The Fuchsia 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 tftp |
| |
| import ( |
| "bytes" |
| "encoding/binary" |
| "errors" |
| "fmt" |
| "io" |
| "net" |
| "strconv" |
| "strings" |
| "time" |
| ) |
| |
| const ( |
| ServerPort = 33340 // tftp server port |
| ClientPort = 33341 // tftp client port |
| ) |
| |
| const ( |
| timeout = 2 * time.Second // default client timeout |
| retries = 5 // default number of retries |
| blockSize = 1024 // default block size |
| datagramSize = 1028 // default datagram size |
| windowSize = 256 // default window size |
| ) |
| |
| const ( |
| opRrq = uint8(1) // read request (RRQ) |
| opWrq = uint8(2) // write request (WRQ) |
| opData = uint8(3) // data |
| opAck = uint8(4) // acknowledgement |
| opError = uint8(5) // error |
| opOack = uint8(6) // option acknowledgment |
| ) |
| |
| const ( |
| ErrorUndefined = uint16(0) // Not defined, see error message (if any) |
| ErrorFileNotFound = uint16(1) // File not found |
| ErrorAccessViolation = uint16(2) // Access violation |
| ErrorDiskFull = uint16(3) // Disk full or allocation exceeded |
| ErrorIllegalOperation = uint16(4) // Illegal TFTP operation |
| ErrorUnknownID = uint16(5) // Unknown transfer ID |
| ErrorFileExists = uint16(6) // File already exists |
| ErrorNoSuchUser = uint16(7) // No such user |
| ErrorBadOptions = uint16(8) // Bad options |
| |
| // ErrorBusy is a Fuchsia-specific extension to the set of TFTP error |
| // codes, meant to indicate that the server cannot currently handle a |
| // request, but may be able to at some future time. |
| ErrorBusy = uint16(0x143) // 'B' + 'U' + 'S' + 'Y' |
| ) |
| |
| var ( |
| ErrShouldWait = fmt.Errorf("target is busy") |
| ) |
| |
| type Client struct { |
| Timeout time.Duration // duration to wait for the client to ack a packet |
| Retries int // how many times a packet will be resent |
| BlockSize uint16 // maximum block size used for file transfers |
| WindowSize uint16 // window size used for file transfers. |
| } |
| |
| func NewClient() *Client { |
| return &Client{ |
| Timeout: timeout, |
| Retries: retries, |
| BlockSize: blockSize, |
| WindowSize: windowSize, |
| } |
| } |
| |
| type options struct { |
| timeout time.Duration |
| blockSize uint16 |
| windowSize uint16 |
| transferSize int64 |
| } |
| |
| type Session interface { |
| // Size returns the transfer size, if set. |
| Size() int64 |
| |
| // RemoteAddr returns the remote adderss. |
| RemoteAddr() net.UDPAddr |
| } |
| |
| // Send sends the filename of length size to server addr with the content being |
| // read from the reader. |
| // |
| // If the server being talked to is running on Fuchsia, this method may return |
| // ErrShouldWait, which indicates that the server is currently not ready to |
| // handle a new request, but will be in the future. This case should be |
| // explicitly handled by the caller. |
| func (c *Client) Send(addr *net.UDPAddr, filename string, size int64) (io.ReaderFrom, error) { |
| conn, err := net.ListenUDP("udp", &net.UDPAddr{IP: net.IPv6zero}) |
| if err != nil { |
| return nil, fmt.Errorf("creating socket: %s", err) |
| } |
| |
| var b bytes.Buffer |
| writeRequest(&b, opWrq, filename, &options{ |
| timeout: c.Timeout, |
| blockSize: c.BlockSize, |
| windowSize: c.WindowSize, |
| transferSize: size, |
| }) |
| |
| opts, addr, err := c.sendRequest(conn, addr, b.Bytes()) |
| if err != nil { |
| conn.Close() |
| if err == ErrShouldWait { |
| return nil, ErrShouldWait |
| } |
| return nil, fmt.Errorf("sending WRQ: %s", err) |
| } |
| b.Reset() |
| if opts.transferSize != size { |
| err := errors.New("transfer size mismatch") |
| abort(conn, addr, ErrorBadOptions, err) |
| return nil, err |
| } |
| |
| return &sender{ |
| addr: addr, |
| conn: conn, |
| opts: opts, |
| retry: c.Retries, |
| }, nil |
| } |
| |
| type sender struct { |
| addr *net.UDPAddr |
| conn *net.UDPConn |
| opts *options |
| retry int |
| } |
| |
| func (s *sender) Size() (n int64) { |
| return s.opts.transferSize |
| } |
| |
| func (s *sender) RemoteAddr() net.UDPAddr { |
| return *s.addr |
| } |
| |
| func (s *sender) ReadFrom(r io.Reader) (int64, error) { |
| l, err := s.send(r) |
| if err != nil { |
| abort(s.conn, s.addr, ErrorUndefined, err) |
| return l, err |
| } |
| s.conn.Close() |
| return l, nil |
| } |
| |
| func (s *sender) send(r io.Reader) (int64, error) { |
| var n int64 // total number of bytes read |
| var seq uint64 // sequence number denoting the beginning of window |
| b := make([]byte, s.opts.blockSize+4) |
| ra, ok := r.(io.ReaderAt) |
| if !ok { |
| return n, fmt.Errorf("%t does not implement io.ReaderAt", r) |
| } |
| |
| Loop: |
| for { |
| Attempt: |
| for attempt := 0; attempt < s.retry; attempt++ { |
| for i := uint16(0); uint16(i) <= s.opts.windowSize; i++ { |
| block := uint16(seq + uint64(i+1)) |
| // Fill the first byte of the command with an arbitrary value to |
| // work around the issue where certain ethernet adapters would |
| // refuse to send the packet on retransmission. |
| b[0] = uint8(attempt) |
| b[1] = opData |
| binary.BigEndian.PutUint16(b[2:], block) |
| off := (seq + uint64(i)) * uint64(s.opts.blockSize) |
| l, err := ra.ReadAt(b[4:], int64(off)) |
| n += int64(l) |
| if err != nil && err != io.EOF { |
| return n, fmt.Errorf("reading bytes for block %d: %s", block, err) |
| } |
| isEOF := err == io.EOF |
| if _, err := s.conn.WriteToUDP(b[:l+4], s.addr); err != nil { |
| return n, fmt.Errorf("sending block %d: %s", block, err) |
| } |
| if isEOF { |
| break |
| } |
| } |
| |
| s.conn.SetReadDeadline(time.Now().Add(s.opts.timeout)) |
| |
| for { |
| m, addr, err := s.conn.ReadFromUDP(b[:]) |
| if err != nil { |
| if t, ok := err.(net.Error); ok && t.Timeout() { |
| continue Attempt |
| } |
| return n, err |
| } |
| if m < 4 { // packet too small |
| continue |
| } |
| if !addr.IP.Equal(s.addr.IP) || addr.Port != s.addr.Port { |
| continue |
| } |
| break |
| } |
| |
| switch b[1] { |
| case opAck: |
| num := binary.BigEndian.Uint16(b[2:4]) |
| off := num - uint16(seq) // offset from the start of the window |
| if off > 0 && off <= s.opts.windowSize { |
| seq += uint64(off) |
| if seq*uint64(s.opts.blockSize) >= uint64(s.opts.transferSize) { |
| return n, nil // all data transferred, return number of bytes |
| } |
| } |
| continue Loop |
| case opError: |
| msg, _, _ := netasciiString(b[4:]) |
| return n, fmt.Errorf("server aborted transfer: %s", msg) |
| } |
| } |
| return n, errors.New("timeout waiting for ACK") |
| } |
| } |
| |
| // Receive reads the data from filename at the server addr with the content |
| // being written to the writer. |
| // |
| // If the server being talked to is running on a Fuchsia, this method may return |
| // ErrShouldWait, which indicates that the server is currently not ready to |
| // handle a new request, but will be in the future. This case should be |
| // explicitly handled by the caller. |
| func (c *Client) Receive(addr *net.UDPAddr, filename string) (io.WriterTo, error) { |
| conn, err := net.ListenUDP("udp", &net.UDPAddr{IP: net.IPv6zero}) |
| if err != nil { |
| return nil, fmt.Errorf("creating socket: %s", err) |
| } |
| |
| var b bytes.Buffer |
| writeRequest(&b, opRrq, filename, &options{ |
| blockSize: c.BlockSize, |
| timeout: c.Timeout, |
| windowSize: c.WindowSize, |
| }) |
| opts, addr, err := c.sendRequest(conn, addr, b.Bytes()) |
| if err != nil { |
| conn.Close() |
| if err == ErrShouldWait { |
| return nil, ErrShouldWait |
| } |
| return nil, fmt.Errorf("sending RRQ: %s", err) |
| } |
| b.Reset() |
| if err := acknowledge(conn, addr, uint16(0)); err != nil { |
| return nil, fmt.Errorf("sending ACK: %s", err) |
| } |
| |
| return &receiver{ |
| addr: addr, |
| conn: conn, |
| opts: opts, |
| retry: c.Retries, |
| }, nil |
| } |
| |
| type receiver struct { |
| addr *net.UDPAddr |
| conn *net.UDPConn |
| opts *options |
| retry int |
| } |
| |
| func (r *receiver) Size() (n int64) { |
| return r.opts.transferSize |
| } |
| |
| func (r *receiver) RemoteAddr() net.UDPAddr { |
| return *r.addr |
| } |
| |
| func (r *receiver) WriteTo(w io.Writer) (int64, error) { |
| l, err := r.receive(w) |
| if err != nil { |
| abort(r.conn, r.addr, ErrorUndefined, err) |
| return l, err |
| } |
| r.conn.Close() |
| return l, nil |
| } |
| |
| func (r *receiver) receive(w io.Writer) (int64, error) { |
| var n int64 |
| var seq uint64 |
| recv := make([]byte, r.opts.blockSize+4) |
| |
| Loop: |
| for { |
| Attempt: |
| for attempt := 0; attempt < r.retry; attempt++ { |
| for i := uint16(0); i < uint16(r.opts.windowSize); i++ { |
| r.conn.SetReadDeadline(time.Now().Add(r.opts.timeout)) |
| |
| var m int |
| for { |
| var addr *net.UDPAddr |
| var err error |
| m, addr, err = r.conn.ReadFromUDP(recv[m:]) |
| if err != nil { |
| if t, ok := err.(net.Error); ok && t.Timeout() { |
| acknowledge(r.conn, r.addr, uint16(seq)) |
| continue Attempt |
| } |
| return n, err |
| } |
| if m < 4 { // packet too small |
| continue |
| } |
| if !addr.IP.Equal(r.addr.IP) || addr.Port != r.addr.Port { |
| continue |
| } |
| break |
| } |
| |
| n += int64(m) |
| |
| switch recv[1] { |
| case opData: |
| if num := binary.BigEndian.Uint16(recv[2:4]); num != uint16(seq)+1 { |
| if num-uint16(seq) < uint16(r.opts.windowSize) { |
| acknowledge(r.conn, r.addr, uint16(seq)) |
| } |
| continue Loop |
| } |
| seq++ |
| if _, err := w.Write(recv[4:m]); err != nil { |
| return n, fmt.Errorf("writing bytes for block %d: %v", seq, err) |
| } |
| if m < int(r.opts.blockSize+4) { |
| acknowledge(r.conn, r.addr, uint16(seq)) |
| return n, nil |
| } |
| case opError: |
| msg, _, _ := netasciiString(recv[4:]) |
| return n, fmt.Errorf("server aborted transfer: %s", msg) |
| } |
| } |
| // TODO: this should be addr |
| acknowledge(r.conn, r.addr, uint16(seq)) |
| continue Loop |
| } |
| return n, errors.New("timeout waiting for DATA") |
| } |
| } |
| |
| func writeRequest(b *bytes.Buffer, op uint8, filename string, o *options) { |
| b.WriteByte(0) |
| b.WriteByte(op) |
| writeString(b, filename) |
| // Only support octet mode, because in practice that's the |
| // only remaining sensible use of TFTP. |
| writeString(b, "octet") |
| writeOption(b, "tsize", o.transferSize) |
| writeOption(b, "blksize", int64(o.blockSize)) |
| writeOption(b, "timeout", int64(o.timeout/time.Second)) |
| writeOption(b, "windowsize", int64(o.windowSize)) |
| } |
| |
| func writeOption(b *bytes.Buffer, name string, value int64) { |
| writeString(b, name) |
| writeString(b, strconv.FormatInt(value, 10)) |
| } |
| |
| func writeString(b *bytes.Buffer, s string) { |
| b.WriteString(s) |
| b.WriteByte(0) |
| } |
| |
| func (c *Client) sendRequest(conn *net.UDPConn, addr *net.UDPAddr, b []byte) (*options, *net.UDPAddr, error) { |
| for attempt := 0; attempt < c.Retries; attempt++ { |
| if _, err := conn.WriteToUDP(b, addr); err != nil { |
| return nil, nil, err |
| } |
| |
| conn.SetReadDeadline(time.Now().Add(c.Timeout)) |
| |
| var recv [256]byte |
| for { |
| n, addr, err := conn.ReadFromUDP(recv[:]) |
| if err != nil { |
| if t, ok := err.(net.Error); ok && t.Timeout() { |
| break |
| } |
| return nil, nil, err |
| } |
| |
| if n < 4 { // packet too small |
| continue |
| } |
| switch recv[1] { |
| case opError: |
| // Handling ErrorBusy here is a Fuchsia-specific extension. |
| if code := binary.BigEndian.Uint16(recv[2:4]); code == ErrorBusy { |
| return nil, addr, ErrShouldWait |
| } |
| msg, _, _ := netasciiString(recv[4:n]) |
| return nil, addr, fmt.Errorf("server aborted transfer: %s", msg) |
| case opOack: |
| options, err := parseOACK(recv[2:n]) |
| return options, addr, err |
| } |
| } |
| } |
| |
| return nil, nil, errors.New("timeout waiting for OACK") |
| } |
| |
| func parseOACK(bs []byte) (*options, error) { |
| var o options |
| |
| for len(bs) > 0 { |
| opt, rest, err := netasciiString(bs) |
| if err != nil { |
| return nil, fmt.Errorf("reading option name: %s", err) |
| } |
| bs = rest |
| val, rest, err := netasciiString(bs) |
| if err != nil { |
| return nil, fmt.Errorf("reading option %q value: %s", opt, err) |
| } |
| bs = rest |
| switch strings.ToLower(opt) { |
| case "blksize": |
| size, err := strconv.ParseUint(val, 10, 16) |
| if err != nil { |
| return nil, fmt.Errorf("unsupported block size %q", val) |
| } |
| o.blockSize = uint16(size) |
| case "timeout": |
| seconds, err := strconv.ParseUint(val, 10, 8) |
| if err != nil { |
| return nil, fmt.Errorf("unsupported timeout %q", val) |
| } |
| o.timeout = time.Second * time.Duration(seconds) |
| case "tsize": |
| size, err := strconv.ParseUint(val, 10, 64) |
| if err != nil { |
| return nil, fmt.Errorf("unsupported transfer size %q", val) |
| } |
| o.transferSize = int64(size) |
| case "windowsize": |
| size, err := strconv.ParseUint(val, 10, 16) |
| if err != nil { |
| return nil, fmt.Errorf("unsupported window size %q", val) |
| } |
| o.windowSize = uint16(size) |
| } |
| } |
| |
| return &o, nil |
| } |
| |
| func acknowledge(conn *net.UDPConn, addr *net.UDPAddr, seq uint16) error { |
| var b bytes.Buffer |
| b.WriteByte(0) |
| b.WriteByte(opAck) |
| if err := binary.Write(&b, binary.BigEndian, seq); err != nil { |
| return fmt.Errorf("writing seqnum: %v", err) |
| } |
| if _, err := conn.WriteToUDP(b.Bytes(), addr); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| func abort(conn *net.UDPConn, addr *net.UDPAddr, code uint16, err error) error { |
| var b bytes.Buffer |
| b.WriteByte(0) |
| b.WriteByte(opError) |
| if binary.Write(&b, binary.BigEndian, code); err != nil { |
| return fmt.Errorf("writing code: %v", err) |
| } |
| b.WriteString(err.Error()) |
| b.WriteByte(0) |
| if _, err := conn.WriteToUDP(b.Bytes(), addr); err != nil { |
| return err |
| } |
| conn.Close() |
| return nil |
| } |
| |
| func netasciiString(bs []byte) (string, []byte, error) { |
| for i, b := range bs { |
| if b == 0 { |
| return string(bs[:i]), bs[i+1:], nil |
| } else if b < 0x20 || b > 0x7e { |
| return "", nil, fmt.Errorf("invalid netascii byte %q at offset %d", b, i) |
| } |
| } |
| return "", nil, errors.New("no null terminated string found") |
| } |
| |
| // WindowReader supports reading bytes from an underlying stream using |
| // fixed sized blocks and rewinding back up to slots blocks. |
| type WindowReader struct { |
| buf []byte // buffer space |
| len []int // len of data written to each slot |
| reader io.Reader // underlying reader object |
| current int // current block to be read |
| head int // head of buffer |
| slots int // number of slots |
| size int // size of the slot |
| } |
| |
| // NewWindowReader creates a new reader with slots blocks of size. |
| func NewWindowReader(reader io.Reader, slots int, size int) *WindowReader { |
| return &WindowReader{ |
| buf: make([]byte, slots*size), |
| len: make([]int, slots), |
| reader: reader, |
| slots: slots, |
| size: size, |
| } |
| } |
| |
| func (r *WindowReader) Read(p []byte) (int, error) { |
| slot := r.current % r.slots |
| offset := slot * r.size |
| |
| if r.current != r.head { |
| len := offset + r.len[slot] |
| n := copy(p, r.buf[offset:len]) |
| r.current++ |
| return n, nil |
| } |
| |
| n, err := r.reader.Read(p) |
| if err != nil { |
| return n, err |
| } |
| n = copy(r.buf[offset:offset+n], p[:n]) |
| r.len[slot] = n |
| |
| r.current++ |
| r.head = r.current |
| return n, err |
| } |
| |
| // Unread rewinds the reader back by n blocks. |
| func (r *WindowReader) Unread(n int) { |
| r.current -= n |
| } |