mlua-socket 0.2.7

A Rust-native implementation of LuaSocket for mlua.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191

-- https://github.com/lunarmodules/luasocket/blob/v3.1.0/src/socket.lua
-----------------------------------------------------------------------------
-- LuaSocket helper module
-- Author: Diego Nehab
-----------------------------------------------------------------------------

-----------------------------------------------------------------------------
-- Declare module and import dependencies
-----------------------------------------------------------------------------
local base = _G
local string = require("string")
local math = require("math")
local socket = require("socket.core")
local except = require("socket.except")

local _M = socket

-----------------------------------------------------------------------------
-- Exported auxiliar functions
-----------------------------------------------------------------------------
function _M.connect4(address, port, laddress, lport)
    return socket.connect(address, port, laddress, lport, "inet")
end

function _M.connect6(address, port, laddress, lport)
    return socket.connect(address, port, laddress, lport, "inet6")
end

--function _M.bind(host, port, backlog)
--    if host == "*" then
--        host = "0.0.0.0"
--    end
--    local addrinfo, err = socket.dns.getaddrinfo(host);
--    if not addrinfo then
--        return nil, err
--    end
--    local sock, res
--    err = "no info on address"
--    for i, alt in base.ipairs(addrinfo) do
--        if alt.family == "inet" then
--            sock, err = socket.tcp4()
--        else
--            sock, err = socket.tcp6()
--        end
--        if not sock then
--            return nil, err
--        end
--        sock:setoption("reuseaddr", true)
--        res, err = sock:bind(alt.addr, port)
--        if not res then
--            sock:close()
--        else
--            res, err = sock:listen(backlog)
--            if not res then
--                sock:close()
--            else
--                return sock
--            end
--        end
--    end
--    return nil, err
--end

_M.newtry = except.newtry
_M.try = _M.newtry()
_M.protect = except.protect

function _M.choose(table)
    return function(name, opt1, opt2)
        if base.type(name) ~= "string" then
            name, opt1, opt2 = "default", name, opt1
        end
        local f = table[name or "nil"]
        if not f then
            base.error("unknown key (" .. base.tostring(name) .. ")", 3)
        else
            return f(opt1, opt2)
        end
    end
end

-----------------------------------------------------------------------------
-- Socket sources and sinks, conforming to LTN12
-----------------------------------------------------------------------------
-- create namespaces inside LuaSocket namespace
local sourcet, sinkt = {}, {}
_M.sourcet = sourcet
_M.sinkt = sinkt

_M.BLOCKSIZE = 2048

sinkt["close-when-done"] = function(sock)
    return base.setmetatable({
        getfd = function()
            return sock:getfd()
        end,
        dirty = function()
            return sock:dirty()
        end
    }, {
        __call = function(self, chunk, err)
            if not chunk then
                sock:close()
                return 1
            else
                return sock:send(chunk)
            end
        end
    })
end

sinkt["keep-open"] = function(sock)
    return base.setmetatable({
        getfd = function()
            return sock:getfd()
        end,
        dirty = function()
            return sock:dirty()
        end
    }, {
        __call = function(self, chunk, err)
            if chunk then
                return sock:send(chunk)
            else
                return 1
            end
        end
    })
end

sinkt["default"] = sinkt["keep-open"]

_M.sink = _M.choose(sinkt)

sourcet["by-length"] = function(sock, length)
    return base.setmetatable({
        getfd = function()
            return sock:getfd()
        end,
        dirty = function()
            return sock:dirty()
        end
    }, {
        __call = function()
            if length <= 0 then
                return nil
            end
            local size = math.min(socket.BLOCKSIZE, length)
            local chunk, err = sock:receive(size)
            if err then
                return nil, err
            end
            length = length - string.len(chunk)
            return chunk
        end
    })
end

sourcet["until-closed"] = function(sock)
    local done
    return base.setmetatable({
        getfd = function()
            return sock:getfd()
        end,
        dirty = function()
            return sock:dirty()
        end
    }, {
        __call = function()
            if done then
                return nil
            end
            local chunk, err, partial = sock:receive(socket.BLOCKSIZE)
            if not err then
                return chunk
            elseif err == "closed" then
                sock:close()
                done = 1
                return partial
            else
                return nil, err
            end
        end
    })
end

sourcet["default"] = sourcet["until-closed"]

_M.source = _M.choose(sourcet)

return _M