Mercurial > projects > ldc

comparison tango/tango/net/ftp/FtpClient.d @ 132:1700239cab2e trunk

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
[svn r136] MAJOR UNSTABLE UPDATE!!! Initial commit after moving to Tango instead of Phobos. Lots of bugfixes... This build is not suitable for most things.
author lindquist
date Fri, 11 Jan 2008 17:57:40 +0100
parents
children
comparison
equal deleted inserted replaced
131:5825d48b27d1 132:1700239cab2e
1 /*******************************************************************************
2
3 copyright: Copyright (c) 2006 UWB. All rights reserved
4
5 license: BSD style: $(LICENSE)
6
7 version: Initial release: June 2006
8
9 author: UWB
10
11 *******************************************************************************/
12
13 module tango.net.ftp.FtpClient;
14
15 private import tango.net.Socket;
16
17 private import tango.net.ftp.Telnet;
18
19 private import tango.time.Clock;
20
21 private import tango.io.Conduit,
22 tango.io.GrowBuffer,
23 tango.io.FileConduit;
24
25 private import tango.time.chrono.Gregorian;
26
27 private import Text = tango.text.Util;
28
29 private import Ascii = tango.text.Ascii;
30
31 private import Regex = tango.text.Regex;
32
33 private import Integer = tango.text.convert.Integer;
34
35 private import Timestamp = tango.text.convert.TimeStamp;
36
37
38 /// An FTP progress delegate.
39 ///
40 /// You may need to add the restart position to this, and use SIZE to determine
41 /// percentage completion. This only represents the number of bytes
42 /// transferred.
43 ///
44 /// Params:
45 /// pos = the current offset into the stream
46 alias void delegate(in size_t pos) FtpProgress;
47
48 /// The format of data transfer.
49 enum FtpFormat
50 {
51 /// Indicates ASCII NON PRINT format (line ending conversion to CRLF.)
52 ascii,
53 /// Indicates IMAGE format (8 bit binary octets.)
54 image,
55 }
56
57 /// A server response, consisting of a code and a potentially multi-line message.
58 struct FtpResponse
59 {
60 /// The response code.
61 ///
62 /// The digits in the response code can be used to determine status
63 /// programatically.
64 ///
65 /// First Digit (status):
66 /// 1xx = a positive, but preliminary, reply
67 /// 2xx = a positive reply indicating completion
68 /// 3xx = a positive reply indicating incomplete status
69 /// 4xx = a temporary negative reply
70 /// 5xx = a permanent negative reply
71 ///
72 /// Second Digit (subject):
73 /// x0x = condition based on syntax
74 /// x1x = informational
75 /// x2x = connection
76 /// x3x = authentication/process
77 /// x5x = file system
78 char[3] code = "000";
79
80 /// The message from the server.
81 ///
82 /// With some responses, the message may contain parseable information.
83 /// For example, this is true of the 257 response.
84 char[] message = null;
85 }
86
87 /// Active or passive connection mode.
88 enum FtpConnectionType
89 {
90 /// Active - server connects to client on open port.
91 active,
92 /// Passive - server listens for a connection from the client.
93 passive,
94 }
95
96 /// Detail about the data connection.
97 ///
98 /// This is used to properly send PORT and PASV commands.
99 struct FtpConnectionDetail
100 {
101 /// The type to be used.
102 FtpConnectionType type = FtpConnectionType.passive;
103
104 /// The address to give the server.
105 Address address = null;
106
107 /// The address to actually listen on.
108 Address listen = null;
109 }
110
111 /// A supported feature of an FTP server.
112 struct FtpFeature
113 {
114 /// The command which is supported, e.g. SIZE.
115 char[] command = null;
116 /// Parameters for this command; e.g. facts for MLST.
117 char[] params = null;
118 }
119
120 /// The type of a file in an FTP listing.
121 enum FtpFileType
122 {
123 /// An unknown file or type (no type fact.)
124 unknown,
125 /// A regular file, or similar.
126 file,
127 /// The current directory (e.g. ., but not necessarily.)
128 cdir,
129 /// A parent directory (usually "..".)
130 pdir,
131 /// Any other type of directory.
132 dir,
133 /// Another type of file. Consult the "type" fact.
134 other,
135 }
136
137 /// Information about a file in an FTP listing.
138 struct FtpFileInfo
139 {
140 /// The filename.
141 char[] name = null;
142 /// Its type.
143 FtpFileType type = FtpFileType.unknown;
144 /// Size in bytes (8 bit octets), or -1 if not available.
145 long size = -1;
146 /// Modification time, if available.
147 Time modify = Time.max;
148 /// Creation time, if available (not often.)
149 Time create = Time.max;
150 /// The file's mime type, if known.
151 char[] mime = null;
152 /// An associative array of all facts returned by the server, lowercased.
153 char[][char[]] facts;
154 }
155
156 /// A connection to an FTP server.
157 ///
158 /// Example:
159 /// ----------
160 /// auto ftp = new FTPConnection("hostname", "user", "pass",21);
161 ///
162 /// ftp.mkdir("test");
163 /// ftp.close();
164 /// ----------
165 ///
166 /// Standards: RFC 959, RFC 2228, RFC 2389, RFC 2428
167 ///
168 /// Bugs:
169 /// Does not support several uncommon FTP commands and responses.
170
171
172 class FTPConnection : Telnet
173 {
174 /// Supported features (if known.)
175 ///
176 /// This will be empty if not known, or else contain at least FEAT.
177 public FtpFeature[] supported_features = null;
178
179 /// Data connection information.
180 protected FtpConnectionDetail data_info;
181
182 /// The last-set restart position.
183 ///
184 /// This is only used when a local file is used for a RETR or STOR.
185 protected size_t restart_pos = 0;
186
187 /// error handler
188 protected void exception (char[] msg)
189 {
190 throw new FTPException ("Exception: " ~ msg);
191 }
192
193 /// ditto
194 protected void exception (FtpResponse r)
195 {
196 throw new FTPException (r);
197 }
198
199 /// Construct an FTPConnection without connecting immediately.
200 public this()
201 {
202 }
203
204 /// Connect to an FTP server with a username and password.
205 ///
206 /// Params:
207 /// hostname = the hostname or IP address to connect to
208 /// port = the port number to connect to
209 /// username = username to be sent
210 /// password = password to be sent, if requested
211 public this(char[] hostname, char[] username, char[] password, int port = 21)
212 {
213 this.connect(hostname, username, password,port);
214 }
215
216 /// Connect to an FTP server with a username and password.
217 ///
218 /// Params:
219 /// hostname = the hostname or IP address to connect to
220 /// port = the port number to connect to
221 /// username = username to be sent
222 /// password = password to be sent, if requested
223 public void connect(char[] hostname, char[] username, char[] password, int port = 21)
224 in
225 {
226 // We definitely need a hostname and port.
227 assert (hostname.length > 0);
228 assert (port > 0);
229 }
230 body
231 {
232 // Close any active connection.
233
234 if (this.socket !is null)
235 this.close();
236
237
238 // Connect to whichever FTP server responds first.
239 this.findAvailableServer(hostname, port);
240
241 this.socket.blocking = false;
242
243 scope (failure)
244 {
245 this.close();
246 }
247
248 // The welcome message should always be a 220. 120 and 421 are considered errors.
249 this.readResponse("220");
250
251 if (username.length == 0)
252 return;
253
254 // Send the username. Anything but 230, 331, or 332 is basically an error.
255 this.sendCommand("USER", username);
256 auto response = this.readResponse();
257
258 // 331 means username okay, please proceed with password.
259 if (response.code == "331")
260 {
261 this.sendCommand("PASS", password);
262 response = this.readResponse();
263 }
264
265 // We don't support ACCT (332) so we should get a 230 here.
266 if (response.code != "230" && response.code != "202")
267 {
268
269 exception (response);
270 }
271
272 }
273
274 /// Close the connection to the server.
275 public void close()
276 {
277 assert (this.socket !is null);
278
279 // Don't even try to close it if it's not open.
280 if (this.socket !is null)
281 {
282 try
283 {
284 this.sendCommand("QUIT");
285 this.readResponse("221");
286 }
287 // Ignore if the above could not be completed.
288 catch (FTPException)
289 {
290 }
291
292 // Shutdown the socket...
293 this.socket.shutdown(SocketShutdown.BOTH);
294 this.socket.detach();
295
296 // Clear out everything.
297 delete this.supported_features;
298 delete this.socket;
299 }
300 }
301
302 /// Set the connection to use passive mode for data tranfers.
303 ///
304 /// This is the default.
305 public void setPassive()
306 {
307 this.data_info.type = FtpConnectionType.passive;
308
309 delete this.data_info.address;
310 delete this.data_info.listen;
311 }
312
313 /// Set the connection to use active mode for data transfers.
314 ///
315 /// This may not work behind firewalls.
316 ///
317 /// Params:
318 /// ip = the ip address to use
319 /// port = the port to use
320 /// listen_ip = the ip to listen on, or null for any
321 /// listen_port = the port to listen on, or 0 for the same port
322 public void setActive(char[] ip, ushort port, char[] listen_ip = null, ushort listen_port = 0)
323 in
324 {
325 assert (ip.length > 0);
326 assert (port > 0);
327 }
328 body
329 {
330 this.data_info.type = FtpConnectionType.active;
331 this.data_info.address = new IPv4Address(ip, port);
332
333 // A local-side port?
334 if (listen_port == 0)
335 listen_port = port;
336
337 // Any specific IP to listen on?
338 if (listen_ip == null)
339 this.data_info.listen = new IPv4Address(IPv4Address.ADDR_ANY, listen_port);
340 else
341 this.data_info.listen = new IPv4Address(listen_ip, listen_port);
342 }
343
344
345 /// Change to the specified directory.
346 public void cd(char[] dir)
347 in
348 {
349 assert (dir.length > 0);
350 }
351 body
352 {
353 this.sendCommand("CWD", dir);
354 this.readResponse("250");
355 }
356
357 /// Change to the parent of this directory.
358 public void cdup()
359 {
360 this.sendCommand("CDUP");
361 this.readResponse("200");
362 }
363
364 /// Determine the current directory.
365 ///
366 /// Returns: the current working directory
367 public char[] cwd()
368 {
369 this.sendCommand("PWD");
370 auto response = this.readResponse("257");
371
372 return this.parse257(response);
373 }
374
375 /// Change the permissions of a file.
376 ///
377 /// This is a popular feature of most FTP servers, but not explicitly outlined
378 /// in the spec. It does not work on, for example, Windows servers.
379 ///
380 /// Params:
381 /// path = the path to the file to chmod
382 /// mode = the desired mode; expected in octal (0777, 0644, etc.)
383 public void chmod(char[] path, int mode)
384 in
385 {
386 assert (path.length > 0);
387 assert (mode >= 0 && (mode >> 16) == 0);
388 }
389 body
390 {
391 char[] tmp = "000";
392 // Convert our octal parameter to a string.
393 Integer.format(tmp, cast(long) mode, Integer.Style.Octal);
394 this.sendCommand("SITE CHMOD", tmp, path);
395 this.readResponse("200");
396 }
397
398 /// Remove a file or directory.
399 ///
400 /// Params:
401 /// path = the path to the file or directory to delete
402 public void del(char[] path)
403 in
404 {
405 assert (path.length > 0);
406 }
407 body
408 {
409 this.sendCommand("DELE", path);
410 auto response = this.readResponse();
411
412 // Try it as a directory, then...?
413 if (response.code != "250")
414 this.rm(path);
415 }
416
417 /// Remove a directory.
418 ///
419 /// Params:
420 /// path = the directory to delete
421 public void rm(char[] path)
422 in
423 {
424 assert (path.length > 0);
425 }
426 body
427 {
428 this.sendCommand("RMD", path);
429 this.readResponse("250");
430 }
431
432 /// Rename/move a file or directory.
433 ///
434 /// Params:
435 /// old_path = the current path to the file
436 /// new_path = the new desired path
437 public void rename(char[] old_path, char[] new_path)
438 in
439 {
440 assert (old_path.length > 0);
441 assert (new_path.length > 0);
442 }
443 body
444 {
445 // Rename from... rename to. Pretty simple.
446 this.sendCommand("RNFR", old_path);
447 this.readResponse("350");
448
449 this.sendCommand("RNTO", new_path);
450 this.readResponse("250");
451 }
452
453 /// Determine the size in bytes of a file.
454 ///
455 /// This size is dependent on the current type (ASCII or IMAGE.)
456 ///
457 /// Params:
458 /// path = the file to retrieve the size of
459 /// format = what format the size is desired in
460 public size_t size(char[] path, FtpFormat format = FtpFormat.image)
461 in
462 {
463 assert (path.length > 0);
464 }
465 body
466 {
467 this.type(format);
468
469 this.sendCommand("SIZE", path);
470 auto response = this.readResponse("213");
471
472 // Only try to parse the numeric bytes of the response.
473 size_t end_pos = 0;
474 while (end_pos < response.message.length)
475 {
476 if (response.message[end_pos] < '0' || response.message[end_pos] > '9')
477 break;
478 end_pos++;
479 }
480
481 return toInt(response.message[0 .. end_pos]);
482 }
483
484 /// Send a command and process the data socket.
485 ///
486 /// This opens the data connection and checks for the appropriate response.
487 ///
488 /// Params:
489 /// command = the command to send (e.g. STOR)
490 /// parameters = any arguments to send
491 ///
492 /// Returns: the data socket
493 public Socket processDataCommand(char[] command, char[][] parameters ...)
494 {
495 // Create a connection.
496 Socket data = this.getDataSocket();
497 scope (failure)
498 {
499 // Close the socket, whether we were listening or not.
500 data.shutdown(SocketShutdown.BOTH);
501 data.detach();
502 }
503
504 // Tell the server about it.
505 this.sendCommand(command, parameters);
506
507 // We should always get a 150/125 response.
508 auto response = this.readResponse();
509 if (response.code != "150" && response.code != "125")
510 exception (response);
511
512 // We might need to do this for active connections.
513 this.prepareDataSocket(data);
514
515 return data;
516 }
517
518 /// Clean up after the data socket and process the response.
519 ///
520 /// This closes the socket and reads the 226 response.
521 ///
522 /// Params:
523 /// data = the data socket
524 public void finishDataCommand(Socket data)
525 {
526 // Close the socket. This tells the server we're done (EOF.)
527 data.shutdown(SocketShutdown.BOTH);
528 data.detach();
529
530 // We shouldn't get a 250 in STREAM mode.
531 this.readResponse("226");
532 }
533
534 /// Get a data socket from the server.
535 ///
536 /// This sends PASV/PORT as necessary.
537 ///
538 /// Returns: the data socket or a listener
539 protected Socket getDataSocket()
540 {
541 // What type are we using?
542 switch (this.data_info.type)
543 {
544 default:
545 exception ("unknown connection type");
546
547 // Passive is complicated. Handle it in another member.
548 case FtpConnectionType.passive:
549 return this.connectPassive();
550
551 // Active is simpler, but not as fool-proof.
552 case FtpConnectionType.active:
553 IPv4Address data_addr = cast(IPv4Address) this.data_info.address;
554
555 // Start listening.
556 Socket listener = new Socket(AddressFamily.INET, SocketType.STREAM, ProtocolType.TCP);
557 listener.bind(this.data_info.listen);
558 listener.listen(32);
559
560 // Use EPRT if we know it's supported.
561 if (this.is_supported("EPRT"))
562 {
563 char[64] tmp = void;
564
565 this.sendCommand("EPRT", Text.layout(tmp, "|1|%0|%1|", data_addr.toAddrString, data_addr.toPortString));
566 // this.sendCommand("EPRT", format("|1|%s|%s|", data_addr.toAddrString(), data_addr.toPortString()));
567 this.readResponse("200");
568 }
569 else
570 {
571 int h1, h2, h3, h4, p1, p2;
572 h1 = (data_addr.addr() >> 24) % 256;
573 h2 = (data_addr.addr() >> 16) % 256;
574 h3 = (data_addr.addr() >> 8_) % 256;
575 h4 = (data_addr.addr() >> 0_) % 256;
576 p1 = (data_addr.port() >> 8_) % 256;
577 p2 = (data_addr.port() >> 0_) % 256;
578
579 // low overhead method to format a numerical string
580 char[64] tmp = void;
581 char[20] foo = void;
582 auto str = Text.layout (tmp, "%0,%1,%2,%3,%4,%5",
583 Integer.format(foo[0..3], h1),
584 Integer.format(foo[3..6], h2),
585 Integer.format(foo[6..9], h3),
586 Integer.format(foo[9..12], h4),
587 Integer.format(foo[12..15], p1),
588 Integer.format(foo[15..18], p2));
589
590 // This formatting is weird.
591 // this.sendCommand("PORT", format("%d,%d,%d,%d,%d,%d", h1, h2, h3, h4, p1, p2));
592
593 this.sendCommand("PORT", str);
594 this.readResponse("200");
595 }
596
597 return listener;
598 }
599 assert (false);
600 }
601
602 /// Prepare a data socket for use.
603 ///
604 /// This modifies the socket in some cases.
605 ///
606 /// Params:
607 /// data = the data listener socket
608 protected void prepareDataSocket(inout Socket data)
609 {
610 switch (this.data_info.type)
611 {
612 default:
613 exception ("unknown connection type");
614
615 case FtpConnectionType.active:
616 Socket new_data = null;
617
618 SocketSet set = new SocketSet();
619 scope (exit)
620 delete set;
621
622 // At end_time, we bail.
623 Time end_time = Clock.now + this.timeout;
624
625 while (Clock.now < end_time)
626 {
627 set.reset();
628 set.add(data);
629
630 // Can we accept yet?
631 int code = Socket.select(set, null, null, this.timeout);
632 if (code == -1 || code == 0)
633 break;
634
635 new_data = data.accept();
636 break;
637 }
638
639 if (new_data is null)
640 throw new FTPException("CLIENT: No connection from server", "420");
641
642 // We don't need the listener anymore.
643 data.shutdown(SocketShutdown.BOTH);
644 data.detach();
645
646 // This is the actual socket.
647 data = new_data;
648 break;
649
650 case FtpConnectionType.passive:
651 break;
652 }
653 }
654
655 /// Send a PASV and initiate a connection.
656 ///
657 /// Returns: a connected socket
658 public Socket connectPassive()
659 {
660 Address connect_to = null;
661
662 // SPSV, which is just a port number.
663 if (this.is_supported("SPSV"))
664 {
665 this.sendCommand("SPSV");
666 auto response = this.readResponse("227");
667
668 // Connecting to the same host.
669 IPv4Address remote = cast(IPv4Address) this.socket.remoteAddress();
670 assert (remote !is null);
671
672 uint address = remote.addr();
673 uint port = toInt(response.message);
674
675 connect_to = new IPv4Address(address, cast(ushort) port);
676 }
677 // Extended passive mode (IP v6, etc.)
678 else if (this.is_supported("EPSV"))
679 {
680 this.sendCommand("EPSV");
681 auto response = this.readResponse("229");
682
683 // Try to pull out the (possibly not parenthesized) address.
684 auto r = Regex.search(response.message, `\([^0-9][^0-9][^0-9](\d+)[^0-9]\)`);
685 if (r is null)
686 throw new FTPException("CLIENT: Unable to parse address", "501");
687
688 IPv4Address remote = cast(IPv4Address) this.socket.remoteAddress();
689 assert (remote !is null);
690
691 uint address = remote.addr();
692 uint port = toInt(r.match(1));
693
694 connect_to = new IPv4Address(address, cast(ushort) port);
695 }
696 else
697 {
698 this.sendCommand("PASV");
699 auto response = this.readResponse("227");
700
701 // Try to pull out the (possibly not parenthesized) address.
702 auto r = Regex.search(response.message, `(\d+),\s*(\d+),\s*(\d+),\s*(\d+),\s*(\d+)(,\s*(\d+))?`);
703 if (r is null)
704 throw new FTPException("CLIENT: Unable to parse address", "501");
705
706 // Now put it into something std.socket will understand.
707 char[] address = r.match(1)~"."~r.match(2)~"."~r.match(3)~"."~r.match(4);
708 uint port = (toInt(r.match(5)) << 8) + (r.match(7).length > 0 ? toInt(r.match(7)) : 0);
709
710 // Okay, we've got it!
711 connect_to = new IPv4Address(address, port);
712 }
713
714 scope (exit)
715 delete connect_to;
716
717 // This will throw an exception if it cannot connect.
718 auto sock = new Socket(AddressFamily.INET, SocketType.STREAM, ProtocolType.TCP);
719 sock.connect (connect_to);
720 return sock;
721 }
722
723 /// Change the type of data transfer.
724 ///
725 /// ASCII mode implies that line ending conversion should be made.
726 /// Only NON PRINT is supported.
727 ///
728 /// Params:
729 /// type = FtpFormat.ascii or FtpFormat.image
730 public void type(FtpFormat format)
731 {
732 if (format == FtpFormat.ascii)
733 this.sendCommand("TYPE", "A");
734 else
735 this.sendCommand("TYPE", "I");
736
737 this.readResponse("200");
738 }
739
740 /// Store a local file on the server.
741 ///
742 /// Calling this function will change the current data transfer format.
743 ///
744 /// Params:
745 /// path = the path to the remote file
746 /// local_file = the path to the local file
747 /// progress = a delegate to call with progress information
748 /// format = what format to send the data in
749
750 public void put(char[] path, char[] local_file, FtpProgress progress = null, FtpFormat format = FtpFormat.image)
751 in
752 {
753 assert (path.length > 0);
754 assert (local_file.length > 0);
755 }
756 body
757 {
758 // Open the file for reading...
759 auto file = new FileConduit(local_file);
760 scope (exit)
761 {
762 file.detach();
763 delete file;
764 }
765
766 // Seek to the correct place, if specified.
767 if (this.restart_pos > 0)
768 {
769 file.seek(this.restart_pos);
770 this.restart_pos = 0;
771 }
772 else
773 {
774 // Allocate space for the file, if we need to.
775 this.allocate(file.length);
776 }
777
778 // Now that it's open, we do what we always do.
779 this.put(path, file, progress, format);
780 }
781
782 /// Store data from a stream on the server.
783 ///
784 /// Calling this function will change the current data transfer format.
785 ///
786 /// Params:
787 /// path = the path to the remote file
788 /// stream = data to store, or null for a blank file
789 /// progress = a delegate to call with progress information
790 /// format = what format to send the data in
791 public void put(char[] path, InputStream stream = null, FtpProgress progress = null, FtpFormat format = FtpFormat.image)
792 in
793 {
794 assert (path.length > 0);
795 }
796 body
797 {
798 // Change to the specified format.
799 this.type(format);
800
801 // Okay server, we want to store something...
802 Socket data = this.processDataCommand("STOR", path);
803
804 // Send the stream over the socket!
805 if (stream !is null)
806 this.sendStream(data, stream, progress);
807
808 this.finishDataCommand(data);
809 }
810
811 /// Append data to a file on the server.
812 ///
813 /// Calling this function will change the current data transfer format.
814 ///
815 /// Params:
816 /// path = the path to the remote file
817 /// stream = data to append to the file
818 /// progress = a delegate to call with progress information
819 /// format = what format to send the data in
820 public void append(char[] path, InputStream stream, FtpProgress progress = null, FtpFormat format = FtpFormat.image)
821 in
822 {
823 assert (path.length > 0);
824 assert (stream !is null);
825 }
826 body
827 {
828 // Change to the specified format.
829 this.type(format);
830
831 // Okay server, we want to store something...
832 Socket data = this.processDataCommand("APPE", path);
833
834 // Send the stream over the socket!
835 this.sendStream(data, stream, progress);
836
837 this.finishDataCommand(data);
838 }
839
840 /// Seek to a byte offset for the next transfer.
841 ///
842 /// Params:
843 /// offset = the number of bytes to seek forward
844 public void restartSeek(size_t offset)
845 {
846 char[16] tmp;
847 this.sendCommand("REST", Integer.format (tmp, cast(long) offset));
848 this.readResponse("350");
849
850 // Set this for later use.
851 this.restart_pos = offset;
852 }
853
854 /// Allocate space for a file.
855 ///
856 /// After calling this, append() or put() should be the next command.
857 ///
858 /// Params:
859 /// bytes = the number of bytes to allocate
860 public void allocate(long bytes)
861 in
862 {
863 assert (bytes > 0);
864 }
865 body
866 {
867 char[16] tmp;
868 this.sendCommand("ALLO", Integer.format(tmp, bytes));
869 auto response = this.readResponse();
870
871 // For our purposes 200 and 202 are both fine.
872 if (response.code != "200" && response.code != "202")
873 exception (response);
874 }
875
876 /// Retrieve a remote file's contents into a local file.
877 ///
878 /// Calling this function will change the current data transfer format.
879 ///
880 /// Params:
881 /// path = the path to the remote file
882 /// local_file = the path to the local file
883 /// progress = a delegate to call with progress information
884 /// format = what format to read the data in
885 public void get(char[] path, char[] local_file, FtpProgress progress = null, FtpFormat format = FtpFormat.image)
886 in
887 {
888 assert (path.length > 0);
889 assert (local_file.length > 0);
890 }
891 body
892 {
893 FileConduit file = null;
894
895 // We may either create a new file...
896 if (this.restart_pos == 0)
897 file = new FileConduit (local_file, FileConduit.ReadWriteCreate);
898 // Or open an existing file, and seek to the specified position (read: not end, necessarily.)
899 else
900 {
901 file = new FileConduit (local_file, FileConduit.ReadWriteExisting);
902 file.seek(this.restart_pos);
903
904 this.restart_pos = 0;
905 }
906
907 scope (exit)
908 {
909 file.detach();
910 delete file;
911 }
912
913 // Now that it's open, we do what we always do.
914 this.get(path, file, progress, format);
915 }
916
917 /// Retrieve a remote file's contents into a local file.
918 ///
919 /// Calling this function will change the current data transfer format.
920 ///
921 /// Params:
922 /// path = the path to the remote file
923 /// stream = stream to write the data to
924 /// progress = a delegate to call with progress information
925 /// format = what format to read the data in
926 public void get(char[] path, OutputStream stream, FtpProgress progress = null, FtpFormat format = FtpFormat.image)
927 in
928 {
929 assert (path.length > 0);
930 assert (stream !is null);
931 }
932 body
933 {
934 // Change to the specified format.
935 this.type(format);
936
937 // Okay server, we want to get this file...
938 Socket data = this.processDataCommand("RETR", path);
939
940 // Read the stream in from the socket!
941 this.readStream(data, stream, progress);
942
943 this.finishDataCommand(data);
944 }
945
946 /// Get information about a single file.
947 ///
948 /// Return an FtpFileInfo struct about the specified path.
949 /// This may not work consistently on directories (but should.)
950 ///
951 /// Params:
952 /// path = the file or directory to get information about
953 ///
954 /// Returns: the file information
955 public FtpFileInfo getFileInfo(char[] path)
956 in
957 {
958 assert (path.length > 0);
959 }
960 body
961 {
962 // Start assuming the MLST didn't work.
963 bool mlst_success = false;
964 FtpResponse response;
965
966 // Check if MLST might be supported...
967 if (this.isSupported("MLST"))
968 {
969 this.sendCommand("MLST", path);
970 response = this.readResponse();
971
972 // If we know it was supported for sure, this is an error.
973 if (this.is_supported("MLST"))
974 exception (response);
975 // Otherwise, it probably means we need to try a LIST.
976 else
977 mlst_success = response.code == "250";
978 }
979
980 // Okay, we got the MLST response... parse it.
981 if (mlst_success)
982 {
983 char[][] lines = Text.splitLines (response.message);
984
985 // We need at least 3 lines - first and last and header/footer lines.
986 // Note that more than 3 could be returned; e.g. multiple lines about the one file.
987 if (lines.length <= 2)
988 throw new FTPException("CLIENT: Bad MLST response from server", "501");
989
990 // Return the first line's information.
991 return parseMlstLine(lines[1]);
992 }
993 else
994 {
995 // Send a list command. This may list the contents of a directory, even.
996 FtpFileInfo[] temp = this.sendListCommand(path);
997
998 // If there wasn't at least one line, the file didn't exist?
999 // We should have already handled that.
1000 if (temp.length < 1)
1001 throw new FTPException("CLIENT: Bad LIST response from server", "501");
1002
1003 // If there are multiple lines, try to return the correct one.
1004 if (temp.length != 1)
1005 foreach (FtpFileInfo info; temp)
1006 {
1007 if (info.type == FtpFileType.cdir)
1008 return info;
1009 }
1010
1011 // Okay then, the first line. Best we can do?
1012 return temp[0];
1013 }
1014 }
1015
1016 /// Get a listing of a directory's contents.
1017 ///
1018 /// Don't end path in a /. Blank means the current directory.
1019 ///
1020 /// Params:
1021 /// path = the directory to list
1022 ///
1023 /// Returns: an array of the contents
1024 public FtpFileInfo[] ls(char[] path = "") // default to current dir
1025 in
1026 {
1027 assert (path.length == 0 || path[path.length - 1] != '/');
1028 }
1029 body
1030 {
1031 FtpFileInfo[] dir;
1032
1033 // We'll try MLSD (which is so much better) first... but it may fail.
1034 bool mlsd_success = false;
1035 Socket data = null;
1036
1037 // Try it if it could/might/maybe is supported.
1038 if (this.isSupported("MLST"))
1039 {
1040 mlsd_success = true;
1041
1042 // Since this is a data command, processDataCommand handles
1043 // checking the response... just catch its Exception.
1044 try
1045 {
1046 if (path.length > 0)
1047 data = this.processDataCommand("MLSD", path);
1048 else
1049 data = this.processDataCommand("MLSD");
1050 }
1051 catch (FTPException)
1052 mlsd_success = false;
1053 }
1054
1055 // If it passed, parse away!
1056 if (mlsd_success)
1057 {
1058 auto listing = new GrowBuffer;
1059 this.readStream(data, listing);
1060 this.finishDataCommand(data);
1061
1062 // Each line is something in that directory.
1063 char[][] lines = Text.splitLines (cast(char[]) listing.slice());
1064 scope (exit)
1065 delete lines;
1066
1067 foreach (char[] line; lines)
1068 {
1069 // Parse each line exactly like MLST does.
1070 FtpFileInfo info = this.parseMlstLine(line);
1071 if (info.name.length > 0)
1072 dir ~= info;
1073 }
1074
1075 return dir;
1076 }
1077 // Fall back to LIST.
1078 else
1079 return this.sendListCommand(path);
1080 }
1081
1082 /// Send a LIST command to determine a directory's content.
1083 ///
1084 /// The format of a LIST response is not guaranteed. If available,
1085 /// MLSD should be used instead.
1086 ///
1087 /// Params:
1088 /// path = the file or directory to list
1089 ///
1090 /// Returns: an array of the contents
1091 protected FtpFileInfo[] sendListCommand(char[] path)
1092 {
1093 FtpFileInfo[] dir;
1094 Socket data = null;
1095
1096 if (path.length > 0)
1097 data = this.processDataCommand("LIST", path);
1098 else
1099 data = this.processDataCommand("LIST");
1100
1101 // Read in the stupid non-standardized response.
1102 auto listing = new GrowBuffer;
1103 this.readStream(data, listing);
1104 this.finishDataCommand(data);
1105
1106 // Split out the lines. Most of the time, it's one-to-one.
1107 char[][] lines = Text.splitLines (cast(char[]) listing.slice());
1108 scope (exit)
1109 delete lines;
1110
1111 foreach (char[] line; lines)
1112 {
1113 // If there are no spaces, or if there's only one... skip the line.
1114 // This is probably like a "total 8" line.
1115 if (Text.locate(line, ' ') == Text.locatePrior(line, ' '))
1116 continue;
1117
1118 // Now parse the line, or try to.
1119 FtpFileInfo info = this.parseListLine(line);
1120 if (info.name.length > 0)
1121 dir ~= info;
1122 }
1123
1124 return dir;
1125 }
1126
1127 /// Parse a LIST response line.
1128 ///
1129 /// The format here isn't even specified, so we have to try to detect
1130 /// commmon ones.
1131 ///
1132 /// Params:
1133 /// line = the line to parse
1134 ///
1135 /// Returns: information about the file
1136 protected FtpFileInfo parseListLine(char[] line)
1137 {
1138 FtpFileInfo info;
1139 size_t pos = 0;
1140
1141 // Convenience function to parse a word from the line.
1142 char[] parse_word()
1143 {
1144 size_t start = 0, end = 0;
1145
1146 // Skip whitespace before.
1147 while (pos < line.length && line[pos] == ' ')
1148 pos++;
1149
1150 start = pos;
1151 while (pos < line.length && line[pos] != ' ')
1152 pos++;
1153 end = pos;
1154
1155 // Skip whitespace after.
1156 while (pos < line.length && line[pos] == ' ')
1157 pos++;
1158
1159 return line[start .. end];
1160 }
1161
1162 // We have to sniff this... :/.
1163 switch (! Text.contains ("0123456789", line[0]))
1164 {
1165 // Not a number; this is UNIX format.
1166 case true:
1167 // The line must be at least 20 characters long.
1168 if (line.length < 20)
1169 return info;
1170
1171 // The first character tells us what it is.
1172 if (line[0] == 'd')
1173 info.type = FtpFileType.dir;
1174 else if (line[0] == '-')
1175 info.type = FtpFileType.file;
1176 else
1177 info.type = FtpFileType.unknown;
1178
1179 // Parse out the mode... rwxrwxrwx = 777.
1180 char[] unix_mode = "0000".dup;
1181 void read_mode(int digit)
1182 {
1183 for (pos = 1 + digit * 3; pos <= 3 + digit * 3; pos++)
1184 {
1185 if (line[pos] == 'r')
1186 unix_mode[digit + 1] |= 4;
1187 else if (line[pos] == 'w')
1188 unix_mode[digit + 1] |= 2;
1189 else if (line[pos] == 'x')
1190 unix_mode[digit + 1] |= 1;
1191 }
1192 }
1193
1194 // This makes it easier, huh?
1195 read_mode(0);
1196 read_mode(1);
1197 read_mode(2);
1198
1199 info.facts["UNIX.mode"] = unix_mode;
1200
1201 // Links, owner, group. These are hard to translate to MLST facts.
1202 parse_word();
1203 parse_word();
1204 parse_word();
1205
1206 // Size in bytes, this one is good.
1207 info.size = toLong(parse_word());
1208
1209 // Make sure we still have enough space.
1210 if (pos + 13 >= line.length)
1211 return info;
1212
1213 // Not parsing date for now. It's too weird (last 12 months, etc.)
1214 pos += 13;
1215
1216 info.name = line[pos .. line.length];
1217 break;
1218
1219 // A number; this is DOS format.
1220 case false:
1221 // We need some data here, to parse.
1222 if (line.length < 18)
1223 return info;
1224
1225 // The order is 1 MM, 2 DD, 3 YY, 4 HH, 5 MM, 6 P
1226 auto r = Regex.search(line, `(\d\d)-(\d\d)-(\d\d)\s+(\d\d):(\d\d)(A|P)M`);
1227 if (r is null)
1228 return info;
1229
1230 if (Timestamp.dostime (r.match(0), info.modify) is 0)
1231 info.modify = Time.max;
1232
1233 pos = r.match(0).length;
1234 delete r;
1235
1236 // This will either be <DIR>, or a number.
1237 char[] dir_or_size = parse_word();
1238
1239 if (dir_or_size.length < 0)
1240 return info;
1241 else if (dir_or_size[0] == '<')
1242 info.type = FtpFileType.dir;
1243 else
1244 info.size = toLong(dir_or_size);
1245
1246 info.name = line[pos .. line.length];
1247 break;
1248
1249 // Something else, not supported.
1250 default:
1251 throw new FTPException("CLIENT: Unsupported LIST format", "501");
1252 }
1253
1254 // Try to fix the type?
1255 if (info.name == ".")
1256 info.type = FtpFileType.cdir;
1257 else if (info.name == "..")
1258 info.type = FtpFileType.pdir;
1259
1260 return info;
1261 }
1262
1263 /// Parse an MLST/MLSD response line.
1264 ///
1265 /// The format here is very rigid, and has facts followed by a filename.
1266 ///
1267 /// Params:
1268 /// line = the line to parse
1269 ///
1270 /// Returns: information about the file
1271 protected FtpFileInfo parseMlstLine(char[] line)
1272 {
1273 FtpFileInfo info;
1274
1275 // After this loop, filename_pos will be location of space + 1.
1276 size_t filename_pos = 0;
1277 while (filename_pos < line.length && line[filename_pos++] != ' ')
1278 continue;
1279
1280 if (filename_pos == line.length)
1281 throw new FTPException("CLIENT: Bad syntax in MLSx response", "501");
1282
1283 info.name = line[filename_pos .. line.length];
1284
1285 // Everything else is frosting on top.
1286 if (filename_pos > 1)
1287 {
1288 char[][] temp_facts = Text.delimit(line[0 .. filename_pos - 1], ";");
1289
1290 // Go through each fact and parse them into the array.
1291 foreach (char[] fact; temp_facts)
1292 {
1293 int pos = Text.locate(fact, '=');
1294 if (pos == fact.length)
1295 continue;
1296
1297 info.facts[Ascii.toLower(fact[0 .. pos])] = fact[pos + 1 .. fact.length];
1298 }
1299
1300 // Do we have a type?
1301 if ("type" in info.facts)
1302 {
1303 // Some reflection might be nice here.
1304 switch (Ascii.toLower(info.facts["type"]))
1305 {
1306 case "file":
1307 info.type = FtpFileType.file;
1308 break;
1309
1310 case "cdir":
1311 info.type = FtpFileType.cdir;
1312 break;
1313
1314 case "pdir":
1315 info.type = FtpFileType.pdir;
1316 break;
1317
1318 case "dir":
1319 info.type = FtpFileType.dir;
1320 break;
1321
1322 default:
1323 info.type = FtpFileType.other;
1324 }
1325 }
1326
1327 // Size, mime, etc...
1328 if ("size" in info.facts)
1329 info.size = toLong(info.facts["size"]);
1330 if ("media-type" in info.facts)
1331 info.mime = info.facts["media-type"];
1332
1333 // And the two dates.
1334 if ("modify" in info.facts)
1335 info.modify = this.parseTimeval(info.facts["modify"]);
1336 if ("create" in info.facts)
1337 info.create = this.parseTimeval(info.facts["create"]);
1338 }
1339
1340 return info;
1341 }
1342
1343 /// Parse a timeval from an FTP response.
1344 ///
1345 /// This is basically an ISO 8601 date, but even more rigid.
1346 ///
1347 /// Params:
1348 /// timeval = the YYYYMMDDHHMMSS date
1349 ///
1350 /// Returns: a d_time representing the same date
1351
1352 protected Time parseTimeval(char[] timeval)
1353 {
1354 if (timeval.length < 14)
1355 throw new FTPException("CLIENT: Unable to parse timeval", "501");
1356
1357 return Gregorian.generic.toTime (Integer.atoi (timeval[0..4]),
1358 Integer.atoi (timeval[4..6]),
1359 Integer.atoi (timeval[6..8]),
1360 Integer.atoi (timeval[8..10]),
1361 Integer.atoi (timeval[10..12]),
1362 Integer.atoi (timeval[12..14]));
1363 }
1364
1365 /// Get the modification time of a file.
1366 ///
1367 /// Not supported by a lot of servers.
1368 ///
1369 /// Params:
1370 /// path = the file or directory in question
1371 ///
1372 /// Returns: a d_time representing the mtime
1373 public Time filemtime(char[] path)
1374 in
1375 {
1376 assert (path.length > 0);
1377 }
1378 body
1379 {
1380 this.sendCommand("MDTM", path);
1381 auto response = this.readResponse("213");
1382
1383 // The whole response should be a timeval.
1384 return this.parseTimeval(response.message);
1385 }
1386
1387 /// Create a directory.
1388 ///
1389 /// Depending on server model, a cwd with the same path may not work.
1390 /// Use the return value instead to escape this problem.
1391 ///
1392 /// Params:
1393 /// path = the directory to create
1394 ///
1395 /// Returns: the path to the directory created
1396 public char[] mkdir(char[] path)
1397 in
1398 {
1399 assert (path.length > 0);
1400 }
1401 body
1402 {
1403 this.sendCommand("MKD", path);
1404 auto response = this.readResponse("257");
1405
1406 return this.parse257(response);
1407 }
1408
1409 /// Get supported features from the server.
1410 ///
1411 /// This may not be supported, in which case the list will remain empty.
1412 /// Otherwise, it will contain at least FEAT.
1413 public void getFeatures()
1414 {
1415 this.sendCommand("FEAT");
1416 auto response = this.readResponse();
1417
1418 // 221 means FEAT is supported, and a list follows. Otherwise we don't know...
1419 if (response.code != "211")
1420 delete this.supported_features;
1421 else
1422 {
1423 char[][] lines = Text.splitLines (response.message);
1424
1425 // There are two more lines than features, but we also have FEAT.
1426 this.supported_features = new FtpFeature[lines.length - 1];
1427 this.supported_features[0].command = "FEAT";
1428
1429 for (size_t i = 1; i < lines.length - 1; i++)
1430 {
1431 size_t pos = Text.locate(lines[i], ' ');
1432
1433 this.supported_features[i].command = lines[i][0 .. pos];
1434 if (pos < lines[i].length - 1)
1435 this.supported_features[i].params = lines[i][pos + 1 .. lines[i].length];
1436 }
1437
1438 delete lines;
1439 }
1440 }
1441
1442 /// Check if a specific feature might be supported.
1443 ///
1444 /// Example:
1445 /// ----------
1446 /// if (ftp.isSupported("SIZE"))
1447 /// size = ftp.size("example.txt");
1448 /// ----------
1449 ///
1450 /// Params:
1451 /// command = the command in question
1452 public bool isSupported(char[] command)
1453 in
1454 {
1455 assert (command.length > 0);
1456 }
1457 body
1458 {
1459 if (this.supported_features.length == 0)
1460 return true;
1461
1462 // Search through the list for the feature.
1463 foreach (FtpFeature feat; this.supported_features)
1464 {
1465 if (Ascii.icompare(feat.command, command) == 0)
1466 return true;
1467 }
1468
1469 return false;
1470 }
1471
1472 /// Check if a specific feature is known to be supported.
1473 ///
1474 /// Example:
1475 /// ----------
1476 /// if (ftp.is_supported("SIZE"))
1477 /// size = ftp.size("example.txt");
1478 /// ----------
1479 ///
1480 /// Params:
1481 /// command = the command in question
1482 public bool is_supported(char[] command)
1483 {
1484 if (this.supported_features.length == 0)
1485 return false;
1486
1487 return this.isSupported(command);
1488 }
1489
1490 /// Send a site-specific command.
1491 ///
1492 /// The command might be WHO, for example, returning a list of users online.
1493 /// These are typically heavily server-specific.
1494 ///
1495 /// Params:
1496 /// command = the command to send (after SITE)
1497 /// parameters = any additional parameters to send
1498 /// (each will be prefixed by a space)
1499 public FtpResponse siteCommand(char[] command, char[][] parameters ...)
1500 in
1501 {
1502 assert (command.length > 0);
1503 }
1504 body
1505 {
1506 // Because of the way sendCommand() works, we have to tweak this a bit.
1507 char[][] temp_params = new char[][parameters.length + 1];
1508 temp_params[0] = command;
1509 temp_params[1 .. temp_params.length][] = parameters;
1510
1511 this.sendCommand("SITE", temp_params);
1512 auto response = this.readResponse();
1513
1514 // Check to make sure it didn't fail.
1515 if (response.code[0] != '2')
1516 exception (response);
1517
1518 return response;
1519 }
1520
1521 /// Send a NOOP, typically used to keep the connection alive.
1522 public void noop()
1523 {
1524 this.sendCommand("NOOP");
1525 this.readResponse("200");
1526 }
1527
1528 /// Send the stream to the server.
1529 ///
1530 /// Params:
1531 /// data = the socket to write to
1532 /// stream = the stream to read from
1533 /// progress = a delegate to call with progress information
1534
1535 protected void sendStream(Socket data, InputStream stream, FtpProgress progress = null)
1536 in
1537 {
1538 assert (data !is null);
1539 assert (stream !is null);
1540 }
1541 body
1542 {
1543 // Set up a SocketSet so we can use select() - it's pretty efficient.
1544 SocketSet set = new SocketSet();
1545 scope (exit)
1546 delete set;
1547
1548 // At end_time, we bail.
1549 Time end_time = Clock.now + this.timeout;
1550
1551 // This is the buffer the stream data is stored in.
1552 ubyte[8 * 1024] buf;
1553 size_t buf_size = 0, buf_pos = 0;
1554 int delta = 0;
1555
1556 size_t pos = 0;
1557 bool completed = false;
1558 while (!completed && Clock.now < end_time)
1559 {
1560 set.reset();
1561 set.add(data);
1562
1563 // Can we write yet, can we write yet?
1564 int code = Socket.select(null, set, null, this.timeout);
1565 if (code == -1 || code == 0)
1566 break;
1567
1568 if (buf_size - buf_pos <= 0)
1569 {
1570 if ((buf_size = stream.read(buf)) is stream.Eof)
1571 buf_size = 0, completed = true;
1572 buf_pos = 0;
1573 }
1574
1575 // Send the chunk (or as much of it as possible!)
1576 delta = data.send(buf[buf_pos .. buf_size]);
1577 if (delta == data.ERROR)
1578 break;
1579
1580 buf_pos += delta;
1581
1582 pos += delta;
1583 if (progress !is null)
1584 progress(pos);
1585
1586 // Give it more time as long as data is going through.
1587 if (delta != 0)
1588 end_time = Clock.now + this.timeout;
1589 }
1590
1591 // Did all the data get sent?
1592 if (!completed)
1593 throw new FTPException("CLIENT: Timeout when sending data", "420");
1594 }
1595
1596 /// Reads from the server to a stream until EOF.
1597 ///
1598 /// Params:
1599 /// data = the socket to read from
1600 /// stream = the stream to write to
1601 /// progress = a delegate to call with progress information
1602 protected void readStream(Socket data, OutputStream stream, FtpProgress progress = null)
1603 in
1604 {
1605 assert (data !is null);
1606 assert (stream !is null);
1607 }
1608 body
1609 {
1610 // Set up a SocketSet so we can use select() - it's pretty efficient.
1611 SocketSet set = new SocketSet();
1612 scope (exit)
1613 delete set;
1614
1615 // At end_time, we bail.
1616 Time end_time = Clock.now + this.timeout;
1617
1618 // This is the buffer the stream data is stored in.
1619 ubyte[8 * 1024] buf;
1620 int buf_size = 0;
1621
1622 bool completed = false;
1623 size_t pos;
1624 while (Clock.now < end_time)
1625 {
1626 set.reset();
1627 set.add(data);
1628
1629 // Can we read yet, can we read yet?
1630 int code = Socket.select(set, null, null, this.timeout);
1631 if (code == -1 || code == 0)
1632 break;
1633
1634 buf_size = data.receive(buf);
1635 if (buf_size == data.ERROR)
1636 break;
1637
1638 if (buf_size == 0)
1639 {
1640 completed = true;
1641 break;
1642 }
1643
1644 stream.write(buf[0 .. buf_size]);
1645
1646 pos += buf_size;
1647 if (progress !is null)
1648 progress(pos);
1649
1650 // Give it more time as long as data is going through.
1651 end_time = Clock.now + this.timeout;
1652 }
1653
1654 // Did all the data get received?
1655 if (!completed)
1656 throw new FTPException("CLIENT: Timeout when reading data", "420");
1657 }
1658
1659 /// Parse a 257 response (which begins with a quoted path.)
1660 ///
1661 /// Params:
1662 /// response = the response to parse
1663 ///
1664 /// Returns: the path in the response
1665
1666 protected char[] parse257(FtpResponse response)
1667 {
1668 char[] path = new char[response.message.length];
1669 size_t pos = 1, len = 0;
1670
1671 // Since it should be quoted, it has to be at least 3 characters in length.
1672 if (response.message.length <= 2)
1673 exception (response);
1674
1675 assert (response.message[0] == '"');
1676
1677 // Trapse through the response...
1678 while (pos < response.message.length)
1679 {
1680 if (response.message[pos] == '"')
1681 {
1682 // An escaped quote, keep going. False alarm.
1683 if (response.message[++pos] == '"')
1684 path[len++] = response.message[pos];
1685 else
1686 break;
1687 }
1688 else
1689 path[len++] = response.message[pos];
1690
1691 pos++;
1692 }
1693
1694 // Okay, done! That wasn't too hard.
1695 path.length = len;
1696 return path;
1697 }
1698
1699 /// Send a command to the FTP server.
1700 ///
1701 /// Does not get/wait for the response.
1702 ///
1703 /// Params:
1704 /// command = the command to send
1705 /// ... = additional parameters to send (a space will be prepended to each)
1706 public void sendCommand(char[] command, char[][] parameters ...)
1707 {
1708 assert (this.socket !is null);
1709
1710
1711 char [] socketCommand = command ;
1712
1713 // Send the command, parameters, and then a CRLF.
1714
1715 foreach (char[] param; parameters)
1716 {
1717 socketCommand ~= " " ~ param;
1718
1719 }
1720
1721 socketCommand ~= "\r\n";
1722
1723 debug(FtpDebug)
1724 {
1725 Stdout.formatln("[sendCommand] Sending command '{0}'",socketCommand );
1726 }
1727 this.sendData(socketCommand);
1728 }
1729
1730 /// Read in response lines from the server, expecting a certain code.
1731 ///
1732 /// Params:
1733 /// expected_code = the code expected from the server
1734 ///
1735 /// Returns: the response from the server
1736 ///
1737 /// Throws: FTPException if code does not match
1738 public FtpResponse readResponse(char[] expected_code)
1739 {
1740 debug (FtpDebug ) { Stdout.formatln("[readResponse] Expected Response {0}",expected_code )(); }
1741 auto response = this.readResponse();
1742 debug (FtpDebug ) { Stdout.formatln("[readResponse] Actual Response {0}",response.code)(); }
1743
1744 if (response.code != expected_code)
1745 exception (response);
1746
1747
1748
1749 return response;
1750 }
1751
1752 /// Read in the response line(s) from the server.
1753 ///
1754 /// Returns: the response from the server
1755 public FtpResponse readResponse()
1756 {
1757 assert (this.socket !is null);
1758
1759 // Pick a time at which we stop reading. It can't take too long, but it could take a bit for the whole response.
1760 Time end_time = Clock.now + this.timeout * 10;
1761
1762 FtpResponse response;
1763 char[] single_line = null;
1764
1765 // Danger, Will Robinson, don't fall into an endless loop from a malicious server.
1766 while (Clock.now < end_time)
1767 {
1768 single_line = this.readLine();
1769
1770
1771 // This is the first line.
1772 if (response.message.length == 0)
1773 {
1774 // The first line must have a code and then a space or hyphen.
1775 if (single_line.length <= 4)
1776 {
1777 response.code[] = "500";
1778 break;
1779 }
1780
1781 // The code is the first three characters.
1782 response.code[] = single_line[0 .. 3];
1783 response.message = single_line[4 .. single_line.length];
1784 }
1785 // This is either an extra line, or the last line.
1786 else
1787 {
1788 response.message ~= "\n";
1789
1790 // If the line starts like "123-", that is not part of the response message.
1791 if (single_line.length > 4 && single_line[0 .. 3] == response.code)
1792 response.message ~= single_line[4 .. single_line.length];
1793 // If it starts with a space, that isn't either.
1794 else if (single_line.length > 2 && single_line[0] == ' ')
1795 response.message ~= single_line[1 .. single_line.length];
1796 else
1797 response.message ~= single_line;
1798 }
1799
1800 // We're done if the line starts like "123 ". Otherwise we're not.
1801 if (single_line.length > 4 && single_line[0 .. 3] == response.code && single_line[3] == ' ')
1802 break;
1803 }
1804
1805 return response;
1806 }
1807
1808 /// convert text to integer
1809 private int toInt (char[] s)
1810 {
1811 return cast(int) toLong (s);
1812 }
1813
1814 /// convert text to integer
1815 private long toLong (char[] s)
1816 {
1817 return Integer.parse (s);
1818 }
1819 }
1820
1821
1822
1823 /// An exception caused by an unexpected FTP response.
1824 ///
1825 /// Even after such an exception, the connection may be in a usable state.
1826 /// Use the response code to determine more information about the error.
1827 ///
1828 /// Standards: RFC 959, RFC 2228, RFC 2389, RFC 2428
1829 class FTPException: Exception
1830 {
1831 /// The three byte response code.
1832 char[3] response_code = "000";
1833
1834 /// Construct an FTPException based on a message and code.
1835 ///
1836 /// Params:
1837 /// message = the exception message
1838 /// code = the code (5xx for fatal errors)
1839 this (char[] message, char[3] code = "420")
1840 {
1841 this.response_code[] = code;
1842 super(message);
1843 }
1844
1845 /// Construct an FTPException based on a response.
1846 ///
1847 /// Params:
1848 /// r = the server response
1849 this (FtpResponse r)
1850 {
1851 this.response_code[] = r.code;
1852 super(r.message);
1853 }
1854
1855 /// A string representation of the error.
1856 char[] toString()
1857 {
1858 char[] buffer = new char[this.msg.length + 4];
1859
1860 buffer[0 .. 3] = this.response_code;
1861 buffer[3] = ' ';
1862 buffer[4 .. buffer.length] = this.msg;
1863
1864 return buffer;
1865 }
1866 }
1867
1868
1869 debug (UnitTest )
1870 {
1871 import tango.io.Stdout;
1872
1873 unittest
1874 {
1875
1876 try
1877 {
1878 /+
1879 + TODO: Fix this
1880 +
1881 auto ftp = new FTPConnection("ftp.gnu.org","anonymous","anonymous");
1882 auto dirList = ftp.ls(); // get list for current dir
1883
1884 foreach ( entry;dirList )
1885 {
1886
1887 Stdout("File :")(entry.name)("\tSize :")(entry.size).newline;
1888
1889 }
1890
1891 ftp.cd("gnu/windows/emacs");
1892
1893
1894 dirList = ftp.ls();
1895
1896 foreach ( entry;dirList )
1897 {
1898
1899 Stdout("File :")(entry.name)("\tSize :")(entry.size).newline;
1900
1901 }
1902
1903
1904 size_t size = ftp.size("emacs-21.3-barebin-i386.tar.gz");
1905
1906 void progress( size_t pos )
1907 {
1908
1909 Stdout.formatln("Byte {0} of {1}",pos,size);
1910
1911 }
1912
1913
1914 ftp.get("emacs-21.3-barebin-i386.tar.gz","emacs.tgz", &progress);
1915 +/
1916 }
1917 catch( Object o )
1918 {
1919 assert( false );
1920 }
1921 }
1922 }