Changeset 3467

Timestamp:

04/27/08 07:49:51 (7 months ago)

Author:

lmartin92

Message:

I believe now that data connections are working and now we are just waiting for me to add the rest and come up with a way to directly access the Input/Output Streams(SocketConduits?) in a very (for lack of better words) good way

Files:

• branches/lmartin/ftp/tango/net/ftp/FtpClient.d (modified) (9 diffs)

branches/lmartin/ftp/tango/net/ftp/FtpClient.d

@@ -1 +1 @@
-/**
-
-
+         
+:      
- * Based upon prior FtpClient.d (some code is borrowed)
-
+
+
- */
-
@@ -24 +25 @@
-    import tango.time.chrono.Gregorian;
-    import tango.io.GrowBuffer;
+    import  Timestamp = tango.text.convert.TimeStamp;
+    import tango.core.Array;
+    debug(UnitTest)
+    {
+        import tango.io.Stdout;
+    }
-}
-
@@ -478 +485 @@
-    }
-
-*
+
-    in {
-        assert(file.length > 0);
@@ -487 +494 @@
-
-        // The whole response should be a timeval.
-&
+
-    }
-
@@ -544 +551 @@
-
-    public void sendCommand(char[] command, char[][] parameters...) {
-        assert(this.socket_ !is null);
-
-        char[] socketCommand = command;
@@ -723 +729 @@
-    ///
-    /// Returns:             a connected socket
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-        sock.connect(connect_to);
-        return sock;
-
+
+
+
+
+
+
-
-    public bool isSupported(char[] command)
@@ -864 +883 @@
-        }
-    }
+
+    public void finishDataCommand(SocketConduit data)
+    {
+        // Close the socket.  This tells the server we're done (EOF.)
+        data.close();
+        data.detach();
+
+        // We shouldn't get a 250 in STREAM mode.
+        this.readResponse("226");
+    }
+    
+    public SocketConduit processDataCommand(char[] command, char[][] parameters ...)
+    {
+        // Create a connection.
+        SocketConduit data = this.getDataSocket();
+        scope (failure)
+            {
+                // Close the socket, whether we were listening or not.
+                data.close();
+            }
+
+        // Tell the server about it.
+        this.sendCommand(command, parameters);
+
+        // We should always get a 150/125 response.
+        auto response = this.readResponse();
+        if (response.code != "150" && response.code != "125")
+            exception (response);
+
+        // We might need to do this for active connections.
+        this.prepareDataSocket(data);
+
+        return data;
+    }
+
+        public FtpFileInfo[] ls(char[] path = "") // default to current dir
+        in
+    {
+        assert (path.length == 0 || path[path.length - 1] != '/');
+    }
+    body
+    {
+        FtpFileInfo[] dir;
+
+        // We'll try MLSD (which is so much better) first... but it may fail.
+        bool mlsd_success = false;
+        SocketConduit data = null;
+
+        // Try it if it could/might/maybe is supported.
+        /*if (this.isSupported("MLST"))
+            {
+                mlsd_success = true;
+
+                // Since this is a data command, processDataCommand handles
+                // checking the response... just catch its Exception.
+                try
+                    {
+                        if (path.length > 0)
+                            data = this.processDataCommand("MLSD", path);
+                        else
+                            data = this.processDataCommand("MLSD");
+                    }
+                catch (FtpException)
+                    mlsd_success = false;
+            }
+
+        // If it passed, parse away!
+        if (mlsd_success)
+            {
+                auto listing = new GrowBuffer;
+                this.readStream(data, listing);
+                this.finishDataCommand(data);
+
+                // Each line is something in that directory.
+                char[][] lines = Text.splitLines (cast(char[]) listing.slice());
+                scope (exit)
+                    delete lines;
+
+                foreach (char[] line; lines)
+                    {
+                        // Parse each line exactly like MLST does.
+                        FtpFileInfo info = this.parseMlstLine(line);
+                        if (info.name.length > 0)
+                            dir ~= info;
+                    }
+
+                return dir;
+            }
+        // Fall back to LIST.
+        else*/
+            return this.sendListCommand(path);
+    }
+
+       protected void readStream(SocketConduit data, OutputStream stream, FtpProgress progress = null)
+        in
+    {
+        assert (data !is null);
+        assert (stream !is null);
+    }
+    body
+    {
+        // Set up a SocketSet so we can use select() - it's pretty efficient.
+        SocketSet set = new SocketSet();
+        scope (exit)
+            delete set;
+
+        // At end_time, we bail.
+        Time end_time = Clock.now + this.timeout;
+
+        // This is the buffer the stream data is stored in.
+        ubyte[8 * 1024] buf;
+        int buf_size = 0;
+
+        bool completed = false;
+        size_t pos;
+        while (Clock.now < end_time)
+            {
+                set.reset();
+                set.add(data.socket);
+
+                // Can we read yet, can we read yet?
+                int code = Socket.select(set, null, null, this.timeout);
+                if (code == -1 || code == 0)
+                    break;
+
+                buf_size = data.socket.receive(buf);
+                if (buf_size == data.socket.ERROR)
+                    break;
+
+                if (buf_size == 0)
+                    {
+                        completed = true;
+                        break;
+                    }
+
+                stream.write(buf[0 .. buf_size]);
+
+                pos += buf_size;
+                if (progress !is null)
+                    progress(pos);
+
+                // Give it more time as long as data is going through.
+                end_time = Clock.now + this.timeout;
+            }
+
+        // Did all the data get received?
+        if (!completed)
+            throw new FtpException("CLIENT: Timeout when reading data", "420");
+    }
+
+    protected void sendStream(SocketConduit data, InputStream stream, FtpProgress progress = null)
+        in
+    {
+        assert (data !is null);
+        assert (stream !is null);
+    }
+    body
+    {
+        // Set up a SocketSet so we can use select() - it's pretty efficient.
+        SocketSet set = new SocketSet();
+        scope (exit)
+            delete set;
+
+        // At end_time, we bail.
+        Time end_time = Clock.now + this.timeout;
+
+        // This is the buffer the stream data is stored in.
+        ubyte[8 * 1024] buf;
+        size_t buf_size = 0, buf_pos = 0;
+        int delta = 0;
+
+        size_t pos = 0;
+        bool completed = false;
+        while (!completed && Clock.now < end_time)
+            {
+                set.reset();
+                set.add(data.socket);
+
+                // Can we write yet, can we write yet?
+                int code = Socket.select(null, set, null, this.timeout);
+                if (code == -1 || code == 0)
+                    break;
+
+                if (buf_size - buf_pos <= 0)
+                    {
+                        if ((buf_size = stream.read(buf)) is stream.Eof)
+                            buf_size = 0, completed = true;
+                        buf_pos = 0;
+                    }
+
+                // Send the chunk (or as much of it as possible!)
+                delta = data.socket.send(buf[buf_pos .. buf_size]);
+                if (delta == data.socket.ERROR)
+                    break;
+
+                buf_pos += delta;
+
+                pos += delta;
+                if (progress !is null)
+                    progress(pos);
+
+                // Give it more time as long as data is going through.
+                if (delta != 0)
+                    end_time = Clock.now + this.timeout;
+            }
+
+        // Did all the data get sent?
+        if (!completed)
+            throw new FtpException("CLIENT: Timeout when sending data", "420");
+    }
+
+    protected FtpFileInfo[] sendListCommand(char[] path)
+    {
+        FtpFileInfo[] dir;
+        SocketConduit data = null;
+
+        if (path.length > 0)
+            data = this.processDataCommand("LIST", path);
+        else
+            data = this.processDataCommand("LIST");
+
+        // Read in the stupid non-standardized response.
+        auto listing = new GrowBuffer;
+        this.readStream(data, listing);
+        this.finishDataCommand(data);
+
+        // Split out the lines.  Most of the time, it's one-to-one.
+        char[][] lines = Text.splitLines (cast(char[]) listing.slice());
+        scope (exit)
+            delete lines;
+
+        foreach (char[] line; lines)
+            {
+                // If there are no spaces, or if there's only one... skip the line.
+                // This is probably like a "total 8" line.
+                if (Text.locate(line, ' ') == Text.locatePrior(line, ' '))
+                    continue;
+
+                // Now parse the line, or try to.
+                FtpFileInfo info = this.parseListLine(line);
+                if (info.name.length > 0)
+                    dir ~= info;
+            }
+
+        return dir;
+    }
+    
+    protected FtpFileInfo parseListLine(char[] line)
+    {
+        FtpFileInfo info;
+        size_t pos = 0;
+
+        // Convenience function to parse a word from the line.
+        char[] parse_word()
+            {
+                size_t start = 0, end = 0;
+
+                // Skip whitespace before.
+                while (pos < line.length && line[pos] == ' ')
+                    pos++;
+
+                start = pos;
+                while (pos < line.length && line[pos] != ' ')
+                    pos++;
+                end = pos;
+
+                // Skip whitespace after.
+                while (pos < line.length && line[pos] == ' ')
+                    pos++;
+
+                return line[start .. end];
+            }
+
+        // We have to sniff this... :/.
+        switch (! Text.contains ("0123456789", line[0]))
+            {
+                // Not a number; this is UNIX format.
+            case true:
+                // The line must be at least 20 characters long.
+                if (line.length < 20)
+                    return info;
+
+                // The first character tells us what it is.
+                if (line[0] == 'd')
+                    info.type = FtpFileType.dir;
+                else if (line[0] == '-')
+                    info.type = FtpFileType.file;
+                else
+                    info.type = FtpFileType.unknown;
+
+                // Parse out the mode... rwxrwxrwx = 777.
+                char[] unix_mode = "0000".dup;
+                void read_mode(int digit)
+                    {
+                        for (pos = 1 + digit * 3; pos <= 3 + digit * 3; pos++)
+                            {
+                                if (line[pos] == 'r')
+                                    unix_mode[digit + 1] |= 4;
+                                else if (line[pos] == 'w')
+                                    unix_mode[digit + 1] |= 2;
+                                else if (line[pos] == 'x')
+                                    unix_mode[digit + 1] |= 1;
+                            }
+                    }
+
+                // This makes it easier, huh?
+                read_mode(0);
+                read_mode(1);
+                read_mode(2);
+
+                info.facts["UNIX.mode"] = unix_mode;
+
+                // Links, owner, group.  These are hard to translate to MLST facts.
+                parse_word();
+                parse_word();
+                parse_word();
+
+                // Size in bytes, this one is good.
+                info.size = toLong(parse_word());
+
+                // Make sure we still have enough space.
+                if (pos + 13 >= line.length)
+                    return info;
+
+                // Not parsing date for now.  It's too weird (last 12 months, etc.)
+                pos += 13;
+
+                info.name = line[pos .. line.length];
+                break;
+
+                // A number; this is DOS format.
+            case false:
+                // We need some data here, to parse.
+                if (line.length < 18)
+                    return info;
+
+                // The order is 1 MM, 2 DD, 3 YY, 4 HH, 5 MM, 6 P
+                auto r = Regex(`(\d\d)-(\d\d)-(\d\d)\s+(\d\d):(\d\d)(A|P)M`);
+                if ( r.test(line) )
+                    return info;
+
+                if (Timestamp.dostime (r.match(0), info.modify) is 0)
+                    info.modify = Time.max;
+
+                pos = r.match(0).length;
+                delete r;
+
+                // This will either be <DIR>, or a number.
+                char[] dir_or_size = parse_word();
+
+                if (dir_or_size.length < 0)
+                    return info;
+                else if (dir_or_size[0] == '<')
+                    info.type = FtpFileType.dir;
+                else
+                    info.size = toLong(dir_or_size);
+
+                info.name = line[pos .. line.length];
+                break;
+
+                // Something else, not supported.
+            default:
+                throw new FtpException("CLIENT: Unsupported LIST format", "501");
+            }
+
+        // Try to fix the type?
+        if (info.name == ".")
+            info.type = FtpFileType.cdir;
+        else if (info.name == "..")
+            info.type = FtpFileType.pdir;
+
+        return info;
+    }
+    
+    protected FtpFileInfo parseMlstLine(char[] line)
+    {
+        FtpFileInfo info;
+
+        // After this loop, filename_pos will be location of space + 1.
+        size_t filename_pos = 0;
+        while (filename_pos < line.length && line[filename_pos++] != ' ')
+            continue;
+
+        if (filename_pos == line.length)
+            throw new FtpException("CLIENT: Bad syntax in MLSx response", "501");
+
+        info.name = line[filename_pos .. line.length];
+
+        // Everything else is frosting on top.
+        if (filename_pos > 1)
+            {
+                char[][] temp_facts = Text.delimit(line[0 .. filename_pos - 1], ";");
+
+                // Go through each fact and parse them into the array.
+                foreach (char[] fact; temp_facts)
+                    {
+                        int pos = Text.locate(fact, '=');
+                        if (pos == fact.length)
+                            continue;
+
+                        info.facts[Ascii.toLower(fact[0 .. pos])] = fact[pos + 1 .. fact.length];
+                    }
+
+                // Do we have a type?
+                if ("type" in info.facts)
+                    {
+                        // Some reflection might be nice here.
+                        switch (Ascii.toLower(info.facts["type"]))
+                            {
+                            case "file":
+                                info.type = FtpFileType.file;
+                                break;
+
+                            case "cdir":
+                                info.type = FtpFileType.cdir;
+                                break;
+
+                            case "pdir":
+                                info.type = FtpFileType.pdir;
+                                break;
+
+                            case "dir":
+                                info.type = FtpFileType.dir;
+                                break;
+
+                            default:
+                                info.type = FtpFileType.other;
+                            }
+                    }
+
+                // Size, mime, etc...
+                if ("size" in info.facts)
+                    info.size = toLong(info.facts["size"]);
+                if ("media-type" in info.facts)
+                    info.mime = info.facts["media-type"];
+
+                // And the two dates.
+                if ("modify" in info.facts)
+                    info.modify = this.parseTimeval(info.facts["modify"]);
+                if ("create" in info.facts)
+                    info.create = this.parseTimeval(info.facts["create"]);
+            }
+
+        return info;
+    }
-}
-
@@ -891 +1355 @@
-        conn.rename("ServingSchedule.tif", "No");
-        Stdout("Getting the mod date.").newline.flush;
-*(conn.modified("No")
+conn.modified("No"
-        Stdout("The file was modified: ");
-        Stdout(layout ("{:ddd, dd MMMM yyyy HH:mm:ss z}", modified)).newline.flush;
@@ -898 +1362 @@
-        Stdout("Deleting the file No.").newline.flush;
-        conn.del("No");
+        FtpFileInfo[] infs = conn.ls();
+        foreach(FtpFileInfo inf; infs)
+        {
+            Stdout(inf.name).newline.flush;
+        }
-        conn.close();
-        Stdout("Finished.").newline.flush;