panda.net.tftp.TFTPRequestPacket Maven / Gradle / Ivy
Show all versions of panda-nets Show documentation
package panda.net.tftp;
import java.net.DatagramPacket;
import java.net.InetAddress;
/***
* An abstract class derived from TFTPPacket definiing a TFTP Request packet type. It is subclassed
* by the {@link panda.net.tftp.TFTPReadRequestPacket} and
* {@link panda.net.tftp.TFTPWriteRequestPacket} classes.
*
* 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 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 should only be concerned with the {@link panda.net.tftp.TFTPClient} class
* {@link panda.net.tftp.TFTPClient#receiveFile receiveFile()} and
* {@link panda.net.tftp.TFTPClient#sendFile sendFile()} methods.
*
* @see TFTPPacket
* @see TFTPReadRequestPacket
* @see TFTPWriteRequestPacket
* @see TFTPPacketException
* @see TFTP
***/
public abstract class TFTPRequestPacket extends TFTPPacket {
/***
* An array containing the string names of the transfer modes and indexed by the transfer mode
* constants.
***/
static final String[] _modeStrings = { "netascii", "octet" };
/***
* A null terminated byte array representation of the ascii names of the transfer mode
* constants. This is convenient for creating the TFTP request packets.
***/
private static final byte[] _modeBytes[] = {
{ (byte)'n', (byte)'e', (byte)'t', (byte)'a', (byte)'s', (byte)'c', (byte)'i', (byte)'i', 0 },
{ (byte)'o', (byte)'c', (byte)'t', (byte)'e', (byte)'t', 0 } };
/*** The transfer mode of the request. ***/
private final int _mode;
/*** The filename of the request. ***/
private final String _filename;
/***
* Creates a request packet of a given type to be sent to a host at a given port with a filename
* and transfer mode request.
*
* @param destination The host to which the packet is going to be sent.
* @param port The port to which the packet is going to be sent.
* @param type The type of the request (either TFTPPacket.READ_REQUEST or
* TFTPPacket.WRITE_REQUEST).
* @param filename The requested filename.
* @param mode The requested transfer mode. This should be on of the TFTP class MODE constants
* (e.g., TFTP.NETASCII_MODE).
***/
TFTPRequestPacket(InetAddress destination, int port, int type, String filename, int mode) {
super(type, destination, port);
_filename = filename;
_mode = mode;
}
/***
* Creates a request packet of a given type based on a received datagram. Assumes the datagram
* is at least length 4, else an ArrayIndexOutOfBoundsException may be thrown.
*
* @param type The type of the request (either TFTPPacket.READ_REQUEST or
* TFTPPacket.WRITE_REQUEST).
* @param datagram The datagram containing the received request.
* @throws TFTPPacketException If the datagram isn't a valid TFTP request packet of the
* appropriate type.
***/
TFTPRequestPacket(int type, DatagramPacket datagram) throws TFTPPacketException {
super(type, datagram.getAddress(), datagram.getPort());
byte[] data = datagram.getData();
if (getType() != data[1]) {
throw new TFTPPacketException("TFTP operator code does not match type.");
}
StringBuilder buffer = new StringBuilder();
int index = 2;
int length = datagram.getLength();
while (index < length && data[index] != 0) {
buffer.append((char)data[index]);
++index;
}
_filename = buffer.toString();
if (index >= length) {
throw new TFTPPacketException("Bad filename and mode format.");
}
buffer.setLength(0);
++index; // need to advance beyond the end of string marker
while (index < length && data[index] != 0) {
buffer.append((char)data[index]);
++index;
}
String modeString = buffer.toString().toLowerCase(java.util.Locale.ENGLISH);
length = _modeStrings.length;
int mode = 0;
for (index = 0; index < length; index++) {
if (modeString.equals(_modeStrings[index])) {
mode = index;
break;
}
}
_mode = mode;
if (index >= length) {
throw new TFTPPacketException("Unrecognized TFTP transfer mode: " + modeString);
// May just want to default to binary mode instead of throwing
// exception.
// _mode = TFTP.OCTET_MODE;
}
}
/***
* This is a method only available within the package for implementing efficient datagram
* transport by elminating buffering. It takes a datagram as an argument, and a byte buffer in
* which to store the raw datagram data. Inside the method, the data is set as the datagram's
* data and the datagram returned.
*
* @param datagram The datagram to create.
* @param data The buffer to store the packet and to use in the datagram.
* @return The datagram argument.
***/
@Override
final DatagramPacket _newDatagram(DatagramPacket datagram, byte[] data) {
int fileLength, modeLength;
fileLength = _filename.length();
modeLength = _modeBytes[_mode].length;
data[0] = 0;
data[1] = (byte)_type;
System.arraycopy(_filename.getBytes(), 0, data, 2, fileLength);
data[fileLength + 2] = 0;
System.arraycopy(_modeBytes[_mode], 0, data, fileLength + 3, modeLength);
datagram.setAddress(_address);
datagram.setPort(_port);
datagram.setData(data);
datagram.setLength(fileLength + modeLength + 3);
return datagram;
}
/***
* Creates a UDP datagram containing all the TFTP request packet data in the proper format. This
* is a method exposed to the programmer in case he wants to implement his own TFTP client
* instead of using the {@link panda.net.tftp.TFTPClient} class. Under normal circumstances, you
* should not have a need to call this method.
*
* @return A UDP datagram containing the TFTP request packet.
***/
@Override
public final DatagramPacket newDatagram() {
int fileLength, modeLength;
byte[] data;
fileLength = _filename.length();
modeLength = _modeBytes[_mode].length;
data = new byte[fileLength + modeLength + 4];
data[0] = 0;
data[1] = (byte)_type;
System.arraycopy(_filename.getBytes(), 0, data, 2, fileLength);
data[fileLength + 2] = 0;
System.arraycopy(_modeBytes[_mode], 0, data, fileLength + 3, modeLength);
return new DatagramPacket(data, data.length, _address, _port);
}
/***
* Returns the transfer mode of the request.
*
* @return The transfer mode of the request.
***/
public final int getMode() {
return _mode;
}
/***
* Returns the requested filename.
*
* @return The requested filename.
***/
public final String getFilename() {
return _filename;
}
}