1 /* 2 * Licensed to the Apache Software Foundation (ASF) under one or more 3 * contributor license agreements. See the NOTICE file distributed with 4 * this work for additional information regarding copyright ownership. 5 * The ASF licenses this file to You under the Apache License, Version 2.0 6 * (the "License"); you may not use this file except in compliance with 7 * the License. You may obtain a copy of the License at 8 * 9 * http://www.apache.org/licenses/LICENSE-2.0 10 * 11 * Unless required by applicable law or agreed to in writing, software 12 * distributed under the License is distributed on an "AS IS" BASIS, 13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 * See the License for the specific language governing permissions and 15 * limitations under the License. 16 */ 17 18 package org.apache.commons.net.tftp; 19 20 import java.net.DatagramPacket; 21 import java.net.InetAddress; 22 23 /*** 24 * An abstract class derived from TFTPPacket definiing a TFTP Request 25 * packet type. It is subclassed by the 26 * {@link org.apache.commons.net.tftp.TFTPReadRequestPacket} 27 * and 28 * {@link org.apache.commons.net.tftp.TFTPWriteRequestPacket} 29 * classes. 30 * <p> 31 * Details regarding the TFTP protocol and the format of TFTP packets can 32 * be found in RFC 783. But the point of these classes is to keep you 33 * from having to worry about the internals. Additionally, only very 34 * few people should have to care about any of the TFTPPacket classes 35 * or derived classes. Almost all users should only be concerned with the 36 * {@link org.apache.commons.net.tftp.TFTPClient} class 37 * {@link org.apache.commons.net.tftp.TFTPClient#receiveFile receiveFile()} 38 * and 39 * {@link org.apache.commons.net.tftp.TFTPClient#sendFile sendFile()} 40 * methods. 41 * <p> 42 * <p> 43 * @see TFTPPacket 44 * @see TFTPReadRequestPacket 45 * @see TFTPWriteRequestPacket 46 * @see TFTPPacketException 47 * @see TFTP 48 ***/ 49 50 public abstract class TFTPRequestPacket extends TFTPPacket 51 { 52 /*** 53 * An array containing the string names of the transfer modes and indexed 54 * by the transfer mode constants. 55 ***/ 56 static final String[] _modeStrings = { "netascii", "octet" }; 57 58 /*** 59 * A null terminated byte array representation of the ascii names of the 60 * transfer mode constants. This is convenient for creating the TFTP 61 * request packets. 62 ***/ 63 private static final byte[] _modeBytes[] = { 64 { (byte)'n', (byte)'e', (byte)'t', (byte)'a', (byte)'s', (byte)'c', 65 (byte)'i', (byte)'i', 0 }, 66 { (byte)'o', (byte)'c', (byte)'t', (byte)'e', (byte)'t', 0 } 67 }; 68 69 /*** The transfer mode of the request. ***/ 70 private final int _mode; 71 72 /*** The filename of the request. ***/ 73 private final String _filename; 74 75 /*** 76 * Creates a request packet of a given type to be sent to a host at a 77 * given port with a filename and transfer mode request. 78 * <p> 79 * @param destination The host to which the packet is going to be sent. 80 * @param port The port to which the packet is going to be sent. 81 * @param type The type of the request (either TFTPPacket.READ_REQUEST or 82 * TFTPPacket.WRITE_REQUEST). 83 * @param filename The requested filename. 84 * @param mode The requested transfer mode. This should be on of the TFTP 85 * class MODE constants (e.g., TFTP.NETASCII_MODE). 86 ***/ 87 TFTPRequestPacket(InetAddress destination, int port, 88 int type, String filename, int mode) 89 { 90 super(type, destination, port); 91 92 _filename = filename; 93 _mode = mode; 94 } 95 96 /*** 97 * Creates a request packet of a given type based on a received 98 * datagram. Assumes the datagram is at least length 4, else an 99 * ArrayIndexOutOfBoundsException may be thrown. 100 * <p> 101 * @param type The type of the request (either TFTPPacket.READ_REQUEST or 102 * TFTPPacket.WRITE_REQUEST). 103 * @param datagram The datagram containing the received request. 104 * @throws TFTPPacketException If the datagram isn't a valid TFTP 105 * request packet of the appropriate type. 106 ***/ 107 TFTPRequestPacket(int type, DatagramPacket datagram) 108 throws TFTPPacketException 109 { 110 super(type, datagram.getAddress(), datagram.getPort()); 111 112 byte[] data = datagram.getData(); 113 114 if (getType() != data[1]) { 115 throw new TFTPPacketException("TFTP operator code does not match type."); 116 } 117 118 StringBuilder buffer = new StringBuilder(); 119 120 int index = 2; 121 int length = datagram.getLength(); 122 123 while (index < length && data[index] != 0) 124 { 125 buffer.append((char)data[index]); 126 ++index; 127 } 128 129 _filename = buffer.toString(); 130 131 if (index >= length) { 132 throw new TFTPPacketException("Bad filename and mode format."); 133 } 134 135 buffer.setLength(0); 136 ++index; // need to advance beyond the end of string marker 137 while (index < length && data[index] != 0) 138 { 139 buffer.append((char)data[index]); 140 ++index; 141 } 142 143 String modeString = buffer.toString().toLowerCase(java.util.Locale.ENGLISH); 144 length = _modeStrings.length; 145 146 int mode = 0; 147 for (index = 0; index < length; index++) 148 { 149 if (modeString.equals(_modeStrings[index])) 150 { 151 mode = index; 152 break; 153 } 154 } 155 156 _mode = mode; 157 158 if (index >= length) 159 { 160 throw new TFTPPacketException("Unrecognized TFTP transfer mode: " + modeString); 161 // May just want to default to binary mode instead of throwing 162 // exception. 163 //_mode = TFTP.OCTET_MODE; 164 } 165 } 166 167 168 /*** 169 * This is a method only available within the package for 170 * implementing efficient datagram transport by elminating buffering. 171 * It takes a datagram as an argument, and a byte buffer in which 172 * to store the raw datagram data. Inside the method, the data 173 * is set as the datagram's data and the datagram returned. 174 * <p> 175 * @param datagram The datagram to create. 176 * @param data The buffer to store the packet and to use in the datagram. 177 * @return The datagram argument. 178 ***/ 179 @Override 180 final DatagramPacket _newDatagram(DatagramPacket datagram, byte[] data) 181 { 182 int fileLength, modeLength; 183 184 fileLength = _filename.length(); 185 modeLength = _modeBytes[_mode].length; 186 187 data[0] = 0; 188 data[1] = (byte)_type; 189 System.arraycopy(_filename.getBytes(), 0, data, 2, fileLength); 190 data[fileLength + 2] = 0; 191 System.arraycopy(_modeBytes[_mode], 0, data, fileLength + 3, 192 modeLength); 193 194 datagram.setAddress(_address); 195 datagram.setPort(_port); 196 datagram.setData(data); 197 datagram.setLength(fileLength + modeLength + 3); 198 199 return datagram; 200 } 201 202 /*** 203 * Creates a UDP datagram containing all the TFTP 204 * request packet data in the proper format. 205 * This is a method exposed to the programmer in case he 206 * wants to implement his own TFTP client instead of using 207 * the {@link org.apache.commons.net.tftp.TFTPClient} 208 * class. Under normal circumstances, you should not have a need to call 209 * this method. 210 * <p> 211 * @return A UDP datagram containing the TFTP request packet. 212 ***/ 213 @Override 214 public final DatagramPacket newDatagram() 215 { 216 int fileLength, modeLength; 217 byte[] data; 218 219 fileLength = _filename.length(); 220 modeLength = _modeBytes[_mode].length; 221 222 data = new byte[fileLength + modeLength + 4]; 223 data[0] = 0; 224 data[1] = (byte)_type; 225 System.arraycopy(_filename.getBytes(), 0, data, 2, fileLength); 226 data[fileLength + 2] = 0; 227 System.arraycopy(_modeBytes[_mode], 0, data, fileLength + 3, 228 modeLength); 229 230 return new DatagramPacket(data, data.length, _address, _port); 231 } 232 233 /*** 234 * Returns the transfer mode of the request. 235 * <p> 236 * @return The transfer mode of the request. 237 ***/ 238 public final int getMode() 239 { 240 return _mode; 241 } 242 243 /*** 244 * Returns the requested filename. 245 * <p> 246 * @return The requested filename. 247 ***/ 248 public final String getFilename() 249 { 250 return _filename; 251 } 252 }