fx-tftp 0.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 39beafe0ad28d4186166ddaa02fdb501c2d303f3
+  data.tar.gz: 4069a701c1205324e86eae44e8153fd377ee1b0a
+SHA512:
+  metadata.gz: 1f97391b5831198c2528ab81200c0b4175c70f1de238ceafbd03d4e5e6809f18b3568d8873db2db649163eef3615270252036733ec535a7f05dd15511346b364
+  data.tar.gz: b22a2355500c4cb7e7f3a9bfdb66fc7200edf70190ab05bd58baa6ab81a7aa79b6c6de13cfb13d726c154a454160882e09dd63468f7910ef378147eeaab5ed32

data/.document

@@ -0,0 +1,2 @@
+- 
+LICENSE.txt

data/.gitignore

@@ -0,0 +1,3 @@
+doc/
+pkg/
+.yardoc/

data/.travis.yml

@@ -0,0 +1,8 @@
+language: ruby
+rvm:
+  - ruby-head
+  - 1.9.3
+install:
+  - gem install minitest
+script:
+  - rake test

data/.yardopts

@@ -0,0 +1,5 @@
+--title "FX-TFTP Documentation"
+--markup markdown
+--charset utf-8
+--protected
+--private

data/LICENSE.txt

@@ -0,0 +1,23 @@
+Copyright (c) 2015, Piotr S. Staszewski
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without 
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this 
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice, 
+   this list of conditions and the following disclaimer in the documentation 
+   and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND 
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE 
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR 
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.md

@@ -0,0 +1,62 @@
+# FX-TFTP [![Build Status](https://travis-ci.org/drbig/fx-tftp.svg?branch=master)](https://travis-ci.org/drbig/fx-tftp) [![Gem](http://img.shields.io/gem/v/fx-tftp.svg)](https://rubygems.org/gems/fx-tftp) [![Yard Docs](http://img.shields.io/badge/yard-docs-blue.svg)](http://www.rubydoc.info/github/drbig/fx-tftp/master)
+
+* [Homepage](https://github.com/drbig/fx-tftp)
+* [Documentation](http://rubydoc.info/gems/fx-tftp/frames)
+
+## Description
+
+FX-TFTP is a slightly over-OO-ed pure-Ruby implementation of plain [RFC1350](https://www.ietf.org/rfc/rfc1350.txt) TFTP *server*. It is very flexible and intended for hacking. Also, and more importantly, it **works**, contrary to other gems that are occupying space at RubyGems.
+
+That flexibility may be useful if you're planning on massive custom TFTP-based boots, or if you're into ~~hacking~~ researching cheap router security. The request packets parsing has been relaxed so that it should work with TFTP clients that use some fancy extensions. I have tested the server on Linux x86_64 with Ruby 2.2.0 and on FreeBSD amd64 with Ruby 1.9.3p194, and it successfully exchanged data both ways with clients running on numerous platforms.
+
+The included `tftpd` executable gives you a fully-fledged read-write TFTP server that also does logging, daemon mode and does not crap out on `SIGTERM`.
+
+## Hacking
+
+Suppose we want to have a TFTP server that only supports reading, but the files served should depend on the IP block the client is connecting from:
+
+    class CustomHandler < TFTP::Handler::RWSimple
+      def run!(tag, req, sock, src)
+        if req.is_a? TFTP::Packet::WRQ
+          sock.send(TFTP::Packet::ERROR.new(4, 'Nope').encode, 0)
+          sock.close
+          return
+        end
+    
+        ip = src.remote_address.ip_address.split('.')
+        block = ip.slice(0, 3).join('-')
+        req.filename = File.join(block, req.filename)
+        log :info, "#{tag} Mapped filename to #{req.filename}"
+        super(tag, req, sock, src)
+      end
+    end
+    
+    srv = TFTP::Server::Base.new(CustomHandler.new(path), opts)
+
+When you combine filename inspection and `#send` and `#recv` methods working on plain `IO` objects you can easily whip up things like serving dynamically built scripts/binaries/archives based on parameters passed as the requested 'filename'.
+
+## Included executable
+
+    $ tftpd
+    Usage: tftpd [OPTIONS] PORT
+        -v, --version                    Show version and exit
+        -d, --debug                      Enable debug output
+        -l, --log PATH                   Log to file
+        -b, --background                 Fork into background
+        -h, --host HOST                  Bind do host
+        -p, --path PATH                  Serving root directory
+
+## Contributing
+
+Fell free to contributed patches using the common GitHub model (descried below). I'm also interested in cases where something doesn't work (weird platforms etc.). If you feel like it please write the client side.
+
+ - Fork the repo
+ - Checkout a new branch for your changes
+ - Write code and tests, check, commit
+ - Make a Pull Request
+
+## Licensing
+
+Standard two-clause BSD license, see LICENSE.txt for details.
+
+Copyright (c) 2015 Piotr S. Staszewski

data/Rakefile

@@ -0,0 +1,37 @@
+require 'rake/testtask'
+
+begin
+  require 'rubygems/tasks'
+  Gem::Tasks.new
+rescue LoadError => e
+  warn e.message
+end
+
+begin
+  require 'yard'
+  YARD::Rake::YardocTask.new
+  task :doc => :yard
+rescue LoadError => e
+  warn e.message
+end
+
+task :default => :test
+
+Rake::TestTask.new do |t|
+  t.libs = ['lib', 'test']
+  t.name = 'test'
+  t.description = 'Run all tests'
+  t.warning = true
+  t.test_files = FileList['test/*.rb']
+end
+
+FileList['test/*.rb'].each do |p|
+  name = p.split('/').last.split('.').first
+  Rake::TestTask.new do |t|
+    t.libs = ['lib', 'test']
+    t.name = "test:#{name}"
+    t.description = "Run only #{name} specific tests"
+    t.warning = true
+    t.test_files = [p]
+  end
+end

data/bin/tftpd

@@ -0,0 +1,60 @@
+#!/usr/bin/env ruby
+#
+
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..', 'lib')
+
+require 'logger'
+require 'optparse'
+require 'tftp'
+
+config = {:path => Dir.pwd, :host => '127.0.0.1', :fork => false,
+          :ver => false, :loglevel => Logger::INFO, :logfile => STDOUT}
+
+def die!(msg)
+  STDERR.puts msg
+  exit(2)
+end
+
+op = OptionParser.new do |o|
+  o.banner = "Usage: #{$PROGRAM_NAME} [OPTIONS] PORT"
+  o.on('-v', '--version', 'Show version and exit')            {    config[:ver]       = true }
+  o.on('-d', '--debug', 'Enable debug output')                {    config[:loglevel]  = Logger::DEBUG }
+  o.on('-l', '--log PATH',  String, 'Log to file')            {|a| config[:logfile]   = a }
+  o.on('-b', '--background', 'Fork into background')          {|a| config[:fork]      = true }
+  o.on('-h', '--host HOST', String, 'Bind do host')           {|a| config[:host]      = a }
+  o.on('-p', '--path PATH', String, 'Serving root directory') {|a| config[:path]      = a }
+end
+op.parse! or die!(op)
+
+if config[:ver]
+  puts "fx-tftpd v#{TFTP::VERSION} Copyright (c) 2015, Piotr S. Staszewski"
+  exit
+end
+
+die!('Serving root does not exists') unless File.exists? config[:path]
+
+PORT = ARGV.shift.to_i
+die!(op) if PORT < 1 || PORT > 65535
+
+log = Logger.new(config[:logfile])
+log.level = config[:loglevel]
+log.formatter = lambda {|s, d, p, m| "#{d.strftime('%Y-%m-%d %H:%M:%S.%3N')} | #{s.ljust(5)} | #{m}\n" }
+
+if config[:fork]
+  log.info 'Detaching from the console'
+  Process.daemon(true)
+end
+
+begin
+  log.info "Serving from and to #{config[:path]}"
+  srv = TFTP::Server::RWSimple.new(config[:path], :host => config[:host], :port => PORT, :logger => log)
+  srv.run!
+rescue SignalException => e
+  puts if e.is_a? Interrupt
+  srv.stop
+end
+
+if Thread.list.length > 1
+  log.info 'Waiting for outstanding connections'
+  Thread.stop
+end

data/fx-tftp.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+#
+
+require File.expand_path('../lib/tftp/version', __FILE__)
+
+Gem::Specification.new do |s|
+  s.name          = 'fx-tftp'
+  s.version       = TFTP::VERSION
+  s.date          = Time.now
+
+  s.summary       = %q{Hackable and ACTUALLY WORKING pure-Ruby TFTP server}
+  s.description   = %q{Got carried away a bit with the OOness of the whole thing, so while it won't be the fastest TFTP server it might be the most flexible, at least for pure-Ruby ones. With all the infastructure already in place adding a client should be a breeze, should anyone need it.}
+  s.license       = 'BSD'
+  s.authors       = ['Piotr S. Staszewski']
+  s.email         = 'p.staszewski@gmail.com'
+  s.homepage      = 'https://github.com/drbig/fx-tftp'
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = s.files.grep(%r{^test/})
+  s.require_paths = ['lib']
+
+  s.required_ruby_version = '>= 1.9.3'
+
+  s.add_development_dependency 'rubygems-tasks', '~> 0.2'
+  s.add_development_dependency 'minitest', '~> 5.4'
+end

data/lib/tftp.rb

@@ -0,0 +1,2 @@
+require 'tftp/tftp'
+require 'tftp/version'

data/lib/tftp/tftp.rb

@@ -0,0 +1,371 @@
+# After https://www.ietf.org/rfc/rfc1350.txt
+#
+
+require 'socket'
+
+module TFTP
+  # TFTP-specific errors.
+  class Error < Exception; end
+  # Packet parsing exception.
+  class ParseError < Error; end
+
+  # Packet can parse a binary string into a lightweight object representation.
+  module Packet
+    # Base is a thin layer over a Struct.
+    class Base < Struct
+      # Encode the packet back to binary string.
+      # It uses the #to_str method to properly format each packet, and then forces
+      # 8bit encoding.
+      def encode; to_str.force_encoding('ascii-8bit'); end
+    end
+
+    # Read Request
+    RRQ = Base.new(:filename, :mode)
+    class RRQ
+      # Convert to binary string.
+      def to_str; "\x00\x01" + self.filename + "\x00" + self.mode.to_s + "\x00"; end
+    end
+
+    # Write Request
+    WRQ = Base.new(:filename, :mode)
+    class WRQ
+      def to_str; "\x00\x02" + self.filename + "\x00" + self.mode.to_s + "\x00"; end
+    end
+
+    # Data
+    DATA = Base.new(:seq, :data)
+    class DATA
+      def to_str; "\x00\x03" + [self.seq].pack('n') + self.data; end
+      # Check if this is the last data packet for this session.
+      def last?; self.data.length < 512; end
+    end
+
+    # Acknowledgement
+    ACK = Base.new(:seq)
+    class ACK
+      def to_str; "\x00\x04" + [self.seq].pack('n'); end
+    end
+
+    # Error
+    ERROR = Base.new(:code, :msg)
+    class ERROR
+      def to_str; "\x00\x05" + [self.code].pack('n') + self.msg + "\x00"; end
+    end
+
+    # Parse a binary string into a packet.
+    # Does some sanity checking, can raise a ParseError.
+    def self.parse(data)
+      data = data.force_encoding('ascii-8bit')
+
+      opcode = data.unpack('n').first
+      if opcode < 1 || opcode > 5
+        raise ParseError, "Unknown packet opcode '#{opcode.inspect}'"
+      end
+
+      payload = data.slice(2, data.length - 2)
+      case opcode
+      when 1, 2 # rrq, wrq
+        raise ParseError, 'Not null terminated' if payload.slice(payload.length - 1) != "\x00"
+        xs = payload.split("\x00")
+        raise ParseError, "Not enough elements: #{xs.inspect}" if xs.length < 2
+        filename = xs[0]
+        mode = xs[1].downcase.to_sym
+        raise ParseError, "Unknown mode '#{xs[1].inspect}'" unless [:netascii, :octet].member? mode
+        return RRQ.new(filename, mode) if opcode == 1
+        return WRQ.new(filename, mode)
+      when 3 # data
+        seq = payload.unpack('n').first
+        block = payload.slice(2, payload.length - 2) || ''
+        raise ParseError, "Exceeded block length with #{block.length} bytes" if block.length > 512
+        return DATA.new(seq, block)
+      when 4 # ack
+        raise ParseError, "Wrong payload length with #{payload.length} bytes" if payload.length != 2
+        seq = payload.unpack('n').first
+        return ACK.new(seq)
+      when 5 # error
+        raise ParseError, 'Not null terminated' if payload.slice(payload.length - 1) != "\x00"
+        code = payload.unpack('n').first
+        raise ParseError, "Unknown error code '#{code.inspect}'" if code < 0 || code > 7
+        msg = payload.slice(2, payload.length - 3) || ''
+        return ERROR.new(code, msg)
+      end
+    end
+  end
+
+  # Handlers implement session-handling logic.
+  module Handler
+    # Base handler contains the common methods for real handlers.
+    class Base
+      # Initialize the handler.
+      #
+      # Options:
+      #
+      #  - :logger  => logger object (e.g. a Logger instance)
+      #  - :timeout => used while waiting for next DATA/ACK packets (default: 5s)
+      #
+      # All given options are saved in @opts.
+      #
+      # @param opts [Hash] Options
+      def initialize(opts = {})
+        @logger = opts[:logger]
+        @timeout = opts[:timeout] || 5
+        @opts = opts
+      end
+
+      # Send data over an established connection.
+      #
+      # Doesn't close neither sock nor io.
+      #
+      # @param tag  [String]    Tag used for logging
+      # @param sock [UDPSocket] Connected socket
+      # @param io   [IO]        Object to send data from
+      def send(tag, sock, io)
+        seq = 1
+        begin
+          while not io.eof?
+            block = io.read(512)
+            sock.send(Packet::DATA.new(seq, block).encode, 0)
+            unless IO.select([sock], nil, nil, @timeout)
+              log :warn, "#{tag} Timeout at block ##{seq}"
+              return
+            end
+            msg, _ = sock.recvfrom(4, 0)
+            pkt = Packet.parse(msg)
+            if pkt.class != Packet::ACK
+              log :warn, "#{tag} Expected ACK but got: #{pkt.class}"
+              return
+            end
+            if pkt.seq != seq
+              log :warn, "#{tag} Seq mismatch: #{seq} != #{pkt.seq}"
+              return
+            end
+            seq += 1
+          end
+        rescue ParseError => e
+          log :warn, "#{tag} Packet parse error: #{e.to_s}"
+          return
+        end
+        log :info, "#{tag} Sent file"
+      end
+
+      # Receive data over an established connection.
+      #
+      # Doesn't close neither sock nor io.
+      # Returns true if whole file has been received, false otherwise.
+      #
+      # @param tag  [String]    Tag used for logging
+      # @param sock [UDPSocket] Connected socket
+      # @param io   [IO]        Object to write data to
+      # @return [Boolean]
+      def recv(tag, sock, io)
+        sock.send(Packet::ACK.new(0).encode, 0)
+        seq = 1
+        begin
+          loop do
+            unless IO.select([sock], nil, nil, @timeout)
+              log :warn, "#{tag} Timeout at block ##{seq}"
+              return false
+            end
+            msg, _ = sock.recvfrom(516, 0)
+            pkt = Packet.parse(msg)
+            if pkt.class != Packet::DATA
+              log :warn, "#{tag} Expected DATA but got: #{pkt.class}"
+              return false
+            end
+            if pkt.seq != seq
+              log :warn, "#{tag} Seq mismatch: #{seq} != #{pkt.seq}"
+              return false
+            end
+            io.write(pkt.data)
+            sock.send(Packet::ACK.new(seq).encode, 0)
+            break if pkt.last?
+            seq += 1
+          end
+        rescue ParseError => e
+          log :warn, "#{tag} Packet parse error: #{e.to_s}"
+          return false
+        end
+        log :info, "#{tag} Received file"
+        true
+      end
+
+      private
+      def log(level, msg)
+        @logger.send(level, msg) if @logger
+      end
+    end
+
+    # Basic read-write session over a 'physical' directory.
+    class RWSimple < Base
+      # @param path [String] Path to serving root directory
+      def initialize(path, opts = {})
+        @path = path
+        super(opts)
+      end
+
+      # Handle a session.
+      #
+      # Has to close the socket (and any other resources).
+      # Note that the current version 'guards' against path traversal by a simple
+      # substitution of '..' with '__'.
+      #
+      # @param tag  [String]    Tag used for logging
+      # @param req  [Packet]    The initial request packet
+      # @param sock [UDPSocket] Connected socket
+      # @param src  [UDPSource] Initial connection information
+      def run!(tag, req, sock, src)
+        name = req.filename.gsub('..', '__')
+        path = File.join(@path, name)
+
+        case req
+        when Packet::RRQ
+          log :info, "#{tag} Read request for #{req.filename} (#{req.mode})"
+          unless File.exist? path
+            log :warn, "#{tag} File not found"
+            sock.send(Packet::ERROR.new(1, 'File not found.').encode, 0)
+            sock.close
+            return
+          end
+          mode = 'r'
+          mode += 'b' if req.mode == :octet
+          io = File.open(path, mode)
+          send(tag, sock, io)
+          sock.close
+          io.close
+        when Packet::WRQ
+          log :info, "#{tag} Write request for #{req.filename} (#{req.mode})"
+          if File.exist? path
+            log :warn, "#{tag} File already exist"
+            sock.send(Packet::ERROR.new(6, 'File already exists.').encode, 0)
+            sock.close
+            return
+          end
+          mode = 'w'
+          mode += 'b' if req.mode == :octet
+          io = File.open(path, mode)
+          ok = recv(tag, sock, io)
+          sock.close
+          io.close
+          unless ok
+            log :warn, "#{tag} Removing partial file #{req.filename}"
+            File.delete(path)
+          end
+        end
+      end
+    end
+  end
+
+  # Servers customize the Basic server and perhaps combine it with a handler.
+  module Server
+    # Basic server utilizing threads for handling sessions.
+    #
+    # It lacks a mutex around access to @clients, in case you'd want to stress
+    # test it for 10K or something.
+    #
+    # @attr handler [Handler] Session handler
+    # @attr host    [String]  Host the sockets bind to
+    # @attr port    [Integer] Session dispatcher port
+    # @attr clients [Hash]    Current sessions
+    class Base
+      attr_reader :handler, :host, :port, :clients
+
+      # Initialize the server.
+      #
+      # Options:
+      # 
+      #  - :host   => host to bind to (default: 127.0.0.1)
+      #  - :port   => dispatcher port (default: 69)
+      #  - :logger => logger instance
+      #
+      # @param handler  [Handler]  Initialized session handler
+      # @param opts     [Hash]     Options
+      def initialize(handler, opts = {})
+        @handler = handler
+
+        @host = opts[:host] || '127.0.0.1'
+        @port = opts[:port] || 69
+        @logger = opts[:logger]
+
+        @clients = Hash.new
+        @run = false
+      end
+
+      # Run the main server loop.
+      #
+      # This is obviously blocking.
+      def run!
+        log :info, "UDP server loop at #{@host}:#{@port}"
+        @run = true
+        Socket.udp_server_loop(@host, @port) do |msg, src|
+          break unless @run
+
+          addr = src.remote_address
+          tag = "[#{addr.ip_address}:#{addr.ip_port.to_s.ljust(5)}]"
+          log :info, "#{tag} New initial packet received"
+
+          begin
+            pkt = Packet.parse(msg)
+          rescue ParseError => e
+            log :warn, "#{tag} Packet parse error: #{e.to_s}"
+            next
+          end
+
+          log :debug, "#{tag} -> PKT: #{pkt.inspect}"
+          tid = get_tid
+          tag = "[#{addr.ip_address}:#{addr.ip_port.to_s.ljust(5)}:#{tid.to_s.ljust(5)}]"
+          sock = addr.connect_from(@host, tid)
+          @clients[tid] = tag
+
+          unless pkt.is_a?(Packet::RRQ) || pkt.is_a?(Packet::WRQ)
+            log :warn, "#{tag} Bad initial packet: #{pkt.class}"
+            sock.send(Packet::ERROR.new(4, 'Illegal TFTP operation.').encode, 0)
+            sock.close
+            next
+          end
+
+          Thread.new do
+            @handler.run!(tag, pkt, sock, src)
+            @clients.delete(tid)
+            log :info, "#{tag} Session ended"
+          end
+        end
+        log :info, 'UDP server loop has stopped'
+      end
+
+      # Stop the main server loop.
+      #
+      # This will allow the currently pending sessions to finish.
+      def stop
+        log :info, 'Stopping UDP server loop'
+        @run = false
+        UDPSocket.new.send('break', 0, @host, @port)
+      end
+
+      private
+      # Get the server's TID.
+      #
+      # The TID is basically a random port number we will use for a session.
+      # This actually tries to get a unique TID per session.
+      # It uses only ports 1024 - 65535 as not to require root.
+      def get_tid
+        tid = 1024 + rand(64512)
+        tid = 1024 + rand(64512) while @clients.has_key? tid
+        tid
+      end
+
+      def log(level, msg)
+        @logger.send(level, msg) if @logger
+      end
+    end
+
+    # Basic read-write TFTP server.
+    #
+    # This is what most other TFTPd implementations give you.
+    class RWSimple < Base
+      def initialize(path, opts = {})
+        handler = Handler::RWSimple.new(path, opts)
+        super(handler, opts)
+      end
+    end
+  end
+end

data/lib/tftp/version.rb

@@ -0,0 +1,4 @@
+module TFTP
+  # Current version string.
+  VERSION = '0.3'
+end

data/test/packet.rb

@@ -0,0 +1,110 @@
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..', 'lib')
+
+require 'minitest/autorun'
+require 'tftp'
+
+class Packet < Minitest::Test
+  def test_parse_rrq
+    assert_equal TFTP::Packet::RRQ.new('test.txt', :netascii),
+                 TFTP::Packet.parse("\x00\x01test.txt\x00netascii\x00")
+    assert_equal TFTP::Packet::RRQ.new('binary', :octet),
+                 TFTP::Packet.parse("\x00\x01binary\x00octet\x00")
+    assert_equal TFTP::Packet::RRQ.new('test.txt', :netascii),
+                 TFTP::Packet.parse("\x00\x01test.txt\x00nEtasCIi\x00")
+    assert_equal TFTP::Packet::RRQ.new('binary.exe', :octet),
+                 TFTP::Packet.parse("\x00\x01binary.exe\x00OCTET\x00")
+
+
+    assert_raises(TFTP::ParseError) { TFTP::Packet.parse("\x00\x01\x00\x00") }
+    assert_raises(TFTP::ParseError) { TFTP::Packet.parse("\x00\x01\x00\x00\x00") }
+    assert_raises(TFTP::ParseError) { TFTP::Packet.parse("\x00\x01a\x00c\x00c\x00") }
+    assert_raises(TFTP::ParseError) { TFTP::Packet.parse("\x00\x01foo\x00bar\x00") }
+  end
+
+  def test_encode_rrq
+    assert_equal "\x00\x01test.txt\x00netascii\x00",
+                 TFTP::Packet::RRQ.new('test.txt', :netascii).encode
+    assert_equal "\x00\x01binary\x00octet\x00",
+                 TFTP::Packet::RRQ.new('binary', :octet).encode
+  end
+
+  def test_parse_wrq
+    assert_equal TFTP::Packet::WRQ.new('test.txt', :netascii),
+                 TFTP::Packet.parse("\x00\x02test.txt\x00netascii\x00")
+    assert_equal TFTP::Packet::WRQ.new('binary', :octet),
+                 TFTP::Packet.parse("\x00\x02binary\x00octet\x00")
+    assert_equal TFTP::Packet::WRQ.new('test.txt', :netascii),
+                 TFTP::Packet.parse("\x00\x02test.txt\x00NetascIi\x00")
+    assert_equal TFTP::Packet::WRQ.new('binary', :octet),
+                 TFTP::Packet.parse("\x00\x02binary\x00OctEt\x00")
+
+
+    assert_raises(TFTP::ParseError) { TFTP::Packet.parse("\x00\x02\x00\x00\x00") }
+    assert_raises(TFTP::ParseError) { TFTP::Packet.parse("\x00\x02a\x00c\x00c\x00") }
+    assert_raises(TFTP::ParseError) { TFTP::Packet.parse("\x00\x02foo\x00bar\x00") }
+  end
+
+  def test_encode_wrq
+    assert_equal "\x00\x02test.txt\x00netascii\x00",
+                 TFTP::Packet::WRQ.new('test.txt', :netascii).encode
+    assert_equal "\x00\x02binary\x00octet\x00",
+                 TFTP::Packet::WRQ.new('binary', :octet).encode
+  end
+
+  def test_parse_data
+    assert_equal TFTP::Packet::DATA.new(0, "1234"),
+                 TFTP::Packet.parse("\x00\x03\x00\x001234")
+    assert_equal TFTP::Packet::DATA.new(16, ('a' * 512)),
+                 TFTP::Packet.parse("\x00\x03\x00\x10" + ('a' * 512))
+    assert       TFTP::Packet.parse("\x00\x03\x00\x001234").last?
+    assert_equal TFTP::Packet::DATA.new(16, ''),
+                 TFTP::Packet.parse("\x00\x03\x00\x10")
+    assert       TFTP::Packet.parse("\x00\x03\x00\x10").last?
+
+    assert_raises(TFTP::ParseError) { TFTP::Packet.parse("\x00\x03\x00\x00" + ('a' * 513)) }
+  end
+
+  def test_encode_data
+    assert_equal "\x00\x03\x00\x001234",
+                 TFTP::Packet::DATA.new(0, "1234").encode
+    assert_equal "\x00\x03\x00\x10" + ('a' * 512),
+                 TFTP::Packet::DATA.new(16, ('a' * 512)).encode
+  end
+
+  def test_parse_ack
+    assert_equal TFTP::Packet::ACK.new(0),
+                 TFTP::Packet.parse("\x00\x04\x00\x00")
+    assert_equal TFTP::Packet::ACK.new(64434),
+                 TFTP::Packet.parse("\x00\x04\xfb\xb2")
+
+
+    assert_raises(TFTP::ParseError) { TFTP::Packet.parse("\x00\x04\x00") }
+    assert_raises(TFTP::ParseError) { TFTP::Packet.parse("\x00\x04\x00" + ('A' * 8)) }
+  end
+
+  def test_encode_ack
+    assert_equal "\x00\x04\x00\x00",
+                  TFTP::Packet::ACK.new(0).encode
+    assert_equal "\x00\x04\x00\x01",
+                  TFTP::Packet::ACK.new(1).encode
+  end
+
+  def test_parse_error
+    assert_equal TFTP::Packet::ERROR.new(0, 'Not defined, see error message (if any).'),
+                 TFTP::Packet.parse("\x00\x05\x00\x00Not defined, see error message (if any).\x00")
+    assert_equal TFTP::Packet::ERROR.new(7, 'No such user.'),
+                 TFTP::Packet.parse("\x00\x05\x00\x07No such user.\x00")
+    assert_equal TFTP::Packet::ERROR.new(3, ''),
+                 TFTP::Packet.parse("\x00\x05\x00\x03\x00")
+
+    assert_raises(TFTP::ParseError) { TFTP::Packet.parse("\x00\x05\x00\xff\x00") }
+    assert_raises(TFTP::ParseError) { TFTP::Packet.parse("\x00\x05\x00\x03") }
+  end
+
+  def test_encode_error
+    assert_equal "\x00\x05\x00\x07No such user.\x00",
+                 TFTP::Packet::ERROR.new(7, 'No such user.').encode
+    assert_equal "\x00\x05\x00\x03\x00",
+                 TFTP::Packet::ERROR.new(3, '').encode
+  end
+end

metadata

@@ -0,0 +1,88 @@
+--- !ruby/object:Gem::Specification
+name: fx-tftp
+version: !ruby/object:Gem::Version
+  version: '0.3'
+platform: ruby
+authors:
+- Piotr S. Staszewski
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-01-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rubygems-tasks
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.4'
+description: Got carried away a bit with the OOness of the whole thing, so while it
+  won't be the fastest TFTP server it might be the most flexible, at least for pure-Ruby
+  ones. With all the infastructure already in place adding a client should be a breeze,
+  should anyone need it.
+email: p.staszewski@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".document"
+- ".gitignore"
+- ".travis.yml"
+- ".yardopts"
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/tftpd
+- fx-tftp.gemspec
+- lib/tftp.rb
+- lib/tftp/tftp.rb
+- lib/tftp/version.rb
+- test/packet.rb
+homepage: https://github.com/drbig/fx-tftp
+licenses:
+- BSD
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.9.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: Hackable and ACTUALLY WORKING pure-Ruby TFTP server
+test_files:
+- test/packet.rb