    001/*
    002 * Licensed to the Apache Software Foundation (ASF) under one or more
    003 * contributor license agreements.  See the NOTICE file distributed with
    004 * this work for additional information regarding copyright ownership.
    005 * The ASF licenses this file to You under the Apache License, Version 2.0
    006 * (the "License"); you may not use this file except in compliance with
    007 * the License.  You may obtain a copy of the License at
    008 *
    009 *      https://www.apache.org/licenses/LICENSE-2.0
    010 *
    011 * Unless required by applicable law or agreed to in writing, software
    012 * distributed under the License is distributed on an "AS IS" BASIS,
    013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    014 * See the License for the specific language governing permissions and
    015 * limitations under the License.
    016 */
    017
    018package org.apache.commons.net.tftp;
    019
    020import java.net.DatagramPacket;
    021import java.net.InetAddress;
    022
    023/**
    024 * TFTPPacket is an abstract class encapsulating the functionality common to the 5 types of TFTP packets. It also provides a static factory method that will
    025 * create the correct TFTP packet instance from a datagram. This relieves the programmer from having to figure out what kind of TFTP packet is contained in a
    026 * datagram and create it himself.
    027 * <p>
    028 * Details regarding the TFTP protocol and the format of TFTP packets can be found in RFC 783. But the point of these classes is to keep you from having to
    029 * worry about the internals. Additionally, only very few people should have to care about any of the TFTPPacket classes or derived classes. Almost all users
    030 * should only be concerned with the {@link org.apache.commons.net.tftp.TFTPClient} class {@link org.apache.commons.net.tftp.TFTPClient#receiveFile
    031 * receiveFile()} and {@link org.apache.commons.net.tftp.TFTPClient#sendFile sendFile()} methods.
    032 * </p>
    033 *
    034 * @see TFTPPacketException
    035 * @see TFTP
    036 */
    037
    038public abstract class TFTPPacket {
    039    /**
    040     * The minimum size of a packet. This is 4 bytes. It is enough to store the opcode and blocknumber or other required data depending on the packet type.
    041     */
    042    static final int MIN_PACKET_SIZE = 4;
    043
    044    /**
    045     * This is the actual TFTP spec identifier and is equal to 1. Identifier returned by {@link #getType getType()} indicating a read request packet.
    046     */
    047    public static final int READ_REQUEST = 1;
    048
    049    /**
    050     * This is the actual TFTP spec identifier and is equal to 2. Identifier returned by {@link #getType getType()} indicating a write request packet.
    051     */
    052    public static final int WRITE_REQUEST = 2;
    053
    054    /**
    055     * This is the actual TFTP spec identifier and is equal to 3. Identifier returned by {@link #getType getType()} indicating a data packet.
    056     */
    057    public static final int DATA = 3;
    058
    059    /**
    060     * This is the actual TFTP spec identifier and is equal to 4. Identifier returned by {@link #getType getType()} indicating an acknowledgement packet.
    061     */
    062    public static final int ACKNOWLEDGEMENT = 4;
    063
    064    /**
    065     * This is the actual TFTP spec identifier and is equal to 5. Identifier returned by {@link #getType getType()} indicating an error packet.
    066     */
    067    public static final int ERROR = 5;
    068
    069    /**
    070     * TFTP spec identifier {@value}. Identifier returned by {@link #getType getType()} indicating an options acknowledgement packet.
    071     *
    072     * @since 3.12.0
    073     */
    074    public static final int OACK = 6;
    075
    076    /**
    077     * The TFTP data packet maximum segment size in bytes. This is 512 and is useful for those familiar with the TFTP protocol who want to use the
    078     * {@link org.apache.commons.net.tftp.TFTP} class methods to implement their own TFTP servers or clients.
    079     */
    080    public static final int SEGMENT_SIZE = 512;
    081
    082    /**
    083     * When you receive a datagram that you expect to be a TFTP packet, you use this factory method to create the proper TFTPPacket object encapsulating the
    084     * data contained in that datagram. This method is the only way you can instantiate a TFTPPacket derived class from a datagram.
    085     *
    086     * @param datagram The datagram containing a TFTP packet.
    087     * @return The TFTPPacket object corresponding to the datagram.
    088     * @throws TFTPPacketException If the datagram does not contain a valid TFTP packet.
    089     */
    090    public static final TFTPPacket newTFTPPacket(final DatagramPacket datagram) throws TFTPPacketException {
    091        if (datagram.getLength() < MIN_PACKET_SIZE) {
    092            throw new TFTPPacketException("Bad packet. Datagram data length is too short.");
    093        }
    094        final byte[] data = datagram.getData();
    095        final TFTPPacket packet;
    096        switch (data[1]) {
    097        case READ_REQUEST:
    098            packet = new TFTPReadRequestPacket(datagram);
    099            break;
    100        case WRITE_REQUEST:
    101            packet = new TFTPWriteRequestPacket(datagram);
    102            break;
    103        case DATA:
    104            packet = new TFTPDataPacket(datagram);
    105            break;
    106        case ACKNOWLEDGEMENT:
    107            packet = new TFTPAckPacket(datagram);
    108            break;
    109        case ERROR:
    110            packet = new TFTPErrorPacket(datagram);
    111            break;
    112        default:
    113            throw new TFTPPacketException("Bad packet.  Invalid TFTP operator code.");
    114        }
    115        return packet;
    116    }
    117
    118    /** The type of packet. */
    119    int type;
    120
    121    /** The port the packet came from or is going to. */
    122    int port;
    123
    124    /** The host the packet is going to be sent or where it came from. */
    125    InetAddress address;
    126
    127    /**
    128     * This constructor is not visible outside the package. It is used by subclasses within the package to initialize base data.
    129     *
    130     * @param type    The type of the packet.
    131     * @param address The host the packet came from or is going to be sent.
    132     * @param port    The port the packet came from or is going to be sent.
    133     **/
    134    TFTPPacket(final int type, final InetAddress address, final int port) {
    135        this.type = type;
    136        this.address = address;
    137        this.port = port;
    138    }
    139
    140    /**
    141     * Gets the address of the host where the packet is going to be sent or where it came from.
    142     *
    143     * @return The type of the packet.
    144     */
    145    public final InetAddress getAddress() {
    146        return address;
    147    }
    148
    149    /**
    150     * Gets the port where the packet is going to be sent or where it came from.
    151     *
    152     * @return The port where the packet came from or where it is going.
    153     */
    154    public final int getPort() {
    155        return port;
    156    }
    157
    158    /**
    159     * Gets the type of the packet.
    160     *
    161     * @return The type of the packet.
    162     */
    163    public final int getType() {
    164        return type;
    165    }
    166
    167    /**
    168     * Creates a UDP datagram containing all the TFTP packet data in the proper format. This is an abstract method, exposed to the programmer in case he wants
    169     * to implement his own TFTP client instead of using the {@link org.apache.commons.net.tftp.TFTPClient} class. Under normal circumstances, you should not
    170     * have a need to call this method.
    171     *
    172     * @return A UDP datagram containing the TFTP packet.
    173     */
    174    public abstract DatagramPacket newDatagram();
    175
    176    /**
    177     * This is an abstract method only available within the package for implementing efficient datagram transport by eliminating buffering. It takes a datagram
    178     * as an argument, and a byte buffer in which to store the raw datagram data. Inside the method, the data should be set as the datagram's data and the
    179     * datagram returned.
    180     *
    181     * @param datagram The datagram to create.
    182     * @param data     The buffer to store the packet and to use in the datagram.
    183     * @return The datagram argument.
    184     */
    185    abstract DatagramPacket newDatagram(DatagramPacket datagram, byte[] data);
    186
    187    /**
    188     * Sets the host address where the packet is going to be sent.
    189     *
    190     * @param address the address to set
    191     */
    192    public final void setAddress(final InetAddress address) {
    193        this.address = address;
    194    }
    195
    196    /**
    197     * Sets the port where the packet is going to be sent.
    198     *
    199     * @param port the port to set
    200     */
    201    public final void setPort(final int port) {
    202        this.port = port;
    203    }
    204
    205    /**
    206     * For debugging
    207     *
    208     * @since 3.6
    209     */
    210    @Override
    211    public String toString() {
    212        return address + " " + port + " " + type;
    213    }
    214}