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 *      http://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 * An abstract class derived from TFTPPacket definiing a TFTP Request
025 * packet type.  It is subclassed by the
026 * {@link org.apache.commons.net.tftp.TFTPReadRequestPacket}
027 *   and
028 * {@link org.apache.commons.net.tftp.TFTPWriteRequestPacket}
029 *  classes.
030 * <p>
031 * Details regarding the TFTP protocol and the format of TFTP packets can
032 * be found in RFC 783.  But the point of these classes is to keep you
033 * from having to worry about the internals.  Additionally, only very
034 * few people should have to care about any of the TFTPPacket classes
035 * or derived classes.  Almost all users should only be concerned with the
036 * {@link org.apache.commons.net.tftp.TFTPClient} class
037 * {@link org.apache.commons.net.tftp.TFTPClient#receiveFile receiveFile()}
038 * and
039 * {@link org.apache.commons.net.tftp.TFTPClient#sendFile sendFile()}
040 * methods.
041 * <p>
042 * <p>
043 * @author Daniel F. Savarese
044 * @see TFTPPacket
045 * @see TFTPReadRequestPacket
046 * @see TFTPWriteRequestPacket
047 * @see TFTPPacketException
048 * @see TFTP
049 ***/
050
051public abstract class TFTPRequestPacket extends TFTPPacket
052{
053    /***
054     * An array containing the string names of the transfer modes and indexed
055     * by the transfer mode constants.
056     ***/
057    static final String[] _modeStrings = { "netascii", "octet" };
058
059    /***
060     * A null terminated byte array representation of the ascii names of the
061     * transfer mode constants.  This is convenient for creating the TFTP
062     * request packets.
063     ***/
064    static final byte[] _modeBytes[] = {
065                                           { (byte)'n', (byte)'e', (byte)'t', (byte)'a', (byte)'s', (byte)'c',
066                                             (byte)'i', (byte)'i', 0 },
067                                           { (byte)'o', (byte)'c', (byte)'t', (byte)'e', (byte)'t', 0 }
068                                       };
069
070    /*** The transfer mode of the request. ***/
071    int _mode;
072
073    /*** The filename of the request. ***/
074    String _filename;
075
076    /***
077     * Creates a request packet of a given type to be sent to a host at a
078     * given port with a filename and transfer mode request.
079     * <p>
080     * @param destination  The host to which the packet is going to be sent.
081     * @param port  The port to which the packet is going to be sent.
082     * @param type The type of the request (either TFTPPacket.READ_REQUEST or
083     *             TFTPPacket.WRITE_REQUEST).
084     * @param filename The requested filename.
085     * @param mode The requested transfer mode.  This should be on of the TFTP
086     *        class MODE constants (e.g., TFTP.NETASCII_MODE).
087     ***/
088    TFTPRequestPacket(InetAddress destination, int port,
089                      int type, String filename, int mode)
090    {
091        super(type, destination, port);
092
093        _filename = filename;
094        _mode = mode;
095    }
096
097    /***
098     * Creates a request packet of a given type based on a received
099     * datagram.  Assumes the datagram is at least length 4, else an
100     * ArrayIndexOutOfBoundsException may be thrown.
101     * <p>
102     * @param type The type of the request (either TFTPPacket.READ_REQUEST or
103     *             TFTPPacket.WRITE_REQUEST).
104     * @param datagram  The datagram containing the received request.
105     * @throws TFTPPacketException  If the datagram isn't a valid TFTP
106     *         request packet of the appropriate type.
107     ***/
108    TFTPRequestPacket(int type, DatagramPacket datagram)
109    throws TFTPPacketException
110    {
111        super(type, datagram.getAddress(), datagram.getPort());
112
113        byte[] data;
114        int index, length;
115        String mode;
116        StringBuffer buffer;
117
118        data = datagram.getData();
119
120        if (getType() != data[1])
121            throw new TFTPPacketException("TFTP operator code does not match type.");
122
123        buffer = new StringBuffer();
124
125        index = 2;
126        length = datagram.getLength();
127
128        while (index < length && data[index] != 0)
129        {
130            buffer.append((char)data[index]);
131            ++index;
132        }
133
134        _filename = buffer.toString();
135
136        if (index >= length)
137            throw new TFTPPacketException("Bad filename and mode format.");
138
139        buffer.setLength(0);
140        ++index; // need to advance beyond the end of string marker
141        while (index < length && data[index] != 0)
142        {
143            buffer.append((char)data[index]);
144            ++index;
145        }
146
147        mode = buffer.toString().toLowerCase(java.util.Locale.ENGLISH);
148        length = _modeStrings.length;
149
150        for (index = 0; index < length; index++)
151        {
152            if (mode.equals(_modeStrings[index]))
153            {
154                _mode = index;
155                break;
156            }
157        }
158
159        if (index >= length)
160        {
161            throw new TFTPPacketException("Unrecognized TFTP transfer mode: " + mode);
162            // May just want to default to binary mode instead of throwing
163            // exception.
164            //_mode = TFTP.OCTET_MODE;
165        }
166    }
167
168
169    /***
170     * This is a method only available within the package for
171     * implementing efficient datagram transport by elminating buffering.
172     * It takes a datagram as an argument, and a byte buffer in which
173     * to store the raw datagram data.  Inside the method, the data
174     * is set as the datagram's data and the datagram returned.
175     * <p>
176     * @param datagram  The datagram to create.
177     * @param data The buffer to store the packet and to use in the datagram.
178     * @return The datagram argument.
179     ***/
180    @Override
181    final DatagramPacket _newDatagram(DatagramPacket datagram, byte[] data)
182    {
183        int fileLength, modeLength;
184
185        fileLength = _filename.length();
186        modeLength = _modeBytes[_mode].length;
187
188        data[0] = 0;
189        data[1] = (byte)_type;
190        System.arraycopy(_filename.getBytes(), 0, data, 2, fileLength);
191        data[fileLength + 2] = 0;
192        System.arraycopy(_modeBytes[_mode], 0, data, fileLength + 3,
193                         modeLength);
194
195        datagram.setAddress(_address);
196        datagram.setPort(_port);
197        datagram.setData(data);
198        datagram.setLength(fileLength + modeLength + 3);
199        
200        return datagram;
201    }
202
203    /***
204     * Creates a UDP datagram containing all the TFTP
205     * request packet data in the proper format.
206     * This is a method exposed to the programmer in case he
207     * wants to implement his own TFTP client instead of using
208     * the {@link org.apache.commons.net.tftp.TFTPClient}
209     * class.  Under normal circumstances, you should not have a need to call
210     * this method.
211     * <p>
212     * @return A UDP datagram containing the TFTP request packet.
213     ***/
214    @Override
215    public final DatagramPacket newDatagram()
216    {
217        int fileLength, modeLength;
218        byte[] data;
219
220        fileLength = _filename.length();
221        modeLength = _modeBytes[_mode].length;
222
223        data = new byte[fileLength + modeLength + 4];
224        data[0] = 0;
225        data[1] = (byte)_type;
226        System.arraycopy(_filename.getBytes(), 0, data, 2, fileLength);
227        data[fileLength + 2] = 0;
228        System.arraycopy(_modeBytes[_mode], 0, data, fileLength + 3,
229                         modeLength);
230
231        return new DatagramPacket(data, data.length, _address, _port);
232    }
233
234    /***
235     * Returns the transfer mode of the request.
236     * <p>
237     * @return The transfer mode of the request.
238     ***/
239    public final int getMode()
240    {
241        return _mode;
242    }
243
244    /***
245     * Returns the requested filename.
246     * <p>
247     * @return The requested filename.
248     ***/
249    public final String getFilename()
250    {
251        return _filename;
252    }
253}