5 files changed, 72 insertions, 70 deletions

diff --git a/src/ftp.lua b/src/ftp.lua
index 1fa48f7..f6fffbb 100644
--- a/src/ftp.lua
+++ b/src/ftp.lua
@@ -8,7 +8,7 @@
 -----------------------------------------------------------------------------
 
 local Public, Private = {}, {}
-FTP = Public
+socket.ftp = Public
 
 -----------------------------------------------------------------------------
 -- Program constants
@@ -47,7 +47,7 @@ end
 -----------------------------------------------------------------------------
 function Private.try_receive(...)
     local sock = arg[1]
-    local data, err = call(sock.receive, arg)
+    local data, err = sock.receive(unpack(arg))
     if err then sock:close() end
     return data, err
 end
@@ -64,9 +64,9 @@ function Private.get_pasv(pasv)
         local a, b, c, d, p1, p2, _
         local ip, port
         _,_, a, b, c, d, p1, p2 =
-                strfind(pasv, "(%d*),(%d*),(%d*),(%d*),(%d*),(%d*)")
+                string.find(pasv, "(%d*),(%d*),(%d*),(%d*),(%d*),(%d*)")
         if not (a and b and c and d and p1 and p2) then return nil, nil end
-        ip = format("%d.%d.%d.%d", a, b, c, d)
+        ip = string.format("%d.%d.%d.%d", a, b, c, d)
         port = tonumber(p1)*256 + tonumber(p2)
         return ip, port
 end
@@ -100,13 +100,13 @@ function Private.get_answer(control)
         local line, err = Private.try_receive(control)
         local answer = line
         if err then return nil, err end
-        _,_, code, sep = strfind(line, "^(%d%d%d)(.)")
+        _,_, code, sep = string.find(line, "^(%d%d%d)(.)")
         if not code or not sep then return nil, answer end
         if sep == "-" then -- answer is multiline
                 repeat 
                         line, err = Private.try_receive(control)
                         if err then return nil, err end
-                        _,_, lastcode, sep = strfind(line, "^(%d%d%d)(.)")
+                        _,_, lastcode, sep = string.find(line, "^(%d%d%d)(.)")
                         answer = answer .. "\n" .. line
                 until code == lastcode and sep == " " -- answer ends with same code
         end
@@ -126,8 +126,8 @@ function Private.check_answer(control, success)
         local answer, code = Private.get_answer(control)
         if not answer then return nil, code end
         if type(success) ~= "table" then success = {success} end
-        for i = 1, getn(success) do
-                if code == success[i] then
+        for _, s in ipairs(success) do
+                if code == s then
                         return code, answer
                 end
         end
@@ -213,13 +213,13 @@ function Private.port(control)
         local code, answer
         local server, ctl_ip
         ctl_ip, answer = control:getsockname()
-        server, answer = bind(ctl_ip, 0)
+        server, answer = socket.bind(ctl_ip, 0)
         server:timeout(Public.TIMEOUT)
         local ip, p, ph, pl
         ip, p = server:getsockname()
-        pl = mod(p, 256)
+        pl = math.mod(p, 256)
         ph = (p - pl)/256
-    local arg = gsub(format("%s,%d,%d", ip, ph, pl), "%.", ",")
+    local arg = string.gsub(string.format("%s,%d,%d", ip, ph, pl), "%.", ",")
         code, answer = Private.command(control, "port", arg, {200})
         if not code then 
                 server:close()
@@ -321,7 +321,7 @@ function Private.send_indirect(data, send_cb, chunk, size)
             data:close()
             return err
         end
-        sent = sent + strlen(chunk)
+        sent = sent + string.len(chunk)
         if sent >= size then break end
         chunk, size = send_cb()
     end
@@ -374,7 +374,7 @@ end
 -----------------------------------------------------------------------------
 function Private.change_type(control, params)
         local type, _
-        _, _, type = strfind(params or "", "type=(.)")
+        _, _, type = string.find(params or "", "type=(.)")
         if type == "a" or type == "i" then 
                 local code, err = Private.command(control, "type", type, {200})
                 if not code then return err end
@@ -391,7 +391,7 @@ end
 -----------------------------------------------------------------------------
 function Private.open(parsed)
         -- start control connection
-        local control, err = connect(parsed.host, parsed.port)
+        local control, err = socket.connect(parsed.host, parsed.port)
         if not control then return nil, err end
         -- make sure we don't block forever
         control:timeout(Public.TIMEOUT)
@@ -423,7 +423,7 @@ end
 --   err: error message if any
 -----------------------------------------------------------------------------
 function Private.change_dir(control, segment)
-        local n = getn(segment)
+    local n = table.getn(segment)
         for i = 1, n-1 do
                 local code, answer = Private.cwd(control, segment[i])
                 if not code then return answer end
@@ -443,7 +443,7 @@ end
 function Private.upload(control, request, segment)
         local code, name, content_cb
         -- get remote file name
-        name = segment[getn(segment)]
+        name = segment[table.getn(segment)]
         if not name then 
                 control:close()
                 return "Invalid file path" 
@@ -472,7 +472,7 @@ function Private.download(control, request, segment)
         is_directory = segment.is_directory
         content_cb = request.content_cb
         -- get remote file name
-        name = segment[getn(segment)]
+        name = segment[table.getn(segment)]
         if not name and not is_directory then 
                 control:close()
                 return "Invalid file path" 
@@ -498,7 +498,7 @@ end
 --   parsed: a table with parsed components
 -----------------------------------------------------------------------------
 function Private.parse_url(request)
-        local parsed = URL.parse_url(request.url, {
+        local parsed = socket.url.parse(request.url, {
                 host = "",
                 user = "anonymous", 
                 port = 21, 
@@ -521,9 +521,10 @@ end
 -- Returns
 --   dirs: a table with parsed directory components
 -----------------------------------------------------------------------------
-function Private.parse_path(parsed)
-        local segment = URL.parse_path(parsed.path)
-        segment.is_directory = segment.is_directory or (parsed.params == "type=d")
+function Private.parse_path(parsed_url)
+        local segment = socket.url.parse_path(parsed_url.path)
+        segment.is_directory = segment.is_directory or 
+        (parsed_url.params == "type=d")
         return segment
 end
 
@@ -560,7 +561,7 @@ end
 function Public.get_cb(request)
         local parsed = Private.parse_url(request)
         if parsed.scheme ~= "ftp" then 
-                return format("unknown scheme '%s'", parsed.scheme)
+                return string.format("unknown scheme '%s'", parsed.scheme)
         end
         local control, err = Private.open(parsed)
         if not control then return err end
@@ -586,7 +587,7 @@ end
 function Public.put_cb(request)
         local parsed = Private.parse_url(request)
         if parsed.scheme ~= "ftp" then 
-                return format("unknown scheme '%s'", parsed.scheme)
+                return string.format("unknown scheme '%s'", parsed.scheme)
         end
         local control, err = Private.open(parsed)
         if not control then return err end
@@ -612,7 +613,7 @@ end
 function Public.put(url_or_request, content)
         local request = Private.build_request(url_or_request)
         request.content_cb = function()
-                return content, strlen(content)
+                return content, string.len(content)
         end
         return Public.put_cb(request)
 end
@@ -630,7 +631,7 @@ end
 --   err: error message in case of error, nil otherwise
 -----------------------------------------------------------------------------
 function Public.get(url_or_request)
-        local cat = Concat.create()
+        local cat = socket.concat.create()
         local request = Private.build_request(url_or_request)
         request.content_cb = function(chunk, err)
                 if chunk then cat:addstring(chunk) end
diff --git a/src/http.lua b/src/http.lua
index 9543d59..3275e3b 100644
--- a/src/http.lua
+++ b/src/http.lua
@@ -8,7 +8,7 @@
 -----------------------------------------------------------------------------
 
 local Public, Private = {}, {}
-http = Public
+socket.http = Public
 
 -----------------------------------------------------------------------------
 -- Program constants
@@ -427,7 +427,7 @@ end
 -----------------------------------------------------------------------------
 function Private.authorize(request, parsed, response)
     request.headers["authorization"] = "Basic " .. 
-        Code.base64(parsed.user .. ":" .. parsed.password)
+        socket.code.base64(parsed.user .. ":" .. parsed.password)
     local authorize = {
         redirects = request.redirects,
         method = request.method,
@@ -471,7 +471,7 @@ function Private.redirect(request, response)
         method = request.method,
         -- the RFC says the redirect URL has to be absolute, but some
         -- servers do not respect that 
-        url = URL.absolute_url(request.url, response.headers["location"]),
+        url = socket.url.absolute(request.url, response.headers["location"]),
         body_cb = request.body_cb,
         headers = request.headers
     }
@@ -535,7 +535,7 @@ end
 --     error: error message, or nil if successfull
 -----------------------------------------------------------------------------
 function Public.request_cb(request, response)
-    local parsed = URL.parse_url(request.url, {
+    local parsed = socket.url.parse(request.url, {
         host = "",
         port = Public.PORT, 
         path ="/",
@@ -622,7 +622,7 @@ function Public.request(request)
             return request.body, string.len(request.body) 
         end
     end
-    local cat = Concat.create()
+    local cat = socket.concat.create()
     response.body_cb = function(chunk, err)
         if chunk then cat:addstring(chunk) end
         return 1
diff --git a/src/mbox.lua b/src/mbox.lua
index 2969111..4a72331 100644
--- a/src/mbox.lua
+++ b/src/mbox.lua
@@ -4,11 +4,11 @@ mbox = Public
 
 function Public.split_message(message_s)
     local message = {}
-    message_s = gsub(message_s, "\r\n", "\n")
-        gsub(message_s, "^(.-\n)\n", function (h) %message.headers = h end)
-        gsub(message_s, "^.-\n\n(.*)", function (b) %message.body = b end)
+    message_s = string.gsub(message_s, "\r\n", "\n")
+        string.gsub(message_s, "^(.-\n)\n", function (h) %message.headers = h end)
+        string.gsub(message_s, "^.-\n\n(.*)", function (b) %message.body = b end)
     if not message.body then
-            gsub(message_s, "^\n(.*)", function (b) %message.body = b end)
+            string.gsub(message_s, "^\n(.*)", function (b) %message.body = b end)
     end
     if not message.headers and not message.body then 
         message.headers = message_s
@@ -18,26 +18,26 @@ end
 
 function Public.split_headers(headers_s)
     local headers = {}
-    headers_s = gsub(headers_s, "\r\n", "\n")
-    headers_s = gsub(headers_s, "\n[ ]+", " ")
-    gsub("\n" .. headers_s, "\n([^\n]+)", function (h) tinsert(%headers, h) end)
+    headers_s = string.gsub(headers_s, "\r\n", "\n")
+    headers_s = string.gsub(headers_s, "\n[ ]+", " ")
+    string.gsub("\n" .. headers_s, "\n([^\n]+)", function (h) table.insert(%headers, h) end)
     return headers
 end
 
 function Public.parse_header(header_s)
-    header_s = gsub(header_s, "\n[ ]+", " ")
-    header_s = gsub(header_s, "\n+", "")
-    local _, __, name, value = strfind(header_s, "([^%s:]-):%s*(.*)")
+    header_s = string.gsub(header_s, "\n[ ]+", " ")
+    header_s = string.gsub(header_s, "\n+", "")
+    local _, __, name, value = string.find(header_s, "([^%s:]-):%s*(.*)")
     return name, value
 end
 
 function Public.parse_headers(headers_s)
     local headers_t = %Public.split_headers(headers_s)
     local headers = {}
-    for i = 1, getn(headers_t) do
+    for i = 1, table.getn(headers_t) do
         local name, value = %Public.parse_header(headers_t[i])
         if name then
-            name = strlower(name)
+            name = string.lower(name)
             if headers[name] then
                 headers[name] = headers[name] .. ", " .. value
             else headers[name] = value end
@@ -47,34 +47,34 @@ function Public.parse_headers(headers_s)
 end
 
 function Public.parse_from(from)
-    local _, __, name, address = strfind(from, "^%s*(.-)%s*%<(.-)%>")
+    local _, __, name, address = string.find(from, "^%s*(.-)%s*%<(.-)%>")
     if not address then
-        _, __, address = strfind(from, "%s*(.+)%s*")
+        _, __, address = string.find(from, "%s*(.+)%s*")
     end
     name = name or ""
     address = address or ""
     if name == "" then name = address end
-        name = gsub(name, '"', "")
+        name = string.gsub(name, '"', "")
     return name, address
 end
 
 function Public.split_mbox(mbox_s)
         mbox = {}
-        mbox_s = gsub(mbox_s, "\r\n", "\n") .."\n\nFrom \n"
+        mbox_s = string.gsub(mbox_s, "\r\n", "\n") .."\n\nFrom \n"
         local nj, i, j = 1, 1, 1
         while 1 do
-                i, nj = strfind(mbox_s, "\n\nFrom .-\n", j)
+                i, nj = string.find(mbox_s, "\n\nFrom .-\n", j)
                 if not i then break end
-                local message = strsub(mbox_s, j, i-1)
-                tinsert(mbox, message)
+                local message = string.sub(mbox_s, j, i-1)
+                table.insert(mbox, message)
                 j = nj+1
         end
         return mbox
 end
 
-function Public.parse_mbox(mbox_s)
+function Public.parse(mbox_s)
         local mbox = %Public.split_mbox(mbox_s)
-        for i = 1, getn(mbox) do
+        for i = 1, table.getn(mbox) do
                 mbox[i] = %Public.parse_message(mbox[i])
         end
         return mbox
diff --git a/src/smtp.lua b/src/smtp.lua
index 774dddb..5da9a6f 100644
--- a/src/smtp.lua
+++ b/src/smtp.lua
@@ -8,7 +8,7 @@
 -----------------------------------------------------------------------------
 
 local Public, Private = {}, {}
-SMTP = Public
+socket.smtp = Public
 
 -----------------------------------------------------------------------------
 -- Program constants
@@ -47,7 +47,7 @@ end
 -----------------------------------------------------------------------------
 function Private.try_receive(...)
     local sock = arg[1]
-    local data, err = call(sock.receive, arg)
+    local data, err = sock.receive(unpack(arg))
     if err then sock:close() end
     return data, err
 end
@@ -81,13 +81,13 @@ function Private.get_answer(control)
     local line, err = Private.try_receive(control)
     local answer = line
     if err then return nil, err end
-    _,_, code, sep = strfind(line, "^(%d%d%d)(.)")
+    _,_, code, sep = string.find(line, "^(%d%d%d)(.)")
     if not code or not sep then return nil, answer end
     if sep == "-" then -- answer is multiline
         repeat 
             line, err = Private.try_receive(control)
             if err then return nil, err end
-            _,_, lastcode, sep = strfind(line, "^(%d%d%d)(.)")
+            _,_, lastcode, sep = string.find(line, "^(%d%d%d)(.)")
             answer = answer .. "\n" .. line
         until code == lastcode and sep == " " -- answer ends with same code
     end
@@ -108,7 +108,7 @@ function Private.check_answer(control, success)
     local answer, code = Private.get_answer(control)
     if not answer then return nil, code end
     if type(success) ~= "table" then success = {success} end
-    for i = 1, getn(success) do
+    for i = 1, table.getn(success) do
         if code == success[i] then
             return code, answer
         end
@@ -157,7 +157,7 @@ end
 --   answer: complete server reply or error message
 -----------------------------------------------------------------------------
 function Private.send_mail(sock, sender)
-    local param = format("FROM:<%s>", sender or "")
+    local param = string.format("FROM:<%s>", sender or "")
     local err = Private.send_command(sock, "MAIL", param)
     if err then return nil, err end
     return Private.check_answer(sock, 250)
@@ -198,7 +198,7 @@ function Private.send_data(sock, headers, body)
     local code, answer = Private.check_answer(sock, 354)
     if not code then return nil, answer end
     -- avoid premature end in message body
-    body = gsub(body or "", "\n%.", "\n%.%.")
+    body = string.gsub(body or "", "\n%.", "\n%.%.")
     -- mark end of message body
     body = body .. "\r\n.\r\n"
     err = Private.send_headers(sock, headers)
@@ -220,8 +220,9 @@ function Private.send_rcpt(sock, rcpt)
     local err
         local code, answer = nil, "No recipient specified"
     if type(rcpt) ~= "table" then rcpt = {rcpt} end
-    for i = 1, getn(rcpt) do
-        err = Private.send_command(sock, "RCPT", format("TO:<%s>", rcpt[i]))
+    for i = 1, table.getn(rcpt) do
+        err = Private.send_command(sock, "RCPT", 
+            string.format("TO:<%s>", rcpt[i]))
         if err then return nil, err end
         code, answer = Private.check_answer(sock, {250, 251})
         if not code then return code, answer end
@@ -242,7 +243,7 @@ function Private.open(server)
         -- default server
         server = server or Public.SERVER
         -- connect to server and make sure we won't hang
-    local sock, err = connect(server, Public.PORT)
+    local sock, err = socket.connect(server, Public.PORT)
     if not sock then return nil, err end
     sock:timeout(Public.TIMEOUT)
     -- initial server greeting
diff --git a/src/url.lua b/src/url.lua
index 4d2bfa7..2cf9669 100644
--- a/src/url.lua
+++ b/src/url.lua
@@ -8,7 +8,7 @@
 ----------------------------------------------------------------------------
 
 local Public, Private = {}, {}
-URL = Public
+socket.url = Public
 
 -----------------------------------------------------------------------------
 -- Parses a url and returns a table with all its parts according to RFC 2396
@@ -28,7 +28,7 @@ URL = Public
 -- Obs:
 --   the leading '/' in {/<path>} is considered part of <path>
 -----------------------------------------------------------------------------
-function Public.parse_url(url, default)
+function Public.parse(url, default)
     -- initialize default parameters
     local parsed = default or {}
     -- empty url is parsed to nil
@@ -70,7 +70,7 @@ end
 -- Returns
 --   a stringing with the corresponding URL
 -----------------------------------------------------------------------------
-function Public.build_url(parsed)
+function Public.build(parsed)
     local url = parsed.path or ""
     if parsed.params then url = url .. ";" .. parsed.params end
     if parsed.query then url = url .. "?" .. parsed.query end
@@ -102,9 +102,9 @@ end
 -- Returns
 --   corresponding absolute url
 -----------------------------------------------------------------------------
-function Public.absolute_url(base_url, relative_url)
-    local base = Public.parse_url(base_url)
-    local relative = Public.parse_url(relative_url)
+function Public.absolute(base_url, relative_url)
+    local base = Public.parse(base_url)
+    local relative = Public.parse(relative_url)
     if not base then return relative_url
     elseif not relative then return base_url
     elseif relative.scheme then return relative_url
@@ -124,7 +124,7 @@ function Public.absolute_url(base_url, relative_url)
                 relative.path = Private.absolute_path(base.path,relative.path)
             end
         end
-        return Public.build_url(relative)
+        return Public.build(relative)
     end
 end
 
@@ -141,7 +141,7 @@ function Public.parse_path(path)
         path = string.gsub(path, "%s", "")
         string.gsub(path, "([^/]+)", function (s) table.insert(parsed, s) end)
         for i = 1, table.getn(parsed) do
-                parsed[i] = Code.unescape(parsed[i])
+                parsed[i] = socket.code.unescape(parsed[i])
         end
         if string.sub(path, 1, 1) == "/" then parsed.is_absolute = 1 end
         if string.sub(path, -1, -1) == "/" then parsed.is_directory = 1 end
@@ -201,7 +201,7 @@ function Private.protect_segment(s)
         local segment_set = Private.segment_set
         return string.gsub(s, "(%W)", function (c) 
                 if segment_set[c] then return c
-                else return Code.escape(c) end
+                else return socket.code.escape(c) end
         end)
 end