使用apache common-net包装实现tftp server

1、POM文件定义：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>multi-project-parent</artifactId>
        <groupId>multi-project-parent</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>tftp</artifactId>

    <dependencies>
        <dependency>
            <groupId>commons-net</groupId>
            <artifactId>commons-net</artifactId>
            <version>3.3</version>
        </dependency>
    </dependencies>
</project>

==========================================================================

2、Server实现：

package com.wolf.tftp.server;

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintStream;
import java.net.SocketException;
import java.net.SocketTimeoutException;
import java.util.HashSet;
import java.util.Iterator;

import com.wolf.tftp.common.Constants;
import com.wolf.tftp.common.Constants;
import org.apache.commons.net.io.FromNetASCIIOutputStream;
import org.apache.commons.net.io.ToNetASCIIInputStream;
import org.apache.commons.net.tftp.*;

/**
 * A fully multi-threaded tftp server. Can handle multiple clients at the same time. Implements RFC
 * 1350 and wrapping block numbers for large file support.
 * <p/>
 * To launch, just create an instance of the class. An IOException will be thrown if the server
 * fails to start for reasons such as port in use, port denied, etc.
 * <p/>
 * To stop, use the shutdown method.
 * <p/>
 * To check to see if the server is still running (or if it stopped because of an error), call the
 * isRunning() method.
 * <p/>
 * By default, events are not logged to stdout/stderr. This can be changed with the
 * setLog and setLogError methods.
 * <p/>
 * <p/>
 * Example usage is below:
 * <p/>
 * <code>
 * public static void main(String[] args) throws Exception
 * {
 * if (args.length != 1)
 * {
 * System.out
 * .println("You must provide 1 argument - the base path for the server to serve from.");
 * System.exit(1);
 * }
 * <p/>
 * TFTPServer ts = new TFTPServer(new File(args[0]), new File(args[0]), GET_AND_PUT);
 * ts.setSocketTimeout(2000);
 * <p/>
 * System.out.println("TFTP Server running.  Press enter to stop.");
 * new InputStreamReader(System.in).read();
 * <p/>
 * ts.shutdown();
 * System.out.println("Server shut down.");
 * System.exit(0);
 * }
 * <p/>
 * </code>
 *
 * @author <A HREF="mailto:[e-mail]">Dan Armbrust</A>
 * @since 2.0
 */
public class TFTPServer implements Runnable {

    public static enum ServerMode {GET_ONLY, PUT_ONLY, GET_AND_PUT;}

    private HashSet<TFTPTransfer> transfers_ = new HashSet<TFTPTransfer>();
    private volatile boolean shutdownServer = true;
    private volatile boolean runningServer = false;
    private TFTP serverTftp_;
    private File serverReadDirectory_;
    private File serverWriteDirectory_;
    private int port_;
    private Exception serverException = null;
    private ServerMode mode_;

    /* /dev/null output stream (default) */
    private static final PrintStream nullStream = new PrintStream(
            new OutputStream() {
                @Override
                public void write(int b) {
                }

                @Override
                public void write(byte[] b) throws IOException {
                }
            }
    );

    // don't have access to a logger api, so we will log to these streams, which
    // by default are set to a no-op logger
    private PrintStream log_;
    private PrintStream logError_;

    private int maxTimeoutRetries_ = 3;
    private int socketTimeout_;
    private Thread serverThread;

    public TFTPServer(File serverReadDirectory, File serverWriteDirectory, ServerMode mode, PrintStream log, PrintStream error)
            throws IOException {
        this(serverReadDirectory, serverWriteDirectory, Constants.DEFAULT_TFTP_PORT, mode, log, error);
    }

    /**
     * Start a TFTP Server on the default port (69). Gets and Puts occur in the specified
     * directories.
     * <p/>
     * The server will start in another thread, allowing this constructor to return immediately.
     * <p/>
     * If a get or a put comes in with a relative path that tries to get outside of the
     * serverDirectory, then the get or put will be denied.
     * <p/>
     * GET_ONLY mode only allows gets, PUT_ONLY mode only allows puts, and GET_AND_PUT allows both.
     * Modes are defined as int constants in this class.
     *
     * @param serverReadDirectory  directory for GET requests
     * @param serverWriteDirectory directory for PUT requests
     * @param mode                 A value as specified above.
     * @throws IOException if the server directory is invalid or does not exist.
     */
    public TFTPServer(File serverReadDirectory, File serverWriteDirectory, ServerMode mode)
            throws IOException {
        this(serverReadDirectory, serverWriteDirectory, Constants.DEFAULT_TFTP_PORT, mode, null, null);
    }

    /**
     * Start a TFTP Server on the specified port. Gets and Puts occur in the specified directory.
     * <p/>
     * The server will start in another thread, allowing this constructor to return immediately.
     * <p/>
     * If a get or a put comes in with a relative path that tries to get outside of the
     * serverDirectory, then the get or put will be denied.
     * <p/>
     * GET_ONLY mode only allows gets, PUT_ONLY mode only allows puts, and GET_AND_PUT allows both.
     * Modes are defined as int constants in this class.
     *
     * @param serverReadDirectory  directory for GET requests
     * @param serverWriteDirectory directory for PUT requests
     * @param mode                 A value as specified above.
     * @param log                  Stream to write log message to. If not provided, uses System.out
     * @param errorLog             Stream to write error messages to. If not provided, uses System.err.
     * @throws IOException if the server directory is invalid or does not exist.
     */
    public TFTPServer(File serverReadDirectory, File serverWriteDirectory, int port, ServerMode mode,
                      PrintStream log, PrintStream errorLog) throws IOException {
        port_ = port;
        mode_ = mode;
        log_ = (log == null ? nullStream : log);
        logError_ = (errorLog == null ? nullStream : errorLog);

        log_.println("Starting TFTP Server on port " + port_ + ".  Read directory: "
                + serverReadDirectory + " Write directory: " + serverWriteDirectory
                + " Server Mode is " + mode_);

        serverReadDirectory_ = serverReadDirectory.getCanonicalFile();
        if (!serverReadDirectory_.exists() || !serverReadDirectory.isDirectory()) {
            throw new IOException("The server read directory " + serverReadDirectory_
                    + " does not exist");
        }

        serverWriteDirectory_ = serverWriteDirectory.getCanonicalFile();
        if (!serverWriteDirectory_.exists() || !serverWriteDirectory.isDirectory()) {
            throw new IOException("The server write directory " + serverWriteDirectory_
                    + " does not exist");
        }
        //launch(serverReadDirectory, serverWriteDirectory);
    }

    /**
     * Set the max number of retries in response to a timeout. Default 3. Min 0.
     *
     * @param retries
     */
    public void setMaxTimeoutRetries(int retries) {
        if (retries < 0) {
            throw new RuntimeException("Invalid Value");
        }
        maxTimeoutRetries_ = retries;
    }

    /**
     * Get the current value for maxTimeoutRetries
     */
    public int getMaxTimeoutRetries() {
        return maxTimeoutRetries_;
    }

    /**
     * Set the socket timeout in milliseconds used in transfers. Defaults to the value here:
     * http://commons.apache.org/net/apidocs/org/apache/commons/net/tftp/TFTP.html#DEFAULT_TIMEOUT
     * (5000 at the time I write this) Min value of 10.
     */
    public void setSocketTimeout(int timeout) {
        if (timeout < 10) {
            throw new RuntimeException("Invalid Value");
        }
        socketTimeout_ = timeout;
    }

    /**
     * The current socket timeout used during transfers in milliseconds.
     */
    public int getSocketTimeout() {
        return socketTimeout_;
    }

    /*
     * start the server, throw an error if it can't start.
     */
    public void launch() {
        shutdownServer = false;
        runningServer = true;

        serverTftp_ = new TFTP();
        // This is the value used in response to each client.
        socketTimeout_ = serverTftp_.getDefaultTimeout();

        // we want the server thread to listen forever.
        serverTftp_.setDefaultTimeout(0);

        try {
            serverTftp_.open(port_);
            System.out.println("TFTP Server is listen on "+port_);
        } catch (SocketException e) {
            shutdownServer = true;
            runningServer = false;
            e.printStackTrace();
        }

        serverThread = new Thread(this);
        serverThread.setDaemon(true);
        serverThread.start();
    }

    @Override
    protected void finalize() throws Throwable {
        shutdown();
    }

    /**
     * check if the server thread is still running.
     *
     * @return true if running, false if stopped.
     * @throws Exception throws the exception that stopped the server if the server is stopped from
     *                   an exception.
     */
    public boolean isRunning() throws Exception {
        if (serverException != null) {
            throw serverException;
        }
        return runningServer;
    }

    public void run() {
        try {
            while (!shutdownServer) {
                TFTPPacket tftpPacket;

                tftpPacket = serverTftp_.receive();

                TFTPTransfer tt = new TFTPTransfer(tftpPacket);
                synchronized (transfers_) {
                    transfers_.add(tt);
                }

                Thread thread = new Thread(tt);
                thread.setDaemon(true);
                thread.start();
            }
        } catch (Exception e) {
            if (!shutdownServer) {
                serverException = e;
                logError_.println("Unexpected Error in TFTP Server - Server shut down! + " + e);
            }
        } finally {
            shutdownServer = true; // set this to true, so the launching thread can check to see if it started.
            runningServer = false;
            if (serverTftp_ != null && serverTftp_.isOpen()) {
                serverTftp_.close();
            }
        }
    }

    /**
     * Stop the tftp server (and any currently running transfers) and release all opened network
     * resources.
     */
    public void shutdown() {
        shutdownServer = true;
        runningServer = false;
        synchronized (transfers_) {
            Iterator<TFTPTransfer> it = transfers_.iterator();
            while (it.hasNext()) {
                it.next().shutdown();
            }
        }

        try {
            serverTftp_.close();
        } catch (RuntimeException e) {
            // noop
        }

        try {
            serverThread.join();
        } catch (InterruptedException e) {
            // we've done the best we could, return
        }
        log_.flush();
        logError_.flush();
        log_.close();
        logError_.close();
    }

    /*
     * An instance of an ongoing transfer.
     */
    private class TFTPTransfer implements Runnable {
        private TFTPPacket tftpPacket_;

        private boolean shutdownTransfer = false;

        TFTP transferTftp_ = null;

        public TFTPTransfer(TFTPPacket tftpPacket) {
            tftpPacket_ = tftpPacket;
        }

        public void shutdown() {
            shutdownTransfer = true;
            try {
                transferTftp_.close();
            } catch (RuntimeException e) {
                // noop
            }
        }

        public void run() {
            try {
                transferTftp_ = new TFTP();

                transferTftp_.beginBufferedOps();
                transferTftp_.setDefaultTimeout(socketTimeout_);

                transferTftp_.open();

                if (tftpPacket_ instanceof TFTPReadRequestPacket) {
                    handleRead(((TFTPReadRequestPacket) tftpPacket_));
                } else if (tftpPacket_ instanceof TFTPWriteRequestPacket) {
                    handleWrite((TFTPWriteRequestPacket) tftpPacket_);
                } else {
                    log_.println("Unsupported TFTP request (" + tftpPacket_ + ") - ignored.");
                }
            } catch (Exception e) {
                e.printStackTrace();
                if (!shutdownTransfer) {
                    logError_
                            .println("Unexpected Error in during TFTP file transfer.  Transfer aborted. "
                                    + e);
                }
            } finally {
                try {
                    if (transferTftp_ != null && transferTftp_.isOpen()) {
                        transferTftp_.endBufferedOps();
                        transferTftp_.close();
                    }
                } catch (Exception e) {
                    // noop
                }
                synchronized (transfers_) {
                    transfers_.remove(this);
                }
            }
        }

        /*
         * Handle a tftp read request.
         */
        private void handleRead(TFTPReadRequestPacket trrp) throws IOException, TFTPPacketException {
            InputStream is = null;
            try {
                if (mode_ == ServerMode.PUT_ONLY) {
                    transferTftp_.bufferedSend(new TFTPErrorPacket(trrp.getAddress(), trrp
                            .getPort(), TFTPErrorPacket.ILLEGAL_OPERATION,
                            "Read not allowed by server."));
                    return;
                }

                try {
                    is = new BufferedInputStream(new FileInputStream(buildSafeFile(
                            serverReadDirectory_, trrp.getFilename(), false)));
                } catch (FileNotFoundException e) {
                    transferTftp_.bufferedSend(new TFTPErrorPacket(trrp.getAddress(), trrp
                            .getPort(), TFTPErrorPacket.FILE_NOT_FOUND, e.getMessage()));
                    return;
                } catch (Exception e) {
                    transferTftp_.bufferedSend(new TFTPErrorPacket(trrp.getAddress(), trrp
                            .getPort(), TFTPErrorPacket.UNDEFINED, e.getMessage()));
                    return;
                }

                if (trrp.getMode() == TFTP.NETASCII_MODE) {
                    is = new ToNetASCIIInputStream(is);
                }

                byte[] temp = new byte[TFTPDataPacket.MAX_DATA_LENGTH];

                TFTPPacket answer;

                int block = 1;
                boolean sendNext = true;

                int readLength = TFTPDataPacket.MAX_DATA_LENGTH;

                TFTPDataPacket lastSentData = null;

                // We are reading a file, so when we read less than the
                // requested bytes, we know that we are at the end of the file.
                while (readLength == TFTPDataPacket.MAX_DATA_LENGTH && !shutdownTransfer) {
                    if (sendNext) {
                        readLength = is.read(temp);
                        if (readLength == -1) {
                            readLength = 0;
                        }

                        lastSentData = new TFTPDataPacket(trrp.getAddress(), trrp.getPort(), block,
                                temp, 0, readLength);
                        transferTftp_.bufferedSend(lastSentData);
                    }

                    answer = null;

                    int timeoutCount = 0;

                    while (!shutdownTransfer
                            && (answer == null || !answer.getAddress().equals(trrp.getAddress()) || answer
                            .getPort() != trrp.getPort())) {
                        // listen for an answer.
                        if (answer != null) {
                            // The answer that we got didn't come from the
                            // expected source, fire back an error, and continue
                            // listening.
                            log_.println("TFTP Server ignoring message from unexpected source.");
                            transferTftp_.bufferedSend(new TFTPErrorPacket(answer.getAddress(),
                                    answer.getPort(), TFTPErrorPacket.UNKNOWN_TID,
                                    "Unexpected Host or Port"));
                        }
                        try {
                            answer = transferTftp_.bufferedReceive();
                        } catch (SocketTimeoutException e) {
                            if (timeoutCount >= maxTimeoutRetries_) {
                                throw e;
                            }
                            // didn't get an ack for this data. need to resend
                            // it.
                            timeoutCount++;
                            transferTftp_.bufferedSend(lastSentData);
                            continue;
                        }
                    }

                    if (answer == null || !(answer instanceof TFTPAckPacket)) {
                        if (!shutdownTransfer) {
                            logError_
                                    .println("Unexpected response from tftp client during transfer ("
                                            + answer + ").  Transfer aborted.");
                        }
                        break;
                    } else {
                        // once we get here, we know we have an answer packet
                        // from the correct host.
                        TFTPAckPacket ack = (TFTPAckPacket) answer;
                        if (ack.getBlockNumber() != block) {
                            /*
                             * The origional tftp spec would have called on us to resend the
                             * previous data here, however, that causes the SAS Syndrome.
                             * http://www.faqs.org/rfcs/rfc1123.html section 4.2.3.1 The modified
                             * spec says that we ignore a duplicate ack. If the packet was really
                             * lost, we will time out on receive, and resend the previous data at
                             * that point.
                             */
                            sendNext = false;
                        } else {
                            // send the next block
                            block++;
                            if (block > 65535) {
                                // wrap the block number
                                block = 0;
                            }
                            sendNext = true;
                        }
                    }
                }
            } finally {
                try {
                    if (is != null) {
                        is.close();
                    }
                } catch (IOException e) {
                    // noop
                }
            }
        }

        /*
         * handle a tftp write request.
         */
        private void handleWrite(TFTPWriteRequestPacket twrp) throws IOException,
                TFTPPacketException {
            OutputStream bos = null;
            try {
                if (mode_ == ServerMode.GET_ONLY) {
                    transferTftp_.bufferedSend(new TFTPErrorPacket(twrp.getAddress(), twrp
                            .getPort(), TFTPErrorPacket.ILLEGAL_OPERATION,
                            "Write not allowed by server."));
                    return;
                }

                int lastBlock = 0;
                String fileName = twrp.getFilename();

                try {
                    File temp = buildSafeFile(serverWriteDirectory_, fileName, true);
                    //if file exists, overwrite
                    /*if (temp.exists()) {
                        transferTftp_.bufferedSend(new TFTPErrorPacket(twrp.getAddress(), twrp
                                .getPort(), TFTPErrorPacket.FILE_EXISTS, "File already exists"));
                        return;
                    }*/
                    bos = new BufferedOutputStream(new FileOutputStream(temp,false));

                    if (twrp.getMode() == TFTP.NETASCII_MODE) {
                        bos = new FromNetASCIIOutputStream(bos);
                    }
                } catch (Exception e) {
                    transferTftp_.bufferedSend(new TFTPErrorPacket(twrp.getAddress(), twrp
                            .getPort(), TFTPErrorPacket.UNDEFINED, e.getMessage()));
                    return;
                }

                TFTPAckPacket lastSentAck = new TFTPAckPacket(twrp.getAddress(), twrp.getPort(), 0);
                transferTftp_.bufferedSend(lastSentAck);

                while (true) {
                    // get the response - ensure it is from the right place.
                    TFTPPacket dataPacket = null;

                    int timeoutCount = 0;

                    while (!shutdownTransfer
                            && (dataPacket == null
                            || !dataPacket.getAddress().equals(twrp.getAddress()) || dataPacket
                            .getPort() != twrp.getPort())) {
                        // listen for an answer.
                        if (dataPacket != null) {
                            // The data that we got didn't come from the
                            // expected source, fire back an error, and continue
                            // listening.
                            log_.println("TFTP Server ignoring message from unexpected source.");
                            transferTftp_.bufferedSend(new TFTPErrorPacket(dataPacket.getAddress(),
                                    dataPacket.getPort(), TFTPErrorPacket.UNKNOWN_TID,
                                    "Unexpected Host or Port"));
                        }

                        try {
                            dataPacket = transferTftp_.bufferedReceive();
                        } catch (SocketTimeoutException e) {
                            if (timeoutCount >= maxTimeoutRetries_) {
                                throw e;
                            }
                            // It didn't get our ack. Resend it.
                            transferTftp_.bufferedSend(lastSentAck);
                            timeoutCount++;
                            continue;
                        }
                    }

                    if (dataPacket != null && dataPacket instanceof TFTPWriteRequestPacket) {
                        // it must have missed our initial ack. Send another.
                        lastSentAck = new TFTPAckPacket(twrp.getAddress(), twrp.getPort(), 0);
                        transferTftp_.bufferedSend(lastSentAck);
                    } else if (dataPacket == null || !(dataPacket instanceof TFTPDataPacket)) {
                        if (!shutdownTransfer) {
                            logError_
                                    .println("Unexpected response from tftp client during transfer ("
                                            + dataPacket + ").  Transfer aborted.");
                        }
                        break;
                    } else {
                        int block = ((TFTPDataPacket) dataPacket).getBlockNumber();
                        byte[] data = ((TFTPDataPacket) dataPacket).getData();
                        int dataLength = ((TFTPDataPacket) dataPacket).getDataLength();
                        int dataOffset = ((TFTPDataPacket) dataPacket).getDataOffset();

                        if (block > lastBlock || (lastBlock == 65535 && block == 0)) {
                            // it might resend a data block if it missed our ack
                            // - don't rewrite the block.
                            bos.write(data, dataOffset, dataLength);
                            lastBlock = block;
                        }

                        lastSentAck = new TFTPAckPacket(twrp.getAddress(), twrp.getPort(), block);
                        transferTftp_.bufferedSend(lastSentAck);
                        if (dataLength < TFTPDataPacket.MAX_DATA_LENGTH) {
                            // end of stream signal - The tranfer is complete.
                            bos.close();

                            // But my ack may be lost - so listen to see if I
                            // need to resend the ack.
                            for (int i = 0; i < maxTimeoutRetries_; i++) {
                                try {
                                    dataPacket = transferTftp_.bufferedReceive();
                                } catch (SocketTimeoutException e) {
                                    // this is the expected route - the client
                                    // shouldn't be sending any more packets.
                                    break;
                                }

                                if (dataPacket != null
                                        && (!dataPacket.getAddress().equals(twrp.getAddress()) || dataPacket
                                        .getPort() != twrp.getPort())) {
                                    // make sure it was from the right client...
                                    transferTftp_
                                            .bufferedSend(new TFTPErrorPacket(dataPacket
                                                    .getAddress(), dataPacket.getPort(),
                                                    TFTPErrorPacket.UNKNOWN_TID,
                                                    "Unexpected Host or Port"));
                                } else {
                                    // This means they sent us the last
                                    // datapacket again, must have missed our
                                    // ack. resend it.
                                    transferTftp_.bufferedSend(lastSentAck);
                                }
                            }

                            // all done.
                            break;
                        }
                    }
                }
            } finally {
                if (bos != null) {
                    bos.close();
                }
            }
        }

        /*
         * Utility method to make sure that paths provided by tftp clients do not get outside of the
         * serverRoot directory.
         */
        private File buildSafeFile(File serverDirectory, String fileName, boolean createSubDirs)
                throws IOException {
            File temp = new File(serverDirectory, fileName);
            temp = temp.getCanonicalFile();

            if (!isSubdirectoryOf(serverDirectory, temp)) {
                throw new IOException("Cannot access files outside of tftp server root.");
            }

            // ensure directory exists (if requested)
            if (createSubDirs) {
                createDirectory(temp.getParentFile());
            }

            return temp;
        }

        /*
         * recursively create subdirectories
         */
        private void createDirectory(File file) throws IOException {
            File parent = file.getParentFile();
            if (parent == null) {
                throw new IOException("Unexpected error creating requested directory");
            }
            if (!parent.exists()) {
                // recurse...
                createDirectory(parent);
            }

            if (parent.isDirectory()) {
                if (file.isDirectory()) {
                    return;
                }
                boolean result = file.mkdir();
                if (!result) {
                    throw new IOException("Couldn't create requested directory");
                }
            } else {
                throw new IOException(
                        "Invalid directory path - file in the way of requested folder");
            }
        }

        /*
         * recursively check to see if one directory is a parent of another.
         */
        private boolean isSubdirectoryOf(File parent, File child) {
            File childsParent = child.getParentFile();
            if (childsParent == null) {
                return false;
            }
            if (childsParent.equals(parent)) {
                return true;
            } else {
                return isSubdirectoryOf(parent, childsParent);
            }
        }
    }

    /**
     * Set the stream object to log debug / informational messages. By default, this is a no-op
     *
     * @param log
     */
    public void setLog(PrintStream log) {
        this.log_ = log;
    }

    /**
     * Set the stream object to log error messsages. By default, this is a no-op
     *
     * @param logError
     */
    public void setLogError(PrintStream logError) {
        this.logError_ = logError;
    }
}

==========================================================================

3、包装server实现

package com.wolf.tftp.server;

import java.io.*;

/**
 * Created with IntelliJ IDEA.
 * User: jiyanbin
 * Date: 13-8-6
 * Time: 下午12:43
 * To change this template use File | Settings | File Templates.
 */
public class TFTPServerConsole {
    private TFTPServer server;
    private String serverReadDir;
    private String serverWriteDir;
    private int port;
    private int timeout = 30000;
    private TFTPServer.ServerMode serverMode;
    //single instance
    private volatile static TFTPServerConsole console;

    private TFTPServerConsole() throws Exception {
        //set default value;
        serverReadDir = SERVER_READ_DIR;
        serverWriteDir = SERVER_WRITE_DIR;
        port = DEFAULT_TFTP_PORT;
        serverMode = TFTPServer.ServerMode.GET_AND_PUT;

        server = new TFTPServer(new File(serverReadDir), new File(serverWriteDir), port, serverMode,
                null, null);
        server.setSocketTimeout(timeout);
    }

    public static TFTPServerConsole getInstance() throws Exception {
        if (console == null) {
            synchronized (Object.class) {
                if (console == null) {
                    console = new TFTPServerConsole();
                }
            }
        }
        return console;
    }

    public void startServer() {
        try {
            if (server != null && !server.isRunning()) {
                server.launch();
            } else {
                System.out.println("TFTP server has been running already!");
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public void stopServer() {
        try {
            if (server != null && server.isRunning()) {
                server.shutdown();
                System.out.println("TFTP Server shutdown.");
            } else {
                System.out.println("TFTP server is not running");
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public void setServerReadDir(String serverReadDir) {
        this.serverReadDir = serverReadDir;
    }

    public void setServerWriteDir(String serverWriteDir) {
        this.serverWriteDir = serverWriteDir;
    }

    public void setPort(int port) {
        this.port = port;
    }

    public void setServerMode(TFTPServer.ServerMode serverMode) {
        this.serverMode = serverMode;
    }

    public void setTimeout(int timeout) {
        this.timeout = timeout;
    }
}

==========================================================================

4、客户端工作器

package com.wolf.tftp.client;

import org.apache.commons.net.tftp.TFTP;
import org.apache.commons.net.tftp.TFTPClient;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.net.SocketException;
import java.net.UnknownHostException;

/**
 * Created with IntelliJ IDEA.
 * User: jiyanbin
 * Date: 13-8-7
 * Time: 上午11:02
 * To change this template use File | Settings | File Templates.
 */
public class TFTPClientWorker {
    private final String host;
    private final int port;
    private final boolean isReceive;
    private final int transferMode;
    private final String localFilename;
    private final String remoteFilename;

    /**
     * TFTPClientTask Builder
     */
    public static class TFTPClientWorkerBuilder {
        private String host = "localhost";
        private int port = DEFAULT_TFTP_PORT;
        private boolean isReceive;
        private int mode = TFTP.BINARY_MODE;// or TFTP.ASCII_MODE
        private String localFilename;
        private String remoteFilename;

        public TFTPClientWorkerBuilder host(String host) {
            this.host = host;
            return this;
        }

        public TFTPClientWorkerBuilder port(int port) {
            this.port = port;
            return this;
        }

        public TFTPClientWorkerBuilder isReceive(boolean isReceiver) {
            this.isReceive = isReceiver;
            return this;
        }

        public TFTPClientWorkerBuilder mode(int mode) {
            this.mode = mode;
            return this;
        }

        public TFTPClientWorkerBuilder localFilename(String localFilename) {
            this.localFilename = localFilename;
            return this;
        }

        public TFTPClientWorkerBuilder remoteFilename(String remoteFilename) {
            this.remoteFilename = remoteFilename;
            return this;
        }

        public TFTPClientWorker builder() {
            return new TFTPClientWorker(this);
        }
    }

    private TFTPClientWorker(TFTPClientWorkerBuilder builder) {
        host = builder.host;
        port = builder.port;
        isReceive = builder.isReceive;
        transferMode = builder.mode;
        localFilename = builder.localFilename;
        remoteFilename = builder.remoteFilename;
    }

    public String getHost() {
        return host;
    }

    public boolean isReceive() {
        return isReceive;
    }

    public int getTransferMode() {
        return transferMode;
    }

    public String getLocalFilename() {
        return localFilename;
    }

    public String getRemoteFilename() {
        return remoteFilename;
    }

    /**
     *
     * @return the File path in TFTP server
     * @throws SocketException
     */
    public String doJob() throws SocketException{
        TFTPClient tftp = new TFTPClient();
        // We want to timeout if a response takes longer than 60 seconds
        tftp.setDefaultTimeout(60000);
        // Open local socket
        try {
            tftp.open();
        } catch (SocketException e) {
            System.err.println("Error: could not open local UDP socket.");
            System.err.println(e.getMessage());
            throw e;
        }
        if (isReceive) {
            received(tftp);
            return SERVER_WRITE_DIR.endsWith(File.separator)?
                    SERVER_WRITE_DIR + remoteFilename:
                    SERVER_WRITE_DIR + File.separator + remoteFilename;
        } else {
            send(tftp);
            return SERVER_READ_DIR.endsWith(File.separator)?
                    SERVER_READ_DIR + remoteFilename:
                    SERVER_READ_DIR + File.separator + remoteFilename;
        }
    }

    private void received(TFTPClient tftp) {
        FileOutputStream output = null;
        File file = new File(localFilename);
        // Try to open local file for writing
        try {
            // If file exists,  overwrite it.
            output = new FileOutputStream(file,false);
        } catch (IOException e) {
            tftp.close();
            System.err.println("Error: could not open local file for writing.");
            System.err.println(e.getMessage());
            return;
        }
        // Try to receive remote file via TFTP
        try {
            tftp.receiveFile(remoteFilename, transferMode, output, host,port);
        } catch (UnknownHostException e) {
            System.err.println("Error: could not resolve hostname.");
            System.err.println(e.getMessage());
            return;
        } catch (IOException e) {
            System.err.println(
                    "Error: I/O exception occurred while receiving file.");
            System.err.println(e.getMessage());
            return;
        } finally {
            // Close local socket and output file
            tftp.close();
            try {
                if (output != null) {
                    output.close();
                }
                //closed = true;
            } catch (IOException e) {
                //closed = false;
                System.err.println("Error: error closing file.");
                System.err.println(e.getMessage());
            }
        }
    }

    private void send(TFTPClient tftp) {
        // We're sending a file
        FileInputStream input = null;
        // Try to open local file for reading
        try {
            input = new FileInputStream(localFilename);
        } catch (IOException e) {
            tftp.close();
            System.err.println("Error: could not open local file for reading.");
            System.err.println(e.getMessage());
            return;
        }
        // Try to send local file via TFTP
        try {
            tftp.sendFile(remoteFilename, transferMode, input, host, port);
        } catch (UnknownHostException e) {
            System.err.println("Error: could not resolve hostname.");
            System.err.println(e.getMessage());
            return;
        } catch (IOException e) {
            System.err.println(
                    "Error: I/O exception occurred while sending file.");
            System.err.println(e.getMessage());
            return;
        } finally {
            // Close local socket and input file
            tftp.close();
            try {
                if (input != null) {
                    input.close();
                }
                //closed = true;
            } catch (IOException e) {
                //closed = false;
                System.err.println("Error: error closing file.");
                System.err.println(e.getMessage());
            }
        }
    }
}

==========================================================================

5、公共常量类

package com.wolf.tftp.common;

/**
 * Created with IntelliJ IDEA.
 * User: jiyanbin
 * Date: 13-8-7
 * Time: 上午11:00
 * To change this template use File | Settings | File Templates.
 */
public abstract class Constants {
    public static final int DEFAULT_TFTP_PORT = 69;
    public static final String SERVER_READ_DIR;
    public static final String SERVER_WRITE_DIR;

    static {
        SERVER_READ_DIR = System.getProperty("tftp.server.read_dir",System.getProperty("java.io.tmpdir"));
        SERVER_WRITE_DIR = System.getProperty("tftp.server.write_dir",System.getProperty("java.io.tmpdir"));
    }
}

==========================================================================

6、测试，可以测试并发时的性能

启动tftp server

package com.wolf.tftp.test;

import com.wolf.tftp.server.TFTPServer;
import com.wolf.tftp.server.TFTPServerConsole;

import java.io.*;

/**
 * Created with IntelliJ IDEA.
 * User: jiyanbin
 * Date: 13-8-6
 * Time: 下午12:43
 * To change this template use File | Settings | File Templates.
 */
public class TFTPServerConsoleTest {

    private final static String WRITE_PATH = "E:\\tftp";
    private final static String READ_PATH = "E:\\tftp";

    private final static String LOG_FILE="e:\\log\\tftp.log";
    private final static String LOG_ERROR_FILE="e:\\log\\tftp.err";

    public static void main(String[] args) throws Exception {
        TFTPServerConsole console = TFTPServerConsole.getInstance();
        console.startServer();
        System.out.println("TFTP Server running.  Press enter to stop.");
        new InputStreamReader(System.in).read();
        console.stopServer();
        System.exit(0);
    }

    public void startServer() throws Exception {
        {
            PrintStream out = new PrintStream(new BufferedOutputStream(new FileOutputStream(LOG_FILE)));
            PrintStream err = new PrintStream(new BufferedOutputStream(new FileOutputStream(LOG_ERROR_FILE)));
            TFTPServer ts = new TFTPServer(new File(READ_PATH), new File(WRITE_PATH),6900, TFTPServer.ServerMode.GET_AND_PUT,
                    out,err );
            ts.setSocketTimeout(2000);
            System.out.println("TFTP Server running.  Press enter to stop.");
            new InputStreamReader(System.in).read();
            ts.shutdown();
            System.out.println("Server shut down.");
            System.exit(0);
        }
    }
}

 

客户端调用

package com.wolf.tftp.test;

import org.apache.commons.net.tftp.TFTP;

import java.util.Random;

/**
 * Created with IntelliJ IDEA.
 * User: jiyanbin
 * Date: 13-8-6
 * Time: 下午2:18
 * To change this template use File | Settings | File Templates.
 */
public class TFTPClientConsoleTest {
    static final String USAGE =
            "Usage: tftp [options] hostname localfile remotefile\n\n" +
                    "hostname   - The name of the remote host\n" +
                    "localfile  - The name of the local file to send or the name to use for\n" +
                    "\tthe received file\n" +
                    "remotefile - The name of the remote file to receive or the name for\n" +
                    "\tthe remote server to use to name the local file being sent.\n\n" +
                    "options: (The default is to assume -r -b)\n" +
                    "\t-s Send a local file\n" +
                    "\t-r Receive a remote file\n" +
                    "\t-a Use ASCII transfer mode\n" +
                    "\t-b Use binary transfer mode\n";

    private final static int CLIENT_COUNT = 200;
    private final static int DURATION = 300;
    private final static String TASK_PREFIX = "TFTP-client-";

    public static void main(String[] args) {
        int argc = 0;
        String arg = "";
        boolean receiveFile = false;
        int transferMode = TFTP.ASCII_MODE;
        String hostname, localFilename = "", remoteFilename = "";
        // Parse options
        for (argc = 0; argc < args.length; argc++) {
            arg = args[argc];
            if (arg.startsWith("-")) {
                if (arg.equals("-r")) {
                    receiveFile = true;
                } else if (arg.equals("-s")) {
                    receiveFile = false;
                } else if (arg.equals("-a")) {
                    transferMode = TFTP.ASCII_MODE;
                } else if (arg.equals("-b")) {
                    transferMode = TFTP.BINARY_MODE;
                } else {
                    System.err.println("Error: unrecognized option.");
                    System.err.print(USAGE);
                    System.exit(1);
                }
            } else {
                break;
            }
        }

        // Make sure there are enough arguments
        if (args.length - argc < 2 || args.length - argc > 3) {
            System.err.println("Error: invalid number of arguments.");
            System.err.print(USAGE);
            System.exit(1);
        }

        // Get host and file arguments
        hostname = args[argc];
        if (args.length - argc == 2) {
            localFilename = remoteFilename = args[argc + 1];
        }
        if (args.length - argc == 3) {
            localFilename = args[argc + 1];
            remoteFilename = args[argc + 2];
        }

        TaskSchedule schedule = new TaskSchedule(DURATION, CLIENT_COUNT);
        for (int i = 0; i < CLIENT_COUNT; i++) {
            String taskId = TASK_PREFIX + i;
            Random random = new Random();
            //取1-500之间的正整数
            int temp = random.nextInt(SOURCE_FILE_COUNT);
            localFilename = SOURCE_FILE_DIR + PREFIX + temp;
            //remoteFilename = taskId + PREFIX + System.currentTimeMillis();
            remoteFilename = PREFIX + temp;

            TFTPClientTask task = new TFTPClientTask.TFTPClientTaskBuilder(taskId)
                    .host(hostname)
                    .isReceive(receiveFile)
                    .localFilename(localFilename)
                    .remoteFilename(remoteFilename)
                    .mode(transferMode)
                    .barrier(schedule.cyclicBarrier)
                    .builder();
            schedule.schedule(task);
        }
    }

    private final static String SOURCE_FILE_DIR = "D:\\work\\documents\\tftp-test-file\\";
    private final static String PREFIX = "CiscoConfig-";
    //upload file count + 1
    private final static int SOURCE_FILE_COUNT = 501;
}

 

package com.wolf.tftp.test;

import java.util.concurrent.CyclicBarrier;

/**
 * Created with IntelliJ IDEA.
 * User: jiyanbin
 * Date: 13-8-7
 * Time: 上午10:39
 * To change this template use File | Settings | File Templates.
 */
public abstract class AbstractTask implements Runnable {
    String taskId;
    long successTimes;
    long failTimes;
    static long totalTimes;
    static CyclicBarrier cyclicBarrier;

    public String getTaskId() {
        return taskId;
    }

    public void setTaskId(String taskId) {
        this.taskId = taskId;
    }

    public long getSuccessTimes() {
        return successTimes;
    }

    public void setSuccessTimes(long successTimes) {
        this.successTimes = successTimes;
    }

    public long getFailTimes() {
        return failTimes;
    }

    public void setFailTimes(long failTimes) {
        this.failTimes = failTimes;
    }

    public long getTotalTimes() {
        return totalTimes;
    }

    public void setTotalTimes(long totalTimes) {
        this.totalTimes = totalTimes;
    }

    public CyclicBarrier getCyclicBarrier() {
        return cyclicBarrier;
    }

    public void setCyclicBarrier(CyclicBarrier cyclicBarrier) {
        this.cyclicBarrier = cyclicBarrier;
    }
}

 

package com.wolf.tftp.test;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * Created with IntelliJ IDEA.
 * User: jiyanbin
 * Date: 13-8-7
 * Time: 上午9:18
 * To change this template use File | Settings | File Templates.
 */
public class TaskSchedule<T extends AbstractTask> {
    CyclicBarrier cyclicBarrier;
    long begin = System.currentTimeMillis();
    List<T> tasks = new ArrayList<T>();
    ExecutorService executor = Executors.newCachedThreadPool();

    public TaskSchedule(final long duration, int taskCount) {
        System.out.println("TFTP client task is running...");
        System.out.println("Total task : " + taskCount);
        System.out.println("Time of duration :" + duration + "s");
        cyclicBarrier = new CyclicBarrier(taskCount, new Runnable() {
            @Override
            public void run() {
                long times = 0L;
                long successTimes = 0L;
                while (System.currentTimeMillis() - begin > duration * 1000) {
                    for (AbstractTask task : tasks) {
                        times = task.getTotalTimes();
                        successTimes += task.getSuccessTimes();
                        System.out.println("==============================================================");
                        //System.out.println(task.getTaskId() + " execute total times is: " + task.getTotalTimes());
                        System.out.println(task.getTaskId() + " execute success times is: " + task.getSuccessTimes());
                        System.out.println(task.getTaskId() + " execute fail times is: " + task.getFailTimes());
                        //System.out.println(task.getTaskId() + " execute rate is: " + task.getTotalTimes() / duration + "times/s");
                        System.out.println("==============================================================");
                    }
                    System.out.println("All of " + tasks.size() + " tasks execute TFTP transfer file task total count is : " + times);
                    System.out.println("Execute success rate is: " + successTimes / duration + " times/s");
                    executor.shutdown();
                    return;
                }
                System.out.println("Task is execute...");
            }
        });
    }

    public void schedule(T task) {
        tasks.add(task);
        executor.execute(task);
    }
}

package com.wolf.tftp.test;

import com.wolf.tftp.client.TFTPClientWorker;
import com.wolf.tftp.common.Constants;
import org.apache.commons.net.tftp.TFTP;

import java.net.SocketException;
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

/**
 * Created with IntelliJ IDEA.
 * User: jiyanbin
 * Date: 13-8-6
 * Time: 下午1:27
 * To change this template use File | Settings | File Templates.
 */
public class TFTPClientTask extends AbstractTask {
    final TFTPClientWorker worker;

    /**
     * TFTPClientTask Builder
     */
    public static class TFTPClientTaskBuilder {
        private final String taskId;
        private String host = "localhost";
        private int port = Constants.DEFAULT_TFTP_PORT;
        private boolean isReceive;
        private int mode = TFTP.BINARY_MODE;// or TFTP.ASCII_MODE
        private String localFilename;
        private String remoteFilename;
        private CyclicBarrier barrier;

        public TFTPClientTaskBuilder(String taskId) {
            this.taskId = taskId;
        }

        public TFTPClientTaskBuilder host(String host) {
            this.host = host;
            return this;
        }

        public TFTPClientTaskBuilder port(int port) {
            this.port = port;
            return this;
        }

        public TFTPClientTaskBuilder isReceive(boolean isReceiver) {
            this.isReceive = isReceiver;
            return this;
        }

        public TFTPClientTaskBuilder mode(int mode) {
            this.mode = mode;
            return this;
        }

        public TFTPClientTaskBuilder localFilename(String localFilename) {
            this.localFilename = localFilename;
            return this;
        }

        public TFTPClientTaskBuilder remoteFilename(String remoteFilename) {
            this.remoteFilename = remoteFilename;
            return this;
        }

        public TFTPClientTaskBuilder barrier(CyclicBarrier barrier) {
            this.barrier = barrier;
            return this;
        }

        public TFTPClientTask builder() {
            return new TFTPClientTask(this);
        }
    }

    private TFTPClientTask(TFTPClientTaskBuilder builder) {
        TFTPClientWorker.TFTPClientWorkerBuilder jobBuilder = new TFTPClientWorker.TFTPClientWorkerBuilder();
        jobBuilder.host(builder.host)
                .port(builder.port)
                .isReceive(builder.isReceive)
                .mode(builder.mode)
                .localFilename(builder.localFilename)
                .remoteFilename(builder.remoteFilename);
        worker = jobBuilder.builder();
        taskId = builder.taskId;
        cyclicBarrier = builder.barrier;
    }

    public TFTPClientWorker getWorker() {
        return worker;
    }

    public void run() {
        try {
            while (!Thread.interrupted()) {
                //System.out.println("Task :" + taskId + "is executing...");
                totalTimes++;
                String filePath = worker.doJob();
                //System.out.println("Remote file path is : " + filePath);
                successTimes++;
                cyclicBarrier.await();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
            failTimes++;
        } catch (BrokenBarrierException e) {
            e.printStackTrace();
            failTimes++;
        } catch (SocketException e) {
            System.err.println("Error: could not open local UDP socket.");
            System.err.println(e.getMessage());
            failTimes++;
        }
    }
   
}

 

 

评论

1 楼 di1984HIT 2016-02-10  

学习了～