unit tests coverage

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
* 

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
* 

36
* 

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
* 

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
* 

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
* 

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
* 

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
* 

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
* 

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
* 

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
* 

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
* 

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.

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		}