%line	%branch
org.apache.commons.net.tftp.TFTPErrorPacket	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 Error
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 TFTPErrorPacket extends TFTPPacket
44		{
45		/*** The undefined error code according to RFC 783, value 0. ***/
46		public static final int UNDEFINED = 0;
47
48		/*** The file not found error code according to RFC 783, value 1. ***/
49		public static final int FILE_NOT_FOUND = 1;
50
51		/*** The access violation error code according to RFC 783, value 2. ***/
52		public static final int ACCESS_VIOLATION = 2;
53
54		/*** The disk full error code according to RFC 783, value 3. ***/
55		public static final int OUT_OF_SPACE = 3;
56
57		/***
58		* The illegal TFTP operation error code according to RFC 783, value 4.
59		***/
60		public static final int ILLEGAL_OPERATION = 4;
61
62		/*** The unknown transfer id error code according to RFC 783, value 5. ***/
63		public static final int UNKNOWN_TID = 5;
64
65		/*** The file already exists error code according to RFC 783, value 6. ***/
66		public static final int FILE_EXISTS = 6;
67
68		/*** The no such user error code according to RFC 783, value 7. ***/
69		public static final int NO_SUCH_USER = 7;
70
71		/*** The error code of this packet. ***/
72		int _error;
73
74		/*** The error message of this packet. ***/
75		String _message;
76
77		/***
78		* Creates an error packet to be sent to a host at a given port
79		* with an error code and error message.
80		* <p>
81		* @param destination The host to which the packet is going to be sent.
82		* @param port The port to which the packet is going to be sent.
83		* @param error The error code of the packet.
84		* @param message The error message of the packet.
85		***/
86		public TFTPErrorPacket(InetAddress destination, int port,
87		int error, String message)
88		{
89	0	super(TFTPPacket.ERROR, destination, port);
90
91	0	_error = error;
92	0	_message = message;
93	0	}
94
95		/***
96		* Creates an error packet based from a received
97		* datagram. Assumes the datagram is at least length 4, else an
98		* ArrayIndexOutOfBoundsException may be thrown.
99		* <p>
100		* @param datagram The datagram containing the received error.
101		* @throws TFTPPacketException If the datagram isn't a valid TFTP
102		* error packet.
103		***/
104		TFTPErrorPacket(DatagramPacket datagram) throws TFTPPacketException
105		{
106	0	super(TFTPPacket.ERROR, datagram.getAddress(), datagram.getPort());
107		int index, length;
108		byte[] data;
109		StringBuffer buffer;
110
111	0	data = datagram.getData();
112	0	length = datagram.getLength();
113
114	0	if (getType() != data[1])
115	0	throw new TFTPPacketException("TFTP operator code does not match type.");
116
117	0	_error = (((data[2] & 0xff) << 8) | (data[3] & 0xff));
118
119	0	if (length < 5)
120	0	throw new TFTPPacketException("Bad error packet. No message.");
121
122	0	index = 4;
123	0	buffer = new StringBuffer();
124
125	0	while (index < length && data[index] != 0)
126		{
127	0	buffer.append((char)data[index]);
128	0	++index;
129		}
130
131	0	_message = buffer.toString();
132	0	}
133
134		/***
135		* This is a method only available within the package for
136		* implementing efficient datagram transport by elminating buffering.
137		* It takes a datagram as an argument, and a byte buffer in which
138		* to store the raw datagram data. Inside the method, the data
139		* is set as the datagram's data and the datagram returned.
140		* <p>
141		* @param datagram The datagram to create.
142		* @param data The buffer to store the packet and to use in the datagram.
143		* @return The datagram argument.
144		***/
145		DatagramPacket _newDatagram(DatagramPacket datagram, byte[] data)
146		{
147		int length;
148
149	0	length = _message.length();
150
151	0	data[0] = 0;
152	0	data[1] = (byte)_type;
153	0	data[2] = (byte)((_error & 0xffff) >> 8);
154	0	data[3] = (byte)(_error & 0xff);
155
156	0	System.arraycopy(_message.getBytes(), 0, data, 4, length);
157
158	0	data[length + 4] = 0;
159
160	0	datagram.setAddress(_address);
161	0	datagram.setPort(_port);
162	0	datagram.setData(data);
163	0	datagram.setLength(length + 4);
164
165	0	return datagram;
166		}
167
168
169		/***
170		* Creates a UDP datagram containing all the TFTP
171		* error packet data in the proper format.
172		* This is a method exposed to the programmer in case he
173		* wants to implement his own TFTP client instead of using
174		* the {@link org.apache.commons.net.tftp.TFTPClient}
175		* class.
176		* Under normal circumstances, you should not have a need to call this
177		* method.
178		* <p>
179		* @return A UDP datagram containing the TFTP error packet.
180		***/
181		public DatagramPacket newDatagram()
182		{
183		byte[] data;
184		int length;
185
186	0	length = _message.length();
187
188	0	data = new byte[length + 5];
189	0	data[0] = 0;
190	0	data[1] = (byte)_type;
191	0	data[2] = (byte)((_error & 0xffff) >> 8);
192	0	data[3] = (byte)(_error & 0xff);
193
194	0	System.arraycopy(_message.getBytes(), 0, data, 4, length);
195
196	0	data[length + 4] = 0;
197
198	0	return new DatagramPacket(data, data.length, _address, _port);
199		}
200
201
202		/***
203		* Returns the error code of the packet.
204		* <p>
205		* @return The error code of the packet.
206		***/
207		public int getError()
208		{
209	0	return _error;
210		}
211
212
213		/***
214		* Returns the error message of the packet.
215		* <p>
216		* @return The error message of the packet.
217		***/
218		public String getMessage()
219		{
220	0	return _message;
221		}
222		}

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