Coverage report

| %line | %branch
--- | --- | ---
org.apache.commons.net.tftp.TFTPDataPacket |
0% |
0% |

1 |  |
     /*
2 |  |
      * Copyright 2001-2005 The Apache Software Foundation
3 |  |
      *
4 |  |
      * Licensed under the Apache License, Version 2.0 (the "License");
5 |  |
      * you may not use this file except in compliance with the License.
6 |  |
      * You may obtain a copy of the License at
7 |  |
      *
8 |  |
      *     http://www.apache.org/licenses/LICENSE-2.0
9 |  |
      *
10 |  |
      * Unless required by applicable law or agreed to in writing, software
11 |  |
      * distributed under the License is distributed on an "AS IS" BASIS,
12 |  |
      * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 |  |
      * See the License for the specific language governing permissions and
14 |  |
      * limitations under the License.
15 |  |
      */
16 |  |
     package org.apache.commons.net.tftp;
17 |  |
18 |  |
     import java.net.DatagramPacket;
19 |  |
     import java.net.InetAddress;
20 |  |
21 |  |
     /***
22 |  |
      * A final class derived from TFTPPacket definiing the TFTP Data
23 |  |
      * packet type.
24 |  |
      * <p>
25 |  |
      * Details regarding the TFTP protocol and the format of TFTP packets can
26 |  |
      * be found in RFC 783.  But the point of these classes is to keep you
27 |  |
      * from having to worry about the internals.  Additionally, only very
28 |  |
      * few people should have to care about any of the TFTPPacket classes
29 |  |
      * or derived classes.  Almost all users should only be concerned with the
30 |  |
      * {@link org.apache.commons.net.tftp.TFTPClient} class
31 |  |
      * {@link org.apache.commons.net.tftp.TFTPClient#receiveFile receiveFile()}
32 |  |
      * and
33 |  |
      * {@link org.apache.commons.net.tftp.TFTPClient#sendFile sendFile()}
34 |  |
      * methods.
35 |  |
      * <p>
36 |  |
      * <p>
37 |  |
      * @author Daniel F. Savarese
38 |  |
      * @see TFTPPacket
39 |  |
      * @see TFTPPacketException
40 |  |
      * @see TFTP
41 |  |
      ***/
42 |  |
43 |  |
     public final class TFTPDataPacket extends TFTPPacket
44 |  |
     {
45 |  |
         /*** The maximum number of bytes in a TFTP data packet (512) ***/
46 |  |
         public static final int MAX_DATA_LENGTH = 512;
47 |  |
48 |  |
         /*** The minimum number of bytes in a TFTP data packet (0) ***/
49 |  |
         public static final int MIN_DATA_LENGTH = 0;
50 |  |
51 |  |
         /*** The block number of the packet. ***/
52 |  |
         int _blockNumber;
53 |  |
54 |  |
         /*** The length of the data. ***/
55 |  |
         int _length;
56 |  |
57 |  |
         /*** The offset into the _data array at which the data begins. ***/
58 |  |
         int _offset;
59 |  |
60 |  |
         /*** The data stored in the packet. ***/
61 |  |
         byte[] _data;
62 |  |
63 |  |
         /***
64 |  |
          * Creates a data packet to be sent to a host at a given port
65 |  |
          * with a given block number.  The actual data to be sent is passed as
66 |  |
          * an array, an offset, and a length.  The offset is the offset into
67 |  |
          * the byte array where the data starts.  The length is the length of
68 |  |
          * the data.  If the length is greater than MAX_DATA_LENGTH, it is
69 |  |
          * truncated.
70 |  |
          * <p>
71 |  |
          * @param destination  The host to which the packet is going to be sent.
72 |  |
          * @param port  The port to which the packet is going to be sent.
73 |  |
          * @param blockNumber The block number of the data.
74 |  |
          * @param data The byte array containing the data.
75 |  |
          * @param offset The offset into the array where the data starts.
76 |  |
          * @param length The length of the data.
77 |  |
          ***/
78 |  |
         public TFTPDataPacket(InetAddress destination, int port, class="keyword">int blockNumber,
79 |  |
                               byte[] data, int offset, class="keyword">int length)
80 |  |
         {
81 | 0 |
             super(TFTPPacket.DATA, destination, port);
82 |  |
83 | 0 |
             _blockNumber = blockNumber;
84 | 0 |
             _data = data;
85 | 0 |
             _offset = offset;
86 |  |
87 | 0 |
             if (length > MAX_DATA_LENGTH)
88 | 0 |
                 _length = MAX_DATA_LENGTH;
89 |  |
             else
90 | 0 |
                 _length = length;
91 | 0 |
         }
92 |  |
93 |  |
         public TFTPDataPacket(InetAddress destination, int port, class="keyword">int blockNumber,
94 |  |
                               byte[] data)
95 |  |
         {
96 | 0 |
             this(destination, port, blockNumber, data, 0, data.length);
97 | 0 |
         }
98 |  |
99 |  |
100 |  |
         /***
101 |  |
          * Creates a data packet based from a received
102 |  |
          * datagram.  Assumes the datagram is at least length 4, else an
103 |  |
          * ArrayIndexOutOfBoundsException may be thrown.
104 |  |
          * <p>
105 |  |
          * @param datagram  The datagram containing the received data.
106 |  |
          * @throws TFTPPacketException  If the datagram isn't a valid TFTP
107 |  |
          *         data packet.
108 |  |
          ***/
109 |  |
         TFTPDataPacket(DatagramPacket datagram) throws TFTPPacketException
110 |  |
         {
111 | 0 |
             super(TFTPPacket.DATA, datagram.getAddress(), datagram.getPort());
112 |  |
113 | 0 |
             _data = datagram.getData();
114 | 0 |
             _offset = 4;
115 |  |
116 | 0 |
             if (getType() != _data[1])
117 | 0 |
                 throw new TFTPPacketException("TFTP operator code does not match type.");
118 |  |
119 | 0 |
             _blockNumber = (((_data[2] & 0xff) << 8) | (_data[3] & 0xff));
120 |  |
121 | 0 |
             _length = datagram.getLength() - 4;
122 |  |
123 | 0 |
             if (_length > MAX_DATA_LENGTH)
124 | 0 |
                 _length = MAX_DATA_LENGTH;
125 | 0 |
         }
126 |  |
127 |  |
         /***
128 |  |
          * This is a method only available within the package for
129 |  |
          * implementing efficient datagram transport by elminating buffering.
130 |  |
          * It takes a datagram as an argument, and a byte buffer in which
131 |  |
          * to store the raw datagram data.  Inside the method, the data
132 |  |
          * is set as the datagram's data and the datagram returned.
133 |  |
          * <p>
134 |  |
          * @param datagram  The datagram to create.
135 |  |
          * @param data The buffer to store the packet and to use in the datagram.
136 |  |
          * @return The datagram argument.
137 |  |
          ***/
138 |  |
         DatagramPacket _newDatagram(DatagramPacket datagram, byte[] data)
139 |  |
         {
140 | 0 |
             data[0] = 0;
141 | 0 |
             data[1] = (byte)_type;
142 | 0 |
             data[2] = (byte)((_blockNumber & 0xffff) >> 8);
143 | 0 |
             data[3] = (byte)(_blockNumber & 0xff);
144 |  |
145 |  |
             // Doublecheck we're not the same
146 | 0 |
             if (data != _data)
147 | 0 |
                 System.arraycopy(_data, _offset, data, 4, _length);
148 |  |
149 | 0 |
             datagram.setAddress(_address);
150 | 0 |
             datagram.setPort(_port);
151 | 0 |
             datagram.setData(data);
152 | 0 |
             datagram.setLength(_length + 4);
153 |  |
154 | 0 |
             return datagram;
155 |  |
         }
156 |  |
157 |  |
         /***
158 |  |
          * Creates a UDP datagram containing all the TFTP
159 |  |
          * data packet data in the proper format.
160 |  |
          * This is a method exposed to the programmer in case he
161 |  |
          * wants to implement his own TFTP client instead of using
162 |  |
          * the {@link org.apache.commons.net.tftp.TFTPClient}
163 |  |
          * class.
164 |  |
          * Under normal circumstances, you should not have a need to call this
165 |  |
          * method.
166 |  |
          * <p>
167 |  |
          * @return A UDP datagram containing the TFTP data packet.
168 |  |
          ***/
169 |  |
         public DatagramPacket newDatagram()
170 |  |
         {
171 |  |
             byte[] data;
172 |  |
173 | 0 |
             data = new byte[_length + 4];
174 | 0 |
             data[0] = 0;
175 | 0 |
             data[1] = (byte)_type;
176 | 0 |
             data[2] = (byte)((_blockNumber & 0xffff) >> 8);
177 | 0 |
             data[3] = (byte)(_blockNumber & 0xff);
178 |  |
179 | 0 |
             System.arraycopy(_data, _offset, data, 4, _length);
180 |  |
181 | 0 |
             return new DatagramPacket(data, _length + 4, _address, _port);
182 |  |
         }
183 |  |
184 |  |
         /***
185 |  |
          * Returns the block number of the data packet.
186 |  |
          * <p>
187 |  |
          * @return The block number of the data packet.
188 |  |
          ***/
189 |  |
         public int getBlockNumber()
190 |  |
         {
191 | 0 |
             return _blockNumber;
192 |  |
         }
193 |  |
194 |  |
         /*** Sets the block number of the data packet.  ***/
195 |  |
         public void setBlockNumber(int blockNumber)
196 |  |
         {
197 | 0 |
             _blockNumber = blockNumber;
198 | 0 |
         }
199 |  |
200 |  |
         /***
201 |  |
          * Sets the data for the data packet.
202 |  |
          * <p>
203 |  |
          * @param data The byte array containing the data.
204 |  |
          * @param offset The offset into the array where the data starts.
205 |  |
          * @param length The length of the data.
206 |  |
          ***/
207 |  |
         public void setData(byte[] data, int offset, class="keyword">int length)
208 |  |
         {
209 | 0 |
             _data = data;
210 | 0 |
             _offset = offset;
211 | 0 |
             _length = length;
212 |  |
213 | 0 |
             if (length > MAX_DATA_LENGTH)
214 | 0 |
                 _length = MAX_DATA_LENGTH;
215 |  |
             else
216 | 0 |
                 _length = length;
217 | 0 |
         }
218 |  |
219 |  |
         /***
220 |  |
          * Returns the length of the data part of the data packet.
221 |  |
          * <p>
222 |  |
          * @return The length of the data part of the data packet.
223 |  |
          ***/
224 |  |
         public int getDataLength()
225 |  |
         {
226 | 0 |
             return _length;
227 |  |
         }
228 |  |
229 |  |
         /***
230 |  |
          * Returns the offset into the byte array where the packet data actually
231 |  |
          * starts.
232 |  |
          * <p>
233 |  |
          * @return The offset into the byte array where the packet data actually
234 |  |
          *         starts.
235 |  |
          ***/
236 |  |
         public int getDataOffset()
237 |  |
         {
238 | 0 |
             return _offset;
239 |  |
         }
240 |  |
241 |  |
         /***
242 |  |
          * Returns the byte array containing the packet data.
243 |  |
          * <p>
244 |  |
          * @return The byte array containing the packet data.
245 |  |
          ***/
246 |  |
         public byte[] getData()
247 |  |
         {
248 | 0 |
             return _data;
249 |  |
         }
250 |  |
     }

This report is generated by jcoverage, Maven and Maven JCoverage Plugin.