%line	%branch
org.apache.commons.net.tftp.TFTPClient	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.io.IOException;
19		import java.io.InputStream;
20		import java.io.InterruptedIOException;
21		import java.io.OutputStream;
22		import java.net.InetAddress;
23		import java.net.SocketException;
24		import java.net.UnknownHostException;
25		import org.apache.commons.net.io.FromNetASCIIOutputStream;
26		import org.apache.commons.net.io.ToNetASCIIInputStream;
27
28		/***
29		* The TFTPClient class encapsulates all the aspects of the TFTP protocol
30		* necessary to receive and send files through TFTP. It is derived from
31		* the {@link org.apache.commons.net.tftp.TFTP} because
32		* it is more convenient than using aggregation, and as a result exposes
33		* the same set of methods to allow you to deal with the TFTP protocol
34		* directly. However, almost every user should only be concerend with the
35		* the {@link org.apache.commons.net.DatagramSocketClient#open open() },
36		* {@link org.apache.commons.net.DatagramSocketClient#close close() },
37		* {@link #sendFile sendFile() }, and
38		* {@link #receiveFile receiveFile() } methods. Additionally, the
39		* {@link #setMaxTimeouts setMaxTimeouts() } and
40		* {@link org.apache.commons.net.DatagramSocketClient#setDefaultTimeout setDefaultTimeout() }
41		* methods may be of importance for performance
42		* tuning.
43		* <p>
44		* Details regarding the TFTP protocol and the format of TFTP packets can
45		* be found in RFC 783. But the point of these classes is to keep you
46		* from having to worry about the internals.
47		* <p>
48		* <p>
49		* @author Daniel F. Savarese
50		* @see TFTP
51		* @see TFTPPacket
52		* @see TFTPPacketException
53		***/
54
55		public class TFTPClient extends TFTP
56		{
57		/***
58		* The default number of times a receive attempt is allowed to timeout
59		* before ending attempts to retry the receive and failing. The default
60		* is 5 timeouts.
61		***/
62		public static final int DEFAULT_MAX_TIMEOUTS = 5;
63
64		/*** The maximum number of timeouts allowed before failing. ***/
65		private int __maxTimeouts;
66
67		/***
68		* Creates a TFTPClient instance with a default timeout of DEFAULT_TIMEOUT,
69		* maximum timeouts value of DEFAULT_MAX_TIMEOUTS, a null socket,
70		* and buffered operations disabled.
71		***/
72		public TFTPClient()
73	0	{
74	0	__maxTimeouts = DEFAULT_MAX_TIMEOUTS;
75	0	}
76
77		/***
78		* Sets the maximum number of times a receive attempt is allowed to
79		* timeout during a receiveFile() or sendFile() operation before ending
80		* attempts to retry the receive and failing.
81		* The default is DEFAULT_MAX_TIMEOUTS.
82		* <p>
83		* @param numTimeouts The maximum number of timeouts to allow. Values
84		* less than 1 should not be used, but if they are, they are
85		* treated as 1.
86		***/
87		public void setMaxTimeouts(int numTimeouts)
88		{
89	0	if (numTimeouts < 1)
90	0	__maxTimeouts = 1;
91		else
92	0	__maxTimeouts = numTimeouts;
93	0	}
94
95		/***
96		* Returns the maximum number of times a receive attempt is allowed to
97		* timeout before ending attempts to retry the receive and failing.
98		* <p>
99		* @return The maximum number of timeouts allowed.
100		***/
101		public int getMaxTimeouts()
102		{
103	0	return __maxTimeouts;
104		}
105
106
107		/***
108		* Requests a named file from a remote host, writes the
109		* file to an OutputStream, closes the connection, and returns the number
110		* of bytes read. A local UDP socket must first be created by
111		* {@link org.apache.commons.net.DatagramSocketClient#open open()} before
112		* invoking this method. This method will not close the OutputStream
113		* containing the file; you must close it after the method invocation.
114		* <p>
115		* @param filename The name of the file to receive.
116		* @param mode The TFTP mode of the transfer (one of the MODE constants).
117		* @param output The OutputStream to which the file should be written.
118		* @param host The remote host serving the file.
119		* @param port The port number of the remote TFTP server.
120		* @exception IOException If an I/O error occurs. The nature of the
121		* error will be reported in the message.
122		***/
123		public int receiveFile(String filename, class="keyword">int mode, OutputStream output,
124		InetAddress host, int port) throws IOException
125		{
126		int bytesRead, timeouts, lastBlock, block, hostPort, dataLength;
127	0	TFTPPacket sent, received = null;
128		TFTPErrorPacket error;
129		TFTPDataPacket data;
130	0	TFTPAckPacket ack = new TFTPAckPacket(host, port, 0);
131
132	0	beginBufferedOps();
133
134	0	dataLength = lastBlock = hostPort = bytesRead = 0;
135	0	block = 1;
136
137	0	if (mode == TFTP.ASCII_MODE)
138	0	output = new FromNetASCIIOutputStream(output);
139
140	0	sent =
141		new TFTPReadRequestPacket(host, port, filename, mode);
142
143		_sendPacket:
144		do
145		{
146	0	bufferedSend(sent);
147
148		_receivePacket:
149		while (true)
150		{
151	0	timeouts = 0;
152	0	while (timeouts < __maxTimeouts)
153		{
154		try
155		{
156	0	received = bufferedReceive();
157	0	break;
158		}
159	0	catch (SocketException e)
160		{
161	0	if (++timeouts >= __maxTimeouts)
162		{
163	0	endBufferedOps();
164	0	throw new IOException("Connection timed out.");
165		}
166	0	continue;
167		}
168	0	catch (InterruptedIOException e)
169		{
170	0	if (++timeouts >= __maxTimeouts)
171		{
172	0	endBufferedOps();
173	0	throw new IOException("Connection timed out.");
174		}
175	0	continue;
176		}
177	0	catch (TFTPPacketException e)
178		{
179	0	endBufferedOps();
180	0	throw new IOException("Bad packet: " + e.getMessage());
181		}
182		}
183
184		// The first time we receive we get the port number and
185		// answering host address (for hosts with multiple IPs)
186	0	if (lastBlock == 0)
187		{
188	0	hostPort = received.getPort();
189	0	ack.setPort(hostPort);
190	0	if(!host.equals(received.getAddress()))
191		{
192	0	host = received.getAddress();
193	0	ack.setAddress(host);
194	0	sent.setAddress(host);
195		}
196		}
197
198		// Comply with RFC 783 indication that an error acknowledgement
199		// should be sent to originator if unexpected TID or host.
200	0	if (host.equals(received.getAddress()) &&
201		received.getPort() == hostPort)
202		{
203
204	0	switch (received.getType())
205		{
206		case TFTPPacket.ERROR:
207	0	error = (TFTPErrorPacket)received;
208	0	endBufferedOps();
209	0	throw new IOException("Error code " + error.getError() +
210		" received: " + error.getMessage());
211		case TFTPPacket.DATA:
212	0	data = (TFTPDataPacket)received;
213	0	dataLength = data.getDataLength();
214
215	0	lastBlock = data.getBlockNumber();
216
217	0	if (lastBlock == block)
218		{
219		try
220		{
221	0	output.write(data.getData(), data.getDataOffset(),
222		dataLength);
223		}
224	0	catch (IOException e)
225		{
226	0	error = new TFTPErrorPacket(host, hostPort,
227		TFTPErrorPacket.OUT_OF_SPACE,
228		"File write failed.");
229	0	bufferedSend(error);
230	0	endBufferedOps();
231	0	throw e;
232	0	}
233	0	++block;
234	0	break _receivePacket;
235		}
236		else
237		{
238	0	discardPackets();
239
240	0	if (lastBlock == (block - 1))
241	0	continue _sendPacket; // Resend last acknowledgement.
242
243		continue _receivePacket; // Start fetching packets again.
244		}
245		//break;
246
247		default:
248	0	endBufferedOps();
249	0	throw new IOException("Received unexpected packet type.");
250		}
251		}
252		else
253		{
254	0	error = new TFTPErrorPacket(received.getAddress(),
255		received.getPort(),
256		TFTPErrorPacket.UNKNOWN_TID,
257		"Unexpected host or port.");
258	0	bufferedSend(error);
259	0	continue _sendPacket;
260		}
261
262		// We should never get here, but this is a safety to avoid
263		// infinite loop. If only Java had the goto statement.
264		//break;
265		}
266
267	0	ack.setBlockNumber(lastBlock);
268	0	sent = ack;
269	0	bytesRead += dataLength;
270		} // First data packet less than 512 bytes signals end of stream.
271
272	0	while (dataLength == TFTPPacket.SEGMENT_SIZE);
273
274	0	bufferedSend(sent);
275	0	endBufferedOps();
276
277	0	return bytesRead;
278		}
279
280
281		/***
282		* Requests a named file from a remote host, writes the
283		* file to an OutputStream, closes the connection, and returns the number
284		* of bytes read. A local UDP socket must first be created by
285		* {@link org.apache.commons.net.DatagramSocketClient#open open()} before
286		* invoking this method. This method will not close the OutputStream
287		* containing the file; you must close it after the method invocation.
288		* <p>
289		* @param filename The name of the file to receive.
290		* @param mode The TFTP mode of the transfer (one of the MODE constants).
291		* @param output The OutputStream to which the file should be written.
292		* @param hostname The name of the remote host serving the file.
293		* @param port The port number of the remote TFTP server.
294		* @exception IOException If an I/O error occurs. The nature of the
295		* error will be reported in the message.
296		* @exception UnknownHostException If the hostname cannot be resolved.
297		***/
298		public int receiveFile(String filename, class="keyword">int mode, OutputStream output,
299		String hostname, int port)
300		throws UnknownHostException, IOException
301		{
302	0	return receiveFile(filename, mode, output, InetAddress.getByName(hostname),
303		port);
304		}
305
306
307		/***
308		* Same as calling receiveFile(filename, mode, output, host, TFTP.DEFAULT_PORT).
309		*
310		* @param filename The name of the file to receive.
311		* @param mode The TFTP mode of the transfer (one of the MODE constants).
312		* @param output The OutputStream to which the file should be written.
313		* @param host The remote host serving the file.
314		* @exception IOException If an I/O error occurs. The nature of the
315		* error will be reported in the message.
316		***/
317		public int receiveFile(String filename, class="keyword">int mode, OutputStream output,
318		InetAddress host)
319		throws IOException
320		{
321	0	return receiveFile(filename, mode, output, host, DEFAULT_PORT);
322		}
323
324		/***
325		* Same as calling receiveFile(filename, mode, output, hostname, TFTP.DEFAULT_PORT).
326		*
327		* @param filename The name of the file to receive.
328		* @param mode The TFTP mode of the transfer (one of the MODE constants).
329		* @param output The OutputStream to which the file should be written.
330		* @param hostname The name of the remote host serving the file.
331		* @exception IOException If an I/O error occurs. The nature of the
332		* error will be reported in the message.
333		* @exception UnknownHostException If the hostname cannot be resolved.
334		***/
335		public int receiveFile(String filename, class="keyword">int mode, OutputStream output,
336		String hostname)
337		throws UnknownHostException, IOException
338		{
339	0	return receiveFile(filename, mode, output, InetAddress.getByName(hostname),
340		DEFAULT_PORT);
341		}
342
343
344		/***
345		* Requests to send a file to a remote host, reads the file from an
346		* InputStream, sends the file to the remote host, and closes the
347		* connection. A local UDP socket must first be created by
348		* {@link org.apache.commons.net.DatagramSocketClient#open open()} before
349		* invoking this method. This method will not close the InputStream
350		* containing the file; you must close it after the method invocation.
351		* <p>
352		* @param filename The name the remote server should use when creating
353		* the file on its file system.
354		* @param mode The TFTP mode of the transfer (one of the MODE constants).
355		* @param host The remote host receiving the file.
356		* @param port The port number of the remote TFTP server.
357		* @exception IOException If an I/O error occurs. The nature of the
358		* error will be reported in the message.
359		***/
360		public void sendFile(String filename, int mode, InputStream input,
361		InetAddress host, int port) throws IOException
362		{
363		int bytesRead, timeouts, lastBlock, block, hostPort, dataLength, offset;
364	0	TFTPPacket sent, received = null;
365		TFTPErrorPacket error;
366	0	TFTPDataPacket data =
367		new TFTPDataPacket(host, port, 0, _sendBuffer, 4, 0);
368		;
369		TFTPAckPacket ack;
370
371	0	beginBufferedOps();
372
373	0	dataLength = lastBlock = hostPort = bytesRead = 0;
374	0	block = 0;
375	0	boolean lastAckWait = false;
376
377	0	if (mode == TFTP.ASCII_MODE)
378	0	input = new ToNetASCIIInputStream(input);
379
380	0	sent =
381		new TFTPWriteRequestPacket(host, port, filename, mode);
382
383		_sendPacket:
384		do
385		{
386	0	bufferedSend(sent);
387
388		_receivePacket:
389		while (true)
390		{
391	0	timeouts = 0;
392	0	while (timeouts < __maxTimeouts)
393		{
394		try
395		{
396	0	received = bufferedReceive();
397	0	break;
398		}
399	0	catch (SocketException e)
400		{
401	0	if (++timeouts >= __maxTimeouts)
402		{
403	0	endBufferedOps();
404	0	throw new IOException("Connection timed out.");
405		}
406	0	continue;
407		}
408	0	catch (InterruptedIOException e)
409		{
410	0	if (++timeouts >= __maxTimeouts)
411		{
412	0	endBufferedOps();
413	0	throw new IOException("Connection timed out.");
414		}
415	0	continue;
416		}
417	0	catch (TFTPPacketException e)
418		{
419	0	endBufferedOps();
420	0	throw new IOException("Bad packet: " + e.getMessage());
421		}
422		}
423
424		// The first time we receive we get the port number and
425		// answering host address (for hosts with multiple IPs)
426	0	if (lastBlock == 0)
427		{
428	0	hostPort = received.getPort();
429	0	data.setPort(hostPort);
430	0	if(!host.equals(received.getAddress()))
431		{
432	0	host = received.getAddress();
433	0	data.setAddress(host);
434	0	sent.setAddress(host);
435		}
436		}
437
438		// Comply with RFC 783 indication that an error acknowledgement
439		// should be sent to originator if unexpected TID or host.
440	0	if (host.equals(received.getAddress()) &&
441		received.getPort() == hostPort)
442		{
443
444	0	switch (received.getType())
445		{
446		case TFTPPacket.ERROR:
447	0	error = (TFTPErrorPacket)received;
448	0	endBufferedOps();
449	0	throw new IOException("Error code " + error.getError() +
450		" received: " + error.getMessage());
451		case TFTPPacket.ACKNOWLEDGEMENT:
452	0	ack = (TFTPAckPacket)received;
453
454	0	lastBlock = ack.getBlockNumber();
455
456	0	if (lastBlock == block)
457		{
458	0	++block;
459	0	if (lastAckWait)
460	0	break _sendPacket;
461		else
462		break _receivePacket;
463		}
464		else
465		{
466	0	discardPackets();
467
468	0	if (lastBlock == (block - 1))
469	0	continue _sendPacket; // Resend last acknowledgement.
470
471		continue _receivePacket; // Start fetching packets again.
472		}
473		//break;
474
475		default:
476	0	endBufferedOps();
477	0	throw new IOException("Received unexpected packet type.");
478		}
479		}
480		else
481		{
482	0	error = new TFTPErrorPacket(received.getAddress(),
483		received.getPort(),
484		TFTPErrorPacket.UNKNOWN_TID,
485		"Unexpected host or port.");
486	0	bufferedSend(error);
487	0	continue _sendPacket;
488		}
489
490		// We should never get here, but this is a safety to avoid
491		// infinite loop. If only Java had the goto statement.
492		//break;
493		}
494
495	0	dataLength = TFTPPacket.SEGMENT_SIZE;
496	0	offset = 4;
497		while (dataLength > 0 &&
498	0	(bytesRead = input.read(_sendBuffer, offset, dataLength)) > 0)
499		{
500	0	offset += bytesRead;
501	0	dataLength -= bytesRead;
502		}
503
504	0	data.setBlockNumber(block);
505	0	data.setData(_sendBuffer, 4, offset - 4);
506	0	sent = data;
507		}
508	0	while (dataLength == 0 || lastAckWait);
509
510	0	endBufferedOps();
511	0	}
512
513
514		/***
515		* Requests to send a file to a remote host, reads the file from an
516		* InputStream, sends the file to the remote host, and closes the
517		* connection. A local UDP socket must first be created by
518		* {@link org.apache.commons.net.DatagramSocketClient#open open()} before
519		* invoking this method. This method will not close the InputStream
520		* containing the file; you must close it after the method invocation.
521		* <p>
522		* @param filename The name the remote server should use when creating
523		* the file on its file system.
524		* @param mode The TFTP mode of the transfer (one of the MODE constants).
525		* @param hostname The name of the remote host receiving the file.
526		* @param port The port number of the remote TFTP server.
527		* @exception IOException If an I/O error occurs. The nature of the
528		* error will be reported in the message.
529		* @exception UnknownHostException If the hostname cannot be resolved.
530		***/
531		public void sendFile(String filename, int mode, InputStream input,
532		String hostname, int port)
533		throws UnknownHostException, IOException
534		{
535	0	sendFile(filename, mode, input, InetAddress.getByName(hostname), port);
536	0	}
537
538
539		/***
540		* Same as calling sendFile(filename, mode, input, host, TFTP.DEFAULT_PORT).
541		*
542		* @param filename The name the remote server should use when creating
543		* the file on its file system.
544		* @param mode The TFTP mode of the transfer (one of the MODE constants).
545		* @param host The name of the remote host receiving the file.
546		* @exception IOException If an I/O error occurs. The nature of the
547		* error will be reported in the message.
548		* @exception UnknownHostException If the hostname cannot be resolved.
549		***/
550		public void sendFile(String filename, int mode, InputStream input,
551		InetAddress host)
552		throws IOException
553		{
554	0	sendFile(filename, mode, input, host, DEFAULT_PORT);
555	0	}
556
557		/***
558		* Same as calling sendFile(filename, mode, input, hostname, TFTP.DEFAULT_PORT).
559		*
560		* @param filename The name the remote server should use when creating
561		* the file on its file system.
562		* @param mode The TFTP mode of the transfer (one of the MODE constants).
563		* @param hostname The name of the remote host receiving the file.
564		* @exception IOException If an I/O error occurs. The nature of the
565		* error will be reported in the message.
566		* @exception UnknownHostException If the hostname cannot be resolved.
567		***/
568		public void sendFile(String filename, int mode, InputStream input,
569		String hostname)
570		throws UnknownHostException, IOException
571		{
572	0	sendFile(filename, mode, input, InetAddress.getByName(hostname),
573		DEFAULT_PORT);
574	0	}
575		}

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