4 files changed, 4 insertions, 281 deletions
diff --git a/etc/check-links-nb.lua b/etc/check-links-nb.lua
deleted file mode 100644
index c379e9a..0000000
--- a/etc/check-links-nb.lua
+++ /dev/null
@@ -1,277 +0,0 @@
-----------------------------------------------------------------------------
-- Little program that checks links in HTML files, using coroutines and
-- non-blocking I/O. Thus, faster than simpler version of same program
-- LuaSocket sample files
-- Author: Diego Nehab
-- RCS ID: $$
-----------------------------------------------------------------------------
-local socket = require("socket")
-TIMEOUT = 10
-- we need to yield across calls to protect, so we can't use pcall
-- we borrow and simplify code from coxpcall to reimplement socket.protect
-- before loading http
-function socket.protect(f)
-    return function(...)
-        local co = coroutine.create(f)
-        while true do
-            local results = {coroutine.resume(co, unpack(arg))}
-            local status = results[1]
-            table.remove(results, 1)
-            if not status then
-                return nil, results[1][1]
-            end
-            if coroutine.status(co) == "suspended" then
-                arg = {coroutine.yield(unpack(results))}
-            else
-                return unpack(results)
-            end
-        end
-    end
-end
-local http = require("socket.http")
-local url = require("socket.url")
-- creates a new set data structure
-function newset()
-    local reverse = {}
-    local set = {}
-    return setmetatable(set, {__index = {
-        insert = function(set, value)
-            if not reverse[value] then
-                table.insert(set, value)
-                reverse[value] = table.getn(set)
-            end
-        end,
-        remove = function(set, value)
-            local index = reverse[value]
-            if index then
-                reverse[value] = nil
-                local top = table.remove(set)
-                if top ~= value then 
-                    reverse[top] = index
-                    set[index] = top
-                end 
-            end
-        end
-    }}) 
-end
-local context = {}
-local sending = newset()
-local receiving = newset()
-local nthreads = 0
-- socket.tcp() replacement for non-blocking I/O
-- implements enough functionality to be used with http.request
-- in Lua 5.1, we have coroutine.running to simplify things... 
-function newcreate(thread)
-    return function()
-        -- try to create underlying socket
-        local tcp, error = socket.tcp()
-        if not tcp then return nil, error end
-        -- put it in non-blocking mode right away
-        tcp:settimeout(0)
-        local trap = { 
-            -- we ignore settimeout to preserve our 0 timeout
-            settimeout = function(self, mode, value)
-                return 1
-            end,
-            -- send in non-blocking mode and yield on timeout
-            send = function(self, data, first, last) 
-                first = (first or 1) - 1
-                local result, error
-                while true do
-                    -- tell dispatcher we want to keep sending before we
-                    -- yield control
-                    sending:insert(tcp)                   
-                    -- return control to dispatcher
-                    -- if upon return the dispatcher tells us we timed out,
-                    -- return an error to whoever called us
-                    if coroutine.yield() == "timeout" then 
-                        return nil, "timeout" 
-                    end
-                    -- mark time we started waiting
-                    context[tcp].last = socket.gettime()
-                    -- try sending
-                    result, error, first = tcp:send(data, first+1, last)
-                    -- if we are done, or there was an unexpected error, 
-                    -- break away from loop
-                    if error ~= "timeout" then return result, error, first end
-                end
-            end,
-            -- receive in non-blocking mode and yield on timeout
-            receive = function(self, pattern)
-                local error, partial = "timeout", ""
-                local value
-                while true do 
-                    -- tell dispatcher we want to keep receiving before we
-                    -- yield control
-                    receiving:insert(tcp)
-                    -- return control to dispatcher
-                    -- if upon return the dispatcher tells us we timed out,
-                    -- return an error to whoever called us
-                    if coroutine.yield() == "timeout" then 
-                        return nil, "timeout" 
-                    end
-                    -- mark time we started waiting
-                    context[tcp].last = socket.gettime()
-                    -- try receiving
-                    value, error, partial = tcp:receive(pattern, partial)
-                    -- if we are done, or there was an unexpected error, 
-                    -- break away from loop
-                    if error ~= "timeout" then return value, error, partial end
-                end
-            end,
-            -- connect in non-blocking mode and yield on timeout
-            connect = function(self, host, port)
-                local result, error = tcp:connect(host, port)
-                -- mark time we started waiting
-                context[tcp].last = socket.gettime()
-                if error == "timeout" then
-                    -- tell dispatcher we will be able to write uppon connection
-                    sending:insert(tcp)
-                    -- return control to dispatcher
-                    -- if upon return the dispatcher tells us we have a
-                    -- timeout, just abort
-                    if coroutine.yield() == "timeout" then 
-                        return nil, "timeout" 
-                    end
-                    -- when we come back, check if connection was successful
-                    result, error = tcp:connect(host, port)
-                    if result or error == "already connected" then return 1
-                    else return nil, "non-blocking connect failed" end
-                else return result, error end
-            end,
-            close = function(self)
-                context[tcp] = nil
-                return tcp:close()
-            end
-        }
-        -- add newly created socket to context
-        context[tcp] = {
-            thread = thread,
-            trap = trap
-        }
-        return trap
-    end
-end
-- get the status of a URL, non-blocking
-function getstatus(link)
-    local parsed = url.parse(link, {scheme = "file"})
-    if parsed.scheme == "http" then
-        local thread = coroutine.create(function(thread, link)
-            local r, c, h, s = http.request{
-                method = "HEAD",
-                url = link, 
-                create = newcreate(thread)
-            }
-            if c == 200 then io.write('\t', link, '\n')
-            else io.write('\t', link, ': ', c, '\n') end
-            nthreads = nthreads - 1
-        end)
-        nthreads = nthreads + 1
-        assert(coroutine.resume(thread, thread, link))
-    end
-end
-- dispatch all threads until we are done
-function dispatch()
-    while nthreads > 0 do
-        -- check which sockets are interesting and act on them
-        local readable, writable = socket.select(receiving, sending, 1)
-        -- for all readable connections, resume their threads
-        for _, who in ipairs(readable) do
-            if context[who] then
-                receiving:remove(who)
-                assert(coroutine.resume(context[who].thread))
-            end
-        end
-        -- for all writable connections, do the same
-        for _, who in ipairs(writable) do
-            if context[who] then
-                sending:remove(who)
-                assert(coroutine.resume(context[who].thread))
-            end
-        end
-        -- politely ask replacement I/O functions in idle threads to 
-        -- return reporting a timeout
-        local now = socket.gettime()
-        for who, data in pairs(context) do
-            if  data.last and now - data.last > TIMEOUT then
-                sending:remove(who)
-                receiving:remove(who)
-                assert(coroutine.resume(context[who].thread, "timeout"))
-            end
-        end
-    end
-end
-function readfile(path)
-    path = url.unescape(path)
-    local file, error = io.open(path, "r")
-    if file then
-        local body = file:read("*a")
-        file:close()
-        return body
-    else return nil, error end
-end
-function load(u)
-    local parsed = url.parse(u, { scheme = "file" })
-    local body, headers, code, error
-    local base = u
-    if parsed.scheme == "http" then
-        body, code, headers = http.request(u)
-        if code == 200 then
-            -- if there was a redirect, update base to reflect it
-            base = headers.location or base
-        end
-        if not body then
-            error = code
-        end
-    elseif parsed.scheme == "file" then
-        body, error = readfile(parsed.path)
-    else error = string.format("unhandled scheme '%s'", parsed.scheme) end
-    return base, body, error
-end
-function getlinks(body, base)
-    -- get rid of comments
-    body = string.gsub(body, "%<%!%-%-.-%-%-%>", "")
-    local links = {}
-    -- extract links
-    body = string.gsub(body, '[Hh][Rr][Ee][Ff]%s*=%s*"([^"]*)"', function(href)
-        table.insert(links, url.absolute(base, href))
-    end)
-    body = string.gsub(body, "[Hh][Rr][Ee][Ff]%s*=%s*'([^']*)'", function(href)
-        table.insert(links, url.absolute(base, href))
-    end)
-    string.gsub(body, "[Hh][Rr][Ee][Ff]%s*=%s*(.-)>", function(href)
-        table.insert(links, url.absolute(base, href))
-    end)
-    return links
-end
-function checklinks(address)
-    local base, body, error = load(address)
-    if not body then print(error) return end
-    print("Checking ", base)
-    local links = getlinks(body, base)
-    for _, link in ipairs(links) do
-        getstatus(link)
-    end
-end
-arg = arg or {}
-if table.getn(arg) < 1 then
-    print("Usage:\n  luasocket check-links.lua {<url>}")
-    exit()
-end
-for _, address in ipairs(arg) do
-    checklinks(url.absolute("file:", address))
-end
-dispatch()
diff --git a/etc/check-links.lua b/etc/check-links.lua
index 725cd2a..5c124a8 100644
--- a/etc/check-links.lua
+++ b/etc/check-links.lua
@@ -5,7 +5,7 @@
 -- Author: Diego Nehab
 -- RCS ID: $$
 -----------------------------------------------------------------------------
-local url = require("socket.url")
+local url = require("url")
 local dispatch = require("dispatch")
 local http = require("socket.http")
 dispatch.TIMEOUT = 10
diff --git a/etc/check-memory.lua b/etc/check-memory.lua
index 7892ba0..7bcdf67 100644
--- a/etc/check-memory.lua
+++ b/etc/check-memory.lua
@@ -7,9 +7,9 @@ function load(s)
    print(s .. ":\t " .. (b-a) .. "k")
 end
-load("socket")
+load("url")
-load("socket.url")
 load("ltn12")
+load("socket")
 load("mime")
 load("socket.tp")
 load("socket.smtp")
diff --git a/etc/get.lua b/etc/get.lua
index 0c95d54..bd5af28 100644
--- a/etc/get.lua
+++ b/etc/get.lua
@@ -7,7 +7,7 @@
 local socket = require("socket")
 local http = require("socket.http")
 local ftp = require("socket.ftp")
-local url = require("socket.url")
+local url = require("url")
 local ltn12 = require("ltn12")
 -- formats a number of seconds into human readable form

diff --git a/etc/check-links-nb.lua b/etc/check-links-nb.lua deleted file mode 100644 index c379e9a..0000000 --- a/etc/check-links-nb.lua +++ /dev/null
@@ -1,277 +0,0 @@
1	-----------------------------------------------------------------------------
2	-- Little program that checks links in HTML files, using coroutines and
3	-- non-blocking I/O. Thus, faster than simpler version of same program
4	-- LuaSocket sample files
5	-- Author: Diego Nehab
6	-- RCS ID: $$
7	-----------------------------------------------------------------------------
8	local socket = require("socket")
9
10	TIMEOUT = 10
11
12	-- we need to yield across calls to protect, so we can't use pcall
13	-- we borrow and simplify code from coxpcall to reimplement socket.protect
14	-- before loading http
15	function socket.protect(f)
16	return function(...)
17	local co = coroutine.create(f)
18	while true do
19	local results = {coroutine.resume(co, unpack(arg))}
20	local status = results[1]
21	table.remove(results, 1)
22	if not status then
23	return nil, results[1][1]
24	end
25	if coroutine.status(co) == "suspended" then
26	arg = {coroutine.yield(unpack(results))}
27	else
28	return unpack(results)
29	end
30	end
31	end
32	end
33
34	local http = require("socket.http")
35	local url = require("socket.url")
36
37	-- creates a new set data structure
38	function newset()
39	local reverse = {}
40	local set = {}
41	return setmetatable(set, {__index = {
42	insert = function(set, value)
43	if not reverse[value] then
44	table.insert(set, value)
45	reverse[value] = table.getn(set)
46	end
47	end,
48	remove = function(set, value)
49	local index = reverse[value]
50	if index then
51	reverse[value] = nil
52	local top = table.remove(set)
53	if top ~= value then
54	reverse[top] = index
55	set[index] = top
56	end
57	end
58	end
59	}})
60	end
61
62	local context = {}
63	local sending = newset()
64	local receiving = newset()
65	local nthreads = 0
66
67	-- socket.tcp() replacement for non-blocking I/O
68	-- implements enough functionality to be used with http.request
69	-- in Lua 5.1, we have coroutine.running to simplify things...
70	function newcreate(thread)
71	return function()
72	-- try to create underlying socket
73	local tcp, error = socket.tcp()
74	if not tcp then return nil, error end
75	-- put it in non-blocking mode right away
76	tcp:settimeout(0)
77	local trap = {
78	-- we ignore settimeout to preserve our 0 timeout
79	settimeout = function(self, mode, value)
80	return 1
81	end,
82	-- send in non-blocking mode and yield on timeout
83	send = function(self, data, first, last)
84	first = (first or 1) - 1
85	local result, error
86	while true do
87	-- tell dispatcher we want to keep sending before we
88	-- yield control
89	sending:insert(tcp)
90	-- return control to dispatcher
91	-- if upon return the dispatcher tells us we timed out,
92	-- return an error to whoever called us
93	if coroutine.yield() == "timeout" then
94	return nil, "timeout"
95	end
96	-- mark time we started waiting
97	context[tcp].last = socket.gettime()
98	-- try sending
99	result, error, first = tcp:send(data, first+1, last)
100	-- if we are done, or there was an unexpected error,
101	-- break away from loop
102	if error ~= "timeout" then return result, error, first end
103	end
104	end,
105	-- receive in non-blocking mode and yield on timeout
106	receive = function(self, pattern)
107	local error, partial = "timeout", ""
108	local value
109	while true do
110	-- tell dispatcher we want to keep receiving before we
111	-- yield control
112	receiving:insert(tcp)
113	-- return control to dispatcher
114	-- if upon return the dispatcher tells us we timed out,
115	-- return an error to whoever called us
116	if coroutine.yield() == "timeout" then
117	return nil, "timeout"
118	end
119	-- mark time we started waiting
120	context[tcp].last = socket.gettime()
121	-- try receiving
122	value, error, partial = tcp:receive(pattern, partial)
123	-- if we are done, or there was an unexpected error,
124	-- break away from loop
125	if error ~= "timeout" then return value, error, partial end
126	end
127	end,
128	-- connect in non-blocking mode and yield on timeout
129	connect = function(self, host, port)
130	local result, error = tcp:connect(host, port)
131	-- mark time we started waiting
132	context[tcp].last = socket.gettime()
133	if error == "timeout" then
134	-- tell dispatcher we will be able to write uppon connection
135	sending:insert(tcp)
136	-- return control to dispatcher
137	-- if upon return the dispatcher tells us we have a
138	-- timeout, just abort
139	if coroutine.yield() == "timeout" then
140	return nil, "timeout"
141	end
142	-- when we come back, check if connection was successful
143	result, error = tcp:connect(host, port)
144	if result or error == "already connected" then return 1
145	else return nil, "non-blocking connect failed" end
146	else return result, error end
147	end,
148	close = function(self)
149	context[tcp] = nil
150	return tcp:close()
151	end
152	}
153	-- add newly created socket to context
154	context[tcp] = {
155	thread = thread,
156	trap = trap
157	}
158	return trap
159	end
160	end
161
162	-- get the status of a URL, non-blocking
163	function getstatus(link)
164	local parsed = url.parse(link, {scheme = "file"})
165	if parsed.scheme == "http" then
166	local thread = coroutine.create(function(thread, link)
167	local r, c, h, s = http.request{
168	method = "HEAD",
169	url = link,
170	create = newcreate(thread)
171	}
172	if c == 200 then io.write('\t', link, '\n')
173	else io.write('\t', link, ': ', c, '\n') end
174	nthreads = nthreads - 1
175	end)
176	nthreads = nthreads + 1
177	assert(coroutine.resume(thread, thread, link))
178	end
179	end
180
181	-- dispatch all threads until we are done
182	function dispatch()
183	while nthreads > 0 do
184	-- check which sockets are interesting and act on them
185	local readable, writable = socket.select(receiving, sending, 1)
186	-- for all readable connections, resume their threads
187	for _, who in ipairs(readable) do
188	if context[who] then
189	receiving:remove(who)
190	assert(coroutine.resume(context[who].thread))
191	end
192	end
193	-- for all writable connections, do the same
194	for _, who in ipairs(writable) do
195	if context[who] then
196	sending:remove(who)
197	assert(coroutine.resume(context[who].thread))
198	end
199	end
200	-- politely ask replacement I/O functions in idle threads to
201	-- return reporting a timeout
202	local now = socket.gettime()
203	for who, data in pairs(context) do
204	if data.last and now - data.last > TIMEOUT then
205	sending:remove(who)
206	receiving:remove(who)
207	assert(coroutine.resume(context[who].thread, "timeout"))
208	end
209	end
210	end
211	end
212
213	function readfile(path)
214	path = url.unescape(path)
215	local file, error = io.open(path, "r")
216	if file then
217	local body = file:read("*a")
218	file:close()
219	return body
220	else return nil, error end
221	end
222
223	function load(u)
224	local parsed = url.parse(u, { scheme = "file" })
225	local body, headers, code, error
226	local base = u
227	if parsed.scheme == "http" then
228	body, code, headers = http.request(u)
229	if code == 200 then
230	-- if there was a redirect, update base to reflect it
231	base = headers.location or base
232	end
233	if not body then
234	error = code
235	end
236	elseif parsed.scheme == "file" then
237	body, error = readfile(parsed.path)
238	else error = string.format("unhandled scheme '%s'", parsed.scheme) end
239	return base, body, error
240	end
241
242	function getlinks(body, base)
243	-- get rid of comments
244	body = string.gsub(body, "%<%!%-%-.-%-%-%>", "")
245	local links = {}
246	-- extract links
247	body = string.gsub(body, '[Hh][Rr][Ee][Ff]%s=%s"([^"]*)"', function(href)
248	table.insert(links, url.absolute(base, href))
249	end)
250	body = string.gsub(body, "[Hh][Rr][Ee][Ff]%s=%s'([^']*)'", function(href)
251	table.insert(links, url.absolute(base, href))
252	end)
253	string.gsub(body, "[Hh][Rr][Ee][Ff]%s=%s(.-)>", function(href)
254	table.insert(links, url.absolute(base, href))
255	end)
256	return links
257	end
258
259	function checklinks(address)
260	local base, body, error = load(address)
261	if not body then print(error) return end
262	print("Checking ", base)
263	local links = getlinks(body, base)
264	for _, link in ipairs(links) do
265	getstatus(link)
266	end
267	end
268
269	arg = arg or {}
270	if table.getn(arg) < 1 then
271	print("Usage:\n luasocket check-links.lua {<url>}")
272	exit()
273	end
274	for _, address in ipairs(arg) do
275	checklinks(url.absolute("file:", address))
276	end
277	dispatch()


diff --git a/etc/check-links.lua b/etc/check-links.lua index 725cd2a..5c124a8 100644 --- a/etc/check-links.lua +++ b/etc/check-links.lua
@@ -5,7 +5,7 @@
5	-- Author: Diego Nehab	5	-- Author: Diego Nehab
6	-- RCS ID: $$	6	-- RCS ID: $$
7	-----------------------------------------------------------------------------	7	-----------------------------------------------------------------------------
8	local url = require("socket.url")	8	local url = require("url")
9	local dispatch = require("dispatch")	9	local dispatch = require("dispatch")
10	local http = require("socket.http")	10	local http = require("socket.http")
11	dispatch.TIMEOUT = 10	11	dispatch.TIMEOUT = 10


diff --git a/etc/check-memory.lua b/etc/check-memory.lua index 7892ba0..7bcdf67 100644 --- a/etc/check-memory.lua +++ b/etc/check-memory.lua
@@ -7,9 +7,9 @@ function load(s)
7	print(s .. ":\t " .. (b-a) .. "k")	7	print(s .. ":\t " .. (b-a) .. "k")
8	end	8	end
9		9
10	load("socket")	10	load("url")
11	load("socket.url")
12	load("ltn12")	11	load("ltn12")
		12	load("socket")
13	load("mime")	13	load("mime")
14	load("socket.tp")	14	load("socket.tp")
15	load("socket.smtp")	15	load("socket.smtp")


diff --git a/etc/get.lua b/etc/get.lua index 0c95d54..bd5af28 100644 --- a/etc/get.lua +++ b/etc/get.lua
@@ -7,7 +7,7 @@
7	local socket = require("socket")	7	local socket = require("socket")
8	local http = require("socket.http")	8	local http = require("socket.http")
9	local ftp = require("socket.ftp")	9	local ftp = require("socket.ftp")
10	local url = require("socket.url")	10	local url = require("url")
11	local ltn12 = require("ltn12")	11	local ltn12 = require("ltn12")
12		12
13	-- formats a number of seconds into human readable form	13	-- formats a number of seconds into human readable form