tftp

README

TFTP server and client library for Golang

Implements:

• RFC 1350 - The TFTP Protocol (Revision 2)
• RFC 2347 - TFTP Option Extension
• RFC 2348 - TFTP Blocksize Option

Partially implements (tsize server side only):

• RFC 2349 - TFTP Timeout Interval and Transfer Size Options

Set of features is sufficient for PXE boot support.

import "github.com/pin/tftp"

TFTP Server

func writeHanlder(filename string, w io.WriterTo) error {
	file, err := os.OpenFile(filename, os.O_WRONLY|os.O_CREATE|os.O_EXCL, 0644)
	if err != nil {
		fmt.Fprintf(os.Stderr, "%v\n", err)
		return err
	}
	// In case client provides tsize option.
	if t, ok := wt.(tftp.IncomingTransfer); ok {
		if n, ok := t.Size(); ok {
			fmt.Printf("Transfer size: %d\n", n)
		}
	}
	n, err := w.WriteTo(file)
	if err != nil {
		fmt.Fprintf(os.Stderr, "%v\n", err)
		return err
	}
	fmt.Printf("%d bytes received\n", n)
	return nil
}

func readHandler(filename string, r io.ReaderFrom) error {
	file, err := os.Open(filename)
	if err != nil {
		fmt.Fprintf(os.Stderr, "%v\n", err)
		return err
	}
	// Optional tsize support.
	// Set transfer size before calling ReadFrom.
	if t, ok := rf.(tftp.OutgoingTransfer); ok {
		if fi, err := file.Stat(); err == nil {
			t.SetSize(fi.Size())
		}
	}
	n, err := r.ReadFrom(file)
	if err != nil {
		fmt.Fprintf(os.Stderr, "%v\n", err)
		return err
	}
	fmt.Printf("%d bytes sent\n", n)
	return nil
}

func main() {
	// use nil in place of handler to disable read or write operations
	s := tftp.NewServer(readHandler, writeHanlder)
	s.SetTimeout(5 * time.Second) // optional
	err := s.ListenAndServe(":69") // blocks until s.Shutdown() is called
	if err != nil {
		fmt.Fprintf(os.Stdout, "server: %v\n", err)
		os.Exit(1)
	}
}

TFTP Client

Uploading file to server:

// TODO: handle errors
c, err := tftp.NewClient("172.16.4.21:69")
file, err := os.Open(path)
c.SetTimeout(5 * time.Second) // optional
r, err := c.Send("foobar.txt", "octet")
n, err := r.ReadFrom(file)
fmt.Printf("%d bytes sent\n", n)

Downloading file from server:

// TODO: handle errors
c, err := tftp.NewClient("172.16.4.21:69")
w, err := c.Receive("foobar.txt", "octet")
file, err := os.Create(path)
// Optional tsize.
if it, ok := readTransfer.(IncomingTransfer); ok {
	if n, ok := it.Size(); ok {
		fmt.Printf("Transfer size: %d\n", n)
	}
}
n, err := w.WriteTo(file)
fmt.Printf("%d bytes received\n", n)

Legacy API

API has been improved in non-backward-compartible way recently. Please use v1 release in legacy code.

Legacy code should import http://gopkg.in/pin/tftp.v1

Documentation

Index

• type Client
  • func NewClient(addr string) (*Client, error)
  • func (c Client) Receive(filename string, mode string) (io.WriterTo, error)
  • func (c Client) Send(filename string, mode string) (io.ReaderFrom, error)
  • func (c *Client) SetRetries(count int)
  • func (c *Client) SetTimeout(t time.Duration)
• type IncomingTransfer
• type OutgoingTransfer
• type Server
  • func NewServer(readHandler func(filename string, rf io.ReaderFrom) error, ...) *Server
  • func (s *Server) ListenAndServe(addr string) error
  • func (s *Server) Serve(conn *net.UDPConn)
  • func (s *Server) SetRetries(count int)
  • func (s *Server) SetTimeout(t time.Duration)
  • func (s *Server) Shutdown()

Types

type Client

type Client struct {
	// contains filtered or unexported fields
}

func NewClient

func NewClient(addr string) (*Client, error)

NewClient creates TFTP client for server on address provided.

func (Client) Receive

func (c Client) Receive(filename string, mode string) (io.WriterTo, error)

Receive starts incoming file transmission. It returns io.WriterTo or error.

func (Client) Send

func (c Client) Send(filename string, mode string) (io.ReaderFrom, error)

Send starts outgoing file transmission. It returns io.ReaderFrom or error.

func (*Client) SetRetries

func (c *Client) SetRetries(count int)

SetRetries sets maximum number of attempts client made to transmit a packet. Default is 5 attempts.

func (*Client) SetTimeout

func (c *Client) SetTimeout(t time.Duration)

SetTimeout sets maximum time client waits for single network round-trip to succeed. Default is 5 seconds.

type IncomingTransfer

type IncomingTransfer interface {
	Size() (n int64, ok bool)
}

type OutgoingTransfer

type OutgoingTransfer interface {
	SetSize(n int64)
}

type Server

type Server struct {
	// contains filtered or unexported fields
}

func NewServer

func NewServer(readHandler func(filename string, rf io.ReaderFrom) error,
	writeHandler func(filename string, wt io.WriterTo) error) *Server

NewServer creates TFTP server. It requires two functions to handle read and write requests. In case nil is provided for read or write handler the respective operation is disabled.

func (*Server) ListenAndServe

func (s *Server) ListenAndServe(addr string) error

ListenAndServe binds to address provided and start the server. ListenAndServe returns when Shutdown is called.

func (*Server) Serve

func (s *Server) Serve(conn *net.UDPConn)

Serve starts server provided already opened UDP connecton. It is useful for the case when you want to run server in separate goroutine but still want to be able to handle any errors opening connection. Serve returns when Shutdown is called or connection is closed.

func (*Server) SetRetries

func (s *Server) SetRetries(count int)

SetRetries sets maximum number of attempts server made to transmit a packet. Default is 5 attempts.

func (*Server) SetTimeout

func (s *Server) SetTimeout(t time.Duration)

SetTimeout sets maximum time server waits for single network round-trip to succeed. Default is 5 seconds.

func (*Server) Shutdown

func (s *Server) Shutdown()

Shutdown make server stop listening for new requests, allows server to finish outstanding transfers and stops server.