#37 使用uri库

22 files changed, 1818 insertions, 48 deletions

diff --git a/server/src/3rd/lua-uri/uri.lua b/server/src/3rd/lua-uri/uri.lua
new file mode 100644
index 00000000..395edcd9
--- /dev/null
+++ b/server/src/3rd/lua-uri/uri.lua
@@ -0,0 +1,504 @@
+local M = { _NAME = "uri", VERSION = "1.0" }
+M.__index = M
+
+local Util = require "uri._util"
+
+local _UNRESERVED = "A-Za-z0-9%-._~"
+local _GEN_DELIMS = ":/?#%[%]@"
+local _SUB_DELIMS = "!$&'()*+,;="
+local _RESERVED = _GEN_DELIMS .. _SUB_DELIMS
+local _USERINFO = "^[" .. _UNRESERVED .. "%%" .. _SUB_DELIMS .. ":]*$"
+local _REG_NAME = "^[" .. _UNRESERVED .. "%%" .. _SUB_DELIMS .. "]*$"
+local _IP_FUTURE_LITERAL = "^v[0-9A-Fa-f]+%." ..
+                           "[" .. _UNRESERVED .. _SUB_DELIMS .. "]+$"
+local _QUERY_OR_FRAG = "^[" .. _UNRESERVED .. "%%" .. _SUB_DELIMS .. ":@/?]*$"
+local _PATH_CHARS = "^[" .. _UNRESERVED .. "%%" .. _SUB_DELIMS .. ":@/]*$"
+
+local function _normalize_percent_encoding (s)
+    if s:find("%%$") or s:find("%%.$") then
+        error("unfinished percent encoding at end of URI '" .. s .. "'")
+    end
+
+    return s:gsub("%%(..)", function (hex)
+        if not hex:find("^[0-9A-Fa-f][0-9A-Fa-f]$") then
+            error("invalid percent encoding '%" .. hex ..
+                  "' in URI '" .. s .. "'")
+        end
+
+        -- Never percent-encode unreserved characters, and always use uppercase
+        -- hexadecimal for percent encoding.  RFC 3986 section 6.2.2.2.
+        local char = string.char(tonumber("0x" .. hex))
+        return char:find("^[" .. _UNRESERVED .. "]") and char or "%" .. hex:upper()
+    end)
+end
+
+local function _is_ip4_literal (s)
+    if not s:find("^[0-9]+%.[0-9]+%.[0-9]+%.[0-9]+$") then return false end
+
+    for dec_octet in s:gmatch("[0-9]+") do
+        if dec_octet:len() > 3 or dec_octet:find("^0.") or
+           tonumber(dec_octet) > 255 then
+            return false
+        end
+    end
+
+    return true
+end
+
+local function _is_ip6_literal (s)
+    local had_elipsis = false       -- true when '::' found
+    local num_chunks = 0
+    while s ~= "" do
+        num_chunks = num_chunks + 1
+        local p1, p2 = s:find("::?")
+        local chunk
+        if p1 then
+            chunk = s:sub(1, p1 - 1)
+            s = s:sub(p2 + 1)
+            if p2 ~= p1 then    -- found '::'
+                if had_elipsis then return false end    -- two of '::'
+                had_elipsis = true
+                if chunk == "" then num_chunks = num_chunks - 1 end
+            else
+                if chunk == "" then return false end    -- ':' at start
+                if s == "" then return false end        -- ':' at end
+            end
+        else
+            chunk = s
+            s = ""
+        end
+
+        -- Chunk is neither 4-digit hex num, nor IPv4address in last chunk.
+        if (not chunk:find("^[0-9a-f]+$") or chunk:len() > 4) and
+           (s ~= "" or not _is_ip4_literal(chunk)) and
+           chunk ~= "" then
+            return false
+        end
+
+        -- IPv4address in last position counts for two chunks of hex digits.
+        if chunk:len() > 4 then num_chunks = num_chunks + 1 end
+    end
+
+    if had_elipsis then
+        if num_chunks > 7 then return false end
+    else
+        if num_chunks ~= 8 then return false end
+    end
+
+    return true
+end
+
+local function _is_valid_host (host)
+    if host:find("^%[.*%]$") then
+        local ip_literal = host:sub(2, -2)
+        if ip_literal:find("^v") then
+            if not ip_literal:find(_IP_FUTURE_LITERAL) then
+                return "invalid IPvFuture literal '" .. ip_literal .. "'"
+            end
+        else
+            if not _is_ip6_literal(ip_literal) then
+                return "invalid IPv6 address '" .. ip_literal .. "'"
+            end
+        end
+    elseif not _is_ip4_literal(host) and not host:find(_REG_NAME) then
+        return "invalid host value '" .. host .. "'"
+    end
+
+    return nil
+end
+
+local function _normalize_and_check_path (s, normalize)
+    if not s:find(_PATH_CHARS) then return false end
+    if not normalize then return s end
+
+    -- Remove unnecessary percent encoding for path values.
+    -- TODO - I think this should be HTTP-specific (probably file also).
+    --s = Util.uri_decode(s, _SUB_DELIMS .. ":@")
+
+    return Util.remove_dot_segments(s)
+end
+
+function M.new (class, uri, base)
+    if not uri then error("usage: URI:new(uristring, [baseuri])") end
+    if type(uri) ~= "string" then uri = tostring(uri) end
+
+    if base then
+        local uri, err = M.new(class, uri)
+        if not uri then return nil, err end
+        if type(base) ~= "table" then
+            base, err = M.new(class, base)
+            if not base then return nil, "error parsing base URI: " .. err end
+        end
+        if base:is_relative() then return nil, "base URI must be absolute" end
+        local ok, err = pcall(uri.resolve, uri, base)
+        if not ok then return nil, err end
+        return uri
+    end
+
+    local s = _normalize_percent_encoding(uri)
+
+    local _, p
+    local scheme, authority, userinfo, host, port, path, query, fragment
+
+    _, p, scheme = s:find("^([a-zA-Z][-+.a-zA-Z0-9]*):")
+    if scheme then
+        scheme = scheme:lower()
+        s = s:sub(p + 1)
+    end
+
+    _, p, authority = s:find("^//([^/?#]*)")
+    if authority then
+        s = s:sub(p + 1)
+
+        _, p, userinfo = authority:find("^([^@]*)@")
+        if userinfo then
+            if not userinfo:find(_USERINFO) then
+                return nil, "invalid userinfo value '" .. userinfo .. "'"
+            end
+            authority = authority:sub(p + 1)
+        end
+
+        p, _, port = authority:find(":([0-9]*)$")
+        if port then
+            port = (port ~= "") and tonumber(port) or nil
+            authority = authority:sub(1, p - 1)
+        end
+
+        host = authority:lower()
+        local err = _is_valid_host(host)
+        if err then return nil, err end
+    end
+
+    _, p, path = s:find("^([^?#]*)")
+    if path ~= "" then
+        local normpath = _normalize_and_check_path(path, scheme)
+        if not normpath then return nil, "invalid path '" .. path .. "'" end
+        path = normpath
+        s = s:sub(p + 1)
+    end
+
+    _, p, query = s:find("^%?([^#]*)")
+    if query then
+        s = s:sub(p + 1)
+        if not query:find(_QUERY_OR_FRAG) then
+            return nil, "invalid query value '?" .. query .. "'"
+        end
+    end
+
+    _, p, fragment = s:find("^#(.*)")
+    if fragment then
+        if not fragment:find(_QUERY_OR_FRAG) then
+            return nil, "invalid fragment value '#" .. fragment .. "'"
+        end
+    end
+
+    local o = {
+        _scheme = scheme,
+        _userinfo = userinfo,
+        _host = host,
+        _port = port,
+        _path = path,
+        _query = query,
+        _fragment = fragment,
+    }
+    setmetatable(o, scheme and class or (require "uri._relative"))
+
+    return o:init()
+end
+
+function M.uri (self, ...)
+    local uri = self._uri
+
+    if not uri then
+        local scheme = self:scheme()
+        if scheme then
+            uri = scheme .. ":"
+        else
+            uri = ""
+        end
+
+        local host, port, userinfo = self:host(), self._port, self:userinfo()
+        if host or port or userinfo then
+            uri = uri .. "//"
+            if userinfo then uri = uri .. userinfo .. "@" end
+            if host then uri = uri .. host end
+            if port then uri = uri .. ":" .. port end
+        end
+
+        local path = self:path()
+        if uri == "" and path:find("^[^/]*:") then
+            path = "./" .. path
+        end
+
+        uri = uri .. path
+        if self:query() then uri = uri .. "?" .. self:query() end
+        if self:fragment() then uri = uri .. "#" .. self:fragment() end
+
+        self._uri = uri     -- cache
+    end
+
+    if select("#", ...) > 0 then
+        local new = ...
+        if not new then error("URI can't be set to nil") end
+        local newuri, err = M:new(new)
+        if not newuri then
+            error("new URI string is invalid (" .. err .. ")")
+        end
+        setmetatable(self, getmetatable(newuri))
+        for k in pairs(self) do self[k] = nil end
+        for k, v in pairs(newuri) do self[k] = v end
+    end
+
+    return uri
+end
+
+function M.__tostring (self) return self:uri() end
+
+function M.eq (a, b)
+    if type(a) == "string" then a = assert(M:new(a)) end
+    if type(b) == "string" then b = assert(M:new(b)) end
+    return a:uri() == b:uri()
+end
+
+function M.scheme (self, ...)
+    local old = self._scheme
+
+    if select("#", ...) > 0 then
+        local new = ...
+        if not new then error("can't remove scheme from absolute URI") end
+        if type(new) ~= "string" then new = tostring(new) end
+        if not new:find("^[a-zA-Z][-+.a-zA-Z0-9]*$") then
+            error("invalid scheme '" .. new .. "'")
+        end
+        Util.do_class_changing_change(self, M, "scheme", new,
+                                      function (uri, new) uri._scheme = new end)
+    end
+
+    return old
+end
+
+function M.userinfo (self, ...)
+    local old = self._userinfo
+
+    if select("#", ...) > 0 then
+        local new = ...
+        if new then
+            if not new:find(_USERINFO) then
+                error("invalid userinfo value '" .. new .. "'")
+            end
+            new = _normalize_percent_encoding(new)
+        end
+        self._userinfo = new
+        if new and not self._host then self._host = "" end
+        self._uri = nil
+    end
+
+    return old
+end
+
+function M.host (self, ...)
+    local old = self._host
+
+    if select("#", ...) > 0 then
+        local new = ...
+        if new then
+            new = tostring(new):lower()
+            local err = _is_valid_host(new)
+            if err then error(err) end
+        else
+            if self._userinfo or self._port then
+                error("there must be a host if there is a userinfo or port," ..
+                      " although it can be the empty string")
+            end
+        end
+        self._host = new
+        self._uri = nil
+    end
+
+    return old
+end
+
+function M.port (self, ...)
+    local old = self._port or self:default_port()
+
+    if select("#", ...) > 0 then
+        local new = ...
+        if new then
+            if type(new) == "string" then new = tonumber(new) end
+            if new < 0 then error("port number must not be negative") end
+            local newint = new - new % 1
+            if newint ~= new then error("port number not integer") end
+            if new == self:default_port() then new = nil end
+        end
+        self._port = new
+        if new and not self._host then self._host = "" end
+        self._uri = nil
+    end
+
+    return old
+end
+
+function M.path (self, ...)
+    local old = self._path
+
+    if select("#", ...) > 0 then
+        local new = ... or ""
+        new = _normalize_percent_encoding(new)
+        new = Util.uri_encode(new, "^A-Za-z0-9%-._~%%!$&'()*+,;=:@/")
+        if self._host then
+            if new ~= "" and not new:find("^/") then
+                error("path must begin with '/' when there is an authority")
+            end
+        else
+            if new:find("^//") then new = "/%2F" .. new:sub(3) end
+        end
+        self._path = new
+        self._uri = nil
+    end
+
+    return old
+end
+
+function M.query (self, ...)
+    local old = self._query
+
+    if select("#", ...) > 0 then
+        local new = ...
+        if new then
+            new = Util.uri_encode(new, "^" .. _UNRESERVED .. "%%" .. _SUB_DELIMS .. ":@/?")
+        end
+        self._query = new
+        self._uri = nil
+    end
+
+    return old
+end
+
+function M.fragment (self, ...)
+    local old = self._fragment
+
+    if select("#", ...) > 0 then
+        local new = ...
+        if new then
+            new = Util.uri_encode(new, "^" .. _UNRESERVED .. "%%" .. _SUB_DELIMS .. ":@/?")
+        end
+        self._fragment = new
+        self._uri = nil
+    end
+
+    return old
+end
+
+function M.init (self)
+    local scheme_class
+        = Util.attempt_require("uri." .. self._scheme:gsub("[-+.]", "_"))
+    if scheme_class then
+        setmetatable(self, scheme_class)
+        if self._port and self._port == self:default_port() then
+            self._port = nil
+        end
+        -- Call the subclass 'init' method, if it has its own.
+        if scheme_class ~= M and self.init ~= M.init then
+            return self:init()
+        end
+    end
+    return self
+end
+
+function M.default_port () return nil end
+function M.is_relative () return false end
+function M.resolve () end   -- only does anything in uri._relative
+
+-- TODO - there should probably be an option or something allowing you to
+-- choose between making a link relative whenever possible (always using a
+-- relative path if the scheme and authority are the same as the base URI) or
+-- just using a relative reference to make the link as small as possible, which
+-- might meaning using a path of '/' instead if '../../../' or whatever.
+-- This method's algorithm is loosely based on the one described here:
+--    http://lists.w3.org/Archives/Public/uri/2007Sep/0003.html
+function M.relativize (self, base)
+    if type(base) == "string" then base = assert(M:new(base)) end
+
+    -- Leave it alone if we can't a relative URI, or if it would be a network
+    -- path reference.
+    if self._scheme ~= base._scheme or self._host ~= base._host or
+       self._port ~= base._port or self._userinfo ~= base._userinfo then
+        return
+    end
+
+    local basepath = base._path
+    local oldpath = self._path
+    -- This is to avoid trying to make a URN or something relative, which
+    -- is likely to lead to grief.
+    if not basepath:find("^/") or not oldpath:find("^/") then return end
+
+    -- Turn it into a relative reference.
+    self._uri = nil
+    self._scheme = nil
+    self._host = nil
+    self._port = nil
+    self._userinfo = nil
+    setmetatable(self, require "uri._relative")
+
+    -- Use empty path if the path in the base URI is already correct.
+    if oldpath == basepath then
+        if self._query or not base._query then
+            self._path = ""
+        else
+            -- An empty URI reference leaves the query string in the base URI
+            -- unchanged, so to get a result with no query part we have to
+            -- have something in the relative path.
+            local _, _, lastseg = oldpath:find("/([^/]+)$")
+            if lastseg and lastseg:find(":") then lastseg = "./" .. lastseg end
+            self._path = lastseg or "."
+        end
+        return
+    end
+
+    if oldpath == "/" or basepath == "/" then return end
+
+    local basesegs = Util.split("/", basepath:sub(2))
+    local oldsegs = Util.split("/", oldpath:sub(2))
+
+    if oldsegs[1] ~= basesegs[1] then return end
+
+    table.remove(basesegs)
+
+    while #oldsegs > 1 and #basesegs > 0 and oldsegs[1] == basesegs[1] do
+        table.remove(oldsegs, 1)
+        table.remove(basesegs, 1)
+    end
+
+    local path_naked = true
+    local newpath = ""
+    while #basesegs > 0 do
+        table.remove(basesegs, 1)
+        newpath = newpath .. "../"
+        path_naked = false
+    end
+
+    if path_naked and #oldsegs == 1 and oldsegs[1] == "" then
+        newpath = "./"
+        table.remove(oldsegs)
+    end
+
+    while #oldsegs > 0 do
+        if path_naked then
+            if oldsegs[1]:find(":") then
+                newpath = newpath .. "./"
+            elseif #oldsegs > 1 and oldsegs[1] == "" and oldsegs[2] == "" then
+                newpath = newpath .. "/."
+            end
+        end
+
+        newpath = newpath .. oldsegs[1]
+        path_naked = false
+        table.remove(oldsegs, 1)
+        if #oldsegs > 0 then newpath = newpath .. "/" end
+    end
+
+    self._path = newpath
+end
+
+return M
+-- vi:ts=4 sw=4 expandtab
diff --git a/server/src/3rd/lua-uri/uri/_login.lua b/server/src/3rd/lua-uri/uri/_login.lua
new file mode 100644
index 00000000..4e9e6844
--- /dev/null
+++ b/server/src/3rd/lua-uri/uri/_login.lua
@@ -0,0 +1,96 @@
+local M = { _NAME = "uri._login" }
+local Util = require "uri._util"
+local URI = require "uri"
+Util.subclass_of(M, URI)
+
+-- Generic terminal logins.  This is used as a base class for 'telnet' and
+-- 'ftp' URL schemes.
+
+local function _valid_userinfo (userinfo)
+    if userinfo then
+        local colon = userinfo:find(":")
+        if colon and userinfo:find(":", colon + 1) then
+            return nil, "only one colon allowed in userinfo"
+        end
+    end
+    return true
+end
+
+-- TODO - this is a bit of a hack because currently subclasses are required
+-- to know whether their superclass has one of these that needs calling.
+-- It should be called from 'init' before anything more specific is done,
+-- and it has the same calling convention.
+-- According to RFC 1738 there should be at most one colon in the userinfo.
+-- I apply that restriction for schemes where it's used for a username/password
+-- pair.
+function M.init_base (self)
+    local host = self:host()
+    if not host or host == "" then
+        return nil, "host missing from login URI"
+    end
+
+    local ok, err = _valid_userinfo(self:userinfo())
+    if not ok then return nil, err end
+
+    return self
+end
+
+function M.userinfo (self, ...)
+    if select("#", ...) > 0 then
+        local ok, err = _valid_userinfo(...)
+        if not ok then error("invalid userinfo value (" .. err .. ")") end
+    end
+    return M._SUPER.userinfo(self, ...)
+end
+
+function M.username (self, ...)
+    local info = M._SUPER.userinfo(self)
+    local old, colon
+    if info then
+        local colon = info and info:find(":")
+        old = colon and info:sub(1, colon - 1) or info
+        old = Util.uri_decode(old)
+    end
+
+    if select('#', ...) > 0 then
+        local pass = colon and info:sub(colon) or ""    -- includes colon
+        local new = ...
+        if not new then
+            M._SUPER.userinfo(self, nil)
+        else
+            -- Escape anything that's not allowed in a userinfo, and also
+            -- colon, because that indicates the end of the username.
+            new = Util.uri_encode(new, "^A-Za-z0-9%-._~!$&'()*+,;=")
+            M._SUPER.userinfo(self, new .. pass)
+        end
+    end
+
+    return old
+end
+
+function M.password (self, ...)
+    local info = M._SUPER.userinfo(self)
+    local old, colon
+    if info then
+        colon = info and info:find(":")
+        old = colon and info:sub(colon + 1) or nil
+        if old then old = Util.uri_decode(old) end
+    end
+
+    if select('#', ...) > 0 then
+        local new = ...
+        local user = colon and info:sub(1, colon - 1) or info
+        if not new then
+            M._SUPER.userinfo(self, user)
+        else
+            if not user then user = "" end
+            new = Util.uri_encode(new, "^A-Za-z0-9%-._~!$&'()*+,;=")
+            M._SUPER.userinfo(self, user .. ":" .. new)
+        end
+    end
+
+    return old
+end
+
+return M
+-- vi:ts=4 sw=4 expandtab
diff --git a/server/src/3rd/lua-uri/uri/_relative.lua b/server/src/3rd/lua-uri/uri/_relative.lua
new file mode 100644
index 00000000..8cd53ca7
--- /dev/null
+++ b/server/src/3rd/lua-uri/uri/_relative.lua
@@ -0,0 +1,81 @@
+local M = { _NAME = "uri._relative" }
+local Util = require "uri._util"
+local URI = require "uri"
+Util.subclass_of(M, URI)
+
+-- There needs to be an 'init' method in this class, to because the base-class
+-- one expects there to be a 'scheme' value.
+function M.init (self)
+    return self
+end
+
+function M.scheme (self, ...)
+    if select("#", ...) > 0 then
+        error("relative URI references can't have a scheme, perhaps you" ..
+              " need to resolve this against an absolute URI instead")
+    end
+    return nil
+end
+
+function M.is_relative () return true end
+
+-- This implements the algorithm from RFC 3986 section 5.2.3
+-- Note that this takes an additional argument which appears to be required
+-- by the algorithm, but isn't shown when it is used in the RFC.
+local function _merge_paths (base, r, base_has_auth)
+    if base_has_auth and base == "" then
+        return "/" .. r
+    end
+
+    return base:gsub("[^/]+$", "", 1) .. r
+end
+
+local function _do_resolve (self, base)
+    if type(base) == "string" then base = assert(URI:new(base)) end
+    setmetatable(self, URI)
+
+    if self:host() or self:userinfo() or self:port() then
+        -- network path reference, just needs a scheme
+        self:path(Util.remove_dot_segments(self:path()))
+        self:scheme(base:scheme())
+        return
+    end
+
+    local path = self:path()
+    if path == "" then
+        self:path(base:path())
+        if not self:query() then self:query(base:query()) end
+    else
+        if path:find("^/") then
+            self:path(Util.remove_dot_segments(path))
+        else
+            local base_has_auth = base:host() or base:userinfo() or base:port()
+            local merged = _merge_paths(base:path(), path, base_has_auth)
+            self:path(Util.remove_dot_segments(merged))
+        end
+    end
+    self:host(base:host())
+    self:userinfo(base:userinfo())
+    self:port(base:port())
+    self:scheme(base:scheme())
+end
+
+function M.resolve (self, base)
+    local orig = tostring(self)
+    local ok, result = pcall(_do_resolve, self, base)
+    if ok then return end
+
+    -- If the resolving causes an exception, it means that the resulting URI
+    -- would be invalid, so we restore self to its original state and rethrow
+    -- the exception.
+    local restored = assert(URI:new(orig))
+    for k in pairs(self) do self[k] = nil end
+    for k, v in pairs(restored) do self[k] = v end
+    setmetatable(self, getmetatable(restored))
+    error("resolved URI reference would be invalid: " .. result)
+end
+
+function M.relativize (self, base) end      -- already relative
+
+return M
+-- vi:ts=4 sw=4 expandtab
diff --git a/server/src/3rd/lua-uri/uri/_util.lua b/server/src/3rd/lua-uri/uri/_util.lua
new file mode 100644
index 00000000..16a3b289
--- /dev/null
+++ b/server/src/3rd/lua-uri/uri/_util.lua
@@ -0,0 +1,128 @@
+local M = { _NAME = "uri._util" }
+
+-- Build a char->hex map
+local escapes = {}
+for i = 0, 255 do
+    escapes[string.char(i)] = string.format("%%%02X", i)
+end
+
+function M.uri_encode (text, patn)
+    if not text then return end
+    if not patn then
+        -- Default unsafe characters.  RFC 2732 ^(uric - reserved)
+        -- TODO - this should be updated to the latest RFC.
+        patn = "^A-Za-z0-9%-_.!~*'()"
+    end
+    return (text:gsub("([" .. patn .. "])",
+                      function (chr) return escapes[chr] end))
+end
+
+function M.uri_decode (str, patn)
+    -- Note from RFC1630:  "Sequences which start with a percent sign
+    -- but are not followed by two hexadecimal characters are reserved
+    -- for future extension"
+    if not str then return end
+    if patn then patn = "[" .. patn .. "]" end
+    return (str:gsub("%%(%x%x)", function (hex)
+        local char = string.char(tonumber(hex, 16))
+        return (patn and not char:find(patn)) and "%" .. hex or char
+    end))
+end
+
+-- This is the remove_dot_segments algorithm from RFC 3986 section 5.2.4.
+-- The input buffer is 's', the output buffer 'path'.
+function M.remove_dot_segments (s)
+    local path = ""
+
+    while s ~= "" do
+        if s:find("^%.%.?/") then                       -- A
+            s = s:gsub("^%.%.?/", "", 1)
+        elseif s:find("^/%./") or s == "/." then        -- B
+            s = s:gsub("^/%./?", "/", 1)
+        elseif s:find("^/%.%./") or s == "/.." then     -- C
+            s = s:gsub("^/%.%./?", "/", 1)
+            if path:find("/") then
+                path = path:gsub("/[^/]*$", "", 1)
+            else
+                path = ""
+            end
+        elseif s == "." or s == ".." then               -- D
+            s = ""
+        else                                            -- E
+            local _, p, seg = s:find("^(/?[^/]*)")
+            s = s:sub(p + 1)
+            path = path .. seg
+        end
+    end
+
+    return path
+end
+
+-- TODO - wouldn't this be better as a method on string?  s:split(patn)
+function M.split (patn, s, max)
+    if s == "" then return {} end
+
+    local i, j = 1, string.find(s, patn)
+    if not j then return { s } end
+
+    local list = {}
+    while true do
+        if #list + 1 == max then list[max] = s:sub(i); return list end
+        list[#list + 1] = s:sub(i, j - 1)
+        i = j + 1
+        j = string.find(s, patn, i)
+        if not j then
+            list[#list + 1] = s:sub(i)
+            break
+        end
+    end
+    return list
+end
+
+function M.attempt_require (modname)
+    local ok, result = pcall(require, modname)
+    if ok then
+        return result
+    elseif type(result) == "string" and
+           result:find("module '.*' not found") then
+        return nil
+    else
+        error(result)
+    end
+end
+
+function M.subclass_of (class, baseclass)
+    class.__index = class
+    class.__tostring = baseclass.__tostring
+    class._SUPER = baseclass
+    setmetatable(class, baseclass)
+end
+
+function M.do_class_changing_change (uri, baseclass, changedesc, newvalue,
+                                     changefunc)
+    local tmpuri = {}
+    setmetatable(tmpuri, baseclass)
+    for k, v in pairs(uri) do tmpuri[k] = v end
+    changefunc(tmpuri, newvalue)
+    tmpuri._uri = nil
+
+    local foo, err = tmpuri:init()
+    if not foo then
+        error("URI not valid after " .. changedesc .. " changed to '" ..
+              newvalue .. "': " .. err)
+    end
+
+    setmetatable(uri, getmetatable(tmpuri))
+    for k in pairs(uri) do uri[k] = nil end
+    for k, v in pairs(tmpuri) do uri[k] = v end
+end
+
+function M.uri_part_not_allowed (class, method)
+    class[method] = function (self, new)
+        if new then error(method .. " not allowed on this kind of URI") end
+        return self["_" .. method]
+    end
+end
+
+return M
+-- vi:ts=4 sw=4 expandtab
diff --git a/server/src/3rd/lua-uri/uri/data.lua b/server/src/3rd/lua-uri/uri/data.lua
new file mode 100644
index 00000000..c425621a
--- /dev/null
+++ b/server/src/3rd/lua-uri/uri/data.lua
@@ -0,0 +1,116 @@
+local M = { _NAME = "uri.data" }
+local Util = require "uri._util"
+local URI = require "uri"
+Util.subclass_of(M, URI)
+
+-- This implements the 'data' scheme defined in RFC 2397.
+
+local Filter = Util.attempt_require("datafilter")
+
+local function _valid_base64 (data) return data:find("^[0-9a-zA-Z/+]*$") end
+
+local function _split_path (path)
+    local _, _, mediatype, data = path:find("^([^,]*),(.*)")
+    if not mediatype then return "must have comma in path" end
+    local base64 = false
+    if mediatype:find(";base64$") then
+        base64 = true
+        mediatype = mediatype:sub(1, -8)
+    end
+    if base64 and not _valid_base64(data) then
+        return "illegal character in base64 encoding"
+    end
+    return nil, mediatype, base64, data
+end
+
+function M.init (self)
+    if M._SUPER.host(self) then
+        return nil, "data URIs may not have authority parts"
+    end
+    local err, mediatype, base64, data = _split_path(M._SUPER.path(self))
+    if err then return nil, "invalid data URI (" .. err .. ")" end
+    return self
+end
+
+function M.data_media_type (self, ...)
+    local _, old, base64, data = _split_path(M._SUPER.path(self))
+
+    if select('#', ...) > 0 then
+        local new = ... or ""
+        new = Util.uri_encode(new, "^A-Za-z0-9%-._~!$&'()*+;=:@/")
+        if base64 then new = new .. ";base64" end
+        M._SUPER.path(self, new .. "," .. data)
+    end
+
+    if old ~= "" then
+        if old:find("^;") then old = "text/plain" .. old end
+        return Util.uri_decode(old)
+    else
+        return "text/plain;charset=US-ASCII"    -- default type
+    end
+end
+
+local function _urienc_len (s)
+    local num_unsafe_chars = s:gsub("[A-Za-z0-9%-._~!$&'()*+,;=:@/]", ""):len()
+    local num_safe_chars = s:len() - num_unsafe_chars
+    return num_safe_chars + num_unsafe_chars * 3
+end
+
+local function _base64_len (s)
+    local num_blocks = (s:len() + 2) / 3
+    num_blocks = num_blocks - num_blocks % 1
+    return num_blocks * 4
+           + 7      -- because of ";base64" marker
+end
+
+local function _do_filter (algorithm, input)
+    return Filter[algorithm](input)
+end
+
+function M.data_bytes (self, ...)
+    local _, mediatype, base64, old = _split_path(M._SUPER.path(self))
+    if base64 then
+        if not Filter then
+            error("'datafilter' Lua module required to decode base64 data")
+        end
+        old = _do_filter("base64_decode", old)
+    else
+        old = Util.uri_decode(old)
+    end
+
+    if select('#', ...) > 0 then
+        local new = ... or ""
+        local urienc_len = _urienc_len(new)
+        local base64_len = _base64_len(new)
+        if base64_len < urienc_len and Filter then
+            mediatype = mediatype .. ";base64"
+            new = _do_filter("base64_encode", new)
+        else
+            new = new:gsub("%%", "%%25")
+        end
+        M._SUPER.path(self, mediatype .. "," .. new)
+    end
+
+    return old
+end
+
+function M.path (self, ...)
+    local old = M._SUPER.path(self)
+
+    if select('#', ...) > 0 then
+        local new = ...
+        if not new then error("there must be a path in a data URI") end
+        local err = _split_path(new)
+        if err then error("invalid data URI (" .. err .. ")") end
+        M._SUPER.path(self, new)
+    end
+
+    return old
+end
+
+Util.uri_part_not_allowed(M, "userinfo")
+Util.uri_part_not_allowed(M, "host")
+Util.uri_part_not_allowed(M, "port")
+
+return M
+-- vi:ts=4 sw=4 expandtab
diff --git a/server/src/3rd/lua-uri/uri/file.lua b/server/src/3rd/lua-uri/uri/file.lua
new file mode 100644
index 00000000..271cb3ed
--- /dev/null
+++ b/server/src/3rd/lua-uri/uri/file.lua
@@ -0,0 +1,72 @@
+local M = { _NAME = "uri.file" }
+local Util = require "uri._util"
+local URI = require "uri"
+Util.subclass_of(M, URI)
+
+function M.init (self)
+    if self:userinfo() or self:port() then
+        return nil, "usernames and passwords are not allowed in HTTP URIs"
+    end
+
+    local host = self:host()
+    local path = self:path()
+    if host then
+        if host:lower() == "localhost" then self:host("") end
+    else
+        if not path:find("^/") then
+            return nil, "file URIs must contain a host, even if it's empty"
+        end
+        self:host("")
+    end
+
+    if path == "" then self:path("/") end
+
+    return self
+end
+
+function M.host (self, ...)
+    local old = M._SUPER.host(self)
+
+    if select('#', ...) > 0 then
+        local new = ...
+        if not new then error("file URIs must have an authority part") end
+        if new:lower() == "localhost" then new = "" end
+        M._SUPER.host(self, new)
+    end
+
+    return old
+end
+
+function M.path (self, ...)
+    local old = M._SUPER.path(self)
+
+    if select('#', ...) > 0 then
+        local new = ...
+        if not new or new == "" then new = "/" end
+        M._SUPER.path(self, new)
+    end
+
+    return old
+end
+
+local function _os_implementation (os)
+    local FileImpl = Util.attempt_require("uri.file." .. os:lower())
+    if not FileImpl then
+        error("no file URI implementation for operating system " .. os)
+    end
+    return FileImpl
+end
+
+function M.filesystem_path (self, os)
+    return _os_implementation(os).filesystem_path(self)
+end
+
+function M.make_file_uri (path, os)
+    return _os_implementation(os).make_file_uri(path)
+end
+
+Util.uri_part_not_allowed(M, "userinfo")
+Util.uri_part_not_allowed(M, "port")
+
+return M
+-- vi:ts=4 sw=4 expandtab
diff --git a/server/src/3rd/lua-uri/uri/file/unix.lua b/server/src/3rd/lua-uri/uri/file/unix.lua
new file mode 100644
index 00000000..2ffe1504
--- /dev/null
+++ b/server/src/3rd/lua-uri/uri/file/unix.lua
@@ -0,0 +1,26 @@
+local M = { _NAME = "uri.file.unix" }
+local URI = require "uri"
+local Util = require "uri._util"
+
+function M.filesystem_path (uri)
+    if uri:host() ~= "" then
+        error("a file URI with a host name can't be converted to a Unix path")
+    end
+    local path = uri:path()
+    if path:find("%%00") or path:find("%%2F") then
+        error("Unix paths cannot contain encoded null bytes or slashes")
+    end
+    return Util.uri_decode(path)
+end
+
+function M.make_file_uri (path)
+    if not path:find("^/") then
+        error("Unix relative paths can't be converted to file URIs")
+    end
+    path = path:gsub("//+", "/")
+    path = Util.uri_encode(path, "^A-Za-z0-9%-._~!$&'()*+,;=:@/")
+    return assert(URI:new("file://" .. path))
+end
+
+return M
+-- vi:ts=4 sw=4 expandtab
diff --git a/server/src/3rd/lua-uri/uri/file/win32.lua b/server/src/3rd/lua-uri/uri/file/win32.lua
new file mode 100644
index 00000000..bdacbe15
--- /dev/null
+++ b/server/src/3rd/lua-uri/uri/file/win32.lua
@@ -0,0 +1,34 @@
+local M = { _NAME = "uri.file.win32" }
+local URI = require "uri"
+local Util = require "uri._util"
+
+function M.filesystem_path (uri)
+    local host = uri:host()
+    local path = Util.uri_decode(uri:path())
+    if host ~= "" then path = "//" .. host .. path end
+    if path:find("^/[A-Za-z]|/") or path:find("^/[A-Za-z]|$") then
+        path = path:gsub("|", ":", 1)
+    end
+    if path:find("^/[A-Za-z]:/") then
+        path = path:sub(2)
+    elseif path:find("^/[A-Za-z]:$") then
+        path = path:sub(2) .. "/"
+    end
+    path = path:gsub("/", "\\")
+    return path
+end
+
+function M.make_file_uri (path)
+    if path:find("^[A-Za-z]:$") then path = path .. "\\" end
+    local _, _, host, hostpath = path:find("^\\\\([A-Za-z.]+)\\(.*)$")
+    host = host or ""
+    hostpath = hostpath or path
+    hostpath = hostpath:gsub("\\", "/")
+                       :gsub("//+", "/")
+    hostpath = Util.uri_encode(hostpath, "^A-Za-z0-9%-._~!$&'()*+,;=:@/")
+    if not hostpath:find("^/") then hostpath = "/" .. hostpath end
+    return assert(URI:new("file://" .. host .. hostpath))
+end
+
+return M
+-- vi:ts=4 sw=4 expandtab
diff --git a/server/src/3rd/lua-uri/uri/ftp.lua b/server/src/3rd/lua-uri/uri/ftp.lua
new file mode 100644
index 00000000..2d9e3f6c
--- /dev/null
+++ b/server/src/3rd/lua-uri/uri/ftp.lua
@@ -0,0 +1,53 @@
+local M = { _NAME = "uri.ftp" }
+local Util = require "uri._util"
+local LoginURI = require "uri._login"
+Util.subclass_of(M, LoginURI)
+
+function M.default_port () return 21 end
+
+function M.init (self)
+    self, err = M._SUPER.init_base(self)
+    if not self then return nil, err end
+
+    local host = self:host()
+    if not host or host == "" then
+        return nil, "FTP URIs must have a hostname"
+    end
+
+    -- I don't think there's any distinction in FTP URIs between empty path
+    -- and the root directory, so probably best to normalize as we do for HTTP.
+    if self:path() == "" then self:path("/") end
+
+    return self
+end
+
+function M.path (self, ...)
+    local old = M._SUPER.path(self)
+
+    if select("#", ...) > 0 then
+        local new = ...
+        if not new or new == "" then new = "/" end
+        M._SUPER.path(self, new)
+    end
+
+    return old
+end
+
+function M.ftp_typecode (self, ...)
+    local path = M._SUPER.path(self)
+    local _, _, withouttype, old = path:find("^(.*);type=(.*)$")
+    if not withouttype then withouttype = path end
+    if old == "" then old = nil end
+
+    if select("#", ...) > 0 then
+        local new = ...
+        if not new then new = "" end
+        if new ~= "" then new = ";type=" .. new end
+        M._SUPER.path(self, withouttype .. new)
+    end
+
+    return old
+end
+
+return M
+-- vi:ts=4 sw=4 expandtab
diff --git a/server/src/3rd/lua-uri/uri/http.lua b/server/src/3rd/lua-uri/uri/http.lua
new file mode 100644
index 00000000..91f7a57f
--- /dev/null
+++ b/server/src/3rd/lua-uri/uri/http.lua
@@ -0,0 +1,32 @@
+local M = { _NAME = "uri.http" }
+local Util = require "uri._util"
+local URI = require "uri"
+Util.subclass_of(M, URI)
+
+-- This implementation is based on RFC 2616 section 3.2 and RFC 1738
+-- section 3.3.
+--
+-- An HTTP URI with a 'userinfo' field is considered invalid, because it isn't
+-- shown in the syntax given in RFC 2616, and is explicitly disallowed by
+-- RFC 1738.
+
+function M.default_port () return 80 end
+
+function M.init (self)
+    if self:userinfo() then
+        return nil, "usernames and passwords are not allowed in HTTP URIs"
+    end
+
+    -- RFC 2616 section 3.2.3 says that this is OK, but not that using the
+    -- redundant slash is canonical.  I'm adding it because browsers tend to
+    -- treat the version with the extra slash as the normalized form, and
+    -- the initial slash is always present in an HTTP GET request.
+    if self:path() == "" then self:path("/") end
+
+    return self
+end
+
+Util.uri_part_not_allowed(M, "userinfo")
+
+return M
+-- vi:ts=4 sw=4 expandtab
diff --git a/server/src/3rd/lua-uri/uri/https.lua b/server/src/3rd/lua-uri/uri/https.lua
new file mode 100644
index 00000000..0c4c8bc3
--- /dev/null
+++ b/server/src/3rd/lua-uri/uri/https.lua
@@ -0,0 +1,9 @@
+local M = { _NAME = "uri.https" }
+local Util = require "uri._util"
+local Http = require "uri.http"
+Util.subclass_of(M, Http)
+
+function M.default_port () return 443 end
+
+return M
+-- vi:ts=4 sw=4 expandtab
diff --git a/server/src/3rd/lua-uri/uri/pop.lua b/server/src/3rd/lua-uri/uri/pop.lua
new file mode 100644
index 00000000..e42d9d41
--- /dev/null
+++ b/server/src/3rd/lua-uri/uri/pop.lua
@@ -0,0 +1,111 @@
+local M = { _NAME = "uri.pop" }
+local URI = require "uri"
+local Util = require "uri._util"
+Util.subclass_of(M, URI)
+
+-- This is the set of characters must be encoded in a POP userinfo, which
+-- unlike for other schemes includes the ';' character.
+local _POP_USERINFO_ENCODE = "^A-Za-z0-9%-._~%%!$&'()*+,=:"
+
+function M.default_port () return 110 end
+
+local function _update_userinfo (self, old, new)
+    if new then
+        local _, _, user, auth = new:find("^(.*);[Aa][Uu][Tt][Hh]=(.*)$")
+        if not user then user = new end
+        if user == "" then return "pop user name must not be empty" end
+        user = Util.uri_encode(user, _POP_USERINFO_ENCODE)
+        if auth then
+            if auth == "" then return "pop auth type must not be empty" end
+            if auth == "*" then auth = nil end
+            auth = Util.uri_encode(auth, _POP_USERINFO_ENCODE)
+        end
+        new = user .. (auth and ";auth=" .. auth or "")
+    end
+
+    if new ~= old then M._SUPER.userinfo(self, new) end
+    return nil
+end
+
+function M.init (self)
+    if M._SUPER.path(self) ~= "" then
+        return nil, "pop URIs must have an empty path"
+    end
+
+    local userinfo = M._SUPER.userinfo(self)
+    local err = _update_userinfo(self, userinfo, userinfo)
+    if err then return nil, err end
+
+    return self
+end
+
+function M.userinfo (self, ...)
+    local old = M._SUPER.userinfo(self)
+
+    if select('#', ...) > 0 then
+        local new = ...
+        local err = _update_userinfo(self, old, new)
+        if err then error(err) end
+    end
+
+    return old
+end
+
+function M.path (self, new)
+    if new and new ~= "" then error("POP URIs must have an empty path") end
+    return ""
+end
+
+local function _decode_userinfo (self)
+    local old = M._SUPER.userinfo(self)
+    if not old then return nil, nil end
+    local _, _, old_user, old_auth = old:find("^(.*);auth=(.*)$")
+    if not old_user then old_user = old end
+    return old_user, old_auth
+end
+
+function M.pop_user (self, ...)
+    local old_user, old_auth = _decode_userinfo(self)
+
+    if select('#', ...) > 0 then
+        local new = ...
+        if new == "" then error("pop user name must not be empty") end
+        if not new and old_auth then
+            error("pop user name required when an auth type is specified")
+        end
+        if new then
+            new = Util.uri_encode(new, _POP_USERINFO_ENCODE)
+            if old_auth then new = new .. ";auth=" .. old_auth end
+        end
+        M._SUPER.userinfo(self, new)
+    end
+
+    return Util.uri_decode(old_user)
+end
+
+function M.pop_auth (self, ...)
+    local old_user, old_auth = _decode_userinfo(self)
+
+    if select('#', ...) > 0 then
+        local new = ...
+        if not new or new == ""
+            then error("pop auth type must not be empty")
+        end
+        if new == "*" then new = nil end
+        if new and not old_user then
+            error("pop auth type can't be specified without user name")
+        end
+        if new then
+            new = old_user .. ";auth=" ..
+                  Util.uri_encode(new, _POP_USERINFO_ENCODE)
+        else
+            new = old_user
+        end
+        M._SUPER.userinfo(self, new)
+    end
+
+    return old_auth and Util.uri_decode(old_auth) or "*"
+end
+
+return M
+-- vi:ts=4 sw=4 expandtab
diff --git a/server/src/3rd/lua-uri/uri/rtsp.lua b/server/src/3rd/lua-uri/uri/rtsp.lua
new file mode 100644
index 00000000..03c71485
--- /dev/null
+++ b/server/src/3rd/lua-uri/uri/rtsp.lua
@@ -0,0 +1,9 @@
+local M = { _NAME = "uri.rtsp" }
+local Util = require "uri._util"
+local HttpURI = require "uri.http"
+Util.subclass_of(M, HttpURI)
+
+function M.default_port () return 554 end
+
+return M
+-- vi:ts=4 sw=4 expandtab
diff --git a/server/src/3rd/lua-uri/uri/rtspu.lua b/server/src/3rd/lua-uri/uri/rtspu.lua
new file mode 100644
index 00000000..16f5e3ee
--- /dev/null
+++ b/server/src/3rd/lua-uri/uri/rtspu.lua
@@ -0,0 +1,7 @@
+local M = { _NAME = "uri.rtspu" }
+local Util = require "uri._util"
+local RtspURI = require "uri.rtsp"
+Util.subclass_of(M, RtspURI)
+
+return M
+-- vi:ts=4 sw=4 expandtab
diff --git a/server/src/3rd/lua-uri/uri/telnet.lua b/server/src/3rd/lua-uri/uri/telnet.lua
new file mode 100644
index 00000000..339e21ee
--- /dev/null
+++ b/server/src/3rd/lua-uri/uri/telnet.lua
@@ -0,0 +1,38 @@
+local M = { _NAME = "uri.telnet" }
+local Util = require "uri._util"
+local LoginURI = require "uri._login"
+Util.subclass_of(M, LoginURI)
+
+function M.default_port () return 23 end
+
+function M.init (self)
+    self, err = M._SUPER.init_base(self)
+    if not self then return nil, err end
+
+    -- RFC 4248 does not discuss what a path longer than '/' might mean, and
+    -- there are no examples with anything significant in the path, so I'm
+    -- assuming that extra information in the path is not allowed.
+    local path = M._SUPER.path(self)
+    if path ~= "" and path ~= "/" then
+        return nil, "superfluous information in path of telnet URI"
+    end
+
+    -- RFC 4248 section 2 says that the '/' can be omitted.  I chose to
+    -- normalize to having it there, since the example shown in the RFC has
+    -- it, and this is consistent with the way I treat HTTP URIs.
+    if path == "" then self:path("/") end
+
+    return self
+end
+
+-- The path is always '/', so setting it won't do anything, but we do throw
+-- an exception on an attempt to set it to anything invalid.
+function M.path (self, new)
+    if new and new ~= "" and new ~= "/" then
+        error("invalid path for telnet URI")
+    end
+    return "/"
+end
+
+return M
+-- vi:ts=4 sw=4 expandtab
diff --git a/server/src/3rd/lua-uri/uri/urn.lua b/server/src/3rd/lua-uri/uri/urn.lua
new file mode 100644
index 00000000..aa4b1776
--- /dev/null
+++ b/server/src/3rd/lua-uri/uri/urn.lua
@@ -0,0 +1,131 @@
+local M = { _NAME = "uri.urn" }
+local Util = require "uri._util"
+local URI = require "uri"
+Util.subclass_of(M, URI)
+
+-- This implements RFC 2141, and attempts to change the class of the URI object
+-- to one of its subclasses for further validation and normalization of the
+-- namespace-specific string.
+
+-- Check NID syntax matches RFC 2141 section 2.1.
+local function _valid_nid (nid)
+    if nid == "" then return nil, "missing completely" end
+    if nid:len() > 32 then return nil, "too long" end
+    if not nid:find("^[A-Za-z0-9][-A-Za-z0-9]*$") then
+        return nil, "contains illegal character"
+    end
+    if nid:lower() == "urn" then return nil, "'urn' is reserved" end
+    return true
+end
+
+-- Check NSS syntax matches RFC 2141 section 2.2.
+local function _valid_nss (nss)
+    if nss == "" then return nil, "can't be empty" end
+    if nss:find("[^A-Za-z0-9()+,%-.:=@;$_!*'/%%]") then
+        return nil, "contains illegal character"
+    end
+    return true
+end
+
+local function _validate_and_normalize_path (path)
+    local _, _, nid, nss = path:find("^([^:]+):(.*)$")
+    if not nid then return nil, "illegal path syntax for URN" end
+
+    local ok, msg = _valid_nid(nid)
+    if not ok then
+        return nil, "invalid namespace identifier (" .. msg .. ")"
+    end
+    ok, msg = _valid_nss(nss)
+    if not ok then
+        return nil, "invalid namespace specific string (" .. msg .. ")"
+    end
+
+    return nid:lower() .. ":" .. nss
+end
+
+-- TODO - this should check that percent-encoded bytes are valid UTF-8
+function M.init (self)
+    if M._SUPER.query(self) then
+        return nil, "URNs may not have query parts"
+    end
+    if M._SUPER.host(self) then
+        return nil, "URNs may not have authority parts"
+    end
+
+    local path, msg = _validate_and_normalize_path(self:path())
+    if not path then return nil, msg end
+    M._SUPER.path(self, path)
+
+    local nid_class
+        = Util.attempt_require("uri.urn." .. self:nid():gsub("%-", "_"))
+    if nid_class then
+        setmetatable(self, nid_class)
+        if self.init ~= M.init then return self:init() end
+    end
+
+    return self
+end
+
+function M.nid (self, new)
+    local _, _, old = self:path():find("^([^:]+)")
+
+    if new then
+        new = new:lower()
+        if new ~= old then
+            local ok, msg = _valid_nid(new)
+            if not ok then
+                error("invalid namespace identifier (" .. msg .. ")")
+            end
+        end
+        Util.do_class_changing_change(self, M, "NID", new, function (uri, new)
+            M._SUPER.path(uri, new .. ":" .. uri:nss())
+        end)
+    end
+
+    return old
+end
+
+function M.nss (self, new)
+    local _, _, old = self:path():find(":(.*)")
+
+    if new and new ~= old then
+        local ok, msg = _valid_nss(new)
+        if not ok then
+            error("invalid namespace specific string (" .. msg .. ")")
+        end
+        M._SUPER.path(self, self:nid() .. ":" .. new)
+    end
+
+    return old
+end
+
+function M.path (self, new)
+    local old = M._SUPER.path(self)
+
+    if new and new ~= old then
+        local path, msg = _validate_and_normalize_path(new)
+        if not path then
+            error("invalid path for URN '" .. new .. "' (" ..msg .. ")")
+        end
+        local _, _, newnid, newnss = path:find("^([^:]+):(.*)")
+        if not newnid then error("bad path for URN, no NID part found") end
+        local ok, msg = _valid_nid(newnid)
+        if not ok then error("invalid namespace identifier (" .. msg .. ")") end
+        if newnid:lower() == self:nid() then
+            self:nss(newnss)
+        else
+            Util.do_class_changing_change(self, M, "path", path,
+                function (uri, new) M._SUPER.path(uri, new) end)
+        end
+    end
+
+    return old
+end
+
+Util.uri_part_not_allowed(M, "userinfo")
+Util.uri_part_not_allowed(M, "host")
+Util.uri_part_not_allowed(M, "port")
+Util.uri_part_not_allowed(M, "query")
+
+return M
+-- vi:ts=4 sw=4 expandtab
diff --git a/server/src/3rd/lua-uri/uri/urn/isbn.lua b/server/src/3rd/lua-uri/uri/urn/isbn.lua
new file mode 100644
index 00000000..5f0bdb69
--- /dev/null
+++ b/server/src/3rd/lua-uri/uri/urn/isbn.lua
@@ -0,0 +1,67 @@
+local M = { _NAME = "uri.urn.isbn" }
+local Util = require "uri._util"
+local URN = require "uri.urn"
+Util.subclass_of(M, URN)
+
+-- This implements the 'isbn' NID defined in RFC 3187, and is consistent
+-- with the same NID suggested in RFC 2288.
+
+local function _valid_isbn (isbn)
+    if not isbn:find("^[-%d]+[%dXx]$") then return nil, "invalid character" end
+    local ISBN = Util.attempt_require("isbn")
+    if ISBN then return ISBN:new(isbn) end
+    return isbn
+end
+
+local function _normalize_isbn (isbn)
+    isbn = isbn:gsub("%-", ""):upper()
+    local ISBN = Util.attempt_require("isbn")
+    if ISBN then return tostring(ISBN:new(isbn)) end
+    return isbn
+end
+
+function M.init (self)
+    local nss = self:nss()
+    local ok, msg = _valid_isbn(nss)
+    if not ok then return nil, "invalid ISBN value (" .. msg .. ")" end
+    self:nss(_normalize_isbn(nss))
+    return self
+end
+
+function M.nss (self, new)
+    local old = M._SUPER.nss(self)
+
+    if new then
+        local ok, msg = _valid_isbn(new)
+        if not ok then
+            error("bad ISBN value '" .. new .. "' (" .. msg .. ")")
+        end
+        M._SUPER.nss(self, _normalize_isbn(new))
+    end
+
+    return old
+end
+
+function M.isbn_digits (self, new)
+    local old = self:nss():gsub("%-", "")
+
+    if new then
+        local ok, msg = _valid_isbn(new)
+        if not ok then
+            error("bad ISBN value '" .. new .. "' (" .. msg .. ")")
+        end
+        self._SUPER.nss(self, _normalize_isbn(new))
+    end
+
+    return old
+end
+
+function M.isbn (self, new)
+    local ISBN = require "isbn"
+    local old = ISBN:new(self:nss())
+    if new then self:nss(tostring(new)) end
+    return old
+end
+
+return M
+-- vi:ts=4 sw=4 expandtab
diff --git a/server/src/3rd/lua-uri/uri/urn/issn.lua b/server/src/3rd/lua-uri/uri/urn/issn.lua
new file mode 100644
index 00000000..c5f37f8c
--- /dev/null
+++ b/server/src/3rd/lua-uri/uri/urn/issn.lua
@@ -0,0 +1,65 @@
+local M = { _NAME = "uri.urn.issn" }
+local Util = require "uri._util"
+local URN = require "uri.urn"
+Util.subclass_of(M, URN)
+
+local function _parse_issn (issn)
+    local _, _, nums1, nums2, checksum
+        = issn:find("^(%d%d%d%d)-?(%d%d%d)([%dxX])$")
+    if checksum == "x" then checksum = "X" end
+    return nums1, nums2, checksum
+end
+
+local function _valid_issn (issn)
+    local nums1, nums2, actual_checksum = _parse_issn(issn)
+    if not nums1 then return nil, "invalid ISSN syntax" end
+    local nums = nums1 .. nums2
+
+    local expected_checksum = 0
+    for i = 1, 7 do
+        expected_checksum = expected_checksum + tonumber(nums:sub(i, i)) * (9 - i)
+    end
+    expected_checksum = (11 - expected_checksum % 11) % 11
+    expected_checksum = (expected_checksum == 10) and "X"
+                                                  or tostring(expected_checksum)
+    if actual_checksum ~= expected_checksum then
+        return nil, "wrong checksum, expected " .. expected_checksum
+    end
+
+    return true
+end
+
+local function _normalize_issn (issn)
+    local nums1, nums2, checksum = _parse_issn(issn)
+    return nums1 .. "-" .. nums2 .. checksum
+end
+
+function M.init (self)
+    local nss = self:nss()
+    local ok, msg = _valid_issn(nss)
+    if not ok then return nil, "bad NSS value for ISSN URI (" .. msg .. ")" end
+    M._SUPER.nss(self, _normalize_issn(nss))
+    return self
+end
+
+function M.nss (self, new)
+    local old = M._SUPER.nss(self)
+
+    if new then
+        local ok, msg = _valid_issn(new)
+        if not ok then
+            error("bad ISSN value '" .. new .. "' (" .. msg .. ")")
+        end
+        M._SUPER.nss(self, _normalize_issn(new))
+    end
+
+    return old
+end
+
+function M.issn_digits (self, new)
+    local old = self:nss(new)
+    return old:sub(1, 4) .. old:sub(6, 9)
+end
+
+return M
+-- vi:ts=4 sw=4 expandtab
diff --git a/server/src/3rd/lua-uri/uri/urn/oid.lua b/server/src/3rd/lua-uri/uri/urn/oid.lua
new file mode 100644
index 00000000..37110cda
--- /dev/null
+++ b/server/src/3rd/lua-uri/uri/urn/oid.lua
@@ -0,0 +1,62 @@
+local M = { _NAME = "uri.urn.oid" }
+local Util = require "uri._util"
+local URN = require "uri.urn"
+Util.subclass_of(M, URN)
+
+-- This implements RFC 3061.
+
+local function _valid_oid (oid)
+    if oid == "" then return nil, "OID can't be zero-length" end
+    if not oid:find("^[.0-9]*$") then return nil, "bad character in OID" end
+    if oid:find("%.%.") then return nil, "missing number in OID" end
+    if oid:find("^0[^.]") or oid:find("%.0[^.]") then
+        return nil, "OID numbers shouldn't have leading zeros"
+    end
+    return true
+end
+
+function M.init (self)
+    local nss = self:nss()
+    local ok, msg = _valid_oid(nss)
+    if not ok then return nil, "bad NSS value for OID URI (" .. msg .. ")" end
+    return self
+end
+
+function M.nss (self, new)
+    local old = M._SUPER.nss(self)
+
+    if new then
+        local ok, msg = _valid_oid(new)
+        if not ok then
+            error("bad OID value '" .. new .. "' (" .. msg .. ")")
+        end
+        M._SUPER.nss(self, new)
+    end
+
+    return old
+end
+
+function M.oid_numbers (self, new)
+    local old = Util.split("%.", self:nss())
+    for i = 1, #old do old[i] = tonumber(old[i]) end
+
+    if new then
+        if type(new) ~= "table" then error("expected array of numbers") end
+        local nss = ""
+        for _, n in ipairs(new) do
+            if type(n) == "string" and n:find("^%d+$") then n = tonumber(n) end
+            if type(n) ~= "number" then error("bad type for number in OID") end
+            n = n - n % 1
+            if n < 0 then error("negative numbers not allowed in OID") end
+            if nss ~= "" then nss = nss .. "." end
+            nss = nss .. n
+        end
+        if nss == "" then error("no numbers in new OID value") end
+        self:nss(nss)
+    end
+
+    return old
+end
+
+return M
+-- vi:ts=4 sw=4 expandtab
diff --git a/server/src/sandbox.lua b/server/src/sandbox.lua
new file mode 100644
index 00000000..c09230fd
--- /dev/null
+++ b/server/src/sandbox.lua
@@ -0,0 +1,163 @@
+local function standard(loaded)
+    local r = {}
+    for _, s in ipairs {
+        --'package',
+        'coroutine',
+        'table',
+        --'io',
+        'os',
+        'string',
+        'math',
+        'utf8',
+        'debug',
+    } do
+        r[s] = _G[s]
+        loaded[s] = _G[s]
+    end
+    for _, s in ipairs {
+        'assert',
+        'collectgarbage',
+        --'dofile',
+        'error',
+        'getmetatable',
+        'ipairs',
+        --'loadfile',
+        'load',
+        'next',
+        'pairs',
+        'pcall',
+        'print',
+        'rawequal',
+        'rawlen',
+        'rawget',
+        'rawset',
+        'select',
+        'setmetatable',
+        'tonumber',
+        'tostring',
+        'type',
+        'xpcall',
+        '_VERSION',
+        --'require',
+    } do
+        r[s] = _G[s]
+    end
+    return r
+end
+
+local function sandbox_env(loadlua, openfile, loaded)
+    local _LOADED = loaded or {}
+    local _E = standard(_LOADED)
+    local _PRELOAD = {}
+
+    _E.io = {
+        open = openfile,
+    }
+
+    local function searchpath(name, path)
+        local err = ''
+    	name = string.gsub(name, '%.', '/')
+    	for c in string.gmatch(path, '[^;]+') do
+            local filename = string.gsub(c, '%?', name)
+            local f = openfile(filename)
+            if f then
+                f:close()
+    			return filename
+    		end
+            err = err .. ("\n\tno file '%s'"):format(filename)
+        end
+        return nil, err
+    end
+
+    local function searcher_preload(name)
+        assert(type(_PRELOAD) == "table", "'package.preload' must be a table")
+        if _PRELOAD[name] == nil then
+            return ("\n\tno field package.preload['%s']"):format(name)
+        end
+        return _PRELOAD[name]
+    end
+    
+    local function searcher_lua(name)
+        assert(type(_E.package.path) == "string", "'package.path' must be a string")
+    	local filename, err = searchpath(name, _E.package.path)
+    	if not filename then
+    		return err
+    	end
+    	local f, err = loadlua(filename)
+    	if not f then
+    		error(("error loading module '%s' from file '%s':\n\t%s"):format(name, filename, err))
+    	end
+    	return f, filename
+    end
+
+    local function require_load(name)
+        local msg = ''
+        local _SEARCHERS = _E.package.searchers
+        assert(type(_SEARCHERS) == "table", "'package.searchers' must be a table")
+    	for _, searcher in ipairs(_SEARCHERS) do
+            local f, extra = searcher(name)
+            if type(f) == 'function' then
+                return f, extra
+            elseif type(f) == 'string' then
+                msg = msg .. f
+            end
+        end
+        error(("module '%s' not found:%s"):format(name, msg))
+    end
+
+    _E.require = function(name)
+        assert(type(name) == "string", ("bad argument #1 to 'require' (string expected, got %s)"):format(type(name)))
+    	local p = _LOADED[name]
+    	if p ~= nil then
+    		return p
+    	end
+    	local init, extra = require_load(name)
+        debug.setupvalue(init, 1, _E)
+    	local res = init(name, extra)
+    	if res ~= nil then
+    		_LOADED[name] = res
+    	end
+    	if _LOADED[name] == nil then
+    		_LOADED[name] = true
+    	end
+    	return _LOADED[name]
+    end
+    _E.package = {
+        config = [[
+            \
+            ;
+            ?
+            !
+            -
+        ]],
+        loaded = _LOADED,
+        path = '?.lua',
+        preload = _PRELOAD,
+        searchers = { searcher_preload, searcher_lua },
+        searchpath = searchpath
+    }
+    return _E
+end
+
+return function(name, root, io_open, loaded)
+    if not root:sub(-1):find '[/\\]' then
+        root = root .. '/'
+    end
+    local function openfile(name, mode)
+        return io_open(root .. name, mode)
+    end
+    local function loadlua(name)
+        local f = openfile(name, 'r')
+        if f then
+            local str = f:read 'a'
+            f:close()
+            return load(str, '@' .. root .. name)
+        end
+    end
+    local init = loadlua(name)
+    if not init then
+        return
+    end
+    debug.setupvalue(init, 1, sandbox_env(loadlua, openfile, loaded))
+	return init()
+end
diff --git a/server/src/uri.lua b/server/src/uri.lua
index a9b64177..35de8a74 100644
--- a/server/src/uri.lua
+++ b/server/src/uri.lua
@@ -1,58 +1,23 @@
 local fs = require 'bee.filesystem'
 local platform = require 'bee.platform'
+local sandbox = require 'sandbox'
+local luaUriPath = (ROOT / 'src' / '3rd' / 'lua-uri'):string()
+local URI = sandbox('uri.lua', luaUriPath, io.open)
+local URI_FILE = sandbox('uri/file.lua', luaUriPath, io.open)
+local OS = platform.OS == 'Windows' and 'win32' or 'unix'
 
 local function decode(uri)
-    -- Unix-like系统根是/
-    if uri:sub(1, 9) == 'file:////' then
-        return fs.path(uri:sub(9))
-    end
-    if uri:sub(1, 8) ~= 'file:///' then
-        log.error('uri decode failed: ', uri)
-        return nil
-    end
-
-    -- linux uri example: file:///home/user/project/
-    if platform.OS == 'Linux' then
-        return fs.path(uri:sub(8))
-    end
-   
-    local names = {}
-    for name in uri:sub(9):gmatch '[^%/]+' do
-        names[#names+1] = name:gsub('%%([0-9a-fA-F][0-9a-fA-F])', function (hex)
-            return string.char(tonumber(hex, 16))
-        end)
-    end
-    if #names == 0 then
-        log.error('uri decode failed: ', uri)
-        return nil
-    end
-    -- 盘符后面加个斜杠
-    local path = fs.path(names[1] .. '/')
-    for i = 2, #names do
-        path = path / names[i]
-    end
-    return fs.absolute(path)
+    local obj = URI:new(uri)
+    local fullPath = obj:filesystem_path(OS)
+    local path = fs.path(fullPath)
+    return path
 end
 
 local function encode(path)
-    local names = {}
-    local cur = fs.absolute(path)
-    while true do
-        local name = cur:filename():string()
-        if name == '' then
-            -- 盘符，去掉一个斜杠
-            name = cur:string():sub(1, -2)
-        end
-        name = name:gsub([=[[^%w%-%_%.%~]]=], function (char)
-            return ('%%%02X'):format(string.byte(char))
-        end)
-        table.insert(names, 1, name)
-        if cur == cur:parent_path() then
-            break
-        end
-        cur = cur:parent_path()
-    end
-    return 'file:///' .. table.concat(names, '/')
+    local fullPath = fs.absolute(path)
+    local obj = URI_FILE.make_file_uri(fullPath:string(), OS)
+    local uri = obj:uri()
+    return uri
 end
 
 return {
diff --git a/server/src/workspace.lua b/server/src/workspace.lua
index 4962e7e1..895a2680 100644
--- a/server/src/workspace.lua
+++ b/server/src/workspace.lua
@@ -151,6 +151,7 @@ function mt:init(rootUri)
         return
     end
     log.info('Workspace inited, root: ', self.root)
+    log.info('Workspace inited, uri: ', rootUri)
     local logPath = ROOT / 'log' / (rootUri:gsub('[/:]+', '_') .. '.log')
     log.info('Log path: ', logPath)
     log.init(ROOT, logPath)