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