dany/luasocket
1
0
Fork 0
mirror of https://github.com/lunarmodules/luasocket.git synced 2025-04-17 22:16:45 +02:00
Code Issues Packages Projects Releases Wiki Activity

BUG: multi-line replies were not supported.

Browse Source 
Error logic simplified.
This commit is contained in:
Diego Nehab 2001-03-27 19:25:11 +00:00
parent 366fb989f3
commit bd0bf45979
1 changed files with 315 additions and 338 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

653
src/smtp.lua
View File

@ -1,338 +1,315 @@
----------------------------------------------------------------------------- -----------------------------------------------------------------------------
-- Simple SMTP support for the Lua language using the LuaSocket toolkit. -- Simple SMTP support for the Lua language using the LuaSocket toolkit.
-- Author: Diego Nehab -- Author: Diego Nehab
-- Date: 26/12/2000 -- Date: 26/12/2000
-- Conforming to: RFC 821 -- Conforming to: RFC 821
----------------------------------------------------------------------------- -----------------------------------------------------------------------------
----------------------------------------------------------------------------- -----------------------------------------------------------------------------
-- Program constants -- Program constants
----------------------------------------------------------------------------- -----------------------------------------------------------------------------
-- timeout in secconds before we give up waiting -- timeout in secconds before we give up waiting
local TIMEOUT = 180 local TIMEOUT = 180
-- port used for connection -- port used for connection
local PORT = 25 local PORT = 25
-- domain used in HELO command. If we are under a CGI, try to get from -- domain used in HELO command. If we are under a CGI, try to get from
-- environment -- environment
local DOMAIN = getenv("SERVER_NAME") local DOMAIN = getenv("SERVER_NAME")
if not DOMAIN then if not DOMAIN then
DOMAIN = "localhost" DOMAIN = "localhost"
end end
----------------------------------------------------------------------------- -----------------------------------------------------------------------------
-- Tries to send DOS mode lines. Closes socket on error. -- Tries to send DOS mode lines. Closes socket on error.
-- Input -- Input
-- sock: server socket -- sock: server socket
-- line: string to be sent -- line: string to be sent
-- Returns -- Returns
-- err: message in case of error, nil if successfull -- err: message in case of error, nil if successfull
----------------------------------------------------------------------------- -----------------------------------------------------------------------------
local puts = function(sock, line) local try_send = function(sock, line)
local err = sock:send(line .. "\r\n") local err = sock:send(line .. "\r\n")
if err then sock:close() end print(line)
return err if err then sock:close() end
end return err
end
-----------------------------------------------------------------------------
-- Tries to receive DOS mode lines. Closes socket on error. -----------------------------------------------------------------------------
-- Input -- Gets command reply, (accepts multiple-line replies)
-- sock: server socket -- Input
-- Returns -- control: control connection socket
-- line: received string if successfull, nil in case of error -- Returns
-- err: error message if any -- answer: whole server reply, nil if error
----------------------------------------------------------------------------- -- code: reply status code or error message
local gets = function(sock) -----------------------------------------------------------------------------
local line, err = sock:receive("*l") local get_answer = function(control)
if err then local code, lastcode, sep
sock:close() local line, err = control:receive()
return nil, err local answer = line
end if err then return nil, err end
return line print(line)
end _,_, code, sep = strfind(line, "^(%d%d%d)(.)")
if not code or not sep then return nil, answer end
----------------------------------------------------------------------------- if sep == "-" then -- answer is multiline
-- Gets a reply from the server and close connection if it is wrong repeat
-- Input line, err = control:receive()
-- sock: server socket if err then return nil, err end
-- accept: acceptable errorcodes print(line)
-- Returns _,_, lastcode, sep = strfind(line, "^(%d%d%d)(.)")
-- code: server reply code. nil if error answer = answer .. "\n" .. line
-- line: complete server reply message or error message until code == lastcode and sep == " " -- answer ends with same code
----------------------------------------------------------------------------- end
local get_reply = function(sock, accept) return answer, tonumber(code)
local line, err = %gets(sock) end
if line then
if type(accept) ~= "table" then accept = {accept} end -----------------------------------------------------------------------------
local _,_, code = strfind(line, "^(%d%d%d)") -- Checks if a message reply code is correct. Closes control connection
if not code then return nil, line end -- if not.
code = tonumber(code) -- Input
for i = 1, getn(accept) do -- control: control connection socket
if code == accept[i] then return code, line end -- success: table with successfull reply status code
end -- Returns
sock:close() -- code: reply code or nil in case of error
return nil, line -- answer: complete server answer or system error message
end -----------------------------------------------------------------------------
return nil, err local check_answer = function(control, success)
end local answer, code = %get_answer(control)
if not answer then
----------------------------------------------------------------------------- control:close()
-- Sends a command to the server return nil, code
-- Input end
-- sock: server socket if type(success) ~= "table" then success = {success} end
-- command: command to be sent for i = 1, getn(success) do
-- param: command parameters if any if code == success[i] then
-- Returns return code, answer
-- err: error message if any end
----------------------------------------------------------------------------- end
local send_command = function(sock, command, param) control:close()
local line return nil, answer
if param then line = command .. " " .. param end
else line = command end
return %puts(sock, line) -----------------------------------------------------------------------------
end -- Sends a command to the server (closes sock on error)
-- Input
----------------------------------------------------------------------------- -- sock: server socket
-- Gets the initial server greeting -- command: command to be sent
-- Input -- param: command parameters if any
-- sock: server socket -- Returns
-- Returns -- err: error message if any
-- code: server status code, nil if error -----------------------------------------------------------------------------
-- answer: complete server reply local send_command = function(sock, command, param)
----------------------------------------------------------------------------- local line
local get_helo = function(sock) if param then line = command .. " " .. param
return %get_reply(sock, 220) else line = command end
end return %try_send(sock, line)
end
-----------------------------------------------------------------------------
-- Sends initial client greeting -----------------------------------------------------------------------------
-- Input -- Sends initial client greeting
-- sock: server socket -- Input
-- Returns -- sock: server socket
-- code: server status code, nil if error -- Returns
-- answer: complete server reply -- code: server code if ok, nil if error
----------------------------------------------------------------------------- -- answer: complete server reply
local send_helo = function(sock) -----------------------------------------------------------------------------
local err = %send_command(sock, "HELO", %DOMAIN) local send_helo = function(sock)
if not err then local err = %send_command(sock, "HELO", %DOMAIN)
return %get_reply(sock, 250) if err then return nil, err end
else return nil, err end return %check_answer(sock, 250)
end end
----------------------------------------------------------------------------- -----------------------------------------------------------------------------
-- Sends mime headers -- Sends mime headers
-- Input -- Input
-- sock: server socket -- sock: server socket
-- mime: table with mime headers to be sent -- mime: table with mime headers to be sent
-- Returns -- Returns
-- err: error message if any -- err: error message if any
----------------------------------------------------------------------------- -----------------------------------------------------------------------------
local send_mime = function(sock, mime) local send_mime = function(sock, mime)
local err local err
mime = mime or {} mime = mime or {}
-- send all headers -- send all headers
for name,value in mime do for name,value in mime do
err = sock:send(name .. ": " .. value .. "\r\n") err = sock:send(name .. ": " .. value .. "\r\n")
if err then if err then
sock:close() sock:close()
return err return err
end end
end end
-- end mime part -- end mime part
err = sock:send("\r\n") err = sock:send("\r\n")
if err then sock:close() end if err then sock:close() end
return err return err
end end
----------------------------------------------------------------------------- -----------------------------------------------------------------------------
-- Sends connection termination command -- Sends connection termination command
-- Input -- Input
-- sock: server socket -- sock: server socket
-- Returns -- Returns
-- code: server status code, nil if error -- code: server status code, nil if error
-- answer: complete server reply -- answer: complete server reply or error message
----------------------------------------------------------------------------- -----------------------------------------------------------------------------
local send_quit = function(sock) local send_quit = function(sock)
local code, answer local err = %send_command(sock, "QUIT")
local err = %send_command(sock, "QUIT") if err then return nil, err end
if not err then local code, answer = %check_answer(sock, 221)
code, answer = %get_reply(sock, 221) sock:close()
sock:close() return code, answer
return code, answer end
else return nil, err end
end -----------------------------------------------------------------------------
-- Sends sender command
----------------------------------------------------------------------------- -- Input
-- Sends sender command -- sock: server socket
-- Input -- sender: e-mail of sender
-- sock: server socket -- Returns
-- sender: e-mail of sender -- code: server status code, nil if error
-- Returns -- answer: complete server reply or error message
-- code: server status code, nil if error -----------------------------------------------------------------------------
-- answer: complete server reply local send_mail = function(sock, sender)
----------------------------------------------------------------------------- local param = format("FROM:<%s>", sender)
local send_mail = function(sock, sender) local err = %send_command(sock, "MAIL", param)
local param = format("FROM:<%s>", sender) if err then return nil, err end
local err = %send_command(sock, "MAIL", param) return %check_answer(sock, 250)
if not err then end
return %get_reply(sock, 250)
else return nil, err end -----------------------------------------------------------------------------
end -- Sends message mime headers and body
-- Input
----------------------------------------------------------------------------- -- sock: server socket
-- Sends message mime headers and body -- mime: table containing all mime headers to be sent
-- Input -- body: message body
-- sock: server socket -- Returns
-- mime: table containing all mime headers to be sent -- code: server status code, nil if error
-- body: message body -- answer: complete server reply or error message
-- Returns -----------------------------------------------------------------------------
-- code: server status code, nil if error local send_data = function (sock, mime, body)
-- answer: complete server reply local err = %send_command(sock, "DATA")
----------------------------------------------------------------------------- if err then return nil, err end
local send_data = function (sock, mime, body) local code, answer = %check_answer(sock, 354)
local err = %send_command(sock, "DATA") if not code then return nil, answer end
if not err then -- avoid premature end in message body
local code, answer = %get_reply(sock, 354) body = gsub(body or "", "\n%.", "\n%.%.")
if not code then return nil, answer end -- mark end of message body
-- avoid premature end in message body body = body .. "\r\n."
body = gsub(body or "", "\n%.", "\n%.%.") err = %send_mime(sock, mime)
-- mark end of message body if err then return nil, err end
body = body .. "\r\n." err = %try_send(sock, body)
err = %send_mime(sock, mime) return %check_answer(sock, 250)
if err then return nil, err end end
err = %puts(sock, body)
return %get_reply(sock, 250) -----------------------------------------------------------------------------
else return nil, err end -- Sends recipient list command
end -- Input
-- sock: server socket
----------------------------------------------------------------------------- -- rcpt: lua table with recipient list
-- Sends recipient list command -- Returns
-- Input -- code: server status code, nil if error
-- sock: server socket -- answer: complete server reply
-- rcpt: lua table with recipient list -----------------------------------------------------------------------------
-- Returns local send_rcpt = function(sock, rcpt)
-- code: server status code, nil if error local err, code, answer
-- answer: complete server reply if type(rcpt) ~= "table" then rcpt = {rcpt} end
----------------------------------------------------------------------------- for i = 1, getn(rcpt) do
local send_rcpt = function(sock, rcpt) err = %send_command(sock, "RCPT", format("TO:<%s>", rcpt[i]))
local err, code, answer if err then return nil, err end
if type(rcpt) ~= "table" then rcpt = {rcpt} end code, answer = %check_answer(sock, {250, 251})
for i = 1, getn(rcpt) do if not code then return code, answer end
err = %send_command(sock, "RCPT", format("TO:<%s>", rcpt[i])) end
if not err then return code, answer
code, answer = %get_reply(sock, {250, 251}) end
if not code then return code, answer end
else return nil, err end -----------------------------------------------------------------------------
end -- Connection oriented mail functions
return code, answer -----------------------------------------------------------------------------
end function smtp_connect(server)
local code, answer
----------------------------------------------------------------------------- -- connect to server
-- Sends verify recipient command local sock, err = connect(server, %PORT)
-- Input if not sock then return nil, err end
-- sock: server socket sock:timeout(%TIMEOUT)
-- user: user to be verified -- initial server greeting
-- Returns code, answer = %check_answer(sock, 220)
-- code: server status code, nil if error if not code then return nil, answer end
-- answer: complete server reply -- HELO
----------------------------------------------------------------------------- code, answer = %send_helo(sock)
local send_vrfy = function (sock, user) if not code then return nil, answer end
local err = %send_command(sock, "VRFY", format("<%s>", user)) return sock
if not err then end
return %get_reply(sock, {250, 251})
else return nil, err end function smtp_send(sock, from, rcpt, mime, body)
end local code, answer
-- MAIL
----------------------------------------------------------------------------- code, answer = %send_mail(sock, from)
-- Connection oriented mail functions if not code then return nil, answer end
----------------------------------------------------------------------------- -- RCPT
function smtp_connect(server) code, answer = %send_rcpt(sock, rcpt)
local code, answer if not code then return nil, answer end
-- connect to server -- DATA
local sock, err = connect(server, %PORT) return %send_data(sock, mime, body)
if not sock then return nil, err end end
sock:timeout(%TIMEOUT)
-- initial server greeting function smtp_close(sock)
code, answer = %get_helo(sock) -- QUIT
if not code then return nil, answer end return %send_quit(sock)
-- HELO end
code, answer = %send_helo(sock)
if not code then return nil, answer end -----------------------------------------------------------------------------
return sock -- Main mail function
end -- Input
-- from: message sender
function smtp_send(sock, from, rcpt, mime, body) -- rcpt: table containing message recipients
local code, answer -- mime: table containing mime headers
-- MAIL -- body: message body
code, answer = %send_mail(sock, from) -- server: smtp server to be used
if not code then return nil, answer end -- Returns
-- RCPT -- nil if successfull, error message in case of error
code, answer = %send_rcpt(sock, rcpt) -----------------------------------------------------------------------------
if not code then return nil, answer end function smtp_mail(from, rcpt, mime, body, server)
-- DATA local sock, err = smtp_connect(server)
return %send_data(sock, mime, body) if not sock then return err end
end local code, answer = smtp_send(sock, from, rcpt, mime, body)
if not code then return answer end
function smtp_close(sock) code, answer = smtp_close(sock)
-- QUIT if code then return nil end
return %send_quit(sock) return answer
end end
----------------------------------------------------------------------------- --===========================================================================
-- Main mail function -- Compatibility functions
-- Input --===========================================================================
-- from: message sender -----------------------------------------------------------------------------
-- rcpt: table containing message recipients -- Converts a comma separated list into a Lua table with one entry for each
-- mime: table containing mime headers -- list element.
-- body: message body -- Input
-- server: smtp server to be used -- str: string containing the list to be converted
-- Returns -- tab: table to be filled with entries
-- nil if successfull, error message in case of error -- Returns
----------------------------------------------------------------------------- -- a table t, where t.n is the number of elements with an entry t[i]
function smtp_mail(from, rcpt, mime, body, server) -- for each element
local sock, err = smtp_connect(server) -----------------------------------------------------------------------------
if not sock then return err end local fill = function(str, tab)
local code, answer = smtp_send(sock, from, rcpt, mime, body) gsub(str, "([^%s,]+)", function (w) tinsert(%tab, w) end)
if not code then return answer end return tab
code, answer = smtp_close(sock) end
if not code then return answer
else return nil end -----------------------------------------------------------------------------
end -- Client mail function, implementing CGILUA 3.2 interface
-----------------------------------------------------------------------------
--=========================================================================== function mail(msg)
-- Compatibility functions local rcpt = {}
--=========================================================================== local mime = {}
----------------------------------------------------------------------------- mime["Subject"] = msg.subject
-- Converts a comma separated list into a Lua table with one entry for each mime["To"] = msg.to
-- list element. mime["From"] = msg.from
-- Input %fill(msg.to, rcpt)
-- str: string containing the list to be converted if msg.cc then
-- tab: table to be filled with entries %fill(msg.cc, rcpt)
-- Returns mime["Cc"] = msg.cc
-- a table t, where t.n is the number of elements with an entry t[i] end
-- for each element if msg.bcc then %fill(msg.bcc, rcpt) end
----------------------------------------------------------------------------- rcpt.n = nil
local fill = function(str, tab) return %smtp_mail(msg.from, rcpt, mime, msg.message, msg.mailserver)
gsub(str, "([^%s,]+)", function (w) tinsert(%tab, w) end) end
return tab
end
-----------------------------------------------------------------------------
-- Client mail function, implementing CGILUA 3.2 interface
-----------------------------------------------------------------------------
function mail(msg)
local rcpt = {}
local mime = {}
mime["Subject"] = msg.subject
mime["To"] = msg.to
mime["From"] = msg.from
%fill(msg.to, rcpt)
if msg.cc then
%fill(msg.cc, rcpt)
mime["Cc"] = msg.cc
end
if msg.bcc then
%fill(msg.bcc, rcpt)
end
rcpt.n = nil
return %smtp_mail(msg.from, rcpt, mime, msg.message, msg.mailserver)
end