Seems to be working.

src/ltn12.lua

@@ -16,7 +16,7 @@ local function second(a, b)
     return b
 end
 
-local function skip(a, b, c)
+local function shift(a, b, c)
     return b, c
 end
 
@@ -69,7 +69,7 @@ function source.file(handle, io_err)
             if not chunk then handle:close() end
             return chunk
         end
-    else source.error(io_err or "unable to open file") end
+    else return source.error(io_err or "unable to open file") end
 end
 
 -- turns a fancy source into a simple source
@@ -114,6 +114,7 @@ function source.chain(src, f)
     local co = coroutine.create(function()
         while true do 
             local chunk, err = src()
+            if err then return nil, err end
             local filtered = f(chunk)
             local done = chunk and ""
             while true do
@@ -121,11 +122,10 @@ function source.chain(src, f)
                 if filtered == done then break end
                 filtered = f(done)
             end
-            if not chunk then return nil, err end
         end
     end)
     return function()
-        return skip(coroutine.resume(co))
+        return shift(coroutine.resume(co))
     end
 end
 
@@ -141,7 +141,7 @@ function source.cat(...)
         end
     end)
     return source.simplify(function()
-        return second(coroutine.resume(co))
+        return shift(coroutine.resume(co))
     end)
 end
 

src/mime.lua

@@ -6,9 +6,9 @@ setmetatable(mime, { __index = _G })
 setfenv(1, mime)
 
 -- encode, decode and wrap algorithm tables
-local et = {}
+encodet = {}
-local dt = {}
+decodet = {}
-local wt = {}
+wrapt = {}
 
 -- creates a function that chooses a filter by name from a given table 
 local function choose(table)
@@ -20,40 +20,40 @@ local function choose(table)
 end
 
 -- define the encoding filters
-et['base64'] = function()
+encodet['base64'] = function()
     return ltn12.filter.cycle(b64, "")
 end
 
-et['quoted-printable'] = function(mode)
+encodet['quoted-printable'] = function(mode)
     return ltn12.filter.cycle(qp, "", 
         (mode == "binary") and "=0D=0A" or "\13\10")
 end
 
 -- define the decoding filters
-dt['base64'] = function()
+decodet['base64'] = function()
     return ltn12.filter.cycle(unb64, "")
 end
 
-dt['quoted-printable'] = function()
+decodet['quoted-printable'] = function()
     return ltn12.filter.cycle(unqp, "")
 end
 
 -- define the line-wrap filters
-wt['text'] = function(length)
+wrapt['text'] = function(length)
     length = length or 76
     return ltn12.filter.cycle(wrp, length, length) 
 end
-wt['base64'] = wt['text']
+wrapt['base64'] = wrapt['text']
 
-wt['quoted-printable'] = function()
+wrapt['quoted-printable'] = function()
     return ltn12.filter.cycle(qpwrp, 76, 76) 
 end
 
 -- function that choose the encoding, decoding or wrap algorithm
-encode = choose(et) 
+encode = choose(encodet) 
-decode = choose(dt)
+decode = choose(decodet)
--- there is different because there is a default wrap filter
+-- it's different because there is a default wrap filter
-local cwt = choose(wt)
+local cwt = choose(wrapt)
 function wrap(mode_or_length, length)
     if type(mode_or_length) ~= "string" then
         length = mode_or_length

src/smtp.lua

@@ -10,23 +10,27 @@ socket.smtp = smtp
 setmetatable(smtp, { __index = _G })
 setfenv(1, smtp)
 
+-- default server used to send e-mails
+SERVER = "localhost"
 -- default port
 PORT = 25 
 -- domain used in HELO command and default sendmail 
 -- If we are under a CGI, try to get from environment
 DOMAIN = os.getenv("SERVER_NAME") or "localhost"
--- default server used to send e-mails
+-- default time zone (means we don't know)
-SERVER = "localhost"
+ZONE = "-0000"
 
 function stuff()
     return ltn12.filter.cycle(dot, 2)
 end
 
-local function skip(a, b, c)
+local function shift(a, b, c)
     return b, c
 end
 
+-- send message or throw an exception
 function psend(control, mailt) 
+    socket.try(control:check("2.."))
     socket.try(control:command("EHLO", mailt.domain or DOMAIN))
     socket.try(control:check("2.."))
     socket.try(control:command("MAIL", "FROM:" .. mailt.from))
@@ -34,11 +38,12 @@ function psend(control, mailt)
     if type(mailt.rcpt) == "table" then
         for i,v in ipairs(mailt.rcpt) do
             socket.try(control:command("RCPT", "TO:" .. v))
+            socket.try(control:check("2.."))
         end
     else
         socket.try(control:command("RCPT", "TO:" .. mailt.rcpt))
+        socket.try(control:check("2.."))
     end
-    socket.try(control:check("2.."))
     socket.try(control:command("DATA"))
     socket.try(control:check("3.."))
     socket.try(control:source(ltn12.source.chain(mailt.source, stuff())))
@@ -48,6 +53,7 @@ function psend(control, mailt)
     socket.try(control:check("2.."))
 end
 
+-- returns a hopefully unique mime boundary
 local seqno = 0
 local function newboundary()
     seqno = seqno + 1
@@ -55,62 +61,98 @@ local function newboundary()
         math.random(0, 99999), seqno)
 end
 
-local function sendmessage(mesgt)
+-- sendmessage forward declaration
-    -- send headers
+local sendmessage
+
+-- yield multipart message body from a multipart message table
+local function sendmultipart(mesgt)
+    local bd = newboundary()
+    -- define boundary and finish headers
+    coroutine.yield('content-type: multipart/mixed; boundary="' .. 
+        bd .. '"\r\n\r\n')
+    -- send preamble
+    if mesgt.body.preamble then coroutine.yield(mesgt.body.preamble) end
+    -- send each part separated by a boundary
+    for i, m in ipairs(mesgt.body) do
+        coroutine.yield("\r\n--" .. bd .. "\r\n")
+        sendmessage(m)
+    end
+    -- send last boundary 
+    coroutine.yield("\r\n--" .. bd .. "--\r\n\r\n")
+    -- send epilogue
+    if mesgt.body.epilogue then coroutine.yield(mesgt.body.epilogue) end
+end
+
+-- yield message body from a source
+local function sendsource(mesgt)
+    -- set content-type if user didn't override
+    if not mesgt.headers or not mesgt.headers["content-type"] then
+        coroutine.yield('content-type: text/plain; charset="iso-88591"\r\n')
+    end
+    -- finish headers
+    coroutine.yield("\r\n")
+    -- send body from source
+    while true do 
+        local chunk, err = mesgt.body()
+        if err then coroutine.yield(nil, err)
+        elseif chunk then coroutine.yield(chunk)
+        else break end
+    end
+end
+
+-- yield message body from a string
+local function sendstring(mesgt)
+    -- set content-type if user didn't override
+    if not mesgt.headers or not mesgt.headers["content-type"] then
+        coroutine.yield('content-type: text/plain; charset="iso-88591"\r\n')
+    end
+    -- finish headers
+    coroutine.yield("\r\n")
+    -- send body from string
+    coroutine.yield(mesgt.body)
+
+end
+
+-- yield the headers one by one
+local function sendheaders(mesgt)
     if mesgt.headers then
         for i,v in pairs(mesgt.headers) do
             coroutine.yield(i .. ':' .. v .. "\r\n")
         end
     end
-    -- deal with multipart
+end
-    if type(mesgt.body) == "table" then
+
-        local bd = newboundary()
+-- message source
-        -- define boundary and finish headers
+function sendmessage(mesgt)
-        coroutine.yield('mime-version: 1.0\r\n') 
+    sendheaders(mesgt)
-        coroutine.yield('content-type: multipart/mixed; boundary="' .. 
+    if type(mesgt.body) == "table" then sendmultipart(mesgt)
-            bd .. '"\r\n\r\n')
+    elseif type(mesgt.body) == "function" then sendsource(mesgt)
-        -- send preamble
+    else sendstring(mesgt) end
-        if mesgt.body.preamble then coroutine.yield(mesgt.body.preamble) end
+end
-        -- send each part separated by a boundary
+
-        for i, m in ipairs(mesgt.body) do
+-- set defaul headers
-            coroutine.yield("\r\n--" .. bd .. "\r\n")
+local function adjustheaders(mesgt)
-            sendmessage(m)
+    mesgt.headers = mesgt.headers or {}
-        end
+    mesgt.headers["mime-version"] = "1.0" 
-        -- send last boundary 
+    mesgt.headers["date"] = mesgt.headers["date"] or 
-        coroutine.yield("\r\n--" .. bd .. "--\r\n\r\n")
+        os.date("%a, %d %b %Y %H:%M:%S") .. (mesgt.zone or ZONE)
-        -- send epilogue
+    mesgt.headers["x-mailer"] = mesgt.headers["x-mailer"] or socket.version
-        if mesgt.body.epilogue then coroutine.yield(mesgt.body.epilogue) end
-    -- deal with a source 
-    elseif type(mesgt.body) == "function" then
-        -- finish headers
-        coroutine.yield("\r\n")
-        while true do 
-            local chunk, err = mesgt.body()
-            if err then return nil, err
-            elseif chunk then coroutine.yield(chunk)
-            else break end
-        end
-    -- deal with a simple string
-    else
-        -- finish headers
-        coroutine.yield("\r\n")
-        coroutine.yield(mesgt.body)
-    end
 end
 
 function message(mesgt)
+    adjustheaders(mesgt)
+    -- create and return message source
     local co = coroutine.create(function() sendmessage(mesgt) end)
-    return function() return skip(coroutine.resume(co)) end
+    return function() return shift(coroutine.resume(co)) end
 end
 
 function send(mailt)
-    local control, err = socket.tp.connect(mailt.server or SERVER, 
+    local c, e = socket.tp.connect(mailt.server or SERVER, mailt.port or PORT)
-        mailt.port or PORT)
+    if not c then return nil, e end
-    if not control then return nil, err end
+    local s, e = pcall(psend, c, mailt)
-    local status, err = pcall(psend, control, mailt)
+    c:close()
-    control:close()
+    if s then return true
-    if status then return true
+    else return nil, e end
-    else return nil, err end
 end
 
 return smtp

src/tp.lua

@@ -82,7 +82,7 @@ function metatable.__index:source(src, instr)
     while true do
         local chunk, err = src()
         if not chunk then return not err, err end
-        local ret, err = try_sending(self.sock, chunk)
+        local ret, err = self.sock:send(chunk)
         if not ret then return nil, err end
     end
 end
@@ -95,7 +95,7 @@ end
 -- connect with server and return sock object
 function connect(host, port)
     local sock, err = socket.connect(host, port)
-    if not sock then return nil, message end
+    if not sock then return nil, err end
     sock:settimeout(TIMEOUT)
     return setmetatable({sock = sock}, metatable)
 end