FTP low-level working.

SMTP connection oriented working.
ltn12 improved.

1 files changed, 43 insertions, 33 deletions

diff --git a/src/tp.lua b/src/tp.lua
index 9365255..e9e38a1 100644
--- a/src/tp.lua
+++ b/src/tp.lua
@@ -18,22 +18,19 @@ setfenv(1, socket.tp)
 
 TIMEOUT = 60
 
--- gets server reply
-local function get_reply(sock)
+-- gets server reply (works for SMTP and FTP)
+local function get_reply(control)
     local code, current, separator, _
-    local line, err = sock:receive()
+    local line, err = control:receive()
     local reply = line
     if err then return nil, err end
     _, _, code, separator = string.find(line, "^(%d%d%d)(.?)")
     if not code then return nil, "invalid server reply" end
     if separator == "-" then -- reply is multiline
         repeat
-            line, err = sock:receive()
+            line, err = control:receive()
             if err then return nil, err end
-            _,_, current, separator = string.find(line, "^(%d%d%d)(.)")
-            if not current or not separator then 
-                return nil, "invalid server reply" 
-            end
+            _,_, current, separator = string.find(line, "^(%d%d%d)(.?)")
             reply = reply .. "\n" .. line
         -- reply ends with same code
         until code == current and separator == " " 
@@ -42,60 +39,73 @@ local function get_reply(sock)
 end
 
 -- metatable for sock object
-local metatable = { __index = {} }
+local metat = { __index = {} }
 
-function metatable.__index:check(ok)
-    local code, reply = get_reply(self.sock)
+function metat.__index:check(ok)
+    local code, reply = get_reply(self.control)
     if not code then return nil, reply end
     if type(ok) ~= "function" then
         if type(ok) == "table" then 
             for i, v in ipairs(ok) do
-                if string.find(code, v) then return code, reply end
+                if string.find(code, v) then return tonumber(code), reply end
             end
             return nil, reply
         else
-            if string.find(code, ok) then return code, reply 
+            if string.find(code, ok) then return tonumber(code), reply 
             else return nil, reply end
         end
-    else return ok(code, reply) end
+    else return ok(tonumber(code), reply) end
 end
 
-function metatable.__index:command(cmd, arg)
-    if arg then return self.sock:send(cmd .. " " .. arg.. "\r\n")
-    else return self.sock:send(cmd .. "\r\n") end
+function metat.__index:command(cmd, arg)
+    if arg then return self.control:send(cmd .. " " .. arg.. "\r\n")
+    else return self.control:send(cmd .. "\r\n") end
 end
 
-function metatable.__index:sink(snk, pat)
-    local chunk, err = sock:receive(pat)
+function metat.__index:sink(snk, pat)
+    local chunk, err = control:receive(pat)
     return snk(chunk, err)
 end
 
-function metatable.__index:send(data)
-    return self.sock:send(data)
+function metat.__index:send(data)
+    return self.control:send(data)
+end
+
+function metat.__index:receive(pat)
+    return self.control:receive(pat)
+end
+
+function metat.__index:getfd()
+    return self.control:getfd()
+end
+
+function metat.__index:dirty()
+    return self.control:dirty()
 end
 
-function metatable.__index:receive(pat)
-    return self.sock:receive(pat)
+function metat.__index:getcontrol()
+    return self.control
 end
 
-function metatable.__index:source(src, instr)
+function metat.__index:source(src, instr)
     while true do
         local chunk, err = src()
         if not chunk then return not err, err end
-        local ret, err = self.sock:send(chunk)
+        local ret, err = self.control:send(chunk)
         if not ret then return nil, err end
     end
 end
 
--- closes the underlying sock
-function metatable.__index:close()
-    self.sock:close()
+-- closes the underlying control
+function metat.__index:close()
+    self.control:close()
+        return 1
 end
 
--- connect with server and return sock object
+-- connect with server and return control object
 function connect(host, port)
-    local sock, err = socket.connect(host, port)
-    if not sock then return nil, err end
-    sock:settimeout(TIMEOUT)
-    return setmetatable({sock = sock}, metatable)
+    local control, err = socket.connect(host, port)
+    if not control then return nil, err end
+    control:settimeout(TIMEOUT)
+    return setmetatable({control = control}, metat)
 end