rufus-lua-win 5.1.5

data/vendor/lua/lib/lua/ssl/https.lua

@@ -0,0 +1,138 @@
+----------------------------------------------------------------------------
+-- LuaSec 0.4
+-- Copyright (C) 2009 PUC-Rio
+--
+-- Author: Pablo Musa
+-- Author: Tomas Guisasola
+---------------------------------------------------------------------------
+
+local socket = require("socket")
+local ssl    = require("ssl")
+local ltn12  = require("ltn12")
+local http   = require("socket.http")
+local url    = require("socket.url")
+
+local table  = require("table")
+local string = require("string")
+
+local try          = socket.try
+local type         = type
+local pairs        = pairs
+local getmetatable = getmetatable
+
+module("ssl.https")
+
+_VERSION   = "0.4"
+_COPYRIGHT = "LuaSec 0.4 - Copyright (C) 2009 PUC-Rio"
+
+-- Default settings
+PORT = 443
+
+local cfg = {
+  protocol = "tlsv1",
+  options  = "all",
+  verify   = "none",
+}
+
+--------------------------------------------------------------------
+-- Auxiliar Functions
+--------------------------------------------------------------------
+
+-- Insert default HTTPS port.
+local function default_https_port(u)
+   return url.build(url.parse(u, {port = PORT}))
+end
+
+-- Convert an URL to a table according to Luasocket needs.
+local function urlstring_totable(url, body, result_table)
+   url = {
+      url = default_https_port(url),
+      method = body and "POST" or "GET",
+      sink = ltn12.sink.table(result_table)
+   }
+   if body then
+      url.source = ltn12.source.string(body)
+      url.headers = {
+         ["content-length"] = #body,
+         ["content-type"] = "application/x-www-form-urlencoded",
+      }
+   end
+   return url
+end
+
+-- Forward calls to the real connection object.
+local function reg(conn)
+   local mt = getmetatable(conn.sock).__index
+   for name, method in pairs(mt) do
+      if type(method) == "function" then
+         conn[name] = function (self, ...)
+                         return method(self.sock, ...)
+                      end
+      end
+   end
+end
+
+-- Return a function which performs the SSL/TLS connection.
+local function tcp(params)
+   params = params or {}
+   -- Default settings
+   for k, v in pairs(cfg) do 
+      params[k] = params[k] or v
+   end
+   -- Force client mode
+   params.mode = "client"
+   -- 'create' function for LuaSocket
+   return function ()
+      local conn = {}
+      conn.sock = try(socket.tcp())
+      local st = getmetatable(conn.sock).__index.settimeout
+      function conn:settimeout(...)
+         return st(self.sock, ...)
+      end
+      -- Replace TCP's connection function
+      function conn:connect(host, port)
+         try(self.sock:connect(host, port))
+         self.sock = try(ssl.wrap(self.sock, params))
+         try(self.sock:dohandshake())
+         reg(self, getmetatable(self.sock))
+         return 1
+      end
+      return conn
+  end
+end
+
+--------------------------------------------------------------------
+-- Main Function
+--------------------------------------------------------------------
+
+-- Make a HTTP request over secure connection.  This function receives
+--  the same parameters of LuaSocket's HTTP module (except 'proxy' and
+--  'redirect') plus LuaSec parameters.
+--
+-- @param url mandatory (string or table)
+-- @param body optional (string)
+-- @return (string if url == string or 1), code, headers, status
+--
+function request(url, body)
+  local result_table = {}
+  local stringrequest = type(url) == "string"
+  if stringrequest then
+    url = urlstring_totable(url, body, result_table)
+  else
+    url.url = default_https_port(url.url)
+  end
+  if http.PROXY or url.proxy then
+    return nil, "proxy not supported"
+  elseif url.redirect then
+    return nil, "redirect not supported"
+  elseif url.create then
+    return nil, "create function not permitted"
+  end
+  -- New 'create' function to establish a secure connection
+  url.create = tcp(url)
+  local res, code, headers, status = http.request(url)
+  if res and stringrequest then
+    return table.concat(result_table), code, headers, status
+  end
+  return res, code, headers, status
+end

data/vendor/lua/lib/lua/stable.lua

@@ -0,0 +1,28 @@
+----------------------------------------------------------------------------
+-- Stable: State persistent table for Rings.
+--
+-- Copyright (c) 2006-2007 Kepler Project
+-- $Id: stable.lua,v 1.7 2008/06/30 17:52:31 carregal Exp $
+----------------------------------------------------------------------------
+
+local remotedostring = assert (remotedostring, "There is no `remotedostring'.  Probably not in a slave state")
+-- creating persistent table at master state.
+assert (remotedostring[[_state_persistent_table_ = _state_persistent_table_ or {}]])
+
+module"stable"
+
+----------------------------------------------------------------------------
+_COPYRIGHT = "Copyright (C) 2006 Kepler Project"
+_DESCRIPTION = "State persistent table"
+_VERSION = "Stable 1.0"
+
+----------------------------------------------------------------------------
+function get (i)
+	local ok, value = remotedostring ("return _state_persistent_table_[...]", i)
+	return value
+end
+
+----------------------------------------------------------------------------
+function set (i, v)
+	remotedostring ("_state_persistent_table_[select(1,...)] = select(2,...)", i, v)
+end

data/vendor/lua/lib/lua/std.lua

@@ -0,0 +1,16 @@
+--- Lua standard library
+-- <ul>
+-- <li>TODO: Write a style guide (indenting/wrapping, capitalisation,
+--   function and variable names); library functions should call
+--   error, not die; OO vs non-OO (a thorny problem).</li>
+-- <li>TODO: Add tests for each function immediately after the function;
+--   this also helps to check module dependencies.</li>
+-- <li>TODO: pre-compile.</li>
+-- </ul>
+module ("std", package.seeall)
+
+version = "General Lua libraries / 29"
+
+for _, m in ipairs (require "modules") do
+  require (m)
+end

data/vendor/lua/lib/lua/strbuf.lua

@@ -0,0 +1,32 @@
+--- String buffers
+module ("strbuf", package.seeall)
+
+--- Create a new string buffer
+local metatable = {}
+function new ()
+  return setmetatable ({}, metatable)
+end
+
+--- Add a string to a buffer
+-- @param b buffer
+-- @param s string to add
+-- @return buffer
+function concat (b, s)
+  table.insert (b, s)
+  return b
+end
+
+--- Convert a buffer to a string
+-- @param b buffer
+-- @return string
+function tostring (b)
+  return table.concat (b)
+end
+
+--- Metamethods for string buffers
+-- buffer:method ()
+metatable.__index = _M
+-- buffer .. string
+metatable.__concat = concat
+-- tostring
+metatable.__tostring = tostring

data/vendor/lua/lib/lua/strict.lua

@@ -0,0 +1,45 @@
+--
+-- strict.lua
+-- checks uses of undeclared global variables
+-- All global variables must be 'declared' through a regular assignment
+-- (even assigning nil will do) in a main chunk before being used
+-- anywhere or assigned to inside a function.
+--
+
+local getinfo, error, rawset, rawget = debug.getinfo, error, rawset, rawget
+
+local mt = getmetatable(_G)
+if mt == nil then
+  mt = {}
+  setmetatable(_G, mt)
+end
+
+__strict = true
+mt.__declared = {}
+
+local function what ()
+  local d = getinfo(3, "S")
+  return d and d.what or "C"
+end
+
+mt.__newindex = function (t, n, v)
+  if __strict and not mt.__declared[n] then
+    local w = what()
+    if w ~= "main" and w ~= "C" then
+      error("assign to undeclared variable '"..n.."'", 2)
+    end
+    mt.__declared[n] = true
+  end
+  rawset(t, n, v)
+end
+  
+mt.__index = function (t, n)
+  if __strict and not mt.__declared[n] and what() ~= "C" then
+    error("variable '"..n.."' is not declared", 2)
+  end
+  return rawget(t, n)
+end
+
+function global(...)
+   for _, v in ipairs{...} do mt.__declared[v] = true end
+end

data/vendor/lua/lib/lua/string_ext.lua

@@ -0,0 +1,274 @@
+--- Additions to the string module
+-- TODO: Pretty printing (use in getopt); see source for details.
+module ("string", package.seeall)
+
+
+-- Write pretty-printing based on:
+--
+--   John Hughes's and Simon Peyton Jones's Pretty Printer Combinators
+--
+--   Based on "The Design of a Pretty-printing Library in Advanced
+--   Functional Programming", Johan Jeuring and Erik Meijer (eds), LNCS 925
+--   http://www.cs.chalmers.se/~rjmh/Papers/pretty.ps
+--   Heavily modified by Simon Peyton Jones, Dec 96
+--
+--   Haskell types:
+--   data Doc     list of lines
+--   quote :: Char -> Char -> Doc -> Doc    Wrap document in ...
+--   (<>) :: Doc -> Doc -> Doc              Beside
+--   (<+>) :: Doc -> Doc -> Doc             Beside, separated by space
+--   ($$) :: Doc -> Doc -> Doc              Above; if there is no overlap it "dovetails" the two
+--   nest :: Int -> Doc -> Doc              Nested
+--   punctuate :: Doc -> [Doc] -> [Doc]     punctuate p [d1, ... dn] = [d1 <> p, d2 <> p, ... dn-1 <> p, dn]
+--   render      :: Int                     Line length
+--               -> Float                   Ribbons per line
+--               -> (TextDetails -> a -> a) What to do with text
+--               -> a                       What to do at the end
+--               -> Doc                     The document
+--               -> a                       Result
+
+
+--- Give strings a subscription operator.
+-- @param s string
+-- @param i index
+-- @return <code>string.sub (s, i, i)</code> if i is a number, or
+-- falls back to any previous metamethod (by default, string methods)
+local old__index = getmetatable ("").__index
+getmetatable ("").__index = function (s, i)
+  if type (i) == "number" then
+    return sub (s, i, i)
+    -- Fall back to old metamethods
+  elseif type (old__index) == "function" then
+    return old__index (s, i)
+  else
+    return old__index[i]
+  end
+end
+
+--- Give strings an append metamethod.
+-- @param s string
+-- @param c character (1-character string)
+-- @return <code>s .. c</code>
+getmetatable ("").__append = function (s, c)
+  return s .. c
+end
+
+--- Give strings a concat metamethod.
+-- @param s string
+-- @param o object
+-- @return s .. tostring (o)
+getmetatable ("").__concat = function (s, o)
+  return tostring (s) .. tostring (o)
+end
+
+--- Capitalise each word in a string.
+-- @param s string
+-- @return capitalised string
+function caps (s)
+  return (gsub (s, "(%w)([%w]*)",
+                function (l, ls)
+                  return upper (l) .. ls
+                end))
+end
+
+--- Remove any final newline from a string.
+-- @param s string to process
+-- @return processed string
+function chomp (s)
+  return (gsub (s, "\n$", ""))
+end
+
+--- Escape a string to be used as a pattern
+-- @param s string to process
+-- @return
+--   @param s_: processed string
+function escapePattern (s)
+  return (gsub (s, "(%W)", "%%%1"))
+end
+
+-- Escape a string to be used as a shell token.
+-- Quotes spaces, parentheses, brackets, quotes, apostrophes and
+-- whitespace.
+-- @param s string to process
+-- @return processed string
+function escapeShell (s)
+  return (gsub (s, "([ %(%)%\\%[%]\"'])", "\\%1"))
+end
+
+--- Return the English suffix for an ordinal.
+-- @param n number of the day
+-- @return suffix
+function ordinalSuffix (n)
+  n = math.mod (n, 100)
+  local d = math.mod (n, 10)
+  if d == 1 and n ~= 11 then
+    return "st"
+  elseif d == 2 and n ~= 12 then
+    return "nd"
+  elseif d == 3 and n ~= 13 then
+    return "rd"
+  else
+    return "th"
+  end
+end
+
+--- Extend to work better with one argument.
+-- If only one argument is passed, no formatting is attempted.
+-- @param f format
+-- @param ... arguments to format
+-- @return formatted string
+local _format = format
+function format (f, arg1, ...)
+  if arg1 == nil then
+    return f
+  else
+    return _format (f, arg1, ...)
+  end
+end
+
+--- Justify a string.
+-- When the string is longer than w, it is truncated (left or right
+-- according to the sign of w).
+-- @param s string to justify
+-- @param w width to justify to (-ve means right-justify; +ve means
+-- left-justify)
+-- @param p string to pad with (default: <code>" "</code>)
+-- @return justified string
+function pad (s, w, p)
+  p = rep (p or " ", math.abs (w))
+  if w < 0 then
+    return sub (p .. s, w)
+  end
+  return sub (s .. p, 1, w)
+end
+
+--- Wrap a string into a paragraph.
+-- @param s string to wrap
+-- @param w width to wrap to (default: 78)
+-- @param ind indent (default: 0)
+-- @param ind1 indent of first line (default: ind)
+-- @return wrapped paragraph
+function wrap (s, w, ind, ind1)
+  w = w or 78
+  ind = ind or 0
+  ind1 = ind1 or ind
+  assert (ind1 < w and ind < w,
+          "the indents must be less than the line width")
+  s = rep (" ", ind1) .. s
+  local lstart, len = 1, len (s)
+  while len - lstart > w - ind do
+    local i = lstart + w - ind
+    while i > lstart and sub (s, i, i) ~= " " do
+      i = i - 1
+    end
+    local j = i
+    while j > lstart and sub (s, j, j) == " " do
+      j = j - 1
+    end
+    s = sub (s, 1, j) .. "\n" .. rep (" ", ind) ..
+      sub (s, i + 1, -1)
+    local change = ind + 1 - (i - j)
+    lstart = j + change
+    len = len + change
+  end
+  return s
+end
+
+--- Write a number using SI suffixes.
+-- The number is always written to 3 s.f.
+-- @param n number
+-- @return string
+function numbertosi (n)
+  local SIprefix = {
+    [-8] = "y", [-7] = "z", [-6] = "a", [-5] = "f",
+    [-4] = "p", [-3] = "n", [-2] = "mu", [-1] = "m",
+    [0] = "", [1] = "k", [2] = "M", [3] = "G",
+    [4] = "T", [5] = "P", [6] = "E", [7] = "Z",
+    [8] = "Y"
+  }
+  local t = format("% #.2e", n)
+  local _, _, m, e = t:find(".(.%...)e(.+)")
+  local man, exp = tonumber (m), tonumber (e)
+  local siexp = math.floor (exp / 3)
+  local shift = exp - siexp * 3
+  local s = SIprefix[siexp] or "e" .. tostring (siexp)
+  man = man * (10 ^ shift)
+  return tostring (man) .. s
+end
+
+--- Do find, returning captures as a list.
+-- @param s target string
+-- @param p pattern
+-- @param init start position (default: 1)
+-- @param plain inhibit magic characters (default: nil)
+-- @return start of match, end of match, table of captures
+function tfind (s, p, init, plain)
+  local function pack (from, to, ...)
+    return from, to, {...}
+  end
+  return pack (p.find (s, p, init, plain))
+end
+
+--- Do multiple <code>find</code>s on a string.
+-- @param s target string
+-- @param p pattern
+-- @param init start position (default: 1)
+-- @param plain inhibit magic characters (default: nil)
+-- @return list of <code>{from, to; capt = {captures}}</code>
+function finds (s, p, init, plain)
+  init = init or 1
+  local l = {}
+  local from, to, r
+  repeat
+    from, to, r = tfind (s, p, init, plain)
+    if from ~= nil then
+      table.insert (l, {from, to, capt = r})
+      init = to + 1
+    end
+  until not from
+  return l
+end
+
+--- Split a string at a given separator.
+-- FIXME: Consider Perl and Python versions.
+-- @param s string to split
+-- @param sep separator regex
+-- @return list of strings
+function split (s, sep)
+  -- finds gets a list of {from, to, capt = {}} lists; we then
+  -- flatten the result, discarding the captures, and prepend 0 (1
+  -- before the first character) and append 0 (1 after the last
+  -- character), and then read off the result in pairs.
+  local pairs = list.concat ({0}, list.flatten (finds (s, sep)), {0})
+  local l = {}
+  for i = 1, #pairs, 2 do
+    table.insert (l, sub (s, pairs[i] + 1, pairs[i + 1] - 1))
+  end
+  return l
+end
+
+--- Remove leading matter from a string.
+-- @param s string
+-- @param r leading regex (default: <code>"%s+"</code>)
+-- @return string without leading r
+function ltrim (s, r)
+  r = r or "%s+"
+  return (gsub (s, "^" .. r, ""))
+end
+
+--- Remove trailing matter from a string.
+-- @param s string
+-- @param r trailing regex (default: <code>"%s+"</code>)
+-- @return string without trailing r
+function rtrim (s, r)
+  r = r or "%s+"
+  return (gsub (s, r .. "$", ""))
+end
+
+--- Remove leading and trailing matter from a string.
+-- @param s string
+-- @param r leading/trailing regex (default: <code>"%s+"</code>)
+-- @return string without leading/trailing r
+function trim (s, r)
+  return rtrim (ltrim (s, r), r)
+end